ai-sdk-ollama/dist/utils/tool-calling-reliability.d.ts

Vercel AI SDK Provider for Ollama using official ollama-js library

/**
 * Tool Calling Reliability Utilities for Ollama
 *
 * This module provides utilities to make Ollama tool calling more reliable
 * and deterministic. It addresses common issues like:
 * - Empty final text responses after tool execution
 * - Inconsistent parameter names
 * - Incomplete agent loops
 * - Tool result validation and recovery
 */
import { LanguageModelV4CallOptions, LanguageModelV4Content, LanguageModelV4FunctionTool, LanguageModelV4Prompt } from '@ai-sdk/provider';
export interface ToolCallingOptions {
    /**
     * Maximum number of retry attempts for tool calls
     */
    maxRetries?: number;
    /**
     * Whether to force completion when tool calls succeed but no final text is generated
     */
    forceCompletion?: boolean;
    /**
     * Whether to normalize parameter names to handle inconsistencies
     */
    normalizeParameters?: boolean;
    /**
     * Whether to validate tool results and attempt recovery
     */
    validateResults?: boolean;
    /**
     * Custom parameter normalization mappings
     */
    parameterMappings?: Record<string, string[]>;
    /**
     * Timeout for tool execution in milliseconds
     */
    toolTimeout?: number;
}
export interface ResolvedToolCallingOptions extends Omit<ToolCallingOptions, 'maxRetries' | 'forceCompletion' | 'normalizeParameters' | 'validateResults'> {
    maxRetries: number;
    forceCompletion: boolean;
    normalizeParameters: boolean;
    validateResults: boolean;
}
export declare function resolveToolCallingOptions(options?: ToolCallingOptions): ResolvedToolCallingOptions;
export interface ToolCallResult {
    success: boolean;
    result?: unknown;
    error?: string;
    normalizedInput?: Record<string, unknown>;
}
export interface ReliableToolCallResult {
    text: string;
    toolCalls: Array<{
        toolName: string;
        input: Record<string, unknown>;
    }>;
    toolResults?: Array<{
        toolName: string;
        input: Record<string, unknown>;
        normalizedInput?: Record<string, unknown>;
        result: unknown;
        success: boolean;
        error?: string;
    }>;
    completionMethod: 'natural' | 'forced' | 'incomplete';
    retryCount: number;
    errors?: string[];
}
export interface ToolDefinition {
    description: string;
    inputSchema: Record<string, unknown>;
    execute: (parameters: Record<string, unknown>) => Promise<unknown>;
}
export declare function parseToolArguments(input?: unknown): Record<string, unknown>;
export declare function createToolDefinitionMap(tools?: Array<LanguageModelV4FunctionTool>): Record<string, ToolDefinition>;
export declare function extractToolCallsFromContent(content: LanguageModelV4Content[]): Array<{
    toolName: string;
    input: Record<string, unknown>;
}>;
export declare function extractToolResultsFromPrompt(prompt: LanguageModelV4Prompt | undefined): Array<{
    toolName: string;
    result: unknown;
    toolCallId?: string;
}>;
/**
 * Extract tool results from Ollama messages array
 * This is used to get tool results that the AI SDK has already executed
 */
export declare function extractToolResultsFromMessages(messages: Array<{
    role: string;
    content: unknown;
}>): Array<{
    toolName: string;
    result: unknown;
    toolCallId?: string;
}>;
/**
 * Normalize tool parameters to handle inconsistent naming from Ollama models
 */
export declare function normalizeToolParameters(input: unknown, mappings?: Record<string, string[]>): Record<string, unknown>;
/**
 * Validate tool result and attempt recovery if needed
 */
export declare function validateToolResult(_toolName: string, input: Record<string, unknown>, result: unknown, executeFunction: (parameters: Record<string, unknown>) => Promise<unknown>, options?: ToolCallingOptions): Promise<ToolCallResult>;
/**
 * Create a structured prompt that encourages better tool usage
 */
export declare function createStructuredToolPrompt(originalPrompt: string, tools: Record<string, ToolDefinition>): string;
/**
 * Execute tool calls with reliability improvements
 */
export declare function executeReliableToolCalls(toolCalls: Array<{
    toolName: string;
    input: unknown;
}>, tools: Record<string, ToolDefinition>, options?: ToolCallingOptions): Promise<Array<{
    toolName: string;
    input: Record<string, unknown>;
    normalizedInput?: Record<string, unknown>;
    result: unknown;
    success: boolean;
    error?: string;
}>>;
/**
 * Force completion by generating a follow-up response with tool results
 */
export declare function forceCompletion(model: {
    doGenerate: (options: LanguageModelV4CallOptions) => Promise<{
        content: LanguageModelV4Content[];
    }>;
}, originalPrompt: string, toolResults: Array<{
    toolName: string;
    result: unknown;
}>, options?: Omit<LanguageModelV4CallOptions, 'prompt'>): Promise<string>;
/**
 * Main function for reliable tool calling with Ollama
 */
export declare function reliableToolCall(model: {
    doGenerate: (options: LanguageModelV4CallOptions) => Promise<{
        content: LanguageModelV4Content[];
        toolCalls?: Array<{
            toolName: string;
            input: Record<string, unknown>;
        }>;
    }>;
}, options: LanguageModelV4CallOptions & {
    tools?: Record<string, ToolDefinition>;
}, reliabilityOptions?: ToolCallingOptions): Promise<ReliableToolCallResult>;
/**
 * Enhanced tool calling wrapper that can be used as a drop-in replacement
 */
export declare function createReliableToolCallWrapper(model: {
    doGenerate: (options: LanguageModelV4CallOptions) => Promise<{
        content: LanguageModelV4Content[];
        toolCalls?: Array<{
            toolName: string;
            input: Record<string, unknown>;
        }>;
    }>;
}, reliabilityOptions?: ToolCallingOptions): (options: LanguageModelV4CallOptions & {
    tools?: Record<string, ToolDefinition>;
}) => Promise<ReliableToolCallResult>;
//# sourceMappingURL=tool-calling-reliability.d.ts.map