llm-advanced-tools 0.1.1 → 0.1.3

package/src/core/registry.ts

@@ -1,198 +0,0 @@
-import { ToolDefinition, SearchConfig } from '../types';
-import { SearchStrategy, RegexSearchStrategy, BM25SearchStrategy } from '../search';
-
-/**
- * Registry for managing tool definitions and discovery
- */
-export class ToolRegistry {
-  private tools: Map<string, ToolDefinition>;
-  private deferredTools: Map<string, ToolDefinition>;
-  private loadedTools: Set<string>;
-  private searchStrategy: SearchStrategy;
-
-  constructor(searchConfig?: SearchConfig) {
-    this.tools = new Map();
-    this.deferredTools = new Map();
-    this.loadedTools = new Set();
-
-    // Initialize search strategy
-    if (searchConfig?.customSearchFn) {
-      this.searchStrategy = {
-        search: async (query, tools) =>
-          searchConfig.customSearchFn!(query, tools)
-      };
-    } else {
-      const strategy = searchConfig?.strategy ?? 'smart';
-      const maxResults = searchConfig?.maxResults ?? 10;
-      const threshold = searchConfig?.threshold ?? 0.0;
-
-      // Map user-friendly names (and legacy names) to implementations
-      // 'smart' or 'bm25' → BM25 (best relevance ranking)
-      // 'keyword' or 'regex' → Regex (fast keyword matching)
-      const useSmartSearch =
-        strategy === 'smart' ||
-        strategy === 'bm25';
-
-      this.searchStrategy = useSmartSearch
-        ? new BM25SearchStrategy(maxResults, threshold)
-        : new RegexSearchStrategy(maxResults, threshold);
-    }
-  }
-
-  /**
-   * Register a tool
-   */
-  register(tool: ToolDefinition): void {
-    if (this.tools.has(tool.name)) {
-      throw new Error(`Tool "${tool.name}" is already registered`);
-    }
-
-    this.tools.set(tool.name, tool);
-
-    if (tool.deferLoading) {
-      this.deferredTools.set(tool.name, tool);
-    } else {
-      this.loadedTools.add(tool.name);
-    }
-  }
-
-  /**
-   * Register multiple tools at once
-   */
-  registerMany(tools: ToolDefinition[]): void {
-    tools.forEach(tool => this.register(tool));
-  }
-
-  /**
-   * Get a specific tool by name
-   */
-  get(name: string): ToolDefinition | undefined {
-    return this.tools.get(name);
-  }
-
-  /**
-   * Load a deferred tool into active context
-   */
-  load(name: string): ToolDefinition | undefined {
-    const tool = this.deferredTools.get(name);
-    if (tool) {
-      this.loadedTools.add(name);
-      return tool;
-    }
-    return undefined;
-  }
-
-  /**
-   * Get all currently loaded tools
-   */
-  getLoadedTools(): ToolDefinition[] {
-    return Array.from(this.loadedTools)
-      .map(name => this.tools.get(name))
-      .filter((tool): tool is ToolDefinition => tool !== undefined);
-  }
-
-  /**
-   * Get all tools (including deferred)
-   */
-  getAllTools(): ToolDefinition[] {
-    return Array.from(this.tools.values());
-  }
-
-  /**
-   * Search for tools matching a query
-   * @param query Search query
-   * @param maxResults Maximum results to return
-   * @param loadResults Whether to automatically load found tools
-   */
-  async search(
-    query: string,
-    maxResults?: number,
-    loadResults = true
-  ): Promise<ToolDefinition[]> {
-    // Search within deferred tools
-    const deferredToolsList = Array.from(this.deferredTools.values());
-    const results = await this.searchStrategy.search(query, deferredToolsList, maxResults);
-
-    // Optionally load the found tools
-    if (loadResults) {
-      results.forEach(tool => this.loadedTools.add(tool.name));
-    }
-
-    return results;
-  }
-
-  /**
-   * Clear all loaded tools (keeps registrations)
-   */
-  clearLoaded(): void {
-    this.loadedTools.clear();
-    // Re-add non-deferred tools
-    this.tools.forEach((tool, name) => {
-      if (!tool.deferLoading) {
-        this.loadedTools.add(name);
-      }
-    });
-  }
-
-  /**
-   * Unregister a tool
-   */
-  unregister(name: string): boolean {
-    const deleted = this.tools.delete(name);
-    this.deferredTools.delete(name);
-    this.loadedTools.delete(name);
-    return deleted;
-  }
-
-  /**
-   * Get statistics about the registry
-   */
-  getStats(): {
-    total: number;
-    loaded: number;
-    deferred: number;
-  } {
-    return {
-      total: this.tools.size,
-      loaded: this.loadedTools.size,
-      deferred: this.deferredTools.size
-    };
-  }
-
-  /**
-   * Create a tool search tool definition
-   * This is a meta-tool that allows LLMs to search for other tools
-   */
-  createToolSearchTool(): ToolDefinition {
-    return {
-      name: 'tool_search',
-      description:
-        'Search for available tools by name or description. Use this when you need to find tools for a specific task.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          query: {
-            type: 'string',
-            description: 'Search query describing the capability you need'
-          },
-          maxResults: {
-            type: 'number',
-            description: 'Maximum number of tools to return',
-            default: 5
-          }
-        },
-        required: ['query']
-      },
-      handler: async (input: { query: string; maxResults?: number }) => {
-        const results = await this.search(input.query, input.maxResults ?? 5, true);
-        return {
-          tools: results.map(tool => ({
-            name: tool.name,
-            description: tool.description
-          })),
-          count: results.length
-        };
-      }
-    };
-  }
-}

package/src/executor/base.ts

@@ -1,122 +0,0 @@
-import { ExecutionResult, ExecutorConfig, ToolDefinition, ToolCall } from '../types';
-
-/**
- * Base interface for code executors
- */
-export interface CodeExecutor {
-  /**
-   * Execute code with access to tools
-   * @param code Code to execute
-   * @param tools Available tools that can be called from code
-   * @param context Additional context/variables
-   */
-  execute(
-    code: string,
-    tools: ToolDefinition[],
-    context?: Record<string, any>
-  ): Promise<ExecutionResult>;
-}
-
-/**
- * Abstract base class for code executors
- */
-export abstract class BaseCodeExecutor implements CodeExecutor {
-  protected config: ExecutorConfig;
-  protected pendingToolCalls: ToolCall[] = [];
-
-  constructor(config: ExecutorConfig = {}) {
-    this.config = {
-      timeout: 30000, // 30 seconds default
-      memoryLimit: '256mb',
-      ...config
-    };
-  }
-
-  abstract execute(
-    code: string,
-    tools: ToolDefinition[],
-    context?: Record<string, any>
-  ): Promise<ExecutionResult>;
-
-  /**
-   * Create a tool wrapper function that the executed code can call
-   */
-  protected createToolWrapper(tool: ToolDefinition): (...args: any[]) => Promise<any> {
-    return async (...args: any[]) => {
-      // Determine input based on schema
-      let input: any;
-
-      if (args.length === 1 && typeof args[0] === 'object') {
-        input = args[0];
-      } else {
-        // If multiple args, create object from schema
-        // This is simplified - in reality would need to parse schema
-        input = args[0];
-      }
-
-      // Generate unique ID for this call
-      const callId = `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-
-      // Record the tool call
-      this.pendingToolCalls.push({
-        id: callId,
-        name: tool.name,
-        input,
-        caller: {
-          type: 'code_execution',
-          toolId: 'code_exec'
-        }
-      });
-
-      // Execute the tool
-      try {
-        const result = await tool.handler(input);
-        return result;
-      } catch (error) {
-        throw new Error(`Tool ${tool.name} failed: ${error}`);
-      }
-    };
-  }
-
-  /**
-   * Create the context object with tool functions
-   */
-  protected createExecutionContext(
-    tools: ToolDefinition[],
-    additionalContext?: Record<string, any>
-  ): Record<string, any> {
-    const context: Record<string, any> = {
-      console: {
-        log: (...args: any[]) => {
-          // Capture console output
-          return args.join(' ');
-        }
-      },
-      ...additionalContext
-    };
-
-    // Add each tool as a callable function
-    tools.forEach(tool => {
-      if (tool.allowedCallers?.includes('code_execution')) {
-        context[tool.name] = this.createToolWrapper(tool);
-      }
-    });
-
-    return context;
-  }
-
-  /**
-   * Wrap code with timeout
-   */
-  protected async withTimeout<T>(
-    promise: Promise<T>,
-    timeoutMs: number
-  ): Promise<T> {
-    return Promise.race([
-      promise,
-      new Promise<T>((_, reject) =>
-        setTimeout(() => reject(new Error('Execution timeout')), timeoutMs)
-      )
-    ]);
-  }
-}

package/src/executor/index.ts

@@ -1,2 +0,0 @@
-export { CodeExecutor, BaseCodeExecutor } from './base';
-export { VMExecutor, createDefaultExecutor } from './vm';

package/src/executor/vm.ts

@@ -1,87 +0,0 @@
-import { ExecutionResult, ExecutorConfig, ToolDefinition } from '../types';
-import { BaseCodeExecutor } from './base';
-import * as vm from 'vm';
-
-/**
- * VM-based code executor
- *
- * WARNING: This provides basic isolation but is NOT secure for untrusted code.
- * For production use with untrusted code, use DockerExecutor or a cloud
- * sandbox service like E2B.
- */
-export class VMExecutor extends BaseCodeExecutor {
-  constructor(config: ExecutorConfig = {}) {
-    super(config);
-  }
-
-  async execute(
-    code: string,
-    tools: ToolDefinition[],
-    context?: Record<string, any>
-  ): Promise<ExecutionResult> {
-    this.pendingToolCalls = [];
-
-    const capturedLogs: string[] = [];
-    let returnValue: any;
-
-    try {
-      // Create execution context with tools
-      const execContext = this.createExecutionContext(tools, context);
-
-      // Override console.log to capture output
-      execContext.console = {
-        log: (...args: any[]) => {
-          const message = args.map(arg =>
-            typeof arg === 'object' ? JSON.stringify(arg) : String(arg)
-          ).join(' ');
-          capturedLogs.push(message);
-        }
-      };
-
-      // Wrap code in async function
-      const wrappedCode = `
-        (async () => {
-          ${code}
-        })()
-      `;
-
-      // Create VM context
-      const vmContext = vm.createContext(execContext);
-
-      // Execute with timeout
-      const script = new vm.Script(wrappedCode);
-      const result = await this.withTimeout(
-        script.runInContext(vmContext, {
-          timeout: this.config.timeout
-        }),
-        this.config.timeout!
-      );
-
-      returnValue = result;
-
-      return {
-        success: true,
-        stdout: capturedLogs.join('\n'),
-        returnValue,
-        toolCalls: this.pendingToolCalls
-      };
-    } catch (error: any) {
-      return {
-        success: false,
-        stderr: error.message,
-        error: {
-          message: error.message,
-          stack: error.stack
-        },
-        toolCalls: this.pendingToolCalls
-      };
-    }
-  }
-}
-
-/**
- * Create a default executor instance
- */
-export function createDefaultExecutor(config?: ExecutorConfig): VMExecutor {
-  return new VMExecutor(config);
-}

package/src/index.ts

@@ -1,26 +0,0 @@
-// Core exports
-export { Client, ToolRegistry } from './core';
-
-// Type exports
-export type {
-  ToolDefinition,
-  ToolCall,
-  ToolResult,
-  Message,
-  ChatRequest,
-  ChatResponse,
-  SearchConfig,
-  ExecutorConfig,
-  ProviderAdapter,
-  ProviderCapabilities,
-  ClientConfig
-} from './types';
-
-// Adapter exports
-export { OpenAIAdapter, VercelAIAdapter } from './adapters';
-
-// Search exports
-export { SearchStrategy, RegexSearchStrategy, BM25SearchStrategy } from './search';
-
-// Executor exports
-export { CodeExecutor, VMExecutor, createDefaultExecutor } from './executor';

package/src/search/base.ts

@@ -1,63 +0,0 @@
-import { ToolDefinition } from '../types';
-
-/**
- * Base interface for tool search strategies
- */
-export interface SearchStrategy {
-  /**
-   * Search for tools matching the query
-   * @param query Search query
-   * @param tools Available tools to search
-   * @param maxResults Maximum number of results to return
-   * @returns Matching tools, sorted by relevance
-   */
-  search(
-    query: string,
-    tools: ToolDefinition[],
-    maxResults?: number
-  ): Promise<ToolDefinition[]>;
-}
-
-/**
- * Abstract base class for search strategies
- */
-export abstract class BaseSearchStrategy implements SearchStrategy {
-  protected maxResults: number;
-  protected threshold: number;
-
-  constructor(maxResults = 10, threshold = 0.0) {
-    this.maxResults = maxResults;
-    this.threshold = threshold;
-  }
-
-  abstract search(
-    query: string,
-    tools: ToolDefinition[],
-    maxResults?: number
-  ): Promise<ToolDefinition[]>;
-
-  /**
-   * Calculate relevance score for a tool
-   */
-  protected abstract scoreRelevance(query: string, tool: ToolDefinition): number;
-
-  /**
-   * Rank tools by relevance
-   */
-  protected rankTools(
-    query: string,
-    tools: ToolDefinition[],
-    maxResults?: number
-  ): ToolDefinition[] {
-    const scored = tools
-      .map(tool => ({
-        tool,
-        score: this.scoreRelevance(query, tool)
-      }))
-      .filter(({ score }) => score >= this.threshold)
-      .sort((a, b) => b.score - a.score);
-
-    const limit = maxResults ?? this.maxResults;
-    return scored.slice(0, limit).map(({ tool }) => tool);
-  }
-}

package/src/search/bm25.ts

@@ -1,64 +0,0 @@
-import { ToolDefinition } from '../types';
-import { BaseSearchStrategy } from './base';
-import * as natural from 'natural';
-
-/**
- * BM25-based search strategy
- * Better relevance ranking, handles synonyms and term frequency
- */
-export class BM25SearchStrategy extends BaseSearchStrategy {
-  private tokenizer: natural.WordTokenizer;
-  private tfidf: natural.TfIdf;
-  private toolsIndex: Map<number, ToolDefinition>;
-
-  constructor(maxResults = 10, threshold = 0.0) {
-    super(maxResults, threshold);
-    this.tokenizer = new natural.WordTokenizer();
-    this.tfidf = new natural.TfIdf();
-    this.toolsIndex = new Map();
-  }
-
-  async search(
-    query: string,
-    tools: ToolDefinition[],
-    maxResults?: number
-  ): Promise<ToolDefinition[]> {
-    // Rebuild index for current tool set
-    this.buildIndex(tools);
-
-    // Search using TF-IDF
-    const results: Array<{ tool: ToolDefinition; score: number }> = [];
-
-    this.tfidf.tfidfs(query, (i, measure) => {
-      const tool = this.toolsIndex.get(i);
-      if (tool && measure >= this.threshold) {
-        results.push({ tool, score: measure });
-      }
-    });
-
-    // Sort by score (descending)
-    results.sort((a, b) => b.score - a.score);
-
-    // Return top results
-    const limit = maxResults ?? this.maxResults;
-    return results.slice(0, limit).map(({ tool }) => tool);
-  }
-
-  protected scoreRelevance(query: string, tool: ToolDefinition): number {
-    // This is handled by TF-IDF in the search method
-    // This method is not used for BM25 but required by base class
-    return 0;
-  }
-
-  private buildIndex(tools: ToolDefinition[]): void {
-    this.tfidf = new natural.TfIdf();
-    this.toolsIndex.clear();
-
-    tools.forEach((tool, index) => {
-      // Combine name (with higher weight) and description for indexing
-      const document = `${tool.name} ${tool.name} ${tool.name} ${tool.description}`;
-      this.tfidf.addDocument(document);
-      this.toolsIndex.set(index, tool);
-    });
-  }
-}

package/src/search/index.ts

@@ -1,3 +0,0 @@
-export { SearchStrategy, BaseSearchStrategy } from './base';
-export { RegexSearchStrategy } from './regex';
-export { BM25SearchStrategy } from './bm25';

package/src/search/regex.ts

@@ -1,66 +0,0 @@
-import { ToolDefinition } from '../types';
-import { BaseSearchStrategy } from './base';
-
-/**
- * Regex-based search strategy
- * Fast and simple, good for exact matches
- */
-export class RegexSearchStrategy extends BaseSearchStrategy {
-  async search(
-    query: string,
-    tools: ToolDefinition[],
-    maxResults?: number
-  ): Promise<ToolDefinition[]> {
-    return this.rankTools(query, tools, maxResults);
-  }
-
-  protected scoreRelevance(query: string, tool: ToolDefinition): number {
-    const normalizedQuery = query.toLowerCase();
-    const toolName = tool.name.toLowerCase();
-    const toolDesc = tool.description.toLowerCase();
-
-    let score = 0;
-
-    // Exact name match gets highest score
-    if (toolName === normalizedQuery) {
-      score += 100;
-    }
-
-    // Name contains query
-    if (toolName.includes(normalizedQuery)) {
-      score += 50;
-    }
-
-    // Query matches word boundary in name
-    const nameWordBoundary = new RegExp(`\\b${this.escapeRegex(normalizedQuery)}`, 'i');
-    if (nameWordBoundary.test(toolName)) {
-      score += 30;
-    }
-
-    // Description contains query
-    if (toolDesc.includes(normalizedQuery)) {
-      score += 20;
-    }
-
-    // Query matches word boundary in description
-    const descWordBoundary = new RegExp(`\\b${this.escapeRegex(normalizedQuery)}`, 'i');
-    if (descWordBoundary.test(toolDesc)) {
-      score += 10;
-    }
-
-    // Check for individual query words
-    const queryWords = normalizedQuery.split(/\s+/);
-    queryWords.forEach(word => {
-      if (word.length > 2) {
-        if (toolName.includes(word)) score += 5;
-        if (toolDesc.includes(word)) score += 2;
-      }
-    });
-
-    return score;
-  }
-
-  private escapeRegex(str: string): string {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  }
-}