@opencode/ai 0.0.0-reserved → 2.0.0

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

@@ -0,0 +1,473 @@
+import { Schema } from "effect";
+import { Protocol } from "../route/protocol.js";
+import { HttpTransport } from "../route/transport/index.js";
+import { OpenResponses } from "./open-responses.js";
+export declare const WebSearch: Schema.Struct<{
+    readonly type: Schema.Literal<"web_search">;
+    readonly search_context_size: Schema.optional<Schema.String>;
+    readonly user_location: Schema.optional<Schema.Struct<{
+        readonly type: Schema.Literal<"approximate">;
+        readonly city: Schema.optional<Schema.String>;
+        readonly region: Schema.optional<Schema.String>;
+        readonly country: Schema.optional<Schema.String>;
+        readonly timezone: Schema.optional<Schema.String>;
+    }>>;
+}>;
+export declare const ImageGeneration: Schema.Struct<{
+    readonly type: Schema.Literal<"image_generation">;
+    readonly size: Schema.optional<Schema.String>;
+    readonly output_format: Schema.optional<Schema.String>;
+    readonly reasoning_strength: Schema.optional<Schema.String>;
+    readonly enable_image_search: Schema.optional<Schema.Boolean>;
+    readonly enable_web_search: Schema.optional<Schema.Boolean>;
+    readonly enable_shell: Schema.optional<Schema.Boolean>;
+}>;
+interface ParserState extends OpenResponses.ParserState {
+    readonly completedItems: ReadonlySet<string>;
+}
+export declare const protocol: Protocol<{
+    readonly input: readonly ({
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "web_search_call";
+        readonly status?: string | undefined;
+        readonly action?: {
+            readonly [x: string]: unknown;
+        } | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "file_search_call";
+        readonly status?: string | undefined;
+        readonly queries?: readonly string[] | undefined;
+        readonly results?: readonly {
+            readonly [x: string]: unknown;
+        }[] | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "code_interpreter_call";
+        readonly status?: string | undefined;
+        readonly code?: string | null | undefined;
+        readonly container_id?: string | null | undefined;
+        readonly outputs?: readonly {
+            readonly [x: string]: unknown;
+        }[] | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "mcp_call";
+        readonly status?: string | undefined;
+        readonly name?: string | undefined;
+        readonly output?: string | null | undefined;
+        readonly error?: unknown;
+        readonly arguments?: string | undefined;
+        readonly server_label?: string | undefined;
+    } | {
+        readonly type: "reasoning";
+        readonly summary: readonly {
+            readonly type: "summary_text";
+            readonly text: string;
+        }[];
+        readonly id?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
+    } | {
+        readonly type: "compaction";
+        readonly encrypted_content: string;
+        readonly id?: string | null | undefined;
+    } | {
+        readonly role: "system";
+        readonly content: string;
+    } | {
+        readonly role: "developer";
+        readonly content: string;
+    } | {
+        readonly content: readonly ({
+            readonly type: "input_image";
+            readonly image_url: string;
+            readonly detail?: string | undefined;
+        } | {
+            readonly type: "input_file";
+            readonly filename: string;
+            readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
+            readonly file_url?: string | undefined;
+        } | {
+            readonly type: "input_text";
+            readonly text: string;
+        })[];
+        readonly role: "user";
+        readonly id?: string | undefined;
+        readonly type?: "message" | undefined;
+        readonly status?: string | undefined;
+    } | {
+        readonly type: "message";
+        readonly content: readonly {
+            readonly type: "output_text";
+            readonly text: string;
+        }[];
+        readonly role: "assistant";
+        readonly id?: string | undefined;
+        readonly status?: string | undefined;
+        readonly phase?: "commentary" | "final_answer" | null | undefined;
+    } | {
+        readonly type: "function_call";
+        readonly name: string;
+        readonly arguments: string;
+        readonly call_id: string;
+        readonly id?: string | undefined;
+        readonly namespace?: string | undefined;
+    } | {
+        readonly type: "function_call_output";
+        readonly call_id: string;
+        readonly output: string | readonly ({
+            readonly type: "input_image";
+            readonly image_url: string;
+            readonly detail?: string | undefined;
+        } | {
+            readonly type: "input_file";
+            readonly filename: string;
+            readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
+            readonly file_url?: string | undefined;
+        } | {
+            readonly type: "input_text";
+            readonly text: string;
+        } | {
+            readonly type: "input_video";
+            readonly video_url: string;
+        })[];
+    } | {
+        readonly id: string;
+        readonly type: "image_generation_call";
+        readonly status?: string | undefined;
+        readonly error?: unknown;
+        readonly result?: string | null | undefined;
+        readonly output_format?: string | undefined;
+    })[];
+    readonly model: string;
+    readonly stream: true;
+    readonly metadata?: {
+        readonly [x: string]: string;
+    } | undefined;
+    readonly instructions?: string | undefined;
+    readonly reasoning?: {
+        readonly summary?: "auto" | "concise" | "detailed" | undefined;
+        readonly effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+    } | undefined;
+    readonly tools?: readonly ({
+        readonly type: "function";
+        readonly description: string;
+        readonly name: string;
+        readonly parameters: {
+            readonly [x: string]: unknown;
+        };
+        readonly strict?: boolean | undefined;
+    } | {
+        readonly type: "web_search";
+        readonly search_context_size?: string | undefined;
+        readonly user_location?: {
+            readonly type: "approximate";
+            readonly region?: string | undefined;
+            readonly city?: string | undefined;
+            readonly country?: string | undefined;
+            readonly timezone?: string | undefined;
+        } | undefined;
+    } | {
+        readonly type: "image_generation";
+        readonly size?: string | undefined;
+        readonly output_format?: string | undefined;
+        readonly reasoning_strength?: string | undefined;
+        readonly enable_image_search?: boolean | undefined;
+        readonly enable_web_search?: boolean | undefined;
+        readonly enable_shell?: boolean | undefined;
+    })[] | undefined;
+    readonly text?: {
+        readonly verbosity?: import("./utils/open-responses-options.js").TextVerbosity | undefined;
+    } | undefined;
+    readonly temperature?: number | undefined;
+    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
+    readonly tool_choice?: "required" | "auto" | "none" | {
+        readonly type: "function";
+        readonly name: string;
+    } | {
+        readonly type: "allowed_tools";
+        readonly mode: "required" | "auto" | "none";
+        readonly tools: readonly {
+            readonly type: "function";
+            readonly name: string;
+        }[];
+    } | undefined;
+    readonly top_p?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly parallel_tool_calls?: boolean | undefined;
+    readonly store?: boolean | undefined;
+    readonly include?: readonly import("./utils/open-responses-options.js").ResponseIncludable[] | undefined;
+    readonly truncation?: "auto" | "disabled" | undefined;
+    readonly stream_options?: {
+        readonly include_obfuscation?: boolean | undefined;
+    } | undefined;
+    readonly safety_identifier?: string | undefined;
+    readonly top_logprobs?: number | undefined;
+    readonly max_output_tokens?: number | undefined;
+    readonly max_tool_calls?: number | undefined;
+}, string, {
+    readonly [x: string]: unknown;
+    readonly type: string;
+    readonly status?: unknown;
+    readonly code?: string | null | undefined;
+    readonly message?: string | undefined;
+    readonly headers?: unknown;
+    readonly text?: string | undefined;
+    readonly error?: {
+        readonly type?: string | null | undefined;
+        readonly code?: string | null | undefined;
+        readonly message?: string | null | undefined;
+        readonly param?: string | null | undefined;
+    } | null | undefined;
+    readonly item?: {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id?: string | undefined;
+        readonly name?: string | undefined;
+        readonly namespace?: string | undefined;
+        readonly arguments?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
+        readonly call_id?: string | undefined;
+    } | null | undefined;
+    readonly delta?: string | undefined;
+    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 namespace?: 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;
+            readonly message?: string | null | undefined;
+            readonly param?: string | null | undefined;
+        } | null | undefined;
+        readonly usage?: {
+            readonly input_tokens?: number | undefined;
+            readonly output_tokens?: number | undefined;
+            readonly output_tokens_details?: {
+                readonly reasoning_tokens?: number | undefined;
+            } | null | undefined;
+            readonly total_tokens?: number | undefined;
+            readonly input_tokens_details?: {
+                readonly cached_tokens?: number | undefined;
+                readonly cache_write_tokens?: number | undefined;
+            } | null | undefined;
+        } | null | undefined;
+        readonly service_tier?: string | null | undefined;
+        readonly incomplete_details?: {
+            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<{
+    readonly input: readonly ({
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "web_search_call";
+        readonly status?: string | undefined;
+        readonly action?: {
+            readonly [x: string]: unknown;
+        } | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "file_search_call";
+        readonly status?: string | undefined;
+        readonly queries?: readonly string[] | undefined;
+        readonly results?: readonly {
+            readonly [x: string]: unknown;
+        }[] | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "code_interpreter_call";
+        readonly status?: string | undefined;
+        readonly code?: string | null | undefined;
+        readonly container_id?: string | null | undefined;
+        readonly outputs?: readonly {
+            readonly [x: string]: unknown;
+        }[] | null | undefined;
+    } | {
+        readonly [x: string]: unknown;
+        readonly id: string;
+        readonly type: "mcp_call";
+        readonly status?: string | undefined;
+        readonly name?: string | undefined;
+        readonly output?: string | null | undefined;
+        readonly error?: unknown;
+        readonly arguments?: string | undefined;
+        readonly server_label?: string | undefined;
+    } | {
+        readonly type: "reasoning";
+        readonly summary: readonly {
+            readonly type: "summary_text";
+            readonly text: string;
+        }[];
+        readonly id?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
+    } | {
+        readonly type: "compaction";
+        readonly encrypted_content: string;
+        readonly id?: string | null | undefined;
+    } | {
+        readonly role: "system";
+        readonly content: string;
+    } | {
+        readonly role: "developer";
+        readonly content: string;
+    } | {
+        readonly content: readonly ({
+            readonly type: "input_image";
+            readonly image_url: string;
+            readonly detail?: string | undefined;
+        } | {
+            readonly type: "input_file";
+            readonly filename: string;
+            readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
+            readonly file_url?: string | undefined;
+        } | {
+            readonly type: "input_text";
+            readonly text: string;
+        })[];
+        readonly role: "user";
+        readonly id?: string | undefined;
+        readonly type?: "message" | undefined;
+        readonly status?: string | undefined;
+    } | {
+        readonly type: "message";
+        readonly content: readonly {
+            readonly type: "output_text";
+            readonly text: string;
+        }[];
+        readonly role: "assistant";
+        readonly id?: string | undefined;
+        readonly status?: string | undefined;
+        readonly phase?: "commentary" | "final_answer" | null | undefined;
+    } | {
+        readonly type: "function_call";
+        readonly name: string;
+        readonly arguments: string;
+        readonly call_id: string;
+        readonly id?: string | undefined;
+        readonly namespace?: string | undefined;
+    } | {
+        readonly type: "function_call_output";
+        readonly call_id: string;
+        readonly output: string | readonly ({
+            readonly type: "input_image";
+            readonly image_url: string;
+            readonly detail?: string | undefined;
+        } | {
+            readonly type: "input_file";
+            readonly filename: string;
+            readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
+            readonly file_url?: string | undefined;
+        } | {
+            readonly type: "input_text";
+            readonly text: string;
+        } | {
+            readonly type: "input_video";
+            readonly video_url: string;
+        })[];
+    } | {
+        readonly id: string;
+        readonly type: "image_generation_call";
+        readonly status?: string | undefined;
+        readonly error?: unknown;
+        readonly result?: string | null | undefined;
+        readonly output_format?: string | undefined;
+    })[];
+    readonly model: string;
+    readonly stream: true;
+    readonly metadata?: {
+        readonly [x: string]: string;
+    } | undefined;
+    readonly instructions?: string | undefined;
+    readonly reasoning?: {
+        readonly summary?: "auto" | "concise" | "detailed" | undefined;
+        readonly effort?: import("./utils/open-responses-options.js").ReasoningEffort | undefined;
+    } | undefined;
+    readonly tools?: readonly ({
+        readonly type: "function";
+        readonly description: string;
+        readonly name: string;
+        readonly parameters: {
+            readonly [x: string]: unknown;
+        };
+        readonly strict?: boolean | undefined;
+    } | {
+        readonly type: "web_search";
+        readonly search_context_size?: string | undefined;
+        readonly user_location?: {
+            readonly type: "approximate";
+            readonly region?: string | undefined;
+            readonly city?: string | undefined;
+            readonly country?: string | undefined;
+            readonly timezone?: string | undefined;
+        } | undefined;
+    } | {
+        readonly type: "image_generation";
+        readonly size?: string | undefined;
+        readonly output_format?: string | undefined;
+        readonly reasoning_strength?: string | undefined;
+        readonly enable_image_search?: boolean | undefined;
+        readonly enable_web_search?: boolean | undefined;
+        readonly enable_shell?: boolean | undefined;
+    })[] | undefined;
+    readonly text?: {
+        readonly verbosity?: import("./utils/open-responses-options.js").TextVerbosity | undefined;
+    } | undefined;
+    readonly temperature?: number | undefined;
+    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
+    readonly tool_choice?: "required" | "auto" | "none" | {
+        readonly type: "function";
+        readonly name: string;
+    } | {
+        readonly type: "allowed_tools";
+        readonly mode: "required" | "auto" | "none";
+        readonly tools: readonly {
+            readonly type: "function";
+            readonly name: string;
+        }[];
+    } | undefined;
+    readonly top_p?: number | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly parallel_tool_calls?: boolean | undefined;
+    readonly store?: boolean | undefined;
+    readonly include?: readonly import("./utils/open-responses-options.js").ResponseIncludable[] | undefined;
+    readonly truncation?: "auto" | "disabled" | undefined;
+    readonly stream_options?: {
+        readonly include_obfuscation?: boolean | undefined;
+    } | undefined;
+    readonly safety_identifier?: string | undefined;
+    readonly top_logprobs?: number | undefined;
+    readonly max_output_tokens?: number | undefined;
+    readonly max_tool_calls?: number | undefined;
+}, string>;
+export * as MetaResponses from "./meta-responses.js";

package/dist/protocols/meta-responses.js

@@ -0,0 +1,173 @@
+import { Effect, Encoding, Schema } from "effect";
+import { Protocol } from "../route/protocol.js";
+import { HttpTransport } from "../route/transport/index.js";
+import { LLMEvent, LLMRequest, Message, ToolResultPart } from "../schema/index.js";
+import { OpenResponses } from "./open-responses.js";
+import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
+import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js";
+import { ToolSchemaProjection } from "./utils/tool-schema.js";
+import { MetaImage } from "./utils/meta-image.js";
+const ADAPTER = "meta-responses";
+const NAME = "Meta Responses";
+export const WebSearch = Schema.Struct({
+    type: Schema.Literal("web_search"),
+    search_context_size: Schema.optional(Schema.String),
+    user_location: Schema.optional(Schema.Struct({
+        type: Schema.Literal("approximate"),
+        city: Schema.optional(Schema.String),
+        region: Schema.optional(Schema.String),
+        country: Schema.optional(Schema.String),
+        timezone: Schema.optional(Schema.String),
+    })),
+});
+export const ImageGeneration = Schema.Struct({
+    type: Schema.Literal("image_generation"),
+    size: Schema.optional(Schema.String),
+    output_format: Schema.optional(Schema.String),
+    reasoning_strength: Schema.optional(Schema.String),
+    enable_image_search: Schema.optional(Schema.Boolean),
+    enable_web_search: Schema.optional(Schema.Boolean),
+    enable_shell: Schema.optional(Schema.Boolean),
+});
+const NativeTool = Schema.Union([WebSearch, ImageGeneration]);
+const ImageItem = Schema.Struct({
+    type: Schema.Literal("image_generation_call"),
+    id: Schema.String,
+    status: Schema.optional(Schema.String),
+    result: optionalNull(Schema.String),
+    output_format: Schema.optional(Schema.String),
+    error: Schema.optional(Schema.Unknown),
+});
+const Body = Schema.Struct({
+    ...OpenResponses.coreFields,
+    input: Schema.Array(Schema.Union([OpenResponses.InputItem, ImageItem])),
+    tools: optionalArray(Schema.Union([OpenResponses.Tool, NativeTool])),
+    stream: Schema.Literal(true),
+});
+const MessageAnnotations = Schema.Struct({
+    content: Schema.Array(Schema.Struct({ annotations: optionalArray(JsonObject) })),
+});
+const adapter = {
+    id: ADAPTER,
+    name: NAME,
+    restoreHostedToolItem: (item) => (Schema.is(ImageItem)(item) ? item : undefined),
+};
+const fromRequest = Effect.fn("MetaResponses.fromRequest")(function* (request) {
+    const key = request.model.route.providerMetadataKey ?? String(request.model.provider);
+    const projected = ProviderShared.flattenToolRequest(LLMRequest.update(request, {
+        messages: request.messages.map((message) => Message.make({
+            ...message,
+            content: message.content.map((part) => {
+                if (part.type !== "tool-result" ||
+                    !part.providerExecuted ||
+                    part.name !== "image_generation" ||
+                    part.result.type !== "content" ||
+                    part.providerMetadata?.[key]?.itemId !== part.id)
+                    return part;
+                // Meta's signed image ID carries edit state; replay the handle, not the image bytes as a user message.
+                return ToolResultPart.make({
+                    ...part,
+                    result: {
+                        type: "json",
+                        value: { type: "image_generation_call", id: part.id, status: "completed", result: null },
+                    },
+                });
+            }),
+        })),
+    }));
+    return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))({
+        ...(yield* OpenResponses.lowerConversation(projected.request, adapter)),
+        ...OpenResponses.lowerGeneration(request),
+        tools: projected.tools.length === 0
+            ? undefined
+            : yield* Effect.forEach(projected.tools, (tool) => Effect.gen(function* () {
+                if (tool.native === undefined)
+                    return yield* OpenResponses.lowerTool(NAME, tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, request.model.compatibility?.toolSchema));
+                return yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(NativeTool))(tool.native.meta);
+            })),
+        tool_choice: OpenResponses.allowedToolChoice(request) ??
+            (request.toolChoice ? yield* OpenResponses.lowerToolChoice(NAME, request.toolChoice) : undefined),
+    });
+});
+const HOSTED_TOOLS = {
+    web_search_call: { name: "web_search", input: (item) => item.action ?? {} },
+    image_generation_call: {
+        name: "image_generation",
+        input: () => ({}),
+        result: Effect.fn("MetaResponses.imageResult")(function* (raw) {
+            const item = yield* Schema.decodeUnknownEffect(ImageItem)(raw).pipe(Effect.mapError((cause) => ProviderShared.eventError(ADAPTER, "Meta returned an invalid image item", ProviderShared.encodeJson(raw), cause)));
+            if (item.error !== undefined && item.error !== null)
+                return { type: "error", value: item.error };
+            if (!item.result)
+                return yield* ProviderShared.eventError(ADAPTER, "Meta returned an image without data", ProviderShared.encodeJson(raw));
+            const data = yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(Effect.mapError((cause) => ProviderShared.eventError(ADAPTER, "Meta returned invalid image base64", ProviderShared.encodeJson(raw), cause)));
+            const mime = MetaImage.mediaType(data, item.output_format);
+            return {
+                type: "content",
+                value: [{ type: "file", uri: `data:${mime};base64,${item.result}`, mime }],
+            };
+        }),
+    },
+};
+const onEvent = Effect.fn("MetaResponses.onEvent")(function* (state, input) {
+    const event = OpenResponses.normalize(state, input);
+    if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))
+        return yield* ResponsesHostedTools.onDone(state, event.item, HOSTED_TOOLS);
+    const result = yield* OpenResponses.step(state, event);
+    if (event.type !== "response.output_item.done" || event.item?.type !== "message")
+        return result;
+    const message = yield* Schema.decodeUnknownEffect(MessageAnnotations)(event.item).pipe(Effect.mapError((cause) => ProviderShared.eventError(ADAPTER, "Meta returned invalid message annotations", ProviderShared.encodeJson(event), cause)));
+    const annotations = message.content.flatMap((part) => part.annotations ?? []);
+    if (annotations.length === 0)
+        return result;
+    return [
+        result[0],
+        result[1].map((item) => LLMEvent.is.textEnd(item)
+            ? LLMEvent.textEnd({
+                ...item,
+                providerMetadata: {
+                    ...item.providerMetadata,
+                    [state.providerMetadataKey]: { ...item.providerMetadata?.[state.providerMetadataKey], annotations },
+                },
+            })
+            : item),
+    ];
+});
+const step = Effect.fn("MetaResponses.step")(function* (state, input) {
+    const completedItems = new Set(state.completedItems);
+    const event = OpenResponses.normalize(state, input);
+    if (event.type === "response.output_item.done" && event.item && completedItems.has(event.item.id))
+        return [state, []];
+    const events = [];
+    let current = state;
+    // Muse Image delivers its image and optional summary only in response.completed.
+    // Recover terminal-only items in order, without duplicating Spark's streamed items.
+    if (event.type === "response.completed") {
+        for (const [index, item] of (event.response?.output ?? []).entries()) {
+            const done = OpenResponses.normalize(current, { type: "response.output_item.done", item, output_index: index });
+            // Spark changes reasoning IDs in the terminal snapshot; output indices still identify the streamed items.
+            if (!done.item || completedItems.has(done.item.id) || completedItems.has(state.outputItems[index] ?? ""))
+                continue;
+            const result = yield* onEvent(current, done);
+            current = result[0];
+            events.push(...result[1]);
+            completedItems.add(done.item.id);
+        }
+    }
+    const result = yield* onEvent(current, event);
+    if (event.type === "response.output_item.done" && event.item)
+        completedItems.add(event.item.id);
+    return [{ ...result[0], completedItems }, [...events, ...result[1]]];
+});
+export const protocol = Protocol.make({
+    id: ADAPTER,
+    body: { schema: Body, from: fromRequest },
+    stream: {
+        event: OpenResponses.protocol.stream.event,
+        initial: (request) => ({ ...OpenResponses.initial(request, adapter), completedItems: new Set() }),
+        step,
+        terminal: OpenResponses.terminal,
+    },
+});
+export const httpTransport = HttpTransport.sseJson.with();
+export * as MetaResponses from "./meta-responses.js";