@opencode/ai 2.1.2 → 2.1.4

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

@@ -20,58 +20,59 @@ const message = (body) => Effect.gen(function* () {
 const driver = (options, body) => {
     let responseID;
     let terminal = false;
+    const observeEvent = Effect.fnUntraced(function* (_create, frame, event) {
+        if (terminal)
+            return yield* ProviderShared.eventError(options.id, `${options.name} emitted ${event.type} after a terminal event`, frame);
+        if (event.type === "error") {
+            terminal = true;
+            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 };
+    });
     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;
-                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 };
-        }),
+        observeEvent,
+        observe: (create, frame) => OpenResponses.decodeChannelEvent(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame, cause)), Effect.flatMap((event) => observeEvent(create, frame, event))),
     };
 };
 export const transport = (options) => {

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

@@ -1,15 +1,21 @@
-import type { WebSocketChannelDriver } from "../route/transport/index.js";
+import { AIError } from "../schema/index.js";
+import type { ChannelCreate, ChannelObservation, WebSocketChannelDriver } from "../route/transport/index.js";
+import { Effect } from "effect";
+import { OpenResponses } from "./open-responses.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 BaseDriver extends WebSocketChannelDriver {
+    readonly observeEvent?: (create: ChannelCreate, frame: string, event: OpenResponses.Event) => Effect.Effect<ChannelObservation, AIError>;
+}
 export interface DriverInput {
     readonly id: string;
     readonly name: string;
     readonly request: Readonly<Record<string, unknown>>;
     readonly message: string;
-    readonly base: WebSocketChannelDriver;
+    readonly base: BaseDriver;
     readonly continuation?: Shape;
 }
 export declare const driver: (input: DriverInput) => WebSocketChannelDriver;

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

@@ -121,7 +121,9 @@ export const driver = (input) => {
         }),
         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);
+            const observation = yield* input.base.observeEvent
+                ? input.base.observeEvent(create, frame, event)
+                : input.base.observe(create, frame);
             if (event.type === "response.output_item.done" && event.item)
                 output.push(event.item);
             if (observation.type === "provider-failure") {