starting to work.

Author: bhouston

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

@@ -3,11 +3,16 @@
  */
 import { LLMProvider } from './provider.js';
 import {
+  AssistantMessage,
   FunctionDefinition,
   GenerateOptions,
   LLMResponse,
   Message,
+  SystemMessage,
   ToolCall,
+  ToolResultMessage,
+  ToolUseMessage,
+  UserMessage,
 } from './types.js';
 
 /**
@@ -112,23 +117,31 @@ export function normalizeMessages(messages: Message[]): Message[] {
         return {
           role: 'system',
           content: msg.content,
-        };
+        } satisfies SystemMessage;
       case 'user':
         return {
           role: 'user',
           content: msg.content,
-        };
+        } satisfies UserMessage;
       case 'assistant':
         return {
           role: 'assistant',
           content: msg.content,
-        };
-      case 'tool':
+        } satisfies AssistantMessage;
+      case 'tool_use':
         return {
-          role: 'tool',
+          role: 'tool_use',
+          id: msg.id,
+          name: msg.name,
           content: msg.content,
-          name: msg.name || 'unknown_tool', // Ensure name is always present for tool messages
-        };
+        } satisfies ToolUseMessage;
+      case 'tool_result':
+        return {
+          role: 'tool_result',
+          tool_use_id: msg.tool_use_id,
+          content: msg.content,
+          is_error: msg.is_error,
+        } satisfies ToolResultMessage;
       default:
         // Use type assertion for unknown roles
         console.warn(

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

@@ -70,13 +70,14 @@ async function _openaiExample() {
 
       // Example of adding a tool result
       const toolResult: Message = {
-        role: 'tool',
-        name: toolCall.name,
+        role: 'tool_result',
+        tool_use_id: toolCall.id,
         content: JSON.stringify({
           temperature: 72,
           unit: 'fahrenheit',
           description: 'Sunny with some clouds',
         }),
+        is_error: false,
       };
 
       // Continue the conversation with the tool result

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

@@ -82,12 +82,21 @@ export class AnthropicProvider implements LLMProvider {
           description: fn.description,
           input_schema: fn.parameters,
         }));
-        console.log('Tools for Anthropic:', JSON.stringify(tools, null, 2));
         (requestOptions as any).tools = tools;
       }
 
+      console.log(
+        'Input Messages for Anthropic:',
+        JSON.stringify(requestOptions.messages, null, 2),
+      );
+
       const response = await this.client.messages.create(requestOptions);
 
+      console.log(
+        'Response from Anthropic:',
+        JSON.stringify(response.content, null, 2),
+      );
+
       // Extract content and tool calls
       const content =
         response.content.find((c) => c.type === 'text')?.text || '';
@@ -144,21 +153,32 @@ export class AnthropicProvider implements LLMProvider {
           role: 'assistant',
           content: msg.content,
         };
-      } else if (msg.role === 'tool') {
+      } else if (msg.role === 'tool_result') {
         // Anthropic expects tool responses as an assistant message with tool_results
         return {
-          role: 'assistant',
+          role: 'user',
           content: [
             {
               type: 'tool_result',
-              tool_use_id: msg.name, // Use name as the tool_use_id
+              tool_use_id: msg.tool_use_id, // Use name as the tool_use_id
               content: msg.content,
+              is_error: msg.is_error,
+            },
+          ],
+        };
+      } else if (msg.role === 'tool_use') {
+        return {
+          role: 'assistant',
+          content: [
+            {
+              type: 'tool_use',
+              name: msg.name,
+              id: msg.id,
+              input: JSON.parse(msg.content),
             },
           ],
         };
       }
-
-      // Default fallback
       return {
         role: 'user',
         content: msg.content,

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

@@ -6,7 +6,7 @@
  * Base message type with role and content
  */
 export interface BaseMessage {
-  role: 'system' | 'user' | 'assistant' | 'tool';
+  role: 'system' | 'user' | 'assistant' | 'tool_use' | 'tool_result';
   content: string;
   name?: string;
 }
@@ -35,9 +35,18 @@ export interface AssistantMessage extends BaseMessage {
 /**
  * Tool message for representing tool responses
  */
-export interface ToolMessage extends BaseMessage {
-  role: 'tool';
+export interface ToolUseMessage extends BaseMessage {
+  role: 'tool_use';
   name: string; // Tool name is required for tool messages
+  id: string; // Tool ID is required for tool messages
+  content: string; // the arguments in string form, but JSON
+}
+
+export interface ToolResultMessage extends BaseMessage {
+  role: 'tool_result';
+  tool_use_id: string; // Tool Use ID is required for tool messages
+  content: string; // the results in string form, but JSON
+  is_error: boolean; // whether the tool call was successful
 }
 
 /**
@@ -47,7 +56,8 @@ export type Message =
   | SystemMessage
   | UserMessage
   | AssistantMessage
-  | ToolMessage;
+  | ToolUseMessage
+  | ToolResultMessage;
 
 /**
  * Function/Tool definition for LLM

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

@@ -8,7 +8,7 @@ export function formatToolCalls(toolCalls: ToolCall[]): any[] {
     type: 'tool_use',
     name: call.name,
     id: call.id,
-    input: JSON.parse(call.arguments),
+    input: call.arguments,
   }));
 }
 
@@ -30,13 +30,15 @@ export function createToolCallParts(toolCalls: any[]): any[] {
  */
 export function addToolResultToMessages(
   messages: Message[],
-  toolName: string,
+  toolUseId: string,
   toolResult: any,
+  isError: boolean,
 ): void {
   messages.push({
-    role: 'tool',
-    name: toolName,
+    role: 'tool_result',
+    tool_use_id: toolUseId,
     content:
       typeof toolResult === 'string' ? toolResult : JSON.stringify(toolResult),
+    is_error: isError,
   });
 }

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

@@ -1,6 +1,6 @@
 import { zodToJsonSchema } from 'zod-to-json-schema';
 
-import { Message, generateText } from '../llm/index.js';
+import { Message, ToolUseMessage, generateText } from '../llm/index.js';
 
 import { DEFAULT_CONFIG } from './config.js';
 import { formatToolCalls } from './messageUtils.js';
@@ -105,6 +105,18 @@ export const toolAgent = async (
 
     // Handle tool calls if any
     if (toolCalls.length > 0) {
+      messages.push(
+        ...toolCalls.map(
+          (toolCall) =>
+            ({
+              role: 'tool_use',
+              name: toolCall.name,
+              id: toolCall.id,
+              content: toolCall.arguments,
+            }) satisfies ToolUseMessage,
+        ),
+      );
+
       // Execute the tools and get results
       const { sequenceCompleted, completionResult, respawn } =
         await executeTools(localToolCalls, tools, messages, context);

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

@@ -36,7 +36,7 @@ export async function executeTools(
   const respawnCall = toolCalls.find((call) => call.name === 'respawn');
   if (respawnCall) {
     // Add the tool result to messages
-    addToolResultToMessages(messages, respawnCall.name, { success: true });
+    addToolResultToMessages(messages, respawnCall.id, { success: true }, false);
 
     return {
       sequenceCompleted: false,
@@ -56,12 +56,14 @@ export async function executeTools(
   const toolResults = await Promise.all(
     toolCalls.map(async (call) => {
       let toolResult = '';
+      let isError = false;
       try {
         toolResult = await executeToolCall(call, tools, {
           ...context,
           tokenTracker: new TokenTracker(call.name, context.tokenTracker),
         });
       } catch (errorStr: any) {
+        isError = true;
         if (errorStr instanceof Error) {
           if (errorStr.stack) {
             context.logger.error(`Tool error stack trace: ${errorStr.stack}`);
@@ -78,7 +80,7 @@ export async function executeTools(
       const parsedResult = safeParse(toolResult);
 
       // Add the tool result to messages
-      addToolResultToMessages(messages, call.name, parsedResult);
+      addToolResultToMessages(messages, call.id, parsedResult, isError);
 
       return {
         toolCallId: call.id,

packages/agent/src/core/types.ts

@@ -62,6 +62,7 @@ export type ToolResultContent = {
   type: 'tool_result';
   tool_use_id: string;
   content: string;
+  is_error: boolean;
 };
 
 export type UserMessage = {