@agentionai/agents 1.5.0 → 1.6.0

package/dist/agents/BaseAgent.d.ts

@@ -67,6 +67,25 @@ export type TokenUsage = {
      */
     outputTokensPerSecond?: number;
 };
+/**
+ * What a model can do, as reported by its provider.
+ *
+ * Every flag is three-valued: `true` and `false` are the provider's answer,
+ * `undefined` means it does not report on that capability at all — which is the
+ * common case, since no provider covers all four. Filter with `!== false` when
+ * you want "not known to be unsupported", and with `=== true` when you need
+ * positive confirmation.
+ */
+export type ModelCapabilities = {
+    /** Conversational generation — what an agent needs to run at all. */
+    chat?: boolean;
+    /** Function / tool calling. */
+    tools?: boolean;
+    /** Image input. */
+    vision?: boolean;
+    /** Extended thinking / reasoning. */
+    thinking?: boolean;
+};
 /**
  * A model as reported by a provider's models endpoint, in a shape that is the
  * same on every provider.
@@ -89,6 +108,22 @@ export type ModelInfo<TRaw = unknown> = {
     ownedBy?: string;
     /** Maximum input context in tokens, where the provider reports one. */
     contextLength?: number;
+    /** Maximum tokens in a single response, where the provider reports one. */
+    maxOutputTokens?: number;
+    /**
+     * What the provider says this model supports. Absent flags mean "not
+     * reported", never "unsupported" — see {@link ModelCapabilities}.
+     */
+    capabilities?: ModelCapabilities;
+    /**
+     * When the provider plans to retire the model, where it publishes a date.
+     * Only Mistral does today; note that a model can stop working before any
+     * announced date, and Google in particular retires models that its listing
+     * still advertises.
+     */
+    deprecatedAt?: Date;
+    /** Model the provider recommends in its place, where it names one. */
+    replacedBy?: string;
     /**
      * Whether the model is currently held in memory, on servers that distinguish
      * "offered" from "loaded" — llama.cpp's model router being the case in point,

package/dist/agents/anthropic/ClaudeAgent.d.ts

@@ -6,6 +6,52 @@ import { BaseAgent, BaseAgentConfig, ModelInfo, TokenUsage } from "../BaseAgent"
 import { History, MessageContent } from "../../history/History";
 import { StreamChunk } from "../openai-compatible/OpenAICompatibleAgent";
 import { ClaudeModel } from "../model-types";
+/** A capability node in Anthropic's model card — always at least `supported`. */
+type AnthropicSupported = {
+    supported: boolean;
+};
+/**
+ * One entry from Anthropic's `/v1/models`.
+ *
+ * Declared here rather than taken from the SDK, whose `ModelInfo` still covers
+ * only `id`/`type`/`display_name`/`created_at`. The API also returns token
+ * limits and a capability tree — verified on the wire on 2026-08-11 — and those
+ * are what `contextLength`, `maxOutputTokens` and `capabilities` are read from.
+ * Everything past the four SDK fields is optional so that an older API version,
+ * or a gateway that trims the response, still typechecks.
+ */
+export type AnthropicModelCard = AnthropicModelInfo & {
+    /** Context window in tokens. */
+    max_input_tokens?: number;
+    /** Largest `max_tokens` the model accepts for a response. */
+    max_tokens?: number;
+    capabilities?: {
+        batch?: AnthropicSupported;
+        citations?: AnthropicSupported;
+        code_execution?: AnthropicSupported;
+        /** Server-side context editing; the dated keys are individual strategies. */
+        context_management?: AnthropicSupported & {
+            [strategy: string]: AnthropicSupported | boolean | undefined;
+        };
+        /** Which effort levels the model accepts — the live answer to what `model-types.ts` hardcodes. */
+        effort?: AnthropicSupported & {
+            low?: AnthropicSupported;
+            medium?: AnthropicSupported;
+            high?: AnthropicSupported;
+            xhigh?: AnthropicSupported;
+            max?: AnthropicSupported;
+        };
+        image_input?: AnthropicSupported;
+        pdf_input?: AnthropicSupported;
+        structured_outputs?: AnthropicSupported;
+        thinking?: AnthropicSupported & {
+            types?: {
+                enabled?: AnthropicSupported;
+                adaptive?: AnthropicSupported;
+            };
+        };
+    };
+};
 type AgentConfig = BaseAgentConfig & {
     apiKey: string;
     model?: ClaudeModel;
@@ -58,11 +104,17 @@ export declare class ClaudeAgent extends BaseAgent {
     /**
      * List the models available to this API key, newest first.
      *
-     * Anthropic reports a display name and release date but no context window,
-     * so `contextLength` is always undefined here. The result is fully
-     * paginated — the endpoint pages at 1000 models.
+     * Anthropic reports token limits and a capability tree that the SDK's own
+     * type omits, so `raw` is typed as {@link AnthropicModelCard} — which is also
+     * where `contextLength` (`max_input_tokens`), `maxOutputTokens` and the
+     * vision/thinking flags come from. `capabilities.effort` on `raw` states which
+     * effort levels each model accepts. Tool support is not reported; every model
+     * the endpoint lists supports tools, so `capabilities.tools` stays undefined
+     * rather than being asserted.
+     *
+     * The result is fully paginated — the endpoint pages at 1000 models.
      */
-    listModels(): Promise<ModelInfo<AnthropicModelInfo>[]>;
+    listModels(): Promise<ModelInfo<AnthropicModelCard>[]>;
     /**
      * Combine locally-executed tool definitions with provider-defined
      * (server-side) built-in tools, in the shape Anthropic's API expects.

package/dist/agents/anthropic/ClaudeAgent.js

@@ -65,19 +65,32 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
     /**
      * List the models available to this API key, newest first.
      *
-     * Anthropic reports a display name and release date but no context window,
-     * so `contextLength` is always undefined here. The result is fully
-     * paginated — the endpoint pages at 1000 models.
+     * Anthropic reports token limits and a capability tree that the SDK's own
+     * type omits, so `raw` is typed as {@link AnthropicModelCard} — which is also
+     * where `contextLength` (`max_input_tokens`), `maxOutputTokens` and the
+     * vision/thinking flags come from. `capabilities.effort` on `raw` states which
+     * effort levels each model accepts. Tool support is not reported; every model
+     * the endpoint lists supports tools, so `capabilities.tools` stays undefined
+     * rather than being asserted.
+     *
+     * The result is fully paginated — the endpoint pages at 1000 models.
      */
     async listModels() {
         try {
             const models = [];
             for await (const model of this.client.models.list({ limit: 1000 })) {
+                const card = model;
                 models.push({
-                    id: model.id,
-                    displayName: model.display_name,
-                    created: new Date(model.created_at),
-                    raw: model,
+                    id: card.id,
+                    displayName: card.display_name,
+                    created: new Date(card.created_at),
+                    contextLength: card.max_input_tokens,
+                    maxOutputTokens: card.max_tokens,
+                    capabilities: {
+                        vision: card.capabilities?.image_input?.supported,
+                        thinking: card.capabilities?.thinking?.supported,
+                    },
+                    raw: card,
                 });
             }
             return models;

package/dist/agents/google/GeminiAgent.d.ts

@@ -2,6 +2,36 @@ import { FunctionDeclarationsTool, GenerateContentResult, Schema } from "@google
 import { BaseAgent, BaseAgentConfig, ModelInfo, TokenUsage } from "../BaseAgent";
 import { History, MessageContent } from "../../history/History";
 import { GeminiModel } from "../model-types";
+/**
+ * Models that `models.list` still advertises but the API no longer serves.
+ *
+ * Google leaves retired models in the listing, fully described and claiming
+ * `generateContent`; calling one fails with `404 — "This model is no longer
+ * available to new users"`. Nothing in the listing distinguishes them, and the
+ * stable `v1` endpoint carries them too, so the only way to keep them out of
+ * `listModels()` is to name them.
+ *
+ * A retirement is permanent, so this list only ever grows — an entry never
+ * needs revisiting, and one that disappears from the API's listing costs
+ * nothing to keep.
+ *
+ * Every entry is confirmed by probing `countTokens` (free, and it 404s the same
+ * way), most recently on 2026-08-11. Note that retirement is per-model, not per
+ * family: `gemini-2.5-flash-image`, `gemini-2.5-*-preview-tts` and
+ * `gemini-2.5-computer-use-preview-10-2025` were all still live at that date,
+ * which is why these are listed individually rather than matched by prefix.
+ *
+ * Pass `{ includeRetired: true }` to `listModels()` to see them anyway.
+ */
+export declare const GEMINI_RETIRED_MODELS: readonly string[];
+/** Options for {@link GeminiAgent.listModels}. */
+export type GeminiListModelsOptions = {
+    /**
+     * Include models known to have been retired. Off by default: they are listed
+     * by the API but fail at call time.
+     */
+    includeRetired?: boolean;
+};
 /**
  * One entry from the Generative Language API's `models.list` response.
  *
@@ -17,8 +47,14 @@ export type GeminiModelCard = {
     description?: string;
     inputTokenLimit?: number;
     outputTokenLimit?: number;
-    /** e.g. `["generateContent", "countTokens"]` — an embedding model has neither. */
+    /**
+     * e.g. `["generateContent", "countTokens"]`. Embedding models have
+     * `embedContent`, Imagen `predict`, Veo `predictLongRunning`, and the live
+     * models only `bidiGenerateContent` — none of which an agent can drive.
+     */
     supportedGenerationMethods?: string[];
+    /** Whether the model reasons before answering. */
+    thinking?: boolean;
     temperature?: number;
     maxTemperature?: number;
     topP?: number;
@@ -64,10 +100,15 @@ export declare class GeminiAgent extends BaseAgent {
      * page is followed, and the `"models/"` prefix is stripped from `id` so the
      * value can be passed straight back as an agent's `model`.
      *
-     * The list includes embedding models; filter on
-     * `raw.supportedGenerationMethods` for the ones this agent can drive.
+     * The list covers everything the key can reach, including embedding, image
+     * and live-audio models — `capabilities.chat` marks the ones an agent can
+     * actually drive.
+     *
+     * Models known to have been retired are left out, since the API lists them
+     * but no longer serves them — see {@link GEMINI_RETIRED_MODELS}. Pass
+     * `{ includeRetired: true }` for the listing exactly as Google returns it.
      */
-    listModels(): Promise<ModelInfo<GeminiModelCard>[]>;
+    listModels(options?: GeminiListModelsOptions): Promise<ModelInfo<GeminiModelCard>[]>;
     protected getToolDefinitionsForGemini(): FunctionDeclarationsTool | undefined;
     /**
      * Convert JSON Schema to Gemini's FunctionDeclarationSchema format

package/dist/agents/google/GeminiAgent.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GeminiAgent = void 0;
+exports.GeminiAgent = exports.GEMINI_RETIRED_MODELS = void 0;
 const generative_ai_1 = require("@google/generative-ai");
 const BaseAgent_1 = require("../BaseAgent");
 const AgentEvent_1 = require("../AgentEvent");
@@ -10,6 +10,34 @@ const VizReporter_1 = require("../../viz/VizReporter");
 const VizConfig_1 = require("../../viz/VizConfig");
 /** Base URL of the Generative Language API, matching the SDK's own default. */
 const GEMINI_API_BASE = "https://generativelanguage.googleapis.com";
+/**
+ * Models that `models.list` still advertises but the API no longer serves.
+ *
+ * Google leaves retired models in the listing, fully described and claiming
+ * `generateContent`; calling one fails with `404 — "This model is no longer
+ * available to new users"`. Nothing in the listing distinguishes them, and the
+ * stable `v1` endpoint carries them too, so the only way to keep them out of
+ * `listModels()` is to name them.
+ *
+ * A retirement is permanent, so this list only ever grows — an entry never
+ * needs revisiting, and one that disappears from the API's listing costs
+ * nothing to keep.
+ *
+ * Every entry is confirmed by probing `countTokens` (free, and it 404s the same
+ * way), most recently on 2026-08-11. Note that retirement is per-model, not per
+ * family: `gemini-2.5-flash-image`, `gemini-2.5-*-preview-tts` and
+ * `gemini-2.5-computer-use-preview-10-2025` were all still live at that date,
+ * which is why these are listed individually rather than matched by prefix.
+ *
+ * Pass `{ includeRetired: true }` to `listModels()` to see them anyway.
+ */
+exports.GEMINI_RETIRED_MODELS = [
+    // Retired for new users some time before 2026-08-11
+    "gemini-2.5-flash",
+    "gemini-2.5-pro",
+    "gemini-2.5-flash-lite",
+];
+const GEMINI_RETIRED = new Set(exports.GEMINI_RETIRED_MODELS);
 /**
  * Agent for Google Gemini models.
  *
@@ -62,10 +90,15 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
      * page is followed, and the `"models/"` prefix is stripped from `id` so the
      * value can be passed straight back as an agent's `model`.
      *
-     * The list includes embedding models; filter on
-     * `raw.supportedGenerationMethods` for the ones this agent can drive.
+     * The list covers everything the key can reach, including embedding, image
+     * and live-audio models — `capabilities.chat` marks the ones an agent can
+     * actually drive.
+     *
+     * Models known to have been retired are left out, since the API lists them
+     * but no longer serves them — see {@link GEMINI_RETIRED_MODELS}. Pass
+     * `{ includeRetired: true }` for the listing exactly as Google returns it.
      */
-    async listModels() {
+    async listModels(options) {
         try {
             const models = [];
             let pageToken;
@@ -86,10 +119,19 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
                 }
                 const body = (await response.json());
                 for (const model of body.models ?? []) {
+                    const id = model.name.replace(/^models\//, "");
+                    if (!options?.includeRetired && GEMINI_RETIRED.has(id)) {
+                        continue;
+                    }
                     models.push({
-                        id: model.name.replace(/^models\//, ""),
+                        id,
                         displayName: model.displayName,
                         contextLength: model.inputTokenLimit,
+                        maxOutputTokens: model.outputTokenLimit,
+                        capabilities: {
+                            chat: model.supportedGenerationMethods?.includes("generateContent"),
+                            thinking: model.thinking,
+                        },
                         raw: model,
                     });
                 }

package/dist/agents/llamacpp/LlamaCppAgent.d.ts

@@ -93,7 +93,10 @@ export declare class LlamaCppAgent extends OpenAICompatibleAgent {
      *   with, falling back to the trained ceiling `n_ctx_train`. Only loaded
      *   models carry `meta`.
      *
-     * The rest — launch args, presets, modalities, quantization — is on `raw`.
+     * `capabilities.vision` follows from the declared input modalities. Tool
+     * support is not reported — it depends on the chat template, not the server —
+     * so it stays undefined. The rest, launch args and presets and quantization
+     * included, is on `raw`.
      */
     listModels(): Promise<ModelInfo<LlamaCppModelCard>[]>;
 }

package/dist/agents/llamacpp/LlamaCppAgent.js

@@ -50,7 +50,10 @@ class LlamaCppAgent extends OpenAICompatibleAgent_1.OpenAICompatibleAgent {
      *   with, falling back to the trained ceiling `n_ctx_train`. Only loaded
      *   models carry `meta`.
      *
-     * The rest — launch args, presets, modalities, quantization — is on `raw`.
+     * `capabilities.vision` follows from the declared input modalities. Tool
+     * support is not reported — it depends on the chat template, not the server —
+     * so it stays undefined. The rest, launch args and presets and quantization
+     * included, is on `raw`.
      */
     async listModels() {
         const models = (await super.listModels());
@@ -60,6 +63,9 @@ class LlamaCppAgent extends OpenAICompatibleAgent_1.OpenAICompatibleAgent {
                 ? model.raw.status.value === "loaded"
                 : undefined,
             contextLength: model.raw.meta?.n_ctx ?? model.raw.meta?.n_ctx_train,
+            capabilities: {
+                vision: model.raw.architecture?.input_modalities?.includes("image"),
+            },
         }));
     }
 }

package/dist/agents/mistral/MistralAgent.d.ts

@@ -53,8 +53,15 @@ export declare class MistralAgent extends BaseAgent {
     /**
      * List the models available to this API key, base and fine-tuned alike.
      *
-     * Mistral reports a context window, which lands on `contextLength`; the
-     * per-model `capabilities` flags (function calling, vision, …) are on `raw`.
+     * Mistral is the most forthcoming of the providers: it reports a context
+     * window, a full capability set, and a retirement date with a replacement
+     * model. All of that is mapped onto the neutral fields.
+     *
+     * Note that `raw` here is the SDK's parsed view, not the wire response — the
+     * Mistral SDK validates against a schema that drops fields it does not know,
+     * so capabilities the API has added since the installed SDK version (as of
+     * `1.13.0`: `reasoning`, the audio flags) are gone before this code sees
+     * them. Every other agent's `raw` is the untouched response.
      */
     listModels(): Promise<ModelInfo<MistralModelCard>[]>;
     protected getToolDefinitions(): Tool[];

package/dist/agents/mistral/MistralAgent.js

@@ -83,8 +83,15 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
     /**
      * List the models available to this API key, base and fine-tuned alike.
      *
-     * Mistral reports a context window, which lands on `contextLength`; the
-     * per-model `capabilities` flags (function calling, vision, …) are on `raw`.
+     * Mistral is the most forthcoming of the providers: it reports a context
+     * window, a full capability set, and a retirement date with a replacement
+     * model. All of that is mapped onto the neutral fields.
+     *
+     * Note that `raw` here is the SDK's parsed view, not the wire response — the
+     * Mistral SDK validates against a schema that drops fields it does not know,
+     * so capabilities the API has added since the installed SDK version (as of
+     * `1.13.0`: `reasoning`, the audio flags) are gone before this code sees
+     * them. Every other agent's `raw` is the untouched response.
      */
     async listModels() {
         try {
@@ -95,6 +102,13 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
                 created: model.created ? new Date(model.created * 1000) : undefined,
                 ownedBy: model.ownedBy,
                 contextLength: model.maxContextLength,
+                capabilities: {
+                    chat: model.capabilities.completionChat,
+                    tools: model.capabilities.functionCalling,
+                    vision: model.capabilities.vision,
+                },
+                deprecatedAt: model.deprecation ?? undefined,
+                replacedBy: model.deprecationReplacementModel ?? undefined,
                 raw: model,
             }));
         }

package/dist/agents/openai/OpenAiAgent.js

@@ -13,6 +13,7 @@ const transformers_1 = require("../../history/transformers");
 const VizReporter_1 = require("../../viz/VizReporter");
 const VizConfig_1 = require("../../viz/VizConfig");
 const model_types_1 = require("../model-types");
+const openai_strict_1 = require("./openai-strict");
 /**
  * Lowest `reasoning.effort` the given model accepts, used to resolve
  * `disableReasoning`. Returns `undefined` when the model has no reasoning to turn
@@ -111,17 +112,20 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
     getToolDefinitions() {
         return Array.from(this.tools.values()).map((tool) => {
             const prompt = tool.getPrompt();
+            const parameters = {
+                type: prompt.input_schema.type,
+                properties: prompt.input_schema.properties,
+                required: prompt.input_schema.required,
+                additionalProperties: false,
+            };
             return {
                 type: "function",
                 name: prompt.name,
                 description: prompt.description,
-                parameters: {
-                    type: prompt.input_schema.type,
-                    properties: prompt.input_schema.properties,
-                    required: prompt.input_schema.required,
-                    additionalProperties: false,
-                },
-                strict: true,
+                parameters,
+                // Per tool, not unconditional: strict mode requires `required` to name
+                // every property, so one optional parameter would 400 the whole request
+                strict: (0, openai_strict_1.canUseStrictSchema)(parameters),
             };
         });
     }

package/dist/agents/openai/openai-strict.d.ts

@@ -0,0 +1,27 @@
+/**
+ * OpenAI strict function schemas.
+ *
+ * `strict: true` is a stronger contract than JSON Schema: OpenAI requires
+ * `required` to list *every* key in `properties`, so a tool with an optional
+ * parameter is rejected with a 400 before the model ever runs. Sending it
+ * unconditionally makes any such tool break the whole request — and since the
+ * tool belt is identical on every retry, every request of the session fails.
+ *
+ * The alternative fix is to declare optional parameters as nullable and require
+ * them anyway, per OpenAI's own guidance. In a library that is worse: it
+ * changes the schema every *other* provider sees (Gemini does not accept a
+ * `["string", "null"]` type union), and it makes each tool responsible for
+ * telling an explicit null from an omitted argument. Deciding `strict` per tool
+ * leaves the schemas untouched and keeps the guarantee for the tools that can
+ * already honour it.
+ */
+/**
+ * Whether OpenAI will accept this parameter schema under `strict: true`.
+ *
+ * Conservative on purpose: a false negative costs the schema-adherence
+ * guarantee for one tool, a false positive costs the whole request. MCP tools
+ * come from servers the host does not control, so "unrecognised shape" has to
+ * mean no.
+ */
+export declare function canUseStrictSchema(parameters: unknown): boolean;
+//# sourceMappingURL=openai-strict.d.ts.map

package/dist/agents/openai/openai-strict.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * OpenAI strict function schemas.
+ *
+ * `strict: true` is a stronger contract than JSON Schema: OpenAI requires
+ * `required` to list *every* key in `properties`, so a tool with an optional
+ * parameter is rejected with a 400 before the model ever runs. Sending it
+ * unconditionally makes any such tool break the whole request — and since the
+ * tool belt is identical on every retry, every request of the session fails.
+ *
+ * The alternative fix is to declare optional parameters as nullable and require
+ * them anyway, per OpenAI's own guidance. In a library that is worse: it
+ * changes the schema every *other* provider sees (Gemini does not accept a
+ * `["string", "null"]` type union), and it makes each tool responsible for
+ * telling an explicit null from an omitted argument. Deciding `strict` per tool
+ * leaves the schemas untouched and keeps the guarantee for the tools that can
+ * already honour it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canUseStrictSchema = canUseStrictSchema;
+/**
+ * Whether OpenAI will accept this parameter schema under `strict: true`.
+ *
+ * Conservative on purpose: a false negative costs the schema-adherence
+ * guarantee for one tool, a false positive costs the whole request. MCP tools
+ * come from servers the host does not control, so "unrecognised shape" has to
+ * mean no.
+ */
+function canUseStrictSchema(parameters) {
+    if (!parameters || typeof parameters !== "object")
+        return false;
+    const schema = parameters;
+    const properties = schema.properties && typeof schema.properties === "object"
+        ? schema.properties
+        : {};
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    // Strict mode also wants `additionalProperties: false` on every nested
+    // object, which `getToolDefinitions()` only sets at the top level. Rather
+    // than rewrite anyone's schema, treat a nested object as reason enough to
+    // drop the guarantee.
+    const isNested = (property) => {
+        if (!property || typeof property !== "object")
+            return false;
+        const value = property;
+        return value.type === "object" || isNested(value.items);
+    };
+    return (Object.keys(properties).every((key) => required.includes(key)) &&
+        !Object.values(properties).some(isNested));
+}
+//# sourceMappingURL=openai-strict.js.map

package/dist/gemini.d.ts

@@ -1,5 +1,5 @@
 export * from "./core";
-export { GeminiAgent } from "./agents/google/GeminiAgent";
-export type { GeminiModelCard } from "./agents/google/GeminiAgent";
+export { GeminiAgent, GEMINI_RETIRED_MODELS, } from "./agents/google/GeminiAgent";
+export type { GeminiModelCard, GeminiListModelsOptions, } from "./agents/google/GeminiAgent";
 export { geminiTransformer } from "./history/transformers";
 //# sourceMappingURL=gemini.d.ts.map

package/dist/gemini.js

@@ -14,11 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.geminiTransformer = exports.GeminiAgent = void 0;
+exports.geminiTransformer = exports.GEMINI_RETIRED_MODELS = exports.GeminiAgent = void 0;
 // Gemini Agent Entry Point
 __exportStar(require("./core"), exports);
 var GeminiAgent_1 = require("./agents/google/GeminiAgent");
 Object.defineProperty(exports, "GeminiAgent", { enumerable: true, get: function () { return GeminiAgent_1.GeminiAgent; } });
+Object.defineProperty(exports, "GEMINI_RETIRED_MODELS", { enumerable: true, get: function () { return GeminiAgent_1.GEMINI_RETIRED_MODELS; } });
 var transformers_1 = require("./history/transformers");
 Object.defineProperty(exports, "geminiTransformer", { enumerable: true, get: function () { return transformers_1.geminiTransformer; } });
 //# sourceMappingURL=gemini.js.map

package/dist/history/transformers.js

@@ -449,17 +449,34 @@ exports.geminiTransformer = {
                         name: block.name,
                         args: block.input,
                     },
+                    // Gemini 3 requires its own reasoning token back on the part it came
+                    // from, or it rejects the follow-up request outright
+                    ...(block.thoughtSignature
+                        ? { thoughtSignature: block.thoughtSignature }
+                        : {}),
                 });
             }
             // Add function response parts (for user messages with tool results)
             for (const block of toolResultBlocks) {
-                // Parse content if it's JSON, otherwise wrap in response object
+                // `functionResponse.response` is a protobuf Struct, so it has to be a
+                // JSON *object*. Parsing alone is not enough: a tool returning a plain
+                // string is stored as `JSON.stringify(result)`, which parses back to a
+                // string rather than throwing, so a bare scalar would go out and Gemini
+                // would answer 400 with the tool output quoted back. Anything that is
+                // not already an object is nested under `result` — the same shape the
+                // parse-failure path produces, so the model sees no difference and no
+                // tool has to know about any of this.
                 let responseData;
                 try {
                     responseData = JSON.parse(block.content);
                 }
                 catch {
-                    responseData = { result: block.content };
+                    responseData = block.content;
+                }
+                if (typeof responseData !== "object" ||
+                    responseData === null ||
+                    Array.isArray(responseData)) {
+                    responseData = { result: responseData ?? "" };
                 }
                 parts.push({
                     functionResponse: {
@@ -485,8 +502,14 @@ exports.geminiTransformer = {
             }
             if ("functionCall" in part && part.functionCall) {
                 const fc = part.functionCall;
-                normalizedContent.push((0, types_1.toolUse)(fc.name, // Gemini doesn't have separate IDs, use function name
-                fc.name, (fc.args || {})));
+                normalizedContent.push((0, types_1.toolUse)(
+                // Deliberately the name, not the `id` the live response also
+                // carries: `toProvider` sends a tool result as
+                // `functionResponse.name = block.tool_use_id`, and Gemini requires
+                // that to be the function name. Keying the block by Gemini's id
+                // would desynchronise the tool_use/tool_result pair without
+                // buying anything — the id is never echoed back.
+                fc.name, fc.name, (fc.args || {}), part.thoughtSignature));
             }
         }
         return {

package/dist/history/types.d.ts

@@ -19,6 +19,15 @@ export type ToolUseContent = {
     id: string;
     name: string;
     input: Record<string, unknown>;
+    /**
+     * Provider-opaque reasoning token that has to be echoed back verbatim.
+     *
+     * Gemini 3 returns one beside every `functionCall` and rejects any later
+     * request in the conversation that omits it — "Function call is missing a
+     * thought_signature in functionCall parts". Nothing reads its contents; it
+     * only has to survive the round trip through history.
+     */
+    thoughtSignature?: string;
 };
 /**
  * Result of a tool execution
@@ -174,7 +183,7 @@ export declare function text(value: string): TextContent;
 /**
  * Create a tool use content block
  */
-export declare function toolUse(id: string, name: string, input: Record<string, unknown>): ToolUseContent;
+export declare function toolUse(id: string, name: string, input: Record<string, unknown>, thoughtSignature?: string): ToolUseContent;
 /**
  * Create a thinking content block. Pass `redactedData` for redacted thinking.
  */

package/dist/history/types.js

@@ -56,8 +56,16 @@ function text(value) {
 /**
  * Create a tool use content block
  */
-function toolUse(id, name, input) {
-    return { type: "tool_use", id, name, input };
+function toolUse(id, name, input, thoughtSignature) {
+    // Only set the key when there is one, so a block stored without a signature
+    // serializes exactly as it did before the field existed
+    return {
+        type: "tool_use",
+        id,
+        name,
+        input,
+        ...(thoughtSignature ? { thoughtSignature } : {}),
+    };
 }
 /**
  * Create a thinking content block. Pass `redactedData` for redacted thinking.

package/dist/index.d.ts

@@ -3,8 +3,8 @@ export * from "./agents/anthropic/ClaudeAgent";
 export { OpenAiAgent } from "./agents/openai/OpenAiAgent";
 export { MistralAgent } from "./agents/mistral/MistralAgent";
 export type { MistralModelCard } from "./agents/mistral/MistralAgent";
-export { GeminiAgent } from "./agents/google/GeminiAgent";
-export type { GeminiModelCard } from "./agents/google/GeminiAgent";
+export { GeminiAgent, GEMINI_RETIRED_MODELS, } from "./agents/google/GeminiAgent";
+export type { GeminiModelCard, GeminiListModelsOptions, } from "./agents/google/GeminiAgent";
 export { OllamaAgent } from "./agents/ollama/OllamaAgent";
 export type { OllamaModelInfo } from "./agents/ollama/OllamaAgent";
 export { LlamaCppAgent } from "./agents/llamacpp/LlamaCppAgent";

package/dist/index.js

@@ -22,7 +22,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.chatCompletionsTransformer = exports.ollamaTransformer = exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = exports.OpenAICompatibleAgent = exports.LlamaCppAgent = exports.OllamaAgent = exports.GeminiAgent = exports.MistralAgent = exports.OpenAiAgent = void 0;
+exports.chatCompletionsTransformer = exports.ollamaTransformer = exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = exports.OpenAICompatibleAgent = exports.LlamaCppAgent = exports.OllamaAgent = exports.GEMINI_RETIRED_MODELS = exports.GeminiAgent = exports.MistralAgent = exports.OpenAiAgent = void 0;
 // Agents
 __exportStar(require("./agents/BaseAgent"), exports);
 __exportStar(require("./agents/anthropic/ClaudeAgent"), exports);
@@ -32,6 +32,7 @@ var MistralAgent_1 = require("./agents/mistral/MistralAgent");
 Object.defineProperty(exports, "MistralAgent", { enumerable: true, get: function () { return MistralAgent_1.MistralAgent; } });
 var GeminiAgent_1 = require("./agents/google/GeminiAgent");
 Object.defineProperty(exports, "GeminiAgent", { enumerable: true, get: function () { return GeminiAgent_1.GeminiAgent; } });
+Object.defineProperty(exports, "GEMINI_RETIRED_MODELS", { enumerable: true, get: function () { return GeminiAgent_1.GEMINI_RETIRED_MODELS; } });
 var OllamaAgent_1 = require("./agents/ollama/OllamaAgent");
 Object.defineProperty(exports, "OllamaAgent", { enumerable: true, get: function () { return OllamaAgent_1.OllamaAgent; } });
 var LlamaCppAgent_1 = require("./agents/llamacpp/LlamaCppAgent");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentionai/agents",
   "author": "Laurent Zuijdwijk",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Agent Library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",