@opencode/ai 2.0.18 → 2.0.20

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

@@ -86,8 +86,8 @@ export declare const routes: (Route<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -123,8 +123,8 @@ export declare const routes: (Route<{
         } | {
             readonly type: "input_file";
             readonly filename: string;
-            readonly file_data?: string | undefined;
             readonly detail?: string | undefined;
+            readonly file_data?: string | undefined;
             readonly file_url?: string | undefined;
         } | {
             readonly type: "input_text";
@@ -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/client.d.ts

@@ -374,8 +374,8 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
 } | {
     readonly id: string;
     readonly type: "tool-error";
-    readonly name: string;
     readonly message: string;
+    readonly name: string;
     readonly error?: unknown;
     readonly providerMetadata?: {
         readonly [x: string]: {

package/dist/route/executor.js

@@ -1,7 +1,7 @@
 import { Cause, Effect, Layer, Option, Schema, Stream } from "effect";
 import { FetchHttpClient, Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, } from "effect/unstable/http";
 import { HttpContext, HttpRateLimitDetails, AIError, TransportError } from "../schema/index.js";
-import { classifyProviderFailure } from "../provider-error.js";
+import { classifyProviderFailure, providerErrorMessage } from "../provider-error.js";
 import { Service } from "./executor-service.js";
 export { Service } from "./executor-service.js";
 const headerDetails = (headers) => Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, String(value)]));
@@ -65,14 +65,18 @@ export const responseHttp = (response) => new HttpContext({
     status: response.status,
     headers: headerDetails(response.headers),
 });
-const decodeProviderBody = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Struct({
-    message: Schema.optionalKey(Schema.String),
-    error: Schema.optionalKey(Schema.Struct({ message: Schema.optionalKey(Schema.String) })),
-})));
+const MAX_BODY_CHARS = 2000;
+// Without a recognized message, show the raw body so the provider's explanation is never dropped.
 const providerMessage = (status, body) => {
-    const decoded = body === undefined ? undefined : Option.getOrUndefined(decodeProviderBody(body));
-    return ([decoded?.error?.message, decoded?.message].find((message) => message?.trim()) ??
-        `Provider request failed with HTTP ${status}`);
+    const fallback = `Provider request failed with HTTP ${status}`;
+    const text = body?.trim() ?? "";
+    const message = providerErrorMessage(text);
+    if (message)
+        return message;
+    // Gateway and proxy HTML error pages are markup, not an explanation.
+    if (!text || /^<(?:!doctype|html)/i.test(text))
+        return fallback;
+    return `${fallback}: ${text.length > MAX_BODY_CHARS ? `${text.slice(0, MAX_BODY_CHARS)}…` : text}`;
 };
 const statusError = (response) => Effect.gen(function* () {
     if (response.status < 400)

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/schema/events.d.ts

@@ -1266,8 +1266,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
     } | {
         readonly id: string;
         readonly type: "tool-error";
-        readonly name: string;
         readonly message: string;
+        readonly name: string;
         readonly error?: unknown;
         readonly providerMetadata?: {
             readonly [x: string]: {
@@ -1513,8 +1513,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
     }> | Extract<{
         readonly id: string;
         readonly type: "tool-error";
-        readonly name: string;
         readonly message: string;
+        readonly name: string;
         readonly error?: unknown;
         readonly providerMetadata?: {
             readonly [x: string]: {
@@ -1750,8 +1750,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
         "tool-error": (u: unknown) => u is {
             readonly id: string;
             readonly type: "tool-error";
-            readonly name: string;
             readonly message: string;
+            readonly name: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -1983,8 +1983,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
             "tool-error": (value: {
                 readonly id: string;
                 readonly type: "tool-error";
-                readonly name: string;
                 readonly message: string;
+                readonly name: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -2199,8 +2199,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
         } | {
             readonly id: string;
             readonly type: "tool-error";
-            readonly name: string;
             readonly message: string;
+            readonly name: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -2426,8 +2426,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
             "tool-error": (value: {
                 readonly id: string;
                 readonly type: "tool-error";
-                readonly name: string;
                 readonly message: string;
+                readonly name: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -2642,8 +2642,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
         } | {
             readonly id: string;
             readonly type: "tool-error";
-            readonly name: string;
             readonly message: string;
+            readonly name: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -2871,8 +2871,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
             "tool-error"?: ((value: {
                 readonly id: string;
                 readonly type: "tool-error";
-                readonly name: string;
                 readonly message: string;
+                readonly name: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -3123,8 +3123,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
         }> | Exclude<{
             readonly id: string;
             readonly type: "tool-error";
-            readonly name: string;
             readonly message: string;
+            readonly name: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -3344,8 +3344,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
         } | {
             readonly id: string;
             readonly type: "tool-error";
-            readonly name: string;
             readonly message: string;
+            readonly name: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -3571,8 +3571,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
             "tool-error"?: ((value: {
                 readonly id: string;
                 readonly type: "tool-error";
-                readonly name: string;
                 readonly message: string;
+                readonly name: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -3823,8 +3823,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
         }> | Exclude<{
             readonly id: string;
             readonly type: "tool-error";
-            readonly name: string;
             readonly message: string;
+            readonly name: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -4044,8 +4044,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
         } | {
             readonly id: string;
             readonly type: "tool-error";
-            readonly name: string;
             readonly message: string;
+            readonly name: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -4287,8 +4287,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
     toolError: (input: WithID<ToolError, ToolCallID>) => {
         readonly id: string;
         readonly type: "tool-error";
-        readonly name: string;
         readonly message: string;
+        readonly name: string;
         readonly error?: unknown;
         readonly providerMetadata?: {
             readonly [x: string]: {
@@ -4535,8 +4535,8 @@ export declare const LLMEvent: Schema.Union<readonly [Schema.refine<{
         toolError: (u: unknown) => u is {
             readonly id: string;
             readonly type: "tool-error";
-            readonly name: string;
             readonly message: string;
+            readonly name: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -5249,8 +5249,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
         } | {
             readonly id: string;
             readonly type: "tool-error";
-            readonly name: string;
             readonly message: string;
+            readonly name: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -5496,8 +5496,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
         }> | Extract<{
             readonly id: string;
             readonly type: "tool-error";
-            readonly name: string;
             readonly message: string;
+            readonly name: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -5733,8 +5733,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             "tool-error": (u: unknown) => u is {
                 readonly id: string;
                 readonly type: "tool-error";
-                readonly name: string;
                 readonly message: string;
+                readonly name: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -5966,8 +5966,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 "tool-error": (value: {
                     readonly id: string;
                     readonly type: "tool-error";
-                    readonly name: string;
                     readonly message: string;
+                    readonly name: string;
                     readonly error?: unknown;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
@@ -6182,8 +6182,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             } | {
                 readonly id: string;
                 readonly type: "tool-error";
-                readonly name: string;
                 readonly message: string;
+                readonly name: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -6409,8 +6409,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 "tool-error": (value: {
                     readonly id: string;
                     readonly type: "tool-error";
-                    readonly name: string;
                     readonly message: string;
+                    readonly name: string;
                     readonly error?: unknown;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
@@ -6625,8 +6625,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             } | {
                 readonly id: string;
                 readonly type: "tool-error";
-                readonly name: string;
                 readonly message: string;
+                readonly name: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -6854,8 +6854,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 "tool-error"?: ((value: {
                     readonly id: string;
                     readonly type: "tool-error";
-                    readonly name: string;
                     readonly message: string;
+                    readonly name: string;
                     readonly error?: unknown;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
@@ -7106,8 +7106,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             }> | Exclude<{
                 readonly id: string;
                 readonly type: "tool-error";
-                readonly name: string;
                 readonly message: string;
+                readonly name: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -7327,8 +7327,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             } | {
                 readonly id: string;
                 readonly type: "tool-error";
-                readonly name: string;
                 readonly message: string;
+                readonly name: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -7554,8 +7554,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
                 "tool-error"?: ((value: {
                     readonly id: string;
                     readonly type: "tool-error";
-                    readonly name: string;
                     readonly message: string;
+                    readonly name: string;
                     readonly error?: unknown;
                     readonly providerMetadata?: {
                         readonly [x: string]: {
@@ -7806,8 +7806,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             }> | Exclude<{
                 readonly id: string;
                 readonly type: "tool-error";
-                readonly name: string;
                 readonly message: string;
+                readonly name: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -8027,8 +8027,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             } | {
                 readonly id: string;
                 readonly type: "tool-error";
-                readonly name: string;
                 readonly message: string;
+                readonly name: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {
@@ -8270,8 +8270,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
         toolError: (input: WithID<ToolError, ToolCallID>) => {
             readonly id: string;
             readonly type: "tool-error";
-            readonly name: string;
             readonly message: string;
+            readonly name: string;
             readonly error?: unknown;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -8518,8 +8518,8 @@ declare const LLMResponse_base: Schema.Class<LLMResponse, Schema.Struct<{
             toolError: (u: unknown) => u is {
                 readonly id: string;
                 readonly type: "tool-error";
-                readonly name: string;
                 readonly message: string;
+                readonly name: string;
                 readonly error?: unknown;
                 readonly providerMetadata?: {
                     readonly [x: string]: {