@opencode/ai 2.0.32 → 2.1.0

package/dist/protocols/open-responses.js

@@ -2,7 +2,7 @@ import { Effect, Option, Schema } from "effect";
 import { HttpTransport } from "../route/transport/index.js";
 import { Protocol } from "../route/protocol.js";
 import { AIError, LLMEvent, ProviderInternalError, Usage, } from "../schema/index.js";
-import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
+import { JsonObject, lenient, optionalArray, optionalNull, optionalNullish, ProviderShared, withUntypedFrames, } from "./shared.js";
 import { classifyProviderFailure } from "../provider-error.js";
 import { effortUpdate } from "../effort-updates.js";
 import { OpenResponsesOptions } from "./utils/open-responses-options.js";
@@ -222,14 +222,14 @@ export const OpenResponsesBody = Schema.Struct({
     stream: Schema.Literal(true),
 });
 export const OpenResponsesUsage = Schema.StructWithRest(Schema.Struct({
-    input_tokens: Schema.optional(Schema.Number),
+    input_tokens: lenient(Schema.Number),
     input_tokens_details: optionalNull(Schema.StructWithRest(Schema.Struct({
-        cached_tokens: Schema.optional(Schema.Number),
-        cache_write_tokens: Schema.optional(Schema.Number),
+        cached_tokens: lenient(Schema.Number),
+        cache_write_tokens: lenient(Schema.Number),
     }), [JsonObject])),
-    output_tokens: Schema.optional(Schema.Number),
-    output_tokens_details: optionalNull(Schema.StructWithRest(Schema.Struct({ reasoning_tokens: Schema.optional(Schema.Number) }), [JsonObject])),
-    total_tokens: Schema.optional(Schema.Number),
+    output_tokens: lenient(Schema.Number),
+    output_tokens_details: optionalNull(Schema.StructWithRest(Schema.Struct({ reasoning_tokens: lenient(Schema.Number) }), [JsonObject])),
+    total_tokens: lenient(Schema.Number),
 }), [JsonObject]);
 // The spec requires `id` on every output item, but some gateways drop it from
 // later item events (Bedrock Mantle renames it to `item_id` on
@@ -238,11 +238,11 @@ export const OpenResponsesUsage = Schema.StructWithRest(Schema.Struct({
 // https://www.openresponses.org/specification#extending-items
 export const StreamItem = Schema.StructWithRest(Schema.Struct({
     type: Schema.String,
-    id: Schema.optional(Schema.String),
-    call_id: Schema.optional(Schema.String),
-    name: Schema.optional(Schema.String),
-    namespace: optionalNull(Schema.String),
-    arguments: Schema.optional(Schema.String),
+    id: optionalNullish(Schema.String),
+    call_id: optionalNullish(Schema.String),
+    name: optionalNullish(Schema.String),
+    namespace: optionalNullish(Schema.String),
+    arguments: optionalNullish(Schema.String),
     encrypted_content: optionalNull(Schema.String),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
 // Responses-compatible providers put error details at the top level, under `error`, or under
@@ -251,21 +251,22 @@ export const StreamItem = Schema.StructWithRest(Schema.Struct({
 // only fail on invalid JSON and otherwise always classifies with the raw body as the fallback.
 // https://www.openresponses.org/specification
 const asText = (value) => typeof value === "string" && value.length > 0 ? value : typeof value === "number" ? String(value) : undefined;
-export const Event = Schema.StructWithRest(Schema.Struct({
+const TypedEvent = Schema.StructWithRest(Schema.Struct({
     type: Schema.String,
-    delta: Schema.optional(Schema.String),
-    arguments: Schema.optional(Schema.String),
-    text: Schema.optional(Schema.String),
+    delta: optionalNullish(Schema.String),
+    arguments: optionalNullish(Schema.String),
+    text: optionalNullish(Schema.String),
+    // Kept strict: item-scoped events always carry an id, so null means a broken stream.
     item_id: Schema.optional(Schema.String),
-    output_index: Schema.optional(Schema.Number),
-    summary_index: Schema.optional(Schema.Number),
+    output_index: optionalNullish(Schema.Number),
+    summary_index: optionalNullish(Schema.Number),
     // OutputItemAdded/Done permit a null item in the Open Responses OpenAPI schema.
     item: optionalNull(StreamItem),
-    response: Schema.optional(Schema.StructWithRest(Schema.Struct({
-        id: Schema.optional(Schema.String),
+    response: optionalNullish(Schema.StructWithRest(Schema.Struct({
+        id: optionalNullish(Schema.String),
         service_tier: optionalNull(Schema.String),
-        incomplete_details: optionalNull(Schema.Struct({ reason: Schema.optional(Schema.String) })),
-        output: Schema.optional(Schema.Array(StreamItem)),
+        incomplete_details: optionalNull(Schema.Struct({ reason: optionalNullish(Schema.String) })),
+        output: optionalNullish(Schema.Array(StreamItem)),
         usage: optionalNull(OpenResponsesUsage),
         error: Schema.optional(Schema.Unknown),
     }), [Schema.Record(Schema.String, Schema.Unknown)])),
@@ -275,16 +276,9 @@ export const Event = Schema.StructWithRest(Schema.Struct({
     status: Schema.optional(Schema.Unknown),
     status_code: Schema.optional(Schema.Unknown),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
-const decodeEventValue = Schema.decodeUnknownEffect(Event);
-const decodeFrame = Schema.decodeUnknownEffect(ProviderShared.Json);
-/**
- * Decodes one WebSocket frame. Some providers and gateways answer a rejected `response.create` with a bare
- * `{ "error": ... }` envelope and no event type; that reads as an error event so it classifies instead of
- * failing decoding.
- */
-export const decodeChannelEvent = (frame) => decodeFrame(frame).pipe(Effect.flatMap((value) => decodeEventValue(ProviderShared.isRecord(value) && value.type === undefined && value.error != null
-    ? { ...value, type: "error" }
-    : value)));
+export const Event = withUntypedFrames(TypedEvent);
+/** Decodes one WebSocket frame. */
+export const decodeChannelEvent = Schema.decodeUnknownEffect(Protocol.jsonEvent(Event));
 const BASE_ADAPTER = { id: ADAPTER, name: NAME };
 // =============================================================================
 // Request Lowering
@@ -654,7 +648,7 @@ export const mapUsage = (usage, providerMetadataKey) => {
 };
 const mapFinishReason = (event, hasFunctionCall) => {
     const reason = event.response?.incomplete_details?.reason;
-    if (reason === undefined || reason === null) {
+    if (reason === undefined) {
         if (hasFunctionCall)
             return "tool-calls";
         if (event.type === "response.incomplete")
@@ -714,8 +708,6 @@ const ITEM_ID_PREFIX = {
 // otherwise it gets a locally minted one.
 const resolveItem = (state, item, index) => ({
     ...item,
-    // Some gateways serialize an absent namespace as null.
-    namespace: item.namespace ?? undefined,
     id: item.id ??
         (index === undefined ? undefined : state.outputItems[index]) ??
         `${ITEM_ID_PREFIX[item.type] ?? "item"}_${crypto.randomUUID().replaceAll("-", "")}`,