@opencode/ai 2.0.22 → 2.0.24

package/dist/protocols/open-responses.js

@@ -121,8 +121,13 @@ export const ConfigurationUpdate = Schema.Struct({
     type: Schema.Literal("configuration_update"),
     reasoning: Schema.Struct({ effort: OpenResponsesOptions.ReasoningEffort }),
 });
+export const HostedToolReplay = Schema.StructWithRest(Schema.Struct({
+    type: Schema.String,
+    id: Schema.String,
+}), [JsonObject]);
 export const InputItem = Schema.Union([
     CompactionItem,
+    ConfigurationUpdate,
     Schema.Struct({ type: Schema.tag("message"), role: Schema.tag("system"), content: Schema.String }),
     Schema.Struct({ type: Schema.tag("message"), role: Schema.tag("developer"), content: Schema.String }),
     Schema.Struct({
@@ -155,6 +160,7 @@ export const InputItem = Schema.Union([
         output: OpenResponsesFunctionCallOutput,
     }),
     HostedToolItem,
+    HostedToolReplay,
 ]);
 export const Tool = Schema.Struct({
     type: Schema.tag("function"),
@@ -163,6 +169,9 @@ export const Tool = Schema.Struct({
     parameters: JsonObject,
     strict: Schema.optional(Schema.Boolean),
 });
+export const HostedTool = Schema.StructWithRest(Schema.Struct({
+    type: Schema.String,
+}), [JsonObject]);
 export const ToolChoice = Schema.Union([
     Schema.Literals(["auto", "none", "required"]),
     Schema.Struct({ type: Schema.tag("function"), name: Schema.String }),
@@ -180,7 +189,7 @@ export const coreFields = {
     model: Schema.String,
     input: Schema.Array(InputItem),
     instructions: Schema.optional(Schema.String),
-    tools: optionalArray(Tool),
+    tools: optionalArray(Schema.Union([Tool, HostedTool])),
     tool_choice: Schema.optional(ToolChoice),
     store: Schema.optional(Schema.Boolean),
     metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
@@ -208,20 +217,20 @@ export const coreFields = {
     presence_penalty: Schema.optional(Schema.Number),
     frequency_penalty: Schema.optional(Schema.Number),
 };
-const OpenResponsesBody = Schema.Struct({
+export const OpenResponsesBody = Schema.Struct({
     ...coreFields,
     stream: Schema.Literal(true),
 });
-export const OpenResponsesUsage = Schema.Struct({
+export const OpenResponsesUsage = Schema.StructWithRest(Schema.Struct({
     input_tokens: Schema.optional(Schema.Number),
-    input_tokens_details: optionalNull(Schema.Struct({
+    input_tokens_details: optionalNull(Schema.StructWithRest(Schema.Struct({
         cached_tokens: Schema.optional(Schema.Number),
         cache_write_tokens: Schema.optional(Schema.Number),
-    })),
+    }), [JsonObject])),
     output_tokens: Schema.optional(Schema.Number),
-    output_tokens_details: optionalNull(Schema.Struct({ reasoning_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),
-});
+}), [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
 // `output_item.done` and `response.completed.output`). Decode it as optional
@@ -280,7 +289,7 @@ const BASE_ADAPTER = { id: ADAPTER, name: NAME };
 // =============================================================================
 // Request Lowering
 // =============================================================================
-export const lowerTool = Effect.fn("OpenResponses.lowerTool")(function* (protocolName, tool) {
+export const lowerTool = Effect.fnUntraced(function* (protocolName, tool) {
     if (tool.native !== undefined)
         return yield* ProviderShared.invalidRequest(`${protocolName} does not support provider-native tool ${tool.name}`);
     return {
@@ -334,12 +343,15 @@ const lowerReasoning = (part, providerMetadataKey) => {
         encrypted_content: encryptedContent,
     };
 };
-const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (part, request, adapter, target) {
+const decodeImageDetail = ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenResponsesInputImage.fields.detail));
+const decodeMessageMetadata = ProviderShared.validateWith(Schema.decodeUnknownEffect(MessageMetadata));
+const lowerMedia = Effect.fnUntraced(function* (part, request, adapter, target) {
     const media = part.media.inline();
     const providerMedia = adapter.lowerMedia?.({ part, media, request });
     if (providerMedia)
         return providerMedia;
-    const detail = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenResponsesInputImage.fields.detail))(part.providerMetadata?.[metadataKey(request.model)]?.detail);
+    const rawDetail = part.providerMetadata?.[metadataKey(request.model)]?.detail;
+    const detail = rawDetail === undefined ? undefined : yield* decodeImageDetail(rawDetail);
     const mime = part.media.mediaType.toLowerCase();
     const url = ProviderShared.mediaUrl(part.media);
     const location = url ?? (yield* ProviderShared.requireInlineMedia(adapter.name, part.media)).dataUrl;
@@ -394,11 +406,12 @@ const lowerToolResultOutput = Effect.fnUntraced(function* (part, request, adapte
     return yield* Effect.forEach(content, (item) => lowerToolResultContentItem(item, request, adapter));
 });
 const DEFAULT_EFFORT = "medium";
-const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (request, adapter) {
+const lowerMessages = Effect.fnUntraced(function* (request, adapter) {
     const input = [];
     const providerMetadataKey = metadataKey(request.model);
     for (const message of request.messages) {
-        const metadata = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Schema.UndefinedOr(MessageMetadata)))(message.providerMetadata?.[providerMetadataKey]);
+        const rawMetadata = message.providerMetadata?.[providerMetadataKey];
+        const metadata = rawMetadata === undefined ? undefined : yield* decodeMessageMetadata(rawMetadata);
         if (message.role === "system") {
             const update = effortUpdate(message);
             if (update) {
@@ -546,7 +559,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
     }
     return input;
 });
-export const lowerConversation = Effect.fn("OpenResponses.lowerConversation")(function* (request, adapter) {
+export const lowerConversation = Effect.fnUntraced(function* (request, adapter) {
     const instructions = ProviderShared.joinText(request.system);
     return {
         model: request.model.id,
@@ -611,10 +624,7 @@ export const fromRequestWithAdapter = Effect.fn("OpenResponses.fromRequestWithAd
             (request.toolChoice ? yield* lowerToolChoice(adapter.name, request.toolChoice) : undefined),
     };
 });
-const decodeBody = ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenResponsesBody));
-export const fromRequest = Effect.fn("OpenResponses.fromRequest")(function* (request) {
-    return yield* decodeBody(yield* fromRequestWithAdapter(request, BASE_ADAPTER));
-});
+export const fromRequest = (request) => fromRequestWithAdapter(request, BASE_ADAPTER);
 // =============================================================================
 // Stream Parsing
 // =============================================================================
@@ -892,7 +902,7 @@ const onReasoningSummaryPartDone = (state, event) => {
         NO_EVENTS,
     ];
 };
-const onFunctionCallArgumentsDelta = Effect.fn("OpenResponses.onFunctionCallArgumentsDelta")(function* (state, event) {
+const onFunctionCallArgumentsDelta = Effect.fnUntraced(function* (state, event) {
     if (event.item_id === undefined)
         return [state, NO_EVENTS];
     const tool = state.tools[event.item_id];
@@ -917,7 +927,7 @@ const onFunctionCallArgumentsDelta = Effect.fn("OpenResponses.onFunctionCallArgu
     events.push(...result.events);
     return [{ ...state, lifecycle, tools: result.tools }, events];
 });
-const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (state, item) {
+const onOutputItemDone = Effect.fnUntraced(function* (state, item) {
     if (!item)
         return [state, NO_EVENTS];
     if (item.type === "compaction") {
@@ -1045,7 +1055,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
     }
     return [state, NO_EVENTS];
 });
-const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (state, event) {
+const onResponseFinish = Effect.fnUntraced(function* (state, event) {
     let current = state;
     const events = [];
     if (event.type === "response.completed") {

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

@@ -18,6 +18,19 @@ declare const ExtraContent: Schema.Struct<{
         readonly thought_signature: Schema.String;
     }>;
 }>;
+export declare const OpenAIChatAssistantToolCall: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly type: Schema.tag<"function">;
+    readonly function: 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;
+        }>;
+    }>>;
+}>;
 declare const ReasoningDetail: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
     readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
     readonly format: Schema.optional<Schema.String>;
@@ -49,6 +62,88 @@ declare const ReasoningDetail: Schema.Union<readonly [Schema.StructWithRest<Sche
     readonly index: Schema.optional<Schema.Number>;
 }>]>;
 type ReasoningDetail = Schema.Schema.Type<typeof ReasoningDetail>;
+export declare const OpenAIChatMessage: Schema.toTaggedUnion<"role", readonly [Schema.Struct<{
+    readonly role: Schema.Literal<"system">;
+    readonly content: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly cache_control: Schema.optional<Schema.Struct<{
+            readonly type: Schema.Literal<"ephemeral">;
+            readonly ttl: Schema.optional<Schema.String>;
+        }>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image_url">;
+        readonly image_url: Schema.Struct<{
+            readonly url: Schema.String;
+        }>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"file">;
+        readonly file: Schema.Struct<{
+            readonly filename: Schema.String;
+            readonly file_data: Schema.String;
+        }>;
+    }>]>>]>;
+}>, Schema.Struct<{
+    readonly role: Schema.Literal<"user">;
+    readonly content: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly cache_control: Schema.optional<Schema.Struct<{
+            readonly type: Schema.Literal<"ephemeral">;
+            readonly ttl: Schema.optional<Schema.String>;
+        }>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"image_url">;
+        readonly image_url: Schema.Struct<{
+            readonly url: Schema.String;
+        }>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"file">;
+        readonly file: Schema.Struct<{
+            readonly filename: Schema.String;
+            readonly file_data: Schema.String;
+        }>;
+    }>]>>]>;
+}>, Schema.StructWithRest<Schema.Struct<{
+    readonly role: Schema.Literal<"assistant">;
+    readonly content: Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly cache_control: Schema.optional<Schema.Struct<{
+            readonly type: Schema.Literal<"ephemeral">;
+            readonly ttl: Schema.optional<Schema.String>;
+        }>>;
+    }>>]>>;
+    readonly tool_calls: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly type: Schema.tag<"function">;
+        readonly function: 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>;
+    readonly reasoning_text: Schema.optional<Schema.String>;
+    readonly reasoning_details: Schema.optional<Schema.Unknown>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, Schema.Struct<{
+    readonly role: Schema.Literal<"tool">;
+    readonly tool_call_id: Schema.String;
+    readonly content: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly cache_control: Schema.optional<Schema.Struct<{
+            readonly type: Schema.Literal<"ephemeral">;
+            readonly ttl: Schema.optional<Schema.String>;
+        }>>;
+    }>>]>;
+}>]>;
+type OpenAIChatMessage = Schema.Schema.Type<typeof OpenAIChatMessage>;
 export declare const bodyFields: {
     model: Schema.String;
     messages: Schema.$Array<Schema.toTaggedUnion<"role", readonly [Schema.Struct<{
@@ -288,6 +383,89 @@ declare const OpenAIChatBody: Schema.Struct<{
     stop: Schema.optional<Schema.$Array<Schema.String>>;
 }>;
 export type OpenAIChatBody = Schema.Schema.Type<typeof OpenAIChatBody>;
+export declare const OpenAIChatUsage: Schema.StructWithRest<Schema.Struct<{
+    readonly prompt_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly completion_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly total_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly cached_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly prompt_cache_hit_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly cache_read_input_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly cache_created_input_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly prompt_tokens_details: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
+        readonly cached_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly cache_write_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+    readonly completion_tokens_details: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
+        readonly reasoning_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly accepted_prediction_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly rejected_prediction_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+export declare const OpenAIChatToolCallDelta: Schema.Struct<{
+    readonly index: Schema.optional<Schema.NullOr<Schema.Number>>;
+    readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly function: Schema.optional<Schema.NullOr<Schema.Struct<{
+        readonly name: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly arguments: Schema.optional<Schema.NullOr<Schema.String>>;
+    }>>>;
+    readonly extra_content: Schema.optional<Schema.NullOr<Schema.Unknown>>;
+}>;
+export declare const OpenAIChatDelta: Schema.StructWithRest<Schema.Struct<{
+    readonly content: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly refusal: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly reasoning_content: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly reasoning: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly reasoning_text: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly reasoning_details: Schema.optional<Schema.NullOr<Schema.Unknown>>;
+    readonly tool_calls: Schema.optional<Schema.NullOr<Schema.$Array<Schema.Struct<{
+        readonly index: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly function: Schema.optional<Schema.NullOr<Schema.Struct<{
+            readonly name: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly arguments: Schema.optional<Schema.NullOr<Schema.String>>;
+        }>>>;
+        readonly extra_content: Schema.optional<Schema.NullOr<Schema.Unknown>>;
+    }>>>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+export declare const OpenAIChatChoice: Schema.StructWithRest<Schema.Struct<{
+    readonly delta: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
+        readonly content: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly refusal: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly reasoning_content: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly reasoning: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly reasoning_text: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly reasoning_details: Schema.optional<Schema.NullOr<Schema.Unknown>>;
+        readonly tool_calls: Schema.optional<Schema.NullOr<Schema.$Array<Schema.Struct<{
+            readonly index: Schema.optional<Schema.NullOr<Schema.Number>>;
+            readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
+            readonly function: Schema.optional<Schema.NullOr<Schema.Struct<{
+                readonly name: Schema.optional<Schema.NullOr<Schema.String>>;
+                readonly arguments: Schema.optional<Schema.NullOr<Schema.String>>;
+            }>>>;
+            readonly extra_content: Schema.optional<Schema.NullOr<Schema.Unknown>>;
+        }>>>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+    readonly finish_reason: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly native_finish_reason: Schema.optional<Schema.NullOr<Schema.String>>;
+    readonly usage: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
+        readonly prompt_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly completion_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly total_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly cached_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly prompt_cache_hit_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly cache_read_input_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly cache_created_input_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+        readonly prompt_tokens_details: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
+            readonly cached_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+            readonly cache_write_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+        readonly completion_tokens_details: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
+            readonly reasoning_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+            readonly accepted_prediction_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+            readonly rejected_prediction_tokens: Schema.optional<Schema.NullOr<Schema.Number>>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
 export declare const OpenAIChatEvent: Schema.StructWithRest<Schema.Struct<{
     readonly choices: Schema.optional<Schema.NullOr<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
         readonly delta: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
@@ -379,6 +557,8 @@ export interface ParserState {
 interface LoweringOptions {
     readonly cacheControl?: (cache: CacheHint | undefined) => OpenAIChatCacheControl | undefined;
     readonly toolCallID?: (id: string) => string;
+    /** Project provider-specific fields from the exact source, even when other messages are dropped during lowering. */
+    readonly assistant?: (source: LLMRequest["messages"][number], message: OpenAIChatMessage) => OpenAIChatMessage;
 }
 export declare const fromRequest: (request: LLMRequest<import("../schema/options.js").LanguageModel<{
     readonly [x: string]: unknown;
@@ -623,6 +803,222 @@ export declare const fromRequest: (request: LLMRequest<import("../schema/options
     } | undefined;
     stream: true;
 }, AIError, never>;
+export declare const finishEvents: (state: ParserState) => Effect.Effect<(({
+    readonly type: "compaction";
+    readonly provider: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    readonly id?: string | undefined;
+    readonly text?: string | null | undefined;
+    readonly encrypted?: string | undefined;
+} & ({
+    readonly encrypted: string;
+    readonly text?: never;
+} | {
+    readonly text: string | null;
+    readonly encrypted?: never;
+})) | {
+    readonly type: "step-start";
+    readonly index: number;
+} | {
+    readonly id: string;
+    readonly type: "text-start";
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+} | {
+    readonly id: string;
+    readonly type: "text-delta";
+    readonly text: string;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+} | {
+    readonly id: string;
+    readonly type: "text-end";
+    readonly text?: string | undefined;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+} | {
+    readonly id: string;
+    readonly type: "reasoning-start";
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+} | {
+    readonly id: string;
+    readonly type: "reasoning-delta";
+    readonly text: string;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+} | {
+    readonly id: string;
+    readonly type: "reasoning-end";
+    readonly text?: string | undefined;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+} | {
+    readonly id: string;
+    readonly type: "tool-input-start";
+    readonly name: string;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+    readonly namespace?: string | undefined;
+    readonly providerExecuted?: boolean | undefined;
+} | {
+    readonly id: string;
+    readonly type: "tool-input-delta";
+    readonly name: string;
+    readonly text: string;
+    readonly input?: unknown;
+    readonly namespace?: string | undefined;
+} | {
+    readonly id: string;
+    readonly type: "tool-input-end";
+    readonly name: string;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+    readonly namespace?: string | undefined;
+} | {
+    readonly id: string;
+    readonly type: "tool-input-error";
+    readonly name: string;
+    readonly raw: string;
+    readonly namespace?: string | undefined;
+} | {
+    readonly id: string;
+    readonly type: "tool-call";
+    readonly name: string;
+    readonly input: unknown;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+    readonly namespace?: string | undefined;
+    readonly providerExecuted?: boolean | undefined;
+} | {
+    readonly id: string;
+    readonly type: "tool-result";
+    readonly name: string;
+    readonly result: {
+        readonly type: "json";
+        readonly value: unknown;
+    } | {
+        readonly type: "text";
+        readonly value: unknown;
+    } | {
+        readonly type: "error";
+        readonly value: unknown;
+    } | {
+        readonly type: "content";
+        readonly value: readonly ({
+            readonly type: "text";
+            readonly text: string;
+        } | {
+            readonly type: "file";
+            readonly uri: string;
+            readonly mime: string;
+            readonly name?: string | undefined;
+        })[];
+    };
+    readonly output?: {
+        readonly structured: unknown;
+        readonly content: readonly ({
+            readonly type: "text";
+            readonly text: string;
+        } | {
+            readonly type: "file";
+            readonly uri: string;
+            readonly mime: string;
+            readonly name?: string | undefined;
+        })[];
+    } | undefined;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+    readonly namespace?: string | undefined;
+    readonly providerExecuted?: boolean | undefined;
+} | {
+    readonly id: string;
+    readonly type: "tool-error";
+    readonly message: string;
+    readonly name: string;
+    readonly error?: unknown;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+    readonly namespace?: string | undefined;
+} | {
+    readonly type: "media";
+    readonly media: import("../media.js").Asset;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+} | {
+    readonly type: "step-finish";
+    readonly reason: {
+        readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly raw?: string | undefined;
+        readonly category?: string | undefined;
+        readonly explanation?: string | undefined;
+    };
+    readonly index: number;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+    readonly usage?: Usage | undefined;
+} | {
+    readonly type: "finish";
+    readonly reason: {
+        readonly normalized: "length" | "stop" | "tool-calls" | "content-filter" | "error" | "unknown";
+        readonly raw?: string | undefined;
+        readonly category?: string | undefined;
+        readonly explanation?: string | undefined;
+    };
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+    readonly usage?: Usage | undefined;
+} | {
+    readonly type: "provider-error";
+    readonly message: string;
+    readonly classification?: "context-overflow" | "payload-too-large" | undefined;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
+})[], AIError, never>;
 /**
  * The OpenAI Chat protocol — request body construction, body schema, and the
  * streaming-event state machine. Reused by every route that speaks OpenAI Chat
@@ -743,9 +1139,9 @@ export declare const protocol: Protocol<{
     readonly top_p?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
-    readonly store?: boolean | undefined;
     readonly stream_options?: {
         readonly include_usage: boolean;
     } | undefined;
@@ -761,9 +1157,9 @@ export declare const protocol: Protocol<{
         readonly [x: string]: unknown;
         readonly cache_read_input_tokens?: number | null | undefined;
         readonly cached_tokens?: number | null | undefined;
+        readonly total_tokens?: number | null | undefined;
         readonly prompt_tokens?: number | null | undefined;
         readonly completion_tokens?: number | null | undefined;
-        readonly total_tokens?: number | null | undefined;
         readonly prompt_tokens_details?: {
             readonly [x: string]: unknown;
             readonly cached_tokens?: number | null | undefined;
@@ -802,9 +1198,9 @@ export declare const protocol: Protocol<{
             readonly [x: string]: unknown;
             readonly cache_read_input_tokens?: number | null | undefined;
             readonly cached_tokens?: number | null | undefined;
+            readonly total_tokens?: number | null | undefined;
             readonly prompt_tokens?: number | null | undefined;
             readonly completion_tokens?: number | null | undefined;
-            readonly total_tokens?: number | null | undefined;
             readonly prompt_tokens_details?: {
                 readonly [x: string]: unknown;
                 readonly cached_tokens?: number | null | undefined;
@@ -938,9 +1334,9 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
     readonly top_p?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
-    readonly store?: boolean | undefined;
     readonly stream_options?: {
         readonly include_usage: boolean;
     } | undefined;
@@ -1060,9 +1456,9 @@ export declare const route: Route<{
     readonly top_p?: number | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
+    readonly store?: boolean | undefined;
     readonly prompt_cache_key?: string | undefined;
     readonly reasoning_effort?: import("../schema/options.js").ReasoningEffort | undefined;
-    readonly store?: boolean | undefined;
     readonly stream_options?: {
         readonly include_usage: boolean;
     } | undefined;