indusagi 0.13.7 → 0.13.8

package/dist/types/facade/mcp-core/tool-factory.d.ts

@@ -0,0 +1,62 @@
+/**
+ * MCP Tool Factory
+ *
+ * Creates AgentTool instances from MCP tool definitions.
+ * Uses the factory pattern to match new_indusvx's ToolRegistry.
+ *
+ * Reference: MCP tool factory integration patterns.
+ */
+import type { TSchema } from "@sinclair/typebox";
+import type { AgentTool } from "../bot/types.js";
+import type { MCPToolDefinition, MCPToolCallResult } from "./types.js";
+/**
+ * Interface for MCP client that can call tools.
+ */
+export interface MCPToolClient {
+    /** Server name */
+    readonly serverName: string;
+    /** Whether client is connected */
+    readonly connected: boolean;
+    /** Call a tool on the MCP server */
+    callTool(name: string, args: Record<string, unknown>): Promise<MCPToolCallResult>;
+}
+/**
+ * Create an AgentTool from an MCP tool definition.
+ *
+ * This function creates a factory that matches ToolRegistry's pattern.
+ * The tool is namespaced with the server name to avoid conflicts.
+ *
+ * @param mcpTool - MCP tool definition from the server
+ * @param client - MCP client to use for tool execution
+ * @returns Factory function that creates an AgentTool
+ */
+export declare function createMCPAgentToolFactory(mcpTool: MCPToolDefinition, client: MCPToolClient): () => AgentTool<TSchema, MCPToolCallResult>;
+/**
+ * Register all MCP tools from a client into a ToolRegistry.
+ *
+ * This is the main integration point with new_indusvx's ToolRegistry.
+ *
+ * @param registry - ToolRegistry instance to register tools into
+ * @param client - MCP client with tools to register
+ * @param tools - List of tool definitions from the server
+ * @returns Number of tools registered
+ */
+export declare function registerMCPToolsInRegistry(registry: import("../bot/actions/registry.js").ToolRegistry, client: MCPToolClient, tools: MCPToolDefinition[]): Promise<number>;
+/**
+ * Create a map of AgentTools from MCP tool definitions.
+ * Useful when you don't want to use the registry pattern.
+ *
+ * @param tools - List of tool definitions from the server
+ * @param client - MCP client to use for tool execution
+ * @returns Map of namespaced tool names to AgentTool instances
+ */
+export declare function createMCPToolsMap(tools: MCPToolDefinition[], client: MCPToolClient): Map<string, AgentTool<TSchema, MCPToolCallResult>>;
+/**
+ * Create a record of AgentTools from MCP tool definitions.
+ * Matches the format expected by Agent's tools property.
+ *
+ * @param tools - List of tool definitions from the server
+ * @param client - MCP client to use for tool execution
+ * @returns Record of namespaced tool names to AgentTool instances
+ */
+export declare function createMCPToolsRecord(tools: MCPToolDefinition[], client: MCPToolClient): Record<string, AgentTool<TSchema, MCPToolCallResult>>;

package/dist/types/facade/mcp-core/toolbox-bridge.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Bridge a connected {@link MCPClient} into the runtime's {@link ToolBox} shape.
+ *
+ * `mcpClientToToolBox` is the entry point most callers want: it asks the
+ * connected client for its remote tool catalog, wraps each one with
+ * {@link defineTool} so the model sees a normal `ToolDescriptor`, and returns a
+ * {@link ToolBox} that drops straight into `createAgent({ tools })`. Every
+ * remote tool is registered under `"<prefix>__<name>"` so two MCP servers
+ * advertising the same name never collide.
+ *
+ * The mapping intentionally projects the MCP result into the kernel's
+ * {@link ToolContentBlock} vocabulary:
+ *   - `text` blocks pass through verbatim;
+ *   - `image` blocks become a one-line text mention (we do not ship raw
+ *     base64 to the model through this seam; structured payloads travel on
+ *     `structuredContent` instead);
+ *   - `resource` blocks become a `[resource <uri>]` mention;
+ *   - `structuredContent`, if present, is appended as a JSON content block.
+ */
+import type { MCPClient } from "./client.js";
+import type { MCPToolDefinition } from "./types.js";
+import type { ToolBox } from "../../runtime/contract/index.js";
+/** Options for {@link mcpClientToToolBox}. */
+export interface McpToToolBoxOptions {
+    /**
+     * Prefix each tool name with `"<prefix>__"`. Default: `"mcp"`. Two clients
+     * bridged in the same agent should use distinct prefixes.
+     */
+    readonly namePrefix?: string;
+    /** Optional filter — return false to skip a tool. */
+    readonly filter?: (tool: MCPToolDefinition) => boolean;
+    /** Logger for diagnostics. */
+    readonly logger?: {
+        debug(msg: string): void;
+        error(msg: string, err?: unknown): void;
+    };
+}
+/**
+ * Wrap a connected {@link MCPClient} as a runtime {@link ToolBox}.
+ *
+ * Each remote tool becomes a prefixed descriptor (`"<prefix>__<name>"`) whose
+ * invocation is forwarded to `client.callTool` with the model's input passed
+ * through unchanged. Results are projected from MCP content blocks onto the
+ * kernel's `ToolContentBlock` vocabulary.
+ */
+export declare function mcpClientToToolBox(client: MCPClient, options?: McpToToolBoxOptions): Promise<ToolBox>;

package/dist/types/facade/mcp-core/toolbox-bridge.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for {@link mcpClientToToolBox}.
+ *
+ * A small inline `FakeMCPClient` stands in for the real client: it tracks
+ * calls and scripts the responses of `listTools` / `callTool`. No network,
+ * no vi.mock — the codebase prefers stubbed fakes.
+ */
+export {};

package/dist/types/facade/mcp-core/types.d.ts

@@ -0,0 +1,298 @@
+/**
+ * MCP Type Definitions
+ *
+ * Aligned with Model Context Protocol specification
+ * Reference: MCP client type definitions.
+ */
+/**
+ * Configuration for MCP servers using stdio (subprocess) transport.
+ * Used when the MCP server is spawned as a subprocess that communicates via stdin/stdout.
+ */
+export interface StdioServerConfig {
+    /** Command to execute (e.g., 'node', 'python', 'npx') */
+    command: string;
+    /** Optional arguments to pass to the command */
+    args?: string[];
+    /** Optional environment variables for the subprocess */
+    env?: Record<string, string>;
+    /** Optional working directory for the subprocess */
+    cwd?: string;
+}
+/**
+ * Configuration for MCP servers using HTTP-based transport (Streamable HTTP or SSE fallback).
+ * Used when connecting to remote MCP servers over HTTP.
+ */
+export interface HttpServerConfig {
+    /** URL of the MCP server endpoint */
+    url: URL;
+    /** Optional headers for HTTP requests */
+    headers?: Record<string, string>;
+    /**
+     * Which HTTP transport to use.
+     *  - "http" (default): Streamable HTTP (single endpoint, server-push channel)
+     *  - "sse": legacy HTTP+SSE transport
+     */
+    transport?: "http" | "sse";
+    /** Custom fetch implementation */
+    fetch?: typeof fetch;
+}
+/**
+ * Configuration for connecting to an MCP server.
+ * Either stdio-based (subprocess) or HTTP-based (remote server).
+ */
+export type MCPServerConfig = StdioServerConfig | HttpServerConfig;
+/**
+ * Options for establishing an MCP connection.
+ */
+export interface MCPConnectionOptions {
+    /** Unique name for this server connection */
+    name: string;
+    /** Server configuration (stdio or HTTP) */
+    config: MCPServerConfig;
+    /** Optional timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * Definition of a tool exposed by an MCP server.
+ */
+export interface MCPToolDefinition {
+    /** Tool name */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** JSON Schema for input parameters */
+    inputSchema: Record<string, unknown>;
+    /** Optional JSON Schema for output */
+    outputSchema?: Record<string, unknown>;
+}
+/**
+ * Resource exposed by an MCP server.
+ */
+export interface MCPResource {
+    /** Unique URI for this resource */
+    uri: string;
+    /** Human-readable name */
+    name?: string;
+    /** MIME type of the resource content */
+    mimeType?: string;
+    /** Description of the resource */
+    description?: string;
+}
+/**
+ * Prompt template exposed by an MCP server.
+ */
+export interface MCPPrompt {
+    /** Prompt name */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Arguments the prompt accepts */
+    arguments?: Array<{
+        name: string;
+        description?: string;
+        required?: boolean;
+    }>;
+}
+/**
+ * Result of MCP server initialization.
+ */
+export interface MCPInitializeResult {
+    /** Protocol version supported by the server */
+    protocolVersion: string;
+    /** Server information */
+    serverInfo: {
+        name: string;
+        version?: string;
+    };
+    /** Server capabilities */
+    capabilities: Record<string, unknown>;
+}
+/**
+ * Current state of an MCP client connection.
+ */
+export interface MCPClientState {
+    /** Whether the client is connected */
+    connected: boolean;
+    /** Name of the connected server */
+    serverName: string;
+    /** Tools available from the server */
+    tools: MCPToolDefinition[];
+    /** Resources available from the server */
+    resources: MCPResource[];
+    /** Prompts available from the server */
+    prompts: MCPPrompt[];
+}
+/**
+ * Request to call an MCP tool.
+ */
+export interface MCPToolCallRequest {
+    /** Tool name */
+    name: string;
+    /** Tool arguments */
+    arguments: Record<string, unknown>;
+}
+/**
+ * Content block in an MCP tool call result.
+ */
+export type MCPContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+} | {
+    type: "resource";
+    resource: MCPResource;
+};
+/**
+ * Result of an MCP tool call.
+ */
+export interface MCPToolCallResult {
+    /** Content blocks returned by the tool */
+    content: MCPContentBlock[];
+    /** Whether the tool execution resulted in an error */
+    isError?: boolean;
+    /** Structured content if the tool has an output schema */
+    structuredContent?: unknown;
+}
+/**
+ * Server configuration in the MCP config file.
+ */
+export interface MCPServerConfigEntry {
+    /** Unique name for this server */
+    name: string;
+    /** Command for stdio transport */
+    command?: string;
+    /** Arguments for stdio transport */
+    args?: string[];
+    /** Environment variables for stdio transport */
+    env?: Record<string, string>;
+    /** URL for HTTP transport */
+    url?: string;
+    /** Headers for HTTP transport */
+    headers?: Record<string, string>;
+    /** HTTP transport flavor ("http" = Streamable HTTP default, "sse" = legacy) */
+    transport?: "http" | "sse";
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Whether this server is enabled (default: true) */
+    enabled?: boolean;
+}
+/**
+ * Server configuration without name (for object format).
+ */
+export interface MCPServerConfigValue {
+    /** Command for stdio transport */
+    command?: string;
+    /** Arguments for stdio transport */
+    args?: string[];
+    /** Environment variables for stdio transport */
+    env?: Record<string, string>;
+    /** URL for HTTP transport */
+    url?: string;
+    /** Headers for HTTP transport */
+    headers?: Record<string, string>;
+    /** HTTP transport flavor ("http" = Streamable HTTP default, "sse" = legacy) */
+    transport?: "http" | "sse";
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Whether this server is enabled (default: true) */
+    enabled?: boolean;
+}
+/**
+ * MCP configuration file structure.
+ * Supports two formats:
+ * - Array: { "servers": [{ "name": "github", "command": "npx", ... }] }
+ * - Object: { "servers": { "github": { "command": "npx", ... } } }
+ */
+export interface MCPConfigFile {
+    /** Server configurations (array or object with server names as keys) */
+    servers: MCPServerConfigEntry[] | Record<string, MCPServerConfigValue>;
+}
+/**
+ * MCP logging levels.
+ */
+export type MCPLoggingLevel = "debug" | "info" | "notice" | "warning" | "error" | "critical" | "alert" | "emergency";
+/**
+ * Log message from an MCP server.
+ */
+export interface MCPLogMessage {
+    /** Logging level */
+    level: MCPLoggingLevel;
+    /** Log message content */
+    message: string;
+    /** Timestamp */
+    timestamp: Date;
+    /** Server name */
+    serverName: string;
+    /** Additional details */
+    details?: Record<string, unknown>;
+}
+/**
+ * Handler function for processing log messages from MCP servers.
+ */
+export type MCPLogHandler = (logMessage: MCPLogMessage) => void;
+/**
+ * Progress notification from an MCP server.
+ */
+export interface MCPProgressNotification {
+    /** Progress token */
+    progressToken: string | number;
+    /** Current progress value */
+    progress: number;
+    /** Total value (optional) */
+    total?: number;
+    /** Human-readable message */
+    message?: string;
+}
+/**
+ * Handler function for processing progress notifications.
+ */
+export type MCPProgressHandler = (params: MCPProgressNotification) => void;
+/**
+ * Elicitation request from an MCP server (requesting user input).
+ */
+export interface MCPElicitRequest {
+    /** Message to display to the user */
+    message: string;
+    /** JSON Schema for the expected response */
+    requestedSchema: Record<string, unknown>;
+}
+/**
+ * Response to an elicitation request.
+ */
+export interface MCPElicitResult {
+    /** Action taken: accept, decline, or cancel */
+    action: "accept" | "decline" | "cancel";
+    /** Content if action is accept */
+    content?: Record<string, unknown>;
+}
+/**
+ * Handler function for processing elicitation requests.
+ */
+export type MCPElicitationHandler = (request: MCPElicitRequest) => Promise<MCPElicitResult>;
+/**
+ * Filesystem root exposed to MCP servers.
+ */
+export interface MCPRoot {
+    /** Unique URI (must be file://) */
+    uri: string;
+    /** Human-readable name */
+    name?: string;
+}
+/**
+ * Base options common to all MCP server definitions.
+ */
+export interface BaseServerOptions {
+    /** Optional handler for server log messages */
+    logger?: MCPLogHandler;
+    /** Optional timeout in milliseconds */
+    timeout?: number;
+    /** Whether to enable server log forwarding (default: true) */
+    enableServerLogs?: boolean;
+    /** Whether to enable progress tracking (default: false) */
+    enableProgressTracking?: boolean;
+    /** List of filesystem roots to expose to the MCP server */
+    roots?: MCPRoot[];
+}

package/dist/types/facade/mcp.d.ts

@@ -0,0 +1 @@
+export * from "./mcp-core/index";

package/dist/types/facade/memory.d.ts

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

package/dist/types/facade/ml/adapters/amazon-bedrock.d.ts

@@ -0,0 +1,32 @@
+import { type Message, type SystemContentBlock, type ToolConfiguration } from "@aws-sdk/client-bedrock-runtime";
+import type { Context, Model, SimpleStreamOptions, StreamFunction, StreamOptions, ThinkingBudgets, ThinkingLevel } from "../types.js";
+export interface BedrockOptions extends StreamOptions {
+    region?: string;
+    profile?: string;
+    toolChoice?: "auto" | "any" | "none" | {
+        type: "tool";
+        name: string;
+    };
+    reasoning?: ThinkingLevel;
+    thinkingBudgets?: ThinkingBudgets;
+    interleavedThinking?: boolean;
+}
+export declare class BedrockRequestBuilder {
+    private readonly model;
+    private readonly context;
+    private readonly options;
+    constructor(model: Model<"bedrock-converse-stream">, context: Context, options: BedrockOptions);
+    build(): {
+        modelId: string;
+        messages: Message[];
+        system: SystemContentBlock[] | undefined;
+        inferenceConfig: {
+            maxTokens: number | undefined;
+            temperature: number | undefined;
+        };
+        toolConfig: ToolConfiguration | undefined;
+        additionalModelRequestFields: Record<string, any> | undefined;
+    };
+}
+export declare const streamBedrock: StreamFunction<"bedrock-converse-stream", BedrockOptions>;
+export declare const streamSimpleBedrock: StreamFunction<"bedrock-converse-stream", SimpleStreamOptions>;

package/dist/types/facade/ml/adapters/anthropic-retry.test.d.ts

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

package/dist/types/facade/ml/adapters/anthropic.d.ts

@@ -0,0 +1,78 @@
+import type { MessageCreateParamsStreaming } from "@anthropic-ai/sdk/resources/messages.js";
+import type { Context, Model, SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.js";
+import { BaseStreamHandler } from "../kit/base-stream-handler.js";
+import { type ProviderLifecycleHooks } from "./simple-options.js";
+export interface AnthropicOptions extends StreamOptions {
+    thinkingEnabled?: boolean;
+    thinkingBudgetTokens?: number;
+    interleavedThinking?: boolean;
+    toolChoice?: "auto" | "any" | "none" | {
+        type: "tool";
+        name: string;
+    };
+}
+export interface AnthropicExecutionOptions {
+    hooks?: ProviderLifecycleHooks<MessageCreateParamsStreaming, unknown>;
+    retryPolicy?: {
+        maxAttempts?: number;
+        baseDelayMs?: number;
+    };
+}
+/**
+ * Assembles the streaming request payload for the Anthropic Messages API.
+ *
+ * Acts as the single place that turns a generic model/context/options triple
+ * into a concrete `MessageCreateParamsStreaming` object.
+ */
+export declare class AnthropicRequestBuilder {
+    private readonly model;
+    private readonly context;
+    private readonly isOAuthToken;
+    private readonly options?;
+    constructor(model: Model<"anthropic-messages">, context: Context, isOAuthToken: boolean, options?: AnthropicOptions | undefined);
+    /**
+     * Produce the parameters passed to the Anthropic streaming endpoint.
+     *
+     * @returns The fully populated SDK streaming request.
+     */
+    build(): MessageCreateParamsStreaming;
+}
+/**
+ * Stream handler tailored to Anthropic.
+ *
+ * Drives the Anthropic SDK stream and forwards normalized assistant events.
+ */
+export declare class AnthropicStreamHandler extends BaseStreamHandler {
+    private readonly executeFn?;
+    constructor(executeFn?: (() => Promise<void>) | undefined);
+    /**
+     * Run the supplied executor, if any, to consume the Anthropic stream.
+     */
+    protected processStream(): Promise<void>;
+    /**
+     * Walk the raw SDK stream, handing each event to the supplied callback.
+     *
+     * @param anthropicStream - Raw async iterable produced by the Anthropic SDK.
+     * @param onEvent - Invoked once per streamed event.
+     */
+    process(anthropicStream: AsyncIterable<unknown>, onEvent: (event: any) => void): Promise<void>;
+}
+/**
+ * Reads a `Retry-After` header off an Anthropic APIError and converts it to a
+ * delay in milliseconds. The header is the integer-seconds form per the
+ * Anthropic API; a missing/non-numeric value yields `null` so callers fall
+ * back to exponential backoff.
+ */
+export declare function parseAnthropicRetryAfterMs(error: unknown): number | null;
+/**
+ * Classifies an Anthropic failure as worth retrying. Mirrors
+ * `kit/provider-errors.ts:isRetryableError`: transient HTTP statuses (408/409/
+ * 429/529/5xx) and an `overloaded_error` body are retryable; auth/validation
+ * (401/403/4xx) are not. Generic errors fall back to a message sniff covering
+ * network/timeout/overload conditions. The `_attempt` is accepted to satisfy
+ * the RetryPolicy.shouldRetry contract but unused here (the loop already caps
+ * attempts).
+ */
+export declare function shouldRetryAnthropic(error: unknown, _attempt: number): boolean;
+export declare const streamAnthropic: StreamFunction<"anthropic-messages", AnthropicOptions>;
+export declare const streamSimpleAnthropic: StreamFunction<"anthropic-messages", SimpleStreamOptions>;

package/dist/types/facade/ml/adapters/azure-openai-responses.d.ts

@@ -0,0 +1,14 @@
+import type { SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.js";
+export interface AzureOpenAIResponsesOptions extends StreamOptions {
+    reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh";
+    reasoningSummary?: "auto" | "detailed" | "concise" | null;
+    azureApiVersion?: string;
+    azureResourceName?: string;
+    azureBaseUrl?: string;
+    azureDeploymentName?: string;
+}
+/**
+ * Streaming entry point for Azure OpenAI Responses deployments.
+ */
+export declare const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses", AzureOpenAIResponsesOptions>;
+export declare const streamSimpleAzureOpenAIResponses: StreamFunction<"azure-openai-responses", SimpleStreamOptions>;

package/dist/types/facade/ml/adapters/google-shared.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Common building blocks used by both Google front-ends — the Generative AI
+ * (Gemini) adapter and the Vertex AI adapter. Covers turning our messages and
+ * tools into Google's shapes, mapping finish reasons back to our stop reasons,
+ * and the bookkeeping around reasoning ("thought") signatures.
+ */
+import { type Content, FinishReason, FunctionCallingConfigMode, type Part, type Schema } from "@google/genai";
+import type { Context, Model, StopReason, Tool } from "../types.js";
+import { type ProviderLifecycleHooks } from "./simple-options.js";
+type GoogleApiType = "google-generative-ai" | "google-vertex";
+export interface GoogleRequestExecutionOptions<TRequest = unknown, TResponse = unknown> {
+    hooks?: ProviderLifecycleHooks<TRequest, TResponse>;
+    retryPolicy?: {
+        maxAttempts?: number;
+        baseDelayMs?: number;
+    };
+}
+export declare function executeGoogleRequest<TRequest, TResponse>(request: TRequest, executor: () => Promise<TResponse>, options?: GoogleRequestExecutionOptions<TRequest, TResponse>): Promise<TResponse>;
+/**
+ * Discrete reasoning intensities understood by Gemini. Every entry corresponds
+ * one-to-one with a value of the Google SDK's ThinkingLevel enum.
+ */
+export type GoogleThinkingLevel = "THINKING_LEVEL_UNSPECIFIED" | "MINIMAL" | "LOW" | "MEDIUM" | "HIGH";
+/**
+ * The four reasoning efforts callers can request, ordered weakest to strongest.
+ * Drawn from the internal ThinkingLevel set with the "xhigh" tier collapsed away.
+ */
+export type ClampedReasoningEffort = "minimal" | "low" | "medium" | "high";
+/** The slice of a Model object the Gemini reasoning helpers actually consult. */
+type GeminiModelRef = {
+    id: string;
+};
+/**
+ * Family buckets that decide how reasoning effort maps onto a request. Gemini 3
+ * variants take a discrete level; everything else takes a token budget.
+ */
+export type GeminiFamily = "gemini-3-pro" | "gemini-3-flash" | "default";
+/** Sort a model id into the Gemini family whose reasoning rules apply to it. */
+export declare function classifyGeminiFamily(modelId: string): GeminiFamily;
+/**
+ * Pick the discrete Gemini thinking level for a given effort. The Gemini-3 Pro
+ * family uses its coarser two-rung table; all other ids use the full four-rung
+ * mapping.
+ */
+export declare function selectGeminiThinkingLevel(effort: ClampedReasoningEffort, model: GeminiModelRef): GoogleThinkingLevel;
+/**
+ * Resolve the thinking-token budget for a model/effort pair. A caller-supplied
+ * override wins outright; otherwise the per-family default table is consulted,
+ * and unrecognized families return -1 so the model sizes its own budget.
+ */
+export declare function resolveGeminiThinkingBudget(model: GeminiModelRef, effort: ClampedReasoningEffort, customBudgets?: Partial<Record<ClampedReasoningEffort, number>>): number;
+/**
+ * Distinguishes a reasoning fragment from a normal answer fragment: a Gemini
+ * `Part` whose `thought` flag is set holds the model's internal reasoning.
+ */
+export declare function isThinkingPart(part: Pick<Part, "thought" | "thoughtSignature">): boolean;
+/**
+ * Keep whichever thought signature is freshest as chunks stream in: a new
+ * non-empty value replaces the old one, otherwise the previous value stands.
+ */
+export declare function retainThoughtSignature(existing: string | undefined, incoming: string | undefined): string | undefined;
+/**
+ * Some models served through Google demand that every function call — and the
+ * function response that answers it — carry an explicit correlation id. This
+ * returns true for those model families.
+ */
+export declare function requiresToolCallId(modelId: string): boolean;
+/**
+ * Map our internal conversation history onto the `Content[]` array Gemini's
+ * generate-content request expects.
+ */
+export declare function convertMessages<T extends GoogleApiType>(model: Model<T>, context: Context): Content[];
+/**
+ * Repackage our tool definitions into the nested function-declaration block
+ * Gemini reads them from.
+ */
+export declare function convertTools(tools: Tool[]): {
+    functionDeclarations: {
+        name: string;
+        description?: string;
+        parameters: Schema;
+    }[];
+}[] | undefined;
+/**
+ * Resolve one of our tool-choice keywords to the matching Gemini
+ * FunctionCallingConfigMode, defaulting to AUTO for anything unrecognized.
+ */
+export declare function mapToolChoice(choice: string): FunctionCallingConfigMode;
+/**
+ * Look up the unified StopReason for a Gemini FinishReason enum value, throwing
+ * if the enum carries a value the table above does not cover.
+ */
+export declare function mapStopReason(reason: FinishReason): StopReason;
+/**
+ * Variant of the finish-reason lookup that takes the raw string seen in
+ * deserialized API JSON, returning "error" for anything not explicitly listed.
+ */
+export declare function mapStopReasonString(reason: string): StopReason;
+export {};

package/dist/types/facade/ml/adapters/google-vertex.d.ts

@@ -0,0 +1,14 @@
+import type { SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.js";
+import { type GoogleThinkingLevel } from "./google-shared.js";
+export interface GoogleVertexOptions extends StreamOptions {
+    toolChoice?: "auto" | "none" | "any";
+    thinking?: {
+        enabled: boolean;
+        budgetTokens?: number;
+        level?: GoogleThinkingLevel;
+    };
+    project?: string;
+    location?: string;
+}
+export declare const streamGoogleVertex: StreamFunction<"google-vertex", GoogleVertexOptions>;
+export declare const streamSimpleGoogleVertex: StreamFunction<"google-vertex", SimpleStreamOptions>;