@opencode-ai/ai 0.0.0-dev-17938 → 0.0.0-dev-17945

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

@@ -451,7 +451,6 @@ export interface ParserState {
     readonly hasFunctionCall: boolean;
     readonly lifecycle: Lifecycle.State;
     readonly messageItems: ReadonlySet<string>;
-    readonly messagePhase: (value: unknown) => MessagePhase | null | undefined;
     readonly messagePhases: Readonly<Record<string, MessagePhase | null>>;
     readonly reasoningItems: Readonly<Record<string, ReasoningStreamItem>>;
     readonly store: boolean | undefined;

package/dist/protocols/open-responses.js

@@ -39,6 +39,11 @@ const OpenResponsesOutputText = Schema.Struct({
     text: Schema.String,
 });
 export const MessagePhase = Schema.NullOr(Schema.Literals(["commentary", "final_answer"]));
+const messagePhase = (value) => {
+    if (value === null || value === "commentary" || value === "final_answer")
+        return value;
+    return undefined;
+};
 const OpenResponsesReasoningSummaryText = Schema.Struct({
     type: Schema.tag("summary_text"),
     text: Schema.String,
@@ -218,19 +223,6 @@ export const Event = Schema.StructWithRest(Schema.Struct({
     status_code: Schema.optional(Schema.Unknown),
     headers: Schema.optional(Schema.Unknown),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
-const RefusalEvent = Schema.Union([
-    Schema.Struct({
-        type: Schema.tag("response.refusal.delta"),
-        item_id: Schema.String,
-        delta: Schema.String,
-    }),
-    Schema.Struct({
-        type: Schema.tag("response.refusal.done"),
-        item_id: Schema.String,
-        refusal: Schema.String,
-    }),
-]);
-const isRefusalEvent = Schema.is(RefusalEvent);
 const BASE = { id: ADAPTER, name: NAME };
 // =============================================================================
 // Request Lowering
@@ -284,9 +276,6 @@ const lowerReasoning = (part, providerMetadataKey) => {
         encrypted_content: encryptedContent,
     };
 };
-const hostedToolItemID = (part, providerMetadataKey) => {
-    return itemID(part.providerMetadata, providerMetadataKey);
-};
 const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (part, request, extension, target) {
     const media = ProviderShared.normalizeMedia(part);
     const extended = extension.lowerMedia?.({ part, media, request });
@@ -424,9 +413,9 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
                 }
                 if (part.type === "tool-result" && part.providerExecuted === true) {
                     flushText();
-                    const itemID = hostedToolItemID(part, providerMetadataKey);
-                    if (store !== false && itemID && !hostedToolReferences.has(itemID))
-                        input.push({ type: "item_reference", id: itemID });
+                    const id = itemID(part.providerMetadata, providerMetadataKey);
+                    if (store !== false && id && !hostedToolReferences.has(id))
+                        input.push({ type: "item_reference", id });
                     if (store === false && part.result.type === "content") {
                         const content = part.result.value;
                         input.push({
@@ -434,8 +423,8 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
                             content: yield* Effect.forEach(content, (item) => lowerHostedToolResultContentItem(item, request, extension)),
                         });
                     }
-                    if (itemID)
-                        hostedToolReferences.add(itemID);
+                    if (id)
+                        hostedToolReferences.add(id);
                     continue;
                 }
                 return yield* ProviderShared.unsupportedContent(extension.name, "assistant", [
@@ -619,18 +608,17 @@ const reasoningMetadata = (state, item) => providerMetadata(state, { itemId: ite
 // best-effort, not guaranteed.
 const onOutputItemAdded = (state, event) => {
     const item = event.item;
-    if (item?.type === "message" && item.id)
+    if (item?.type === "message" && item.id) {
+        const phase = messagePhase(item.phase);
         return [
             {
                 ...state,
                 messageItems: new Set([...state.messageItems, item.id]),
-                messagePhases: (() => {
-                    const phase = state.messagePhase(item.phase);
-                    return phase === undefined ? state.messagePhases : { ...state.messagePhases, [item.id]: phase };
-                })(),
+                messagePhases: phase === undefined ? state.messagePhases : { ...state.messagePhases, [item.id]: phase },
             },
             NO_EVENTS,
         ];
+    }
     if (item && isReasoningItem(item)) {
         const events = [];
         return [
@@ -752,7 +740,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
     if (!item)
         return [state, NO_EVENTS];
     if (item.type === "message" && item.id) {
-        const itemPhase = state.messagePhase(item.phase);
+        const itemPhase = messagePhase(item.phase);
         const phase = itemPhase === undefined ? state.messagePhases[item.id] : itemPhase;
         const events = [];
         const messageItems = new Set(state.messageItems);
@@ -843,22 +831,26 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
     });
     return [{ ...state, lifecycle, hasFunctionCall, tools: pending.tools }, events];
 });
-// Build a single human-readable message from whatever the provider supplied.
+// Build the prettiest summary available from whatever the provider supplied.
 // When both code and message are present, prefix the code so consumers see
 // the failure mode (e.g. `rate_limit_exceeded: Slow down`) instead of just
 // the bare message — production rate limits and context-length failures used
-// to be indistinguishable from generic stream drops.
-const providerErrorMessage = (event, fallback) => {
-    const nested = event.error ?? event.response?.error ?? undefined;
+// to be indistinguishable from generic stream drops. Returns undefined when
+// the payload carries no usable summary.
+const providerErrorMessage = (event, nested) => {
     const message = event.message || nested?.message || undefined;
     const code = event.code || nested?.code || undefined;
     if (message && code)
         return `${code}: ${message}`;
-    return message || code || fallback;
+    return message || code;
 };
 export const providerFailure = (id, event, fallback) => {
-    const code = event.code || event.error?.code || event.response?.error?.code || undefined;
-    const message = providerErrorMessage(event, fallback);
+    const nested = event.error ?? event.response?.error ?? undefined;
+    const code = event.code || nested?.code || undefined;
+    // Keep the full raw payload on the error even when the message is a summary.
+    const body = JSON.stringify(nested ?? event) ?? "";
+    const summary = providerErrorMessage(event, nested);
+    const message = summary ?? (body === "{}" ? fallback : body);
     const status = typeof event.status === "number"
         ? event.status
         : typeof event.status_code === "number"
@@ -867,7 +859,8 @@ export const providerFailure = (id, event, fallback) => {
     return new AIError({
         module: id,
         method: "stream",
-        reason: classifyProviderFailure({ message, code, status }),
+        body,
+        reason: classifyProviderFailure({ message, code, status, rawBody: body }),
     });
 };
 const providerError = (state, event, fallback) => providerFailure(state.id, event, fallback);
@@ -880,22 +873,18 @@ export const step = (state, event) => {
             : onOutputTextDone(state, event, event.item_id));
     }
     if (event.type === "response.refusal.delta" || event.type === "response.refusal.done") {
-        if (!isRefusalEvent(event))
+        const value = event.type === "response.refusal.delta" ? event.delta : event.refusal;
+        if (!event.item_id || typeof value !== "string")
             return ProviderShared.eventError(state.id, `${event.type} is malformed`);
         return Effect.succeed(event.type === "response.refusal.delta"
             ? onOutputTextDelta(state, event, event.item_id)
-            : onOutputTextDone(state, { ...event, text: event.refusal }, event.item_id));
+            : onOutputTextDone(state, { ...event, text: value }, event.item_id));
     }
     if (event.type === "response.reasoning.delta" || event.type === "response.reasoning_summary_text.delta") {
         if (!event.item_id)
             return ProviderShared.eventError(state.id, `${event.type} is missing item_id`);
         return Effect.succeed(onReasoningDelta(state, event, event.item_id));
     }
-    if (event.type === "response.reasoning.done" || event.type === "response.reasoning_summary_text.done") {
-        if (!event.item_id)
-            return ProviderShared.eventError(state.id, `${event.type} is missing item_id`);
-        return Effect.succeed(onReasoningDone(state, event));
-    }
     if (event.type === "response.reasoning_summary_part.added")
         return event.item_id
             ? Effect.succeed(onReasoningSummaryPartAdded(state, event))
@@ -939,16 +928,10 @@ export const initial = (request, extension = BASE) => ({
     tools: ToolStream.empty(),
     lifecycle: Lifecycle.initial(),
     messageItems: new Set(),
-    messagePhase,
     messagePhases: {},
     reasoningItems: {},
     store: OpenResponsesOptions.resolve(request).store,
 });
-const messagePhase = (value) => {
-    if (value === null || value === "commentary" || value === "final_answer")
-        return value;
-    return undefined;
-};
 export const protocol = Protocol.make({
     id: ADAPTER,
     body: {

package/dist/provider-error.d.ts

@@ -6,6 +6,7 @@ export interface ProviderFailure {
     readonly message: string;
     readonly status?: number | undefined;
     readonly code?: string | undefined;
+    readonly rawBody?: string | undefined;
     readonly retryAfterMs?: number | undefined;
     readonly rateLimit?: HttpRateLimitDetails | undefined;
     readonly http?: HttpContext | undefined;

package/dist/provider-error.js

@@ -56,11 +56,13 @@ const NETWORK_ERROR_TEXT = /network[-_\s]error/i;
 // Keep HTTP failures and provider-reported stream failures on one typed path so
 // session retry policy never needs provider-specific string matching.
 export function classifyProviderFailure(input) {
-    const body = input.http?.body ?? "";
+    const body = input.http?.body ?? input.rawBody ?? "";
     const codes = [input.code, ...providerCodes(body), ...providerCodes(input.message)]
         .filter((code) => code !== undefined)
         .map((code) => code.toLowerCase());
-    const text = body || input.message;
+    // Scan the raw payload too so signals missing from the summary message
+    // (e.g. overflow phrases nested in a JSON error body) still classify.
+    const text = [input.message, body].filter((value) => value.length > 0).join("\n");
     const common = { message: input.message, providerMetadata: input.providerMetadata, http: input.http };
     const clientScoped = input.status === undefined || (input.status >= 400 && input.status < 500);
     if (clientScoped &&

package/dist/schema/errors.d.ts

@@ -140,6 +140,7 @@ declare const AIError_base: Schema.Class<AIError, Schema.TaggedStruct<"AI.Error"
     readonly module: Schema.String;
     readonly method: Schema.String;
     readonly reason: Schema.toTaggedUnion<"_tag", readonly [typeof InvalidRequestReason, typeof NoRouteReason, typeof AuthenticationReason, typeof RateLimitReason, typeof QuotaExceededReason, typeof ContentPolicyReason, typeof ProviderInternalReason, typeof TransportReason, typeof InvalidProviderOutputReason, typeof UnknownProviderReason]>;
+    readonly body: Schema.optional<Schema.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AIError extends AIError_base {
     readonly cause: InvalidRequestReason | NoRouteReason | AuthenticationReason | RateLimitReason | QuotaExceededReason | ContentPolicyReason | ProviderInternalReason | TransportReason | InvalidProviderOutputReason | UnknownProviderReason;

package/dist/schema/errors.js

@@ -137,6 +137,9 @@ export class AIError extends Schema.TaggedError()("AI.Error", {
     module: Schema.String,
     method: Schema.String,
     reason: AIErrorReason,
+    // Raw provider payload as a string, so classified failures never lose the
+    // original error detail even when the pretty message is a summary.
+    body: Schema.optional(Schema.String),
 }) {
     cause = this.reason;
     get message() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-17938",
+  "version": "0.0.0-dev-17945",
   "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.110",
-    "@opencode-ai/http-recorder": "0.0.0-dev-17938",
+    "@opencode-ai/http-recorder": "0.0.0-dev-17945",
     "@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-17938",
+    "@opencode-ai/schema": "0.0.0-dev-17945",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.110",
     "google-auth-library": "10.5.0"