@opencode/ai 0.0.0-reserved → 2.0.0

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

@@ -0,0 +1,141 @@
+import { Effect, Schema, Stream } from "effect";
+import { Headers } from "effect/unstable/http";
+import { Framing } from "../route/framing.js";
+import { HttpTransport, WebSocketTransport, } from "../route/transport/index.js";
+import * as ProviderShared from "./shared.js";
+import { OpenResponses } from "./open-responses.js";
+import { OpenResponsesContinuation } from "./open-responses-continuation.js";
+const WebSocketResponseCreate = Schema.StructWithRest(Schema.Struct({ type: Schema.tag("response.create") }), [
+    Schema.Record(Schema.String, Schema.Unknown),
+]);
+const decodeMessage = ProviderShared.validateWith(Schema.decodeUnknownEffect(WebSocketResponseCreate));
+const encodeMessage = Schema.encodeSync(Schema.fromJsonString(WebSocketResponseCreate));
+const message = (body) => Effect.gen(function* () {
+    if (!ProviderShared.isRecord(body))
+        return yield* ProviderShared.invalidRequest("Open Responses WebSocket body must be a JSON object");
+    const { stream: _stream, stream_options: _streamOptions, background: _background, ...request } = body;
+    const decoded = yield* decodeMessage({ ...request, type: "response.create" });
+    return { request: decoded, message: encodeMessage(decoded) };
+});
+const driver = (options, body) => {
+    let responseID;
+    let terminal = false;
+    return {
+        create: () => Effect.sync(() => {
+            responseID = undefined;
+            terminal = false;
+            return { message: body, mode: "full" };
+        }),
+        observe: (_create, frame) => Effect.gen(function* () {
+            const event = yield* OpenResponses.decodeChannelEvent(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame, cause)));
+            if (terminal)
+                return yield* ProviderShared.eventError(options.id, `${options.name} emitted ${event.type} after a terminal event`, frame);
+            if (event.type === "error") {
+                terminal = true;
+                yield* OpenResponses.decodeKnownErrorEvent(event).pipe(Effect.mapError((cause) => ProviderShared.eventError(options.id, `${options.name} returned a malformed error event`, frame, cause)));
+                return {
+                    type: "provider-failure",
+                    error: OpenResponses.providerFailure(event, `${options.name} stream error`, frame),
+                };
+            }
+            if (event.type === "response.failed") {
+                terminal = true;
+                if (responseID && event.response?.id && event.response.id !== responseID)
+                    return yield* ProviderShared.eventError(options.id, `${options.name} response ID changed during execution`, frame);
+                return {
+                    type: "provider-failure",
+                    error: OpenResponses.providerFailure(event, `${options.name} response failed`, frame),
+                };
+            }
+            if (event.type === "response.created") {
+                const created = event.response?.id;
+                if (responseID)
+                    return yield* ProviderShared.eventError(options.id, `${options.name} emitted duplicate response.created`, frame);
+                if (!created)
+                    return yield* ProviderShared.eventError(options.id, `${options.name} response.created is missing response.id`, frame);
+                responseID = created;
+                return { type: "frame", frame };
+            }
+            // Keepalives and provider notifications carry no response state and may precede response.created.
+            if (!event.type.startsWith("response."))
+                return { type: "frame", frame };
+            if (!responseID)
+                return yield* ProviderShared.eventError(options.id, `${options.name} emitted ${event.type} before response.created`, frame);
+            if (event.response?.id && event.response.id !== responseID)
+                return yield* ProviderShared.eventError(options.id, `${options.name} response ID changed during execution`, frame);
+            if (event.type === "response.completed") {
+                terminal = true;
+                return { type: "completed", frame };
+            }
+            if (event.type === "response.incomplete") {
+                terminal = true;
+                return { type: "incomplete", frame };
+            }
+            return { type: "frame", frame };
+        }),
+    };
+};
+export const transport = (options) => {
+    const http = HttpTransport.sseJson.with();
+    return {
+        id: http.id,
+        prepare: (input) => Effect.gen(function* () {
+            const parts = yield* HttpTransport.jsonRequestParts(input);
+            const headers = Headers.remove(options.headers?.(parts.headers) ?? parts.headers, "content-length");
+            const channel = input.webSocket && (options.enabled?.(parts.url) ?? true)
+                ? yield* Effect.gen(function* () {
+                    const create = yield* message(parts.jsonBody);
+                    const base = driver(options, create.message);
+                    return {
+                        url: yield* WebSocketTransport.toWebSocketUrl(options.url?.(parts.url) ?? parts.url),
+                        headers,
+                        rotateAfterMs: options.rotateAfterMs,
+                        driver: OpenResponsesContinuation.driver({
+                            id: options.id,
+                            name: options.name,
+                            request: create.request,
+                            message: create.message,
+                            base,
+                            continuation: options.continuation,
+                        }),
+                    };
+                })
+                : undefined;
+            return {
+                http: {
+                    request: ProviderShared.jsonPost({ url: parts.url, body: parts.bodyText, headers: parts.headers }),
+                    framing: Framing.sse,
+                    middleware: input.middleware,
+                },
+                channel,
+            };
+        }),
+        execute: (prepared, request, runtime, executeOptions) => Effect.gen(function* () {
+            if (!executeOptions?.webSocket || !prepared.channel)
+                return yield* http.execute(prepared.http, request, runtime);
+            let fallbackHttp;
+            const exchange = {
+                id: request.id ?? "request",
+                connect: {
+                    url: prepared.channel.url,
+                    headers: prepared.channel.headers,
+                    rotateAfterMs: prepared.channel.rotateAfterMs,
+                },
+                fallback: () => Stream.unwrap(http.execute(prepared.http, request, runtime).pipe(Effect.map((execution) => {
+                    fallbackHttp = execution.http;
+                    return execution.frames;
+                }))),
+                driver: prepared.channel.driver,
+            };
+            const execution = yield* executeOptions.webSocket.execute(exchange);
+            return {
+                frames: execution.frames,
+                complete: execution.complete,
+                get http() {
+                    return fallbackHttp ?? execution.http;
+                },
+            };
+        }),
+    };
+};
+export const OpenResponsesChannel = { transport };

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

@@ -0,0 +1,16 @@
+import type { WebSocketChannelDriver } from "../route/transport/index.js";
+/**
+ * Fields to send next to `previous_response_id` on an incremental step, or undefined to send the step in full.
+ * Whether omitted fields carry over from the continued response is provider behavior the route must know.
+ */
+export type Shape = (request: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>> | undefined;
+export interface DriverInput {
+    readonly id: string;
+    readonly name: string;
+    readonly request: Readonly<Record<string, unknown>>;
+    readonly message: string;
+    readonly base: WebSocketChannelDriver;
+    readonly continuation?: Shape;
+}
+export declare const driver: (input: DriverInput) => WebSocketChannelDriver;
+export * as OpenResponsesContinuation from "./open-responses-continuation.js";

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

@@ -0,0 +1,170 @@
+import { AIError, TransportError } from "../schema/index.js";
+import { Effect, Option, Schema } from "effect";
+import * as ProviderShared from "./shared.js";
+import { OpenResponses } from "./open-responses.js";
+const PROTOCOL = "open-responses.websocket.v1";
+const VERSION = 1;
+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)
+        .filter((key) => value[key] !== undefined)
+        .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",
+            // Annotations and logprobs describe the response, not the text replayed in model input.
+            content: Array.isArray(value.content)
+                ? value.content.map((part) => ProviderShared.isRecord(part) && part.type === "output_text" ? { type: part.type, text: part.text } : part)
+                : 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 = (observation, recovery) => ({
+    type: "rejected",
+    recovery,
+    error: new AIError({
+        reason: new TransportError({
+            message: observation.error.message,
+            body: observation.error.reason.body,
+            http: observation.error.reason.http,
+            cause: observation.error.reason.cause,
+            transport: "websocket",
+            operation: "read",
+            phase: "receive",
+            delivery: "rejected",
+            recovery,
+        }),
+    }),
+});
+export const driver = (input) => {
+    const { previous_response_id: _previousResponseID, ...request } = input.request;
+    const shape = input.continuation ?? ((fields) => fields);
+    let output = [];
+    return {
+        create: (checkpoint) => Effect.sync(() => {
+            output = [];
+            const previous = checkpointValue(checkpoint);
+            // Ask the route first: diffing the whole history is wasted when it declines the continuation.
+            const fields = previous ? shape(request) : undefined;
+            const delta = previous && fields ? incremental(request, previous) : undefined;
+            if (!previous || !fields || !delta)
+                return { message: ProviderShared.encodeJson(request), mode: "full" };
+            return {
+                message: ProviderShared.encodeJson({ ...fields, input: delta, previous_response_id: previous.responseID }),
+                mode: "incremental",
+            };
+        }),
+        observe: (create, frame) => Effect.gen(function* () {
+            const event = yield* OpenResponses.decodeChannelEvent(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame, cause)));
+            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(observation, "retry-full");
+                if (rejection === "websocket_connection_limit_reached")
+                    return rejected(observation, "rotate-and-retry-full");
+                // Only the continuation distinguishes an incremental send from a full one, so an unclassified
+                // invalid request there is retried full; Codex reports a stale previous_response_id that way, with
+                // no code. Classified failures such as context overflow keep their runner-owned recovery.
+                if (create.mode === "incremental" &&
+                    observation.error.reason._tag === "InvalidRequest" &&
+                    observation.error.reason.classification === undefined)
+                    return rejected(observation, "retry-full");
+            }
+            if (observation.type !== "completed")
+                return observation;
+            // A trigger installs a different context window. Clear the append baseline, retaining the socket.
+            if (Array.isArray(request.input) &&
+                request.input.some((item) => ProviderShared.isRecord(item) && item.type === "compaction_trigger"))
+                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,
+                        // Completion can re-encrypt reasoning. Callers replay the item already emitted by output_item.done.
+                        output: event.response?.output?.length
+                            ? event.response.output.map((item) => item.type === "reasoning" && item.id !== undefined
+                                ? (output.find((done) => done.type === item.type && done.id === item.id) ?? item)
+                                : item)
+                            : output.slice(),
+                    },
+                },
+            };
+        }),
+    };
+};
+export * as OpenResponsesContinuation from "./open-responses-continuation.js";