@riotprompt/riotprompt 0.0.8 → 0.0.10

package/dist/token-budget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-budget.js","sources":["../src/token-budget.ts"],"sourcesContent":["import { encoding_for_model, Tiktoken, TiktokenModel } from 'tiktoken';\nimport type { ConversationMessage } from './conversation';\nimport { Model } from './chat';\nimport { DEFAULT_LOGGER, wrapLogger } from './logger';\nimport { getEncoding } from './model-config';\n\n// ===== TYPE DEFINITIONS =====\n\n/**\n * Token usage information\n */\nexport interface TokenUsage {\n    used: number;\n    max: number;\n    remaining: number;\n    percentage: number;\n}\n\n/**\n * Compression statistics\n */\nexport interface CompressionStats {\n    messagesBefore: number;\n    messagesAfter: number;\n    tokensBefore: number;\n    tokensAfter: number;\n    tokensSaved: number;\n    strategy: CompressionStrategy;\n}\n\n/**\n * Compression strategy\n */\nexport type CompressionStrategy = 'priority-based' | 'fifo' | 'summarize' | 'adaptive';\n\n/**\n * Token budget configuration\n */\nexport interface TokenBudgetConfig {\n    // Hard limits\n    max: number;\n    reserveForResponse: number;\n    warningThreshold?: number;  // Default: 0.8 (80%)\n\n    // Compression strategy\n    strategy: CompressionStrategy;\n\n    // Behavior when budget exceeded\n    onBudgetExceeded: 'compress' | 'error' | 'warn' | 'truncate';\n\n    // What to preserve\n    preserveRecent?: number;\n    preserveSystem?: boolean;  // Default: true\n    preserveHighPriority?: boolean;  // Default: true\n\n    // Monitoring\n    onWarning?: (usage: TokenUsage) => void;\n    onCompression?: (stats: CompressionStats) => void;\n}\n\n// ===== TOKEN COUNTER =====\n\n/**\n * TokenCounter counts tokens using tiktoken for accurate model-specific counting.\n *\n * Features:\n * - Model-specific token counting\n * - Message overhead calculation\n * - Tool call token estimation\n * - Response token estimation\n *\n * @example\n * ```typescript\n * const counter = new TokenCounter('gpt-4o');\n *\n * const tokens = counter.count('Hello, world!');\n * console.log(`Text uses ${tokens} tokens`);\n *\n * const messageTokens = counter.countMessage({\n *   role: 'user',\n *   content: 'What is the weather?'\n * });\n * ```\n */\nexport class TokenCounter {\n    private encoder: Tiktoken;\n    private model: Model;\n    private logger: any;\n\n    constructor(model: Model, logger?: any) {\n        this.model = model;\n        this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'TokenCounter');\n\n        // Map RiotPrompt models to Tiktoken models\n        const tiktokenModel = this.mapToTiktokenModel(model);\n        this.encoder = encoding_for_model(tiktokenModel);\n\n        this.logger.debug('Created TokenCounter', { model });\n    }\n\n    /**\n     * Count tokens in text\n     */\n    count(text: string): number {\n        if (!text) return 0;\n        return this.encoder.encode(text).length;\n    }\n\n    /**\n     * Count tokens in a single message\n     */\n    countMessage(message: ConversationMessage): number {\n        let tokens = 4;  // Base overhead per message\n\n        // Content tokens\n        if (message.content) {\n            tokens += this.count(message.content);\n        }\n\n        // Role tokens\n        tokens += 1;\n\n        // Tool call tokens\n        if (message.tool_calls) {\n            for (const toolCall of message.tool_calls) {\n                tokens += this.count(JSON.stringify(toolCall));\n                tokens += 3;  // Tool call overhead\n            }\n        }\n\n        // Tool result tokens\n        if (message.tool_call_id) {\n            tokens += this.count(message.tool_call_id);\n            tokens += 2;  // Tool result overhead\n        }\n\n        return tokens;\n    }\n\n    /**\n     * Count tokens in entire conversation\n     */\n    countConversation(messages: ConversationMessage[]): number {\n        let total = 3;  // Conversation start overhead\n\n        for (const message of messages) {\n            total += this.countMessage(message);\n        }\n\n        return total;\n    }\n\n    /**\n     * Count with additional overhead estimation\n     */\n    countWithOverhead(\n        messages: ConversationMessage[],\n        includeToolOverhead: boolean = false\n    ): number {\n        let total = this.countConversation(messages);\n\n        // Add tool definition overhead if tools are present\n        if (includeToolOverhead) {\n            const hasTools = messages.some(m => m.tool_calls && m.tool_calls.length > 0);\n            if (hasTools) {\n                total += 100;  // Estimated tool definition overhead\n            }\n        }\n\n        return total;\n    }\n\n    /**\n     * Estimate tokens needed for response\n     */\n    estimateResponseTokens(messages: ConversationMessage[]): number {\n        // Heuristic: average response is about 20% of input\n        const inputTokens = this.countConversation(messages);\n        return Math.max(500, Math.floor(inputTokens * 0.2));\n    }\n\n    /**\n     * Map RiotPrompt model to Tiktoken model using model registry\n     */\n    private mapToTiktokenModel(model: Model): TiktokenModel {\n        const encoding = getEncoding(model);\n\n        // Map our encoding types to tiktoken models\n        switch (encoding) {\n            case 'gpt-4o':\n            case 'o200k_base':\n                return 'gpt-4o';\n            case 'cl100k_base':\n                return 'gpt-3.5-turbo';\n            default:\n                return 'gpt-4o';\n        }\n    }\n\n    /**\n     * Free encoder resources\n     */\n    dispose(): void {\n        this.encoder.free();\n    }\n}\n\n// ===== TOKEN BUDGET MANAGER =====\n\n/**\n * TokenBudgetManager manages token budgets and compression strategies.\n *\n * Features:\n * - Monitor token usage\n * - Automatic compression when budget exceeded\n * - Multiple compression strategies\n * - Priority-based message retention\n * - Usage statistics and callbacks\n *\n * @example\n * ```typescript\n * const manager = new TokenBudgetManager({\n *   max: 8000,\n *   reserveForResponse: 1000,\n *   strategy: 'priority-based',\n *   onBudgetExceeded: 'compress'\n * }, 'gpt-4o');\n *\n * // Check if message can be added\n * if (manager.canAddMessage(message)) {\n *   messages.push(message);\n * } else {\n *   // Compress conversation\n *   messages = manager.compress(messages);\n *   messages.push(message);\n * }\n * ```\n */\nexport class TokenBudgetManager {\n    private config: Required<TokenBudgetConfig>;\n    private counter: TokenCounter;\n    private logger: any;\n\n    constructor(config: TokenBudgetConfig, model: Model, logger?: any) {\n        this.config = {\n            warningThreshold: 0.8,\n            preserveRecent: 3,\n            preserveSystem: true,\n            preserveHighPriority: true,\n            onWarning: () => {},\n            onCompression: () => {},\n            ...config,\n        } as Required<TokenBudgetConfig>;\n\n        this.counter = new TokenCounter(model, logger);\n        this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'TokenBudgetManager');\n\n        this.logger.debug('Created TokenBudgetManager', {\n            max: this.config.max,\n            strategy: this.config.strategy\n        });\n    }\n\n    /**\n     * Get current token usage\n     */\n    getCurrentUsage(messages: ConversationMessage[]): TokenUsage {\n        const used = this.counter.countConversation(messages);\n        const max = this.config.max;\n        const remaining = Math.max(0, max - used - this.config.reserveForResponse);\n        const percentage = (used / max) * 100;\n\n        return { used, max, remaining, percentage };\n    }\n\n    /**\n     * Get remaining tokens available\n     */\n    getRemainingTokens(messages: ConversationMessage[]): number {\n        return this.getCurrentUsage(messages).remaining;\n    }\n\n    /**\n     * Check if near token limit\n     */\n    isNearLimit(messages: ConversationMessage[], threshold?: number): boolean {\n        const usage = this.getCurrentUsage(messages);\n        const checkThreshold = threshold ?? this.config.warningThreshold;\n\n        const isNear = usage.percentage >= (checkThreshold * 100);\n\n        if (isNear) {\n            this.config.onWarning?.(usage);\n        }\n\n        return isNear;\n    }\n\n    /**\n     * Check if a message can be added without exceeding budget\n     */\n    canAddMessage(message: ConversationMessage, currentMessages: ConversationMessage[]): boolean {\n        const currentTokens = this.counter.countConversation(currentMessages);\n        const messageTokens = this.counter.countMessage(message);\n        const total = currentTokens + messageTokens + this.config.reserveForResponse;\n\n        return total <= this.config.max;\n    }\n\n    /**\n     * Compress messages according to strategy\n     */\n    compress(messages: ConversationMessage[]): ConversationMessage[] {\n        const before = messages.length;\n        const tokensBefore = this.counter.countConversation(messages);\n        const targetTokens = this.config.max - this.config.reserveForResponse;\n\n        this.logger.debug('Compressing messages', {\n            before,\n            tokensBefore,\n            targetTokens,\n            strategy: this.config.strategy\n        });\n\n        // No compression needed\n        if (tokensBefore <= targetTokens) {\n            return messages;\n        }\n\n        let compressed: ConversationMessage[];\n\n        switch (this.config.strategy) {\n            case 'priority-based':\n                compressed = this.compressByPriority(messages, targetTokens);\n                break;\n            case 'fifo':\n                compressed = this.compressFIFO(messages, targetTokens);\n                break;\n            case 'adaptive':\n                compressed = this.compressAdaptive(messages, targetTokens);\n                break;\n            case 'summarize':\n                // For now, fall back to FIFO (summarization would require LLM call)\n                compressed = this.compressFIFO(messages, targetTokens);\n                break;\n            default:\n                compressed = this.compressFIFO(messages, targetTokens);\n        }\n\n        const tokensAfter = this.counter.countConversation(compressed);\n\n        const stats: CompressionStats = {\n            messagesBefore: before,\n            messagesAfter: compressed.length,\n            tokensBefore,\n            tokensAfter,\n            tokensSaved: tokensBefore - tokensAfter,\n            strategy: this.config.strategy,\n        };\n\n        this.config.onCompression?.(stats);\n\n        this.logger.info('Compressed conversation', stats);\n\n        return compressed;\n    }\n\n    /**\n     * Compress by priority (keep high-priority messages)\n     */\n    private compressByPriority(\n        messages: ConversationMessage[],\n        targetTokens: number\n    ): ConversationMessage[] {\n        // Calculate priority for each message\n        const withPriority = messages.map((msg, idx) => ({\n            message: msg,\n            priority: this.calculatePriority(msg, idx, messages.length),\n            tokens: this.counter.countMessage(msg),\n            index: idx,\n        }));\n\n        // Sort by priority (descending)\n        withPriority.sort((a, b) => b.priority - a.priority);\n\n        // Keep highest priority messages that fit in budget\n        const kept: typeof withPriority = [];\n        let totalTokens = 0;\n\n        for (const item of withPriority) {\n            if (totalTokens + item.tokens <= targetTokens) {\n                kept.push(item);\n                totalTokens += item.tokens;\n            }\n        }\n\n        // Sort back to original order\n        kept.sort((a, b) => a.index - b.index);\n\n        return kept.map(item => item.message);\n    }\n\n    /**\n     * Compress using FIFO (remove oldest first) - optimized with Set\n     */\n    private compressFIFO(\n        messages: ConversationMessage[],\n        targetTokens: number\n    ): ConversationMessage[] {\n        const preserved: ConversationMessage[] = [];\n        const preservedSet = new Set<ConversationMessage>();\n        let totalTokens = 0;\n\n        // Always preserve system messages if configured\n        const systemMessages = messages.filter(m => m.role === 'system');\n        if (this.config.preserveSystem) {\n            for (const msg of systemMessages) {\n                preserved.push(msg);\n                preservedSet.add(msg);\n                totalTokens += this.counter.countMessage(msg);\n            }\n        }\n\n        // Preserve recent messages\n        const recentCount = this.config.preserveRecent ?? 3;\n        const recentMessages = messages.slice(-recentCount).filter(m => m.role !== 'system');\n        for (const msg of recentMessages) {\n            if (!preservedSet.has(msg)) {\n                const tokens = this.counter.countMessage(msg);\n                if (totalTokens + tokens <= targetTokens) {\n                    preserved.push(msg);\n                    preservedSet.add(msg);\n                    totalTokens += tokens;\n                }\n            }\n        }\n\n        // Add older messages if space available\n        const otherMessages = messages.filter(\n            m => !preservedSet.has(m) && m.role !== 'system'\n        );\n\n        for (let i = otherMessages.length - 1; i >= 0; i--) {\n            const msg = otherMessages[i];\n            const tokens = this.counter.countMessage(msg);\n\n            if (totalTokens + tokens <= targetTokens) {\n                preserved.unshift(msg);\n                preservedSet.add(msg);\n                totalTokens += tokens;\n            } else {\n                break;\n            }\n        }\n\n        // Sort to maintain conversation order - use Set for O(1) lookup\n        return messages.filter(m => preservedSet.has(m));\n    }\n\n    /**\n     * Adaptive compression based on conversation phase\n     */\n    private compressAdaptive(\n        messages: ConversationMessage[],\n        targetTokens: number\n    ): ConversationMessage[] {\n        const messageCount = messages.length;\n\n        // Early phase: minimal compression (keep most messages)\n        if (messageCount <= 5) {\n            return this.compressFIFO(messages, targetTokens);\n        }\n\n        // Mid phase: moderate compression\n        if (messageCount <= 15) {\n            // Temporarily modify preserveRecent, then restore\n            const originalPreserveRecent = this.config.preserveRecent;\n            this.config.preserveRecent = 5;\n            const result = this.compressFIFO(messages, targetTokens);\n            this.config.preserveRecent = originalPreserveRecent;\n            return result;\n        }\n\n        // Late phase: aggressive compression (priority-based)\n        return this.compressByPriority(messages, targetTokens);\n    }\n\n    /**\n     * Calculate message priority for compression\n     */\n    private calculatePriority(\n        message: ConversationMessage,\n        index: number,\n        total: number\n    ): number {\n        let priority = 1.0;\n\n        // System messages: highest priority\n        if (message.role === 'system') {\n            priority = 10.0;\n        }\n\n        // Recent messages: higher priority\n        const recencyBonus = index / total;\n        priority += recencyBonus * 2;\n\n        // Tool results: moderate priority\n        if (message.role === 'tool') {\n            priority += 0.5;\n        }\n\n        // Messages with tool calls: keep for context\n        if (message.tool_calls && message.tool_calls.length > 0) {\n            priority += 0.8;\n        }\n\n        return priority;\n    }\n\n    /**\n     * Truncate to exact number of messages\n     */\n    truncate(messages: ConversationMessage[], maxMessages: number): ConversationMessage[] {\n        if (messages.length <= maxMessages) {\n            return messages;\n        }\n\n        // Keep system messages + recent messages\n        const systemMessages = messages.filter(m => m.role === 'system');\n        const otherMessages = messages.filter(m => m.role !== 'system');\n\n        const recentOther = otherMessages.slice(-(maxMessages - systemMessages.length));\n\n        return [...systemMessages, ...recentOther];\n    }\n\n    /**\n     * Dispose resources\n     */\n    dispose(): void {\n        this.counter.dispose();\n    }\n}\n\nexport default TokenBudgetManager;\n\n"],"names":["TokenCounter","count","text","encoder","encode","length","countMessage","message","tokens","content","tool_calls","toolCall","JSON","stringify","tool_call_id","countConversation","messages","total","countWithOverhead","includeToolOverhead","hasTools","some","m","estimateResponseTokens","inputTokens","Math","max","floor","mapToTiktokenModel","model","encoding","getEncoding","dispose","free","logger","wrapLogger","DEFAULT_LOGGER","tiktokenModel","encoding_for_model","debug","TokenBudgetManager","getCurrentUsage","used","counter","config","remaining","reserveForResponse","percentage","getRemainingTokens","isNearLimit","threshold","usage","checkThreshold","warningThreshold","isNear","onWarning","canAddMessage","currentMessages","currentTokens","messageTokens","compress","before","tokensBefore","targetTokens","strategy","compressed","compressByPriority","compressFIFO","compressAdaptive","tokensAfter","stats","messagesBefore","messagesAfter","tokensSaved","onCompression","info","withPriority","map","msg","idx","priority","calculatePriority","index","sort","a","b","kept","totalTokens","item","push","preservedSet","Set","systemMessages","filter","role","preserveSystem","add","recentCount","preserveRecent","recentMessages","slice","has","otherMessages","i","messageCount","originalPreserveRecent","result","recencyBonus","truncate","maxMessages","recentOther","preserveHighPriority"],"mappings":"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"}

package/dist/tools.d.ts

@@ -0,0 +1,239 @@
+/**
+ * Parameter definition for a tool
+ */
+export interface ToolParameter {
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+    description: string;
+    items?: ToolParameter;
+    properties?: Record<string, ToolParameter>;
+    required?: string[];
+    enum?: string[];
+    default?: any;
+}
+/**
+ * Context provided to tool execution
+ */
+export interface ToolContext {
+    workingDirectory?: string;
+    storage?: any;
+    logger?: any;
+    conversationState?: any;
+    [key: string]: any;
+}
+/**
+ * Example usage of a tool
+ */
+export interface ToolExample {
+    scenario: string;
+    params: any;
+    expectedResult: string;
+}
+/**
+ * Cost hint for tool execution
+ */
+export type ToolCost = 'cheap' | 'moderate' | 'expensive';
+/**
+ * Tool definition
+ */
+export interface Tool {
+    name: string;
+    description: string;
+    parameters: {
+        type: 'object';
+        properties: Record<string, ToolParameter>;
+        required?: string[];
+    };
+    execute: (params: any, context?: ToolContext) => Promise<any>;
+    category?: string;
+    cost?: ToolCost;
+    examples?: ToolExample[];
+}
+/**
+ * OpenAI-compatible tool format
+ */
+export interface OpenAITool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: 'object';
+            properties: Record<string, any>;
+            required?: string[];
+        };
+    };
+}
+/**
+ * Anthropic-compatible tool format
+ */
+export interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: 'object';
+        properties: Record<string, any>;
+        required?: string[];
+    };
+}
+/**
+ * Tool execution result
+ */
+export interface ToolExecutionResult {
+    success: boolean;
+    result?: any;
+    error?: string;
+    duration?: number;
+}
+/**
+ * Usage statistics for a tool
+ */
+export interface ToolUsageStats {
+    calls: number;
+    failures: number;
+    successRate: number;
+    averageDuration?: number;
+}
+/**
+ * Tool definition for export
+ */
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: Tool['parameters'];
+    category?: string;
+    cost?: ToolCost;
+    examples?: ToolExample[];
+}
+/**
+ * ToolRegistry manages tool definitions and execution.
+ *
+ * Features:
+ * - Register and manage tools
+ * - Execute tools with context
+ * - Track usage statistics
+ * - Export to different formats (OpenAI, Anthropic)
+ * - Filter by category
+ *
+ * @example
+ * ```typescript
+ * const registry = ToolRegistry.create({
+ *   workingDirectory: process.cwd(),
+ *   logger: myLogger
+ * });
+ *
+ * registry.register({
+ *   name: 'read_file',
+ *   description: 'Read a file',
+ *   parameters: {
+ *     type: 'object',
+ *     properties: {
+ *       path: { type: 'string', description: 'File path' }
+ *     },
+ *     required: ['path']
+ *   },
+ *   execute: async ({ path }) => {
+ *     return await fs.readFile(path, 'utf-8');
+ *   }
+ * });
+ *
+ * const result = await registry.execute('read_file', { path: 'test.txt' });
+ * ```
+ */
+export declare class ToolRegistry {
+    private tools;
+    private context;
+    private logger;
+    private usageStats;
+    private constructor();
+    /**
+     * Create a new ToolRegistry instance
+     */
+    static create(context?: ToolContext, logger?: any): ToolRegistry;
+    /**
+     * Register a single tool
+     */
+    register(tool: Tool): void;
+    /**
+     * Register multiple tools at once
+     */
+    registerAll(tools: Tool[]): void;
+    /**
+     * Get a tool by name
+     */
+    get(name: string): Tool | undefined;
+    /**
+     * Get all registered tools
+     */
+    getAll(): Tool[];
+    /**
+     * Get tools by category
+     */
+    getByCategory(category: string): Tool[];
+    /**
+     * Check if a tool is registered
+     */
+    has(name: string): boolean;
+    /**
+     * Get number of registered tools
+     */
+    count(): number;
+    /**
+     * Execute a tool by name
+     */
+    execute(name: string, params: any): Promise<any>;
+    /**
+     * Execute multiple tools in sequence
+     */
+    executeBatch(calls: Array<{
+        name: string;
+        params: any;
+    }>): Promise<any[]>;
+    /**
+     * Export tools in OpenAI format
+     */
+    toOpenAIFormat(): OpenAITool[];
+    /**
+     * Export tools in Anthropic format
+     */
+    toAnthropicFormat(): AnthropicTool[];
+    /**
+     * Get tool definitions (without execute function)
+     */
+    getDefinitions(): ToolDefinition[];
+    /**
+     * Get usage statistics for all tools
+     */
+    getUsageStats(): Map<string, ToolUsageStats>;
+    /**
+     * Get most frequently used tools
+     */
+    getMostUsed(limit?: number): Tool[];
+    /**
+     * Get list of all categories
+     */
+    getCategories(): string[];
+    /**
+     * Update execution context
+     */
+    updateContext(context: Partial<ToolContext>): void;
+    /**
+     * Get current context
+     */
+    getContext(): ToolContext;
+    /**
+     * Clear all tools
+     */
+    clear(): void;
+    /**
+     * Unregister a specific tool
+     */
+    unregister(name: string): boolean;
+    /**
+     * Reset usage statistics
+     */
+    resetStats(): void;
+}
+/**
+ * Export the registry for use in other modules
+ */
+export default ToolRegistry;

package/dist/tools.js

@@ -0,0 +1,324 @@
+import { z } from 'zod';
+import { wrapLogger, DEFAULT_LOGGER } from './logger.js';
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+// ===== VALIDATION SCHEMAS =====
+// Simplified parameter schema - just validate structure, not deep nesting
+const ToolSchema = z.object({
+    name: z.string().min(1),
+    description: z.string().min(1),
+    parameters: z.object({
+        type: z.literal('object'),
+        properties: z.record(z.string(), z.any()).default({}),
+        required: z.array(z.string()).optional()
+    }).passthrough(),
+    execute: z.custom((val)=>typeof val === 'function', {
+        message: 'execute must be a function'
+    }),
+    category: z.string().optional(),
+    cost: z.enum([
+        'cheap',
+        'moderate',
+        'expensive'
+    ]).optional(),
+    examples: z.array(z.object({
+        scenario: z.string(),
+        params: z.any(),
+        expectedResult: z.string()
+    })).optional()
+}).passthrough(); // Allow additional fields at tool level too
+// ===== TOOL REGISTRY =====
+/**
+ * ToolRegistry manages tool definitions and execution.
+ *
+ * Features:
+ * - Register and manage tools
+ * - Execute tools with context
+ * - Track usage statistics
+ * - Export to different formats (OpenAI, Anthropic)
+ * - Filter by category
+ *
+ * @example
+ * ```typescript
+ * const registry = ToolRegistry.create({
+ *   workingDirectory: process.cwd(),
+ *   logger: myLogger
+ * });
+ *
+ * registry.register({
+ *   name: 'read_file',
+ *   description: 'Read a file',
+ *   parameters: {
+ *     type: 'object',
+ *     properties: {
+ *       path: { type: 'string', description: 'File path' }
+ *     },
+ *     required: ['path']
+ *   },
+ *   execute: async ({ path }) => {
+ *     return await fs.readFile(path, 'utf-8');
+ *   }
+ * });
+ *
+ * const result = await registry.execute('read_file', { path: 'test.txt' });
+ * ```
+ */ class ToolRegistry {
+    /**
+     * Create a new ToolRegistry instance
+     */ static create(context, logger) {
+        return new ToolRegistry(context, logger);
+    }
+    /**
+     * Register a single tool
+     */ register(tool) {
+        // Validate tool
+        try {
+            ToolSchema.parse(tool);
+        } catch (error) {
+            throw new Error(`Invalid tool definition for "${tool.name}": ${error}`);
+        }
+        if (this.tools.has(tool.name)) {
+            this.logger.warn(`Tool "${tool.name}" already registered, overwriting`);
+        }
+        this.tools.set(tool.name, tool);
+        this.usageStats.set(tool.name, {
+            calls: 0,
+            failures: 0,
+            totalDuration: 0
+        });
+        this.logger.debug('Registered tool', {
+            name: tool.name,
+            category: tool.category
+        });
+    }
+    /**
+     * Register multiple tools at once
+     */ registerAll(tools) {
+        this.logger.debug('Registering multiple tools', {
+            count: tools.length
+        });
+        tools.forEach((tool)=>this.register(tool));
+    }
+    /**
+     * Get a tool by name
+     */ get(name) {
+        return this.tools.get(name);
+    }
+    /**
+     * Get all registered tools
+     */ getAll() {
+        return Array.from(this.tools.values());
+    }
+    /**
+     * Get tools by category
+     */ getByCategory(category) {
+        return this.getAll().filter((tool)=>tool.category === category);
+    }
+    /**
+     * Check if a tool is registered
+     */ has(name) {
+        return this.tools.has(name);
+    }
+    /**
+     * Get number of registered tools
+     */ count() {
+        return this.tools.size;
+    }
+    /**
+     * Execute a tool by name
+     */ async execute(name, params) {
+        const tool = this.tools.get(name);
+        if (!tool) {
+            throw new Error(`Tool "${name}" not found`);
+        }
+        this.logger.debug('Executing tool', {
+            name,
+            params
+        });
+        const startTime = Date.now();
+        const stats = this.usageStats.get(name);
+        stats.calls++;
+        try {
+            const result = await tool.execute(params, this.context);
+            const duration = Date.now() - startTime;
+            stats.totalDuration += duration;
+            this.logger.debug('Tool execution succeeded', {
+                name,
+                duration
+            });
+            return result;
+        } catch (error) {
+            stats.failures++;
+            this.logger.error('Tool execution failed', {
+                name,
+                error
+            });
+            throw error;
+        }
+    }
+    /**
+     * Execute multiple tools in sequence
+     */ async executeBatch(calls) {
+        this.logger.debug('Executing batch', {
+            count: calls.length
+        });
+        const results = [];
+        for (const call of calls){
+            try {
+                const result = await this.execute(call.name, call.params);
+                results.push(result);
+            } catch (error) {
+                results.push({
+                    error: String(error)
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Export tools in OpenAI format
+     */ toOpenAIFormat() {
+        return this.getAll().map((tool)=>({
+                type: 'function',
+                function: {
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: {
+                        type: 'object',
+                        properties: tool.parameters.properties,
+                        required: tool.parameters.required
+                    }
+                }
+            }));
+    }
+    /**
+     * Export tools in Anthropic format
+     */ toAnthropicFormat() {
+        return this.getAll().map((tool)=>({
+                name: tool.name,
+                description: tool.description,
+                input_schema: {
+                    type: 'object',
+                    properties: tool.parameters.properties,
+                    required: tool.parameters.required
+                }
+            }));
+    }
+    /**
+     * Get tool definitions (without execute function)
+     */ getDefinitions() {
+        return this.getAll().map((tool)=>({
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters,
+                category: tool.category,
+                cost: tool.cost,
+                examples: tool.examples
+            }));
+    }
+    /**
+     * Get usage statistics for all tools
+     */ getUsageStats() {
+        const stats = new Map();
+        this.usageStats.forEach((rawStats, name)=>{
+            stats.set(name, {
+                calls: rawStats.calls,
+                failures: rawStats.failures,
+                successRate: rawStats.calls > 0 ? (rawStats.calls - rawStats.failures) / rawStats.calls : 0,
+                averageDuration: rawStats.calls > 0 ? rawStats.totalDuration / rawStats.calls : undefined
+            });
+        });
+        return stats;
+    }
+    /**
+     * Get most frequently used tools
+     */ getMostUsed(limit = 5) {
+        const sorted = Array.from(this.usageStats.entries()).sort((a, b)=>b[1].calls - a[1].calls).slice(0, limit).map(([name])=>this.tools.get(name)).filter((tool)=>tool !== undefined);
+        return sorted;
+    }
+    /**
+     * Get list of all categories
+     */ getCategories() {
+        const categories = new Set();
+        this.getAll().forEach((tool)=>{
+            if (tool.category) {
+                categories.add(tool.category);
+            }
+        });
+        return Array.from(categories).sort();
+    }
+    /**
+     * Update execution context
+     */ updateContext(context) {
+        this.context = {
+            ...this.context,
+            ...context
+        };
+        this.logger.debug('Updated context', {
+            keys: Object.keys(context)
+        });
+    }
+    /**
+     * Get current context
+     */ getContext() {
+        return {
+            ...this.context
+        };
+    }
+    /**
+     * Clear all tools
+     */ clear() {
+        this.logger.debug('Clearing all tools');
+        this.tools.clear();
+        this.usageStats.clear();
+    }
+    /**
+     * Unregister a specific tool
+     */ unregister(name) {
+        if (this.tools.has(name)) {
+            this.tools.delete(name);
+            this.usageStats.delete(name);
+            this.logger.debug('Unregistered tool', {
+                name
+            });
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Reset usage statistics
+     */ resetStats() {
+        this.logger.debug('Resetting usage statistics');
+        this.usageStats.forEach((stats)=>{
+            stats.calls = 0;
+            stats.failures = 0;
+            stats.totalDuration = 0;
+        });
+    }
+    constructor(context = {}, logger){
+        _define_property(this, "tools", void 0);
+        _define_property(this, "context", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "usageStats", void 0);
+        this.tools = new Map();
+        this.context = context;
+        this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'ToolRegistry');
+        this.usageStats = new Map();
+        this.logger.debug('Created ToolRegistry');
+    }
+}
+
+export { ToolRegistry, ToolRegistry as default };
+//# sourceMappingURL=tools.js.map

package/dist/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","sources":["../src/tools.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { DEFAULT_LOGGER, wrapLogger } from \"./logger\";\n\n// ===== TYPE DEFINITIONS =====\n\n/**\n * Parameter definition for a tool\n */\nexport interface ToolParameter {\n    type: 'string' | 'number' | 'boolean' | 'array' | 'object';\n    description: string;\n    items?: ToolParameter;\n    properties?: Record<string, ToolParameter>;\n    required?: string[];\n    enum?: string[];\n    default?: any;\n}\n\n/**\n * Context provided to tool execution\n */\nexport interface ToolContext {\n    workingDirectory?: string;\n    storage?: any;\n    logger?: any;\n    conversationState?: any;\n    [key: string]: any;\n}\n\n/**\n * Example usage of a tool\n */\nexport interface ToolExample {\n    scenario: string;\n    params: any;\n    expectedResult: string;\n}\n\n/**\n * Cost hint for tool execution\n */\nexport type ToolCost = 'cheap' | 'moderate' | 'expensive';\n\n/**\n * Tool definition\n */\nexport interface Tool {\n    name: string;\n    description: string;\n    parameters: {\n        type: 'object';\n        properties: Record<string, ToolParameter>;\n        required?: string[];\n    };\n    execute: (params: any, context?: ToolContext) => Promise<any>;\n\n    // Optional metadata\n    category?: string;\n    cost?: ToolCost;\n    examples?: ToolExample[];\n}\n\n/**\n * OpenAI-compatible tool format\n */\nexport interface OpenAITool {\n    type: 'function';\n    function: {\n        name: string;\n        description: string;\n        parameters: {\n            type: 'object';\n            properties: Record<string, any>;\n            required?: string[];\n        };\n    };\n}\n\n/**\n * Anthropic-compatible tool format\n */\nexport interface AnthropicTool {\n    name: string;\n    description: string;\n    input_schema: {\n        type: 'object';\n        properties: Record<string, any>;\n        required?: string[];\n    };\n}\n\n/**\n * Tool execution result\n */\nexport interface ToolExecutionResult {\n    success: boolean;\n    result?: any;\n    error?: string;\n    duration?: number;\n}\n\n/**\n * Usage statistics for a tool\n */\nexport interface ToolUsageStats {\n    calls: number;\n    failures: number;\n    successRate: number;\n    averageDuration?: number;\n}\n\n/**\n * Tool definition for export\n */\nexport interface ToolDefinition {\n    name: string;\n    description: string;\n    parameters: Tool['parameters'];\n    category?: string;\n    cost?: ToolCost;\n    examples?: ToolExample[];\n}\n\n// ===== VALIDATION SCHEMAS =====\n\n// Simplified parameter schema - just validate structure, not deep nesting\nconst ToolSchema = z.object({\n    name: z.string().min(1),\n    description: z.string().min(1),\n    parameters: z.object({\n        type: z.literal('object'),\n        properties: z.record(z.string(), z.any()).default({}), // Allow any parameter structure\n        required: z.array(z.string()).optional(),\n    }).passthrough(), // Allow additional fields\n    execute: z.custom<(params: any, context?: any) => Promise<any>>(\n        (val) => typeof val === 'function',\n    { message: 'execute must be a function' }\n    ),\n    category: z.string().optional(),\n    cost: z.enum(['cheap', 'moderate', 'expensive']).optional(),\n    examples: z.array(z.object({\n        scenario: z.string(),\n        params: z.any(),\n        expectedResult: z.string(),\n    })).optional(),\n}).passthrough(); // Allow additional fields at tool level too\n\n// ===== TOOL REGISTRY =====\n\n/**\n * ToolRegistry manages tool definitions and execution.\n *\n * Features:\n * - Register and manage tools\n * - Execute tools with context\n * - Track usage statistics\n * - Export to different formats (OpenAI, Anthropic)\n * - Filter by category\n *\n * @example\n * ```typescript\n * const registry = ToolRegistry.create({\n *   workingDirectory: process.cwd(),\n *   logger: myLogger\n * });\n *\n * registry.register({\n *   name: 'read_file',\n *   description: 'Read a file',\n *   parameters: {\n *     type: 'object',\n *     properties: {\n *       path: { type: 'string', description: 'File path' }\n *     },\n *     required: ['path']\n *   },\n *   execute: async ({ path }) => {\n *     return await fs.readFile(path, 'utf-8');\n *   }\n * });\n *\n * const result = await registry.execute('read_file', { path: 'test.txt' });\n * ```\n */\nexport class ToolRegistry {\n    private tools: Map<string, Tool>;\n    private context: ToolContext;\n    private logger: any;\n    private usageStats: Map<string, { calls: number; failures: number; totalDuration: number }>;\n\n    private constructor(context: ToolContext = {}, logger?: any) {\n        this.tools = new Map();\n        this.context = context;\n        this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'ToolRegistry');\n        this.usageStats = new Map();\n\n        this.logger.debug('Created ToolRegistry');\n    }\n\n    /**\n     * Create a new ToolRegistry instance\n     */\n    static create(context?: ToolContext, logger?: any): ToolRegistry {\n        return new ToolRegistry(context, logger);\n    }\n\n    /**\n     * Register a single tool\n     */\n    register(tool: Tool): void {\n        // Validate tool\n        try {\n            ToolSchema.parse(tool);\n        } catch (error) {\n            throw new Error(`Invalid tool definition for \"${tool.name}\": ${error}`);\n        }\n\n        if (this.tools.has(tool.name)) {\n            this.logger.warn(`Tool \"${tool.name}\" already registered, overwriting`);\n        }\n\n        this.tools.set(tool.name, tool);\n        this.usageStats.set(tool.name, { calls: 0, failures: 0, totalDuration: 0 });\n\n        this.logger.debug('Registered tool', { name: tool.name, category: tool.category });\n    }\n\n    /**\n     * Register multiple tools at once\n     */\n    registerAll(tools: Tool[]): void {\n        this.logger.debug('Registering multiple tools', { count: tools.length });\n\n        tools.forEach(tool => this.register(tool));\n    }\n\n    /**\n     * Get a tool by name\n     */\n    get(name: string): Tool | undefined {\n        return this.tools.get(name);\n    }\n\n    /**\n     * Get all registered tools\n     */\n    getAll(): Tool[] {\n        return Array.from(this.tools.values());\n    }\n\n    /**\n     * Get tools by category\n     */\n    getByCategory(category: string): Tool[] {\n        return this.getAll().filter(tool => tool.category === category);\n    }\n\n    /**\n     * Check if a tool is registered\n     */\n    has(name: string): boolean {\n        return this.tools.has(name);\n    }\n\n    /**\n     * Get number of registered tools\n     */\n    count(): number {\n        return this.tools.size;\n    }\n\n    /**\n     * Execute a tool by name\n     */\n    async execute(name: string, params: any): Promise<any> {\n        const tool = this.tools.get(name);\n\n        if (!tool) {\n            throw new Error(`Tool \"${name}\" not found`);\n        }\n\n        this.logger.debug('Executing tool', { name, params });\n\n        const startTime = Date.now();\n        const stats = this.usageStats.get(name)!;\n        stats.calls++;\n\n        try {\n            const result = await tool.execute(params, this.context);\n\n            const duration = Date.now() - startTime;\n            stats.totalDuration += duration;\n\n            this.logger.debug('Tool execution succeeded', { name, duration });\n\n            return result;\n        } catch (error) {\n            stats.failures++;\n\n            this.logger.error('Tool execution failed', { name, error });\n\n            throw error;\n        }\n    }\n\n    /**\n     * Execute multiple tools in sequence\n     */\n    async executeBatch(calls: Array<{ name: string; params: any }>): Promise<any[]> {\n        this.logger.debug('Executing batch', { count: calls.length });\n\n        const results: any[] = [];\n\n        for (const call of calls) {\n            try {\n                const result = await this.execute(call.name, call.params);\n                results.push(result);\n            } catch (error) {\n                results.push({ error: String(error) });\n            }\n        }\n\n        return results;\n    }\n\n    /**\n     * Export tools in OpenAI format\n     */\n    toOpenAIFormat(): OpenAITool[] {\n        return this.getAll().map(tool => ({\n            type: 'function' as const,\n            function: {\n                name: tool.name,\n                description: tool.description,\n                parameters: {\n                    type: 'object' as const,\n                    properties: tool.parameters.properties,\n                    required: tool.parameters.required,\n                },\n            },\n        }));\n    }\n\n    /**\n     * Export tools in Anthropic format\n     */\n    toAnthropicFormat(): AnthropicTool[] {\n        return this.getAll().map(tool => ({\n            name: tool.name,\n            description: tool.description,\n            input_schema: {\n                type: 'object' as const,\n                properties: tool.parameters.properties,\n                required: tool.parameters.required,\n            },\n        }));\n    }\n\n    /**\n     * Get tool definitions (without execute function)\n     */\n    getDefinitions(): ToolDefinition[] {\n        return this.getAll().map(tool => ({\n            name: tool.name,\n            description: tool.description,\n            parameters: tool.parameters,\n            category: tool.category,\n            cost: tool.cost,\n            examples: tool.examples,\n        }));\n    }\n\n    /**\n     * Get usage statistics for all tools\n     */\n    getUsageStats(): Map<string, ToolUsageStats> {\n        const stats = new Map<string, ToolUsageStats>();\n\n        this.usageStats.forEach((rawStats, name) => {\n            stats.set(name, {\n                calls: rawStats.calls,\n                failures: rawStats.failures,\n                successRate: rawStats.calls > 0\n                    ? (rawStats.calls - rawStats.failures) / rawStats.calls\n                    : 0,\n                averageDuration: rawStats.calls > 0\n                    ? rawStats.totalDuration / rawStats.calls\n                    : undefined,\n            });\n        });\n\n        return stats;\n    }\n\n    /**\n     * Get most frequently used tools\n     */\n    getMostUsed(limit: number = 5): Tool[] {\n        const sorted = Array.from(this.usageStats.entries())\n            .sort((a, b) => b[1].calls - a[1].calls)\n            .slice(0, limit)\n            .map(([name]) => this.tools.get(name)!)\n            .filter(tool => tool !== undefined);\n\n        return sorted;\n    }\n\n    /**\n     * Get list of all categories\n     */\n    getCategories(): string[] {\n        const categories = new Set<string>();\n\n        this.getAll().forEach(tool => {\n            if (tool.category) {\n                categories.add(tool.category);\n            }\n        });\n\n        return Array.from(categories).sort();\n    }\n\n    /**\n     * Update execution context\n     */\n    updateContext(context: Partial<ToolContext>): void {\n        this.context = { ...this.context, ...context };\n        this.logger.debug('Updated context', { keys: Object.keys(context) });\n    }\n\n    /**\n     * Get current context\n     */\n    getContext(): ToolContext {\n        return { ...this.context };\n    }\n\n    /**\n     * Clear all tools\n     */\n    clear(): void {\n        this.logger.debug('Clearing all tools');\n        this.tools.clear();\n        this.usageStats.clear();\n    }\n\n    /**\n     * Unregister a specific tool\n     */\n    unregister(name: string): boolean {\n        if (this.tools.has(name)) {\n            this.tools.delete(name);\n            this.usageStats.delete(name);\n            this.logger.debug('Unregistered tool', { name });\n            return true;\n        }\n\n        return false;\n    }\n\n    /**\n     * Reset usage statistics\n     */\n    resetStats(): void {\n        this.logger.debug('Resetting usage statistics');\n\n        this.usageStats.forEach(stats => {\n            stats.calls = 0;\n            stats.failures = 0;\n            stats.totalDuration = 0;\n        });\n    }\n}\n\n/**\n * Export the registry for use in other modules\n */\nexport default ToolRegistry;\n\n"],"names":["ToolSchema","z","object","name","string","min","description","parameters","type","literal","properties","record","any","default","required","array","optional","passthrough","execute","custom","val","message","category","cost","enum","examples","scenario","params","expectedResult","ToolRegistry","create","context","logger","register","tool","parse","error","Error","tools","has","warn","set","usageStats","calls","failures","totalDuration","debug","registerAll","count","length","forEach","get","getAll","Array","from","values","getByCategory","filter","size","startTime","Date","now","stats","result","duration","executeBatch","results","call","push","String","toOpenAIFormat","map","function","toAnthropicFormat","input_schema","getDefinitions","getUsageStats","Map","rawStats","successRate","averageDuration","undefined","getMostUsed","limit","sorted","entries","sort","a","b","slice","getCategories","categories","Set","add","updateContext","keys","Object","getContext","clear","unregister","delete","resetStats","wrapLogger","DEFAULT_LOGGER"],"mappings":"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"}