@opencode-ai/ai 0.0.0-beta-17492

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

@@ -0,0 +1,107 @@
+import { Route, type RouteRoutedLanguageModelInput } from "../route/client.js";
+export type OpenAICompatibleChatLanguageModelInput = RouteRoutedLanguageModelInput;
+/**
+ * Route for non-OpenAI providers that expose an OpenAI Chat-compatible
+ * `/chat/completions` endpoint. Reuses `OpenAIChat.protocol` end-to-end and
+ * overrides only the route id so providers can be resolved per-family without
+ * colliding with native OpenAI. Provider helpers configure the route endpoint
+ * before model selection.
+ */
+export declare const route: Route<{
+    readonly model: string;
+    readonly messages: readonly ({
+        readonly role: "system";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly role: "user";
+        readonly content: string | readonly ({
+            readonly type: "text";
+            readonly text: string;
+            readonly cache_control?: {
+                readonly type: "ephemeral";
+                readonly ttl?: string | undefined;
+            } | undefined;
+        } | {
+            readonly type: "image_url";
+            readonly image_url: {
+                readonly url: string;
+            };
+        })[];
+    } | {
+        readonly [x: string]: unknown;
+        readonly content: string | null;
+        readonly role: "assistant";
+        readonly reasoning?: string | undefined;
+        readonly reasoning_content?: string | undefined;
+        readonly reasoning_text?: string | undefined;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+        readonly tool_calls?: readonly {
+            readonly id: string;
+            readonly type: "function";
+            readonly function: {
+                readonly name: string;
+                readonly arguments: string;
+            };
+        }[] | undefined;
+        readonly reasoning_details?: unknown;
+    } | {
+        readonly content: string;
+        readonly role: "tool";
+        readonly tool_call_id: string;
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+    })[];
+    readonly stream: true;
+    readonly stop?: readonly string[] | undefined;
+    readonly max_completion_tokens?: number | undefined;
+    readonly max_tokens?: number | undefined;
+    readonly tools?: readonly {
+        readonly function: {
+            readonly name: string;
+            readonly description: string;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
+        };
+        readonly type: "function";
+        readonly cache_control?: {
+            readonly type: "ephemeral";
+            readonly ttl?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    readonly temperature?: number | undefined;
+    readonly seed?: number | undefined;
+    readonly tool_choice?: "required" | "none" | "auto" | {
+        readonly type: "function";
+        readonly function: {
+            readonly name: string;
+        };
+    } | undefined;
+    readonly top_p?: number | undefined;
+    readonly store?: boolean | undefined;
+    readonly stream_options?: {
+        readonly include_usage: boolean;
+    } | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly reasoning_effort?: string | undefined;
+    readonly frequency_penalty?: number | undefined;
+    readonly presence_penalty?: number | undefined;
+}, import("../route/transport/http.js").HttpPrepared<string>>;
+export * as OpenAICompatibleChat from "./openai-compatible-chat.js";

package/dist/protocols/openai-compatible-chat.js

@@ -0,0 +1,20 @@
+import { Route } from "../route/client.js";
+import { Endpoint } from "../route/endpoint.js";
+import { Framing } from "../route/framing.js";
+import * as OpenAIChat from "./openai-chat.js";
+const ADAPTER = "openai-compatible-chat";
+/**
+ * Route for non-OpenAI providers that expose an OpenAI Chat-compatible
+ * `/chat/completions` endpoint. Reuses `OpenAIChat.protocol` end-to-end and
+ * overrides only the route id so providers can be resolved per-family without
+ * colliding with native OpenAI. Provider helpers configure the route endpoint
+ * before model selection.
+ */
+export const route = Route.make({
+    id: ADAPTER,
+    providerMetadataKey: "openai",
+    protocol: OpenAIChat.protocol,
+    endpoint: Endpoint.path("/chat/completions"),
+    framing: Framing.sse,
+});
+export * as OpenAICompatibleChat from "./openai-compatible-chat.js";

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

@@ -0,0 +1,96 @@
+import { Route, type RouteRoutedLanguageModelInput } from "../route/client.js";
+export type OpenAICompatibleResponsesLanguageModelInput = RouteRoutedLanguageModelInput;
+/**
+ * Deployment adapter for providers that expose an Open Responses-compatible
+ * `/responses` endpoint. Provider helpers configure identity, endpoint, and
+ * auth while the semantic protocol remains provider-neutral.
+ */
+export declare const route: Route<{
+    readonly input: readonly ({
+        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: "item_reference";
+        readonly id: string;
+    } | {
+        readonly role: "system";
+        readonly content: string;
+    } | {
+        readonly role: "user";
+        readonly content: readonly ({
+            readonly type: "input_image";
+            readonly image_url: string;
+        } | {
+            readonly type: "input_file";
+            readonly filename: string;
+            readonly file_data: string;
+            readonly mime_type?: string | undefined;
+        } | {
+            readonly type: "input_text";
+            readonly text: string;
+        })[];
+    } | {
+        readonly content: readonly {
+            readonly type: "output_text";
+            readonly text: string;
+        }[];
+        readonly role: "assistant";
+        readonly phase?: "commentary" | "final_answer" | undefined;
+    } | {
+        readonly type: "function_call";
+        readonly call_id: string;
+        readonly name: string;
+        readonly arguments: string;
+    } | {
+        readonly type: "function_call_output";
+        readonly call_id: string;
+        readonly output: string | readonly ({
+            readonly type: "input_image";
+            readonly image_url: string;
+        } | {
+            readonly type: "input_file";
+            readonly filename: string;
+            readonly file_data: string;
+            readonly mime_type?: string | undefined;
+        } | {
+            readonly type: "input_text";
+            readonly text: string;
+        })[];
+    })[];
+    readonly model: string;
+    readonly stream: true;
+    readonly instructions?: string | undefined;
+    readonly reasoning?: {
+        readonly summary?: "auto" | "concise" | "detailed" | undefined;
+        readonly effort?: string | undefined;
+    } | undefined;
+    readonly tools?: readonly {
+        readonly type: "function";
+        readonly description: string;
+        readonly name: string;
+        readonly parameters: {
+            readonly [x: string]: unknown;
+        };
+        readonly strict?: boolean | undefined;
+    }[] | undefined;
+    readonly text?: {
+        readonly verbosity?: "low" | "medium" | "high" | undefined;
+    } | undefined;
+    readonly temperature?: number | undefined;
+    readonly tool_choice?: "required" | "none" | "auto" | {
+        readonly type: "function";
+        readonly name: string;
+    } | undefined;
+    readonly top_p?: number | undefined;
+    readonly include?: readonly ("file_search_call.results" | "web_search_call.results" | "web_search_call.action.sources" | "message.input_image.image_url" | "computer_call_output.output.image_url" | "code_interpreter_call.outputs" | "reasoning.encrypted_content" | "message.output_text.logprobs")[] | undefined;
+    readonly store?: boolean | undefined;
+    readonly prompt_cache_key?: string | undefined;
+    readonly service_tier?: "default" | "auto" | "flex" | "priority" | undefined;
+    readonly max_output_tokens?: number | undefined;
+}, import("../route/transport/http.js").HttpPrepared<string>>;
+export * as OpenAICompatibleResponses from "./openai-compatible-responses.js";

package/dist/protocols/openai-compatible-responses.js

@@ -0,0 +1,17 @@
+import { Route } from "../route/client.js";
+import { Endpoint } from "../route/endpoint.js";
+import { OpenResponses } from "./open-responses.js";
+const ADAPTER = "openai-compatible-responses";
+/**
+ * Deployment adapter for providers that expose an Open Responses-compatible
+ * `/responses` endpoint. Provider helpers configure identity, endpoint, and
+ * auth while the semantic protocol remains provider-neutral.
+ */
+export const route = Route.make({
+    id: ADAPTER,
+    providerMetadataKey: "openresponses",
+    protocol: OpenResponses.protocol,
+    endpoint: Endpoint.path(OpenResponses.PATH),
+    transport: OpenResponses.httpTransport,
+});
+export * as OpenAICompatibleResponses from "./openai-compatible-responses.js";

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

@@ -0,0 +1,32 @@
+import { ImageModel, type ImageInput } from "../image.js";
+import { type Definition as AuthDefinition } from "../route/auth.js";
+import { type HttpOptions } from "../schema/index.js";
+export declare const DEFAULT_BASE_URL = "https://api.openai.com/v1";
+export declare const PATH = "/images/generations";
+export declare const EDIT_PATH = "/images/edits";
+export type OpenAIImageString<Known extends string> = Known | (string & {});
+export type OpenAIImageOptions = {
+    readonly mask?: ImageInput;
+    readonly n?: number;
+    readonly size?: OpenAIImageString<"auto" | "256x256" | "512x512" | "1024x1024" | "1536x1024" | "1024x1536" | "1792x1024" | "1024x1792">;
+    readonly quality?: OpenAIImageString<"auto" | "low" | "medium" | "high" | "standard" | "hd">;
+    readonly background?: OpenAIImageString<"auto" | "opaque" | "transparent">;
+    readonly moderation?: OpenAIImageString<"auto" | "low">;
+    readonly outputFormat?: OpenAIImageString<"png" | "jpeg" | "webp">;
+    readonly outputCompression?: number;
+} & Record<string, unknown>;
+export type OpenAIImageBody = Record<string, unknown> & {
+    readonly model: string;
+    readonly prompt: string;
+};
+export interface ModelInput {
+    readonly id: string;
+    readonly auth: AuthDefinition;
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions;
+}
+export declare const model: (input: ModelInput) => ImageModel<OpenAIImageOptions>;
+export declare const OpenAIImages: {
+    readonly model: (input: ModelInput) => ImageModel<OpenAIImageOptions>;
+};

package/dist/protocols/openai-images.js

@@ -0,0 +1,188 @@
+import { Effect, Encoding, Schema } from "effect";
+import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { ImageModel, GeneratedImage, ImageResponse, } from "../image.js";
+import { Auth } from "../route/auth.js";
+import { InvalidProviderOutputReason, AIError, Usage, mergeHttpOptions, mergeJsonRecords, } from "../schema/index.js";
+import { ProviderShared } from "./shared.js";
+import { ImageInputs } from "./utils/image-input.js";
+import { OpenAIImage } from "./utils/openai-image.js";
+const ADAPTER = "openai-images";
+export const DEFAULT_BASE_URL = "https://api.openai.com/v1";
+export const PATH = "/images/generations";
+export const EDIT_PATH = "/images/edits";
+const OpenAIImageResponse = Schema.Struct({
+    data: Schema.Array(Schema.Struct({
+        b64_json: Schema.optional(Schema.String),
+        url: Schema.optional(Schema.String),
+        revised_prompt: Schema.optional(Schema.String),
+    })),
+    output_format: Schema.optional(Schema.String),
+    usage: Schema.optional(Schema.Struct({
+        input_tokens: Schema.optional(Schema.Number),
+        output_tokens: Schema.optional(Schema.Number),
+        total_tokens: Schema.optional(Schema.Number),
+        input_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+        output_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    })),
+});
+const nativeOptions = (options) => {
+    if (!options)
+        return undefined;
+    const { mask: _, outputFormat, outputCompression, ...native } = options;
+    return {
+        output_format: outputFormat,
+        output_compression: outputCompression,
+        ...native,
+    };
+};
+const invalidOutput = (message) => new AIError({
+    module: ADAPTER,
+    method: "generate",
+    reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),
+});
+const applyQuery = (url, query) => {
+    if (!query)
+        return url;
+    const next = new URL(url);
+    Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value));
+    return next.toString();
+};
+export const model = (input) => {
+    const route = {
+        id: ADAPTER,
+        generate: Effect.fn("OpenAIImages.generate")(function* (request, execute) {
+            const mask = request.options?.mask;
+            if (mask !== undefined && (request.images?.length ?? 0) === 0)
+                return yield* ImageInputs.invalid(ADAPTER, "An OpenAI image mask requires at least one input image");
+            const http = mergeHttpOptions(request.model.http, request.http);
+            const sourceImages = request.images ?? [];
+            const multipartImages = yield* Effect.forEach(sourceImages, (image) => {
+                if (image.type === "bytes")
+                    return Effect.succeed({ data: image.data, mediaType: image.mediaType });
+                if (image.type === "url")
+                    return ImageInputs.decodeDataUrl(image.url, ADAPTER);
+                return Effect.succeed(undefined);
+            });
+            const multipartMask = mask === undefined
+                ? undefined
+                : mask.type === "bytes"
+                    ? { data: mask.data, mediaType: mask.mediaType }
+                    : mask.type === "url"
+                        ? yield* ImageInputs.decodeDataUrl(mask.url, ADAPTER)
+                        : undefined;
+            const useMultipart = sourceImages.length > 0 &&
+                multipartImages.every((image) => image !== undefined) &&
+                (mask === undefined || multipartMask !== undefined);
+            const path = sourceImages.length === 0 ? PATH : EDIT_PATH;
+            const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${path}`, http?.query);
+            if (useMultipart) {
+                const form = new FormData();
+                form.append("model", request.model.id);
+                form.append("prompt", request.prompt);
+                Object.entries(mergeJsonRecords(nativeOptions(request.options), http?.body) ?? {}).forEach(([key, value]) => {
+                    if (["model", "prompt", "image", "image[]", "images", "mask"].includes(key))
+                        return;
+                    form.append(key, typeof value === "string" ? value : ProviderShared.encodeJson(value));
+                });
+                multipartImages.forEach((image, index) => {
+                    if (image === undefined)
+                        return;
+                    form.append("image[]", imageBlob(image.data, image.mediaType), `image-${index}`);
+                });
+                if (multipartMask !== undefined)
+                    form.append("mask", imageBlob(multipartMask.data, multipartMask.mediaType), "mask");
+                const headers = yield* Auth.toEffect(input.auth)({
+                    request,
+                    method: "POST",
+                    url,
+                    body: "[multipart/form-data]",
+                    headers: Headers.remove(Headers.fromInput({ ...input.headers, ...http?.headers }), "content-type"),
+                });
+                const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyFormData(form)));
+                return yield* parseResponse(response, request.options, http?.body);
+            }
+            const references = sourceImages.map((image) => {
+                if (image.type === "bytes")
+                    return { image_url: ImageInputs.dataUrl(image) };
+                if (image.type === "url")
+                    return { image_url: image.url };
+                if (image.type === "file-id")
+                    return { file_id: image.id };
+                return undefined;
+            });
+            if (references.some((image) => image === undefined))
+                return yield* ImageInputs.invalid(ADAPTER, "OpenAI Images accepts image URLs, data URLs, bytes, and file IDs");
+            const maskReference = mask === undefined
+                ? undefined
+                : mask.type === "bytes"
+                    ? { image_url: ImageInputs.dataUrl(mask) }
+                    : mask.type === "url"
+                        ? { image_url: mask.url }
+                        : mask.type === "file-id"
+                            ? { file_id: mask.id }
+                            : undefined;
+            if (mask !== undefined && maskReference === undefined)
+                return yield* ImageInputs.invalid(ADAPTER, "OpenAI Images accepts masks as URLs, data URLs, bytes, or file IDs");
+            const requestBody = mergeJsonRecords({
+                model: request.model.id,
+                prompt: request.prompt,
+                images: references.length === 0 ? undefined : references,
+                mask: maskReference,
+            }, nativeOptions(request.options), http?.body);
+            const text = ProviderShared.encodeJson(requestBody);
+            const headers = yield* Auth.toEffect(input.auth)({
+                request,
+                method: "POST",
+                url,
+                body: text,
+                headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
+            });
+            const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(text, "application/json")));
+            return yield* parseResponse(response, request.options, http?.body);
+        }),
+    };
+    return ImageModel.make({ id: input.id, provider: "openai", route, http: input.http });
+};
+const parseResponse = Effect.fn("OpenAIImages.parseResponse")(function* (response, options, overlay) {
+    const payload = yield* response.json.pipe(Effect.mapError(() => invalidOutput("Failed to read the OpenAI Images response")));
+    const decoded = yield* Schema.decodeUnknownEffect(OpenAIImageResponse)(payload).pipe(Effect.mapError(() => invalidOutput("OpenAI Images returned an invalid response")));
+    const requestBody = mergeJsonRecords(nativeOptions(options), overlay);
+    const format = decoded.output_format ?? (typeof requestBody?.output_format === "string" ? requestBody.output_format : "png");
+    const images = yield* Effect.forEach(decoded.data, (item, index) => {
+        if (item.b64_json)
+            return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(Effect.mapError(() => invalidOutput(`OpenAI Images result ${index} contains invalid base64 data`)), Effect.map((data) => new GeneratedImage({
+                mediaType: `image/${format}`,
+                data,
+                providerMetadata: item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
+            })));
+        if (item.url)
+            return Effect.succeed(new GeneratedImage({
+                mediaType: `image/${format}`,
+                data: item.url,
+                providerMetadata: item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
+            }));
+        return Effect.fail(invalidOutput(`OpenAI Images result ${index} has neither image data nor a URL`));
+    });
+    if (images.length === 0)
+        return yield* invalidOutput("OpenAI Images returned no images");
+    return new ImageResponse({
+        images,
+        usage: decoded.usage === undefined
+            ? undefined
+            : new Usage({
+                inputTokens: decoded.usage.input_tokens,
+                outputTokens: decoded.usage.output_tokens,
+                totalTokens: decoded.usage.total_tokens,
+                providerMetadata: { openai: decoded.usage },
+            }),
+        providerMetadata: { openai: { outputFormat: format } },
+    });
+});
+const imageBlob = (data, mediaType) => {
+    const buffer = new ArrayBuffer(data.byteLength);
+    new Uint8Array(buffer).set(data);
+    return new Blob([buffer], { type: mediaType });
+};
+export const OpenAIImages = {
+    model,
+};

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

@@ -0,0 +1,12 @@
+import type { WebSocketChannelDriver } from "../route/transport/index.js";
+export interface DriverInput {
+    readonly id: string;
+    readonly name: string;
+    readonly request: Readonly<Record<string, unknown>>;
+    readonly message: string;
+    readonly base: WebSocketChannelDriver;
+}
+export declare const driver: (input: DriverInput) => WebSocketChannelDriver;
+export declare const OpenAIResponsesChannel: {
+    readonly driver: (input: DriverInput) => WebSocketChannelDriver;
+};

package/dist/protocols/openai-responses-channel.js

@@ -0,0 +1,142 @@
+import { AIError, TransportReason } from "../schema/index.js";
+import { Effect, Option, Schema } from "effect";
+import * as ProviderShared from "./shared.js";
+import { OpenResponses } from "./open-responses.js";
+const PROTOCOL = "openai-responses.websocket.v1";
+const VERSION = 1;
+const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event);
+const checkpointValue = (checkpoint) => {
+    if (checkpoint?.protocol !== PROTOCOL || !ProviderShared.isRecord(checkpoint.value))
+        return undefined;
+    if (checkpoint.value.version !== VERSION)
+        return undefined;
+    if (typeof checkpoint.value.responseID !== "string" || checkpoint.value.responseID.trim().length === 0)
+        return undefined;
+    if (!ProviderShared.isRecord(checkpoint.value.request) || !Array.isArray(checkpoint.value.output))
+        return undefined;
+    return {
+        version: VERSION,
+        responseID: checkpoint.value.responseID,
+        request: checkpoint.value.request,
+        output: checkpoint.value.output,
+    };
+};
+const canonical = (value) => {
+    if (value === undefined)
+        return "undefined";
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    if (!ProviderShared.isRecord(value))
+        return ProviderShared.encodeJson(value);
+    return `{${Object.keys(value)
+        .sort()
+        .map((key) => `${ProviderShared.encodeJson(key)}:${canonical(value[key])}`)
+        .join(",")}}`;
+};
+const json = (value) => {
+    if (typeof value !== "string")
+        return value;
+    return Option.getOrElse(Schema.decodeUnknownOption(ProviderShared.Json)(value), () => value);
+};
+const comparable = (value) => {
+    if (!ProviderShared.isRecord(value))
+        return value;
+    if (value.type === "message" && value.role === "assistant")
+        return {
+            role: "assistant",
+            content: value.content,
+            ...(value.phase === undefined ? {} : { phase: value.phase }),
+        };
+    if (value.type === "function_call")
+        return {
+            type: value.type,
+            call_id: value.call_id,
+            name: value.name,
+            arguments: json(value.arguments),
+        };
+    if (value.type === "reasoning")
+        return {
+            type: value.type,
+            summary: value.summary,
+            encrypted_content: value.encrypted_content,
+        };
+    return value;
+};
+const invariant = (request) => {
+    const { type: _type, input: _input, previous_response_id: _previousResponseID, ...rest } = request;
+    return rest;
+};
+const incremental = (request, checkpoint) => {
+    const input = request.input;
+    const previousInput = checkpoint.request.input;
+    if (!Array.isArray(input) || !Array.isArray(previousInput))
+        return undefined;
+    if (canonical(invariant(request)) !== canonical(invariant(checkpoint.request)))
+        return undefined;
+    const baseline = [...previousInput, ...checkpoint.output];
+    if (input.length <= baseline.length)
+        return undefined;
+    if (!baseline.every((item, index) => canonical(comparable(item)) === canonical(comparable(input[index]))))
+        return undefined;
+    return input.slice(baseline.length);
+};
+const code = (event) => event.code || event.error?.code || event.response?.error?.code || undefined;
+const rejected = (input, observation, recovery) => ({
+    type: "rejected",
+    recovery,
+    error: new AIError({
+        module: input.id,
+        method: "stream",
+        reason: new TransportReason({
+            message: observation.error.message,
+            transport: "websocket",
+            operation: "read",
+            phase: "receive",
+            delivery: "rejected",
+            recovery,
+        }),
+    }),
+});
+export const driver = (input) => {
+    const { previous_response_id: _previousResponseID, ...request } = input.request;
+    let output = [];
+    return {
+        create: (checkpoint) => Effect.sync(() => {
+            output = [];
+            const previous = checkpointValue(checkpoint);
+            const delta = previous ? incremental(request, previous) : undefined;
+            if (!previous || !delta)
+                return { message: ProviderShared.encodeJson(request), mode: "full" };
+            return {
+                message: ProviderShared.encodeJson({ ...request, input: delta, previous_response_id: previous.responseID }),
+                mode: "incremental",
+            };
+        }),
+        observe: (create, frame) => Effect.gen(function* () {
+            const event = yield* decodeEvent(frame).pipe(Effect.mapError(() => ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame)));
+            const observation = yield* input.base.observe(create, frame);
+            if (event.type === "response.output_item.done" && event.item)
+                output.push(event.item);
+            if (observation.type === "provider-failure") {
+                const rejection = code(event);
+                if (rejection === "previous_response_not_found")
+                    return rejected(input, observation, "retry-full");
+                if (rejection === "websocket_connection_limit_reached")
+                    return rejected(input, observation, "rotate-and-retry-full");
+            }
+            if (observation.type !== "completed")
+                return observation;
+            const responseID = event.response?.id;
+            if (!responseID || responseID.trim().length === 0)
+                return observation;
+            return {
+                ...observation,
+                checkpoint: {
+                    protocol: PROTOCOL,
+                    value: { version: VERSION, responseID, request, output: output.slice() },
+                },
+            };
+        }),
+    };
+};
+export const OpenAIResponsesChannel = { driver };