@opencode-ai/ai 0.0.0-dev-18192 → 0.0.0-dev-18195

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

@@ -133,7 +133,12 @@ export const driver = (input) => {
                 ...observation,
                 checkpoint: {
                     protocol: PROTOCOL,
-                    value: { version: VERSION, responseID, request, output: output.slice() },
+                    value: {
+                        version: VERSION,
+                        responseID,
+                        request,
+                        output: event.response?.output ? [...event.response.output] : output.slice(),
+                    },
                 },
             };
         }),

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

@@ -402,6 +402,14 @@ export declare const Event: Schema.StructWithRest<Schema.Struct<{
         readonly incomplete_details: Schema.optional<Schema.NullOr<Schema.Struct<{
             readonly reason: Schema.optional<Schema.String>;
         }>>>;
+        readonly output: Schema.optional<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+            readonly type: Schema.String;
+            readonly id: Schema.optional<Schema.String>;
+            readonly call_id: Schema.optional<Schema.String>;
+            readonly name: Schema.optional<Schema.String>;
+            readonly arguments: Schema.optional<Schema.String>;
+            readonly encrypted_content: Schema.optional<Schema.NullOr<Schema.String>>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
         readonly usage: Schema.optional<Schema.NullOr<Schema.Struct<{
             readonly input_tokens: Schema.optional<Schema.Number>;
             readonly input_tokens_details: Schema.optional<Schema.NullOr<Schema.Struct<{
@@ -656,7 +664,7 @@ export declare const terminal: (event: Event) => boolean;
 export declare const onReasoningDelta: (state: ParserState, event: Event, itemID: string) => StepResult;
 export declare const onReasoningDone: (state: ParserState, event: Event, itemID: string) => StepResult;
 export declare const providerFailure: (id: string, event: Event, fallback: string) => AIError;
-export declare const step: (state: ParserState, event: Event) => AIError | Effect.Effect<StepResult, never, never> | Effect.Effect<[ParserState, readonly ({
+export declare const step: (state: ParserState, event: Event) => AIError | Effect.Effect<[ParserState, readonly ({
     readonly type: "step-start";
     readonly index: number;
 } | {
@@ -838,7 +846,7 @@ export declare const step: (state: ParserState, event: Event) => AIError | Effec
         };
     } | undefined;
     readonly classification?: "context-overflow" | "payload-too-large" | undefined;
-})[]], AIError, never>;
+})[]], AIError, never> | Effect.Effect<StepResult, never, never>;
 /**
  * The provider-neutral Open Responses protocol. Provider-specific Responses
  * implementations compose this baseline with their own tools and event variants.
@@ -987,6 +995,15 @@ export declare const protocol: Protocol<{
     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 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;

package/dist/protocols/open-responses.js

@@ -213,6 +213,7 @@ export const Event = Schema.StructWithRest(Schema.Struct({
         id: Schema.optional(Schema.String),
         service_tier: optionalNull(Schema.String),
         incomplete_details: optionalNull(Schema.Struct({ reason: Schema.optional(Schema.String) })),
+        output: Schema.optional(Schema.Array(StreamItem)),
         usage: optionalNull(OpenResponsesUsage),
         error: optionalNull(OpenResponsesErrorPayload),
     }), [Schema.Record(Schema.String, Schema.Unknown)])),
@@ -855,27 +856,35 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
     return [state, NO_EVENTS];
 });
 const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (state, event) {
+    const reconciled = event.type === "response.completed"
+        ? yield* Effect.reduce(event.response?.output ?? [], () => [state, NO_EVENTS], ([current, events], item) => {
+            if (item.type !== "function_call" || !item.id || !current.tools[item.id])
+                return Effect.succeed([current, events]);
+            return onOutputItemDone(current, { type: "response.output_item.done", item }).pipe(Effect.map(([next, emitted]) => [next, [...events, ...emitted]]));
+        })
+        : [state, NO_EVENTS];
+    const current = reconciled[0];
     // Some compatible providers omit output_item.done even after completing the response.
     const pending = event.type === "response.completed"
-        ? yield* ToolStream.finishAll(state.id, state.tools)
-        : { tools: state.tools, events: NO_EVENTS };
-    const events = [...pending.events];
+        ? yield* ToolStream.finishAll(current.id, current.tools)
+        : { tools: current.tools, events: NO_EVENTS };
+    const events = [...reconciled[1], ...pending.events];
     const hasFunctionCall = pending.events.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
-        state.hasFunctionCall;
-    const lifecycle = Lifecycle.finish(state.lifecycle, events, {
+        current.hasFunctionCall;
+    const lifecycle = Lifecycle.finish(current.lifecycle, events, {
         reason: {
             normalized: mapFinishReason(event, hasFunctionCall),
             raw: event.response?.incomplete_details?.reason,
         },
-        usage: mapUsage(event.response?.usage, state.providerMetadataKey),
+        usage: mapUsage(event.response?.usage, current.providerMetadataKey),
         providerMetadata: event.response?.id || event.response?.service_tier
-            ? providerMetadata(state, {
+            ? providerMetadata(current, {
                 responseId: event.response.id,
                 serviceTier: event.response.service_tier,
             })
             : undefined,
     });
-    return [{ ...state, lifecycle, hasFunctionCall, tools: pending.tools }, events];
+    return [{ ...current, lifecycle, hasFunctionCall, tools: pending.tools }, events];
 });
 // Build the prettiest summary available from whatever the provider supplied.
 // When both code and message are present, prefix the code so consumers see

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

@@ -286,6 +286,15 @@ export declare const protocol: Protocol<{
     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 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;

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

@@ -143,6 +143,15 @@ export declare const protocol: Protocol<{
     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 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-18192",
+  "version": "0.0.0-dev-18195",
   "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.111",
-    "@opencode-ai/http-recorder": "0.0.0-dev-18192",
+    "@opencode-ai/http-recorder": "0.0.0-dev-18195",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -39,7 +39,7 @@
   "dependencies": {
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "0.0.0-dev-18192",
+    "@opencode-ai/schema": "0.0.0-dev-18195",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.111",
     "google-auth-library": "10.5.0"