@amodalai/runtime 0.2.0 → 0.2.1

package/dist/src/__fixtures__/smoke.test.js

@@ -13,26 +13,12 @@
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 import { fork } from 'node:child_process';
 import { resolve } from 'node:path';
-import { readFileSync, writeFileSync, rmSync } from 'node:fs';
-// Load API keys from repo root .env.test if not already set.
-// To run smoke tests: create .env.test at the repo root with ANTHROPIC_API_KEY=sk-ant-...
-// This file is gitignored — never commit API keys.
-if (!process.env['ANTHROPIC_API_KEY']) {
-    try {
-        const envPath = resolve(__dirname, '../../../../.env.test');
-        const envContent = readFileSync(envPath, 'utf-8');
-        for (const line of envContent.split('\n')) {
-            const match = line.match(/^([^#=]+)=(.*)$/);
-            if (match) {
-                const [, key, value] = match;
-                if (key && value && !process.env[key.trim()]) {
-                    process.env[key.trim()] = value.trim();
-                }
-            }
-        }
-    }
-    catch { /* no .env.test — tests will skip */ }
-}
+import { readFileSync, writeFileSync, rmSync, readdirSync } from 'node:fs';
+import { expectDoneReason, expectTotalTokens } from './test-helpers.js';
+import { loadTestEnv, defaultTargetName } from './test-env.js';
+// Pull API keys out of <repo-root>/.env.test (gitignored). Missing keys
+// cause the describe block below to skip with a reason.
+loadTestEnv();
 // ---------------------------------------------------------------------------
 // Config
 // ---------------------------------------------------------------------------
@@ -42,6 +28,18 @@ const AGENT_DIR = resolve(__dirname, 'smoke-agent');
 const REST_SERVER = resolve(__dirname, 'smoke-rest-server.mjs');
 const MCP_SERVER = resolve(__dirname, 'smoke-mcp-server.mjs');
 const TIMEOUT = 45_000; // per-test timeout for LLM calls
+const SMOKE_TARGETS = {
+    anthropic: { provider: 'anthropic', model: 'claude-sonnet-4-20250514', apiKeyEnv: 'ANTHROPIC_API_KEY' },
+    google: { provider: 'google', model: 'gemini-2.5-flash', apiKeyEnv: 'GOOGLE_API_KEY' },
+    openai: { provider: 'openai', model: 'gpt-4o-mini', apiKeyEnv: 'OPENAI_API_KEY' },
+    groq: { provider: 'groq', model: 'llama-3.3-70b-versatile', apiKeyEnv: 'GROQ_API_KEY' },
+};
+function pickSmokeTarget() {
+    const override = process.env['SMOKE_TARGET'];
+    const name = override ?? defaultTargetName(SMOKE_TARGETS);
+    return { name, target: SMOKE_TARGETS[name] };
+}
+const { name: smokeTargetName, target: smokeTarget } = pickSmokeTarget();
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -58,10 +56,12 @@ async function waitForServer(port, maxMs = 15_000) {
     }
     throw new Error(`Server on port ${port} did not start within ${maxMs}ms`);
 }
-async function chat(message, sessionId) {
+async function chat(message, sessionId, opts) {
     const body = { message };
     if (sessionId)
         body['session_id'] = sessionId;
+    if (opts?.maxSessionTokens !== undefined)
+        body['max_session_tokens'] = opts.maxSessionTokens;
     const res = await fetch(`http://localhost:${AGENT_PORT}/chat`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
@@ -102,14 +102,45 @@ function allText(events) {
 // ---------------------------------------------------------------------------
 let restServer = null;
 let agentServer = null;
-const skipReason = process.env['ANTHROPIC_API_KEY'] ? '' : 'ANTHROPIC_API_KEY not set';
-describe.skipIf(!!skipReason)('smoke tests', () => {
+/** Captures payloads delivered to callback-type targets for assertion. */
+const receivedAutomationResults = [];
+const skipReason = !smokeTarget
+    ? `unknown SMOKE_TARGET "${smokeTargetName}"; known: ${Object.keys(SMOKE_TARGETS).join(', ')}`
+    : process.env[smokeTarget.apiKeyEnv]
+        ? ''
+        : `${smokeTarget.apiKeyEnv} not set`;
+describe.skipIf(!!skipReason)(`smoke tests [${smokeTargetName}]`, () => {
+    // Stash fixture files so afterAll can restore them; otherwise the
+    // per-run rewrites (provider + absolute MCP path) leak into the repo.
+    const amodalPath = resolve(AGENT_DIR, 'amodal.json');
+    const mcpSpecPath = resolve(AGENT_DIR, 'connections/mock-mcp/spec.json');
+    const originalAmodalJson = readFileSync(amodalPath, 'utf-8');
+    const originalMcpSpec = readFileSync(mcpSpecPath, 'utf-8');
     beforeAll(async () => {
         // 0. Nuke prior state — clean slate for every run
         rmSync(resolve(AGENT_DIR, '.amodal/store-data'), { recursive: true, force: true });
-        rmSync(resolve(AGENT_DIR, '.amodal/sessions'), { recursive: true, force: true });
-        // 2. Write MCP server spec with absolute path (loadRepo reads this as-is)
-        writeFileSync(resolve(AGENT_DIR, 'connections/mock-mcp/spec.json'), JSON.stringify({ protocol: 'mcp', transport: 'stdio', command: 'node', args: [MCP_SERVER] }, null, 2));
+        // 1. Rewrite amodal.json with the selected provider/model.
+        //    smokeTarget is guaranteed defined here — skipReason above gates
+        //    the describe block when it's undefined or missing a key.
+        if (!smokeTarget)
+            throw new Error('unreachable: smokeTarget is undefined under skipReason guard');
+        const amodalConfig = JSON.parse(originalAmodalJson);
+        amodalConfig['models'] = {
+            main: { provider: smokeTarget.provider, model: smokeTarget.model },
+        };
+        // Enable web_search + fetch_url tools when a Google API key is available.
+        // Key resolution happens in the core config parser via env: prefix.
+        if (process.env['GOOGLE_API_KEY']) {
+            amodalConfig['webTools'] = {
+                provider: 'google',
+                apiKey: 'env:GOOGLE_API_KEY',
+                model: 'gemini-3-flash-preview',
+            };
+        }
+        writeFileSync(amodalPath, JSON.stringify(amodalConfig, null, 2));
+        // 2. Write MCP server spec with absolute path (loadRepo reads this as-is).
+        //    Restored in afterAll so the env-specific path doesn't leak into git.
+        writeFileSync(mcpSpecPath, JSON.stringify({ protocol: 'mcp', transport: 'stdio', command: 'node', args: [MCP_SERVER] }, null, 2));
         // 3. Start mock REST server
         restServer = fork(REST_SERVER, [], {
             env: { ...process.env, SMOKE_REST_PORT: String(REST_PORT) },
@@ -122,6 +153,9 @@ describe.skipIf(!!skipReason)('smoke tests', () => {
             repoPath: AGENT_DIR,
             port: AGENT_PORT,
             hotReload: false,
+            onAutomationResult: (payload) => {
+                receivedAutomationResults.push(payload);
+            },
         });
         await agentServer.start();
         await waitForServer(AGENT_PORT);
@@ -133,6 +167,10 @@ describe.skipIf(!!skipReason)('smoke tests', () => {
         if (restServer) {
             restServer.kill('SIGTERM');
         }
+        // Restore fixture files so the per-run rewrites stay test-local and
+        // don't show up in git status afterwards.
+        writeFileSync(amodalPath, originalAmodalJson);
+        writeFileSync(mcpSpecPath, originalMcpSpec);
     });
     // -------------------------------------------------------------------------
     // 1. Server lifecycle
@@ -272,9 +310,205 @@ describe.skipIf(!!skipReason)('smoke tests', () => {
         const toolStarts = findEvents(events, 'tool_call_start');
         const readTool = toolStarts.find((e) => e['tool_name'] === 'read_repo_file');
         expect(readTool).toBeDefined();
+        // The matching result should be a success — validates the full
+        // tool_call_start → execute → tool_call_result SSE round-trip.
+        const toolResults = findEvents(events, 'tool_call_result');
+        const readResult = toolResults.find((e) => e['tool_id'] === readTool?.['tool_id']);
+        expect(readResult).toBeDefined();
+        expect(readResult?.['status']).toBe('success');
         const responseText = allText(events);
         expect(responseText.toLowerCase()).toContain('test');
     }, TIMEOUT);
+    // End-to-end: the "reduce emojis in formatting rules" scenario from the
+    // admin-agent regression. Before the discovery + edit tools existed, the
+    // agent guessed wrong paths and often created a new skill file instead
+    // of editing the existing knowledge doc. With list_repo_files /
+    // glob_repo_files / grep_repo_files / edit_repo_file available, it
+    // should discover knowledge/formatting-rules.md and edit it in place.
+    it('admin agent discovers and edits the right file (emoji-reduction scenario)', async () => {
+        const formattingRulesPath = resolve(AGENT_DIR, 'knowledge', 'formatting-rules.md');
+        const emojiHeavyBody = [
+            '# Formatting Rules 🎨',
+            '',
+            'Use emojis liberally to make the output more engaging! 🎉🎉🎉',
+            '',
+            '## Tone 💬',
+            '',
+            "Drop a 🚀 when celebrating a win, a 🔥 when highlighting risk, and a ✨ when introducing a new feature. Don't hold back! 🙌",
+            '',
+            'Every bullet point should start with an emoji. 📝 Every heading should have one too. 🏷️',
+            '',
+            '## Examples 📚',
+            '- ✅ "Deployment succeeded 🎉"',
+            '- ❌ "Deployment failed 💥"',
+            '',
+        ].join('\n');
+        const emojiCount = (s) => (s.match(/\p{Emoji_Presentation}/gu) ?? []).length;
+        const initialEmojis = emojiCount(emojiHeavyBody);
+        expect(initialEmojis).toBeGreaterThan(5);
+        writeFileSync(formattingRulesPath, emojiHeavyBody);
+        // Snapshot skills/ so we can assert the agent didn't create a bogus skill.
+        const skillsDir = resolve(AGENT_DIR, 'skills');
+        const skillsBefore = new Set(readdirSync(skillsDir));
+        try {
+            const res = await fetch(`http://localhost:${AGENT_PORT}/config/chat`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    message: 'I want to use emojis less often in my formatting rules. Find where they are defined in my repo and reduce the emoji guidance — remove most emoji usage from the instructions, keep the document but make it plain text. Work carefully: first look around to find the right file, then edit it in place. Do not create any new skills.',
+                }),
+                signal: AbortSignal.timeout(TIMEOUT * 2),
+            });
+            const text = await res.text();
+            const events = parseSSE(text);
+            const toolStarts = findEvents(events, 'tool_call_start');
+            const toolNames = toolStarts.map((e) => String(e['tool_name']));
+            // Discovery: the agent should have used at least one of the new
+            // discovery tools to find formatting-rules.md instead of guessing.
+            const usedDiscovery = toolNames.some((n) => n === 'list_repo_files' || n === 'glob_repo_files' || n === 'grep_repo_files');
+            expect(usedDiscovery).toBe(true);
+            // Action: should edit in place, NOT rewrite the whole file or create
+            // a new skill. We allow either edit_repo_file (preferred) or
+            // write_repo_file targeting the same path (acceptable).
+            const editedInPlace = toolNames.includes('edit_repo_file');
+            const rewroteFile = toolNames.includes('write_repo_file');
+            expect(editedInPlace || rewroteFile).toBe(true);
+            // Regression guard: agent must NOT have created a new skill.
+            const skillsAfter = new Set(readdirSync(skillsDir));
+            const newSkills = [...skillsAfter].filter((s) => !skillsBefore.has(s));
+            expect(newSkills).toEqual([]);
+            // Outcome: the file should still exist and contain significantly
+            // fewer emojis than before.
+            const after = readFileSync(formattingRulesPath, 'utf-8');
+            expect(after.length).toBeGreaterThan(0);
+            const afterEmojis = emojiCount(after);
+            expect(afterEmojis).toBeLessThan(initialEmojis);
+        }
+        finally {
+            // Clean up — remove the formatting-rules.md fixture regardless of pass/fail.
+            rmSync(formattingRulesPath, { force: true });
+        }
+    }, TIMEOUT * 2);
+    // Pagination end-to-end: drop a 3000-line file with a sentinel on line
+    // 2800, ask the admin agent to report what's there verbatim. The default
+    // read cap is 2000 lines, so the agent MUST either paginate via offset
+    // or use grep. Verifies the new line_start/line_end/total_lines/
+    // truncated response shape is actually usable by a real LLM.
+    it('admin agent paginates a long file to reach content past the default cap', async () => {
+        const bigFilePath = resolve(AGENT_DIR, 'knowledge', 'big-file.md');
+        // Sentinel must be distinct enough that the agent can quote it back.
+        const SENTINEL = 'TARGET:CONTENT:ABCD1234:the-answer-is-42';
+        const TARGET_LINE = 2800;
+        const TOTAL_LINES = 3000;
+        const body = Array.from({ length: TOTAL_LINES }, (_, i) => {
+            const n = i + 1;
+            return n === TARGET_LINE ? `line ${String(n)}: ${SENTINEL}` : `line ${String(n)}: filler`;
+        }).join('\n');
+        writeFileSync(bigFilePath, body);
+        try {
+            const res = await fetch(`http://localhost:${AGENT_PORT}/config/chat`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    message: `I just added a long file at knowledge/big-file.md. Tell me exactly what's on line ${String(TARGET_LINE)} — report the full line content verbatim. Just give me the line, no summary.`,
+                }),
+                signal: AbortSignal.timeout(TIMEOUT * 2),
+            });
+            const text = await res.text();
+            const events = parseSSE(text);
+            const toolStarts = findEvents(events, 'tool_call_start');
+            const toolNames = toolStarts.map((e) => String(e['tool_name']));
+            // The agent needs to touch the file — either read_repo_file or
+            // grep_repo_files would work to find the target line.
+            const touchedFile = toolNames.some((n) => n === 'read_repo_file' || n === 'grep_repo_files');
+            expect(touchedFile).toBe(true);
+            // If the agent used read_repo_file, at least one call must have
+            // specified an offset/limit that covers line 2800 (the default
+            // 2000-line window doesn't reach it, so the agent HAS to adapt).
+            const readCalls = toolStarts.filter((e) => e['tool_name'] === 'read_repo_file');
+            if (readCalls.length > 0) {
+                const usedPagination = readCalls.some((e) => {
+                    const params = e['parameters'];
+                    if (!params)
+                        return false;
+                    const offset = typeof params['offset'] === 'number' ? params['offset'] : 1;
+                    const limit = typeof params['limit'] === 'number' ? params['limit'] : 2000;
+                    // Covers line TARGET_LINE if offset <= TARGET_LINE AND
+                    // offset + limit - 1 >= TARGET_LINE.
+                    return offset <= TARGET_LINE && offset + limit - 1 >= TARGET_LINE;
+                });
+                expect(usedPagination).toBe(true);
+            }
+            // Hard assertion: the response contains the sentinel verbatim.
+            const responseText = allText(events);
+            expect(responseText).toContain(SENTINEL);
+        }
+        finally {
+            rmSync(bigFilePath, { force: true });
+        }
+    }, TIMEOUT * 2);
+    // Multi-chunk pagination: sentinels spread across a 5000-line file so no
+    // single default read (2000 lines) can cover all of them. Verifies the
+    // agent either (a) chains multiple reads following the truncated: true
+    // signal, or (b) uses grep. Either is acceptable — what matters is that
+    // the agent finds content past the default window.
+    it('admin agent finds content scattered across a long file via pagination or grep', async () => {
+        const bigFilePath = resolve(AGENT_DIR, 'knowledge', 'scatter.md');
+        const MARKER = 'MARKER-ZXCV9876';
+        const MARKER_LINES = [500, 2500, 4500];
+        const TOTAL_LINES = 5000;
+        const body = Array.from({ length: TOTAL_LINES }, (_, i) => {
+            const n = i + 1;
+            return MARKER_LINES.includes(n) ? `line ${String(n)}: ${MARKER}` : `line ${String(n)}: filler`;
+        }).join('\n');
+        writeFileSync(bigFilePath, body);
+        try {
+            const res = await fetch(`http://localhost:${AGENT_PORT}/config/chat`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    message: `Read knowledge/scatter.md and quote the exact content of line 500, line 2500, and line 4500 verbatim. Report each line's full text.`,
+                }),
+                signal: AbortSignal.timeout(TIMEOUT * 2),
+            });
+            const text = await res.text();
+            const events = parseSSE(text);
+            const toolStarts = findEvents(events, 'tool_call_start');
+            const toolNames = toolStarts.map((e) => String(e['tool_name']));
+            // Agent must have touched the file.
+            const touchedFile = toolNames.some((n) => n === 'read_repo_file' || n === 'grep_repo_files');
+            expect(touchedFile).toBe(true);
+            // If the agent committed to read-only discovery (no grep), verify at
+            // least one read_repo_file call reached past the default 2000-line
+            // cap — otherwise it couldn't have seen markers at lines 2500 or
+            // 4500. When grep is used first, pagination isn't required because
+            // the agent may have used read_repo_file only to confirm a line it
+            // already found via grep.
+            const usedGrep = toolNames.includes('grep_repo_files');
+            const readCalls = toolStarts.filter((e) => e['tool_name'] === 'read_repo_file');
+            if (readCalls.length > 0 && !usedGrep) {
+                const reachedPastCap = readCalls.some((e) => {
+                    const params = e['parameters'];
+                    if (!params)
+                        return false;
+                    const offset = typeof params['offset'] === 'number' ? params['offset'] : 1;
+                    const limit = typeof params['limit'] === 'number' ? params['limit'] : 2000;
+                    // A single read covers up to line_end = offset + limit - 1.
+                    return offset + limit - 1 > 2000;
+                });
+                expect(reachedPastCap).toBe(true);
+            }
+            // Hard assertion: final response identifies all three marker line
+            // numbers. LLMs paraphrase, so search the response for each number.
+            const responseText = allText(events);
+            for (const n of MARKER_LINES) {
+                expect(responseText).toContain(String(n));
+            }
+        }
+        finally {
+            rmSync(bigFilePath, { force: true });
+        }
+    }, TIMEOUT * 2);
     // -------------------------------------------------------------------------
     // 10. Write intent enforcement (G8)
     // -------------------------------------------------------------------------
@@ -372,6 +606,44 @@ describe.skipIf(!!skipReason)('smoke tests', () => {
         expect(mentionsAny).toBe(true);
     }, TIMEOUT * 3);
     // -------------------------------------------------------------------------
+    // 11e. Parallel tool calls — batched read-only execution
+    // -------------------------------------------------------------------------
+    it('batches parallel read-only tool calls in a single turn', async () => {
+        // Seed three distinct items with unique names so we can verify the
+        // model saw each result.
+        const seed = [
+            ['parallel-alpha', 'Alpha Marker'],
+            ['parallel-beta', 'Beta Marker'],
+            ['parallel-gamma', 'Gamma Marker'],
+        ];
+        const writes = await Promise.all(seed.map(([id, name]) => chat(`Write to test-items store: item_id="${id}", name="${name}", status="active".`)));
+        const allWritesOk = writes.every((w) => findEvents(w.events, 'tool_call_result').some((e) => e['status'] === 'success'));
+        if (!allWritesOk)
+            return; // seeding failed — skip
+        // Ask the model to fetch all three in parallel. Models sometimes split
+        // this across turns; when they emit a single-turn parallel batch we
+        // verify the runtime handled it correctly end-to-end.
+        const { events } = await chat('Fetch all three of these items from the test-items store in parallel ' +
+            'using three concurrent query_store tool calls (one per key): ' +
+            '"parallel-alpha", "parallel-beta", "parallel-gamma". Then list the name ' +
+            'field of each item in your response.');
+        const toolStarts = findEvents(events, 'tool_call_start');
+        const toolResults = findEvents(events, 'tool_call_result');
+        const queryStoreStarts = toolStarts.filter((e) => e['tool_name'] === 'query_store');
+        if (queryStoreStarts.length < 2) {
+            // eslint-disable-next-line no-console -- intentional test diagnostic
+            console.warn(`[smoke] Model emitted ${String(queryStoreStarts.length)} query_store call(s) — ` +
+                'parallel-batch path not exercised this run (LLM non-determinism)');
+            return;
+        }
+        // Every start must have a matching successful result — batching must
+        // not drop events or corrupt SSE ordering. (This is the assertion that
+        // actually exercises the batching code path; content coverage of the
+        // response is LLM-variable and not the batcher's job.)
+        const successResults = toolResults.filter((e) => e['status'] === 'success');
+        expect(successResults.length).toBeGreaterThanOrEqual(queryStoreStarts.length);
+    }, TIMEOUT * 3);
+    // -------------------------------------------------------------------------
     // 12. Concurrent sessions don't bleed context
     // -------------------------------------------------------------------------
     it('concurrent sessions are isolated', async () => {
@@ -558,9 +830,6 @@ describe.skipIf(!!skipReason)('smoke tests', () => {
     // 23. Sessions — listing and history
     // -------------------------------------------------------------------------
     it('sessions endpoint returns a sessions array', async () => {
-        // Chat sessions in local dev don't auto-populate the legacy session store
-        // used by /sessions (only automation runs do), so we just verify the
-        // endpoint returns the expected shape.
         const res = await fetch(`http://localhost:${AGENT_PORT}/sessions`, { signal: AbortSignal.timeout(5000) });
         const body = await res.json();
         expect(res.status).toBe(200);
@@ -570,6 +839,79 @@ describe.skipIf(!!skipReason)('smoke tests', () => {
         const res = await fetch(`http://localhost:${AGENT_PORT}/session/nonexistent-id`, { signal: AbortSignal.timeout(5000) });
         expect(res.status).toBe(404);
     });
+    it('persists chat session through full list/get/patch/delete lifecycle', async () => {
+        // Full dev-UI session history loop, all served from DrizzleSessionStore.
+        const { sessionId } = await chat('Say "ok" in one word.');
+        expect(sessionId).toBeTruthy();
+        // 1. Session appears in /sessions with the UI response shape
+        const listRes = await fetch(`http://localhost:${AGENT_PORT}/sessions`, { signal: AbortSignal.timeout(5000) });
+        const listBody = await listRes.json();
+        expect(listRes.status).toBe(200);
+        const found = listBody.sessions.find((s) => s['id'] === sessionId);
+        expect(found).toBeDefined();
+        if (!found)
+            throw new Error('unreachable');
+        expect(found['appId']).toBe('local');
+        expect(typeof found['summary']).toBe('string');
+        expect(String(found['summary']).length).toBeGreaterThan(0);
+        expect(typeof found['createdAt']).toBe('number');
+        expect(typeof found['lastAccessedAt']).toBe('number');
+        expect(found['automationName']).toBeUndefined();
+        // 2. /session/:id returns the conversation history
+        const getRes = await fetch(`http://localhost:${AGENT_PORT}/session/${sessionId}`, { signal: AbortSignal.timeout(5000) });
+        const getBody = await getRes.json();
+        expect(getRes.status).toBe(200);
+        expect(getBody.session_id).toBe(sessionId);
+        expect(getBody.messages.length).toBeGreaterThan(0);
+        expect(getBody.messages[0].role).toBe('user');
+        expect(getBody.messages[0].text).toContain('Say "ok"');
+        // 3. PATCH title updates metadata and is visible on subsequent list
+        const patchRes = await fetch(`http://localhost:${AGENT_PORT}/session/${sessionId}`, {
+            method: 'PATCH',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ title: 'smoke renamed' }),
+            signal: AbortSignal.timeout(5000),
+        });
+        expect(patchRes.status).toBe(200);
+        const list2Res = await fetch(`http://localhost:${AGENT_PORT}/sessions`, { signal: AbortSignal.timeout(5000) });
+        const list2Body = await list2Res.json();
+        const renamed = list2Body.sessions.find((s) => s['id'] === sessionId);
+        expect(renamed?.['title']).toBe('smoke renamed');
+        expect(renamed?.['summary']).toBe('smoke renamed');
+        // 4. DELETE removes the session, subsequent GET 404s
+        const delRes = await fetch(`http://localhost:${AGENT_PORT}/session/${sessionId}`, {
+            method: 'DELETE',
+            signal: AbortSignal.timeout(5000),
+        });
+        expect(delRes.status).toBe(200);
+        const getAfterDelRes = await fetch(`http://localhost:${AGENT_PORT}/session/${sessionId}`, { signal: AbortSignal.timeout(5000) });
+        expect(getAfterDelRes.status).toBe(404);
+    }, TIMEOUT);
+    it('preserves tool-call chips in /session/:id history', async () => {
+        // Tool calls appear as {type: 'tool-call'} parts in the assistant's
+        // ModelMessage.content — flattenModelMessage should surface them to
+        // the UI as toolCalls[]. Without this, the dev-UI chat history panel
+        // renders the assistant's reply but drops the tool-call chips.
+        const { sessionId } = await chat('Use the request tool to GET /items from the mock-api connection with intent "read".');
+        expect(sessionId).toBeTruthy();
+        const getRes = await fetch(`http://localhost:${AGENT_PORT}/session/${sessionId}`, { signal: AbortSignal.timeout(5000) });
+        const getBody = await getRes.json();
+        expect(getRes.status).toBe(200);
+        const assistantWithTools = getBody.messages.find((m) => m.role === 'assistant' && m.toolCalls && m.toolCalls.length > 0);
+        // Soft assertion: the model may choose not to call tools on any given
+        // turn (LLM non-determinism). When it does, the toolCall round-trip
+        // must work end-to-end.
+        if (assistantWithTools?.toolCalls) {
+            const call = assistantWithTools.toolCalls[0];
+            expect(call.toolId).toBeTruthy();
+            expect(call.toolName).toBeTruthy();
+            expect(typeof call.parameters).toBe('object');
+        }
+        else {
+            // eslint-disable-next-line no-console -- intentional test diagnostic
+            console.warn('[smoke] Model did not call a tool for the request prompt — LLM non-determinism, skipping toolCall round-trip assertion');
+        }
+    }, TIMEOUT);
     // -------------------------------------------------------------------------
     // 24. Files — browser and editor
     // -------------------------------------------------------------------------
@@ -699,6 +1041,268 @@ describe.skipIf(!!skipReason)('smoke tests', () => {
         });
         expect(res.status).toBe(400);
     });
+    // -------------------------------------------------------------------------
+    // Agent loop safety features (budget, done reason)
+    // -------------------------------------------------------------------------
+    it('done event carries reason=model_stop on normal completion', async () => {
+        const { events } = await chat('Reply with just the word "ok".');
+        expectDoneReason(events, 'model_stop');
+    });
+    it('max_session_tokens budget terminates the loop with reason=budget_exceeded', async () => {
+        // 200 tokens is well below what any single-turn + tool-call response
+        // will consume, so the budget check fires after the first turn.
+        const { events } = await chat('Echo these strings one at a time, calling echo_tool for each: alpha, bravo, charlie, delta, echo, foxtrot.', undefined, { maxSessionTokens: 200 });
+        expectDoneReason(events, 'budget_exceeded');
+        expectTotalTokens(events, { atLeast: 200 });
+    });
+    // -------------------------------------------------------------------------
+    // 25. Runtime event bus (/api/events SSE stream)
+    // -------------------------------------------------------------------------
+    it('emits session_created when a new chat session is created', async () => {
+        const stream = await openEventStream();
+        try {
+            const chatResult = await chat('Say "hi" and nothing else.');
+            const event = await stream.waitFor((e) => e['type'] === 'session_created' && e['sessionId'] === chatResult.sessionId, TIMEOUT);
+            expect(event['type']).toBe('session_created');
+            expect(event['sessionId']).toBe(chatResult.sessionId);
+            expect(event['seq']).toBeGreaterThan(0);
+            expect(typeof event['timestamp']).toBe('string');
+        }
+        finally {
+            stream.close();
+        }
+    }, TIMEOUT);
+    it('emits session_updated on follow-up messages in an existing session', async () => {
+        const first = await chat('Remember the number 7.');
+        const stream = await openEventStream();
+        try {
+            await chat('Reply with just "ok".', first.sessionId);
+            const event = await stream.waitFor((e) => e['type'] === 'session_updated' && e['sessionId'] === first.sessionId, TIMEOUT);
+            expect(event['type']).toBe('session_updated');
+            expect(event['sessionId']).toBe(first.sessionId);
+        }
+        finally {
+            stream.close();
+        }
+    }, TIMEOUT * 2);
+    it('emits session_deleted when a session is DELETEd', async () => {
+        const { sessionId } = await chat('Say "ok".');
+        const stream = await openEventStream();
+        try {
+            const res = await fetch(`http://localhost:${AGENT_PORT}/session/${sessionId}`, {
+                method: 'DELETE',
+                signal: AbortSignal.timeout(5000),
+            });
+            expect(res.status).toBe(200);
+            const event = await stream.waitFor((e) => e['type'] === 'session_deleted' && e['sessionId'] === sessionId, 5000);
+            expect(event['type']).toBe('session_deleted');
+            expect(event['sessionId']).toBe(sessionId);
+        }
+        finally {
+            stream.close();
+        }
+    }, TIMEOUT);
+    it('emits automation_triggered and automation_completed on manual run', async () => {
+        // The automation's registered name is derived from the filename
+        // (automations/test-auto.md → "test-auto"), not the frontmatter.
+        const automationName = 'test-auto';
+        const stream = await openEventStream();
+        try {
+            const runPromise = fetch(`http://localhost:${AGENT_PORT}/automations/${automationName}/run`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: '{}',
+                signal: AbortSignal.timeout(TIMEOUT),
+            });
+            const triggered = await stream.waitFor((e) => e['type'] === 'automation_triggered' && e['name'] === automationName, 5000);
+            expect(triggered['source']).toBeDefined();
+            const completed = await stream.waitFor((e) => (e['type'] === 'automation_completed' || e['type'] === 'automation_failed') &&
+                e['name'] === automationName, TIMEOUT);
+            expect(completed['type']).toBe('automation_completed');
+            expect(typeof completed['durationMs']).toBe('number');
+            const runRes = await runPromise;
+            expect([200, 500]).toContain(runRes.status);
+        }
+        finally {
+            stream.close();
+        }
+    }, TIMEOUT + 10_000);
+    it('delivers automation result via onAutomationResult callback (full chain)', async () => {
+        // This test verifies the full wiring:
+        //   automation runs → DeliveryRouter dispatches callback target →
+        //   LocalServerConfig.onAutomationResult fires with the payload.
+        //
+        // The delivery-callback-test automation has `delivery.targets: [{ type:
+        // 'callback' }]` with a template. When it completes, our onAutomationResult
+        // (configured in beforeAll) should receive the full DeliveryPayload.
+        const before = receivedAutomationResults.length;
+        const runRes = await fetch(`http://localhost:${AGENT_PORT}/automations/delivery-callback-test/run`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: '{}', signal: AbortSignal.timeout(TIMEOUT) });
+        expect([200, 500]).toContain(runRes.status);
+        // Poll briefly for the callback to fire (delivery happens after runMessage drains)
+        const deadline = Date.now() + 5000;
+        while (receivedAutomationResults.length === before && Date.now() < deadline) {
+            await new Promise((r) => setTimeout(r, 100));
+        }
+        expect(receivedAutomationResults.length).toBeGreaterThan(before);
+        const payload = receivedAutomationResults[receivedAutomationResults.length - 1];
+        expect(payload?.['automation']).toBe('delivery-callback-test');
+        expect(payload?.['status']).toBe('success');
+        // Template renders with {{automation}} built-in; {{count}} should come
+        // from the JSON result (soft-check since LLM output varies slightly).
+        const message = String(payload?.['message'] ?? '');
+        expect(message).toContain('delivery-callback-test');
+    }, TIMEOUT + 10_000);
+    it('replays buffered events via Last-Event-ID on reconnect', async () => {
+        // Produce at least one event, capture its seq, disconnect, reconnect
+        // with Last-Event-ID set to seq-1, and verify we get the event back.
+        const firstStream = await openEventStream();
+        let capturedSeq = 0;
+        try {
+            await chat('Say "ok".');
+            const event = await firstStream.waitFor((e) => e['type'] === 'session_created', TIMEOUT);
+            capturedSeq = Number(event['seq']);
+            expect(capturedSeq).toBeGreaterThan(0);
+        }
+        finally {
+            firstStream.close();
+        }
+        const replayStream = await openEventStream({ lastEventId: String(capturedSeq - 1) });
+        try {
+            const replayed = await replayStream.waitFor((e) => Number(e['seq']) === capturedSeq, 5000);
+            expect(Number(replayed['seq'])).toBe(capturedSeq);
+        }
+        finally {
+            replayStream.close();
+        }
+    }, TIMEOUT);
+    it('emits session_updated when title is PATCHed', async () => {
+        const { sessionId } = await chat('Say "ok".');
+        const stream = await openEventStream();
+        try {
+            const res = await fetch(`http://localhost:${AGENT_PORT}/session/${sessionId}`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ title: 'my renamed session' }),
+                signal: AbortSignal.timeout(5000),
+            });
+            expect(res.status).toBe(200);
+            const event = await stream.waitFor((e) => e['type'] === 'session_updated' && e['sessionId'] === sessionId && e['title'] === 'my renamed session', 5000);
+            expect(event['title']).toBe('my renamed session');
+        }
+        finally {
+            stream.close();
+        }
+    }, TIMEOUT);
+    it('emits store_updated when a tool writes to a store', async () => {
+        const stream = await openEventStream();
+        try {
+            // Ask the agent to write to test-items store. Agent non-determinism
+            // means it might not actually call the tool; we soft-check the event.
+            await chat('Write an item to the test-items store with id="evt-smoke-1" and name="smoke event test".');
+            const event = stream.events.find((e) => e['type'] === 'store_updated' && e['storeName'] === 'test-items');
+            if (event) {
+                expect(event['operation']).toBe('put');
+            }
+            else {
+                // Model may have chosen not to call the store tool — this test is
+                // soft (logged, not asserted) because it depends on LLM behavior.
+                // eslint-disable-next-line no-console -- intentional test diagnostic
+                console.warn('[smoke] store_updated not emitted — LLM may have declined to call store_write');
+            }
+        }
+        finally {
+            stream.close();
+        }
+    }, TIMEOUT);
+    it('emits store_updated when a direct REST write happens', async () => {
+        // This path doesn't depend on the LLM — assertable hard.
+        const stream = await openEventStream();
+        try {
+            const res = await fetch(`http://localhost:${AGENT_PORT}/api/stores/test-items`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ id: 'rest-smoke-1', name: 'direct rest write' }),
+                signal: AbortSignal.timeout(5000),
+            });
+            expect(res.status).toBe(201);
+            const event = await stream.waitFor((e) => e['type'] === 'store_updated' && e['storeName'] === 'test-items' && e['operation'] === 'put', 5000);
+            expect(event['operation']).toBe('put');
+        }
+        finally {
+            stream.close();
+        }
+    }, TIMEOUT);
+    it('emits automation_started and automation_stopped', async () => {
+        // The smoke agent's test-auto has no cron schedule, so start will fail.
+        // That's fine — we want to verify the happy path when a schedulable
+        // automation exists. Skip if none are available.
+        const listRes = await fetch(`http://localhost:${AGENT_PORT}/automations`);
+        const listBody = await listRes.json();
+        const schedulable = listBody.automations.find((a) => a.schedule);
+        if (!schedulable) {
+            return; // smoke agent has no scheduled automation — skip
+        }
+        const stream = await openEventStream();
+        try {
+            const startRes = await fetch(`http://localhost:${AGENT_PORT}/automations/${schedulable.name}/start`, { method: 'POST', signal: AbortSignal.timeout(5000) });
+            if (startRes.status !== 200)
+                return; // not a schedulable automation
+            const started = await stream.waitFor((e) => e['type'] === 'automation_started' && e['name'] === schedulable.name, 5000);
+            expect(typeof started['intervalMs']).toBe('number');
+            await fetch(`http://localhost:${AGENT_PORT}/automations/${schedulable.name}/stop`, { method: 'POST', signal: AbortSignal.timeout(5000) });
+            const stopped = await stream.waitFor((e) => e['type'] === 'automation_stopped' && e['name'] === schedulable.name, 5000);
+            expect(stopped['name']).toBe(schedulable.name);
+        }
+        finally {
+            stream.close();
+        }
+    }, TIMEOUT);
+    it('fans out the same event to all concurrent clients (two-tab case)', async () => {
+        // Two independent SSE connections — the "two browser tabs" scenario.
+        // Every event emitted by the server should reach BOTH clients with
+        // the same seq number.
+        const [s1, s2] = await Promise.all([openEventStream(), openEventStream()]);
+        try {
+            const chatResult = await chat('Say "ok".');
+            const [e1, e2] = await Promise.all([
+                s1.waitFor((e) => e['type'] === 'session_created' && e['sessionId'] === chatResult.sessionId, TIMEOUT),
+                s2.waitFor((e) => e['type'] === 'session_created' && e['sessionId'] === chatResult.sessionId, TIMEOUT),
+            ]);
+            // Same logical event reached both clients
+            expect(e1['seq']).toBe(e2['seq']);
+            expect(e1['timestamp']).toBe(e2['timestamp']);
+            expect(e1['sessionId']).toBe(e2['sessionId']);
+        }
+        finally {
+            s1.close();
+            s2.close();
+        }
+    }, TIMEOUT);
+    // -------------------------------------------------------------------------
+    // Web tools (web_search, fetch_url) — gated on GOOGLE_API_KEY.
+    //
+    // When the smoke target is Anthropic/OpenAI but GOOGLE_API_KEY is set,
+    // these tests exercise the cross-provider case: the main agent runs on
+    // one provider, but web_search routes through the dedicated Gemini
+    // backend. beforeAll injects the webTools config when the key is set.
+    // -------------------------------------------------------------------------
+    const hasGoogleKey = !!process.env['GOOGLE_API_KEY'];
+    it.skipIf(!hasGoogleKey)('web_search tool is invoked for a current-information question', async () => {
+        const { events } = await chat('Use the web_search tool to find an authoritative source for the current stable version of Node.js. Reply with just the version number.');
+        const toolStarts = findEvents(events, 'tool_call_start');
+        const toolResults = findEvents(events, 'tool_call_result');
+        const webSearchStart = toolStarts.find((e) => e['tool_name'] === 'web_search');
+        expect(webSearchStart).toBeDefined();
+        // The matching result for that tool_id should be a success.
+        const toolId = webSearchStart?.['tool_id'];
+        const webSearchResult = toolResults.find((e) => e['tool_id'] === toolId);
+        expect(webSearchResult).toBeDefined();
+        expect(webSearchResult?.['status']).toBe('success');
+        // The session should finish normally with text output.
+        const done = findEvent(events, 'done');
+        expect(done?.['reason']).toBe('model_stop');
+        expect(allText(events).length).toBeGreaterThan(0);
+    }, TIMEOUT);
 });
 // ---------------------------------------------------------------------------
 // SSE parser helper
@@ -715,4 +1319,86 @@ function parseSSE(text) {
     }
     return events;
 }
+async function openEventStream(options = {}) {
+    const controller = new AbortController();
+    const headers = { Accept: 'text/event-stream' };
+    if (options.lastEventId)
+        headers['Last-Event-ID'] = options.lastEventId;
+    const res = await fetch(`http://localhost:${AGENT_PORT}/api/events`, {
+        headers,
+        signal: controller.signal,
+    });
+    if (!res.body)
+        throw new Error('no response body from /api/events');
+    const events = [];
+    const waiters = [];
+    // Drain the stream in the background, parsing SSE frames. Push each event
+    // to the events array and notify any waiting predicates.
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let draining = true;
+    void (async () => {
+        try {
+            while (draining) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                let idx;
+                while ((idx = buffer.indexOf('\n\n')) !== -1) {
+                    const frame = buffer.slice(0, idx);
+                    buffer = buffer.slice(idx + 2);
+                    const dataLine = frame.split('\n').find((l) => l.startsWith('data: '));
+                    if (!dataLine)
+                        continue;
+                    try {
+                        const event = JSON.parse(dataLine.slice(6));
+                        events.push(event);
+                        // Notify any matching waiters (iterate a snapshot; matching
+                        // waiters are removed from the queue).
+                        for (let i = waiters.length - 1; i >= 0; i--) {
+                            const waiter = waiters[i];
+                            if (waiter && waiter.predicate(event)) {
+                                waiters.splice(i, 1);
+                                waiter.resolve(event);
+                            }
+                        }
+                    }
+                    catch { /* malformed frame */ }
+                }
+            }
+        }
+        catch { /* aborted or connection closed */ }
+    })();
+    return {
+        events,
+        waitFor(predicate, timeoutMs = 5000) {
+            // Check already-buffered events first
+            const already = events.find(predicate);
+            if (already)
+                return Promise.resolve(already);
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    const idx = waiters.findIndex((w) => w.predicate === predicate);
+                    if (idx !== -1)
+                        waiters.splice(idx, 1);
+                    reject(new Error(`waitFor timed out after ${String(timeoutMs)}ms`));
+                }, timeoutMs);
+                waiters.push({
+                    predicate,
+                    resolve: (event) => {
+                        clearTimeout(timer);
+                        resolve(event);
+                    },
+                });
+            });
+        },
+        close() {
+            draining = false;
+            controller.abort();
+            reader.cancel().catch(() => { });
+        },
+    };
+}
 //# sourceMappingURL=smoke.test.js.map