kimaki 0.4.103 → 0.4.104

package/dist/anthropic-auth-plugin.test.js

@@ -1,131 +1,109 @@
-// Tests for Anthropic OAuth multi-account persistence and rotation.
-import { mkdtemp, readFile, rm, mkdir, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, test } from 'vitest';
-import { authFilePath, loadAccountStore, rememberAnthropicOAuth, removeAccount, rotateAnthropicAccount, saveAccountStore, shouldRotateAuth, } from './anthropic-auth-state.js';
-const firstAccount = {
-    type: 'oauth',
-    refresh: 'refresh-first',
-    access: 'access-first',
-    expires: 1,
-};
-const secondAccount = {
-    type: 'oauth',
-    refresh: 'refresh-second',
-    access: 'access-second',
-    expires: 2,
-};
-let originalXdgDataHome;
-let tempDir = '';
-beforeEach(async () => {
-    originalXdgDataHome = process.env.XDG_DATA_HOME;
-    tempDir = await mkdtemp(path.join(tmpdir(), 'anthropic-auth-plugin-'));
-    process.env.XDG_DATA_HOME = tempDir;
-});
-afterEach(async () => {
-    if (originalXdgDataHome === undefined) {
-        delete process.env.XDG_DATA_HOME;
-    }
-    else {
-        process.env.XDG_DATA_HOME = originalXdgDataHome;
+// Tests Anthropic request-time prompt rewriting and transform fallback behavior.
+import { describe, expect, test } from 'vitest';
+import { replacer, rewriteAnthropicRequestPayload, } from './anthropic-auth-plugin.js';
+function parseRewrittenBody(body) {
+    if (!body) {
+        throw new Error('Expected rewritten body');
     }
-    await rm(tempDir, { force: true, recursive: true });
-});
-describe('rememberAnthropicOAuth', () => {
-    test('stores accounts and updates existing entries by refresh token', async () => {
-        await rememberAnthropicOAuth(firstAccount);
-        await rememberAnthropicOAuth({ ...firstAccount, access: 'access-first-new', expires: 3 });
-        const store = await loadAccountStore();
-        expect(store.activeIndex).toBe(0);
-        expect(store.accounts).toHaveLength(1);
-        expect(store.accounts[0]).toMatchObject({
-            refresh: 'refresh-first',
-            access: 'access-first-new',
-            expires: 3,
-        });
+    return JSON.parse(body);
+}
+describe('rewriteAnthropicRequestPayload', () => {
+    test('sanitizes raw opencode system text at request time', () => {
+        const rewritten = rewriteAnthropicRequestPayload(JSON.stringify({
+            model: 'claude-sonnet-4-5',
+            system: "You are OpenCode, the best coding agent on the planet.\nOS: macOS\nCWD: /repo\nSkills provide specialized instructions\nUse opencode tools carefully.",
+            tool_choice: { type: 'tool', name: 'read' },
+            tools: [{ name: 'read' }],
+        }));
+        const payload = parseRewrittenBody(rewritten.body);
+        expect(payload).toMatchInlineSnapshot(`
+      {
+        "model": "claude-sonnet-4-5",
+        "system": [
+          {
+            "text": "You are Claude Code, Anthropic's official CLI for Claude.",
+            "type": "text",
+          },
+          {
+            "text": "
+      <environment>
+      <cwd>/Users/morse/Documents/GitHub/kimakivoice/cli</cwd>
+      </environment>
+      Skills provide specialized instructions
+      Use openc0de tools carefully.",
+            "type": "text",
+          },
+        ],
+        "tool_choice": {
+          "name": "Read",
+          "type": "tool",
+        },
+        "tools": [
+          {
+            "name": "Read",
+          },
+        ],
+      }
+    `);
     });
-});
-describe('rotateAnthropicAccount', () => {
-    test('rotates to the next stored account and syncs auth state', async () => {
-        await saveAccountStore({
-            version: 1,
-            activeIndex: 0,
-            accounts: [
-                { ...firstAccount, addedAt: 1, lastUsed: 1 },
-                { ...secondAccount, addedAt: 2, lastUsed: 2 },
-            ],
-        });
-        const authSetCalls = [];
-        const client = {
-            auth: {
-                set: async (input) => {
-                    authSetCalls.push(input);
+    test('does not duplicate claude code identity when request was already sanitized', () => {
+        const rewritten = rewriteAnthropicRequestPayload(JSON.stringify({
+            model: 'claude-sonnet-4-5',
+            system: [
+                {
+                    type: 'text',
+                    text: "You are Claude Code, Anthropic's official CLI for Claude.",
                 },
-            },
-        };
-        const rotated = await rotateAnthropicAccount(firstAccount, client);
-        const store = await loadAccountStore();
-        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
-        expect(rotated).toMatchObject({
-            auth: { refresh: 'refresh-second' },
-            fromLabel: '#1 (refresh-...irst)',
-            toLabel: '#2 (refresh-...cond)',
-            fromIndex: 0,
-            toIndex: 1,
-        });
-        expect(store.activeIndex).toBe(1);
-        expect(authJson.anthropic?.refresh).toBe('refresh-second');
-        expect(authSetCalls).toEqual([
-            {
-                path: { id: 'anthropic' },
-                body: {
-                    type: 'oauth',
-                    refresh: 'refresh-second',
-                    access: 'access-second',
-                    expires: 2,
+                {
+                    type: 'text',
+                    text: '<environment>\n<cwd>/repo</cwd>\n</environment>\nSkills provide specialized instructions',
                 },
-            },
-        ]);
-    });
-});
-describe('removeAccount', () => {
-    test('removing the active account promotes the next stored account', async () => {
-        await saveAccountStore({
-            version: 1,
-            activeIndex: 1,
-            accounts: [
-                { ...firstAccount, addedAt: 1, lastUsed: 1 },
-                { ...secondAccount, addedAt: 2, lastUsed: 2 },
             ],
-        });
-        await removeAccount(1);
-        const store = await loadAccountStore();
-        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
-        expect(store.activeIndex).toBe(0);
-        expect(store.accounts).toHaveLength(1);
-        expect(store.accounts[0]?.refresh).toBe('refresh-first');
-        expect(authJson.anthropic?.refresh).toBe('refresh-first');
-    });
-    test('removing the last account clears active Anthropic auth', async () => {
-        await saveAccountStore({
-            version: 1,
-            activeIndex: 0,
-            accounts: [{ ...firstAccount, addedAt: 1, lastUsed: 1 }],
-        });
-        await mkdir(path.dirname(authFilePath()), { recursive: true });
-        await writeFile(authFilePath(), JSON.stringify({ anthropic: firstAccount }, null, 2));
-        await removeAccount(0);
-        const store = await loadAccountStore();
-        const authJson = JSON.parse(await readFile(authFilePath(), 'utf8'));
-        expect(store.accounts).toHaveLength(0);
-        expect(authJson.anthropic).toBeUndefined();
+        }));
+        const payload = parseRewrittenBody(rewritten.body);
+        expect(payload.system).toMatchInlineSnapshot(`
+      [
+        {
+          "text": "You are Claude Code, Anthropic's official CLI for Claude.",
+          "type": "text",
+        },
+        {
+          "text": "<environment>
+      <cwd>/repo</cwd>
+      </environment>
+      Skills provide specialized instructions",
+          "type": "text",
+        },
+      ]
+    `);
     });
 });
-describe('shouldRotateAuth', () => {
-    test('only rotates on rate limit or auth failures', () => {
-        expect(shouldRotateAuth(429, '')).toBe(true);
-        expect(shouldRotateAuth(401, 'permission_error')).toBe(true);
-        expect(shouldRotateAuth(400, 'bad request')).toBe(false);
+describe('replacer', () => {
+    test('sanitizes system text only for anthropic provider metadata', async () => {
+        const plugin = await replacer({});
+        const transform = plugin['experimental.chat.system.transform'];
+        if (!transform) {
+            throw new Error('Expected experimental.chat.system.transform hook');
+        }
+        const output = {
+            system: [
+                "You are OpenCode, the best coding agent on the planet.\nOS: macOS\nSkills provide specialized instructions\nUse opencode tools carefully.",
+            ],
+        };
+        await transform({
+            model: {
+                providerID: 'anthropic',
+            },
+        }, output);
+        expect(output.system).toMatchInlineSnapshot(`
+      [
+        "
+      <environment>
+      <cwd>/Users/morse/Documents/GitHub/kimakivoice/cli</cwd>
+      </environment>
+      Skills provide specialized instructions
+      Use openc0de tools carefully.",
+      ]
+    `);
     });
 });

package/dist/cli-parsing.test.js

@@ -1,84 +1,84 @@
 // Regression tests for CLI argument parsing around Discord ID string preservation.
 import { describe, expect, test } from 'vitest';
-import { goke } from 'goke';
-function createCliForIdParsing() {
-    const cli = goke('kimaki');
-    cli
-        .command('send', 'Send a message')
-        .option('-c, --channel <channelId>', 'Discord channel ID')
-        .option('--thread <threadId>', 'Thread ID')
-        .option('--session <sessionId>', 'Session ID')
-        .option('--send-at <schedule>', 'Schedule');
-    cli.command('session archive <threadId>', 'Archive a thread');
-    cli
-        .command('session search <query>', 'Search sessions')
-        .option('--channel <channelId>', 'Discord channel ID')
-        .option('--project <path>', 'Project path');
-    cli
-        .command('session export-events-jsonl', 'Export in-memory events to JSONL')
-        .option('--session <sessionId>', 'Session ID')
-        .option('--out <file>', 'Output path');
-    cli
-        .command('add-project', 'Add a project')
-        .option('-g, --guild <guildId>', 'Discord guild/server ID');
-    cli.command('task delete <id>', 'Delete task');
-    cli.command('anthropic-accounts list', 'List stored Anthropic accounts');
-    cli.command('anthropic-accounts remove <indexOrEmail>', 'Remove stored Anthropic account');
-    return cli;
+import { execAsync } from './exec-async.js';
+async function parseWithGoke(argv) {
+    const script = [
+        "import { goke } from 'goke'",
+        'const cli = goke(\'kimaki\')',
+        "cli.command('send', 'Send a message').option('-c, --channel <channelId>', 'Discord channel ID').option('--thread <threadId>', 'Thread ID').option('--session <sessionId>', 'Session ID').option('--send-at <schedule>', 'Schedule')",
+        "cli.command('session archive <threadId>', 'Archive a thread')",
+        "cli.command('session search <query>', 'Search sessions').option('--channel <channelId>', 'Discord channel ID').option('--project <path>', 'Project path')",
+        "cli.command('session export-events-jsonl', 'Export in-memory events to JSONL').option('--session <sessionId>', 'Session ID').option('--out <file>', 'Output path')",
+        "cli.command('add-project', 'Add a project').option('-g, --guild <guildId>', 'Discord guild/server ID')",
+        "cli.command('task delete <id>', 'Delete task')",
+        "cli.command('anthropic-accounts list', 'List stored Anthropic accounts')",
+        "cli.command('anthropic-accounts remove <indexOrEmail>', 'Remove stored Anthropic account')",
+        `const result = cli.parse(${JSON.stringify(argv)}, { run: false })`,
+        'process.stdout.write(JSON.stringify({ args: result.args, options: result.options }))',
+    ].join(';');
+    const { stdout } = await execAsync(`node --input-type=module -e ${JSON.stringify(script)}`, {
+        cwd: import.meta.dirname,
+        timeout: 10_000,
+    });
+    return JSON.parse(stdout);
+}
+async function getHelpOutput() {
+    const script = [
+        "import { goke } from 'goke'",
+        'const stdout = { text: \'\', write(data) { this.text += String(data) } }',
+        "const cli = goke('kimaki', { stdout })",
+        "cli.command('send', 'Send a message')",
+        "cli.command('anthropic-accounts list', 'List stored Anthropic accounts')",
+        'cli.help()',
+        "cli.parse(['node', 'kimaki', '--help'], { run: false })",
+        'process.stdout.write(stdout.text)',
+    ].join(';');
+    const { stdout } = await execAsync(`node --input-type=module -e ${JSON.stringify(script)}`, {
+        cwd: import.meta.dirname,
+        timeout: 10_000,
+    });
+    return stdout;
 }
 describe('goke CLI ID parsing', () => {
-    test('keeps large Discord IDs as strings', () => {
-        const cli = createCliForIdParsing();
+    test('keeps large Discord IDs as strings', async () => {
         const channelId = '1234567890123456789';
         const threadId = '9876543210987654321';
         const sessionId = '1111222233334444555';
-        const channelResult = cli.parse(['node', 'kimaki', 'send', '--channel', channelId], {
-            run: false,
-        });
+        const channelResult = await parseWithGoke(['node', 'kimaki', 'send', '--channel', channelId]);
         expect(channelResult.options.channel).toBe(channelId);
         expect(typeof channelResult.options.channel).toBe('string');
-        const threadResult = cli.parse(['node', 'kimaki', 'send', '--thread', threadId], { run: false });
+        const threadResult = await parseWithGoke(['node', 'kimaki', 'send', '--thread', threadId]);
         expect(threadResult.options.thread).toBe(threadId);
         expect(typeof threadResult.options.thread).toBe('string');
-        const sessionResult = cli.parse(['node', 'kimaki', 'send', '--session', sessionId], {
-            run: false,
-        });
+        const sessionResult = await parseWithGoke(['node', 'kimaki', 'send', '--session', sessionId]);
         expect(sessionResult.options.session).toBe(sessionId);
         expect(typeof sessionResult.options.session).toBe('string');
     });
-    test('preserves leading zeros in Discord IDs', () => {
-        const cli = createCliForIdParsing();
+    test('preserves leading zeros in Discord IDs', async () => {
         const guildId = '001230045600789';
-        const result = cli.parse(['node', 'kimaki', 'add-project', '--guild', guildId], { run: false });
+        const result = await parseWithGoke(['node', 'kimaki', 'add-project', '--guild', guildId]);
         expect(result.options.guild).toBe(guildId);
         expect(typeof result.options.guild).toBe('string');
     });
-    test('keeps session archive thread ID as string', () => {
-        const cli = createCliForIdParsing();
+    test('keeps session archive thread ID as string', async () => {
         const threadId = '0098765432109876543';
-        const result = cli.parse(['node', 'kimaki', 'session', 'archive', threadId], {
-            run: false,
-        });
+        const result = await parseWithGoke(['node', 'kimaki', 'session', 'archive', threadId]);
         expect(result.args[0]).toBe(threadId);
         expect(typeof result.args[0]).toBe('string');
     });
-    test('keeps session search regex and channel ID as strings', () => {
-        const cli = createCliForIdParsing();
+    test('keeps session search regex and channel ID as strings', async () => {
         const channelId = '0012345678901234567';
         const query = '/error\\s+42/i';
-        const result = cli.parse(['node', 'kimaki', 'session', 'search', query, '--channel', channelId], {
-            run: false,
-        });
+        const result = await parseWithGoke(['node', 'kimaki', 'session', 'search', query, '--channel', channelId]);
         expect(result.args[0]).toBe(query);
         expect(typeof result.args[0]).toBe('string');
         expect(result.options.channel).toBe(channelId);
         expect(typeof result.options.channel).toBe('string');
     });
-    test('keeps session export options as strings', () => {
-        const cli = createCliForIdParsing();
+    test('keeps session export options as strings', async () => {
         const sessionId = '001111222233334444';
         const outPath = './tmp/session-events.jsonl';
-        const result = cli.parse([
+        const result = await parseWithGoke([
             'node',
             'kimaki',
             'session',
@@ -87,54 +87,35 @@ describe('goke CLI ID parsing', () => {
             sessionId,
             '--out',
             outPath,
-        ], {
-            run: false,
-        });
+        ]);
         expect(result.options.session).toBe(sessionId);
         expect(typeof result.options.session).toBe('string');
         expect(result.options.out).toBe(outPath);
         expect(typeof result.options.out).toBe('string');
     });
-    test('keeps --send-at cron string intact', () => {
-        const cli = createCliForIdParsing();
+    test('keeps --send-at cron string intact', async () => {
         const cron = '0 9 * * 1';
-        const result = cli.parse(['node', 'kimaki', 'send', '--send-at', cron], {
-            run: false,
-        });
+        const result = await parseWithGoke(['node', 'kimaki', 'send', '--send-at', cron]);
         expect(result.options.sendAt).toBe(cron);
         expect(typeof result.options.sendAt).toBe('string');
     });
-    test('keeps task delete ID as string before validation', () => {
-        const cli = createCliForIdParsing();
+    test('keeps task delete ID as string before validation', async () => {
         const taskId = '0012345';
-        const result = cli.parse(['node', 'kimaki', 'task', 'delete', taskId], {
-            run: false,
-        });
+        const result = await parseWithGoke(['node', 'kimaki', 'task', 'delete', taskId]);
         expect(result.args[0]).toBe(taskId);
         expect(typeof result.args[0]).toBe('string');
     });
-    test('anthropic account remove parses index and email as strings', () => {
-        const cli = createCliForIdParsing();
-        const indexResult = cli.parse(['node', 'kimaki', 'anthropic-accounts', 'remove', '2'], { run: false });
-        const emailResult = cli.parse(['node', 'kimaki', 'anthropic-accounts', 'remove', 'user@example.com'], { run: false });
+    test('anthropic account remove parses index and email as strings', async () => {
+        const indexResult = await parseWithGoke(['node', 'kimaki', 'anthropic-accounts', 'remove', '2']);
+        const emailResult = await parseWithGoke(['node', 'kimaki', 'anthropic-accounts', 'remove', 'user@example.com']);
         expect(indexResult.args[0]).toBe('2');
         expect(typeof indexResult.args[0]).toBe('string');
         expect(emailResult.args[0]).toBe('user@example.com');
         expect(typeof emailResult.args[0]).toBe('string');
     });
-    test('anthropic account commands are included in help output', () => {
-        const stdout = {
-            text: '',
-            write(data) {
-                this.text += String(data);
-            },
-        };
-        const cli = goke('kimaki', { stdout: stdout });
-        cli.command('send', 'Send a message');
-        cli.command('anthropic-accounts list', 'List stored Anthropic accounts');
-        cli.help();
-        cli.parse(['node', 'kimaki', '--help'], { run: false });
-        expect(stdout.text).toContain('send');
-        expect(stdout.text).toContain('anthropic-accounts');
+    test('anthropic account commands are included in help output', async () => {
+        const stdout = await getHelpOutput();
+        expect(stdout).toContain('send');
+        expect(stdout).toContain('anthropic-accounts');
     });
 });

package/dist/queue-question-select-drain.e2e.test.js

@@ -89,7 +89,16 @@ describe('queue drain after question select answer', () => {
         if (!queueAck.messageId) {
             throw new Error('Expected /queue response message id');
         }
-        // 4. Answer the question via dropdown select (pick first option "Alpha")
+        // 4. The first queued item should be handed off immediately even while
+        //    the question is still pending, so the visible dispatch indicator
+        //    appears before the user answers the dropdown.
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: '» **question-select-tester:** Reply with exactly: post-question-drain',
+            timeout: 8_000,
+        });
+        // 5. Answer the question via dropdown select (pick first option "Alpha")
         const interaction = await th.user(TEST_USER_ID).selectMenu({
             messageId: questionMsg.id,
             customId: `ask_question:${pending.contextHash}:0`,
@@ -99,15 +108,6 @@ describe('queue drain after question select answer', () => {
             interactionId: interaction.id,
             timeout: 8_000,
         });
-        // 5. Queued message should be handed off to OpenCode's own prompt queue
-        //    after the question reply, so the dispatch indicator appears without
-        //    waiting for a later natural idle.
-        await waitForBotMessageContaining({
-            discord: ctx.discord,
-            threadId: thread.id,
-            text: '» **question-select-tester:** Reply with exactly: post-question-drain',
-            timeout: 8_000,
-        });
         // 6. Wait for footer from the drained queued message
         await waitForFooterMessage({
             discord: ctx.discord,
@@ -116,10 +116,21 @@ describe('queue drain after question select answer', () => {
             afterMessageIncludes: '» **question-select-tester:**',
             afterAuthorId: ctx.discord.botUserId,
         });
-        // Assert key invariants instead of exact snapshot — on CI the deterministic
-        // matcher can fire a second time after the drained message (rawPromptIncludes
-        // scans full history), adding an extra question to the timeline.
         const timeline = await th.text({ showInteractions: true });
+        expect(timeline).toMatchInlineSnapshot(`
+        "--- from: user (question-select-tester)
+        QUESTION_SELECT_QUEUE_MARKER
+        --- from: assistant (TestBot)
+        **Select action**
+        How to proceed?
+        ✓ _Alpha_
+        [user interaction]
+        » **question-select-tester:** Reply with exactly: post-question-drain
+        Queued message (position 1)
+        [user selects dropdown: 0]
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `);
         expect(timeline).toContain('QUESTION_SELECT_QUEUE_MARKER');
         expect(timeline).toContain('How to proceed?');
         expect(timeline).toContain('[user selects dropdown: 0]');
@@ -226,11 +237,11 @@ describe('queue drain after question select answer', () => {
         How to proceed?
         ✓ _Alpha_
         [user interaction]
+        » **question-select-tester:** SLOW_ABORT_MARKER run long response
         Queued message (position 1)
         [user interaction]
-        Queued message (position 2)
+        Queued message (position 1)
         [user selects dropdown: 0]
-        » **question-select-tester:** SLOW_ABORT_MARKER run long response
         ⬥ slow-response-started
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         » **question-select-tester:** Reply with exactly: post-question-second

package/dist/session-handler/event-stream-state.js

@@ -3,6 +3,12 @@
 // Zero imports from thread-session-runtime.ts, store.ts, or state.ts.
 // Only types from @opencode-ai/sdk/v2 and the getOpencodeEventSessionId helper.
 import { getOpencodeEventSessionId } from './opencode-session-event-log.js';
+export function getEventBufferSessionId(event) {
+    if (event.type === 'queue.question-handoff-started') {
+        return event.properties.sessionID;
+    }
+    return getOpencodeEventSessionId(event);
+}
 function getTaskChildSessionId({ part, }) {
     // Event-shape reference:
     // - cli/src/session-handler/event-stream-fixtures/real-session-task-three-parallel-sleeps.jsonl
@@ -51,7 +57,7 @@ export function isSessionBusy({ events, sessionId, upToIndex, }) {
             continue;
         }
         const e = entry.event;
-        const eid = getOpencodeEventSessionId(e);
+        const eid = getEventBufferSessionId(e);
         if (eid !== sessionId) {
             continue;
         }
@@ -64,6 +70,27 @@ export function isSessionBusy({ events, sessionId, upToIndex, }) {
     }
     return false;
 }
+export function didQuestionQueueHandoffSinceLatestQuestionAsked({ events, sessionId, upToIndex, }) {
+    const end = upToIndex ?? events.length - 1;
+    for (let i = end; i >= 0; i--) {
+        const entry = events[i];
+        if (!entry) {
+            continue;
+        }
+        const event = entry.event;
+        const eventSessionId = getEventBufferSessionId(event);
+        if (eventSessionId !== sessionId) {
+            continue;
+        }
+        if (event.type === 'queue.question-handoff-started') {
+            return true;
+        }
+        if (event.type === 'question.asked') {
+            return false;
+        }
+    }
+    return false;
+}
 export function isAssistantMessageNaturalCompletion({ message, }) {
     if (typeof message.time.completed !== 'number') {
         return false;

package/dist/session-handler/event-stream-state.test.js

@@ -3,8 +3,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { describe, expect, test } from 'vitest';
-import { getOpencodeEventSessionId, } from './opencode-session-event-log.js';
-import { getAssistantMessageIdsForLatestUserTurn, getCurrentTurnStartTime, getDerivedSubtaskIndex, getLatestAssistantMessageIdForLatestUserTurn, getLatestRunInfo, hasAssistantMessageCompletedBefore, doesLatestUserTurnHaveNaturalCompletion, isAssistantMessageInLatestUserTurn, isAssistantMessageNaturalCompletion, isSessionBusy, } from './event-stream-state.js';
+import {} from './opencode-session-event-log.js';
+import { getAssistantMessageIdsForLatestUserTurn, getEventBufferSessionId, getCurrentTurnStartTime, getDerivedSubtaskIndex, getLatestAssistantMessageIdForLatestUserTurn, getLatestRunInfo, hasAssistantMessageCompletedBefore, doesLatestUserTurnHaveNaturalCompletion, isAssistantMessageInLatestUserTurn, isAssistantMessageNaturalCompletion, isSessionBusy, } from './event-stream-state.js';
 const fixturesDir = path.join(import.meta.dirname, 'event-stream-fixtures');
 function loadFixture(filename) {
     const content = fs.readFileSync(path.join(fixturesDir, filename), 'utf8');
@@ -18,7 +18,7 @@ function loadFixture(filename) {
 }
 function getSessionId(events) {
     for (const entry of events) {
-        const sessionId = getOpencodeEventSessionId(entry.event);
+        const sessionId = getEventBufferSessionId(entry.event);
         if (sessionId) {
             return sessionId;
         }