@agentionai/agents 1.4.0 → 1.6.0-beta.0

package/README.md

@@ -75,7 +75,7 @@ import { ClaudeAgent, OpenAiAgent } from '@agentionai/agents';
 
 ## Features
 
-- **Multi-Provider, No Lock-in** - Claude, OpenAI, Gemini, Mistral, plus local models via Ollama and llama.cpp—same interface. Switch models with one line.
+- **Multi-Provider, No Lock-in** - Claude, OpenAI, Gemini, Mistral, plus local models via Ollama and llama.cpp—same interface. Switch models with one line. `listModels()` asks any provider what it currently offers, in one shared shape.
 - **Composable Context Management** - Tool result masking (lossless, free) + rolling summarization (auto-firing) + sub-agent delegation (token isolation by architecture).
 - **Streaming** - `executeStream()` on Claude, OpenAI, and all OpenAI-compatible agents. Yields `{ type: "text" | "reasoning" }` chunks; tool calls handled transparently.
 - **Built-In Tools** - Use provider-defined server-side tools (e.g. Anthropic's web search, bash, text editor) alongside your own.

package/dist/agents/BaseAgent.d.ts

@@ -67,6 +67,76 @@ 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.
+ *
+ * Only `id` — the value you pass as `model` in an agent config — is guaranteed.
+ * Every other field is optional because no two providers report the same set:
+ * Anthropic gives a display name and release date but no context window,
+ * OpenAI gives an owner and a creation timestamp, Mistral and Gemini give
+ * context limits. The provider's own untouched entry is always available on
+ * `raw` for anything not covered here.
+ */
+export type ModelInfo<TRaw = unknown> = {
+    /** Model identifier, as passed to the API in the `model` field. */
+    id: string;
+    /** Human-readable name, where the provider reports one. */
+    displayName?: string;
+    /** Release or creation date, where the provider reports one. */
+    created?: Date;
+    /** Owning organisation, where the provider reports one. */
+    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,
+     * where an unloaded model is listed but has to be loaded before it answers.
+     *
+     * Undefined wherever the distinction does not exist or is not reported: every
+     * hosted provider, and a single-model `llama-server`, where the one model
+     * listed is by definition the loaded one.
+     */
+    loaded?: boolean;
+    /** The provider's unmodified entry for this model. */
+    raw: TRaw;
+};
 /**
  * The base agent is what the other agents are inheriting from
  * Handles the BaseConfig
@@ -107,6 +177,19 @@ export declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> ext
     protected abstract process(input: TInput): Promise<TOutput>;
     protected abstract handleResponse(response: unknown): Promise<unknown>;
     protected getToolDefinitions(): unknown[];
+    /**
+     * List the models the provider currently offers, straight from its models
+     * endpoint — the live answer, as opposed to the hand-maintained unions in
+     * `model-types.ts`.
+     *
+     * Overridden by every built-in agent; the base implementation throws so that
+     * a custom agent without a models endpoint fails with a clear message rather
+     * than silently returning nothing.
+     *
+     * @throws {ExecutionError} If the provider does not support listing, or the
+     *                          request fails.
+     */
+    listModels(): Promise<ModelInfo[]>;
     /**
      * Add an entry to history
      */

package/dist/agents/BaseAgent.js

@@ -7,6 +7,7 @@ exports.BaseAgent = void 0;
 const events_1 = __importDefault(require("events"));
 const Tool_1 = require("../tools/Tool");
 const History_1 = require("../history/History");
+const AgentError_1 = require("./errors/AgentError");
 /**
  * The base agent is what the other agents are inheriting from
  * Handles the BaseConfig
@@ -49,6 +50,21 @@ class BaseAgent extends events_1.default {
     getToolDefinitions() {
         return Array.from(this.tools.values()).map((tool) => tool.getPrompt());
     }
+    /**
+     * List the models the provider currently offers, straight from its models
+     * endpoint — the live answer, as opposed to the hand-maintained unions in
+     * `model-types.ts`.
+     *
+     * Overridden by every built-in agent; the base implementation throws so that
+     * a custom agent without a models endpoint fails with a clear message rather
+     * than silently returning nothing.
+     *
+     * @throws {ExecutionError} If the provider does not support listing, or the
+     *                          request fails.
+     */
+    async listModels() {
+        throw new AgentError_1.ExecutionError(`listModels() is not implemented for the '${this.vendor}' agent`);
+    }
     /**
      * Add an entry to history
      */

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

@@ -1,11 +1,57 @@
 import { Anthropic } from "@anthropic-ai/sdk";
-import { Message, ToolUnion, Usage } from "@anthropic-ai/sdk/resources";
+import { Message, type ModelInfo as AnthropicModelInfo, ToolUnion, Usage } from "@anthropic-ai/sdk/resources";
 import { type ToolDefinition } from "../../tools/Tool";
 import { type BuiltInTool } from "../../tools/BuiltInTool";
-import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
+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;
@@ -55,6 +101,20 @@ export declare class ClaudeAgent extends BaseAgent {
     private currentToolCallCount;
     constructor(config: Omit<AgentConfig, "vendor">, history?: History);
     protected getToolDefinitions(): ToolDefinition[];
+    /**
+     * List the models available to this API key, newest first.
+     *
+     * 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<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

@@ -62,6 +62,43 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
     getToolDefinitions() {
         return Array.from(this.tools.values()).map((tool) => tool.getPrompt());
     }
+    /**
+     * List the models available to this API key, newest first.
+     *
+     * 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: 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;
+        }
+        catch (error) {
+            throw new AgentError_1.ExecutionError(`Failed to list Anthropic models: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
     /**
      * Combine locally-executed tool definitions with provider-defined
      * (server-side) built-in tools, in the shape Anthropic's API expects.

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

@@ -1,7 +1,65 @@
 import { FunctionDeclarationsTool, GenerateContentResult, Schema } from "@google/generative-ai";
-import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
+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.
+ *
+ * Declared here rather than imported: `@google/generative-ai` only covers
+ * content generation and ships no type for the models endpoint.
+ */
+export type GeminiModelCard = {
+    /** Resource name, e.g. `"models/gemini-flash-latest"`. */
+    name: string;
+    baseModelId?: string;
+    version?: string;
+    displayName?: string;
+    description?: string;
+    inputTokenLimit?: number;
+    outputTokenLimit?: number;
+    /**
+     * 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;
+    topK?: number;
+};
 type AgentConfig = BaseAgentConfig & {
     apiKey: string;
     model?: GeminiModel;
@@ -34,6 +92,23 @@ export declare class GeminiAgent extends BaseAgent {
     /** Count of tool calls in current execution */
     private currentToolCallCount;
     constructor(config: Omit<AgentConfig, "vendor">, history?: History);
+    /**
+     * List the models available to this API key.
+     *
+     * Issued as a direct request to `/v1beta/models`: `@google/generative-ai`
+     * exposes no models endpoint, so there is no client method to call. Every
+     * 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 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(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");
@@ -8,6 +8,36 @@ const AgentError_1 = require("../errors/AgentError");
 const transformers_1 = require("../../history/transformers");
 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.
  *
@@ -45,12 +75,74 @@ class GeminiAgent extends BaseAgent_1.BaseAgent {
             candidateCount,
             responseMimeType,
             responseSchema,
+            defaultHeaders: config.defaultHeaders,
         };
         // Initialize the model
         this.generativeModel = this.client.getGenerativeModel({ model: this.config.model }, config.defaultHeaders ? { customHeaders: config.defaultHeaders } : undefined);
         // Add system message to history (skips if already exists with same content)
         this.addSystemMessage(this.getSystemMessage());
     }
+    /**
+     * List the models available to this API key.
+     *
+     * Issued as a direct request to `/v1beta/models`: `@google/generative-ai`
+     * exposes no models endpoint, so there is no client method to call. Every
+     * 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 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(options) {
+        try {
+            const models = [];
+            let pageToken;
+            do {
+                const url = new URL(`${GEMINI_API_BASE}/v1beta/models`);
+                url.searchParams.set("pageSize", "1000");
+                if (pageToken) {
+                    url.searchParams.set("pageToken", pageToken);
+                }
+                const response = await fetch(url, {
+                    headers: {
+                        "x-goog-api-key": this.config.apiKey,
+                        ...this.config.defaultHeaders,
+                    },
+                });
+                if (!response.ok) {
+                    throw new Error(`${response.status} ${response.statusText}: ${await response.text()}`);
+                }
+                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,
+                        displayName: model.displayName,
+                        contextLength: model.inputTokenLimit,
+                        maxOutputTokens: model.outputTokenLimit,
+                        capabilities: {
+                            chat: model.supportedGenerationMethods?.includes("generateContent"),
+                            thinking: model.thinking,
+                        },
+                        raw: model,
+                    });
+                }
+                pageToken = body.nextPageToken;
+            } while (pageToken);
+            return models;
+        }
+        catch (error) {
+            throw new AgentError_1.ExecutionError(`Failed to list Gemini models: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
     getToolDefinitionsForGemini() {
         const tools = Array.from(this.tools.values());
         if (tools.length === 0) {

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

@@ -1,6 +1,56 @@
+import { Model } from "openai/resources/models";
 import { History } from "../../history/History";
+import { ModelInfo } from "../BaseAgent";
 import { OpenAICompatibleAgent, OpenAICompatibleConfig } from "../openai-compatible/OpenAICompatibleAgent";
 import { LlamaCppModel } from "../model-types";
+/**
+ * The GGUF details `llama-server` reports for a model it has loaded. Absent
+ * from the listing for a model the router knows about but has not loaded.
+ */
+export type LlamaCppModelMeta = {
+    vocab_type?: number;
+    n_vocab?: number;
+    /** Context the model was actually loaded with (`--ctx-size`). */
+    n_ctx?: number;
+    /** Context the model was trained with — its ceiling, not its current size. */
+    n_ctx_train?: number;
+    n_embd?: number;
+    n_params?: number;
+    /** On-disk size in bytes. */
+    size?: number;
+    /** Quantization, e.g. `"Q6_K"`. */
+    ftype?: string;
+};
+/**
+ * One entry from a llama.cpp server's `/v1/models`.
+ *
+ * Everything past the OpenAI-standard fields is optional because it depends on
+ * how the server was started: a single-model `llama-server` reports `meta` for
+ * the model it is serving and nothing else, while a server in model-router mode
+ * lists every model it can serve, each with a `status` saying whether it is
+ * currently loaded. Verified against llama.cpp b10148.
+ */
+export type LlamaCppModelCard = Model & {
+    /** Alternative ids that resolve to this model. */
+    aliases?: string[];
+    tags?: string[];
+    /** Router mode only: whether the model is in memory, and how it is launched. */
+    status?: {
+        value: "loaded" | "unloaded" | (string & {});
+        /** The `llama-server` argv the router uses to bring this model up. */
+        args?: string[];
+        /** The preset block backing this model, as INI text. */
+        preset?: string;
+    };
+    architecture?: {
+        input_modalities?: string[];
+        output_modalities?: string[];
+    };
+    /** Where the router got the model — a config preset or the local HF cache. */
+    source?: "preset" | "cache" | (string & {});
+    can_remove?: boolean;
+    meta?: LlamaCppModelMeta;
+};
 type LlamaCppConfig = Omit<OpenAICompatibleConfig, "baseURL" | "model" | "vendor"> & {
     /** Base URL of the llama.cpp server's OpenAI-compatible API (default: `http://localhost:8080/v1`) */
     baseURL?: string;
@@ -32,6 +82,23 @@ type LlamaCppConfig = Omit<OpenAICompatibleConfig, "baseURL" | "model" | "vendor
 export declare class LlamaCppAgent extends OpenAICompatibleAgent {
     constructor(config: LlamaCppConfig, history?: History);
     protected getVendorName(): string;
+    /**
+     * List the models the server offers, adding the two things llama.cpp reports
+     * beyond the OpenAI-standard fields:
+     *
+     * - `loaded` — in model-router mode a listed model is not necessarily in
+     *   memory; an unloaded one has to be loaded before it answers. Left
+     *   undefined by a single-model server, which reports no status at all.
+     * - `contextLength` — `meta.n_ctx`, the context the model was actually loaded
+     *   with, falling back to the trained ceiling `n_ctx_train`. Only loaded
+     *   models carry `meta`.
+     *
+     * `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>[]>;
 }
 export {};
 //# sourceMappingURL=LlamaCppAgent.d.ts.map

package/dist/agents/llamacpp/LlamaCppAgent.js

@@ -39,6 +39,35 @@ class LlamaCppAgent extends OpenAICompatibleAgent_1.OpenAICompatibleAgent {
     getVendorName() {
         return "llama.cpp";
     }
+    /**
+     * List the models the server offers, adding the two things llama.cpp reports
+     * beyond the OpenAI-standard fields:
+     *
+     * - `loaded` — in model-router mode a listed model is not necessarily in
+     *   memory; an unloaded one has to be loaded before it answers. Left
+     *   undefined by a single-model server, which reports no status at all.
+     * - `contextLength` — `meta.n_ctx`, the context the model was actually loaded
+     *   with, falling back to the trained ceiling `n_ctx_train`. Only loaded
+     *   models carry `meta`.
+     *
+     * `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());
+        return models.map((model) => ({
+            ...model,
+            loaded: model.raw.status
+                ? 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"),
+            },
+        }));
+    }
 }
 exports.LlamaCppAgent = LlamaCppAgent;
 //# sourceMappingURL=LlamaCppAgent.js.map

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

@@ -1,7 +1,13 @@
-import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
+import { BaseAgent, BaseAgentConfig, ModelInfo, TokenUsage } from "../BaseAgent";
 import { History, MessageContent } from "../../history/History";
-import { ChatCompletionResponse, Tool, UsageInfo } from "@mistralai/mistralai/models/components";
+import { ChatCompletionResponse, ModelList, Tool, UsageInfo } from "@mistralai/mistralai/models/components";
 import { MistralModel } from "../model-types";
+/**
+ * One entry from Mistral's `/v1/models` response — a base model card or a
+ * fine-tuned one. Derived from the SDK's `ModelList` rather than imported
+ * directly, since the SDK exports the union under the unhelpful name `Data`.
+ */
+export type MistralModelCard = NonNullable<ModelList["data"]>[number];
 type AgentConfig = BaseAgentConfig & {
     apiKey: string;
     model?: MistralModel;
@@ -44,6 +50,20 @@ export declare class MistralAgent extends BaseAgent {
     /** Count of tool calls in current execution */
     private currentToolCallCount;
     constructor(config: Omit<AgentConfig, "vendor">, history?: History);
+    /**
+     * List the models available to this API key, base and fine-tuned alike.
+     *
+     * 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[];
     protected process(_input: string): Promise<string>;
     execute(input: string | MessageContent[]): Promise<string>;

package/dist/agents/mistral/MistralAgent.js

@@ -80,6 +80,42 @@ class MistralAgent extends BaseAgent_1.BaseAgent {
         // Add system message to history (skips if already exists with same content)
         this.addSystemMessage(this.getSystemMessage());
     }
+    /**
+     * List the models available to this API key, base and fine-tuned alike.
+     *
+     * 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 {
+            const response = await this.client.models.list();
+            return (response.data ?? []).map((model) => ({
+                id: model.id,
+                displayName: model.name ?? undefined,
+                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,
+            }));
+        }
+        catch (error) {
+            throw new AgentError_1.ExecutionError(`Failed to list Mistral models: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
     getToolDefinitions() {
         return Array.from(this.tools.values()).map((tool) => ({
             type: components_1.ToolTypes.Function,

package/dist/agents/ollama/OllamaAgent.d.ts

@@ -1,4 +1,4 @@
-import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
+import { BaseAgent, BaseAgentConfig, ModelInfo, TokenUsage } from "../BaseAgent";
 import { History, MessageContent } from "../../history/History";
 import { OllamaModel } from "../model-types";
 type AgentConfig = BaseAgentConfig & {
@@ -56,8 +56,12 @@ export declare class OllamaAgent extends BaseAgent {
     private getClient;
     /**
      * List the models currently available on the Ollama server.
+     *
+     * `id` is the tag to pass as `model` (e.g. `"llama3.2:latest"`) and `created`
+     * carries the local `modified_at` timestamp — Ollama reports when a model was
+     * last pulled or changed on this machine, not when it was released.
      */
-    listModels(): Promise<OllamaModelInfo[]>;
+    listModels(): Promise<ModelInfo<OllamaModelInfo>[]>;
     protected getToolDefinitions(): OllamaToolDefinition[];
     protected process(_input: string): Promise<string>;
     execute(input: string | MessageContent[]): Promise<string>;

package/dist/agents/ollama/OllamaAgent.js

@@ -113,12 +113,21 @@ class OllamaAgent extends BaseAgent_1.BaseAgent {
     }
     /**
      * List the models currently available on the Ollama server.
+     *
+     * `id` is the tag to pass as `model` (e.g. `"llama3.2:latest"`) and `created`
+     * carries the local `modified_at` timestamp — Ollama reports when a model was
+     * last pulled or changed on this machine, not when it was released.
      */
     async listModels() {
         try {
             const client = await this.getClient();
             const response = await client.list();
-            return response.models;
+            return response.models.map((model) => ({
+                id: model.model,
+                displayName: model.name,
+                created: model.modified_at ? new Date(model.modified_at) : undefined,
+                raw: model,
+            }));
         }
         catch (error) {
             throw new AgentError_1.ExecutionError(`Failed to list Ollama models: ${error instanceof Error ? error.message : "Unknown error"}`);

package/dist/agents/openai/OpenAiAgent.d.ts

@@ -1,6 +1,7 @@
-import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
+import { BaseAgent, BaseAgentConfig, ModelInfo, TokenUsage } from "../BaseAgent";
 import { History, MessageContent } from "../../history/History";
 import { Tool, Response, ResponseUsage } from "openai/resources/responses/responses";
+import type { Model as OpenAIModelCard } from "openai/resources/models";
 import { OpenAIModel, ReasoningEffort, ReasoningEffortFor } from "../model-types";
 import { StreamChunk } from "../openai-compatible/OpenAICompatibleAgent";
 type AgentConfig<M extends OpenAIModel = OpenAIModel> = BaseAgentConfig & {
@@ -67,6 +68,14 @@ export declare class OpenAiAgent<M extends OpenAIModel = OpenAIModel> extends Ba
     /** Count of tool calls in current execution */
     private currentToolCallCount;
     constructor(config: Omit<AgentConfig<M>, "vendor">, history?: History);
+    /**
+     * List the models available to this API key.
+     *
+     * The list covers everything the key can reach — chat, embedding, audio and
+     * image models alike — so filter by `id` if you only want the ones this
+     * agent can drive.
+     */
+    listModels(): Promise<ModelInfo<OpenAIModelCard>[]>;
     protected getToolDefinitions(): Tool[];
     /**
      * Build the `reasoning` field for a Responses API request, as an object to

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
@@ -87,20 +88,44 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
         // Add system message to history (skips if already exists with same content)
         this.addSystemMessage(this.getSystemMessage());
     }
+    /**
+     * List the models available to this API key.
+     *
+     * The list covers everything the key can reach — chat, embedding, audio and
+     * image models alike — so filter by `id` if you only want the ones this
+     * agent can drive.
+     */
+    async listModels() {
+        try {
+            const page = await this.client.models.list();
+            return page.data.map((model) => ({
+                id: model.id,
+                created: model.created ? new Date(model.created * 1000) : undefined,
+                ownedBy: model.owned_by,
+                raw: model,
+            }));
+        }
+        catch (error) {
+            throw new AgentError_1.ExecutionError(`Failed to list OpenAI models: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
     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/agents/openai-compatible/OpenAICompatibleAgent.d.ts

@@ -1,7 +1,7 @@
 import OpenAI from "openai";
 import { ChatCompletion, ChatCompletionTool } from "openai/resources/chat/completions";
 import { Model } from "openai/resources/models";
-import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
+import { BaseAgent, BaseAgentConfig, ModelInfo, TokenUsage } from "../BaseAgent";
 import { AgentVendor } from "../AgentConfig";
 import { History, MessageContent } from "../../history/History";
 /**
@@ -43,8 +43,11 @@ export declare abstract class OpenAICompatibleAgent extends BaseAgent {
     protected buildExtraRequestParams(): Record<string, unknown>;
     /**
      * List the models available on the server via the `/v1/models` endpoint.
+     *
+     * Local servers vary in how much they fill in — llama.cpp reports little
+     * beyond the id — so most fields other than `id` are typically undefined.
      */
-    listModels(): Promise<Model[]>;
+    listModels(): Promise<ModelInfo<Model>[]>;
     protected getToolDefinitions(): ChatCompletionTool[];
     protected process(_input: string): Promise<string>;
     execute(input: string | MessageContent[]): Promise<string>;

package/dist/agents/openai-compatible/OpenAICompatibleAgent.js

@@ -50,11 +50,19 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
     }
     /**
      * List the models available on the server via the `/v1/models` endpoint.
+     *
+     * Local servers vary in how much they fill in — llama.cpp reports little
+     * beyond the id — so most fields other than `id` are typically undefined.
      */
     async listModels() {
         try {
             const page = await this.client.models.list();
-            return page.data;
+            return page.data.map((model) => ({
+                id: model.id,
+                created: model.created ? new Date(model.created * 1000) : undefined,
+                ownedBy: model.owned_by,
+                raw: model,
+            }));
         }
         catch (error) {
             throw new AgentError_1.ExecutionError(`Failed to list ${this.getVendorName()} models: ${error instanceof Error ? error.message : "Unknown error"}`);

package/dist/gemini.d.ts

@@ -1,4 +1,5 @@
 export * from "./core";
-export { GeminiAgent } 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

@@ -2,9 +2,13 @@ export * from "./agents/BaseAgent";
 export * from "./agents/anthropic/ClaudeAgent";
 export { OpenAiAgent } from "./agents/openai/OpenAiAgent";
 export { MistralAgent } from "./agents/mistral/MistralAgent";
-export { GeminiAgent } from "./agents/google/GeminiAgent";
+export type { MistralModelCard } from "./agents/mistral/MistralAgent";
+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";
+export type { LlamaCppModelCard, LlamaCppModelMeta, } from "./agents/llamacpp/LlamaCppAgent";
 export { OpenAICompatibleAgent } from "./agents/openai-compatible/OpenAICompatibleAgent";
 export type { OpenAICompatibleConfig, StreamChunk } from "./agents/openai-compatible/OpenAICompatibleAgent";
 export * from "./agents/model-types";

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/dist/llamacpp.d.ts

@@ -1,5 +1,6 @@
 export * from "./core";
 export { LlamaCppAgent } from "./agents/llamacpp/LlamaCppAgent";
+export type { LlamaCppModelCard, LlamaCppModelMeta, } from "./agents/llamacpp/LlamaCppAgent";
 export { OpenAICompatibleAgent } from "./agents/openai-compatible/OpenAICompatibleAgent";
 export type { OpenAICompatibleConfig, StreamChunk } from "./agents/openai-compatible/OpenAICompatibleAgent";
 export { chatCompletionsTransformer } from "./history/transformers";

package/dist/mistral.d.ts

@@ -1,4 +1,5 @@
 export * from "./core";
 export { MistralAgent } from "./agents/mistral/MistralAgent";
+export type { MistralModelCard } from "./agents/mistral/MistralAgent";
 export { mistralTransformer } from "./history/transformers";
 //# sourceMappingURL=mistral.d.ts.map

package/dist/ollama.d.ts

@@ -1,4 +1,5 @@
 export * from "./core";
 export { OllamaAgent } from "./agents/ollama/OllamaAgent";
+export type { OllamaModelInfo } from "./agents/ollama/OllamaAgent";
 export { ollamaTransformer } from "./history/transformers";
 //# sourceMappingURL=ollama.d.ts.map

package/package.json

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