@opencode-ai/ai 0.0.0-next-16134 → 0.0.0-next-16144

package/dist/protocols/openai-responses.js

@@ -2,97 +2,18 @@ import { Effect, Encoding, Schema } from "effect";
 import { Route } from "../route/client";
 import { Auth } from "../route/auth";
 import { Endpoint } from "../route/endpoint";
-import { HttpTransport, WebSocketTransport } from "../route/transport";
 import { Protocol } from "../route/protocol";
-import { LLMError, LLMEvent, Usage, } from "../schema";
-import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared";
-import { classifyProviderFailure } from "../provider-error";
-import { OpenAIOptions } from "./utils/openai-options";
+import { HttpTransport, WebSocketTransport } from "../route/transport";
+import { LLMEvent, LLMRequest } from "../schema";
+import { OpenResponses } from "./open-responses";
+import { optionalArray, ProviderShared } from "./shared";
 import { Lifecycle } from "./utils/lifecycle";
-import { ToolSchemaProjection } from "./utils/tool-schema";
-import { ToolStream } from "./utils/tool-stream";
 import { OpenAIImage } from "./utils/openai-image";
+import { ToolSchemaProjection } from "./utils/tool-schema";
 const ADAPTER = "openai-responses";
-const MEDIA_MIMES = new Set([...ProviderShared.IMAGE_MIMES, ...ProviderShared.PDF_MIMES]);
+const NAME = "OpenAI Responses";
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1";
-export const PATH = "/responses";
-// =============================================================================
-// Request Body Schema
-// =============================================================================
-const OpenAIResponsesInputText = Schema.Struct({
-    type: Schema.tag("input_text"),
-    text: Schema.String,
-});
-const OpenAIResponsesInputImage = Schema.Struct({
-    type: Schema.tag("input_image"),
-    image_url: Schema.String,
-});
-const OpenAIResponsesInputFile = Schema.Struct({
-    type: Schema.tag("input_file"),
-    filename: Schema.String,
-    file_data: Schema.String,
-    mime_type: Schema.optional(Schema.String),
-});
-const OpenAIResponsesInputContent = Schema.Union([
-    OpenAIResponsesInputText,
-    OpenAIResponsesInputImage,
-    OpenAIResponsesInputFile,
-]);
-const OpenAIResponsesOutputText = Schema.Struct({
-    type: Schema.tag("output_text"),
-    text: Schema.String,
-});
-const OpenAIResponsesReasoningSummaryText = Schema.Struct({
-    type: Schema.tag("summary_text"),
-    text: Schema.String,
-});
-const OpenAIResponsesReasoningItem = Schema.Struct({
-    type: Schema.tag("reasoning"),
-    id: Schema.optionalKey(Schema.String),
-    summary: Schema.Array(OpenAIResponsesReasoningSummaryText),
-    encrypted_content: optionalNull(Schema.String),
-});
-const OpenAIResponsesItemReference = Schema.Struct({
-    type: Schema.tag("item_reference"),
-    id: Schema.String,
-});
-// `function_call_output.output` accepts either a plain string or an ordered
-// array of content items so tools can return images and files in addition to text.
-// https://platform.openai.com/docs/api-reference/responses/object
-const OpenAIResponsesFunctionCallOutputContent = Schema.Union([
-    OpenAIResponsesInputText,
-    OpenAIResponsesInputImage,
-    OpenAIResponsesInputFile,
-]);
-const OpenAIResponsesFunctionCallOutput = Schema.Union([
-    Schema.String,
-    Schema.Array(OpenAIResponsesFunctionCallOutputContent),
-]);
-const OpenAIResponsesInputItem = Schema.Union([
-    Schema.Struct({ role: Schema.tag("system"), content: Schema.String }),
-    Schema.Struct({ role: Schema.tag("user"), content: Schema.Array(OpenAIResponsesInputContent) }),
-    Schema.Struct({ role: Schema.tag("assistant"), content: Schema.Array(OpenAIResponsesOutputText) }),
-    OpenAIResponsesReasoningItem,
-    OpenAIResponsesItemReference,
-    Schema.Struct({
-        type: Schema.tag("function_call"),
-        call_id: Schema.String,
-        name: Schema.String,
-        arguments: Schema.String,
-    }),
-    Schema.Struct({
-        type: Schema.tag("function_call_output"),
-        call_id: Schema.String,
-        output: OpenAIResponsesFunctionCallOutput,
-    }),
-]);
-const OpenAIResponsesTool = Schema.Struct({
-    type: Schema.tag("function"),
-    name: Schema.String,
-    description: Schema.String,
-    parameters: JsonObject,
-    strict: Schema.optional(Schema.Boolean),
-});
+export const PATH = OpenResponses.PATH;
 const OpenAIResponsesImageGenerationTool = Schema.Struct({
     type: Schema.tag("image_generation"),
     action: Schema.optional(Schema.Literals(["auto", "generate", "edit"])),
@@ -104,36 +25,15 @@ const OpenAIResponsesImageGenerationTool = Schema.Struct({
     quality: Schema.optional(Schema.Literals(["auto", "low", "medium", "high"])),
     size: Schema.optional(OpenAIImage.Size),
 });
-const OpenAIResponsesTools = Schema.Union([OpenAIResponsesTool, OpenAIResponsesImageGenerationTool]);
+const OpenAIResponsesTools = Schema.Union([OpenResponses.Tool, OpenAIResponsesImageGenerationTool]);
 const OpenAIResponsesToolChoice = Schema.Union([
-    Schema.Literals(["auto", "none", "required"]),
-    Schema.Struct({ type: Schema.tag("function"), name: Schema.String }),
+    OpenResponses.ToolChoice,
     Schema.Struct({ type: Schema.tag("image_generation") }),
 ]);
-// Fields shared between the HTTP body and the WebSocket `response.create`
-// message. The HTTP body adds `stream: true`; the WebSocket message adds
-// `type: "response.create"`. Defining the shared shape once keeps the two
-// transports in sync without a destructure-and-strip dance.
 const OpenAIResponsesCoreFields = {
-    model: Schema.String,
-    input: Schema.Array(OpenAIResponsesInputItem),
-    instructions: Schema.optional(Schema.String),
+    ...OpenResponses.coreFields,
     tools: optionalArray(OpenAIResponsesTools),
     tool_choice: Schema.optional(OpenAIResponsesToolChoice),
-    store: Schema.optional(Schema.Boolean),
-    service_tier: Schema.optional(OpenAIOptions.OpenAIServiceTier),
-    prompt_cache_key: Schema.optional(Schema.String),
-    include: optionalArray(OpenAIOptions.OpenAIResponseIncludable),
-    reasoning: Schema.optional(Schema.Struct({
-        effort: Schema.optional(OpenAIOptions.OpenAIReasoningEffort),
-        summary: Schema.optional(Schema.Literal("auto")),
-    })),
-    text: Schema.optional(Schema.Struct({
-        verbosity: Schema.optional(OpenAIOptions.OpenAITextVerbosity),
-    })),
-    max_output_tokens: Schema.optional(Schema.Number),
-    temperature: Schema.optional(Schema.Number),
-    top_p: Schema.optional(Schema.Number),
 };
 const OpenAIResponsesBody = Schema.Struct({
     ...OpenAIResponsesCoreFields,
@@ -144,69 +44,20 @@ const OpenAIResponsesWebSocketMessage = Schema.StructWithRest(Schema.Struct({
     ...OpenAIResponsesCoreFields,
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
 const encodeWebSocketMessage = Schema.encodeSync(Schema.fromJsonString(OpenAIResponsesWebSocketMessage));
-const OpenAIResponsesUsage = Schema.Struct({
-    input_tokens: Schema.optional(Schema.Number),
-    input_tokens_details: optionalNull(Schema.Struct({ cached_tokens: Schema.optional(Schema.Number) })),
-    output_tokens: Schema.optional(Schema.Number),
-    output_tokens_details: optionalNull(Schema.Struct({ reasoning_tokens: Schema.optional(Schema.Number) })),
-    total_tokens: Schema.optional(Schema.Number),
-});
-const OpenAIResponsesStreamItem = Schema.Struct({
-    type: Schema.String,
-    id: Schema.optional(Schema.String),
-    call_id: Schema.optional(Schema.String),
-    name: Schema.optional(Schema.String),
-    arguments: Schema.optional(Schema.String),
-    // Hosted (provider-executed) tool fields. Each hosted tool item carries its
-    // own subset of these — we capture them generically so we can surface the
-    // call's typed input portion and round-trip the full result payload without
-    // hand-rolling a per-tool schema.
-    status: Schema.optional(Schema.String),
-    action: Schema.optional(Schema.Unknown),
-    queries: Schema.optional(Schema.Unknown),
-    results: Schema.optional(Schema.Unknown),
-    code: Schema.optional(Schema.String),
-    container_id: Schema.optional(Schema.String),
-    outputs: Schema.optional(Schema.Unknown),
-    server_label: Schema.optional(Schema.String),
-    output: Schema.optional(Schema.Unknown),
-    result: Schema.optional(Schema.String),
-    output_format: Schema.optional(Schema.Literals(["png", "jpeg", "webp"])),
-    error: Schema.optional(Schema.Unknown),
-    encrypted_content: optionalNull(Schema.String),
-});
-// The Responses schema puts streaming error details at the top level and
-// response failures under `response.error`. The official SDK also recognizes
-// an event-level HTTP-style `error` envelope, so accept all three shapes here.
-// https://github.com/openai/openai-openapi/blob/5162af98d3147432c14680df789e8e12d4891e6b/openapi.yaml#L67234-L67382
-// https://github.com/openai/openai-node/blob/61539248cbe04665de68a71e6fd878127ae4db87/src/core/streaming.ts#L58-L85
-const OpenAIResponsesErrorPayload = Schema.Struct({
-    code: optionalNull(Schema.String),
-    message: optionalNull(Schema.String),
-    param: optionalNull(Schema.String),
-});
-const OpenAIResponsesEvent = Schema.Struct({
-    type: Schema.String,
-    delta: Schema.optional(Schema.String),
-    item_id: Schema.optional(Schema.String),
-    summary_index: Schema.optional(Schema.Number),
-    item: Schema.optional(OpenAIResponsesStreamItem),
-    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) })),
-        usage: optionalNull(OpenAIResponsesUsage),
-        error: optionalNull(OpenAIResponsesErrorPayload),
-    }), [Schema.Record(Schema.String, Schema.Unknown)])),
-    code: optionalNull(Schema.String),
-    message: Schema.optional(Schema.String),
-    param: optionalNull(Schema.String),
-    error: optionalNull(OpenAIResponsesErrorPayload),
-});
-const invalid = ProviderShared.invalidRequest;
-// =============================================================================
-// Request Lowering
-// =============================================================================
+const extension = {
+    id: ADAPTER,
+    name: NAME,
+    lowerMedia: ({ part, media, request }) => {
+        if (request.model.provider !== "xai" || media.mime !== "application/pdf")
+            return undefined;
+        return {
+            type: "input_file",
+            filename: part.filename ?? "document.pdf",
+            file_data: media.base64,
+            mime_type: media.mime,
+        };
+    },
+};
 const nativeImageToolInput = (tool) => {
     const native = tool.native?.openai;
     return ProviderShared.isRecord(native) && native.type === "image_generation" ? native : undefined;
@@ -220,18 +71,11 @@ const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool, inputS
     if (native !== undefined) {
         if (Schema.is(OpenAIResponsesImageGenerationTool)(native))
             return native;
-        return yield* invalid("OpenAI Responses image generation tool options are invalid");
+        return yield* ProviderShared.invalidRequest("OpenAI Responses image generation tool options are invalid");
     }
-    return {
-        type: "function",
-        name: tool.name,
-        description: tool.description,
-        parameters: ToolSchemaProjection.openAI(inputSchema),
-        // TODO: Read this from OpenAI-specific tool options so direct LLM callers can opt into strict schemas.
-        strict: false,
-    };
+    return yield* OpenResponses.lowerTool(NAME, tool, inputSchema);
 });
-const lowerToolChoice = (toolChoice, tools) => ProviderShared.matchToolChoice("OpenAI Responses", toolChoice, {
+const lowerToolChoice = (toolChoice, tools) => ProviderShared.matchToolChoice(NAME, toolChoice, {
     auto: () => "auto",
     none: () => "none",
     required: () => "required",
@@ -239,274 +83,17 @@ const lowerToolChoice = (toolChoice, tools) => ProviderShared.matchToolChoice("O
         ? { type: "image_generation" }
         : { type: "function", name },
 });
-const lowerToolCall = (part) => ({
-    type: "function_call",
-    call_id: part.id,
-    name: part.name,
-    arguments: ProviderShared.encodeJson(part.input),
-});
-const lowerReasoning = (part) => {
-    const openai = part.providerMetadata?.openai;
-    if (!ProviderShared.isRecord(openai) || typeof openai.itemId !== "string" || openai.itemId.length === 0)
-        return undefined;
-    const encryptedContent = typeof openai.reasoningEncryptedContent === "string"
-        ? openai.reasoningEncryptedContent
-        : openai.reasoningEncryptedContent === null
-            ? null
-            : undefined;
-    return {
-        type: "reasoning",
-        id: openai.itemId,
-        summary: part.text.length > 0 ? [{ type: "summary_text", text: part.text }] : [],
-        encrypted_content: encryptedContent,
-    };
-};
-const hostedToolItemID = (part) => {
-    const openai = part.providerMetadata?.openai;
-    return ProviderShared.isRecord(openai) && typeof openai.itemId === "string" && openai.itemId.length > 0
-        ? openai.itemId
-        : undefined;
-};
-const lowerMedia = Effect.fn("OpenAIResponses.lowerMedia")(function* (part, provider) {
-    const media = yield* ProviderShared.validateMedia("OpenAI Responses", part, MEDIA_MIMES);
-    if (media.mime === "application/pdf") {
-        // xAI models inline bytes and MIME separately; OpenAI uses a data URL in file_data.
-        if (provider === "xai")
-            return {
-                type: "input_file",
-                filename: part.filename ?? "document.pdf",
-                file_data: media.base64,
-                mime_type: media.mime,
-            };
-        return {
-            type: "input_file",
-            filename: part.filename ?? "document.pdf",
-            file_data: media.dataUrl,
-        };
-    }
-    return { type: "input_image", image_url: media.dataUrl };
-});
-const lowerUserContent = Effect.fn("OpenAIResponses.lowerUserContent")(function* (part, provider) {
-    if (part.type === "text")
-        return { type: "input_text", text: part.text };
-    if (part.type === "media")
-        return yield* lowerMedia(part, provider);
-    return yield* ProviderShared.unsupportedContent("OpenAI Responses", "user", ["text", "media"]);
-});
-// Tool results may carry structured text, images, and files. Keep media as provider-native
-// content instead of JSON-stringifying base64 into a prompt string.
-const lowerToolResultContentItem = Effect.fn("OpenAIResponses.lowerToolResultContentItem")(function* (item, provider) {
-    if (item.type === "text")
-        return { type: "input_text", text: item.text };
-    return yield* lowerMedia({ type: "media", mediaType: item.mime, data: item.uri, filename: item.name }, provider);
-});
-const lowerToolResultOutput = Effect.fn("OpenAIResponses.lowerToolResultOutput")(function* (part, provider) {
-    // Text/json/error results are encoded as a plain string for backward
-    // compatibility with existing cassettes and provider expectations.
-    if (part.result.type !== "content")
-        return ProviderShared.toolResultText(part);
-    // Preserve the narrowed array element type when compiled through a consumer package.
-    const content = part.result.value;
-    return yield* Effect.forEach(content, (item) => lowerToolResultContentItem(item, provider));
-});
-const lowerMessages = Effect.fn("OpenAIResponses.lowerMessages")(function* (request) {
-    const system = request.system.length === 0 ? [] : [{ role: "system", content: ProviderShared.joinText(request.system) }];
-    const input = [...system];
-    const store = OpenAIOptions.store(request);
-    for (const message of request.messages) {
-        if (message.role === "system") {
-            const part = yield* ProviderShared.wrappedSystemUpdate("OpenAI Responses", message);
-            const previous = input.at(-1);
-            if (previous && "role" in previous && previous.role === "user")
-                input[input.length - 1] = {
-                    role: "user",
-                    content: [...previous.content, { type: "input_text", text: part.text }],
-                };
-            else
-                input.push({ role: "user", content: [{ type: "input_text", text: part.text }] });
-            continue;
-        }
-        if (message.role === "user") {
-            input.push({
-                role: "user",
-                content: yield* Effect.forEach(message.content, (part) => lowerUserContent(part, request.model.provider)),
-            });
-            continue;
-        }
-        if (message.role === "assistant") {
-            const content = [];
-            const reasoningItems = {};
-            const reasoningReferences = new Set();
-            const hostedToolReferences = new Set();
-            const flushText = () => {
-                if (content.length === 0)
-                    return;
-                input.push({ role: "assistant", content: content.map((part) => ({ type: "output_text", text: part.text })) });
-                content.splice(0, content.length);
-            };
-            for (const part of message.content) {
-                if (part.type === "text") {
-                    content.push(part);
-                    continue;
-                }
-                if (part.type === "reasoning") {
-                    flushText();
-                    const reasoning = lowerReasoning(part);
-                    if (!reasoning)
-                        continue;
-                    if (store !== false) {
-                        if (!reasoningReferences.has(reasoning.id))
-                            input.push({ type: "item_reference", id: reasoning.id });
-                        reasoningReferences.add(reasoning.id);
-                        continue;
-                    }
-                    const existing = reasoningItems[reasoning.id];
-                    if (existing) {
-                        existing.summary.push(...reasoning.summary);
-                        if (typeof reasoning.encrypted_content === "string")
-                            existing.encrypted_content = reasoning.encrypted_content;
-                        continue;
-                    }
-                    const replay = {
-                        type: reasoning.type,
-                        summary: reasoning.summary,
-                        encrypted_content: reasoning.encrypted_content,
-                    };
-                    reasoningItems[reasoning.id] = replay;
-                    input.push(replay);
-                    continue;
-                }
-                if (part.type === "tool-call") {
-                    flushText();
-                    if (part.providerExecuted === true)
-                        continue;
-                    input.push(lowerToolCall(part));
-                    continue;
-                }
-                if (part.type === "tool-result" && part.providerExecuted === true) {
-                    flushText();
-                    const itemID = hostedToolItemID(part);
-                    if (store !== false && itemID && !hostedToolReferences.has(itemID))
-                        input.push({ type: "item_reference", id: itemID });
-                    if (store === false && part.name === "image_generation" && part.result.type === "content") {
-                        const content = part.result.value;
-                        input.push({
-                            role: "user",
-                            content: yield* Effect.forEach(content, (item) => lowerToolResultContentItem(item, request.model.provider)),
-                        });
-                    }
-                    if (itemID)
-                        hostedToolReferences.add(itemID);
-                    continue;
-                }
-                return yield* ProviderShared.unsupportedContent("OpenAI Responses", "assistant", [
-                    "text",
-                    "reasoning",
-                    "tool-call",
-                    "tool-result",
-                ]);
-            }
-            flushText();
-            continue;
-        }
-        for (const part of message.content) {
-            if (!ProviderShared.supportsContent(part, ["tool-result"]))
-                return yield* ProviderShared.unsupportedContent("OpenAI Responses", "tool", ["tool-result"]);
-            input.push({
-                type: "function_call_output",
-                call_id: part.id,
-                output: yield* lowerToolResultOutput(part, request.model.provider),
-            });
-        }
-    }
-    // With store:false, OpenAI only accepts 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;
-});
-const lowerOptions = Effect.fn("OpenAIResponses.lowerOptions")(function* (request) {
-    const store = OpenAIOptions.store(request);
-    const promptCacheKey = OpenAIOptions.promptCacheKey(request);
-    const effort = OpenAIOptions.reasoningEffort(request);
-    const summary = OpenAIOptions.reasoningSummary(request);
-    const include = OpenAIOptions.include(request);
-    const verbosity = OpenAIOptions.textVerbosity(request);
-    const instructions = OpenAIOptions.instructions(request);
-    const serviceTier = OpenAIOptions.serviceTier(request);
-    return {
-        ...(instructions ? { instructions } : {}),
-        ...(store !== undefined ? { store } : {}),
-        ...(promptCacheKey ? { prompt_cache_key: promptCacheKey } : {}),
-        ...(include ? { include } : {}),
-        ...(effort || summary ? { reasoning: { effort, summary } } : {}),
-        ...(verbosity ? { text: { verbosity } } : {}),
-        ...(serviceTier ? { service_tier: serviceTier } : {}),
-    };
-});
 const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request) {
-    const generation = request.generation;
-    const options = yield* lowerOptions(request);
+    const body = yield* OpenResponses.fromRequest(LLMRequest.update(request, { tools: [], toolChoice: undefined }), extension);
     const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
     return {
-        model: request.model.id,
-        input: yield* lowerMessages(request),
+        ...body,
         tools: request.tools.length === 0
             ? undefined
             : yield* Effect.forEach(request.tools, (tool) => lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility))),
         tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined,
-        stream: true,
-        max_output_tokens: generation?.maxTokens,
-        temperature: generation?.temperature,
-        top_p: generation?.topP,
-        ...options,
     };
 });
-// =============================================================================
-// Stream Parsing
-// =============================================================================
-// OpenAI Responses reports `input_tokens` (inclusive total) with a
-// `cached_tokens` subset, and `output_tokens` (inclusive total) with a
-// `reasoning_tokens` subset. Pass the totals through and derive the
-// non-cached breakdown.
-const mapUsage = (usage) => {
-    if (!usage)
-        return undefined;
-    const cached = usage.input_tokens_details?.cached_tokens;
-    const reasoning = usage.output_tokens_details?.reasoning_tokens;
-    const nonCached = ProviderShared.subtractTokens(usage.input_tokens, cached);
-    return new Usage({
-        inputTokens: usage.input_tokens,
-        outputTokens: usage.output_tokens,
-        nonCachedInputTokens: nonCached,
-        cacheReadInputTokens: cached,
-        reasoningTokens: reasoning,
-        totalTokens: ProviderShared.totalTokens(usage.input_tokens, usage.output_tokens, usage.total_tokens),
-        providerMetadata: { openai: usage },
-    });
-};
-const mapFinishReason = (event, hasFunctionCall) => {
-    const reason = event.response?.incomplete_details?.reason;
-    if (reason === undefined || reason === null)
-        return hasFunctionCall ? "tool-calls" : event.type === "response.incomplete" ? "unknown" : "stop";
-    if (reason === "max_output_tokens")
-        return "length";
-    if (reason === "content_filter")
-        return "content-filter";
-    return hasFunctionCall ? "tool-calls" : "unknown";
-};
-const openaiMetadata = (metadata) => ({ openai: metadata });
-// Hosted tool items (provider-executed) ship their typed input + status +
-// result fields all in one item. We expose them as a `tool-call` +
-// `tool-result` pair so consumers can treat them uniformly with client tools,
-// only differentiated by `providerExecuted: true`.
-//
-// One record per OpenAI Responses item type that represents a hosted
-// (provider-executed) tool call: the common name we surface, plus an `input`
-// extractor that picks the fields the model actually populated for that tool.
-// Falling back to `{}` when an entry isn't fully typed keeps unknown tools
-// observable without rolling a per-tool schema.
 const HOSTED_TOOLS = {
     web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
     web_search_preview_call: { name: "web_search_preview", input: (item) => item.action ?? {} },
@@ -524,346 +111,53 @@ const HOSTED_TOOLS = {
     local_shell_call: { name: "local_shell", input: (item) => item.action ?? {} },
 };
 const isHostedToolItem = (item) => item.type in HOSTED_TOOLS && typeof item.id === "string" && item.id.length > 0;
-const isReasoningItem = (item) => item.type === "reasoning" && typeof item.id === "string" && item.id.length > 0;
-// Round-trip the full item as the structured result so consumers can extract
-// outputs / sources / status without re-decoding.
 const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function* (item) {
-    const isError = typeof item.error !== "undefined" && item.error !== null;
+    const isError = item.error !== undefined && item.error !== null;
     if (item.type === "image_generation_call" && item.result) {
         yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(Effect.mapError(() => ProviderShared.eventError(ADAPTER, "OpenAI Responses returned invalid image base64")));
+        const format = item.output_format ?? "png";
         return {
             type: "content",
             value: [
                 {
                     type: "file",
-                    uri: `data:image/${item.output_format ?? "png"};base64,${item.result}`,
-                    mime: `image/${item.output_format ?? "png"}`,
+                    uri: `data:image/${format};base64,${item.result}`,
+                    mime: `image/${format}`,
                 },
             ],
         };
     }
     return isError ? { type: "error", value: item.error } : { type: "json", value: item };
 });
-const hostedToolEvents = Effect.fn("OpenAIResponses.hostedToolEvents")(function* (item) {
+const onHostedToolDone = Effect.fn("OpenAIResponses.onHostedToolDone")(function* (state, item) {
     const tool = HOSTED_TOOLS[item.type];
-    const providerMetadata = openaiMetadata({ itemId: item.id });
-    return [
-        LLMEvent.toolCall({
-            id: item.id,
-            name: tool.name,
-            input: tool.input(item),
-            providerExecuted: true,
-            providerMetadata,
-        }),
-        LLMEvent.toolResult({
-            id: item.id,
-            name: tool.name,
-            result: yield* hostedToolResult(item),
-            providerExecuted: true,
-            providerMetadata,
-        }),
-    ];
-});
-const NO_EVENTS = [];
-// `response.completed` / `response.incomplete` are clean finishes that emit a
-// `finish` event; `response.failed` is a hard failure. All three end the stream,
-// so keep this set aligned with `step` and the protocol's terminal predicate.
-const TERMINAL_TYPES = new Set(["response.completed", "response.incomplete", "response.failed"]);
-const onOutputTextDelta = (state, event) => {
-    if (!event.delta)
-        return [state, NO_EVENTS];
-    const events = [];
-    return [
-        { ...state, lifecycle: Lifecycle.textDelta(state.lifecycle, events, event.item_id ?? "text-0", event.delta) },
-        events,
-    ];
-};
-const onOutputTextDone = (state, event) => {
-    const events = [];
-    return [{ ...state, lifecycle: Lifecycle.textEnd(state.lifecycle, events, event.item_id ?? "text-0") }, events];
-};
-const onReasoningDelta = (state, event) => {
-    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 [
-        {
-            ...state,
-            lifecycle: Lifecycle.reasoningDelta(state.lifecycle, events, id, event.delta),
-        },
-        events,
-    ];
-};
-const onReasoningDone = (state, _event) => [state, NO_EVENTS];
-const reasoningMetadata = (item) => openaiMetadata({ itemId: item.id, reasoningEncryptedContent: item.encrypted_content ?? null });
-// OpenAI Responses streams reasoning items in a stable order:
-//   `output_item.added` (reasoning) →
-//     `reasoning_summary_part.added` (index=0) →
-//     `reasoning_summary_text.delta` →
-//     `reasoning_summary_part.done` (index=0) →
-//     (repeat for index>0) →
-//   `output_item.done` (reasoning).
-// The handlers below rely on this ordering: `onOutputItemAdded` seeds the
-// per-item entry, `onReasoningSummaryPartAdded` for `summary_index === 0`
-// short-circuits when the entry already exists, and higher-index handlers
-// fold against the same entry. Behaviour for out-of-order events is
-// best-effort, not guaranteed.
-const onOutputItemAdded = (state, event) => {
-    const item = event.item;
-    if (item && isReasoningItem(item)) {
-        const events = [];
-        return [
-            {
-                ...state,
-                lifecycle: Lifecycle.reasoningStart(state.lifecycle, events, `${item.id}:0`, reasoningMetadata(item)),
-                reasoningItems: {
-                    ...state.reasoningItems,
-                    [item.id]: { encryptedContent: item.encrypted_content, summaryParts: { 0: "active" } },
-                },
-            },
-            events,
-        ];
-    }
-    if (item?.type !== "function_call" || !item.id)
-        return [state, NO_EVENTS];
-    const providerMetadata = openaiMetadata({ itemId: item.id });
+    const providerMetadata = OpenResponses.providerMetadata(state, { itemId: item.id });
     const events = [];
     const lifecycle = Lifecycle.stepStart(state.lifecycle, events);
-    return [
-        {
-            ...state,
-            lifecycle,
-            hasFunctionCall: state.hasFunctionCall,
-            tools: ToolStream.start(state.tools, item.id, {
-                id: item.call_id ?? item.id,
-                name: item.name ?? "",
-                input: item.arguments ?? "",
-                providerMetadata,
-            }),
-        },
-        [...events, LLMEvent.toolInputStart({ id: item.call_id ?? item.id, name: item.name ?? "", providerMetadata })],
-    ];
-};
-const onReasoningSummaryPartAdded = (state, event) => {
-    if (!event.item_id || event.summary_index === undefined)
-        return [state, NO_EVENTS];
-    const item = state.reasoningItems[event.item_id] ?? { encryptedContent: undefined, summaryParts: {} };
-    if (event.summary_index === 0) {
-        if (state.reasoningItems[event.item_id])
-            return [state, NO_EVENTS];
-        const events = [];
-        return [
-            {
-                ...state,
-                lifecycle: Lifecycle.reasoningStart(state.lifecycle, events, `${event.item_id}:0`, openaiMetadata({ itemId: event.item_id, reasoningEncryptedContent: null })),
-                reasoningItems: {
-                    ...state.reasoningItems,
-                    [event.item_id]: { ...item, summaryParts: { 0: "active" } },
-                },
-            },
-            events,
-        ];
-    }
-    const events = [];
-    const closed = Object.entries(item.summaryParts)
-        .filter((entry) => entry[1] === "can-conclude")
-        .reduce((lifecycle, entry) => Lifecycle.reasoningEnd(lifecycle, events, `${event.item_id}:${entry[0]}`, openaiMetadata({ itemId: event.item_id })), state.lifecycle);
-    return [
-        {
-            ...state,
-            lifecycle: Lifecycle.reasoningStart(closed, events, `${event.item_id}:${event.summary_index}`, openaiMetadata({ itemId: event.item_id, reasoningEncryptedContent: item.encryptedContent ?? null })),
-            reasoningItems: {
-                ...state.reasoningItems,
-                [event.item_id]: {
-                    ...item,
-                    summaryParts: {
-                        ...Object.fromEntries(Object.entries(item.summaryParts).map((entry) => entry[1] === "can-conclude" ? [entry[0], "concluded"] : entry)),
-                        [event.summary_index]: "active",
-                    },
-                },
-            },
-        },
-        events,
-    ];
-};
-const onReasoningSummaryPartDone = (state, event) => {
-    if (!event.item_id || event.summary_index === undefined)
-        return [state, NO_EVENTS];
-    const item = state.reasoningItems[event.item_id];
-    if (!item)
-        return [state, NO_EVENTS];
-    const events = [];
-    return [
-        {
-            ...state,
-            lifecycle: state.store !== false
-                ? Lifecycle.reasoningEnd(state.lifecycle, events, `${event.item_id}:${event.summary_index}`, openaiMetadata({ itemId: event.item_id }))
-                : state.lifecycle,
-            reasoningItems: {
-                ...state.reasoningItems,
-                [event.item_id]: {
-                    ...item,
-                    summaryParts: {
-                        ...item.summaryParts,
-                        [event.summary_index]: state.store !== false ? "concluded" : "can-conclude",
-                    },
-                },
-            },
-        },
-        events,
-    ];
-};
-const onFunctionCallArgumentsDelta = Effect.fn("OpenAIResponses.onFunctionCallArgumentsDelta")(function* (state, event) {
-    if (!event.item_id || !event.delta)
-        return [state, NO_EVENTS];
-    const result = ToolStream.appendExisting(ADAPTER, state.tools, event.item_id, event.delta, "OpenAI Responses tool argument delta is missing its tool call");
-    if (ToolStream.isError(result))
-        return yield* result;
-    const events = [];
-    const lifecycle = result.events.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle;
-    events.push(...result.events);
-    return [{ ...state, lifecycle, tools: result.tools }, events];
-});
-const onOutputItemDone = Effect.fn("OpenAIResponses.onOutputItemDone")(function* (state, event) {
-    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 === "function_call") {
-        if (!item.id || !item.call_id || !item.name)
-            return [state, NO_EVENTS];
-        const tools = state.tools[item.id]
-            ? state.tools
-            : ToolStream.start(state.tools, item.id, { id: item.call_id, name: item.name });
-        const result = item.arguments === undefined
-            ? yield* ToolStream.finish(ADAPTER, tools, item.id)
-            : yield* ToolStream.finishWithInput(ADAPTER, tools, item.id, item.arguments);
-        const events = [];
-        const resultEvents = result.events ?? [];
-        const lifecycle = resultEvents.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle;
-        events.push(...resultEvents);
-        return [
-            {
-                ...state,
-                lifecycle,
-                hasFunctionCall: resultEvents.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
-                    state.hasFunctionCall,
-                tools: result.tools,
-            },
-            events,
-        ];
-    }
-    if (isHostedToolItem(item)) {
-        const events = [];
-        const lifecycle = Lifecycle.stepStart(state.lifecycle, events);
-        events.push(...(yield* hostedToolEvents(item)));
-        return [{ ...state, lifecycle }, events];
-    }
-    if (isReasoningItem(item)) {
-        const events = [];
-        const providerMetadata = reasoningMetadata(item);
-        const reasoningItem = state.reasoningItems[item.id];
-        if (reasoningItem) {
-            const lifecycle = Object.entries(reasoningItem.summaryParts)
-                .filter((entry) => entry[1] === "active" || entry[1] === "can-conclude")
-                .reduce((lifecycle, entry) => Lifecycle.reasoningEnd(lifecycle, events, `${item.id}:${entry[0]}`, providerMetadata), state.lifecycle);
-            const { [item.id]: _removed, ...reasoningItems } = state.reasoningItems;
-            return [{ ...state, lifecycle, reasoningItems }, events];
-        }
-        if (!state.lifecycle.reasoning.has(item.id)) {
-            const lifecycle = Lifecycle.stepStart(state.lifecycle, events);
-            events.push(LLMEvent.reasoningStart({ id: item.id, providerMetadata }));
-            events.push(LLMEvent.reasoningEnd({ id: item.id, providerMetadata }));
-            return [{ ...state, lifecycle }, events];
-        }
-        return [
-            { ...state, lifecycle: Lifecycle.reasoningEnd(state.lifecycle, events, item.id, providerMetadata) },
-            events,
-        ];
-    }
-    return [state, NO_EVENTS];
-});
-const onResponseFinish = (state, event) => {
-    const events = [];
-    const lifecycle = Lifecycle.finish(state.lifecycle, events, {
-        reason: {
-            normalized: mapFinishReason(event, state.hasFunctionCall),
-            raw: event.response?.incomplete_details?.reason,
-        },
-        usage: mapUsage(event.response?.usage),
-        providerMetadata: event.response?.id || event.response?.service_tier
-            ? openaiMetadata({
-                responseId: event.response.id,
-                serviceTier: event.response.service_tier,
-            })
-            : undefined,
-    });
+    events.push(LLMEvent.toolCall({
+        id: item.id,
+        name: tool.name,
+        input: tool.input(item),
+        providerExecuted: true,
+        providerMetadata,
+    }), LLMEvent.toolResult({
+        id: item.id,
+        name: tool.name,
+        result: yield* hostedToolResult(item),
+        providerExecuted: true,
+        providerMetadata,
+    }));
     return [{ ...state, lifecycle }, events];
-};
-// Build a single human-readable message from whatever the provider supplied.
-// When both code and message are present, prefix the code so consumers see
-// the failure mode (e.g. `rate_limit_exceeded: Slow down`) instead of just
-// the bare message — production rate limits and context-length failures used
-// to be indistinguishable from generic stream drops.
-const providerErrorMessage = (event, fallback) => {
-    const nested = event.error ?? event.response?.error ?? undefined;
-    const message = event.message || nested?.message || undefined;
-    const code = event.code || nested?.code || undefined;
-    if (message && code)
-        return `${code}: ${message}`;
-    return message || code || fallback;
-};
-const providerError = (event, fallback) => {
-    const code = event.code || event.error?.code || event.response?.error?.code || undefined;
-    const message = providerErrorMessage(event, fallback);
-    return new LLMError({
-        module: ADAPTER,
-        method: "stream",
-        reason: classifyProviderFailure({ message, code }),
-    });
-};
+});
 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_text.delta" ||
-        event.type === "response.reasoning_summary.delta" ||
-        event.type === "response.reasoning_summary_text.delta")
-        return Effect.succeed(onReasoningDelta(state, event));
-    if (event.type === "response.reasoning_text.done" ||
-        event.type === "response.reasoning_summary.done" ||
-        event.type === "response.reasoning_summary_text.done")
-        return Effect.succeed(onReasoningDone(state, event));
-    if (event.type === "response.reasoning_summary_part.added")
-        return Effect.succeed(onReasoningSummaryPartAdded(state, event));
-    if (event.type === "response.reasoning_summary_part.done")
-        return Effect.succeed(onReasoningSummaryPartDone(state, event));
-    if (event.type === "response.output_item.added")
-        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")
-        return onOutputItemDone(state, event);
-    if (event.type === "response.completed" || event.type === "response.incomplete")
-        return Effect.succeed(onResponseFinish(state, event));
-    if (event.type === "response.failed")
-        return providerError(event, "OpenAI Responses response failed");
-    if (event.type === "error")
-        return providerError(event, "OpenAI Responses stream error");
-    return Effect.succeed([state, NO_EVENTS]);
+    if (event.type === "response.reasoning_text.delta" || event.type === "response.reasoning_summary.delta")
+        return Effect.succeed(OpenResponses.onReasoningDelta(state, event));
+    if (event.type === "response.reasoning_text.done" || event.type === "response.reasoning_summary.done")
+        return Effect.succeed(OpenResponses.onReasoningDone(state, event));
+    if (event.type === "response.output_item.done" && event.item && isHostedToolItem(event.item))
+        return onHostedToolDone(state, event.item);
+    return OpenResponses.step(state, event);
 };
-// =============================================================================
-// Protocol And OpenAI Route
-// =============================================================================
-/**
- * The OpenAI Responses protocol — request body construction, body schema, and
- * the streaming-event state machine. Used by native OpenAI and (once
- * registered) Azure OpenAI Responses.
- */
 export const protocol = Protocol.make({
     id: ADAPTER,
     body: {
@@ -871,16 +165,10 @@ export const protocol = Protocol.make({
         from: fromRequest,
     },
     stream: {
-        event: Protocol.jsonEvent(OpenAIResponsesEvent),
-        initial: (request) => ({
-            hasFunctionCall: false,
-            tools: ToolStream.empty(),
-            lifecycle: Lifecycle.initial(),
-            reasoningItems: {},
-            store: OpenAIOptions.store(request),
-        }),
+        event: OpenResponses.protocol.stream.event,
+        initial: (request) => OpenResponses.initial(request, extension),
         step,
-        terminal: (event) => TERMINAL_TYPES.has(event.type),
+        terminal: OpenResponses.terminal,
     },
 });
 const endpoint = Endpoint.path(PATH, { baseURL: DEFAULT_BASE_URL });