smoltalk 0.8.0 → 0.8.2

package/dist/clients/anthropic.d.ts

@@ -2,6 +2,17 @@ import type { MessageParam, Tool } from "@anthropic-ai/sdk/resources/messages.js
 import { PromptResult, Result, SmolClient, SmolConfig, StreamChunk, HostedToolResult } from "../types.js";
 import { BaseClient } from "./baseClient.js";
 import { ModelName } from "../models.js";
+export declare function mergeConsecutiveMessages(messages: MessageParam[]): MessageParam[];
+/**
+ * Whether a model supports Anthropic's native structured-output request
+ * (`output_config.format` with a json_schema — the direct analog of the OpenAI
+ * client's `response_format`). GA on Claude 4.x+ (Opus 4.5+, Sonnet 4.5+, Haiku
+ * 4.5, and the 4.6/4.7/4.8 / Sonnet 5 / Fable families). The legacy claude-3.x /
+ * 2.x aliases do not support it; there we fall back to prompt-based output plus
+ * the base client's fence stripping. Unknown/future model names default to
+ * supported (forward-looking).
+ */
+export declare function anthropicSupportsStructuredOutput(model: string): boolean;
 export declare function anthropicWebSearchEntries(hostedTools?: string[]): any[];
 export declare function parseAnthropicHostedTools(response: any, provider: string): HostedToolResult[];
 type EphemeralCacheControl = {

package/dist/clients/anthropic.js

@@ -12,6 +12,52 @@ import { BaseClient } from "./baseClient.js";
 import { getModel, isTextModel } from "../models.js";
 import { Model } from "../model.js";
 const DEFAULT_MAX_TOKENS = 4096;
+// Normalize an Anthropic message's content to a block array for merging.
+// Array content is passed through; a non-empty string becomes a single text
+// block; an empty string (or any other unexpected value) becomes no blocks
+// (Anthropic rejects empty text blocks). Guarding non-array values keeps the
+// exported merge helper from throwing on a spread if a caller passes content
+// that isn't the string | block[] the type promises.
+function anthropicContentToBlocks(content) {
+    if (Array.isArray(content)) {
+        return content;
+    }
+    if (typeof content === "string" && content.length > 0) {
+        return [{ type: "text", text: content }];
+    }
+    return [];
+}
+// Anthropic requires strict user/assistant turn alternation. Collapse any run of
+// consecutive messages that share a role into a single message by concatenating
+// their content blocks. Does not mutate the input.
+export function mergeConsecutiveMessages(messages) {
+    const merged = [];
+    for (const msg of messages) {
+        const last = merged[merged.length - 1];
+        if (last && last.role === msg.role) {
+            const content = [
+                ...anthropicContentToBlocks(last.content),
+                ...anthropicContentToBlocks(msg.content),
+            ];
+            merged[merged.length - 1] = { ...last, content };
+            continue;
+        }
+        merged.push(msg);
+    }
+    return merged;
+}
+/**
+ * Whether a model supports Anthropic's native structured-output request
+ * (`output_config.format` with a json_schema — the direct analog of the OpenAI
+ * client's `response_format`). GA on Claude 4.x+ (Opus 4.5+, Sonnet 4.5+, Haiku
+ * 4.5, and the 4.6/4.7/4.8 / Sonnet 5 / Fable families). The legacy claude-3.x /
+ * 2.x aliases do not support it; there we fall back to prompt-based output plus
+ * the base client's fence stripping. Unknown/future model names default to
+ * supported (forward-looking).
+ */
+export function anthropicSupportsStructuredOutput(model) {
+    return !/^claude-(?:3(?:[-.]|$)|2(?:[-.]|$)|instant(?:[-.]|$))/i.test(model);
+}
 export function anthropicWebSearchEntries(hostedTools) {
     if (hostedTools && hostedTools.includes(WEB_SEARCH)) {
         return [{ type: "web_search_20250305", name: "web_search" }];
@@ -187,30 +233,21 @@ export class SmolAnthropic extends BaseClient {
             .filter((m) => m instanceof SystemMessage || m instanceof DeveloperMessage)
             .map((m) => m.content);
         const system = systemParts.length > 0 ? systemParts.join("\n") : undefined;
-        // Convert remaining messages, merging consecutive tool_result user messages
-        const anthropicMessages = [];
+        // Convert remaining messages into Anthropic message params.
+        const converted = [];
         for (const msg of config.messages) {
             if (msg instanceof SystemMessage || msg instanceof DeveloperMessage) {
                 continue;
             }
-            const converted = msg.toAnthropicMessage();
-            if (converted === null)
+            const c = msg.toAnthropicMessage();
+            if (c === null)
                 continue;
-            // Merge consecutive tool_result user messages into one (required by Anthropic)
-            if (converted.role === "user" &&
-                Array.isArray(converted.content) &&
-                converted.content.every((c) => c.type === "tool_result")) {
-                const last = anthropicMessages[anthropicMessages.length - 1];
-                if (last &&
-                    last.role === "user" &&
-                    Array.isArray(last.content) &&
-                    last.content.every((c) => c.type === "tool_result")) {
-                    last.content.push(...converted.content);
-                    continue;
-                }
-            }
-            anthropicMessages.push(converted);
+            converted.push(c);
         }
+        // Anthropic requires strict user/assistant alternation — merge any run of
+        // consecutive same-role messages into one (e.g. two user turns, or a user
+        // turn followed by tool results, which also map to role "user").
+        const anthropicMessages = mergeConsecutiveMessages(converted);
         const functionTools = config.tools && config.tools.length > 0
             ? config.tools.map((tool) => zodToAnthropicTool(tool.name, tool.schema, {
                 description: tool.description,
@@ -222,7 +259,22 @@ export class SmolAnthropic extends BaseClient {
         // Normalize the user's provider-agnostic thinking/effort config into the
         // shape this specific model accepts. Both `thinking.enabled` and
         // `reasoningEffort` are treated as a request to think.
-        const { thinking, outputConfig } = this.resolveThinking(config);
+        const { thinking, outputConfig: effortConfig } = this.resolveThinking(config);
+        // Provider-native structured output. Anthropic constrains the response to a
+        // JSON schema via `output_config.format` (grammar-constrained decoding) —
+        // the direct analog of the OpenAI client's `response_format` json_schema,
+        // and it composes with function tools (the model may call a tool OR emit the
+        // structured JSON). GA on Claude 4.x+; on the legacy claude-3.x/2.x aliases
+        // it isn't available, so we omit it and let the base client's fence stripper
+        // + retry recover a prompt-shaped reply.
+        const format = config.responseFormat &&
+            anthropicSupportsStructuredOutput(this.getModel())
+            ? { type: "json_schema", schema: config.responseFormat.toJSONSchema() }
+            : undefined;
+        // Merge effort + format into one output_config (both optional, independent).
+        const outputConfig = effortConfig || format
+            ? { ...effortConfig, ...(format && { format }) }
+            : undefined;
         const cachingEnabled = config.caching?.enabled !== false;
         const baseRequest = { system, messages: anthropicMessages, tools };
         const finalRequest = cachingEnabled
@@ -391,6 +443,18 @@ export class SmolAnthropic extends BaseClient {
         const toolBlocks = new Map();
         // Track thinking blocks by index: index -> { text, signature }
         const thinkingBlockMap = new Map();
+        // Track server-side web_search blocks by index -> partial input JSON. The
+        // query streams in as input_json_delta just like a client tool call; we
+        // parse it once the block stops and emit a live `web_search` chunk.
+        const webSearchBlocks = new Map();
+        // Accumulated hosted-tool signal for the final `done` result (parity with
+        // the non-streaming path's `hostedToolResults`): queries, sources,
+        // citations, billed count, and the raw provider blocks.
+        const webSearchQueries = [];
+        const webSearchSources = [];
+        const webSearchCitations = [];
+        const webSearchRaw = [];
+        let webSearchRequests;
         let inputTokens = 0;
         let cacheReadTokens = 0;
         let cacheCreationTokens = 0;
@@ -410,6 +474,25 @@ export class SmolAnthropic extends BaseClient {
                         arguments: "",
                     });
                 }
+                else if (event.content_block.type === "server_tool_use" &&
+                    event.content_block.name === "web_search") {
+                    // Keep the start block so we can reconstruct the raw provider block
+                    // (with its streamed `input`) at content_block_stop.
+                    webSearchBlocks.set(event.index, {
+                        arguments: "",
+                        start: event.content_block,
+                    });
+                }
+                else if (event.content_block.type === "web_search_tool_result") {
+                    // Server tool results arrive whole (no deltas). Collect sources and
+                    // keep the raw block so the final `done` result matches _textSync.
+                    webSearchRaw.push(event.content_block);
+                    for (const r of event.content_block.content || []) {
+                        if (r && typeof r.url === "string") {
+                            webSearchSources.push({ url: r.url, title: r.title });
+                        }
+                    }
+                }
                 else if (event.content_block.type === "thinking") {
                     thinkingBlockMap.set(event.index, { text: "", signature: "" });
                 }
@@ -424,6 +507,10 @@ export class SmolAnthropic extends BaseClient {
                     if (block) {
                         block.arguments += event.delta.partial_json;
                     }
+                    const searchBlock = webSearchBlocks.get(event.index);
+                    if (searchBlock) {
+                        searchBlock.arguments += event.delta.partial_json;
+                    }
                 }
                 else if (event.delta.type === "thinking_delta") {
                     const block = thinkingBlockMap.get(event.index);
@@ -437,6 +524,15 @@ export class SmolAnthropic extends BaseClient {
                         block.signature = event.delta.signature;
                     }
                 }
+                else if (event.delta.type === "citations_delta") {
+                    // Citations stream in one per delta (whereas _textSync reads them
+                    // from the assembled text block's `citations` array). Collect any
+                    // with a url so the done result's hostedToolResults match sync.
+                    const c = event.delta.citation;
+                    if (c && typeof c.url === "string") {
+                        webSearchCitations.push({ url: c.url, title: c.title });
+                    }
+                }
             }
             else if (event.type === "content_block_stop") {
                 // Emit thinking chunk once the block is fully assembled
@@ -448,6 +544,29 @@ export class SmolAnthropic extends BaseClient {
                         signature: thinkingBlock.signature,
                     };
                 }
+                // Emit the web search query the moment its block completes, so
+                // consumers see the keywords live rather than only in the final result.
+                const searchBlock = webSearchBlocks.get(event.index);
+                if (searchBlock) {
+                    // Delete first so a replayed/duplicate stop event can't emit the
+                    // same query twice.
+                    webSearchBlocks.delete(event.index);
+                    let input;
+                    try {
+                        input = JSON.parse(searchBlock.arguments || "{}");
+                    }
+                    catch {
+                        // Malformed/partial JSON — skip this block rather than throw.
+                    }
+                    // Reconstruct the raw provider block (start header + streamed input)
+                    // so hostedToolResults.raw matches the non-streaming shape.
+                    webSearchRaw.push({ ...searchBlock.start, input });
+                    const query = input?.query;
+                    if (typeof query === "string" && query.length > 0) {
+                        webSearchQueries.push(query);
+                        yield { type: "web_search", query };
+                    }
+                }
             }
             else if (event.type === "message_delta") {
                 outputTokens = event.usage.output_tokens;
@@ -460,6 +579,10 @@ export class SmolAnthropic extends BaseClient {
                 if (event.usage.cache_creation_input_tokens != null) {
                     cacheCreationTokens = event.usage.cache_creation_input_tokens;
                 }
+                // Billable web-search count, for hosted-tool cost on the done result.
+                if (event.usage.server_tool_use?.web_search_requests != null) {
+                    webSearchRequests = event.usage.server_tool_use.web_search_requests;
+                }
             }
         }
         this.logger.debug("Streaming response completed from Anthropic");
@@ -485,7 +608,28 @@ export class SmolAnthropic extends BaseClient {
         if (cacheCreationTokens > 0) {
             usage.cacheCreationInputTokens = cacheCreationTokens;
         }
-        const cost = this.model.calculateCost(usage) ?? undefined;
+        let cost = this.model.calculateCost(usage) ?? undefined;
+        // Fold hosted-tool (web search) results into the done result so the
+        // streaming path reports the same `hostedToolResults` shape as _textSync.
+        // The live `web_search` chunks above already surfaced the queries; this is
+        // the durable record (queries + sources + citations + billed cost + raw).
+        let hostedToolResults = [];
+        const usedWebSearch = webSearchQueries.length > 0 ||
+            webSearchSources.length > 0 ||
+            (webSearchRequests ?? 0) > 0;
+        if (usedWebSearch) {
+            const applied = applyHostedToolCost([
+                webSearchResult("anthropic", {
+                    queries: webSearchQueries,
+                    sources: webSearchSources,
+                    citations: webSearchCitations,
+                    callCount: webSearchRequests,
+                    raw: webSearchRaw,
+                }),
+            ], cost, this.getModel(), this.config.modelData);
+            hostedToolResults = applied.results;
+            cost = applied.cost;
+        }
         yield {
             type: "done",
             result: {
@@ -495,6 +639,7 @@ export class SmolAnthropic extends BaseClient {
                 usage,
                 cost,
                 model: this.getModel(),
+                ...(hostedToolResults.length > 0 && { hostedToolResults }),
             },
         };
     }

package/dist/clients/baseClient.js

@@ -258,7 +258,12 @@ export class BaseClient {
                 retries > 0) {
                 const allowExtraKeys = promptConfig.responseFormatOptions?.allowExtraKeys ?? false;
                 try {
-                    const parsed = JSON.parse(output);
+                    // Strip any ```json … ``` fence before parsing. Models (notably
+                    // Anthropic on the prompt-based path) routinely wrap structured
+                    // output in a markdown fence; feeding that straight to JSON.parse
+                    // throws and burns a retry. stripCodeFence is a no-op on unfenced
+                    // JSON, so this is safe for every provider.
+                    const parsed = JSON.parse(stripCodeFence(output));
                     const parseResult = this.extractResponse(promptConfig, parsed, promptConfig.responseFormat);
                     return success({
                         ...result.value,

package/dist/clients/google.d.ts

@@ -5,6 +5,21 @@ import { ModelName } from "../models.js";
 import { HostedToolResult } from "../types.js";
 export type SmolGoogleConfig = SmolConfig;
 export declare function googleWebSearchEntries(hostedTools?: string[]): any[];
+/**
+ * Whether a Gemini model can combine built-in tools (e.g. hosted web search)
+ * with function calling in a single request. Confirmed against the live API:
+ *   - Gemini 3+  : supported, but ONLY when `toolConfig
+ *     .includeServerSideToolInvocations` is set ("tool call context
+ *     circulation"). Without it the API 400s asking you to enable it.
+ *   - Gemini 2.5 and earlier: NOT supported by any means — the raw combination
+ *     400s with "Built-in tools and Function Calling cannot be combined", and
+ *     the flag 400s with "Tool call context circulation is not enabled for
+ *     <model>".
+ * Unknown / non-versioned model names default to supported (forward-looking):
+ * new models are expected to allow the combination.
+ * See egonSchiele/agency-lang#495.
+ */
+export declare function geminiSupportsToolCirculation(model: string): boolean;
 export declare function parseGoogleHostedTools(result: any, provider: string, model: string): HostedToolResult[];
 type GeneratedRequest = {
     contents: Content[];

package/dist/clients/google.js

@@ -4,7 +4,7 @@ import { getLogger } from "../util/logger.js";
 import { redactAttachments } from "../util/redact.js";
 import { addCosts, addTokenUsage, success, } from "../types.js";
 import { zodToGoogleTool } from "../util/tool.js";
-import { SmolContentPolicyError, SmolContextWindowExceededError, smolErrorForStatus, } from "../smolError.js";
+import { SmolError, SmolContentPolicyError, SmolContextWindowExceededError, smolErrorForStatus, } from "../smolError.js";
 import { extractHttpErrorFields } from "../util/httpError.js";
 import { sanitizeAttributes } from "../util/util.js";
 import { BaseClient } from "./baseClient.js";
@@ -17,6 +17,26 @@ export function googleWebSearchEntries(hostedTools) {
     }
     return [];
 }
+/**
+ * Whether a Gemini model can combine built-in tools (e.g. hosted web search)
+ * with function calling in a single request. Confirmed against the live API:
+ *   - Gemini 3+  : supported, but ONLY when `toolConfig
+ *     .includeServerSideToolInvocations` is set ("tool call context
+ *     circulation"). Without it the API 400s asking you to enable it.
+ *   - Gemini 2.5 and earlier: NOT supported by any means — the raw combination
+ *     400s with "Built-in tools and Function Calling cannot be combined", and
+ *     the flag 400s with "Tool call context circulation is not enabled for
+ *     <model>".
+ * Unknown / non-versioned model names default to supported (forward-looking):
+ * new models are expected to allow the combination.
+ * See egonSchiele/agency-lang#495.
+ */
+export function geminiSupportsToolCirculation(model) {
+    const m = /^gemini-(\d+)/.exec(model);
+    if (!m)
+        return true;
+    return parseInt(m[1], 10) >= 3;
+}
 export function parseGoogleHostedTools(result, provider, model) {
     const queries = [];
     const sources = [];
@@ -134,9 +154,22 @@ export class SmolGoogle extends BaseClient {
                 toolGroups.push(entry);
             }
             genConfig.tools = toolGroups;
-            // Gemini rejects mixing built-in (server-side) tools with function calling
-            // unless the caller opts in. Only required when both kinds coexist.
+            // Combining built-in tools (hosted web search) with function calling is a
+            // Gemini feature ("tool call context circulation") that must be opted
+            // into via includeServerSideToolInvocations AND is only supported on
+            // Gemini 3+. On older models the combination is impossible: sending the
+            // flag 400s ("circulation is not enabled for <model>") and omitting it
+            // 400s ("Built-in tools and Function Calling cannot be combined"). Fail
+            // fast with an actionable message instead of a cryptic provider 400.
+            // See egonSchiele/agency-lang#495.
             if (tools.length > 0 && hostedEntries.length > 0) {
+                if (!geminiSupportsToolCirculation(this.getModel())) {
+                    throw new SmolError(`${this.getModel()} cannot use the hosted web_search tool together ` +
+                        `with function tools in one request. Gemini only allows combining ` +
+                        `built-in tools with function calling on Gemini 3+ models. Use a ` +
+                        `Gemini 3+ model, switch to a client-side search tool instead of ` +
+                        `the hosted web_search, or drop one of the two.`, { status: 400 });
+                }
                 genConfig.toolConfig = {
                     ...genConfig.toolConfig,
                     includeServerSideToolInvocations: true,
@@ -147,7 +180,20 @@ export class SmolGoogle extends BaseClient {
             genConfig.responseMimeType = "application/json";
             genConfig.responseJsonSchema = config.responseFormat.toJSONSchema();
         }
-        if (!config.thinking?.enabled && config.reasoningEffort) {
+        if (config.thinking?.enabled) {
+            // Gemini only returns thought-summary parts (parts with `thought: true`,
+            // which populate PromptResult.thinkingBlocks) when includeThoughts is set.
+            // Without it the model still reasons, but returns only the encrypted
+            // thoughtSignature on the answer part — no visible reasoning text — so
+            // thinkingBlocks would come back empty.
+            genConfig.thinkingConfig = {
+                includeThoughts: true,
+                ...(config.thinking.budgetTokens !== undefined && {
+                    thinkingBudget: config.thinking.budgetTokens,
+                }),
+            };
+        }
+        else if (config.reasoningEffort) {
             const budgetMap = { low: 2048, medium: 8192, high: 16384 };
             genConfig.thinkingConfig = {
                 thinkingBudget: budgetMap[config.reasoningEffort],
@@ -291,14 +337,19 @@ export class SmolGoogle extends BaseClient {
                             thoughtSignature: part.thoughtSignature,
                         }));
                     }
-                    else if (part.thoughtSignature) {
-                        // Capture thought parts (thought: true indicates a thinking part)
+                    else if (part.thought) {
+                        // A thinking part is identified by `thought: true` — NOT merely by
+                        // the presence of a thoughtSignature. Gemini 3 also rides a
+                        // thoughtSignature on the final answer part (no `thought` flag) for
+                        // stateless reasoning continuity; keying on the signature alone
+                        // would misfile that answer text as a thinking block and leave the
+                        // output empty. See egonSchiele/agency-lang.
                         thinkingBlocks.push({
                             text: part.text || "",
-                            signature: part.thoughtSignature,
+                            signature: part.thoughtSignature || "",
                         });
                     }
-                    else if (typeof part.text === "string" && !part.thought) {
+                    else if (typeof part.text === "string") {
                         textContent += part.text;
                     }
                 });
@@ -395,10 +446,16 @@ export class SmolGoogle extends BaseClient {
                             }
                         }
                     }
-                    else if (p.thoughtSignature) {
+                    else if (p.thought) {
+                        // A thinking part is identified by `thought: true` — NOT merely by
+                        // the presence of a thoughtSignature. Gemini 3 also rides a
+                        // thoughtSignature on the final answer part (no `thought` flag) for
+                        // stateless reasoning continuity; keying on the signature alone
+                        // would misfile that answer text as a thinking block and drop it
+                        // from the completion. See egonSchiele/agency-lang.
                         const block = {
                             text: p.text || "",
-                            signature: p.thoughtSignature,
+                            signature: p.thoughtSignature || "",
                         };
                         thinkingBlocks.push(block);
                         yield {

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.d.ts

@@ -162,6 +162,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoltalk",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
   "files": [