fix(kernel-agents): report invalid-argument tool calls as tool errors

The chat strategy catches a capability invocation failure and reports it as an
`Error calling …` tool message, but it assumed the thrown value was an `Error`
and read `.message` directly. An exo interface guard can reject with a
non-`Error` value, so an invalid-argument tool call made the catch itself throw
and crash the whole task instead of recovering.

Extract the message defensively (`error instanceof Error ? error.message :
String(error)`), matching the idiom already used elsewhere in the file, and add
a regression test that an invalid-argument tool call comes back as an `Error
calling …` tool message — and that the capability never runs with the bad
arguments — instead of crashing the task.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: grypez

packages/kernel-agents/src/strategies/chat-agent.test.ts

@@ -155,6 +155,48 @@ describe('makeChatAgent', () => {
     ).toBe(true);
   });
 
+  it('injects a tool error for an invalid-argument tool call and continues', async () => {
+    const add = vi.fn(async (a: number, b: number) => a + b);
+    const addCap = makeMethodCapability(
+      'Math',
+      'add',
+      add,
+      S.method(
+        'Add two numbers',
+        [S.arg('a', S.number()), S.arg('b', S.number())],
+        S.number(),
+      ),
+    );
+
+    const recorded: ChatMessage[][] = [];
+    let call = 0;
+    const chat: BoundChat = async ({ messages }) => {
+      recorded.push([...messages]);
+      call += 1;
+      if (call === 1) {
+        // `b` is missing, so the exo's interface guard rejects the call.
+        return makeToolCallResponse('0', [makeToolCall('c1', 'add', { a: 3 })]);
+      }
+      return makeTextResponse('recovered');
+    };
+
+    const agent = makeChatAgent({ chat, capabilities: { add: addCap } });
+    const result = await agent.task('add 3 and ?');
+
+    // The guard rejection surfaces as a tool error rather than crashing the
+    // task, and the implementation never runs with the bad arguments.
+    expect(result).toBe('recovered');
+    expect(add).not.toHaveBeenCalled();
+    const secondTurn = recorded[1] ?? [];
+    expect(
+      secondTurn.some(
+        (message) =>
+          message.role === 'tool' &&
+          message.content.startsWith('Error calling add'),
+      ),
+    ).toBe(true);
+  });
+
   it('throws when invocation budget is exceeded', async () => {
     const ping = makeMethodCapability(
       'Server',

packages/kernel-agents/src/strategies/chat-agent.ts

@@ -182,7 +182,11 @@ export const makeChatAgent = ({
               // here and is reported as the tool error below.
               toolResult = await spec.func(args as never);
             } catch (error) {
-              const errorContent = `Error calling ${name}: ${(error as Error).message}`;
+              // The guard rejection (or any thrown value) becomes a tool error
+              // rather than crashing the task; it may not be an `Error`.
+              const message =
+                error instanceof Error ? error.message : String(error);
+              const errorContent = `Error calling ${name}: ${message}`;
               const toolMsg: ChatMessage = {
                 role: 'tool',
                 tool_call_id: toolCall.id,