@opencode-ai/ai 0.0.0-next-16211 → 0.0.0-next-16214

package/dist/protocols/open-responses.js

@@ -35,6 +35,7 @@ const OpenResponsesOutputText = Schema.Struct({
     type: Schema.tag("output_text"),
     text: Schema.String,
 });
+export const MessagePhase = Schema.Literals(["commentary", "final_answer"]);
 const OpenResponsesReasoningSummaryText = Schema.Struct({
     type: Schema.tag("summary_text"),
     text: Schema.String,
@@ -61,10 +62,14 @@ const OpenResponsesFunctionCallOutput = Schema.Union([
     Schema.String,
     Schema.Array(OpenResponsesFunctionCallOutputContent),
 ]);
-const OpenResponsesInputItem = Schema.Union([
+export const InputItem = Schema.Union([
     Schema.Struct({ role: Schema.tag("system"), content: Schema.String }),
     Schema.Struct({ role: Schema.tag("user"), content: Schema.Array(OpenResponsesInputContent) }),
-    Schema.Struct({ role: Schema.tag("assistant"), content: Schema.Array(OpenResponsesOutputText) }),
+    Schema.Struct({
+        role: Schema.tag("assistant"),
+        content: Schema.Array(OpenResponsesOutputText),
+        phase: Schema.optionalKey(MessagePhase),
+    }),
     OpenResponsesReasoningItem,
     OpenResponsesItemReference,
     Schema.Struct({
@@ -96,7 +101,7 @@ export const ToolChoice = Schema.Union([
 // transports in sync without a destructure-and-strip dance.
 export const coreFields = {
     model: Schema.String,
-    input: Schema.Array(OpenResponsesInputItem),
+    input: Schema.Array(InputItem),
     instructions: Schema.optional(Schema.String),
     tools: optionalArray(Tool),
     tool_choice: Schema.optional(ToolChoice),
@@ -149,6 +154,7 @@ const OpenResponsesErrorPayload = Schema.Struct({
 export const Event = Schema.StructWithRest(Schema.Struct({
     type: Schema.String,
     delta: Schema.optional(Schema.String),
+    text: Schema.optional(Schema.String),
     item_id: Schema.optional(Schema.String),
     summary_index: Schema.optional(Schema.Number),
     item: Schema.optional(StreamItem),
@@ -282,7 +288,23 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
             const flushText = () => {
                 if (content.length === 0)
                     return;
-                input.push({ role: "assistant", content: content.map((part) => ({ type: "output_text", text: part.text })) });
+                const groups = content.reduce((groups, part) => {
+                    const metadata = part.providerMetadata?.[providerMetadataKey];
+                    const phase = ProviderShared.isRecord(metadata)
+                        ? messagePhase(metadata.phase, extension)
+                        : undefined;
+                    const group = groups.at(-1);
+                    if (group && group.phase === phase)
+                        group.parts.push(part);
+                    else
+                        groups.push({ phase, parts: [part] });
+                    return groups;
+                }, []);
+                input.push(...groups.map((group) => ({
+                    role: "assistant",
+                    content: group.parts.map((part) => ({ type: "output_text", text: part.text })),
+                    ...(group.phase === undefined ? {} : { phase: group.phase }),
+                })));
                 content.splice(0, content.length);
             };
             for (const part of message.content) {
@@ -381,7 +403,7 @@ const lowerOptions = (request) => {
         ...(options.serviceTier ? { service_tier: options.serviceTier } : {}),
     };
 };
-export const fromRequest = Effect.fn("OpenResponses.fromRequest")(function* (request, extension = BASE) {
+export const fromRequestWithExtension = Effect.fn("OpenResponses.fromRequestWithExtension")(function* (request, extension) {
     const generation = request.generation;
     const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
     return {
@@ -398,6 +420,10 @@ export const fromRequest = Effect.fn("OpenResponses.fromRequest")(function* (req
         ...lowerOptions(request),
     };
 });
+const decodeBody = ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenResponsesBody));
+export const fromRequest = Effect.fn("OpenResponses.fromRequest")(function* (request) {
+    return yield* decodeBody(yield* fromRequestWithExtension(request, BASE));
+});
 // =============================================================================
 // Stream Parsing
 // =============================================================================
@@ -448,24 +474,31 @@ const NO_EVENTS = [];
 // so keep this set aligned with `step` and the protocol's terminal predicate.
 const TERMINAL_TYPES = new Set(["response.completed", "response.incomplete", "response.failed"]);
 export const terminal = (event) => TERMINAL_TYPES.has(event.type);
-const onOutputTextDelta = (state, event) => {
+const onOutputTextDelta = (state, event, id) => {
     if (!event.delta)
         return [state, NO_EVENTS];
     const events = [];
+    const phase = state.messagePhases[id];
+    const metadata = phase === undefined ? undefined : providerMetadata(state, { phase });
+    const lifecycle = Lifecycle.textStart(state.lifecycle, events, id, metadata);
     return [
-        { ...state, lifecycle: Lifecycle.textDelta(state.lifecycle, events, event.item_id ?? "text-0", event.delta) },
+        { ...state, lifecycle: Lifecycle.textDelta(lifecycle, events, id, event.delta) },
         events,
     ];
 };
-const onOutputTextDone = (state, event) => {
+const onOutputTextDone = (state, event, id) => {
+    if (state.messageItems.has(id)) {
+        if (state.lifecycle.text.has(id) || event.text === undefined)
+            return [state, NO_EVENTS];
+        return onOutputTextDelta(state, { ...event, delta: event.text }, id);
+    }
     const events = [];
-    return [{ ...state, lifecycle: Lifecycle.textEnd(state.lifecycle, events, event.item_id ?? "text-0") }, events];
+    return [{ ...state, lifecycle: Lifecycle.textEnd(state.lifecycle, events, id) }, events];
 };
-export const onReasoningDelta = (state, event) => {
+export const onReasoningDelta = (state, event, itemID) => {
     if (!event.delta)
         return [state, NO_EVENTS];
     const events = [];
-    const itemID = event.item_id ?? "reasoning-0";
     const id = event.summary_index !== undefined || state.reasoningItems[itemID] ? `${itemID}:${event.summary_index ?? 0}` : itemID;
     return [
         {
@@ -491,6 +524,18 @@ const reasoningMetadata = (state, item) => providerMetadata(state, { itemId: ite
 // best-effort, not guaranteed.
 const onOutputItemAdded = (state, event) => {
     const item = event.item;
+    if (item?.type === "message" && item.id)
+        return [
+            {
+                ...state,
+                messageItems: new Set([...state.messageItems, item.id]),
+                messagePhases: (() => {
+                    const phase = state.messagePhase(item.phase);
+                    return phase === undefined ? state.messagePhases : { ...state.messagePhases, [item.id]: phase };
+                })(),
+            },
+            NO_EVENTS,
+        ];
     if (item && isReasoningItem(item)) {
         const events = [];
         return [
@@ -611,8 +656,23 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
     const item = event.item;
     if (!item)
         return [state, NO_EVENTS];
-    if (item.type === "message" && item.id)
-        return onOutputTextDone(state, { ...event, item_id: item.id });
+    if (item.type === "message" && item.id) {
+        const itemPhase = state.messagePhase(item.phase);
+        const phase = itemPhase === undefined ? state.messagePhases[item.id] : itemPhase;
+        const events = [];
+        const messageItems = new Set(state.messageItems);
+        messageItems.delete(item.id);
+        const { [item.id]: _phase, ...messagePhases } = state.messagePhases;
+        return [
+            {
+                ...state,
+                lifecycle: Lifecycle.textEnd(state.lifecycle, events, item.id, phase === undefined ? undefined : providerMetadata(state, { phase })),
+                messageItems,
+                messagePhases,
+            },
+            events,
+        ];
+    }
     if (item.type === "function_call") {
         if (!item.id || !item.call_id || !item.name)
             return [state, NO_EVENTS];
@@ -701,24 +761,43 @@ const providerError = (state, event, fallback) => {
     });
 };
 export const step = (state, event) => {
-    if (event.type === "response.output_text.delta")
-        return Effect.succeed(onOutputTextDelta(state, event));
-    if (event.type === "response.output_text.done")
-        return Effect.succeed(onOutputTextDone(state, event));
-    if (event.type === "response.reasoning.delta" || event.type === "response.reasoning_summary_text.delta")
-        return Effect.succeed(onReasoningDelta(state, event));
-    if (event.type === "response.reasoning.done" || event.type === "response.reasoning_summary_text.done")
+    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`);
+        return Effect.succeed(event.type === "response.output_text.delta"
+            ? onOutputTextDelta(state, event, event.item_id)
+            : onOutputTextDone(state, event, event.item_id));
+    }
+    if (event.type === "response.reasoning.delta" || event.type === "response.reasoning_summary_text.delta") {
+        if (!event.item_id)
+            return ProviderShared.eventError(state.id, `${event.type} is missing item_id`);
+        return Effect.succeed(onReasoningDelta(state, event, event.item_id));
+    }
+    if (event.type === "response.reasoning.done" || event.type === "response.reasoning_summary_text.done") {
+        if (!event.item_id)
+            return ProviderShared.eventError(state.id, `${event.type} is missing item_id`);
         return Effect.succeed(onReasoningDone(state, event));
+    }
     if (event.type === "response.reasoning_summary_part.added")
-        return Effect.succeed(onReasoningSummaryPartAdded(state, event));
+        return event.item_id
+            ? Effect.succeed(onReasoningSummaryPartAdded(state, event))
+            : ProviderShared.eventError(state.id, `${event.type} is missing item_id`);
     if (event.type === "response.reasoning_summary_part.done")
-        return Effect.succeed(onReasoningSummaryPartDone(state, event));
-    if (event.type === "response.output_item.added")
+        return event.item_id
+            ? Effect.succeed(onReasoningSummaryPartDone(state, event))
+            : ProviderShared.eventError(state.id, `${event.type} is missing item_id`);
+    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));
+    }
     if (event.type === "response.function_call_arguments.delta")
         return onFunctionCallArgumentsDelta(state, event);
-    if (event.type === "response.output_item.done")
+    if (event.type === "response.output_item.done") {
+        if (event.item?.type === "message" && !event.item.id)
+            return ProviderShared.eventError(state.id, `${event.type} message is missing id`);
         return onOutputItemDone(state, event);
+    }
     if (event.type === "response.completed" || event.type === "response.incomplete")
         return Effect.succeed(onResponseFinish(state, event));
     if (event.type === "response.failed")
@@ -741,9 +820,17 @@ export const initial = (request, extension = BASE) => ({
     hasFunctionCall: false,
     tools: ToolStream.empty(),
     lifecycle: Lifecycle.initial(),
+    messageItems: new Set(),
+    messagePhase: (value) => messagePhase(value, extension),
+    messagePhases: {},
     reasoningItems: {},
     store: OpenResponsesOptions.resolve(request).store,
 });
+const messagePhase = (value, extension) => {
+    if (value === "commentary" || value === "final_answer")
+        return value;
+    return extension.messagePhase?.(value);
+};
 export const protocol = Protocol.make({
     id: ADAPTER,
     body: {

package/dist/protocols/openai-compatible-responses.d.ts

@@ -34,13 +34,14 @@ export declare const route: Route<{
             readonly file_data: import("effect/Schema").String;
             readonly mime_type: import("effect/Schema").optional<import("effect/Schema").String>;
         }>]>]>>;
-    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
-        readonly role: import("effect/Schema").tag<"assistant">;
-        readonly content: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+    }, "Type"> | {
+        readonly content: readonly import("effect/Schema").Struct.ReadonlySide<{
             readonly type: import("effect/Schema").tag<"output_text">;
             readonly text: import("effect/Schema").String;
-        }>>;
-    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+        }, "Type">[];
+        readonly role: "assistant";
+        readonly phase?: "commentary" | "final_answer" | undefined;
+    } | import("effect/Schema").Struct.ReadonlySide<{
         readonly type: import("effect/Schema").tag<"function_call">;
         readonly call_id: import("effect/Schema").String;
         readonly name: import("effect/Schema").String;

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

@@ -7,31 +7,14 @@ export declare const DEFAULT_BASE_URL = "https://api.openai.com/v1";
 export declare const PATH = "/responses";
 declare const OpenAIResponsesBody: Schema.Struct<{
     readonly stream: Schema.Literal<true>;
-    readonly tools: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-        readonly type: Schema.tag<"function">;
-        readonly name: Schema.String;
-        readonly description: Schema.String;
-        readonly parameters: Schema.$Record<Schema.String, Schema.Unknown>;
-        readonly strict: Schema.optional<Schema.Boolean>;
-    }>, Schema.Struct<{
-        readonly type: Schema.tag<"image_generation">;
-        readonly action: Schema.optional<Schema.Literals<readonly ["auto", "generate", "edit"]>>;
-        readonly background: Schema.optional<Schema.Literals<readonly ["auto", "opaque", "transparent"]>>;
-        readonly input_fidelity: Schema.optional<Schema.Literals<readonly ["low", "high"]>>;
-        readonly output_compression: Schema.optional<Schema.Int>;
-        readonly output_format: Schema.optional<Schema.Literals<readonly ["png", "jpeg", "webp"]>>;
-        readonly partial_images: Schema.optional<Schema.Int>;
-        readonly quality: Schema.optional<Schema.Literals<readonly ["auto", "low", "medium", "high"]>>;
-        readonly size: Schema.optional<Schema.String>;
-    }>]>>>;
-    readonly tool_choice: Schema.optional<Schema.Union<readonly [Schema.Union<readonly [Schema.Literals<readonly ["auto", "none", "required"]>, Schema.Struct<{
-        readonly type: Schema.tag<"function">;
-        readonly name: Schema.String;
-    }>]>, Schema.Struct<{
-        readonly type: Schema.tag<"image_generation">;
-    }>]>>;
-    readonly model: Schema.String;
     readonly input: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly role: Schema.tag<"assistant">;
+        readonly content: Schema.$Array<Schema.Struct<{
+            readonly type: Schema.tag<"output_text">;
+            readonly text: Schema.String;
+        }>>;
+        readonly phase: Schema.optionalKey<Schema.NullOr<Schema.Literals<readonly ["commentary", "final_answer"]>>>;
+    }>, Schema.Union<readonly [Schema.Struct<{
         readonly role: Schema.tag<"system">;
         readonly content: Schema.String;
     }>, Schema.Struct<{
@@ -54,6 +37,7 @@ declare const OpenAIResponsesBody: Schema.Struct<{
             readonly type: Schema.tag<"output_text">;
             readonly text: Schema.String;
         }>>;
+        readonly phase: Schema.optionalKey<Schema.Literals<readonly ["commentary", "final_answer"]>>;
     }>, Schema.Struct<{
         readonly type: Schema.tag<"reasoning">;
         readonly id: Schema.optionalKey<Schema.String>;
@@ -85,7 +69,31 @@ declare const OpenAIResponsesBody: Schema.Struct<{
             readonly file_data: Schema.String;
             readonly mime_type: Schema.optional<Schema.String>;
         }>]>>]>;
+    }>]>]>>;
+    readonly tools: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.tag<"function">;
+        readonly name: Schema.String;
+        readonly description: Schema.String;
+        readonly parameters: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly strict: Schema.optional<Schema.Boolean>;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"image_generation">;
+        readonly action: Schema.optional<Schema.Literals<readonly ["auto", "generate", "edit"]>>;
+        readonly background: Schema.optional<Schema.Literals<readonly ["auto", "opaque", "transparent"]>>;
+        readonly input_fidelity: Schema.optional<Schema.Literals<readonly ["low", "high"]>>;
+        readonly output_compression: Schema.optional<Schema.Int>;
+        readonly output_format: Schema.optional<Schema.Literals<readonly ["png", "jpeg", "webp"]>>;
+        readonly partial_images: Schema.optional<Schema.Int>;
+        readonly quality: Schema.optional<Schema.Literals<readonly ["auto", "low", "medium", "high"]>>;
+        readonly size: Schema.optional<Schema.String>;
+    }>]>>>;
+    readonly tool_choice: Schema.optional<Schema.Union<readonly [Schema.Union<readonly [Schema.Literals<readonly ["auto", "none", "required"]>, Schema.Struct<{
+        readonly type: Schema.tag<"function">;
+        readonly name: Schema.String;
+    }>]>, Schema.Struct<{
+        readonly type: Schema.tag<"image_generation">;
     }>]>>;
+    readonly model: Schema.String;
     readonly instructions: Schema.optional<Schema.String>;
     readonly store: Schema.optional<Schema.Boolean>;
     readonly service_tier: Schema.optional<Schema.Literals<readonly ["auto", "default", "flex", "priority"]>>;
@@ -132,13 +140,14 @@ export declare const protocol: Protocol<{
             readonly file_data: Schema.String;
             readonly mime_type: Schema.optional<Schema.String>;
         }>]>]>>;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
-        readonly role: Schema.tag<"assistant">;
-        readonly content: Schema.$Array<Schema.Struct<{
+    }, "Type"> | {
+        readonly content: readonly Schema.Struct.ReadonlySide<{
             readonly type: Schema.tag<"output_text">;
             readonly text: Schema.String;
-        }>>;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
+        }, "Type">[];
+        readonly role: "assistant";
+        readonly phase?: "commentary" | "final_answer" | undefined;
+    } | Schema.Struct.ReadonlySide<{
         readonly type: Schema.tag<"function_call">;
         readonly call_id: Schema.String;
         readonly name: Schema.String;
@@ -158,7 +167,14 @@ export declare const protocol: Protocol<{
             readonly file_data: Schema.String;
             readonly mime_type: Schema.optional<Schema.String>;
         }>]>>]>;
-    }, "Type">)[];
+    }, "Type"> | {
+        readonly content: readonly Schema.Struct.ReadonlySide<{
+            readonly type: Schema.tag<"output_text">;
+            readonly text: Schema.String;
+        }, "Type">[];
+        readonly role: "assistant";
+        readonly phase?: "commentary" | "final_answer" | null | undefined;
+    })[];
     readonly model: string;
     readonly stream: true;
     readonly text?: {
@@ -209,6 +225,7 @@ export declare const protocol: Protocol<{
         readonly code?: string | null | undefined;
         readonly param?: string | null | undefined;
     } | null | undefined;
+    readonly text?: string | undefined;
     readonly response?: {
         readonly [x: string]: unknown;
         readonly error?: {
@@ -279,13 +296,14 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
             readonly file_data: Schema.String;
             readonly mime_type: Schema.optional<Schema.String>;
         }>]>]>>;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
-        readonly role: Schema.tag<"assistant">;
-        readonly content: Schema.$Array<Schema.Struct<{
+    }, "Type"> | {
+        readonly content: readonly Schema.Struct.ReadonlySide<{
             readonly type: Schema.tag<"output_text">;
             readonly text: Schema.String;
-        }>>;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
+        }, "Type">[];
+        readonly role: "assistant";
+        readonly phase?: "commentary" | "final_answer" | undefined;
+    } | Schema.Struct.ReadonlySide<{
         readonly type: Schema.tag<"function_call">;
         readonly call_id: Schema.String;
         readonly name: Schema.String;
@@ -305,7 +323,14 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
             readonly file_data: Schema.String;
             readonly mime_type: Schema.optional<Schema.String>;
         }>]>>]>;
-    }, "Type">)[];
+    }, "Type"> | {
+        readonly content: readonly Schema.Struct.ReadonlySide<{
+            readonly type: Schema.tag<"output_text">;
+            readonly text: Schema.String;
+        }, "Type">[];
+        readonly role: "assistant";
+        readonly phase?: "commentary" | "final_answer" | null | undefined;
+    })[];
     readonly model: string;
     readonly stream: true;
     readonly text?: {
@@ -378,13 +403,14 @@ export declare const route: Route<{
             readonly file_data: Schema.String;
             readonly mime_type: Schema.optional<Schema.String>;
         }>]>]>>;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
-        readonly role: Schema.tag<"assistant">;
-        readonly content: Schema.$Array<Schema.Struct<{
+    }, "Type"> | {
+        readonly content: readonly Schema.Struct.ReadonlySide<{
             readonly type: Schema.tag<"output_text">;
             readonly text: Schema.String;
-        }>>;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
+        }, "Type">[];
+        readonly role: "assistant";
+        readonly phase?: "commentary" | "final_answer" | undefined;
+    } | Schema.Struct.ReadonlySide<{
         readonly type: Schema.tag<"function_call">;
         readonly call_id: Schema.String;
         readonly name: Schema.String;
@@ -404,7 +430,14 @@ export declare const route: Route<{
             readonly file_data: Schema.String;
             readonly mime_type: Schema.optional<Schema.String>;
         }>]>>]>;
-    }, "Type">)[];
+    }, "Type"> | {
+        readonly content: readonly Schema.Struct.ReadonlySide<{
+            readonly type: Schema.tag<"output_text">;
+            readonly text: Schema.String;
+        }, "Type">[];
+        readonly role: "assistant";
+        readonly phase?: "commentary" | "final_answer" | null | undefined;
+    })[];
     readonly model: string;
     readonly stream: true;
     readonly text?: {
@@ -477,13 +510,14 @@ export declare const webSocketTransport: import("../route/transport/websocket").
             readonly file_data: Schema.String;
             readonly mime_type: Schema.optional<Schema.String>;
         }>]>]>>;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
-        readonly role: Schema.tag<"assistant">;
-        readonly content: Schema.$Array<Schema.Struct<{
+    }, "Type"> | {
+        readonly content: readonly Schema.Struct.ReadonlySide<{
             readonly type: Schema.tag<"output_text">;
             readonly text: Schema.String;
-        }>>;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
+        }, "Type">[];
+        readonly role: "assistant";
+        readonly phase?: "commentary" | "final_answer" | undefined;
+    } | Schema.Struct.ReadonlySide<{
         readonly type: Schema.tag<"function_call">;
         readonly call_id: Schema.String;
         readonly name: Schema.String;
@@ -503,7 +537,14 @@ export declare const webSocketTransport: import("../route/transport/websocket").
             readonly file_data: Schema.String;
             readonly mime_type: Schema.optional<Schema.String>;
         }>]>>]>;
-    }, "Type">)[];
+    }, "Type"> | {
+        readonly content: readonly Schema.Struct.ReadonlySide<{
+            readonly type: Schema.tag<"output_text">;
+            readonly text: Schema.String;
+        }, "Type">[];
+        readonly role: "assistant";
+        readonly phase?: "commentary" | "final_answer" | null | undefined;
+    })[];
     readonly model: string;
     readonly stream: true;
     readonly text?: {
@@ -577,13 +618,14 @@ export declare const webSocketTransport: import("../route/transport/websocket").
             readonly file_data: Schema.String;
             readonly mime_type: Schema.optional<Schema.String>;
         }>]>]>>;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
-        readonly role: Schema.tag<"assistant">;
-        readonly content: Schema.$Array<Schema.Struct<{
+    }, "Type"> | {
+        readonly content: readonly Schema.Struct.ReadonlySide<{
             readonly type: Schema.tag<"output_text">;
             readonly text: Schema.String;
-        }>>;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
+        }, "Type">[];
+        readonly role: "assistant";
+        readonly phase?: "commentary" | "final_answer" | undefined;
+    } | Schema.Struct.ReadonlySide<{
         readonly type: Schema.tag<"function_call">;
         readonly call_id: Schema.String;
         readonly name: Schema.String;
@@ -603,7 +645,14 @@ export declare const webSocketTransport: import("../route/transport/websocket").
             readonly file_data: Schema.String;
             readonly mime_type: Schema.optional<Schema.String>;
         }>]>>]>;
-    }, "Type">)[];
+    }, "Type"> | {
+        readonly content: readonly Schema.Struct.ReadonlySide<{
+            readonly type: Schema.tag<"output_text">;
+            readonly text: Schema.String;
+        }, "Type">[];
+        readonly role: "assistant";
+        readonly phase?: "commentary" | "final_answer" | null | undefined;
+    })[];
     readonly model: string;
     readonly text?: {
         readonly verbosity?: "low" | "medium" | "high" | undefined;
@@ -675,13 +724,14 @@ export declare const webSocketRoute: Route<{
             readonly file_data: Schema.String;
             readonly mime_type: Schema.optional<Schema.String>;
         }>]>]>>;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
-        readonly role: Schema.tag<"assistant">;
-        readonly content: Schema.$Array<Schema.Struct<{
+    }, "Type"> | {
+        readonly content: readonly Schema.Struct.ReadonlySide<{
             readonly type: Schema.tag<"output_text">;
             readonly text: Schema.String;
-        }>>;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
+        }, "Type">[];
+        readonly role: "assistant";
+        readonly phase?: "commentary" | "final_answer" | undefined;
+    } | Schema.Struct.ReadonlySide<{
         readonly type: Schema.tag<"function_call">;
         readonly call_id: Schema.String;
         readonly name: Schema.String;
@@ -701,7 +751,14 @@ export declare const webSocketRoute: Route<{
             readonly file_data: Schema.String;
             readonly mime_type: Schema.optional<Schema.String>;
         }>]>>]>;
-    }, "Type">)[];
+    }, "Type"> | {
+        readonly content: readonly Schema.Struct.ReadonlySide<{
+            readonly type: Schema.tag<"output_text">;
+            readonly text: Schema.String;
+        }, "Type">[];
+        readonly role: "assistant";
+        readonly phase?: "commentary" | "final_answer" | null | undefined;
+    })[];
     readonly model: string;
     readonly stream: true;
     readonly text?: {

package/dist/protocols/openai-responses.js

@@ -30,8 +30,17 @@ const OpenAIResponsesToolChoice = Schema.Union([
     OpenResponses.ToolChoice,
     Schema.Struct({ type: Schema.tag("image_generation") }),
 ]);
+const OpenAIResponsesInputItem = Schema.Union([
+    Schema.Struct({
+        role: Schema.tag("assistant"),
+        content: Schema.Array(Schema.Struct({ type: Schema.tag("output_text"), text: Schema.String })),
+        phase: Schema.optionalKey(Schema.NullOr(OpenResponses.MessagePhase)),
+    }),
+    OpenResponses.InputItem,
+]);
 const OpenAIResponsesCoreFields = {
     ...OpenResponses.coreFields,
+    input: Schema.Array(OpenAIResponsesInputItem),
     tools: optionalArray(OpenAIResponsesTools),
     tool_choice: Schema.optional(OpenAIResponsesToolChoice),
 };
@@ -47,6 +56,7 @@ const encodeWebSocketMessage = Schema.encodeSync(Schema.fromJsonString(OpenAIRes
 const extension = {
     id: ADAPTER,
     name: NAME,
+    messagePhase: (value) => (value === null ? null : undefined),
     lowerMedia: ({ part, media, request }) => {
         if (request.model.provider !== "xai" || media.mime !== "application/pdf")
             return undefined;
@@ -84,7 +94,7 @@ const lowerToolChoice = (toolChoice, tools) => ProviderShared.matchToolChoice(NA
         : { type: "function", name },
 });
 const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request) {
-    const body = yield* OpenResponses.fromRequest(LLMRequest.update(request, { tools: [], toolChoice: undefined }), extension);
+    const body = yield* OpenResponses.fromRequestWithExtension(LLMRequest.update(request, { tools: [], toolChoice: undefined }), extension);
     const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
     return {
         ...body,
@@ -151,9 +161,13 @@ const onHostedToolDone = Effect.fn("OpenAIResponses.onHostedToolDone")(function*
 });
 const step = (state, event) => {
     if (event.type === "response.reasoning_text.delta" || event.type === "response.reasoning_summary.delta")
-        return Effect.succeed(OpenResponses.onReasoningDelta(state, event));
+        return event.item_id
+            ? Effect.succeed(OpenResponses.onReasoningDelta(state, event, event.item_id))
+            : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`);
     if (event.type === "response.reasoning_text.done" || event.type === "response.reasoning_summary.done")
-        return Effect.succeed(OpenResponses.onReasoningDone(state, event));
+        return event.item_id
+            ? Effect.succeed(OpenResponses.onReasoningDone(state, event))
+            : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`);
     if (event.type === "response.output_item.done" && event.item && isHostedToolItem(event.item))
         return onHostedToolDone(state, event.item);
     return OpenResponses.step(state, event);

package/dist/providers/azure.d.ts

@@ -114,13 +114,14 @@ export declare const routes: (RouteDef<{
             readonly file_data: import("effect/Schema").String;
             readonly mime_type: import("effect/Schema").optional<import("effect/Schema").String>;
         }>]>]>>;
-    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
-        readonly role: import("effect/Schema").tag<"assistant">;
-        readonly content: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+    }, "Type"> | {
+        readonly content: readonly import("effect/Schema").Struct.ReadonlySide<{
             readonly type: import("effect/Schema").tag<"output_text">;
             readonly text: import("effect/Schema").String;
-        }>>;
-    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+        }, "Type">[];
+        readonly role: "assistant";
+        readonly phase?: "commentary" | "final_answer" | undefined;
+    } | import("effect/Schema").Struct.ReadonlySide<{
         readonly type: import("effect/Schema").tag<"function_call">;
         readonly call_id: import("effect/Schema").String;
         readonly name: import("effect/Schema").String;
@@ -140,7 +141,14 @@ export declare const routes: (RouteDef<{
             readonly file_data: import("effect/Schema").String;
             readonly mime_type: import("effect/Schema").optional<import("effect/Schema").String>;
         }>]>>]>;
-    }, "Type">)[];
+    }, "Type"> | {
+        readonly content: readonly import("effect/Schema").Struct.ReadonlySide<{
+            readonly type: import("effect/Schema").tag<"output_text">;
+            readonly text: import("effect/Schema").String;
+        }, "Type">[];
+        readonly role: "assistant";
+        readonly phase?: "commentary" | "final_answer" | null | undefined;
+    })[];
     readonly model: string;
     readonly stream: true;
     readonly text?: {