Revert Vercel AI SDK adoption and implement clean abstraction for LLM providers

Author: bhouston

packages/agent/package.json

@@ -44,18 +44,13 @@
   "author": "Ben Houston",
   "license": "MIT",
   "dependencies": {
-    "@ai-sdk/anthropic": "^1.1.13",
-    "@ai-sdk/mistral": "^1.1.13",
-    "@ai-sdk/openai": "^1.2.0",
-    "@ai-sdk/xai": "^1.1.12",
+    "@anthropic-ai/sdk": "^0.16.0",
     "@mozilla/readability": "^0.5.0",
     "@playwright/test": "^1.50.1",
     "@vitest/browser": "^3.0.5",
-    "ai": "^4.1.50",
     "chalk": "^5.4.1",
     "dotenv": "^16",
     "jsdom": "^26.0.0",
-    "ollama-ai-provider": "^1.2.0",
     "playwright": "^1.50.1",
     "uuid": "^11",
     "zod": "^3.24.2",

packages/agent/src/core/llm/core.ts

@@ -0,0 +1,125 @@
+/**
+ * Core LLM abstraction for generating text
+ */
+import { FunctionDefinition, GenerateOptions, LLMResponse, Message, ToolCall } from './types.js';
+import { LLMProvider } from './provider.js';
+
+/**
+ * Generate text using the specified LLM provider
+ * 
+ * @param provider The LLM provider implementation
+ * @param options Options for generation including messages, functions, etc.
+ * @returns A response containing generated text and/or tool calls
+ */
+export async function generateText(
+  provider: LLMProvider,
+  options: GenerateOptions
+): Promise<LLMResponse> {
+  // Validate options
+  if (!options.messages || options.messages.length === 0) {
+    throw new Error('Messages array cannot be empty');
+  }
+
+  // Use the provider to generate the response
+  return provider.generateText(options);
+}
+
+/**
+ * Format tool calls for consistent usage across providers
+ * 
+ * @param rawToolCalls Tool calls from provider
+ * @returns Normalized tool calls
+ */
+export function normalizeToolCalls(rawToolCalls: any[]): ToolCall[] {
+  if (!rawToolCalls || !Array.isArray(rawToolCalls) || rawToolCalls.length === 0) {
+    return [];
+  }
+
+  return rawToolCalls.map((call) => {
+    // Handle different provider formats
+    if (typeof call.arguments === 'string') {
+      // Already in correct format
+      return {
+        id: call.id || `tool-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
+        name: call.name || call.function?.name,
+        arguments: call.arguments
+      };
+    } else if (typeof call.arguments === 'object') {
+      // Convert object to JSON string
+      return {
+        id: call.id || `tool-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
+        name: call.name || call.function?.name,
+        arguments: JSON.stringify(call.arguments)
+      };
+    } else {
+      throw new Error(`Unsupported tool call format: ${JSON.stringify(call)}`);
+    }
+  });
+}
+
+/**
+ * Format function definitions for provider compatibility
+ * 
+ * @param functions Function definitions
+ * @returns Normalized function definitions
+ */
+export function normalizeFunctionDefinitions(
+  functions?: FunctionDefinition[]
+): FunctionDefinition[] {
+  if (!functions || functions.length === 0) {
+    return [];
+  }
+
+  return functions.map((fn) => ({
+    name: fn.name,
+    description: fn.description,
+    parameters: fn.parameters
+  }));
+}
+
+/**
+ * Convert messages to provider-specific format if needed
+ * 
+ * @param messages Array of messages
+ * @returns Normalized messages
+ */
+export function normalizeMessages(messages: Message[]): Message[] {
+  return messages.map((msg: any) => {
+    // Ensure content is a string
+    if (typeof msg.content !== 'string') {
+      throw new Error(`Message content must be a string: ${JSON.stringify(msg)}`);
+    }
+    
+    // Handle each role type explicitly
+    switch (msg.role) {
+      case 'system':
+        return {
+          role: 'system',
+          content: msg.content
+        };
+      case 'user':
+        return {
+          role: 'user',
+          content: msg.content
+        };
+      case 'assistant':
+        return {
+          role: 'assistant',
+          content: msg.content
+        };
+      case 'tool':
+        return {
+          role: 'tool',
+          content: msg.content,
+          name: msg.name || 'unknown_tool' // Ensure name is always present for tool messages
+        };
+      default:
+        // Use type assertion for unknown roles
+        console.warn(`Unexpected message role: ${String(msg.role)}, treating as user message`);
+        return {
+          role: 'user',
+          content: msg.content
+        };
+    }
+  });
+}

packages/agent/src/core/llm/examples.ts

@@ -0,0 +1,100 @@
+/**
+ * Examples of using the LLM abstraction
+ */
+import { createProvider, generateText } from './index.js';
+import { FunctionDefinition, Message } from './types.js';
+
+/**
+ * Example of using the OpenAI provider
+ */
+async function openaiExample() {
+  // Create an OpenAI provider
+  const provider = createProvider('openai', 'gpt-4', {
+    apiKey: process.env.OPENAI_API_KEY,
+  });
+  
+  // Define messages
+  const messages: Message[] = [
+    {
+      role: 'system',
+      content: 'You are a helpful assistant that can use tools to accomplish tasks.',
+    },
+    {
+      role: 'user',
+      content: 'What is the weather in New York?',
+    },
+  ];
+  
+  // Define functions/tools
+  const functions: FunctionDefinition[] = [
+    {
+      name: 'get_weather',
+      description: 'Get the current weather in a location',
+      parameters: {
+        type: 'object',
+        properties: {
+          location: {
+            type: 'string',
+            description: 'The city and state, e.g. San Francisco, CA',
+          },
+          unit: {
+            type: 'string',
+            enum: ['celsius', 'fahrenheit'],
+            description: 'The unit of temperature',
+          },
+        },
+        required: ['location'],
+      },
+    },
+  ];
+  
+  // Generate text
+  const response = await generateText(provider, {
+    messages,
+    functions,
+    temperature: 0.7,
+    maxTokens: 1000,
+  });
+  
+  console.log('Generated text:', response.text);
+  console.log('Tool calls:', response.toolCalls);
+  
+  // Handle tool calls
+  if (response.toolCalls.length > 0) {
+    const toolCall = response.toolCalls[0];
+    if (toolCall) {
+      console.log(`Tool called: ${toolCall.name}`);
+      console.log(`Arguments: ${toolCall.arguments}`);
+      
+      // Example of adding a tool result
+      const toolResult: Message = {
+        role: 'tool',
+        name: toolCall.name,
+        content: JSON.stringify({
+          temperature: 72,
+          unit: 'fahrenheit',
+          description: 'Sunny with some clouds',
+        }),
+      };
+    
+      // Continue the conversation with the tool result
+      const followupResponse = await generateText(provider, {
+        messages: [
+          ...messages,
+          {
+            role: 'assistant',
+            content: response.text,
+          },
+          toolResult,
+        ],
+        temperature: 0.7,
+        maxTokens: 1000,
+      });
+      
+      console.log('Follow-up response:', followupResponse.text);
+    }
+  }
+}
+
+// Example usage
+// openaiExample().catch(console.error);

packages/agent/src/core/llm/index.ts

@@ -0,0 +1,20 @@
+/**
+ * LLM abstraction module
+ */
+
+// Export message types
+export * from './types.js';
+
+// Export core functionality
+export * from './core.js';
+
+// Export provider interface
+export * from './provider.js';
+
+// Export provider implementations
+export * from './providers/openai.js';
+export * from './providers/index.js';
+
+// Re-export the main function for convenience
+import { generateText } from './core.js';
+export { generateText };

packages/agent/src/core/llm/provider.ts

@@ -0,0 +1,50 @@
+/**
+ * LLM Provider interface and factory
+ */
+import { GenerateOptions, LLMResponse, ProviderOptions } from './types.js';
+
+/**
+ * Interface for LLM providers
+ */
+export interface LLMProvider {
+  /**
+   * Provider name (e.g., 'openai', 'anthropic', etc.)
+   */
+  name: string;
+  
+  /**
+   * Provider-specific identifier (e.g., 'openai.chat', 'anthropic.messages', etc.)
+   */
+  provider: string;
+  
+  /**
+   * Model name (e.g., 'gpt-4', 'claude-3', etc.)
+   */
+  model: string;
+  
+  /**
+   * Generate text using this provider
+   * 
+   * @param options Generation options
+   * @returns Response with text and/or tool calls
+   */
+  generateText(options: GenerateOptions): Promise<LLMResponse>;
+  
+  /**
+   * Get the number of tokens in a given text
+   * 
+   * @param text Text to count tokens for
+   * @returns Number of tokens
+   */
+  countTokens(text: string): Promise<number>;
+}
+
+/**
+ * Factory function to create a provider
+ * 
+ * @param providerType Provider type (e.g., 'openai', 'anthropic')
+ * @param model Model name
+ * @param options Provider-specific options
+ * @returns LLM provider instance
+ */
+export { createProvider, registerProvider } from './providers/index.js';