@opencode-ai/ai 0.0.0-beta-18148 → 0.0.0-beta-18219

package/dist/image-client.d.ts

@@ -1,7 +1,7 @@
 import { Context, Effect, Layer } from "effect";
 import { RequestExecutor } from "./route/executor.js";
+import { type AIError } from "./schema/index.js";
 import type { ImageOptions, ImageRequestFor, ImageResponse } from "./image.js";
-import type { AIError } from "./schema/index.js";
 export type Execute = RequestExecutor.Interface["execute"];
 export interface Interface {
     readonly generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<ImageResponse, AIError>;

package/dist/image-client.js

@@ -1,5 +1,7 @@
 import { Context, Effect, Layer } from "effect";
 import { RequestExecutor } from "./route/executor.js";
+import { mergeHttpOptions } from "./schema/index.js";
+import { sanitizeSurrogates } from "./utils/sanitize.js";
 export class Service extends Context.Service()("@opencode/ImageClient") {
 }
 export const generate = (request) => Effect.gen(function* () {
@@ -9,7 +11,14 @@ export const generate = (request) => Effect.gen(function* () {
 export const layer = Layer.effect(Service, Effect.gen(function* () {
     const executor = yield* RequestExecutor.Service;
     return Service.of({
-        generate: (request) => request.model.route.generate(request, executor.execute),
+        generate: (request) => request.model.route.generate({
+            ...sanitizeSurrogates({
+                ...request,
+                model: undefined,
+                http: mergeHttpOptions(request.model.http, request.http),
+            }),
+            model: request.model,
+        }, executor.execute),
     });
 }));
 export const ImageClient = {

package/dist/protocols/anthropic-messages.d.ts

@@ -584,15 +584,7 @@ export declare const protocol: Protocol<{
         readonly type?: string | undefined;
         readonly message?: string | undefined;
     } | undefined;
-    readonly delta?: {
-        readonly type?: string | undefined;
-        readonly text?: string | undefined;
-        readonly thinking?: string | undefined;
-        readonly signature?: string | undefined;
-        readonly partial_json?: string | undefined;
-        readonly stop_reason?: string | null | undefined;
-        readonly stop_sequence?: string | null | undefined;
-    } | undefined;
+    readonly delta?: unknown;
     readonly index?: number | undefined;
     readonly usage?: {
         readonly [x: string]: unknown;
@@ -609,18 +601,7 @@ export declare const protocol: Protocol<{
             readonly thinking_tokens?: number | undefined;
         } | null | undefined;
     } | undefined;
-    readonly content_block?: {
-        readonly type: string;
-        readonly id?: string | undefined;
-        readonly data?: string | undefined;
-        readonly name?: string | undefined;
-        readonly input?: unknown;
-        readonly text?: string | undefined;
-        readonly content?: unknown;
-        readonly thinking?: string | undefined;
-        readonly signature?: string | undefined;
-        readonly tool_use_id?: string | undefined;
-    } | undefined;
+    readonly content_block?: unknown;
 }, {
     tools: Partial<Record<number, ToolStream.PendingTool>>;
     reasoningSignatures: {};

package/dist/protocols/anthropic-messages.js

@@ -1,5 +1,5 @@
 import { Buffer } from "node:buffer";
-import { Effect, Schema } from "effect";
+import { Effect, Option, Schema } from "effect";
 import { Tool } from "@opencode-ai/schema/tool";
 import { Route } from "../route/client.js";
 import { Auth } from "../route/auth.js";
@@ -264,6 +264,7 @@ const AnthropicStreamBlock = Schema.Struct({
     tool_use_id: Schema.optional(Schema.String),
     content: Schema.optional(Schema.Unknown),
 });
+const decodeAnthropicStreamBlock = Schema.decodeUnknownOption(AnthropicStreamBlock);
 const AnthropicStreamDelta = Schema.Struct({
     type: Schema.optional(Schema.String),
     text: Schema.optional(Schema.String),
@@ -273,12 +274,13 @@ const AnthropicStreamDelta = Schema.Struct({
     stop_reason: optionalNull(Schema.String),
     stop_sequence: optionalNull(Schema.String),
 });
+const decodeAnthropicStreamDelta = Schema.decodeUnknownOption(AnthropicStreamDelta);
 const AnthropicEvent = Schema.Struct({
     type: Schema.String,
     index: Schema.optional(Schema.Number),
     message: Schema.optional(Schema.Struct({ usage: Schema.optional(AnthropicUsage) })),
-    content_block: Schema.optional(AnthropicStreamBlock),
-    delta: Schema.optional(AnthropicStreamDelta),
+    content_block: Schema.optional(Schema.Unknown),
+    delta: Schema.optional(Schema.Unknown),
     usage: Schema.optional(AnthropicUsage),
     // `type` and `message` are both required per Anthropic's spec, but
     // OpenAI-compatible proxies and gateway translations occasionally drop one
@@ -1044,6 +1046,8 @@ const onContentBlockStart = (state, event) => {
 const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(function* (state, event) {
     const delta = event.delta;
     if (delta?.type === "text_delta" && delta.text) {
+        if (!state.lifecycle.text.has(`text-${event.index ?? 0}`))
+            return [state, NO_EVENTS];
         const events = [];
         return [
             { ...state, lifecycle: Lifecycle.textDelta(state.lifecycle, events, `text-${event.index ?? 0}`, delta.text) },
@@ -1051,6 +1055,8 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
         ];
     }
     if (delta?.type === "thinking_delta" && delta.thinking) {
+        if (!state.lifecycle.reasoning.has(`reasoning-${event.index ?? 0}`))
+            return [state, NO_EVENTS];
         const events = [];
         return [
             {
@@ -1062,6 +1068,8 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
     }
     if (delta?.type === "signature_delta" && delta.signature) {
         const index = event.index ?? 0;
+        if (!state.lifecycle.reasoning.has(`reasoning-${index}`))
+            return [state, NO_EVENTS];
         return [
             {
                 ...state,
@@ -1148,25 +1156,62 @@ const onError = (event) => Effect.fail(new AIError({
     method: "stream",
     reason: classifyProviderFailure({ message: providerErrorMessage(event), code: event.error?.type }),
 }));
+const isKnownStreamBlockType = (type) => type === "text" ||
+    type === "thinking" ||
+    type === "redacted_thinking" ||
+    type === "tool_use" ||
+    type === "server_tool_use" ||
+    isServerToolResultType(type);
+const isKnownStreamDeltaType = (type) => type === "text_delta" || type === "thinking_delta" || type === "signature_delta" || type === "input_json_delta";
+const invalidStreamEvent = (event) => Effect.fail(ProviderShared.eventError(ADAPTER, "Invalid anthropic/anthropic-messages stream event", ProviderShared.encodeJson(event)));
 const step = (state, event) => {
+    if (!SSE_EVENTS.has(event.type))
+        return Effect.succeed([state, NO_EVENTS]);
+    if (event.type !== "content_block_start" &&
+        event.content_block !== undefined &&
+        Option.isNone(decodeAnthropicStreamBlock(event.content_block)))
+        return invalidStreamEvent(event);
+    if (event.type !== "content_block_delta" &&
+        event.delta !== undefined &&
+        Option.isNone(decodeAnthropicStreamDelta(event.delta)))
+        return invalidStreamEvent(event);
     if (event.type === "message_start")
         return Effect.succeed(onMessageStart(state, event));
     if (event.type === "content_block_start") {
-        const block = event.content_block;
-        if (block && (block.type === "tool_use" || block.type === "server_tool_use")) {
+        if (!ProviderShared.isRecord(event.content_block) || typeof event.content_block.type !== "string")
+            return invalidStreamEvent(event);
+        if (!isKnownStreamBlockType(event.content_block.type))
+            return Effect.succeed([state, NO_EVENTS]);
+        const decoded = decodeAnthropicStreamBlock(event.content_block);
+        if (Option.isNone(decoded))
+            return invalidStreamEvent(event);
+        const block = decoded.value;
+        if (block.type === "tool_use" || block.type === "server_tool_use") {
             if (event.index === undefined)
                 return Effect.fail(ProviderShared.eventError(ADAPTER, `Anthropic ${block.type} missing index`));
             if (!block.id)
                 return Effect.fail(ProviderShared.eventError(ADAPTER, `Anthropic tool_use missing id at index ${event.index}`));
         }
-        return Effect.succeed(onContentBlockStart(state, event));
+        return Effect.succeed(onContentBlockStart(state, { ...event, content_block: block }));
+    }
+    if (event.type === "content_block_delta") {
+        if (!ProviderShared.isRecord(event.delta))
+            return invalidStreamEvent(event);
+        if (typeof event.delta.type === "string" && !isKnownStreamDeltaType(event.delta.type))
+            return Effect.succeed([state, NO_EVENTS]);
+        const decoded = decodeAnthropicStreamDelta(event.delta);
+        if (Option.isNone(decoded))
+            return invalidStreamEvent(event);
+        return onContentBlockDelta(state, { ...event, delta: decoded.value });
     }
-    if (event.type === "content_block_delta")
-        return onContentBlockDelta(state, event);
     if (event.type === "content_block_stop")
         return onContentBlockStop(state, event);
-    if (event.type === "message_delta")
-        return Effect.succeed(onMessageDelta(state, event));
+    if (event.type === "message_delta") {
+        const decoded = decodeAnthropicStreamDelta(event.delta);
+        if (Option.isNone(decoded))
+            return invalidStreamEvent(event);
+        return Effect.succeed(onMessageDelta(state, { ...event, delta: decoded.value }));
+    }
     if (event.type === "message_stop")
         return onMessageStop(state);
     if (event.type === "error")

package/dist/protocols/bedrock-converse.d.ts

@@ -273,6 +273,14 @@ export declare const protocol: Protocol<{
         } | undefined;
         readonly metrics?: unknown;
     } | undefined;
+    readonly exception?: {
+        readonly type: string;
+        readonly details: {
+            readonly message?: string | undefined;
+            readonly originalMessage?: string | undefined;
+            readonly originalStatusCode?: number | undefined;
+        };
+    } | undefined;
     readonly messageStart?: {
         readonly role: string;
     } | undefined;
@@ -307,31 +315,6 @@ export declare const protocol: Protocol<{
         readonly stopReason: string;
         readonly additionalModelResponseFields?: unknown;
     } | undefined;
-    readonly internalServerException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
-    readonly modelStreamErrorException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
-    readonly validationException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
-    readonly throttlingException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
-    readonly serviceUnavailableException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
 }, {
     readonly metadata?: {
         readonly usage?: {
@@ -343,6 +326,14 @@ export declare const protocol: Protocol<{
         } | undefined;
         readonly metrics?: unknown;
     } | undefined;
+    readonly exception?: {
+        readonly type: string;
+        readonly details: {
+            readonly message?: string | undefined;
+            readonly originalMessage?: string | undefined;
+            readonly originalStatusCode?: number | undefined;
+        };
+    } | undefined;
     readonly messageStart?: {
         readonly role: string;
     } | undefined;
@@ -377,31 +368,6 @@ export declare const protocol: Protocol<{
         readonly stopReason: string;
         readonly additionalModelResponseFields?: unknown;
     } | undefined;
-    readonly internalServerException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
-    readonly modelStreamErrorException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
-    readonly validationException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
-    readonly throttlingException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
-    readonly serviceUnavailableException?: {
-        readonly message?: string | undefined;
-        readonly originalMessage?: string | undefined;
-        readonly originalStatusCode?: number | undefined;
-    } | undefined;
 }, ParserState>;
 export declare const route: Route<{
     readonly messages: readonly ({

package/dist/protocols/bedrock-converse.js

@@ -149,11 +149,7 @@ const BedrockEvent = Schema.Struct({
         usage: Schema.optional(BedrockUsageSchema),
         metrics: Schema.optional(Schema.Unknown),
     })),
-    internalServerException: Schema.optional(BedrockStreamException),
-    modelStreamErrorException: Schema.optional(BedrockStreamException),
-    validationException: Schema.optional(BedrockStreamException),
-    throttlingException: Schema.optional(BedrockStreamException),
-    serviceUnavailableException: Schema.optional(BedrockStreamException),
+    exception: Schema.optional(Schema.Struct({ type: Schema.String, details: BedrockStreamException })),
 });
 // =============================================================================
 // Request Lowering
@@ -507,20 +503,13 @@ const step = (state, event) => Effect.gen(function* () {
             [],
         ];
     }
-    const exception = [
-        ["internalServerException", event.internalServerException],
-        ["modelStreamErrorException", event.modelStreamErrorException],
-        ["serviceUnavailableException", event.serviceUnavailableException],
-        ["throttlingException", event.throttlingException],
-        ["validationException", event.validationException],
-    ].find((entry) => entry[1] !== undefined);
-    if (exception) {
+    if (event.exception) {
         return yield* new AIError({
             module: ADAPTER,
             method: "stream",
             reason: classifyProviderFailure({
-                message: exception[1]?.message ?? exception[1]?.originalMessage ?? "Bedrock Converse stream error",
-                code: exception[0],
+                message: event.exception.details.message ?? event.exception.details.originalMessage ?? "Bedrock Converse stream error",
+                code: event.exception.type,
             }),
         });
     }
@@ -565,7 +554,7 @@ export const protocol = Protocol.make({
             reasoningSignatures: {},
         }),
         step,
-        onHalt,
+        onHalt: (state) => Effect.succeed(onHalt(state)),
     },
 });
 export const route = Route.make({

package/dist/protocols/bedrock-event-stream.js

@@ -56,7 +56,7 @@ const consumeFrames = (route) => (state, chunk) => Effect.gen(function* () {
         // against ad-hoc `JSON.parse` calls.
         const parsed = (yield* ProviderShared.parseJson(route, payload, "Failed to parse Bedrock Converse event-stream payload"));
         delete parsed.p;
-        out.push({ [eventType]: parsed });
+        out.push(messageType === "exception" ? { exception: { type: eventType, details: parsed } } : { [eventType]: parsed });
     }
     return [cursor, out];
 });

package/dist/protocols/gemini.js

@@ -574,7 +574,7 @@ export const protocol = Protocol.make({
             lifecycle: Lifecycle.initial(),
         }),
         step,
-        onHalt: finish,
+        onHalt: (state) => Effect.succeed(finish(state)),
     },
 });
 export const route = Route.make({

package/dist/protocols/open-responses-continuation.js

@@ -133,7 +133,12 @@ export const driver = (input) => {
                 ...observation,
                 checkpoint: {
                     protocol: PROTOCOL,
-                    value: { version: VERSION, responseID, request, output: output.slice() },
+                    value: {
+                        version: VERSION,
+                        responseID,
+                        request,
+                        output: event.response?.output ? [...event.response.output] : output.slice(),
+                    },
                 },
             };
         }),

package/dist/protocols/open-responses.d.ts

@@ -384,8 +384,10 @@ export declare const decodeKnownErrorEvent: (event: Event) => Effect.Effect<{
 export declare const Event: Schema.StructWithRest<Schema.Struct<{
     readonly type: Schema.String;
     readonly delta: Schema.optional<Schema.String>;
+    readonly arguments: Schema.optional<Schema.String>;
     readonly text: Schema.optional<Schema.String>;
     readonly item_id: Schema.optional<Schema.String>;
+    readonly output_index: Schema.optional<Schema.Number>;
     readonly summary_index: Schema.optional<Schema.Number>;
     readonly item: Schema.optional<Schema.StructWithRest<Schema.Struct<{
         readonly type: Schema.String;
@@ -401,6 +403,14 @@ export declare const Event: Schema.StructWithRest<Schema.Struct<{
         readonly incomplete_details: Schema.optional<Schema.NullOr<Schema.Struct<{
             readonly reason: Schema.optional<Schema.String>;
         }>>>;
+        readonly output: Schema.optional<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+            readonly type: Schema.String;
+            readonly id: Schema.optional<Schema.String>;
+            readonly call_id: Schema.optional<Schema.String>;
+            readonly name: Schema.optional<Schema.String>;
+            readonly arguments: Schema.optional<Schema.String>;
+            readonly encrypted_content: Schema.optional<Schema.NullOr<Schema.String>>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
         readonly usage: Schema.optional<Schema.NullOr<Schema.Struct<{
             readonly input_tokens: Schema.optional<Schema.Number>;
             readonly input_tokens_details: Schema.optional<Schema.NullOr<Schema.Struct<{
@@ -452,6 +462,7 @@ export interface ParserState {
     readonly tools: ToolStream.State<string>;
     readonly hasFunctionCall: boolean;
     readonly lifecycle: Lifecycle.State;
+    readonly outputItems: Readonly<Record<number, string>>;
     readonly messageItems: ReadonlySet<string>;
     readonly messagePhases: Readonly<Record<string, MessagePhase | null>>;
     readonly reasoningItems: Readonly<Record<string, ReasoningStreamItem>>;
@@ -652,10 +663,11 @@ export declare const fromRequest: (request: LLMRequest) => Effect.Effect<{
 export declare const providerMetadata: (state: ParserState, metadata: Record<string, unknown>) => ProviderMetadata;
 export type StepResult = readonly [ParserState, ReadonlyArray<LLMEvent>];
 export declare const terminal: (event: Event) => boolean;
+export declare const outputItemID: (state: ParserState, event: Event) => string | undefined;
 export declare const onReasoningDelta: (state: ParserState, event: Event, itemID: string) => StepResult;
 export declare const onReasoningDone: (state: ParserState, event: Event, itemID: string) => StepResult;
 export declare const providerFailure: (id: string, event: Event, fallback: string) => AIError;
-export declare const step: (state: ParserState, event: Event) => AIError | Effect.Effect<StepResult, never, never> | Effect.Effect<[ParserState, readonly ({
+export declare const step: (state: ParserState, input: Event) => AIError | Effect.Effect<[ParserState, readonly ({
     readonly type: "step-start";
     readonly index: number;
 } | {
@@ -837,7 +849,7 @@ export declare const step: (state: ParserState, event: Event) => AIError | Effec
         };
     } | undefined;
     readonly classification?: "context-overflow" | "payload-too-large" | undefined;
-})[]], AIError, never>;
+})[]], AIError, never> | Effect.Effect<StepResult, never, never>;
 /**
  * The provider-neutral Open Responses protocol. Provider-specific Responses
  * implementations compose this baseline with their own tools and event variants.
@@ -986,6 +998,15 @@ export declare const protocol: Protocol<{
     readonly response?: {
         readonly [x: string]: unknown;
         readonly id?: string | undefined;
+        readonly output?: readonly {
+            readonly [x: string]: unknown;
+            readonly type: string;
+            readonly id?: string | undefined;
+            readonly name?: string | undefined;
+            readonly arguments?: string | undefined;
+            readonly encrypted_content?: string | null | undefined;
+            readonly call_id?: string | undefined;
+        }[] | undefined;
         readonly error?: {
             readonly type?: string | null | undefined;
             readonly code?: string | null | undefined;
@@ -1009,9 +1030,11 @@ export declare const protocol: Protocol<{
             readonly reason?: string | undefined;
         } | null | undefined;
     } | undefined;
+    readonly arguments?: string | undefined;
     readonly param?: string | null | undefined;
     readonly status_code?: unknown;
     readonly item_id?: string | undefined;
+    readonly output_index?: number | undefined;
     readonly summary_index?: number | undefined;
 }, ParserState>;
 export declare const httpTransport: HttpTransport.HttpJsonTransport<{

package/dist/protocols/open-responses.js

@@ -204,14 +204,17 @@ export const decodeKnownErrorEvent = (event) => decodeWebSocketErrorEvent({
 export const Event = Schema.StructWithRest(Schema.Struct({
     type: Schema.String,
     delta: Schema.optional(Schema.String),
+    arguments: Schema.optional(Schema.String),
     text: Schema.optional(Schema.String),
     item_id: Schema.optional(Schema.String),
+    output_index: Schema.optional(Schema.Number),
     summary_index: Schema.optional(Schema.Number),
     item: Schema.optional(StreamItem),
     response: Schema.optional(Schema.StructWithRest(Schema.Struct({
         id: Schema.optional(Schema.String),
         service_tier: optionalNull(Schema.String),
         incomplete_details: optionalNull(Schema.Struct({ reason: Schema.optional(Schema.String) })),
+        output: Schema.optional(Schema.Array(StreamItem)),
         usage: optionalNull(OpenResponsesUsage),
         error: optionalNull(OpenResponsesErrorPayload),
     }), [Schema.Record(Schema.String, Schema.Unknown)])),
@@ -461,16 +464,11 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
             });
         }
     }
-    // With store:false, Responses APIs only accept previous reasoning items when the
-    // complete item has encrypted state. Summary blocks for one item may carry
-    // that state only on the last block, so filter after they have been joined.
-    return store === false
-        ? input.filter((item) => !("type" in item) || item.type !== "reasoning" || typeof item.encrypted_content === "string")
-        : input;
+    return input;
 });
 const lowerOptions = (request) => {
     const options = OpenResponsesOptions.resolve(request);
-    const cacheKey = ProviderShared.clampPromptCacheKey(request.promptCacheKey);
+    const cacheKey = ProviderShared.promptCacheKey(request);
     const parallelToolCalls = resolveParallelToolCalls(request);
     return {
         ...(options.instructions ? { instructions: options.instructions } : {}),
@@ -602,6 +600,7 @@ const onOutputTextDone = (state, event, id) => {
     const events = [];
     return [{ ...state, lifecycle: Lifecycle.textEnd(state.lifecycle, events, id) }, events];
 };
+export const outputItemID = (state, event) => event.output_index === undefined ? event.item_id : (state.outputItems[event.output_index] ?? event.item_id);
 export const onReasoningDelta = (state, event, itemID) => {
     const item = state.reasoningItems[itemID];
     if (!event.delta || !item)
@@ -756,9 +755,23 @@ const onReasoningSummaryPartDone = (state, event) => {
     ];
 };
 const onFunctionCallArgumentsDelta = Effect.fn("OpenResponses.onFunctionCallArgumentsDelta")(function* (state, event) {
-    if (!event.item_id || !event.delta || !state.tools[event.item_id])
+    if (!event.item_id)
+        return [state, NO_EVENTS];
+    const tool = state.tools[event.item_id];
+    if (!tool)
         return [state, NO_EVENTS];
-    const result = ToolStream.appendExisting(state.id, state.tools, event.item_id, event.delta, `${state.name} tool argument delta is missing its tool call`);
+    const final = event.type === "response.function_call_arguments.done" ? event.arguments : undefined;
+    if (event.type === "response.function_call_arguments.done" && final === undefined)
+        return [state, NO_EVENTS];
+    if (final !== undefined && !final.startsWith(tool.input))
+        return [
+            { ...state, tools: ToolStream.start(state.tools, event.item_id, { ...tool, input: final }) },
+            NO_EVENTS,
+        ];
+    const delta = final === undefined ? event.delta : final.slice(tool.input.length);
+    if (!delta)
+        return [state, NO_EVENTS];
+    const result = ToolStream.appendExisting(state.id, state.tools, event.item_id, delta, `${state.name} tool argument delta is missing its tool call`);
     if (ToolStream.isError(result))
         return yield* result;
     const events = [];
@@ -840,27 +853,37 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
     return [state, NO_EVENTS];
 });
 const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (state, event) {
+    const reconciled = event.type === "response.completed"
+        ? yield* Effect.reduce(event.response?.output ?? [], () => [state, NO_EVENTS], ([current, events], item) => {
+            if (!item.id ||
+                ((item.type !== "function_call" || !current.tools[item.id]) &&
+                    (item.type !== "reasoning" || !current.reasoningItems[item.id])))
+                return Effect.succeed([current, events]);
+            return onOutputItemDone(current, { type: "response.output_item.done", item }).pipe(Effect.map(([next, emitted]) => [next, [...events, ...emitted]]));
+        })
+        : [state, NO_EVENTS];
+    const current = reconciled[0];
     // Some compatible providers omit output_item.done even after completing the response.
     const pending = event.type === "response.completed"
-        ? yield* ToolStream.finishAll(state.id, state.tools)
-        : { tools: state.tools, events: NO_EVENTS };
-    const events = [...pending.events];
+        ? yield* ToolStream.finishAll(current.id, current.tools)
+        : { tools: current.tools, events: NO_EVENTS };
+    const events = [...reconciled[1], ...pending.events];
     const hasFunctionCall = pending.events.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
-        state.hasFunctionCall;
-    const lifecycle = Lifecycle.finish(state.lifecycle, events, {
+        current.hasFunctionCall;
+    const lifecycle = Lifecycle.finish(current.lifecycle, events, {
         reason: {
             normalized: mapFinishReason(event, hasFunctionCall),
             raw: event.response?.incomplete_details?.reason,
         },
-        usage: mapUsage(event.response?.usage, state.providerMetadataKey),
+        usage: mapUsage(event.response?.usage, current.providerMetadataKey),
         providerMetadata: event.response?.id || event.response?.service_tier
-            ? providerMetadata(state, {
+            ? providerMetadata(current, {
                 responseId: event.response.id,
                 serviceTier: event.response.service_tier,
             })
             : undefined,
     });
-    return [{ ...state, lifecycle, hasFunctionCall, tools: pending.tools }, events];
+    return [{ ...current, lifecycle, hasFunctionCall, tools: pending.tools }, events];
 });
 // Build the prettiest summary available from whatever the provider supplied.
 // When both code and message are present, prefix the code so consumers see
@@ -902,7 +925,10 @@ export const providerFailure = (id, event, fallback) => {
     });
 };
 const providerError = (state, event, fallback) => providerFailure(state.id, event, fallback);
-export const step = (state, event) => {
+export const step = (state, input) => {
+    const event = input.item_id && outputItemID(state, input) !== input.item_id
+        ? { ...input, item_id: outputItemID(state, input) }
+        : input;
     if (event.type === "response.output_text.delta" || event.type === "response.output_text.done") {
         if (!event.item_id)
             return ProviderShared.eventError(state.id, `${event.type} is missing item_id`);
@@ -941,9 +967,11 @@ export const step = (state, event) => {
     if (event.type === "response.output_item.added") {
         if (event.item?.type === "message" && !event.item.id)
             return ProviderShared.eventError(state.id, `${event.type} message is missing id`);
-        return Effect.succeed(onOutputItemAdded(state, event));
+        return Effect.succeed(onOutputItemAdded(event.output_index !== undefined && event.item?.id
+            ? { ...state, outputItems: { ...state.outputItems, [event.output_index]: event.item.id } }
+            : state, event));
     }
-    if (event.type === "response.function_call_arguments.delta")
+    if (event.type === "response.function_call_arguments.delta" || event.type === "response.function_call_arguments.done")
         return event.item_id
             ? onFunctionCallArgumentsDelta(state, event)
             : ProviderShared.eventError(state.id, `${event.type} is missing item_id`);
@@ -974,6 +1002,7 @@ export const initial = (request, extension = BASE) => ({
     hasFunctionCall: false,
     tools: ToolStream.empty(),
     lifecycle: Lifecycle.initial(),
+    outputItems: {},
     messageItems: new Set(),
     messagePhases: {},
     reasoningItems: {},

package/dist/protocols/openai-chat.d.ts

@@ -204,7 +204,7 @@ declare const OpenAIChatBody: Schema.Struct<{
     stop: Schema.optional<Schema.$Array<Schema.String>>;
 }>;
 export type OpenAIChatBody = Schema.Schema.Type<typeof OpenAIChatBody>;
-export declare const OpenAIChatEvent: Schema.Struct<{
+export declare const OpenAIChatEvent: Schema.StructWithRest<Schema.Struct<{
     readonly choices: Schema.optional<Schema.NullOr<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
         readonly delta: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
             readonly content: Schema.optional<Schema.NullOr<Schema.String>>;
@@ -257,11 +257,11 @@ export declare const OpenAIChatEvent: Schema.Struct<{
             readonly rejected_prediction_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
         }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
     }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
-    readonly error: Schema.optional<Schema.NullOr<Schema.Struct<{
+    readonly error: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
         readonly code: Schema.optional<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.Number]>>>;
         readonly message: Schema.String;
-    }>>>;
-}>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
 export type OpenAIChatEvent = Schema.Schema.Type<typeof OpenAIChatEvent>;
 interface PendingToolDelta {
     readonly id?: string;
@@ -281,6 +281,7 @@ export interface ParserState {
     readonly reasoningEmitted: boolean;
     readonly latestToolIndex?: number;
     readonly nextToolIndex: number;
+    readonly requireFinishReason: boolean;
 }
 interface LoweringOptions {
     readonly cacheControl?: (cache: CacheHint | undefined) => Schema.Schema.Type<typeof OpenAIChatCacheControl> | undefined;
@@ -585,7 +586,9 @@ export declare const protocol: Protocol<{
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
 }, string, {
+    readonly [x: string]: unknown;
     readonly error?: {
+        readonly [x: string]: unknown;
         readonly message: string;
         readonly code?: string | number | null | undefined;
     } | null | undefined;