@opencode/ai 2.1.1 → 2.1.3

package/dist/protocols/alibaba-messages.d.ts

@@ -5,7 +5,7 @@ import { OpenResponsesOptions } from "./utils/open-responses-options.js";
 declare const Options: Schema.Struct<{
     readonly effort: Schema.optional<Schema.declare<OpenResponsesOptions.ReasoningEffort, OpenResponsesOptions.ReasoningEffort>>;
     readonly thinking: Schema.optional<Schema.Struct<{
-        readonly type: Schema.declare<"disabled" | "enabled" | (string & {}), "disabled" | "enabled" | (string & {})>;
+        readonly type: Schema.declare<import("../schema/options.js").OpenString<"disabled" | "enabled">, import("../schema/options.js").OpenString<"disabled" | "enabled">>;
         readonly budgetTokens: Schema.optional<Schema.Int>;
         readonly budget_tokens: Schema.optional<Schema.Int>;
     }>>;

package/dist/protocols/alibaba-messages.js

@@ -7,7 +7,7 @@ import { OpenResponsesOptions } from "./utils/open-responses-options.js";
 const Options = Schema.Struct({
     effort: Schema.optional(OpenResponsesOptions.ReasoningEffort),
     thinking: Schema.optional(Schema.Struct({
-        type: Schema.declare(Schema.is(Schema.String)),
+        type: ProviderShared.knownString(),
         budgetTokens: Schema.optional(Schema.Int),
         budget_tokens: Schema.optional(Schema.Int),
     })),

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

@@ -169,15 +169,15 @@ export declare const protocol: Protocol<{
     } | undefined;
     readonly top_logprobs?: number | undefined;
     readonly truncation?: "auto" | "disabled" | undefined;
-    readonly service_tier?: OpenResponsesOptions.ServiceTier | undefined;
+    readonly service_tier?: import("../index.js").OpenString<"auto" | "default" | "flex" | "priority"> | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly include?: readonly OpenResponsesOptions.ResponseIncludable[] | undefined;
+    readonly include?: readonly import("../index.js").OpenString<"code_interpreter_call.outputs" | "computer_call_output.output.image_url" | "file_search_call.results" | "message.input_image.image_url" | "message.output_text.logprobs" | "reasoning.encrypted_content" | "web_search_call.action.sources" | "web_search_call.results">[] | undefined;
     readonly reasoning?: {
         readonly effort?: OpenResponsesOptions.ReasoningEffort | undefined;
         readonly summary?: "auto" | "concise" | "detailed" | undefined;
     } | undefined;
     readonly text?: {
-        readonly verbosity?: OpenResponsesOptions.TextVerbosity | undefined;
+        readonly verbosity?: import("../index.js").OpenString<"high" | "low" | "medium"> | undefined;
     } | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;

package/dist/protocols/anthropic-messages.js

@@ -400,13 +400,13 @@ const cacheControl = (breakpoints, cache) => {
 const providerMetadata = (key, metadata) => ({ [key]: metadata });
 const signatureFromMetadata = (metadata, key) => {
     const provider = metadata?.[key];
-    if (!ProviderShared.isRecord(provider))
+    if (!provider)
         return undefined;
     return typeof provider.signature === "string" ? provider.signature : undefined;
 };
 const redactedDataFromMetadata = (metadata, key) => {
     const provider = metadata?.[key];
-    if (!ProviderShared.isRecord(provider))
+    if (!provider)
         return undefined;
     return typeof provider.redactedData === "string" ? provider.redactedData : undefined;
 };
@@ -477,7 +477,7 @@ const lowerServerToolResult = Effect.fnUntraced(function* (part, providerMetadat
     };
 });
 const fileIdFromMetadata = (metadata) => {
-    if (!ProviderShared.isRecord(metadata))
+    if (!metadata)
         return undefined;
     const anthropic = metadata.anthropic;
     if (ProviderShared.isRecord(anthropic)) {
@@ -493,7 +493,7 @@ const fileIdFromMetadata = (metadata) => {
     return undefined;
 };
 const transformationsFromMetadata = (metadata) => {
-    if (!ProviderShared.isRecord(metadata))
+    if (!metadata)
         return undefined;
     const anthropic = ProviderShared.isRecord(metadata.anthropic) ? metadata.anthropic : undefined;
     const raw = anthropic?.transformations ?? metadata.transformations;
@@ -507,19 +507,19 @@ const transformationsFromMetadata = (metadata) => {
     return undefined;
 };
 const documentTitleFromPart = (part) => {
-    if (ProviderShared.isRecord(part.metadata)) {
+    if (part.metadata !== undefined) {
         const anthropic = part.metadata.anthropic;
         if (ProviderShared.isRecord(anthropic) && typeof anthropic.title === "string")
             return anthropic.title;
         if (typeof part.metadata.title === "string")
             return part.metadata.title;
     }
-    if (typeof part.filename === "string" && part.filename.length > 0)
+    if (part.filename && part.filename.length > 0)
         return part.filename;
     return undefined;
 };
 const documentContextFromMetadata = (metadata) => {
-    if (!ProviderShared.isRecord(metadata))
+    if (!metadata)
         return undefined;
     const anthropic = ProviderShared.isRecord(metadata.anthropic) ? metadata.anthropic : undefined;
     if (anthropic && typeof anthropic.context === "string")
@@ -529,7 +529,7 @@ const documentContextFromMetadata = (metadata) => {
     return undefined;
 };
 const citationsFromMetadata = (metadata) => {
-    if (!ProviderShared.isRecord(metadata))
+    if (!metadata)
         return undefined;
     const raw = ProviderShared.isRecord(metadata.anthropic)
         ? (metadata.anthropic.citations ?? metadata.citations)
@@ -796,7 +796,7 @@ const lowerMessages = Effect.fnUntraced(function* (request, breakpoints) {
                         content.push({ type: "redacted_thinking", data: redactedData });
                         continue;
                     }
-                    if (typeof signature !== "string" || signature.trim().length === 0) {
+                    if (!signature || signature.trim().length === 0) {
                         if (part.text.trim().length === 0)
                             continue;
                         if (!requireThinkingSignature(request)) {
@@ -1044,9 +1044,7 @@ const isServerToolResultType = (type) => type in SERVER_TOOL_RESULT_NAMES;
 const serverToolResultEvent = (block, providerMetadataKey) => {
     if (!block.type || !isServerToolResultType(block.type))
         return undefined;
-    const errorPayload = typeof block.content === "object" && block.content !== null && "type" in block.content
-        ? String(block.content.type)
-        : "";
+    const errorPayload = ProviderShared.isRecord(block.content) && "type" in block.content ? String(block.content.type) : "";
     const isError = errorPayload.endsWith("_tool_result_error");
     return LLMEvent.toolResult({
         id: block.tool_use_id ?? "",

package/dist/protocols/bedrock-converse.d.ts

@@ -260,58 +260,8 @@ export declare const protocol: Protocol<{
         readonly [x: string]: unknown;
     } | undefined;
 }, {
-    readonly messageStart?: {
-        readonly role: string;
-    } | undefined;
-    readonly contentBlockStart?: {
-        readonly contentBlockIndex: number;
-        readonly start?: {
-            readonly toolUse?: {
-                readonly toolUseId: string;
-                readonly name: string;
-            } | undefined;
-        } | undefined;
-    } | undefined;
-    readonly contentBlockDelta?: {
-        readonly contentBlockIndex: number;
-        readonly delta?: {
-            readonly text?: string | undefined;
-            readonly toolUse?: {
-                readonly input: string;
-            } | undefined;
-            readonly reasoningContent?: {
-                readonly text?: string | undefined;
-                readonly signature?: string | undefined;
-                readonly redactedContent?: string | undefined;
-                readonly data?: string | undefined;
-            } | undefined;
-        } | undefined;
-    } | undefined;
-    readonly contentBlockStop?: {
-        readonly contentBlockIndex: number;
-    } | undefined;
-    readonly messageStop?: {
-        readonly stopReason: string;
-        readonly additionalModelResponseFields?: unknown;
-    } | undefined;
-    readonly metadata?: {
-        readonly usage?: {
-            readonly inputTokens?: number | undefined;
-            readonly outputTokens?: number | undefined;
-            readonly totalTokens?: number | undefined;
-            readonly cacheReadInputTokens?: number | undefined;
-            readonly cacheWriteInputTokens?: number | undefined;
-        } | undefined;
-        readonly metrics?: unknown;
-    } | undefined;
-    readonly exception?: {
-        readonly type: string;
-        readonly details: {
-            readonly message?: string | undefined;
-            readonly originalMessage?: string | undefined;
-            readonly originalStatusCode?: number | undefined;
-        };
-    } | undefined;
+    readonly [x: string]: unknown;
+    readonly rawBody: string;
 }, {
     readonly messageStart?: {
         readonly role: string;
@@ -497,6 +447,9 @@ export declare const route: Route<{
     readonly additionalModelRequestFields?: {
         readonly [x: string]: unknown;
     } | undefined;
-}, import("../route/transport/http.js").HttpPrepared<object>, import("../route/client.js").CompactionOperations | undefined>;
+}, import("../route/transport/http.js").HttpPrepared<{
+    readonly [x: string]: unknown;
+    readonly rawBody: string;
+}>, import("../route/client.js").CompactionOperations | undefined>;
 export declare const sigV4Auth: typeof BedrockAuth.sigV4;
 export * as BedrockConverse from "./bedrock-converse.js";

package/dist/protocols/bedrock-converse.js

@@ -189,12 +189,12 @@ const reasoningSignature = (part, providerMetadataKey) => {
     const metadata = part.providerMetadata?.[providerMetadataKey];
     if (part.encrypted !== undefined)
         return part.encrypted;
-    if (ProviderShared.isRecord(metadata) && typeof metadata.signature === "string")
+    if (typeof metadata?.signature === "string")
         return metadata.signature;
 };
 const reasoningRedactedData = (part, providerMetadataKey) => {
     const metadata = part.providerMetadata?.[providerMetadataKey];
-    if (ProviderShared.isRecord(metadata) && typeof metadata.redactedData === "string")
+    if (typeof metadata?.redactedData === "string")
         return metadata.redactedData;
 };
 const removeEmptyToolInputKeys = (input) => {
@@ -647,6 +647,7 @@ const step = (state, event) => Effect.gen(function* () {
         return yield* new AIError({
             reason: classifyProviderFailure({
                 message,
+                status: event.exception.details.originalStatusCode,
                 rawBody: body,
             }),
         });
@@ -690,7 +691,7 @@ export const protocol = Protocol.make({
         from: fromRequest,
     },
     stream: {
-        event: BedrockEvent,
+        event: BedrockEventStream.Frame.pipe(Schema.decodeTo(BedrockEvent)),
         initial: (request) => ({
             providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
             tools: ToolStream.empty(),

package/dist/protocols/bedrock-event-stream.d.ts

@@ -1,9 +1,14 @@
+import { Schema } from "effect";
 import { Framing } from "../route/framing.js";
+export declare const Frame: Schema.StructWithRest<Schema.Struct<{
+    readonly rawBody: Schema.String;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
+export type Frame = typeof Frame.Type;
 /**
  * AWS event-stream framing for Bedrock Converse. Each frame is decoded by
  * `@smithy/eventstream-codec` (length + header + payload + CRC) and rewrapped
  * under its `:event-type` header so the chunk schema can match the JSON
  * payload directly.
  */
-export declare const framing: (route: string) => Framing.Definition<object>;
+export declare const framing: (route: string) => Framing.Definition<Frame>;
 export * as BedrockEventStream from "./bedrock-event-stream.js";

package/dist/protocols/bedrock-event-stream.js

@@ -1,6 +1,6 @@
 import { EventStreamCodec } from "@smithy/eventstream-codec";
 import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
-import { Effect, Stream } from "effect";
+import { Effect, Schema, Stream } from "effect";
 import { Base64 } from "effect/encoding";
 import { AIError, AIErrorReason, InvalidProviderOutputError } from "../schema/index.js";
 import { Framing } from "../route/framing.js";
@@ -12,6 +12,7 @@ import { ProviderShared } from "./shared.js";
 const eventCodec = new EventStreamCodec(toUtf8, fromUtf8);
 const utf8 = new TextDecoder();
 const initialFrameBuffer = { buffer: new Uint8Array(0), offset: 0 };
+export const Frame = Schema.StructWithRest(Schema.Struct({ rawBody: Schema.String }), [ProviderShared.JsonObject]);
 const endOfStream = { _tag: "End" };
 const appendChunk = (state, chunk) => {
     const remaining = state.buffer.length - state.offset;
@@ -71,14 +72,14 @@ const consumeFrames = (route) => (state, input) => Effect.gen(function* () {
         // before handing the object to the chunk schema. JSON decode goes
         // through the shared Schema-driven codec to satisfy the package rule
         // against ad-hoc `JSON.parse` calls.
-        const parsed = (yield* ProviderShared.parseJson(route, payload, "Failed to parse Bedrock Converse event-stream payload").pipe(Effect.mapError((error) => new AIError({
+        const parsed = yield* ProviderShared.parseJson(route, payload, "Failed to parse Bedrock Converse event-stream payload").pipe(Effect.mapError((error) => new AIError({
             reason: AIErrorReason.make({ ...error.reason, message: error.message, cause: error.reason.cause, body }),
-        }))));
-        delete parsed.p;
+        })));
+        if (!ProviderShared.isRecord(parsed))
+            return yield* ProviderShared.eventError(route, "Failed to parse Bedrock Converse event-stream payload", body);
+        const { p: _, ...event } = parsed;
         out.push({
-            ...(messageType === "exception"
-                ? { exception: { type: eventType, details: parsed } }
-                : { [eventType]: parsed }),
+            ...(messageType === "exception" ? { exception: { type: eventType, details: event } } : { [eventType]: event }),
             rawBody: body,
         });
     }
@@ -92,7 +93,7 @@ const consumeFrames = (route) => (state, input) => Effect.gen(function* () {
  */
 export const framing = (route) => ({
     id: "aws-event-stream",
-    body: (frame) => ("rawBody" in frame && typeof frame.rawBody === "string" ? frame.rawBody : undefined),
+    body: (frame) => frame.rawBody,
     frame: (bytes) => bytes.pipe(Stream.map((bytes) => ({ _tag: "Chunk", bytes })), Stream.concat(Stream.succeed(endOfStream)), Stream.mapAccumEffect(() => initialFrameBuffer, consumeFrames(route))),
 });
 export * as BedrockEventStream from "./bedrock-event-stream.js";

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

@@ -49,7 +49,9 @@ export declare const protocol: Protocol<{
         readonly function: {
             readonly name: string;
             readonly description?: string | undefined;
-            readonly parameters: unknown;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
         };
     }[] | undefined;
     readonly tool_choice?: "NONE" | "REQUIRED" | undefined;
@@ -161,7 +163,9 @@ export declare const route: Route<{
         readonly function: {
             readonly name: string;
             readonly description?: string | undefined;
-            readonly parameters: unknown;
+            readonly parameters: {
+                readonly [x: string]: unknown;
+            };
         };
     }[] | undefined;
     readonly tool_choice?: "NONE" | "REQUIRED" | undefined;

package/dist/protocols/cohere-chat.js

@@ -4,7 +4,7 @@ import { Endpoint } from "../route/endpoint.js";
 import { Framing } from "../route/framing.js";
 import { Protocol } from "../route/protocol.js";
 import { LLMEvent, Usage } from "../schema/index.js";
-import { ProviderShared } from "./shared.js";
+import { JsonObject, ProviderShared } from "./shared.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "cohere-chat";
@@ -41,7 +41,7 @@ const Body = Schema.Struct({
         function: Schema.Struct({
             name: Schema.String,
             description: Schema.optional(Schema.String),
-            parameters: Schema.Unknown,
+            parameters: JsonObject,
         }),
     }))),
     tool_choice: Schema.optional(Schema.Literals(["NONE", "REQUIRED"])),

package/dist/protocols/gemini.d.ts

@@ -239,7 +239,12 @@ export declare const protocol: Protocol<{
     } | undefined;
     readonly continuationToken?: string | undefined;
 }, NextRequest | {
-    readonly error?: unknown;
+    readonly error?: {
+        readonly [x: string]: unknown;
+        readonly code?: number | undefined;
+        readonly message?: string | undefined;
+        readonly status?: string | undefined;
+    } | undefined;
     readonly candidates?: readonly {
         readonly content?: {
             readonly role?: "model" | "user" | null | undefined;
@@ -261,7 +266,12 @@ export declare const protocol: Protocol<{
         readonly totalTokenCount?: number | null | undefined;
     } | null | undefined;
 }, NextRequest | {
-    readonly error?: unknown;
+    readonly error?: {
+        readonly [x: string]: unknown;
+        readonly code?: number | undefined;
+        readonly message?: string | undefined;
+        readonly status?: string | undefined;
+    } | undefined;
     readonly candidates?: readonly {
         readonly content?: {
             readonly role?: "model" | "user" | null | undefined;

package/dist/protocols/gemini.js

@@ -182,8 +182,13 @@ const GeminiPromptFeedback = Schema.StructWithRest(Schema.Struct({
     blockReasonMessage: optionalNull(Schema.String),
     safetyRatings: optionalNull(Schema.Unknown),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
+const GeminiError = Schema.StructWithRest(Schema.Struct({
+    code: lenient(Schema.Number),
+    message: lenient(Schema.String),
+    status: lenient(Schema.String),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
 const GeminiEvent = Schema.Struct({
-    error: Schema.optional(Schema.Unknown),
+    error: Schema.optional(GeminiError),
     candidates: optionalNull(Schema.Array(GeminiCandidate)),
     promptFeedback: optionalNull(GeminiPromptFeedback),
     usageMetadata: optionalNull(GeminiUsage),
@@ -211,9 +216,7 @@ const lowerContentPart = Effect.fnUntraced(function* (part) {
 const providerMetadata = (key, metadata) => ({ [key]: metadata });
 const thoughtSignature = (metadata, key) => {
     const value = metadata?.[key];
-    return ProviderShared.isRecord(value) && typeof value.thoughtSignature === "string"
-        ? value.thoughtSignature
-        : undefined;
+    return typeof value?.thoughtSignature === "string" ? value.thoughtSignature : undefined;
 };
 const lowerToolCall = (part, omitIds, metadataKey) => ({
     functionCall: { ...(omitIds ? {} : { id: part.id }), name: part.name, args: part.input },
@@ -511,22 +514,16 @@ const step = (state, event) => {
             },
             [],
         ]);
-    if (ProviderShared.isRecord(event.error)) {
+    if (event.error) {
         const body = ProviderShared.encodeJson(event);
         return Effect.fail(new AIError({
             reason: classifyProviderFailure({
-                message: typeof event.error.message === "string" && event.error.message.length > 0
-                    ? event.error.message
-                    : typeof event.error.status === "string" && event.error.status.length > 0
-                        ? event.error.status
-                        : "Gemini provider error",
-                status: typeof event.error.code === "number" ? event.error.code : undefined,
+                message: event.error.message || event.error.status || "Gemini provider error",
+                status: event.error.code,
                 rawBody: body,
             }),
         }));
     }
-    if ("error" in event)
-        return Effect.fail(ProviderShared.eventError(state.route, `Invalid ${state.route} stream event`, ProviderShared.encodeJson(event)));
     const candidate = event.candidates?.[0];
     const nextState = {
         ...state,

package/dist/protocols/google-interactions.d.ts

@@ -137,7 +137,8 @@ export declare const protocol: Protocol<{
             readonly text: string;
         };
     } | {
-        readonly type: string;
+        readonly type: "unknown";
+        readonly rawType: string;
     };
 } | {
     readonly event_type: "step.stop";

package/dist/protocols/google-interactions.js

@@ -108,13 +108,20 @@ const OutputStep = Schema.Struct({
     summary: Schema.optional(Schema.Array(Text)),
     content: Schema.optional(Schema.Array(Schema.Struct({ type: Schema.String, text: Schema.optional(Schema.String) }))),
 });
+const KNOWN_DELTA_TYPES = new Set(["text", "arguments_delta", "thought_signature", "thought_summary"]);
+const UnknownDelta = Schema.Struct({
+    type: Schema.String.check(Schema.makeFilter((type) => !KNOWN_DELTA_TYPES.has(type))),
+}).pipe(Schema.decodeTo(Schema.Struct({ type: Schema.Literal("unknown"), rawType: Schema.String }), {
+    decode: SchemaGetter.transform((delta) => ({ type: "unknown", rawType: delta.type })),
+    encode: SchemaGetter.forbidden(() => "Unknown Google Interactions deltas are decode-only"),
+}));
 const Delta = Schema.Union([
     Schema.Struct({ type: Schema.Literal("text"), text: Schema.String }),
     Schema.Struct({ type: Schema.Literal("arguments_delta"), arguments: Schema.String }),
     Schema.Struct({ type: Schema.Literal("thought_signature"), signature: Schema.String }),
     Schema.Struct({ type: Schema.Literal("thought_summary"), content: Text }),
     // Unknown output modalities must fail explicitly rather than disappearing from a successful response.
-    Schema.Struct({ type: Schema.String }),
+    UnknownDelta,
 ]);
 const Interaction = Schema.StructWithRest(Schema.Struct({
     id: Schema.optional(Schema.String),
@@ -173,9 +180,7 @@ const mediaContent = Effect.fnUntraced(function* (asset) {
 });
 const signature = (metadata, key) => {
     const value = metadata?.[key];
-    return ProviderShared.isRecord(value) && typeof value.interactionSignature === "string"
-        ? value.interactionSignature
-        : undefined;
+    return typeof value?.interactionSignature === "string" ? value.interactionSignature : undefined;
 };
 const lowerMessages = Effect.fnUntraced(function* (request) {
     const steps = [];
@@ -362,17 +367,17 @@ const onDelta = Effect.fnUntraced(function* (state, index, delta) {
     if (!step)
         return yield* ProviderShared.eventError(ADAPTER, "Interactions delta without step.start", encodeJson(delta));
     const events = [];
-    if (delta.type === "text" && "text" in delta && step.type === "model_output")
+    if (delta.type === "text" && step.type === "model_output")
         return [
             { ...state, lifecycle: Lifecycle.textDelta(state.lifecycle, events, String(index), delta.text) },
             events,
         ];
-    if (delta.type === "thought_summary" && "content" in delta && step.type === "thought")
+    if (delta.type === "thought_summary" && step.type === "thought")
         return [
             { ...state, lifecycle: Lifecycle.reasoningDelta(state.lifecycle, events, String(index), delta.content.text) },
             events,
         ];
-    if (delta.type === "thought_signature" && "signature" in delta) {
+    if (delta.type === "thought_signature") {
         const next = { ...step, signature: delta.signature };
         const tool = state.tools[index];
         return [
@@ -384,13 +389,13 @@ const onDelta = Effect.fnUntraced(function* (state, index, delta) {
             events,
         ];
     }
-    if (delta.type === "arguments_delta" && "arguments" in delta && step.type === "function_call") {
+    if (delta.type === "arguments_delta" && step.type === "function_call") {
         const result = ToolStream.appendExisting(ADAPTER, state.tools, index, delta.arguments, "Interactions arguments without function call");
         if (ToolStream.isError(result))
             return yield* result;
         return [{ ...state, tools: result.tools }, result.events];
     }
-    return yield* ProviderShared.eventError(ADAPTER, `Unsupported Interactions delta: ${delta.type}`, encodeJson(delta));
+    return yield* ProviderShared.eventError(ADAPTER, `Unsupported Interactions delta: ${delta.type === "unknown" ? delta.rawType : delta.type}`, encodeJson(delta));
 });
 const onStop = Effect.fnUntraced(function* (state, index) {
     const step = state.steps[index];

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

@@ -183,15 +183,15 @@ export declare const protocol: Protocol<{
     } | undefined;
     readonly top_logprobs?: number | undefined;
     readonly truncation?: "auto" | "disabled" | undefined;
-    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
+    readonly service_tier?: import("../schema/options.js").OpenString<"auto" | "default" | "flex" | "priority"> | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly include?: readonly import("./utils/open-responses-options.js").ResponseIncludable[] | undefined;
+    readonly include?: readonly import("../schema/options.js").OpenString<"code_interpreter_call.outputs" | "computer_call_output.output.image_url" | "file_search_call.results" | "message.input_image.image_url" | "message.output_text.logprobs" | "reasoning.encrypted_content" | "web_search_call.action.sources" | "web_search_call.results">[] | undefined;
     readonly reasoning?: {
         readonly effort?: import("../schema/options.js").ReasoningEffort | undefined;
         readonly summary?: "auto" | "concise" | "detailed" | undefined;
     } | undefined;
     readonly text?: {
-        readonly verbosity?: import("./utils/open-responses-options.js").TextVerbosity | undefined;
+        readonly verbosity?: import("../schema/options.js").OpenString<"high" | "low" | "medium"> | undefined;
     } | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;
@@ -419,15 +419,15 @@ export declare const httpTransport: import("../route/transport/http.js").HttpJso
     } | undefined;
     readonly top_logprobs?: number | undefined;
     readonly truncation?: "auto" | "disabled" | undefined;
-    readonly service_tier?: import("./utils/open-responses-options.js").ServiceTier | undefined;
+    readonly service_tier?: import("../schema/options.js").OpenString<"auto" | "default" | "flex" | "priority"> | undefined;
     readonly prompt_cache_key?: string | undefined;
-    readonly include?: readonly import("./utils/open-responses-options.js").ResponseIncludable[] | undefined;
+    readonly include?: readonly import("../schema/options.js").OpenString<"code_interpreter_call.outputs" | "computer_call_output.output.image_url" | "file_search_call.results" | "message.input_image.image_url" | "message.output_text.logprobs" | "reasoning.encrypted_content" | "web_search_call.action.sources" | "web_search_call.results">[] | undefined;
     readonly reasoning?: {
         readonly effort?: import("../schema/options.js").ReasoningEffort | undefined;
         readonly summary?: "auto" | "concise" | "detailed" | undefined;
     } | undefined;
     readonly text?: {
-        readonly verbosity?: import("./utils/open-responses-options.js").TextVerbosity | undefined;
+        readonly verbosity?: import("../schema/options.js").OpenString<"high" | "low" | "medium"> | undefined;
     } | undefined;
     readonly max_output_tokens?: number | undefined;
     readonly max_tool_calls?: number | undefined;

package/dist/protocols/mistral-chat.js

@@ -290,9 +290,6 @@ const lowerTool = (tool) => ({
 });
 export const fromRequest = Effect.fn("MistralChat.fromRequest")(function* (request) {
     const options = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(MistralOptions))(request.providerOptions ?? {});
-    const selected = request.toolChoice?.type === "tool" ? request.toolChoice.name : undefined;
-    if (request.toolChoice?.type === "tool" && !selected)
-        return yield* ProviderShared.invalidRequest("Mistral Chat tool choice requires a tool name");
     if (options.reasoningEffort !== undefined && options.promptMode !== undefined)
         return yield* ProviderShared.invalidRequest("Mistral Chat reasoningEffort and promptMode provider options are mutually exclusive");
     const toolChoice = request.toolChoice
@@ -372,7 +369,7 @@ const thinkingUnits = (value) => {
         return [];
     return value.filter(Schema.is(MistralThinkingUnit));
 };
-const thinkingText = (thinking) => thinking.flatMap((unit) => (typeof unit.text === "string" ? [unit.text] : [])).join("");
+const thinkingText = (thinking) => thinking.flatMap((unit) => (unit.text !== undefined ? [unit.text] : [])).join("");
 const thinkingMetadata = (thinking) => ({ mistral: { thinking } });
 const closeActive = (state, events) => {
     if (!state.active)