skimpyclaw 0.3.6 → 0.3.9

package/dist/__tests__/context-manager.test.js

@@ -0,0 +1,236 @@
+import { describe, it, expect } from 'vitest';
+import { estimateTokens, compactAnthropicMessages, compactOpenAIMessages, compactCodexMessages, } from '../providers/context-manager.js';
+// Helper: build an Anthropic-style tool exchange (assistant + user pair)
+function anthropicExchange(toolResult) {
+    return [
+        {
+            role: 'assistant',
+            content: [
+                { type: 'text', text: 'Using a tool.' },
+                { type: 'tool_use', id: 'tu_1', name: 'Bash', input: { command: 'ls' } },
+            ],
+        },
+        {
+            role: 'user',
+            content: [{ type: 'tool_result', tool_use_id: 'tu_1', content: toolResult }],
+        },
+    ];
+}
+// Helper: build a Codex-style function call exchange
+function codexExchange(output) {
+    return [
+        { type: 'function_call', call_id: 'fc_1', name: 'Bash', arguments: '{}' },
+        { type: 'function_call_output', call_id: 'fc_1', output },
+    ];
+}
+describe('estimateTokens', () => {
+    it('returns a positive number for non-empty data', () => {
+        expect(estimateTokens([{ role: 'user', content: 'hello' }])).toBeGreaterThan(0);
+    });
+    it('returns a small number for empty array', () => {
+        expect(estimateTokens([])).toBeLessThan(5);
+    });
+    it('grows with more content', () => {
+        const small = estimateTokens([{ content: 'hi' }]);
+        const large = estimateTokens([{ content: 'x'.repeat(10_000) }]);
+        expect(large).toBeGreaterThan(small);
+    });
+});
+describe('compactAnthropicMessages', () => {
+    it('passes through unchanged when under threshold', () => {
+        const messages = anthropicExchange('short result');
+        const result = compactAnthropicMessages(messages, { maxContextTokens: 100_000 });
+        expect(result).toEqual(messages);
+    });
+    it('returns same reference when no compaction needed', () => {
+        const messages = anthropicExchange('short result');
+        const result = compactAnthropicMessages(messages, { maxContextTokens: 100_000 });
+        expect(result).toBe(messages);
+    });
+    it('truncates old tool_result content when over threshold', () => {
+        const longResult = 'x'.repeat(10_000);
+        // Build many exchanges to exceed threshold
+        const messages = [];
+        for (let i = 0; i < 30; i++) {
+            messages.push(...anthropicExchange(longResult));
+        }
+        const result = compactAnthropicMessages(messages, { maxContextTokens: 1_000 });
+        // Head messages should have truncated tool results
+        const headMessages = result.slice(0, -8);
+        const toolResultMessages = headMessages.filter(m => Array.isArray(m.content) && m.content.some((b) => b.type === 'tool_result'));
+        for (const msg of toolResultMessages) {
+            const block = msg.content.find((b) => b.type === 'tool_result');
+            expect(block.content).toContain('[truncated]');
+            expect(block.content.length).toBeLessThan(longResult.length);
+        }
+    });
+    it('keeps last 8 messages intact when compacting', () => {
+        const longResult = 'x'.repeat(10_000);
+        const messages = [];
+        for (let i = 0; i < 30; i++) {
+            messages.push(...anthropicExchange(longResult));
+        }
+        const result = compactAnthropicMessages(messages, { maxContextTokens: 1_000 });
+        // Last 8 messages should be untouched
+        const tail = result.slice(-8);
+        const originalTail = messages.slice(-8);
+        expect(tail).toEqual(originalTail);
+    });
+    it('does not mutate the input array', () => {
+        const longResult = 'x'.repeat(10_000);
+        const messages = [];
+        for (let i = 0; i < 30; i++) {
+            messages.push(...anthropicExchange(longResult));
+        }
+        const originalJson = JSON.stringify(messages);
+        compactAnthropicMessages(messages, { maxContextTokens: 1_000 });
+        expect(JSON.stringify(messages)).toBe(originalJson);
+    });
+    it('preserves non-tool_result blocks unchanged', () => {
+        const longResult = 'x'.repeat(10_000);
+        const messages = [];
+        for (let i = 0; i < 30; i++) {
+            messages.push(...anthropicExchange(longResult));
+        }
+        const result = compactAnthropicMessages(messages, { maxContextTokens: 1_000 });
+        // Assistant messages (tool_use blocks) should be untouched
+        const assistantMessages = result.filter(m => m.role === 'assistant');
+        for (const msg of assistantMessages) {
+            const toolUse = msg.content.find((b) => b.type === 'tool_use');
+            expect(toolUse).toBeDefined();
+            expect(toolUse.name).toBe('Bash');
+        }
+    });
+    it('passes through unchanged when disabled', () => {
+        const longResult = 'x'.repeat(10_000);
+        const messages = [];
+        for (let i = 0; i < 30; i++) {
+            messages.push(...anthropicExchange(longResult));
+        }
+        const result = compactAnthropicMessages(messages, { enabled: false, maxContextTokens: 1 });
+        expect(result).toBe(messages);
+    });
+});
+// Helper: build an OpenAI-style tool exchange (assistant + tool result)
+function openaiExchange(toolResult) {
+    return [
+        {
+            role: 'assistant',
+            content: null,
+            tool_calls: [{ id: 'tc_1', type: 'function', function: { name: 'Bash', arguments: '{}' } }],
+        },
+        { role: 'tool', tool_call_id: 'tc_1', content: toolResult },
+    ];
+}
+describe('compactOpenAIMessages', () => {
+    it('passes through unchanged when under threshold', () => {
+        const messages = openaiExchange('short result');
+        const result = compactOpenAIMessages(messages, { maxContextTokens: 100_000 });
+        expect(result).toBe(messages);
+    });
+    it('truncates old tool content when over threshold', () => {
+        const longResult = 'x'.repeat(10_000);
+        const messages = [];
+        for (let i = 0; i < 30; i++) {
+            messages.push(...openaiExchange(longResult));
+        }
+        const result = compactOpenAIMessages(messages, { maxContextTokens: 1_000 });
+        const headItems = result.slice(0, -8);
+        const toolMessages = headItems.filter((m) => m.role === 'tool');
+        for (const msg of toolMessages) {
+            expect(msg.content).toContain('[truncated]');
+            expect(msg.content.length).toBeLessThan(longResult.length);
+        }
+    });
+    it('keeps last 8 messages intact', () => {
+        const longResult = 'x'.repeat(10_000);
+        const messages = [];
+        for (let i = 0; i < 30; i++) {
+            messages.push(...openaiExchange(longResult));
+        }
+        const result = compactOpenAIMessages(messages, { maxContextTokens: 1_000 });
+        expect(result.slice(-8)).toEqual(messages.slice(-8));
+    });
+    it('does not mutate the input array', () => {
+        const longResult = 'x'.repeat(10_000);
+        const messages = [];
+        for (let i = 0; i < 30; i++) {
+            messages.push(...openaiExchange(longResult));
+        }
+        const original = JSON.stringify(messages);
+        compactOpenAIMessages(messages, { maxContextTokens: 1_000 });
+        expect(JSON.stringify(messages)).toBe(original);
+    });
+    it('passes through unchanged when disabled', () => {
+        const longResult = 'x'.repeat(10_000);
+        const messages = [];
+        for (let i = 0; i < 30; i++) {
+            messages.push(...openaiExchange(longResult));
+        }
+        const result = compactOpenAIMessages(messages, { enabled: false, maxContextTokens: 1 });
+        expect(result).toBe(messages);
+    });
+});
+describe('compactCodexMessages', () => {
+    it('passes through unchanged when under threshold', () => {
+        const items = codexExchange('short result');
+        const result = compactCodexMessages(items, { maxContextTokens: 100_000 });
+        expect(result).toEqual(items);
+    });
+    it('truncates old function_call_output when over threshold', () => {
+        const longOutput = 'x'.repeat(10_000);
+        const items = [];
+        for (let i = 0; i < 30; i++) {
+            items.push(...codexExchange(longOutput));
+        }
+        const result = compactCodexMessages(items, { maxContextTokens: 1_000 });
+        const headItems = result.slice(0, -8);
+        const outputItems = headItems.filter((item) => item.type === 'function_call_output');
+        for (const item of outputItems) {
+            expect(item.output).toContain('[truncated]');
+            expect(item.output.length).toBeLessThan(longOutput.length);
+        }
+    });
+    it('keeps last 8 items intact when compacting', () => {
+        const longOutput = 'x'.repeat(10_000);
+        const items = [];
+        for (let i = 0; i < 30; i++) {
+            items.push(...codexExchange(longOutput));
+        }
+        const result = compactCodexMessages(items, { maxContextTokens: 1_000 });
+        const tail = result.slice(-8);
+        const originalTail = items.slice(-8);
+        expect(tail).toEqual(originalTail);
+    });
+    it('does not mutate the input array', () => {
+        const longOutput = 'x'.repeat(10_000);
+        const items = [];
+        for (let i = 0; i < 30; i++) {
+            items.push(...codexExchange(longOutput));
+        }
+        const originalJson = JSON.stringify(items);
+        compactCodexMessages(items, { maxContextTokens: 1_000 });
+        expect(JSON.stringify(items)).toBe(originalJson);
+    });
+    it('preserves function_call items (not just outputs) unchanged', () => {
+        const longOutput = 'x'.repeat(10_000);
+        const items = [];
+        for (let i = 0; i < 30; i++) {
+            items.push(...codexExchange(longOutput));
+        }
+        const result = compactCodexMessages(items, { maxContextTokens: 1_000 });
+        const callItems = result.filter((item) => item.type === 'function_call');
+        for (const item of callItems) {
+            expect(item.name).toBe('Bash');
+        }
+    });
+    it('passes through unchanged when disabled', () => {
+        const longOutput = 'x'.repeat(10_000);
+        const items = [];
+        for (let i = 0; i < 30; i++) {
+            items.push(...codexExchange(longOutput));
+        }
+        const result = compactCodexMessages(items, { enabled: false, maxContextTokens: 1 });
+        expect(result).toBe(items);
+    });
+});

package/dist/__tests__/package-manager-detection.test.js

@@ -147,17 +147,17 @@ describe('buildValidationCommand', () => {
         writeFileSync(join(tempDir, 'yarn.lock'), '');
         expect(buildValidationCommand(tempDir)).toBe('yarn build');
     });
-    it('falls back to both commands when no package.json exists', () => {
-        // No package.json, no lockfile → pnpm fallback
-        expect(buildValidationCommand(tempDir)).toBe('pnpm build && pnpm test');
+    it('returns empty when no package.json exists', () => {
+        // No package.json, no lockfile → nothing to validate
+        expect(buildValidationCommand(tempDir)).toBe('');
     });
-    it('falls back to both commands when scripts object is empty', () => {
+    it('returns empty when scripts object is empty', () => {
         writeFileSync(join(tempDir, 'package.json'), JSON.stringify({
             name: 'test',
             scripts: {},
         }));
         writeFileSync(join(tempDir, 'yarn.lock'), '');
-        expect(buildValidationCommand(tempDir)).toBe('yarn build && yarn test');
+        expect(buildValidationCommand(tempDir)).toBe('');
     });
     // wp-calypso scenario
     it('generates yarn commands for wp-calypso-like project', () => {

package/dist/__tests__/setup.test.js

@@ -133,11 +133,13 @@ describe('setup config generation', () => {
                 skillWebSearch: false,
             },
         });
-        expect(config.cron.jobs).toHaveLength(2);
-        expect(config.cron.jobs[0].id).toBe('tech-digest');
-        expect(config.cron.jobs[1].id).toBe('weather');
-        expect(config.cron.jobs[1].schedule.tz).toBe('America/New_York');
-        expect(config.cron.jobs[1].payload.message).toContain('Austin, TX');
+        expect(config.cron.jobs).toHaveLength(3);
+        expect(config.cron.jobs[0].id).toBe('memory-trim');
+        expect(config.cron.jobs[0].model).toBe('claude-haiku');
+        expect(config.cron.jobs[1].id).toBe('tech-digest');
+        expect(config.cron.jobs[2].id).toBe('weather');
+        expect(config.cron.jobs[2].schedule.tz).toBe('America/New_York');
+        expect(config.cron.jobs[2].payload.message).toContain('Austin, TX');
         expect(config.skills.enabled).toBe(true);
         expect(config.skills.entries['daily-notes']).toBe(true);
         expect(config.skills.entries['weather']).toBe(true);

package/dist/__tests__/skills.test.js

@@ -211,8 +211,8 @@ describe('checkEligibility', () => {
         const result = checkEligibility({ name: 'test', description: 'test', requires: { tools: ['Browser'] } }, { enabled: true, allowedPaths: ['/tmp'], browser: { enabled: true } });
         expect(result.eligible).toBe(true);
     });
-    it('passes on spawn_subagent requirement when tools enabled', () => {
-        const result = checkEligibility({ name: 'test', description: 'test', requires: { tools: ['spawn_subagent'] } }, { enabled: true, allowedPaths: ['/tmp'] });
+    it('passes on code_with_agent requirement when tools enabled', () => {
+        const result = checkEligibility({ name: 'test', description: 'test', requires: { tools: ['code_with_agent'] } }, { enabled: true, allowedPaths: ['/tmp'] });
         expect(result.eligible).toBe(true);
     });
 });

package/dist/__tests__/structured-context.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/structured-context.test.js

@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import { parseAgentOutput, formatStructuredContext } from '../code-agents/structured-context.js';
+describe('parseAgentOutput', () => {
+    it('returns empty files and errors for plain text', () => {
+        const result = parseAgentOutput('Everything looks good.');
+        expect(result.summary).toBe('Everything looks good.');
+        expect(result.files).toEqual([]);
+        expect(result.errors).toEqual([]);
+    });
+    it('extracts backtick-quoted file paths', () => {
+        const raw = 'Updated `src/agent.ts` and `src/types.ts` to add the new field.';
+        const result = parseAgentOutput(raw);
+        expect(result.files).toContain('src/agent.ts');
+        expect(result.files).toContain('src/types.ts');
+    });
+    it('extracts absolute file paths', () => {
+        const raw = 'Wrote changes to /Users/katre/Sites/skimpyclaw/src/agent.ts successfully.';
+        const result = parseAgentOutput(raw);
+        expect(result.files).toContain('/Users/katre/Sites/skimpyclaw/src/agent.ts');
+    });
+    it('ignores backtick tokens without dots (not file paths)', () => {
+        const raw = 'Call `myFunction` and `anotherMethod` to do the work.';
+        const result = parseAgentOutput(raw);
+        expect(result.files).toEqual([]);
+    });
+    it('ignores backtick tokens with spaces (commands, not paths)', () => {
+        const raw = 'Run `pnpm build && pnpm test` to verify.';
+        const result = parseAgentOutput(raw);
+        expect(result.files).toEqual([]);
+    });
+    it('extracts error lines', () => {
+        const raw = 'Build completed.\nError: Cannot find module src/missing.js\nAll tests passed.';
+        const result = parseAgentOutput(raw);
+        expect(result.errors).toHaveLength(1);
+        expect(result.errors[0]).toContain('Cannot find module');
+    });
+    it('caps errors at 5', () => {
+        const lines = Array.from({ length: 10 }, (_, i) => `Error: problem ${i}`).join('\n');
+        const result = parseAgentOutput(lines);
+        expect(result.errors.length).toBeLessThanOrEqual(5);
+    });
+    it('caps files at 15', () => {
+        const lines = Array.from({ length: 20 }, (_, i) => `Updated \`src/file${i}.ts\`.`).join('\n');
+        const result = parseAgentOutput(lines);
+        expect(result.files.length).toBeLessThanOrEqual(15);
+    });
+    it('deduplicates file paths', () => {
+        const raw = 'Updated `src/agent.ts`. Also modified `src/agent.ts` again.';
+        const result = parseAgentOutput(raw);
+        const count = result.files.filter(f => f === 'src/agent.ts').length;
+        expect(count).toBe(1);
+    });
+    it('truncates summary to 500 chars', () => {
+        const raw = 'x'.repeat(1000);
+        const result = parseAgentOutput(raw);
+        expect(result.summary).toHaveLength(500);
+    });
+    it('strips trailing punctuation from absolute paths', () => {
+        const raw = 'Modified /src/foo.ts, and /src/bar.ts.';
+        const result = parseAgentOutput(raw);
+        expect(result.files).not.toContain('/src/foo.ts,');
+        expect(result.files).not.toContain('/src/bar.ts.');
+    });
+});
+describe('formatStructuredContext', () => {
+    it('formats summary only when no files or errors', () => {
+        const result = formatStructuredContext({ summary: 'Done.', files: [], errors: [] });
+        expect(result).toBe('Summary: Done.');
+    });
+    it('includes files line when files present', () => {
+        const result = formatStructuredContext({
+            summary: 'Updated auth.',
+            files: ['src/auth.ts', 'src/types.ts'],
+            errors: [],
+        });
+        expect(result).toContain('Files: src/auth.ts, src/types.ts');
+    });
+    it('includes errors line when errors present', () => {
+        const result = formatStructuredContext({
+            summary: 'Build failed.',
+            files: [],
+            errors: ['Error: missing export'],
+        });
+        expect(result).toContain('Errors: Error: missing export');
+    });
+    it('separates multiple errors with pipe', () => {
+        const result = formatStructuredContext({
+            summary: 'Done.',
+            files: [],
+            errors: ['Error: foo', 'Error: bar'],
+        });
+        expect(result).toContain('Error: foo | Error: bar');
+    });
+    it('produces a shorter output than raw 1000-char input', () => {
+        const raw = 'x'.repeat(1000);
+        const parsed = parseAgentOutput(raw);
+        const formatted = formatStructuredContext(parsed);
+        expect(formatted.length).toBeLessThan(raw.length);
+    });
+});

package/dist/__tests__/tools.test.js

@@ -59,6 +59,42 @@ describe('getToolDefinitions', () => {
         const tools = await getToolDefinitions();
         expect(tools.map(t => t.name)).not.toContain('Browser');
     });
+    describe('tool profiles', () => {
+        it('minimal returns exactly 4 built-in tools', async () => {
+            const config = { ...toolConfig, toolProfile: 'minimal' };
+            const tools = await getToolDefinitions(config, { includeAgentTools: true, includeMcp: true });
+            expect(tools).toHaveLength(4);
+            expect(tools.map(t => t.name)).toEqual(['Read', 'Write', 'Glob', 'Bash']);
+        });
+        it('minimal excludes Browser even when browser.enabled is true', async () => {
+            const config = { ...toolConfig, toolProfile: 'minimal', browser: { enabled: true } };
+            const tools = await getToolDefinitions(config);
+            expect(tools.map(t => t.name)).not.toContain('Browser');
+        });
+        it('minimal excludes MCP tools', async () => {
+            const config = { ...toolConfig, toolProfile: 'minimal' };
+            const tools = await getToolDefinitions(config, { includeMcp: true });
+            expect(tools.every(t => !t.name.startsWith('mcp__'))).toBe(true);
+        });
+        it('coding includes code_with_agent and check_code_agent but not code_with_team', async () => {
+            const config = { ...toolConfig, toolProfile: 'coding' };
+            const tools = await getToolDefinitions(config, { includeAgentTools: true });
+            const names = tools.map(t => t.name);
+            expect(names).toContain('code_with_agent');
+            expect(names).toContain('check_code_agent');
+            expect(names).not.toContain('code_with_team');
+        });
+        it('coding excludes MCP tools', async () => {
+            const config = { ...toolConfig, toolProfile: 'coding' };
+            const tools = await getToolDefinitions(config, { includeMcp: true });
+            expect(tools.every(t => !t.name.startsWith('mcp__'))).toBe(true);
+        });
+        it('full profile behaves like default (no profile set)', async () => {
+            const defaultTools = await getToolDefinitions(toolConfig);
+            const fullTools = await getToolDefinitions({ ...toolConfig, toolProfile: 'full' });
+            expect(fullTools.map(t => t.name)).toEqual(defaultTools.map(t => t.name));
+        }, 15000);
+    });
 });
 describe('tool name mapping', () => {
     it('maps Claude Code names to internal names', () => {
@@ -192,6 +228,32 @@ describe('bash', () => {
         const result = await executeTool('delete_everything', {}, toolConfig);
         expect(result).toContain('Error: Unknown tool');
     });
+    describe('exec approval in unattended contexts', () => {
+        it('fast-denies tier 3 inline interpreter scripts in subagent context', async () => {
+            const result = await executeTool('Bash', { command: 'node -e "console.log(1)"' }, toolConfig, { channel: 'subagent' });
+            expect(result).toContain('⛔');
+            expect(result).toContain('tier 3');
+            expect(result).not.toContain('approved');
+        });
+        it('fast-denies tier 2 commands in subagent context', async () => {
+            const result = await executeTool('Bash', { command: 'gh pr review --approve' }, toolConfig, { channel: 'subagent' });
+            expect(result).toContain('⛔');
+            expect(result).toContain('tier 2');
+        });
+        it('fast-denies tier 3 commands in cron context', async () => {
+            const result = await executeTool('Bash', { command: 'node -e "console.log(1)"' }, toolConfig, { isCronJob: true });
+            expect(result).toContain('⛔');
+            expect(result).toContain('tier 3');
+        });
+        it('fast-denies when no approver and no chatId', async () => {
+            const result = await executeTool('Bash', { command: 'kubectl delete pods --all' }, toolConfig, {});
+            expect(result).toContain('⛔');
+        });
+        it('allows safe tier 0 commands in subagent context', async () => {
+            const result = await executeTool('Bash', { command: 'echo hello' }, toolConfig, { channel: 'subagent' });
+            expect(result.trim()).toBe('hello');
+        });
+    });
 });
 describe('browser', () => {
     const browserDisabledConfig = {
@@ -286,7 +348,7 @@ describe('code_with_agent', () => {
             expect(props).toContain('validate');
         });
         it('is included in getToolDefinitions when includeSpawnSubagent is true', async () => {
-            const tools = await getToolDefinitions(toolConfig, { includeSpawnSubagent: true });
+            const tools = await getToolDefinitions(toolConfig, { includeAgentTools: true });
             expect(tools.map(t => t.name)).toContain('code_with_agent');
         });
         it('is excluded from getToolDefinitions when includeSpawnSubagent is false', async () => {
@@ -401,7 +463,7 @@ describe('code_with_agent', () => {
             expect(CHECK_CODE_AGENT_TOOL.input_schema.properties).toHaveProperty('id');
         });
         it('is included in getToolDefinitions when includeSpawnSubagent is true', async () => {
-            const tools = await getToolDefinitions(toolConfig, { includeSpawnSubagent: true });
+            const tools = await getToolDefinitions(toolConfig, { includeAgentTools: true });
             expect(tools.map(t => t.name)).toContain('check_code_agent');
         });
         it('is excluded from getToolDefinitions when includeSpawnSubagent is false', async () => {
@@ -453,7 +515,7 @@ describe('code_with_team', () => {
             expect(props).not.toContain('max_turns');
         });
         it('is included in getToolDefinitions when includeSpawnSubagent is true', async () => {
-            const tools = await getToolDefinitions(toolConfig, { includeSpawnSubagent: true });
+            const tools = await getToolDefinitions(toolConfig, { includeAgentTools: true });
             expect(tools.map(t => t.name)).toContain('code_with_team');
         });
         it('is excluded from getToolDefinitions when includeSpawnSubagent is false', async () => {

package/dist/agent.js

@@ -1,8 +1,9 @@
 // Agent runner: loads templates, calls models, manages memory
-import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from 'fs';
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { getAgentDir } from './config.js';
 import { buildSafeSystemPrompt, sanitizeUserInput } from './security.js';
+import { toErrorMessage } from './utils.js';
 import { startTrace, endTrace } from './audit.js';
 import { loadSkills, getSkillsForContext, formatSkillsPrompt } from './skills.js';
 import { getLangfuseConfig, isLangfuseEnabled } from './langfuse.js';
@@ -73,9 +74,7 @@ export function appendToMemory(agentId, entry) {
     }
     const path = getTodayMemoryPath(agentId);
     const timestamp = new Date().toISOString();
-    const content = existsSync(path) ? readFileSync(path, 'utf-8') : '';
-    const newContent = content + `\n## ${timestamp}\n\n${entry}\n`;
-    writeFileSync(path, newContent.trim() + '\n');
+    appendFileSync(path, `\n## ${timestamp}\n\n${entry}\n`, 'utf-8');
 }
 // --- Agent Turn ---
 // Langfuse app tagging
@@ -230,7 +229,7 @@ export async function runAgentTurn(agentId, userMessage, config, modelOverride,
             return result;
         }
         catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
+            const errorMessage = toErrorMessage(err);
             agentObs.update({
                 level: 'ERROR',
                 statusMessage: errorMessage,