smoltalk 0.8.1 → 0.8.3

package/dist/clients/ollama.js

@@ -4,6 +4,8 @@ import { getLogger } from "../util/logger.js";
 import { redactAttachments } from "../util/redact.js";
 import { success, } from "../types.js";
 import { zodToGoogleTool } from "../util/tool.js";
+import { responseFormatToJsonSchema } from "../util/jsonSchema.js";
+import { normalizeOllamaStopReason } from "../util/stopReason.js";
 import { sanitizeAttributes } from "../util/util.js";
 import { resolveBaseUrl } from "../util/provider.js";
 import { BaseClient } from "./baseClient.js";
@@ -81,7 +83,7 @@ export class SmolOllama extends BaseClient {
             request.tools = tools.map((t) => ({ type: "function", function: t }));
         }
         if (config.responseFormat) {
-            request.format = config.responseFormat.toJSONSchema();
+            request.format = responseFormatToJsonSchema(config.responseFormat);
         }
         Object.assign(request, sanitizeAttributes(config.rawAttributes));
         this.logger.debug("Sending request to Ollama:", JSON.stringify(redactAttachments(request), null, 2));
@@ -116,8 +118,20 @@ export class SmolOllama extends BaseClient {
         }
         // Extract usage and calculate cost
         const { usage, cost } = this.calculateUsageAndCost(result);
+        const rawStopReason = result.done_reason ?? undefined;
         // Return the response, updating the chat history
-        return success({ output, toolCalls, usage, cost, model: this.getModel() });
+        const promptResult = {
+            output,
+            toolCalls,
+            usage,
+            cost,
+            model: this.getModel(),
+            stopReason: normalizeOllamaStopReason(rawStopReason),
+        };
+        if (rawStopReason) {
+            promptResult.rawStopReason = rawStopReason;
+        }
+        return success(promptResult);
     }
     async *_textStream(config) {
         const messages = config.messages.map((msg) => msg.toOllamaMessage());
@@ -135,7 +149,7 @@ export class SmolOllama extends BaseClient {
             request.tools = tools.map((t) => ({ type: "function", function: t }));
         }
         if (config.responseFormat) {
-            request.format = config.responseFormat.toJSONSchema();
+            request.format = responseFormatToJsonSchema(config.responseFormat);
         }
         Object.assign(request, sanitizeAttributes(config.rawAttributes));
         this.logger.debug("Sending streaming request to Ollama:", JSON.stringify(redactAttachments(request), null, 2));
@@ -201,16 +215,19 @@ export class SmolOllama extends BaseClient {
                 toolCalls.push(toolCall);
                 yield { type: "tool_call", toolCall };
             }
-            yield {
-                type: "done",
-                result: {
-                    output: content || null,
-                    toolCalls,
-                    usage,
-                    cost,
-                    model: this.getModel(),
-                },
+            const rawStopReason = lastChunk?.done_reason ?? undefined;
+            const result = {
+                output: content || null,
+                toolCalls,
+                usage,
+                cost,
+                model: this.getModel(),
+                stopReason: normalizeOllamaStopReason(rawStopReason),
             };
+            if (rawStopReason) {
+                result.rawStopReason = rawStopReason;
+            }
+            yield { type: "done", result };
         }
         catch (error) {
             this.rethrowAsSmolError(error);

package/dist/clients/openai.js

@@ -8,6 +8,8 @@ import { BaseClient } from "./baseClient.js";
 import { SmolContentPolicyError, SmolContextWindowExceededError, smolErrorForStatus, } from "../smolError.js";
 import { extractHttpErrorFields } from "../util/httpError.js";
 import { zodToOpenAITool } from "../util/tool.js";
+import { responseFormatToJsonSchema } from "../util/jsonSchema.js";
+import { normalizeOpenAIStopReason } from "../util/stopReason.js";
 import { Model } from "../model.js";
 export class SmolOpenAi extends BaseClient {
     client;
@@ -120,7 +122,7 @@ export class SmolOpenAi extends BaseClient {
                 type: "json_schema",
                 json_schema: {
                     name: config.responseFormatOptions?.name || "response",
-                    schema: config.responseFormat.toJSONSchema(),
+                    schema: responseFormatToJsonSchema(config.responseFormat),
                 },
             };
         }
@@ -185,14 +187,22 @@ export class SmolOpenAi extends BaseClient {
         // response headers (e.g. LiteLLM's x-litellm-response-cost).
         const { usage, cost } = this.calculateUsageAndCost(completion.usage, rawResponse);
         const hostedToolResults = this.parseHostedToolResults(completion, config);
-        return success({
+        const rawStopReason = completion.choices[0]?.finish_reason ?? undefined;
+        const result = {
             output,
             toolCalls,
             usage,
             cost,
             model: this.getModel(),
-            ...(hostedToolResults.length > 0 ? { hostedToolResults } : {}),
-        });
+            stopReason: normalizeOpenAIStopReason(rawStopReason),
+        };
+        if (rawStopReason) {
+            result.rawStopReason = rawStopReason;
+        }
+        if (hostedToolResults.length > 0) {
+            result.hostedToolResults = hostedToolResults;
+        }
+        return success(result);
     }
     async *_textStream(config) {
         const request = this.buildRequest(config);
@@ -214,7 +224,11 @@ export class SmolOpenAi extends BaseClient {
         const toolCallsMap = new Map();
         let usage;
         let cost;
+        let rawStopReason;
         for await (const chunk of completion) {
+            const chunkFinish = chunk.choices?.[0]?.finish_reason;
+            if (chunkFinish)
+                rawStopReason = chunkFinish;
             // Extract usage from the final chunk
             if (chunk.usage) {
                 // Header-based cost (LiteLLM) is unsupported while streaming.
@@ -266,15 +280,17 @@ export class SmolOpenAi extends BaseClient {
             toolCalls.push(toolCall);
             yield { type: "tool_call", toolCall };
         }
-        yield {
-            type: "done",
-            result: {
-                output: content || null,
-                toolCalls,
-                usage,
-                cost,
-                model: this.getModel(),
-            },
+        const result = {
+            output: content || null,
+            toolCalls,
+            usage,
+            cost,
+            model: this.getModel(),
+            stopReason: normalizeOpenAIStopReason(rawStopReason),
         };
+        if (rawStopReason) {
+            result.rawStopReason = rawStopReason;
+        }
+        yield { type: "done", result };
     }
 }

package/dist/clients/openaiResponses.js

@@ -5,6 +5,8 @@ import { getLogger } from "../util/logger.js";
 import { redactAttachments } from "../util/redact.js";
 import { BaseClient } from "./baseClient.js";
 import { zodToOpenAIResponsesTool } from "../util/tool.js";
+import { responseFormatToJsonSchema } from "../util/jsonSchema.js";
+import { normalizeOpenAIResponsesStopReason } from "../util/stopReason.js";
 import { sanitizeAttributes } from "../util/util.js";
 import { WEB_SEARCH, webSearchResult, applyHostedToolCost } from "../util/hostedTools.js";
 import { Model } from "../model.js";
@@ -122,7 +124,7 @@ export class SmolOpenAiResponses extends BaseClient {
                 format: {
                     type: "json_schema",
                     name: config.responseFormatOptions?.name || "response",
-                    schema: config.responseFormat.toJSONSchema(),
+                    schema: responseFormatToJsonSchema(config.responseFormat),
                 },
             };
         }
@@ -192,13 +194,19 @@ export class SmolOpenAiResponses extends BaseClient {
         const { usage, cost } = this.calculateUsageAndCost(response.usage);
         const parsed = parseOpenAIResponsesHostedTools(response, "openai-responses");
         const { results: hostedToolResults, cost: finalCost } = applyHostedToolCost(parsed, cost, this.getModel(), this.config.modelData);
+        const incompleteReason = response.incomplete_details?.reason;
+        const rawStopReason = incompleteReason ?? response.status ?? undefined;
         const result = {
             output,
             toolCalls,
             usage,
             cost: finalCost,
             model: this.getModel(),
+            stopReason: normalizeOpenAIResponsesStopReason(response.status, incompleteReason, toolCalls.length > 0),
         };
+        if (rawStopReason) {
+            result.rawStopReason = rawStopReason;
+        }
         if (hostedToolResults.length > 0) {
             result.hostedToolResults = hostedToolResults;
         }
@@ -222,7 +230,12 @@ export class SmolOpenAiResponses extends BaseClient {
         const functionCalls = new Map();
         let usage;
         let cost;
+        let finalResponse;
         for await (const event of stream) {
+            if (event.type === "response.completed" ||
+                event.type === "response.incomplete") {
+                finalResponse = event.response;
+            }
             switch (event.type) {
                 case "response.output_text.delta": {
                     content += event.delta;
@@ -291,15 +304,19 @@ export class SmolOpenAiResponses extends BaseClient {
             toolCalls.push(toolCall);
             yield { type: "tool_call", toolCall };
         }
-        yield {
-            type: "done",
-            result: {
-                output: content || null,
-                toolCalls,
-                usage,
-                cost,
-                model: this.getModel(),
-            },
+        const incompleteReason = finalResponse?.incomplete_details?.reason;
+        const rawStopReason = incompleteReason ?? finalResponse?.status ?? undefined;
+        const result = {
+            output: content || null,
+            toolCalls,
+            usage,
+            cost,
+            model: this.getModel(),
+            stopReason: normalizeOpenAIResponsesStopReason(finalResponse?.status, incompleteReason, toolCalls.length > 0),
         };
+        if (rawStopReason) {
+            result.rawStopReason = rawStopReason;
+        }
+        yield { type: "done", result };
     }
 }

package/dist/models.d.ts

@@ -773,6 +773,108 @@ export declare const textModels: readonly [{
     readonly structuredOutput: true;
     readonly temperatureSupported: false;
     readonly provider: "openai-responses";
+}, {
+    readonly type: "text";
+    readonly modelName: "gpt-5.6-sol";
+    readonly description: "GPT-5.6 Sol is the flagship model of the GPT-5.6 family for the most complex coding and agentic tasks. 1M context window. Standard pricing for ≤272K tokens, 2x input/1.5x output for >272K. Knowledge cutoff: February 2026.";
+    readonly maxInputTokens: 1050000;
+    readonly maxOutputTokens: 128000;
+    readonly inputTokenCost: 5;
+    readonly cachedInputTokenCost: 0.5;
+    readonly outputTokenCost: 30;
+    readonly longContext: {
+        readonly inputTokenCost: 10;
+        readonly cachedInputTokenCost: 1;
+        readonly outputTokenCost: 45;
+        readonly thresholdTokens: 200000;
+    };
+    readonly reasoning: {
+        readonly levels: readonly ["none", "low", "medium", "high", "xhigh", "max"];
+        readonly defaultLevel: "medium";
+        readonly canDisable: true;
+        readonly outputsThinking: false;
+        readonly outputsSignatures: false;
+    };
+    readonly modalities: {
+        readonly input: readonly ["text", "image", "pdf"];
+        readonly output: readonly ["text"];
+    };
+    readonly knowledge: "2026-02-16";
+    readonly releaseDate: "2026-07-09";
+    readonly lastUpdated: "2026-07-09";
+    readonly family: "gpt";
+    readonly openWeights: false;
+    readonly structuredOutput: true;
+    readonly temperatureSupported: false;
+    readonly provider: "openai";
+}, {
+    readonly type: "text";
+    readonly modelName: "gpt-5.6-terra";
+    readonly description: "GPT-5.6 Terra balances capability and cost — competitive with GPT-5.5 at roughly half the price. 1M context window. Standard pricing for ≤272K tokens, 2x input/1.5x output for >272K. Knowledge cutoff: February 2026.";
+    readonly maxInputTokens: 1050000;
+    readonly maxOutputTokens: 128000;
+    readonly inputTokenCost: 2.5;
+    readonly cachedInputTokenCost: 0.25;
+    readonly outputTokenCost: 15;
+    readonly longContext: {
+        readonly inputTokenCost: 5;
+        readonly cachedInputTokenCost: 0.5;
+        readonly outputTokenCost: 22.5;
+        readonly thresholdTokens: 200000;
+    };
+    readonly reasoning: {
+        readonly levels: readonly ["none", "low", "medium", "high", "xhigh", "max"];
+        readonly defaultLevel: "medium";
+        readonly canDisable: true;
+        readonly outputsThinking: false;
+        readonly outputsSignatures: false;
+    };
+    readonly modalities: {
+        readonly input: readonly ["text", "image", "pdf"];
+        readonly output: readonly ["text"];
+    };
+    readonly knowledge: "2026-02-16";
+    readonly releaseDate: "2026-07-09";
+    readonly lastUpdated: "2026-07-09";
+    readonly family: "gpt";
+    readonly openWeights: false;
+    readonly structuredOutput: true;
+    readonly temperatureSupported: false;
+    readonly provider: "openai";
+}, {
+    readonly type: "text";
+    readonly modelName: "gpt-5.6-luna";
+    readonly description: "GPT-5.6 Luna is the fast, most affordable member of the GPT-5.6 family. 1M context window. Standard pricing for ≤272K tokens, 2x input/1.5x output for >272K. Knowledge cutoff: February 2026.";
+    readonly maxInputTokens: 1050000;
+    readonly maxOutputTokens: 128000;
+    readonly inputTokenCost: 1;
+    readonly cachedInputTokenCost: 0.1;
+    readonly outputTokenCost: 6;
+    readonly longContext: {
+        readonly inputTokenCost: 2;
+        readonly cachedInputTokenCost: 0.2;
+        readonly outputTokenCost: 9;
+        readonly thresholdTokens: 200000;
+    };
+    readonly reasoning: {
+        readonly levels: readonly ["none", "low", "medium", "high", "xhigh", "max"];
+        readonly defaultLevel: "medium";
+        readonly canDisable: true;
+        readonly outputsThinking: false;
+        readonly outputsSignatures: false;
+    };
+    readonly modalities: {
+        readonly input: readonly ["text", "image", "pdf"];
+        readonly output: readonly ["text"];
+    };
+    readonly knowledge: "2026-02-16";
+    readonly releaseDate: "2026-07-09";
+    readonly lastUpdated: "2026-07-09";
+    readonly family: "gpt";
+    readonly openWeights: false;
+    readonly structuredOutput: true;
+    readonly temperatureSupported: false;
+    readonly provider: "openai";
 }, {
     readonly type: "text";
     readonly modelName: "gemini-3.1-pro-preview";
@@ -1040,7 +1142,7 @@ export declare const textModels: readonly [{
 }, {
     readonly type: "text";
     readonly modelName: "gemini-2.0-flash";
-    readonly description: "Workhorse model for all daily tasks. Strong overall performance and supports real-time streaming Live API. 1M context window. DEPRECATED: Will be shut down on March 31, 2026.";
+    readonly description: "Workhorse model for all daily tasks. Strong overall performance and supports real-time streaming Live API. 1M context window. RETIRED: Shut down June 1, 2026. Use gemini-2.5-flash instead.";
     readonly maxInputTokens: 1048576;
     readonly maxOutputTokens: 8192;
     readonly inputTokenCost: 0.1;
@@ -1073,7 +1175,7 @@ export declare const textModels: readonly [{
 }, {
     readonly type: "text";
     readonly modelName: "gemini-2.0-flash-lite";
-    readonly description: "Cost effective offering to support high throughput. DEPRECATED: Will be shut down on March 31, 2026. Use gemini-2.5-flash-lite instead.";
+    readonly description: "Cost effective offering to support high throughput. RETIRED: Shut down June 1, 2026. Use gemini-2.5-flash-lite instead.";
     readonly maxInputTokens: 1048576;
     readonly maxOutputTokens: 8192;
     readonly inputTokenCost: 0.075;
@@ -1439,6 +1541,12 @@ export declare const imageModels: readonly [{
     readonly provider: "google";
     readonly description: "Fast image generation with Gemini 3.1 Flash (GA). Supports resolutions from 512px to 4096px. ~$0.045/image at 512px, $0.067 at 1K, $0.101 at 2K, $0.151 at 4K.";
     readonly costPerImage: 0.067;
+}, {
+    readonly type: "image";
+    readonly modelName: "gemini-3.1-flash-lite-image";
+    readonly provider: "google";
+    readonly description: "aka Nano Banana 2 Lite (GA 2026-06-30). Fastest, most cost-effective Gemini image model (~4s generation). ~$0.034/image at 1K. Recommended replacement for gemini-2.5-flash-image.";
+    readonly costPerImage: 0.034;
 }];
 export declare const embeddingsModels: EmbeddingsModel[];
 export type TextModelName = (typeof textModels)[number]["modelName"];

package/dist/models.js

@@ -733,6 +733,111 @@ export const textModels = [
         temperatureSupported: false,
         provider: "openai-responses",
     },
+    {
+        type: "text",
+        modelName: "gpt-5.6-sol",
+        description: "GPT-5.6 Sol is the flagship model of the GPT-5.6 family for the most complex coding and agentic tasks. 1M context window. Standard pricing for ≤272K tokens, 2x input/1.5x output for >272K. Knowledge cutoff: February 2026.",
+        maxInputTokens: 1050000,
+        maxOutputTokens: 128000,
+        inputTokenCost: 5,
+        cachedInputTokenCost: 0.5,
+        outputTokenCost: 30,
+        longContext: {
+            inputTokenCost: 10,
+            cachedInputTokenCost: 1,
+            outputTokenCost: 45,
+            thresholdTokens: 200000,
+        },
+        reasoning: {
+            levels: ["none", "low", "medium", "high", "xhigh", "max"],
+            defaultLevel: "medium",
+            canDisable: true,
+            outputsThinking: false,
+            outputsSignatures: false,
+        },
+        modalities: {
+            input: ["text", "image", "pdf"],
+            output: ["text"],
+        },
+        knowledge: "2026-02-16",
+        releaseDate: "2026-07-09",
+        lastUpdated: "2026-07-09",
+        family: "gpt",
+        openWeights: false,
+        structuredOutput: true,
+        temperatureSupported: false,
+        provider: "openai",
+    },
+    {
+        type: "text",
+        modelName: "gpt-5.6-terra",
+        description: "GPT-5.6 Terra balances capability and cost — competitive with GPT-5.5 at roughly half the price. 1M context window. Standard pricing for ≤272K tokens, 2x input/1.5x output for >272K. Knowledge cutoff: February 2026.",
+        maxInputTokens: 1050000,
+        maxOutputTokens: 128000,
+        inputTokenCost: 2.5,
+        cachedInputTokenCost: 0.25,
+        outputTokenCost: 15,
+        longContext: {
+            inputTokenCost: 5,
+            cachedInputTokenCost: 0.5,
+            outputTokenCost: 22.5,
+            thresholdTokens: 200000,
+        },
+        reasoning: {
+            levels: ["none", "low", "medium", "high", "xhigh", "max"],
+            defaultLevel: "medium",
+            canDisable: true,
+            outputsThinking: false,
+            outputsSignatures: false,
+        },
+        modalities: {
+            input: ["text", "image", "pdf"],
+            output: ["text"],
+        },
+        knowledge: "2026-02-16",
+        releaseDate: "2026-07-09",
+        lastUpdated: "2026-07-09",
+        family: "gpt",
+        openWeights: false,
+        structuredOutput: true,
+        temperatureSupported: false,
+        provider: "openai",
+    },
+    {
+        type: "text",
+        modelName: "gpt-5.6-luna",
+        description: "GPT-5.6 Luna is the fast, most affordable member of the GPT-5.6 family. 1M context window. Standard pricing for ≤272K tokens, 2x input/1.5x output for >272K. Knowledge cutoff: February 2026.",
+        maxInputTokens: 1050000,
+        maxOutputTokens: 128000,
+        inputTokenCost: 1,
+        cachedInputTokenCost: 0.1,
+        outputTokenCost: 6,
+        longContext: {
+            inputTokenCost: 2,
+            cachedInputTokenCost: 0.2,
+            outputTokenCost: 9,
+            thresholdTokens: 200000,
+        },
+        reasoning: {
+            levels: ["none", "low", "medium", "high", "xhigh", "max"],
+            defaultLevel: "medium",
+            canDisable: true,
+            outputsThinking: false,
+            outputsSignatures: false,
+        },
+        modalities: {
+            input: ["text", "image", "pdf"],
+            output: ["text"],
+        },
+        knowledge: "2026-02-16",
+        releaseDate: "2026-07-09",
+        lastUpdated: "2026-07-09",
+        family: "gpt",
+        openWeights: false,
+        structuredOutput: true,
+        temperatureSupported: false,
+        provider: "openai",
+    },
     {
         type: "text",
         modelName: "gemini-3.1-pro-preview",
@@ -1009,7 +1114,7 @@ export const textModels = [
     {
         type: "text",
         modelName: "gemini-2.0-flash",
-        description: "Workhorse model for all daily tasks. Strong overall performance and supports real-time streaming Live API. 1M context window. DEPRECATED: Will be shut down on March 31, 2026.",
+        description: "Workhorse model for all daily tasks. Strong overall performance and supports real-time streaming Live API. 1M context window. RETIRED: Shut down June 1, 2026. Use gemini-2.5-flash instead.",
         maxInputTokens: 1048576,
         maxOutputTokens: 8192,
         inputTokenCost: 0.1,
@@ -1044,7 +1149,7 @@ export const textModels = [
     {
         type: "text",
         modelName: "gemini-2.0-flash-lite",
-        description: "Cost effective offering to support high throughput. DEPRECATED: Will be shut down on March 31, 2026. Use gemini-2.5-flash-lite instead.",
+        description: "Cost effective offering to support high throughput. RETIRED: Shut down June 1, 2026. Use gemini-2.5-flash-lite instead.",
         maxInputTokens: 1048576,
         maxOutputTokens: 8192,
         inputTokenCost: 0.075,
@@ -1434,6 +1539,13 @@ export const imageModels = [
         description: "Fast image generation with Gemini 3.1 Flash (GA). Supports resolutions from 512px to 4096px. ~$0.045/image at 512px, $0.067 at 1K, $0.101 at 2K, $0.151 at 4K.",
         costPerImage: 0.067,
     },
+    {
+        type: "image",
+        modelName: "gemini-3.1-flash-lite-image",
+        provider: "google",
+        description: "aka Nano Banana 2 Lite (GA 2026-06-30). Fastest, most cost-effective Gemini image model (~4s generation). ~$0.034/image at 1K. Recommended replacement for gemini-2.5-flash-image.",
+        costPerImage: 0.034,
+    },
 ];
 export const embeddingsModels = [
     {

package/dist/types/stopReason.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Normalized reason a generation turn ended, unified across providers. The
+ * untouched provider value is available separately as `PromptResult.rawStopReason`.
+ */
+export type StopReason = 
+/** Natural completion (OpenAI `stop`, Anthropic `end_turn`, Google `STOP`, Ollama `stop`). */
+"stop"
+/** Hit the max-tokens limit (`length` / `max_tokens` / `MAX_TOKENS`). */
+ | "length"
+/** Model wants to call a tool (`tool_calls` / `tool_use`). */
+ | "tool_use"
+/** Blocked by a safety/policy filter or refusal (`content_filter` / `refusal` / `SAFETY`). */
+ | "content_filter"
+/** Hit a caller-supplied stop sequence (Anthropic `stop_sequence`). */
+ | "stop_sequence"
+/** Provider paused a long-running turn (Anthropic `pause_turn`). */
+ | "pause"
+/** Anything unmapped or unknown. */
+ | "other";

package/dist/types/stopReason.js

@@ -0,0 +1 @@
+export {};

package/dist/types.d.ts

@@ -10,8 +10,10 @@ import type { ModelDataBlob } from "./modelData.js";
 import { Result } from "./types/result.js";
 import { TokenUsage } from "./types/tokenUsage.js";
 import { CostEstimate } from "./types/costEstimate.js";
+import { StopReason } from "./types/stopReason.js";
 export * from "./types/costEstimate.js";
 export * from "./types/tokenUsage.js";
+export * from "./types/stopReason.js";
 export type SmolConfig = {
     /** The model to use. */
     model: ModelName;
@@ -150,8 +152,12 @@ export type PromptResult = {
     cost?: CostEstimate;
     model?: ModelName;
     hostedToolResults?: HostedToolResult[];
+    /** Normalized reason the turn ended, unified across providers. */
+    stopReason?: StopReason;
+    /** The untouched provider finish/stop-reason value (e.g. `end_turn`, `MAX_TOKENS`). */
+    rawStopReason?: string;
 };
-export declare function promptResult({ output, toolCalls, thinkingBlocks, usage, cost, model, hostedToolResults, }: Partial<PromptResult>): PromptResult;
+export declare function promptResult({ output, toolCalls, thinkingBlocks, usage, cost, model, hostedToolResults, stopReason, rawStopReason, }: Partial<PromptResult>): PromptResult;
 export type StreamChunk = {
     type: "text";
     text: string;
@@ -162,6 +168,14 @@ export type StreamChunk = {
 } | {
     type: "tool_call";
     toolCall: ToolCall;
+}
+/** A provider-run web search (server-side tool). Emitted the moment a
+ *  search block completes, so consumers can surface the query live. One
+ *  chunk per search; a turn may emit several. The same queries also appear
+ *  in the final `done` result's `hostedToolResults`. */
+ | {
+    type: "web_search";
+    query: string;
 } | {
     type: "done";
     result: PromptResult;

package/dist/types.js

@@ -3,7 +3,8 @@ export * from "./classes/message/contentParts.js";
 import z from "zod";
 export * from "./types/costEstimate.js";
 export * from "./types/tokenUsage.js";
-export function promptResult({ output, toolCalls, thinkingBlocks, usage, cost, model, hostedToolResults, }) {
+export * from "./types/stopReason.js";
+export function promptResult({ output, toolCalls, thinkingBlocks, usage, cost, model, hostedToolResults, stopReason, rawStopReason, }) {
     return {
         output: output || null,
         toolCalls: toolCalls || [],
@@ -12,6 +13,8 @@ export function promptResult({ output, toolCalls, thinkingBlocks, usage, cost, m
         cost,
         model,
         hostedToolResults,
+        stopReason,
+        rawStopReason,
     };
 }
 export const ThinkingBlockSchema = z.object({

package/dist/util/jsonSchema.d.ts

@@ -0,0 +1,38 @@
+/**
+ * JSON Schema sanitization for structured output.
+ *
+ * Zod converts `z.any()` / `z.unknown()` to an unconstrained schema — a bare
+ * `{}` (nested), `{"$schema":…}` (top-level), or the boolean `true`. That is
+ * valid JSON Schema ("accept any value"), but every provider rejects an
+ * unconstrained node inside a structured-output or strict-tool schema, since the
+ * whole point of structured output is that it is structured. These helpers map
+ * such nodes to `{"type":"string"}` (the safe universal container) and let
+ * callers detect the whole-schema-is-`any` case so they can drop structured
+ * output entirely and return free text.
+ */
+/**
+ * True if `node` accepts any value: the boolean `true`, or a plain object whose
+ * every own key is a pure annotation (`{}`, `{$schema:…}`,
+ * `{$schema:…, description:…}`). `false` and any object with a structural or
+ * validation keyword are constrained.
+ */
+export declare function isUnconstrainedSchema(node: unknown): boolean;
+/**
+ * Convert a Zod `responseFormat` schema to a sanitized JSON Schema for a
+ * provider's structured-output request: any nested unconstrained node becomes
+ * `{"type":"string"}`. (The whole-schema-is-`any` case is handled upstream in
+ * `BaseClient.normalizeResponseFormat`, which drops structured output entirely.)
+ */
+export declare function responseFormatToJsonSchema(schema: {
+    toJSONSchema: () => unknown;
+}): object;
+/**
+ * Returns a new JSON Schema with every unconstrained node replaced by
+ * `{"type":"string"}` (annotations preserved), recursing through all subschema
+ * positions. Idempotent — a node that already has `type` is left untouched.
+ *
+ * `additionalProperties` and `items` may be a boolean (`true`/`false`), which is
+ * a legitimate provider-accepted flag, not an any-typed value slot; booleans
+ * there are left as-is and only an object subschema is sanitized.
+ */
+export declare function sanitizeJsonSchema(node: unknown): unknown;