@@ -656,15 +656,11 @@ const step = Effect.fn("MistralChat.step")(function* (state: ParserState, event:
   }
   const events: LLMEvent[] = []
   const usage = mapUsage(event.usage) ?? state.usage
-  if (state.finishReason) {
-    if (hasLateContent(event))
-      return yield* ProviderShared.eventError(
-        ADAPTER,
-        "Mistral Chat received content after the finish reason",
-        ProviderShared.encodeJson(event),
-      )
-    return [{ ...state, usage }, events] as const
-  }
+  // Trailing deltas after a terminal `finish_reason` are real model output:
+  // absorb them into the stream instead of failing the response. The single
+  // terminal finish event is emitted once at stream end, so late content still
+  // precedes it.
+  if (state.finishReason && !hasLateContent(event)) return [{ ...state, usage }, events] as const
   const choice = event.choices?.[0]
   const withContent = choice?.delta?.content == null ? state : appendContent(state, events, choice.delta.content)
   const withTools = yield* appendTools(withContent, events, choice?.delta?.tool_calls ?? [])
@@ -685,7 +681,10 @@ const step = Effect.fn("MistralChat.step")(function* (state: ParserState, event:
     })
   }
   const incomplete = finishReason.normalized === "length" || finishReason.normalized === "content-filter"
-  if (!incomplete && Object.keys(withTools.pendingTools).length > 0)
+  // Only the first terminal arrival rejects unidentifiable tool deltas; late
+  // frames after a finish absorb malformed tool identities silently instead of
+  // failing the response.
+  if (state.finishReason === undefined && !incomplete && Object.keys(withTools.pendingTools).length > 0)
     return yield* ProviderShared.eventError(
       ADAPTER,
       "Mistral Chat tool call delta is missing a name",
@@ -699,7 +698,7 @@ const step = Effect.fn("MistralChat.step")(function* (state: ParserState, event:
     {
       ...withTools,
       tools: finished?.tools ?? withTools.tools,
-      completedTools: finished?.events ?? withTools.completedTools,
+      completedTools: finished ? [...withTools.completedTools, ...finished.events] : withTools.completedTools,
       usage,
       finishReason,
     },
 
@@ -988,15 +988,12 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
       reasoning !== undefined ||
       (Array.isArray(delta?.reasoning_details) && delta.reasoning_details.length > 0) ||
       toolDeltas.some((tool) => Boolean(tool.id) || Boolean(tool.function?.name) || Boolean(tool.function?.arguments))
-    if (state.finishReason !== undefined) {
-      if (hasLateContent)
-        return yield* ProviderShared.eventError(
-          ADAPTER,
-          "OpenAI Chat received content after the finish reason",
-          ProviderShared.encodeJson(event),
-        )
-      return [{ ...state, usage }, events] as const
-    }
+    // Trailing deltas after a terminal `finish_reason` are real model output:
+    // some OpenAI-compatible providers emit a last content or reasoning chunk
+    // after the finish chunk. Absorb them into the stream instead of failing
+    // the response; the single terminal finish event is emitted once at stream
+    // end, so late content still precedes it.
+    if (state.finishReason !== undefined && !hasLateContent) return [{ ...state, usage }, events] as const
 
     const reasoningField = state.reasoningField ?? reasoning?.field
     const detailDelta = Array.isArray(delta?.reasoning_details) ? delta.reasoning_details : undefined
@@ -1081,11 +1078,9 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
       )
 
     // Filtering or truncation terminates the response without confirming pending tool calls.
+    // Late frames after a complete finish finalize newly absorbed tool calls here too.
     const finished =
-      finishReason !== undefined &&
-      !incompleteTools &&
-      state.finishReason === undefined &&
-      Object.keys(tools).length > 0
+      finishReason !== undefined && !incompleteTools && Object.keys(tools).length > 0
         ? yield* ToolStream.finishAll(ADAPTER, tools)
         : undefined
 
@@ -1094,7 +1089,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
         providerMetadataKey: state.providerMetadataKey,
         tools: finished?.tools ?? tools,
         pendingTools,
-        toolCallEvents: finished?.events ?? state.toolCallEvents,
+        toolCallEvents: finished ? [...state.toolCallEvents, ...finished.events] : state.toolCallEvents,
         usage,
         finishReason,
         lifecycle,
 
@@ -673,9 +673,8 @@ describe("Mistral Chat", () => {
         Effect.provide(
           fixedResponse(sseEvents(chunk({}, "stop"), chunk({ content: [{ type: "text", text: "late" }] }))),
         ),
-        Effect.flip,
       )
-      expect(lateContent.message).toContain("content after the finish reason")
+      expect(lateContent.text).toBe("late")
     }),
   )
 
 
@@ -561,9 +561,23 @@ describe("OpenAI-compatible Chat route", () => {
     }),
   )
 
-  it.effect("rejects content after a terminal chunk", () =>
+  it.effect("absorbs content after a terminal chunk", () =>
     Effect.gen(function* () {
-      const error = yield* LLMClient.generate(request).pipe(
+      const response = yield* LLMClient.generate(request).pipe(
+        Effect.provide(
+          fixedResponse(
+            sseEvents(deltaChunk({ content: "Hello" }), deltaChunk({}, "stop"), deltaChunk({ content: " late" })),
+          ),
+        ),
+      )
+
+      expect(response.text).toBe("Hello late")
+    }),
+  )
+
+  it.effect("finishes a tool call absorbed after a terminal chunk", () =>
+    Effect.gen(function* () {
+      const response = yield* LLMClient.generate(request).pipe(
         Effect.provide(
           fixedResponse(
             sseEvents(
@@ -573,15 +587,28 @@ describe("OpenAI-compatible Chat route", () => {
             ),
           ),
         ),
-        Effect.flip,
       )
 
-      expect(error.message).toContain("OpenAI Chat received content after the finish reason")
-      expect(error.reason._tag).toBe("InvalidProviderOutput")
-      if (error.reason._tag !== "InvalidProviderOutput") return
-      expect(decodeJson(error.reason.body ?? "")).toMatchObject({
-        choices: [{ delta: { tool_calls: [{ id: "call_1" }] } }],
-      })
+      expect(response.toolCalls).toMatchObject([{ id: "call_1", name: "lookup", input: {} }])
+    }),
+  )
+
+  it.effect("still drops unconfirmed tool calls after a content-filter finish", () =>
+    Effect.gen(function* () {
+      const response = yield* LLMClient.generate(request).pipe(
+        Effect.provide(
+          fixedResponse(
+            sseEvents(
+              deltaChunk({ tool_calls: [{ index: 0, id: "call_1", function: { name: "lookup", arguments: "{}" } }] }),
+              deltaChunk({}, "content_filter"),
+              deltaChunk({ tool_calls: [{ index: 1, id: "call_2", function: { name: "lookup", arguments: "{}" } }] }),
+            ),
+          ),
+        ),
+      )
+
+      expect(response.toolCalls).toEqual([])
+      expect(response.finishReason).toEqual({ normalized: "content-filter", raw: "content_filter" })
     }),
   )
 })
Original file line number	Diff line number	Diff line change
`@@ -673,9 +673,8 @@ describe("Mistral Chat", () => {`
`673`	`673`	`Effect.provide(`
`674`	`674`	`fixedResponse(sseEvents(chunk({}, "stop"), chunk({ content: [{ type: "text", text: "late" }] }))),`
`675`	`675`	`),`
`676`		`- Effect.flip,`
`677`	`676`	`)`
`678`		`- expect(lateContent.message).toContain("content after the finish reason")`
	`677`	`+ expect(lateContent.text).toBe("late")`
`679`	`678`	`}),`
`680`	`679`	`)`
`681`	`680`