partial conversion.

Author: bhouston

packages/agent/package.json

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

packages/agent/src/core/tokens.ts

@@ -1,4 +1,4 @@
-import Anthropic from '@anthropic-ai/sdk';
+//import Anthropic from '@anthropic-ai/sdk';
 
 import { LogLevel } from '../utils/logger.js';
 
@@ -34,14 +34,15 @@ export class TokenUsage {
     return usage;
   }
 
+  /*
   static fromMessage(message: Anthropic.Message) {
     const usage = new TokenUsage();
     usage.input = message.usage.input_tokens;
     usage.cacheWrites = message.usage.cache_creation_input_tokens ?? 0;
     usage.cacheReads = message.usage.cache_read_input_tokens ?? 0;
     usage.output = message.usage.output_tokens;
     return usage;
-  }
+  }*/
 
   static sum(usages: TokenUsage[]) {
     const usage = new TokenUsage();

packages/agent/src/core/toolAgent.respawn.test.ts

@@ -1,3 +1,4 @@
+import { anthropic } from '@ai-sdk/anthropic';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
 import { toolAgent } from '../../src/core/toolAgent.js';
@@ -15,32 +16,6 @@ const toolContext: ToolContext = {
   pageFilter: 'simple',
   tokenTracker: new TokenTracker(),
 };
-// Mock Anthropic SDK
-vi.mock('@anthropic-ai/sdk', () => {
-  return {
-    default: vi.fn().mockImplementation(() => ({
-      messages: {
-        create: vi
-          .fn()
-          .mockResolvedValueOnce({
-            content: [
-              {
-                type: 'tool_use',
-                name: 'respawn',
-                id: 'test-id',
-                input: { respawnContext: 'new context' },
-              },
-            ],
-            usage: { input_tokens: 10, output_tokens: 10 },
-          })
-          .mockResolvedValueOnce({
-            content: [],
-            usage: { input_tokens: 5, output_tokens: 5 },
-          }),
-      },
-    })),
-  };
-});
 
 describe('toolAgent respawn functionality', () => {
   const tools = getTools();
@@ -56,7 +31,7 @@ describe('toolAgent respawn functionality', () => {
       tools,
       {
         maxIterations: 2, // Need at least 2 iterations for respawn + empty response
-        model: 'test-model',
+        model: anthropic('claude-3-7-sonnet-20250219'),
         maxTokens: 100,
         temperature: 0,
         getSystemPrompt: () => 'test system prompt',

packages/agent/src/core/toolAgent.test.ts

@@ -1,3 +1,4 @@
+import { anthropic } from '@ai-sdk/anthropic';
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
 import { MockLogger } from '../utils/mockLogger.js';
@@ -19,7 +20,7 @@ const toolContext: ToolContext = {
 // Mock configuration for testing
 const testConfig = {
   maxIterations: 50,
-  model: 'claude-3-7-sonnet-latest',
+  model: anthropic('claude-3-7-sonnet-20250219'),
   maxTokens: 4096,
   temperature: 0.7,
   getSystemPrompt: () => 'Test system prompt',

packages/agent/src/core/toolAgent.ts

@@ -1,19 +1,23 @@
 import { execSync } from 'child_process';
 
-import Anthropic from '@anthropic-ai/sdk';
-import { ContentBlockParam } from '@anthropic-ai/sdk/resources/messages/messages.js';
+import { anthropic } from '@ai-sdk/anthropic';
+import {
+  CoreMessage,
+  CoreToolMessage,
+  generateText,
+  ToolResultPart,
+  ToolSet,
+} from 'ai';
 import chalk from 'chalk';
 
 import { getAnthropicApiKeyError } from '../utils/errors.js';
 
 import { executeToolCall } from './executeToolCall.js';
-import { TokenTracker, TokenUsage } from './tokens.js';
+import { TokenTracker } from './tokens.js';
 import {
   Tool,
-  TextContent,
   ToolUseContent,
   ToolResultContent,
-  Message,
   ToolContext,
 } from './types.js';
 
@@ -24,7 +28,7 @@ export interface ToolAgentResult {
 
 const CONFIG = {
   maxIterations: 200,
-  model: 'claude-3-7-sonnet-latest',
+  model: anthropic('claude-3-7-sonnet-20250219'),
   maxTokens: 4096,
   temperature: 0.7,
   getSystemPrompt: () => {
@@ -86,9 +90,9 @@ const CONFIG = {
 interface ToolCallResult {
   sequenceCompleted: boolean;
   completionResult?: string;
-  toolResults: ToolResultContent[];
+  toolResults: ToolResultPart[];
 }
-
+/*
 function processResponse(response: Anthropic.Message) {
   const content: (TextContent | ToolUseContent)[] = [];
   const toolCalls: ToolUseContent[] = [];
@@ -110,11 +114,12 @@ function processResponse(response: Anthropic.Message) {
 
   return { content, toolCalls };
 }
+*/
 
 async function executeTools(
   toolCalls: ToolUseContent[],
   tools: Tool[],
-  messages: Message[],
+  messages: CoreMessage[],
   context: ToolContext,
 ): Promise<ToolCallResult & { respawn?: { context: string } }> {
   if (toolCalls.length === 0) {
@@ -132,18 +137,19 @@ async function executeTools(
       sequenceCompleted: false,
       toolResults: [
         {
-          type: 'tool_result',
-          tool_use_id: respawnCall.id,
-          content: 'Respawn initiated',
-        },
+          type: 'tool-result',
+          toolCallId: respawnCall.id,
+          toolName: respawnCall.name,
+          result: { success: true },
+        } satisfies ToolResultPart,
       ],
       respawn: {
         context: respawnCall.input.respawnContext,
       },
     };
   }
 
-  const results = await Promise.all(
+  const toolResults: ToolResultPart[] = await Promise.all(
     toolCalls.map(async (call) => {
       let toolResult = '';
       try {
@@ -155,35 +161,36 @@ async function executeTools(
         toolResult = `Error: Exception thrown during tool execution.  Type: ${error.constructor.name}, Message: ${error.message}`;
       }
       return {
-        type: 'tool_result' as const,
-        tool_use_id: call.id,
-        content: toolResult,
-        isComplete: call.name === 'sequenceComplete',
-      };
+        type: 'tool-result',
+        toolCallId: call.id,
+        toolName: call.name,
+        result: JSON.parse(toolResult) satisfies ToolResultContent,
+      } satisfies ToolResultPart;
     }),
   );
 
-  const toolResults = results.map(({ type, tool_use_id, content }) => ({
-    type,
-    tool_use_id,
-    content,
-  }));
-
-  const sequenceCompleted = results.some((r) => r.isComplete);
-  const completionResult = results.find((r) => r.isComplete)?.content;
+  const sequenceCompletedTool = toolResults.find(
+    (r) => r.toolName === 'sequenceComplete',
+  );
+  const completionResult = sequenceCompletedTool?.result as string;
 
   messages.push({
-    role: 'user',
+    role: 'tool',
     content: toolResults,
-  });
+  } satisfies CoreToolMessage);
 
-  if (sequenceCompleted) {
+  if (sequenceCompletedTool) {
     logger.verbose('Sequence completed', { completionResult });
   }
 
-  return { sequenceCompleted, completionResult, toolResults };
+  return {
+    sequenceCompleted: sequenceCompletedTool !== undefined,
+    completionResult,
+    toolResults,
+  };
 }
 
+/*
 // a function that takes a list of messages and returns a list of messages but with the last message having a cache_control of ephemeral
 function addCacheControlToTools<T>(messages: T[]): T[] {
   return messages.map((m, i) => ({
@@ -238,7 +245,7 @@ function addCacheControlToMessages(
           : m.content,
     };
   });
-}
+}*/
 
 export const toolAgent = async (
   initialPrompt: string,
@@ -256,8 +263,8 @@ export const toolAgent = async (
   const apiKey = process.env.ANTHROPIC_API_KEY;
   if (!apiKey) throw new Error(getAnthropicApiKeyError());
 
-  const client = new Anthropic({ apiKey });
-  const messages: Message[] = [
+  //  const client = new Anthropic({ apiKey });
+  const messages: CoreMessage[] = [
     {
       role: 'user',
       content: [{ type: 'text', text: initialPrompt }],
@@ -278,32 +285,31 @@ export const toolAgent = async (
 
     interactions++;
 
-    // Create request parameters
-    const requestParams: Anthropic.MessageCreateParams = {
-      model: config.model,
-      max_tokens: config.maxTokens,
-      temperature: config.temperature,
-      messages: addCacheControlToMessages(messages),
-      system: [
-        {
-          type: 'text',
-          text: systemPrompt,
-          cache_control: { type: 'ephemeral' },
-        },
-      ],
-      tools: addCacheControlToTools(
-        tools.map((t) => ({
-          name: t.name,
-          description: t.description,
-          input_schema: t.parameters as Anthropic.Tool.InputSchema,
-        })),
-      ),
-      tool_choice: { type: 'auto' },
-    };
+    const toolSet: ToolSet = {};
+    tools.forEach((tool) => {
+      toolSet[tool.name] = {
+        description: tool.description,
+        parameters: tool.parameters,
+      };
+    });
+    const { text, reasoning, reasoningDetails, toolCalls, toolResults } =
+      await generateText({
+        model: config.model,
+        temperature: config.temperature,
+        messages,
+        system: systemPrompt,
+        tools: toolSet,
+        toolChoice: 'auto',
+      });
 
-    const response = await client.messages.create(requestParams);
+    const localToolCalls: ToolUseContent[] = toolCalls.map((call) => ({
+      type: 'tool_use',
+      name: call.toolName,
+      id: call.toolCallId,
+      input: call.args,
+    }));
 
-    if (!response.content.length) {
+    if (!text.length) {
       // Instead of treating empty response as completion, remind the agent
       logger.verbose('Received empty response from agent, sending reminder');
       messages.push({
@@ -319,31 +325,25 @@ export const toolAgent = async (
     }
 
     // Track both regular and cached token usage
-    const tokenUsagePerMessage = TokenUsage.fromMessage(response);
-    tokenTracker.tokenUsage.add(tokenUsagePerMessage);
+    //const tokenUsagePerMessage = TokenUsage.fromMessage(response);
+    //tokenTracker.tokenUsage.add(tokenUsagePerMessage);
 
-    const { content, toolCalls } = processResponse(response);
     messages.push({
       role: 'assistant',
-      content,
+      content: [{ type: 'text', text: text }],
     });
 
-    // Log the assistant's message
-    const assistantMessage = content
-      .filter((c) => c.type === 'text')
-      .map((c) => c.text)
-      .join('\\n');
-    if (assistantMessage) {
-      logger.info(assistantMessage);
+    if (text) {
+      logger.info(text);
     }
 
-    logger.log(
+    /*logger.log(
       tokenTracker.logLevel,
       chalk.blue(`[Token Usage/Message] ${tokenUsagePerMessage.toString()}`),
-    );
+    );*/
 
     const { sequenceCompleted, completionResult, respawn } = await executeTools(
-      toolCalls,
+      localToolCalls,
       tools,
       messages,
       context,
@@ -361,10 +361,8 @@ export const toolAgent = async (
     }
 
     if (sequenceCompleted) {
-      const result = {
-        result:
-          completionResult ??
-          'Sequence explicitly completed with an empty result',
+      const result: ToolAgentResult = {
+        result: completionResult ?? 'Sequence explicitly completed',
         interactions,
       };
       logger.log(

packages/agent/src/tools/interaction/subAgent.ts

@@ -1,3 +1,4 @@
+import { anthropic } from '@ai-sdk/anthropic';
 import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 
@@ -47,7 +48,7 @@ type ReturnType = z.infer<typeof returnSchema>;
 // Sub-agent specific configuration
 const subAgentConfig = {
   maxIterations: 50,
-  model: process.env.AGENT_MODEL || 'claude-3-opus-20240229',
+  model: anthropic('claude-3-7-sonnet-20250219'),
   maxTokens: 4096,
   temperature: 0.7,
   getSystemPrompt: () => {