@@ -239,7 +239,6 @@ export interface ParserState {
   readonly reasoningDetails: Array<unknown>
   readonly reasoningDetailsObserved: boolean
   readonly reasoningEmitted: boolean
-  readonly latestToolIndex?: number
   readonly nextToolIndex: number
 }
 
@@ -697,7 +696,6 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
     const toolDeltas = delta?.tool_calls ?? []
     let tools = state.tools
     let pendingTools = state.pendingTools
-    let latestToolIndex = state.latestToolIndex
     let nextToolIndex = state.nextToolIndex
 
     let lifecycle = state.lifecycle
@@ -742,11 +740,15 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
       lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content)
     }
 
-    // Compatible providers may omit indexes. Prefer durable identity, then use
-    // batch position for parallel deltas or the latest call for sparse chunks.
+    // Compatible providers may omit indexes. Prefer durable identity, use batch
+    // position for parallel deltas, and only infer a singleton continuation
+    // when exactly one call is active.
     for (const [position, tool] of toolDeltas.entries()) {
       const matched = toolIndexByID(tools, pendingTools, tool.id || undefined)
-      const fallback = toolDeltas.length > 1 ? position : (latestToolIndex ?? position)
+      const active = Object.keys({ ...pendingTools, ...tools }).map(Number)
+      if ((tool.index === undefined || tool.index === null) && matched === undefined && !tool.id && active.length > 1)
+        return yield* ProviderShared.eventError(ADAPTER, "OpenAI Chat tool call delta has an ambiguous index")
+      const fallback = toolDeltas.length > 1 ? position : (active[0] ?? position)
       const fallbackTool = tools[fallback] ?? pendingTools[fallback]
       const index =
         tool.index ?? matched ??
@@ -756,7 +758,6 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
       const id = current?.id ?? pending?.id ?? (tool.id || undefined)
       const name = current?.name ?? pending?.name ?? (tool.function?.name || undefined)
       const text = `${pending?.input ?? ""}${tool.function?.arguments ?? ""}`
-      latestToolIndex = index
       nextToolIndex = Math.max(nextToolIndex, index + 1)
       if (!current && (!id || !name)) {
         pendingTools = {
@@ -804,7 +805,6 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
         reasoningDetails: state.reasoningDetails,
         reasoningDetailsObserved,
         reasoningEmitted,
-        latestToolIndex,
         nextToolIndex,
       },
       events,
 
@@ -312,7 +312,7 @@ describe("OpenAI-compatible Chat route", () => {
                   { index: null, id: "call_london", function: { name: "weather", arguments: '{"city":"' } },
                 ],
               }),
-              deltaChunk({ tool_calls: [{ function: { arguments: 'London"}' } }] }),
+              deltaChunk({ tool_calls: [{ id: "call_london", function: { arguments: 'London"}' } }] }),
               deltaChunk({ tool_calls: [{ id: "call_paris", function: { arguments: 'Paris"}' } }] }),
               deltaChunk({}, "tool_calls"),
             ),
@@ -327,6 +327,59 @@ describe("OpenAI-compatible Chat route", () => {
     }),
   )
 
+  it.effect("assembles one indexless tool call across chunks", () =>
+    Effect.gen(function* () {
+      const response = yield* LLMClient.generate(
+        LLMRequest.update(request, {
+          tools: [ToolDefinition.make({ name: "weather", description: "Get weather", inputSchema: { type: "object" } })],
+        }),
+      ).pipe(
+        Effect.provide(
+          fixedResponse(
+            sseEvents(
+              deltaChunk({
+                tool_calls: [{ id: "call_paris", function: { name: "weather", arguments: '{"city":"' } }],
+              }),
+              deltaChunk({ tool_calls: [{ function: { arguments: 'Paris"}' } }] }),
+              deltaChunk({}, "tool_calls"),
+            ),
+          ),
+        ),
+      )
+
+      expect(response.toolCalls).toMatchObject([
+        { id: "call_paris", name: "weather", input: { city: "Paris" } },
+      ])
+    }),
+  )
+
+  it.effect("rejects ambiguous indexless parallel tool deltas", () =>
+    Effect.gen(function* () {
+      const error = yield* LLMClient.generate(
+        LLMRequest.update(request, {
+          tools: [ToolDefinition.make({ name: "weather", description: "Get weather", inputSchema: { type: "object" } })],
+        }),
+      ).pipe(
+        Effect.provide(
+          fixedResponse(
+            sseEvents(
+              deltaChunk({
+                tool_calls: [
+                  { id: "call_paris", function: { name: "weather", arguments: '{"city":"' } },
+                  { id: "call_london", function: { name: "weather", arguments: '{"city":"' } },
+                ],
+              }),
+              deltaChunk({ tool_calls: [{ function: { arguments: 'Paris"}' } }] }),
+            ),
+          ),
+        ),
+        Effect.flip,
+      )
+
+      expect(error.message).toContain("OpenAI Chat tool call delta has an ambiguous index")
+    }),
+  )
+
   it.effect("treats an empty finish reason as terminal", () =>
     Effect.gen(function* () {
       const response = yield* LLMClient.generate(request).pipe(