@opencode/ai 2.0.17 → 2.0.19

package/dist/providers/openrouter.d.ts

@@ -141,6 +141,11 @@ declare const OpenRouterBody: Schema.StructWithRest<Schema.Struct<{
                 readonly name: Schema.String;
                 readonly arguments: Schema.String;
             }>;
+            readonly extra_content: Schema.optional<Schema.Struct<{
+                readonly google: Schema.Struct<{
+                    readonly thought_signature: Schema.String;
+                }>;
+            }>>;
         }>>>;
         readonly reasoning_content: Schema.optional<Schema.String>;
         readonly reasoning: Schema.optional<Schema.String>;
@@ -253,12 +258,17 @@ export declare const protocol: Protocol<{
             readonly ttl?: string | undefined;
         } | undefined;
         readonly tool_calls?: readonly {
-            readonly id: string;
-            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
+            readonly id: string;
+            readonly type: "function";
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
@@ -349,6 +359,7 @@ export declare const protocol: Protocol<{
                 } | null | undefined;
                 readonly id?: string | null | undefined;
                 readonly index?: number | null | undefined;
+                readonly extra_content?: unknown;
             }[] | null | undefined;
             readonly reasoning_details?: unknown;
         } | null | undefined;
@@ -432,12 +443,17 @@ export declare const route: Route<{
             readonly ttl?: string | undefined;
         } | undefined;
         readonly tool_calls?: readonly {
-            readonly id: string;
-            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
+            readonly id: string;
+            readonly type: "function";
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
@@ -544,12 +560,17 @@ export declare const routes: Route<{
             readonly ttl?: string | undefined;
         } | undefined;
         readonly tool_calls?: readonly {
-            readonly id: string;
-            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
+            readonly id: string;
+            readonly type: "function";
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {

package/dist/providers/togetherai.d.ts

@@ -68,12 +68,17 @@ export declare const route: Route<{
             readonly ttl?: string | undefined;
         } | undefined;
         readonly tool_calls?: readonly {
-            readonly id: string;
-            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
+            readonly id: string;
+            readonly type: "function";
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
@@ -179,12 +184,17 @@ export declare const routes: Route<{
             readonly ttl?: string | undefined;
         } | undefined;
         readonly tool_calls?: readonly {
-            readonly id: string;
-            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
+            readonly id: string;
+            readonly type: "function";
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {

package/dist/providers/xai.d.ts

@@ -76,12 +76,17 @@ export declare const routes: (Route<{
             readonly ttl?: string | undefined;
         } | undefined;
         readonly tool_calls?: readonly {
-            readonly id: string;
-            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
+            readonly id: string;
+            readonly type: "function";
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {

package/dist/providers/xai.js

@@ -13,13 +13,13 @@ const baseURL = "https://api.x.ai/v1";
 const RESPONSES_WEBSOCKET_ROTATE_AFTER_MS = 24 * 60 * 1000;
 const responsesRoute = Route.make({
     compact: { endpoint: XAIResponses.compact },
-    id: "openai-responses",
+    id: "xai-responses",
     provider: id,
     providerMetadataKey: "xai",
     protocol: XAIResponses.protocol,
     endpoint: Endpoint.path("/responses", { baseURL }),
     transport: OpenResponsesChannel.transport({
-        id: "openai-responses",
+        id: "xai-responses",
         name: "xAI Responses",
         rotateAfterMs: RESPONSES_WEBSOCKET_ROTATE_AFTER_MS,
         // xAI continues a chain only from stored responses: with `store: false` (the route default) `previous_response_id`
@@ -30,7 +30,7 @@ const responsesRoute = Route.make({
     defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
 });
 const chatRoute = Route.make({
-    id: "openai-compatible-chat",
+    id: "xai-chat",
     provider: id,
     providerMetadataKey: "xai",
     protocol: OpenAIChat.protocol,

package/dist/providers/zai-coding-plan.d.ts

@@ -240,12 +240,17 @@ export declare const routes: (Route<{
             readonly ttl?: string | undefined;
         } | undefined;
         readonly tool_calls?: readonly {
-            readonly id: string;
-            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
+            readonly id: string;
+            readonly type: "function";
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {

package/dist/providers/zai.d.ts

@@ -70,12 +70,17 @@ export declare const routes: Route<{
             readonly ttl?: string | undefined;
         } | undefined;
         readonly tool_calls?: readonly {
-            readonly id: string;
-            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
+            readonly id: string;
+            readonly type: "function";
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {

package/dist/route/media-protocol.d.ts

@@ -3,7 +3,7 @@ import { HttpClientResponse } from "effect/unstable/http";
 import type { Snapshot, Status } from "../generation.js";
 import { Media } from "../media.js";
 import type { AuthInput } from "./auth.js";
-import { AIError, HttpContext, ProviderID } from "../schema/index.js";
+import { AIError, AuthenticationError, HttpContext, InvalidRequestError, ProviderID, ProviderInternalError, RateLimitError } from "../schema/index.js";
 /** Array values become repeated parameters (`keyterm=a&keyterm=b`). */
 export type Query = Readonly<Record<string, string | ReadonlyArray<string>>>;
 /** `query` is appended to the endpoint URL before the route and caller `http.query` overlays. */
@@ -128,6 +128,14 @@ export interface Streamed<Request, Event, Frame, State> {
     readonly finish: (state: State, context: ResponseContext<Request>) => Effect.Effect<ReadonlyArray<Event>, AIError>;
 }
 export declare const stream: <Request, Event, Frame, State>(route: Identity, input: Omit<Streamed<Request, Event, Frame, State>, "kind" | "id" | "provider">) => Streamed<Request, Event, Frame, State>;
+/** Reasons a provider can report for a `failed` generation; anything it does not classify is `ProviderInternal`. */
+declare const FAILURES: {
+    InvalidRequest: typeof InvalidRequestError;
+    Authentication: typeof AuthenticationError;
+    RateLimit: typeof RateLimitError;
+    ProviderInternal: typeof ProviderInternalError;
+};
+export type Failure = keyof typeof FAILURES;
 /** One protocol's route id, display name, and provider, with the decoders and errors that carry them. */
 export declare const identity: (input: {
     readonly id: string;
@@ -141,7 +149,7 @@ export declare const identity: (input: {
         body: string;
         http: HttpContext;
         invalid: (message: string, cause?: unknown) => AIError;
-        ended: (status: Exclude<Status, "queued" | "running" | "completed">, message: string) => AIError;
+        ended: (status: Exclude<Status, "queued" | "running" | "completed">, message: string, failure?: Failure) => AIError;
         pending: (id: string) => AIError;
         contentPolicy: (message: string) => AIError;
     }, AIError, never>;
@@ -150,7 +158,7 @@ export declare const identity: (input: {
         body: string;
         http: HttpContext;
         invalid: (message: string, cause?: unknown) => AIError;
-        ended: (status: Exclude<Status, "queued" | "running" | "completed">, message: string) => AIError;
+        ended: (status: Exclude<Status, "queued" | "running" | "completed">, message: string, failure?: Failure) => AIError;
         pending: (id: string) => AIError;
         contentPolicy: (message: string) => AIError;
     }, AIError, never>;
@@ -167,6 +175,8 @@ export type Identity = ReturnType<typeof identity>;
 export type Output = Effect.Success<ReturnType<Identity["text"]>>;
 /** Map a provider status string through the protocol's table; unknown values are an invalid provider document. */
 export declare const status: <Table extends Record<string, Status>>(table: Table, raw: string, output: Output) => Effect.Effect<Status, AIError>;
+/** Map a provider error code through the protocol's table; missing or unmapped codes are `ProviderInternal`. */
+export declare const failure: (table: Readonly<Record<string, Failure>>, code: string | number | undefined) => Failure;
 /** A `url` asset whose provider-declared retention window starts now. */
 export declare const expiringUrl: (url: string, retention: Duration.Duration, options?: Parameters<typeof Media.url>[1]) => Effect.Effect<Media.Asset, never, never>;
 export * as MediaProtocol from "./media-protocol.js";

package/dist/route/media-protocol.js

@@ -1,7 +1,7 @@
 import { Clock, Duration, Effect, Schema } from "effect";
 import { HttpClientResponse } from "effect/unstable/http";
 import { Media } from "../media.js";
-import { AIError, ContentPolicyError, HttpContext, InvalidProviderOutputError, InvalidRequestError, ProviderID, ProviderInternalError, UnsupportedOperationError, } from "../schema/index.js";
+import { AIError, AuthenticationError, ContentPolicyError, HttpContext, InvalidProviderOutputError, InvalidRequestError, ProviderID, ProviderInternalError, RateLimitError, UnsupportedOperationError, } from "../schema/index.js";
 export const json = (value, query) => ({
     type: "json",
     value,
@@ -20,6 +20,13 @@ export const stream = (route, input) => ({ kind: "stream", id: route.id, provide
 // ---------------------------------------------------------------------------
 // Response helpers
 // ---------------------------------------------------------------------------
+/** Reasons a provider can report for a `failed` generation; anything it does not classify is `ProviderInternal`. */
+const FAILURES = {
+    InvalidRequest: InvalidRequestError,
+    Authentication: AuthenticationError,
+    RateLimit: RateLimitError,
+    ProviderInternal: ProviderInternalError,
+};
 const context = (response) => new HttpContext({ url: response.request.url, status: response.status, headers: response.headers });
 /** One protocol's route id, display name, and provider, with the decoders and errors that carry them. */
 export const identity = (input) => {
@@ -27,9 +34,10 @@ export const identity = (input) => {
     const frameError = (message, body, cause) => new AIError({ reason: new InvalidProviderOutputError({ route: input.id, message, body, cause }) });
     /**
      * Read a text body while retaining the original payload and HTTP context on every downstream error. `invalid` is a
-     * malformed provider document; `ended` is a generation that reached a terminal status without output (`failed` is
-     * provider-side, `cancelled`/`expired` mean the result will never exist); `pending` is a `result()` read before the
-     * generation finished, which is caller misuse; `contentPolicy` is a moderated result.
+     * malformed provider document; `ended` is a generation that reached a terminal status without output (`failed`
+     * carries the provider's classification, defaulting to `ProviderInternal`; `cancelled`/`expired` mean the result
+     * will never exist); `pending` is a `result()` read before the generation finished, which is caller misuse;
+     * `contentPolicy` is a moderated result.
      */
     const text = Effect.fn("MediaProtocol.text")(function* (response) {
         const http = context(response);
@@ -45,9 +53,9 @@ export const identity = (input) => {
             body,
             http,
             invalid: (message, cause) => new AIError({ reason: new InvalidProviderOutputError({ route: input.id, message, body, http, cause }) }),
-            ended: (status, message) => new AIError({
+            ended: (status, message, failure = "ProviderInternal") => new AIError({
                 reason: status === "failed"
-                    ? new ProviderInternalError({ message, body, http })
+                    ? new FAILURES[failure]({ message, body, http })
                     : new InvalidRequestError({ message, body, http }),
             }),
             pending: (id) => new AIError({
@@ -103,6 +111,8 @@ export const status = (table, raw, output) => {
         return Effect.fail(output.invalid(`Unknown generation status "${raw}"`));
     return Effect.succeed(table[raw]);
 };
+/** Map a provider error code through the protocol's table; missing or unmapped codes are `ProviderInternal`. */
+export const failure = (table, code) => code !== undefined && Object.hasOwn(table, code) ? table[code] : "ProviderInternal";
 /** A `url` asset whose provider-declared retention window starts now. */
 export const expiringUrl = (url, retention, options) => Clock.currentTimeMillis.pipe(Effect.map((now) => Media.url(url, { ...options, expiresAt: now + Duration.toMillis(retention) })));
 export * as MediaProtocol from "./media-protocol.js";

package/dist/route/media.js

@@ -1,4 +1,4 @@
-import { Effect, Schema, Stream } from "effect";
+import { Duration, Effect, Schedule, Schema, Stream } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
 import { Auth } from "./auth.js";
 import { Endpoint } from "./endpoint.js";
@@ -6,6 +6,7 @@ import { RequestExecutorService } from "./executor-service.js";
 import { RequestExecutor } from "./executor.js";
 import { MediaProtocol } from "./media-protocol.js";
 import { Generation, isTerminal } from "../generation.js";
+import { isRetryable } from "../provider-error.js";
 import { AIError, AIErrorReason, HttpOptions, InvalidRequestError, ProviderID, UnsupportedOperationError, mergeHttpOptions, } from "../schema/index.js";
 import { encodeJson } from "../utils/json.js";
 import { sanitizeSurrogates } from "../utils/sanitize.js";
@@ -35,6 +36,19 @@ export const inline = (input) => {
         }),
     };
 };
+const READ_RETRY_MAX_DELAY = Duration.seconds(30);
+/**
+ * Status and result reads retry transient failures; `start` and `cancel` never do. Gaps grow exponentially from 1s,
+ * jittered, up to 30s each, for at most 8 retries (about two minutes when every attempt fails), so a direct
+ * `Generation.result()` stays bounded; `await` and `events` also cut retries off at `poll.timeout`. A provider
+ * `retryAfterMs` raises the gap, still capped at 30s.
+ */
+const READ_RETRY = Schedule.max([
+    Schedule.min([Schedule.exponential("1 second"), Schedule.spaced(READ_RETRY_MAX_DELAY)]),
+    Schedule.recurs(8),
+]).pipe(Schedule.jittered, Schedule.setInputType(), Schedule.modifyDelay(({ input, duration }) => Effect.succeed(Duration.min(input.reason._tag === "RateLimit" || input.reason._tag === "ProviderInternal"
+    ? Duration.max(duration, Duration.millis(input.reason.retryAfterMs ?? 0))
+    : duration, READ_RETRY_MAX_DELAY))));
 /**
  * Compose a queued media protocol the same way, adding `start`/`resume` handles whose polls reuse the route's auth,
  * deployment headers, and (for `start`) the request's `http` overlay. The token is decoded once at the boundary and
@@ -48,9 +62,9 @@ export const queued = (input) => {
     const encodeToken = Schema.encodeSync(protocol.token);
     const generationRoute = (token, http, execute) => {
         const materialize = (asset) => asset.materialize().pipe(Effect.provideService(RequestExecutorService, { execute }));
-        const poll = (operation) => transport
-            .call("GET", operation.path(token), http, execute)
-            .pipe(Effect.flatMap((sent) => operation.decode(sent.response, { token, auth: sent.auth, materialize })));
+        // Only the GET exchange retries: a decoded terminal failure (`output.ended`) can be a `ProviderInternal` too, and
+        // re-reading it would spin until the caller's deadline.
+        const poll = (operation) => transport.call("GET", operation.path(token), http, execute).pipe(Effect.retry({ schedule: READ_RETRY, while: isRetryable }), Effect.flatMap((sent) => operation.decode(sent.response, { token, auth: sent.auth, materialize })));
         const status = poll(protocol.status);
         const cancel = protocol.cancel;
         const send = cancel === undefined

package/dist/transcription.d.ts

@@ -72,7 +72,7 @@ export type TranscriptionRequestInput<Model extends TranscriptionModel = Transcr
     readonly providerOptions?: NoInfer<TranscriptionModelOptions<Model>>;
     readonly http?: HttpOptions.Input;
 };
-/** Speaker labels are provider-native (`A`, `0`, `spk:0`, or a known speaker name). */
+/** Speaker labels are provider-native (`A`, `0`, `spk:0`, `speaker_0`, or a known speaker name). */
 export declare const TranscriptionSegment: Schema.Struct<{
     readonly text: Schema.String;
     readonly startSeconds: Schema.Number;

package/dist/transcription.js

@@ -36,7 +36,7 @@ export class TranscriptionRequest extends Schema.Class("Transcription.Request")(
 // ---------------------------------------------------------------------------
 // Response and events
 // ---------------------------------------------------------------------------
-/** Speaker labels are provider-native (`A`, `0`, `spk:0`, or a known speaker name). */
+/** Speaker labels are provider-native (`A`, `0`, `spk:0`, `speaker_0`, or a known speaker name). */
 export const TranscriptionSegment = Schema.Struct({
     text: Schema.String,
     startSeconds: Schema.Number,

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.17",
+  "version": "2.0.19",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/http-recorder": "2.0.17",
+    "@opencode/http-recorder": "2.0.19",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -44,7 +44,7 @@
     "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "2.0.17",
+    "@opencode/schema": "2.0.19",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"