llm-advanced-tools 0.1.2 → 0.1.4

package/src/adapters/openai.ts

@@ -1,195 +0,0 @@
-import OpenAI from 'openai';
-import {
-  ProviderAdapter,
-  ProviderCapabilities,
-  ToolDefinition,
-  ChatRequest,
-  ChatResponse,
-  ToolCall,
-  ToolResult,
-  Message
-} from '../types';
-
-/**
- * OpenAI provider adapter
- * Emulates advanced tool use features for OpenAI's API
- */
-export class OpenAIAdapter implements ProviderAdapter {
-  readonly name = 'openai';
-  readonly capabilities: ProviderCapabilities = {
-    supportsNativeToolSearch: false,
-    supportsNativeCodeExecution: false,
-    supportsNativeExamples: false,
-    supportsStreaming: true,
-    supportsParallelToolCalls: true,
-    maxTokens: 128000 // GPT-4 Turbo
-  };
-
-  private client: OpenAI;
-  private model: string;
-
-  constructor(apiKey: string, model = 'gpt-4-turbo-preview') {
-    this.client = new OpenAI({ apiKey });
-    this.model = model;
-  }
-
-  /**
-   * Format a tool definition for OpenAI's function calling format
-   */
-  formatTool(tool: ToolDefinition): Record<string, any> {
-    // Extract schema from Zod or use as-is
-    let schema = tool.inputSchema;
-    if (typeof schema === 'object' && 'parse' in schema) {
-      // It's a Zod schema - we'd need to convert it
-      // For now, assume it's already JSON schema
-      schema = tool.inputSchema;
-    }
-
-    // Prepare description with examples if available
-    let description = tool.description;
-
-    if (tool.inputExamples && tool.inputExamples.length > 0) {
-      description += '\n\nExamples:';
-      tool.inputExamples.forEach((example, i) => {
-        description += `\n${i + 1}. ${JSON.stringify(example)}`;
-      });
-    }
-
-    return {
-      type: 'function',
-      function: {
-        name: tool.name,
-        description,
-        parameters: schema
-      }
-    };
-  }
-
-  /**
-   * Convert our Message format to OpenAI's format
-   */
-  private convertMessages(messages: Message[]): OpenAI.ChatCompletionMessageParam[] {
-    return messages.map(msg => {
-      if (msg.role === 'tool') {
-        // Tool result message
-        const toolResults = msg.toolResults || [];
-        return toolResults.map(result => ({
-          role: 'tool' as const,
-          tool_call_id: result.toolCallId,
-          content: result.error
-            ? `Error: ${result.error.message}`
-            : JSON.stringify(result.data)
-        }));
-      }
-
-      if (msg.toolCalls && msg.toolCalls.length > 0) {
-        // Assistant message with tool calls
-        return {
-          role: 'assistant' as const,
-          content: typeof msg.content === 'string' ? msg.content : null,
-          tool_calls: msg.toolCalls.map(tc => ({
-            id: tc.id,
-            type: 'function' as const,
-            function: {
-              name: tc.name,
-              arguments: JSON.stringify(tc.input)
-            }
-          }))
-        };
-      }
-
-      // Regular message
-      return {
-        role: msg.role as 'system' | 'user' | 'assistant',
-        content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
-      };
-    }).flat();
-  }
-
-  /**
-   * Create a chat completion
-   */
-  async chat(request: ChatRequest): Promise<ChatResponse> {
-    const messages = this.convertMessages(request.messages);
-
-    const tools = request.tools
-      ?.filter(tool => !tool.deferLoading) // Only send loaded tools
-      ?.map(tool => this.formatTool(tool)) as OpenAI.ChatCompletionTool[] | undefined;
-
-    const completion = await this.client.chat.completions.create({
-      model: this.model,
-      messages,
-      tools: tools && tools.length > 0 ? tools : undefined,
-      max_tokens: request.maxTokens,
-      temperature: request.temperature,
-      stream: false // Streaming not yet supported
-    }) as OpenAI.ChatCompletion;
-
-    const choice = completion.choices[0];
-    const message = choice.message;
-
-    // Parse tool calls if any
-    const toolCalls = message.tool_calls
-      ? this.parseToolCalls(message.tool_calls)
-      : [];
-
-    return {
-      message: {
-        role: 'assistant',
-        content: message.content || '',
-        toolCalls
-      },
-      usage: completion.usage
-        ? {
-            inputTokens: completion.usage.prompt_tokens,
-            outputTokens: completion.usage.completion_tokens,
-            totalTokens: completion.usage.total_tokens
-          }
-        : undefined,
-      stopReason: this.mapFinishReason(choice.finish_reason),
-      toolCalls
-    };
-  }
-
-  /**
-   * Parse tool calls from OpenAI response
-   */
-  parseToolCalls(toolCalls: OpenAI.ChatCompletionMessageToolCall[]): ToolCall[] {
-    return toolCalls.map(tc => ({
-      id: tc.id,
-      name: tc.function.name,
-      input: JSON.parse(tc.function.arguments)
-    }));
-  }
-
-  /**
-   * Format tool results for OpenAI
-   */
-  formatToolResults(results: ToolResult[]): OpenAI.ChatCompletionMessageParam[] {
-    return results.map(result => ({
-      role: 'tool' as const,
-      tool_call_id: result.toolCallId,
-      content: result.error
-        ? `Error: ${result.error.message}`
-        : JSON.stringify(result.data)
-    }));
-  }
-
-  /**
-   * Map OpenAI finish reason to our format
-   */
-  private mapFinishReason(
-    reason: string | null
-  ): 'end_turn' | 'max_tokens' | 'tool_use' | 'stop_sequence' | undefined {
-    switch (reason) {
-      case 'stop':
-        return 'end_turn';
-      case 'length':
-        return 'max_tokens';
-      case 'tool_calls':
-        return 'tool_use';
-      default:
-        return undefined;
-    }
-  }
-}

package/src/adapters/vercel-ai.ts

@@ -1,281 +0,0 @@
-import { generateText, LanguageModel, tool } from 'ai';
-import { z } from 'zod';
-import {
-  ProviderAdapter,
-  ProviderCapabilities,
-  ToolDefinition,
-  ChatRequest,
-  ChatResponse,
-  ToolCall,
-  ToolResult,
-  Message
-} from '../types';
-
-/**
- * Vercel AI SDK adapter
- * Works with any provider supported by AI SDK (OpenAI, Anthropic, Google, etc.)
- */
-export class VercelAIAdapter implements ProviderAdapter {
-  readonly name = 'vercel-ai';
-  readonly capabilities: ProviderCapabilities = {
-    supportsNativeToolSearch: false,
-    supportsNativeCodeExecution: false,
-    supportsNativeExamples: false,
-    supportsStreaming: true,
-    supportsParallelToolCalls: true,
-    maxTokens: 128000 // Depends on model, using safe default
-  };
-
-  private model: LanguageModel;
-  private providerName: string;
-
-  /**
-   * @param model - AI SDK language model (e.g., from @ai-sdk/openai, @ai-sdk/anthropic)
-   * @param providerName - Optional provider name for identification
-   */
-  constructor(model: LanguageModel, providerName = 'ai-sdk') {
-    this.model = model;
-    this.providerName = providerName;
-  }
-
-  /**
-   * Format a tool definition for AI SDK's format
-   */
-  formatTool(tool: ToolDefinition): Record<string, any> {
-    // AI SDK uses Zod schemas, but also accepts JSON schema
-    let parameters = tool.inputSchema;
-
-    // If it's already a Zod schema, use it directly
-    if (typeof parameters === 'object' && 'parse' in parameters) {
-      parameters = tool.inputSchema;
-    }
-
-    // Add examples to description for better accuracy
-    let description = tool.description;
-    if (tool.inputExamples && tool.inputExamples.length > 0) {
-      description += '\n\nExample usage:';
-      tool.inputExamples.forEach((example, i) => {
-        description += `\n${i + 1}. ${JSON.stringify(example)}`;
-      });
-    }
-
-    // AI SDK CoreTool format
-    return {
-      description,
-      parameters
-    };
-  }
-
-  /**
-   * Convert our Message format to AI SDK's format
-   */
-  private convertMessages(messages: Message[]): Array<{
-    role: 'user' | 'assistant' | 'system';
-    content: string;
-  }> {
-    const converted: Array<{ role: 'user' | 'assistant' | 'system'; content: string }> = [];
-
-    for (const msg of messages) {
-      if (msg.role === 'tool') {
-        // Tool results are handled differently in AI SDK
-        // They're included in the tool execution flow
-        continue;
-      }
-
-      converted.push({
-        role: msg.role as 'user' | 'assistant' | 'system',
-        content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
-      });
-    }
-
-    return converted;
-  }
-
-  /**
-   * Convert JSON Schema to Zod schema (simplified)
-   */
-  private jsonSchemaToZod(schema: any): z.ZodType {
-    // If it's already a Zod schema, return it
-    if (schema && typeof schema === 'object' && 'parse' in schema) {
-      return schema;
-    }
-
-    // Simple JSON Schema to Zod conversion
-    // This is a simplified version - for production, use a proper converter
-    if (schema.type === 'object') {
-      const shape: Record<string, z.ZodType> = {};
-      const required = schema.required || [];
-
-      for (const [key, value] of Object.entries(schema.properties || {})) {
-        const prop: any = value;
-        let zodType: z.ZodType;
-
-        switch (prop.type) {
-          case 'string':
-            zodType = z.string();
-            if (prop.enum) {
-              zodType = z.enum(prop.enum);
-            }
-            break;
-          case 'number':
-            zodType = z.number();
-            break;
-          case 'boolean':
-            zodType = z.boolean();
-            break;
-          case 'array':
-            zodType = z.array(z.any());
-            break;
-          default:
-            zodType = z.any();
-        }
-
-        if (prop.description) {
-          zodType = zodType.describe(prop.description);
-        }
-
-        // Make field optional if not in required array
-        if (!required.includes(key)) {
-          zodType = zodType.optional();
-        }
-
-        shape[key] = zodType;
-      }
-
-      return z.object(shape);
-    }
-
-    return z.any();
-  }
-
-  /**
-   * Create a chat completion using AI SDK
-   */
-  async chat(request: ChatRequest): Promise<ChatResponse> {
-    const messages = this.convertMessages(request.messages);
-
-    // Convert our tools to AI SDK format using the tool() helper
-    const tools: Record<string, any> = {};
-    const toolDefinitions = request.tools?.filter(t => !t.deferLoading) || [];
-
-    for (const toolDef of toolDefinitions) {
-      // Add examples to description
-      let description = toolDef.description;
-      if (toolDef.inputExamples && toolDef.inputExamples.length > 0) {
-        description += '\n\nExample usage:';
-        toolDef.inputExamples.forEach((example, i) => {
-          description += `\n${i + 1}. ${JSON.stringify(example)}`;
-        });
-      }
-
-      // Convert schema to Zod
-      const parameters = this.jsonSchemaToZod(toolDef.inputSchema);
-
-      // Create the tool using AI SDK's tool() helper
-      // Store reference to toolDef in closure to avoid issues
-      const handler = toolDef.handler;
-      const name = toolDef.name;
-      tools[name] = {
-        description,
-        parameters,
-        execute: async (args: any) => {
-          try {
-            const result = await handler(args);
-            return result;
-          } catch (error: any) {
-            throw new Error(`Tool ${name} failed: ${error.message}`);
-          }
-        }
-      } as any;
-    }
-
-    // Generate text with tools
-    const generateOptions: any = {
-      model: this.model,
-      messages: messages.map(m => ({
-        role: m.role,
-        content: m.content
-      })),
-      tools: Object.keys(tools).length > 0 ? tools : undefined
-    };
-
-    // Add optional parameters if provided
-    if (request.temperature !== undefined) {
-      generateOptions.temperature = request.temperature;
-    }
-    if (request.maxTokens !== undefined) {
-      generateOptions.maxCompletionTokens = request.maxTokens;
-    }
-
-    const result = await generateText(generateOptions);
-
-    // Parse tool calls from result
-    const toolCalls: ToolCall[] = [];
-    if (result.toolCalls && result.toolCalls.length > 0) {
-      result.toolCalls.forEach((tc: any, index: number) => {
-        toolCalls.push({
-          id: `call_${index}`,
-          name: tc.toolName,
-          input: tc.args
-        });
-      });
-    }
-
-    return {
-      message: {
-        role: 'assistant',
-        content: result.text || '',
-        toolCalls
-      },
-      usage: result.usage
-        ? {
-            inputTokens: result.usage.inputTokens || (result.usage as any).promptTokens || 0,
-            outputTokens: result.usage.outputTokens || (result.usage as any).completionTokens || 0,
-            totalTokens: result.usage.totalTokens || 0
-          }
-        : undefined,
-      stopReason: this.mapFinishReason(result.finishReason),
-      toolCalls
-    };
-  }
-
-  /**
-   * Parse tool calls from AI SDK response
-   */
-  parseToolCalls(toolCalls: any[]): ToolCall[] {
-    return toolCalls.map((tc, index) => ({
-      id: `call_${index}`,
-      name: tc.toolName,
-      input: tc.args
-    }));
-  }
-
-  /**
-   * Format tool results for AI SDK
-   */
-  formatToolResults(results: ToolResult[]): any {
-    // AI SDK handles tool results automatically in the execute callback
-    return results;
-  }
-
-  /**
-   * Map AI SDK finish reason to our format
-   */
-  private mapFinishReason(
-    reason: string | undefined
-  ): 'end_turn' | 'max_tokens' | 'tool_use' | 'stop_sequence' | undefined {
-    switch (reason) {
-      case 'stop':
-        return 'end_turn';
-      case 'length':
-        return 'max_tokens';
-      case 'tool-calls':
-        return 'tool_use';
-      case 'content-filter':
-      case 'error':
-        return 'stop_sequence';
-      default:
-        return undefined;
-    }
-  }
-}

package/src/core/client.ts

@@ -1,232 +0,0 @@
-import {
-  ClientConfig,
-  ChatRequest,
-  ChatResponse,
-  Message,
-  ToolCall,
-  ToolResult
-} from '../types';
-import { ToolRegistry } from './registry';
-import { CodeExecutor, createDefaultExecutor } from '../executor';
-
-/**
- * Main client for provider-agnostic tool use
- */
-export class Client {
-  private config: ClientConfig;
-  private registry: ToolRegistry;
-  private executor?: CodeExecutor;
-
-  constructor(config: ClientConfig, registry?: ToolRegistry) {
-    this.config = config;
-    this.registry = registry || new ToolRegistry(config.searchConfig);
-
-    if (config.enableProgrammaticCalling) {
-      this.executor = createDefaultExecutor(config.executorConfig);
-    }
-  }
-
-  /**
-   * Get the tool registry
-   */
-  getRegistry(): ToolRegistry {
-    return this.registry;
-  }
-
-  /**
-   * Send a chat message
-   */
-  async chat(request: Omit<ChatRequest, 'tools'>): Promise<ChatResponse> {
-    const messages = [...request.messages];
-
-    // If tool search is enabled and provider doesn't support it natively,
-    // add the tool search tool to loaded tools
-    if (
-      this.config.enableToolSearch &&
-      !this.config.adapter.capabilities.supportsNativeToolSearch
-    ) {
-      const toolSearchTool = this.registry.createToolSearchTool();
-      this.registry.register(toolSearchTool);
-    }
-
-    // Get loaded tools for this request
-    const tools = this.registry.getLoadedTools();
-
-    // Make the request
-    const response = await this.config.adapter.chat({
-      ...request,
-      messages,
-      tools
-    });
-
-    // Handle tool calls if any
-    if (response.toolCalls && response.toolCalls.length > 0) {
-      return this.handleToolCalls(request, response);
-    }
-
-    return response;
-  }
-
-  /**
-   * Handle tool calls from LLM response
-   */
-  private async handleToolCalls(
-    originalRequest: Omit<ChatRequest, 'tools'>,
-    response: ChatResponse
-  ): Promise<ChatResponse> {
-    const toolCalls = response.toolCalls!;
-
-    // Check if any tool call is for code execution
-    const codeExecutionCall = toolCalls.find(tc => tc.name === 'code_execution');
-
-    if (codeExecutionCall && this.executor && this.config.enableProgrammaticCalling) {
-      return this.handleProgrammaticToolCall(originalRequest, response, codeExecutionCall);
-    }
-
-    // Regular tool execution
-    const results = await this.executeToolCalls(toolCalls);
-
-    // Add tool results to messages and continue conversation
-    const messages: Message[] = [
-      ...originalRequest.messages,
-      response.message,
-      {
-        role: 'tool',
-        content: '',
-        toolResults: results
-      }
-    ];
-
-    return this.chat({
-      ...originalRequest,
-      messages
-    });
-  }
-
-  /**
-   * Handle programmatic tool calling (code execution)
-   */
-  private async handleProgrammaticToolCall(
-    originalRequest: Omit<ChatRequest, 'tools'>,
-    response: ChatResponse,
-    codeCall: ToolCall
-  ): Promise<ChatResponse> {
-    const code = codeCall.input.code;
-    const tools = this.registry.getLoadedTools();
-
-    // Execute the code with access to tools
-    const execResult = await this.executor!.execute(code, tools);
-
-    // Create tool result message
-    const result: ToolResult = {
-      toolCallId: codeCall.id,
-      data: {
-        stdout: execResult.stdout,
-        returnValue: execResult.returnValue
-      },
-      error: execResult.error
-    };
-
-    // Continue conversation with execution result
-    const messages: Message[] = [
-      ...originalRequest.messages,
-      response.message,
-      {
-        role: 'tool',
-        content: '',
-        toolResults: [result]
-      }
-    ];
-
-    return this.chat({
-      ...originalRequest,
-      messages
-    });
-  }
-
-  /**
-   * Execute tool calls
-   */
-  private async executeToolCalls(toolCalls: ToolCall[]): Promise<ToolResult[]> {
-    const results: ToolResult[] = [];
-
-    for (const call of toolCalls) {
-      const tool = this.registry.get(call.name);
-
-      if (!tool) {
-        results.push({
-          toolCallId: call.id,
-          error: {
-            message: `Tool "${call.name}" not found`,
-            code: 'TOOL_NOT_FOUND'
-          }
-        });
-        continue;
-      }
-
-      // Special handling for tool_search
-      if (call.name === 'tool_search') {
-        try {
-          const data = await tool.handler(call.input);
-          results.push({
-            toolCallId: call.id,
-            data
-          });
-        } catch (error: any) {
-          results.push({
-            toolCallId: call.id,
-            error: {
-              message: error.message,
-              code: 'EXECUTION_ERROR'
-            }
-          });
-        }
-        continue;
-      }
-
-      // Execute regular tool
-      try {
-        const data = await tool.handler(call.input);
-        results.push({
-          toolCallId: call.id,
-          data
-        });
-      } catch (error: any) {
-        results.push({
-          toolCallId: call.id,
-          error: {
-            message: error.message,
-            code: 'EXECUTION_ERROR',
-            details: error
-          }
-        });
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * Helper method for simple text chat
-   */
-  async ask(prompt: string, systemPrompt?: string): Promise<string> {
-    const messages: Message[] = [];
-
-    if (systemPrompt) {
-      messages.push({
-        role: 'system',
-        content: systemPrompt
-      });
-    }
-
-    messages.push({
-      role: 'user',
-      content: prompt
-    });
-
-    const response = await this.chat({ messages });
-    return typeof response.message.content === 'string'
-      ? response.message.content
-      : JSON.stringify(response.message.content);
-  }
-}

package/src/core/index.ts

@@ -1,2 +0,0 @@
-export { ToolRegistry } from './registry';
-export { Client } from './client';