kimaki 0.26.0 → 0.28.0

package/dist/session-handler/opencode-session-event-log.js

@@ -10,6 +10,34 @@ let eventLogWriteDisabled = false;
 export function isOpencodeSessionEventLogEnabled() {
     return process.env['KIMAKI_LOG_OPENCODE_SESSION_EVENTS'] === '1';
 }
+function sessionIdFromEventProperties(properties) {
+    if (!properties || typeof properties !== 'object') {
+        return undefined;
+    }
+    const sessionID = Reflect.get(properties, 'sessionID');
+    if (typeof sessionID === 'string') {
+        return sessionID;
+    }
+    const info = Reflect.get(properties, 'info');
+    if (info && typeof info === 'object') {
+        const id = Reflect.get(info, 'id');
+        if (typeof id === 'string') {
+            return id;
+        }
+        const infoSessionId = Reflect.get(info, 'sessionID');
+        if (typeof infoSessionId === 'string') {
+            return infoSessionId;
+        }
+    }
+    const part = Reflect.get(properties, 'part');
+    if (part && typeof part === 'object') {
+        const partSessionId = Reflect.get(part, 'sessionID');
+        if (typeof partSessionId === 'string') {
+            return partSessionId;
+        }
+    }
+    return undefined;
+}
 export function getOpencodeEventSessionId(event) {
     switch (event.type) {
         case 'message.updated':
@@ -34,7 +62,8 @@ export function getOpencodeEventSessionId(event) {
         case 'session.deleted':
             return event.properties.info.id;
         default:
-            return undefined;
+            // session.next.* and later SDK events put sessionID on properties.
+            return sessionIdFromEventProperties(event.properties);
     }
 }
 function sanitizeSessionIdForFilename(sessionId) {

package/dist/session-handler/thread-ingress.test.js

@@ -0,0 +1,41 @@
+// Unit tests for the per-thread Discord arrival FIFO.
+// /plan-agent and a follow-up message must keep Discord order.
+import { describe, expect, test } from 'vitest';
+import { reserveThreadIngress, runInThreadIngressSlot, waitForCurrentThreadIngress, } from './thread-session-runtime.js';
+describe('thread ingress FIFO', () => {
+    test('later waiters stay behind an unreleased earlier slot', async () => {
+        const first = reserveThreadIngress('thread-fifo');
+        const second = reserveThreadIngress('thread-fifo');
+        const order = [];
+        const firstWork = runInThreadIngressSlot(first, async () => {
+            await waitForCurrentThreadIngress();
+            order.push('first-write');
+            first.release();
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            order.push('first-work');
+        });
+        const secondWork = runInThreadIngressSlot(second, async () => {
+            await waitForCurrentThreadIngress();
+            order.push('second');
+            second.release();
+        });
+        await Promise.all([firstWork, secondWork]);
+        expect(order).toEqual(['first-write', 'second', 'first-work']);
+    });
+    test('runInThreadIngressSlot releases after a thrown callback', async () => {
+        const first = reserveThreadIngress('thread-fifo-throw');
+        const second = reserveThreadIngress('thread-fifo-throw');
+        const order = [];
+        const firstWork = runInThreadIngressSlot(first, async () => {
+            await waitForCurrentThreadIngress();
+            order.push('first');
+            throw new Error('boom');
+        }).catch(() => { });
+        const secondWork = runInThreadIngressSlot(second, async () => {
+            await waitForCurrentThreadIngress();
+            order.push('second');
+        });
+        await Promise.all([firstWork, secondWork]);
+        expect(order).toEqual(['first', 'second']);
+    });
+});

package/dist/session-handler/thread-runtime-state.js

@@ -71,6 +71,8 @@ export function setSessionUsername(threadId, username) {
     });
 }
 export function setSessionUserId(threadId, userId) {
+    if (!userId)
+        return;
     updateThread(threadId, (t) => {
         if (t.sessionUserId) {
             return t;

package/dist/session-handler/thread-session-runtime-summary.test.js

@@ -0,0 +1,121 @@
+import { describe, expect, test } from 'vitest';
+import { ThreadSessionRuntime } from './thread-session-runtime.js';
+function summaryMessageEvent({ sessionId, messageId, }) {
+    return {
+        id: `evt_${messageId}`,
+        type: 'message.updated',
+        properties: {
+            sessionID: sessionId,
+            info: {
+                id: messageId,
+                sessionID: sessionId,
+                role: 'assistant',
+                parentID: 'msg_user',
+                time: { created: 2, completed: 3 },
+                modelID: 'compaction-model',
+                providerID: 'test-provider',
+                mode: 'compaction',
+                agent: 'compaction',
+                path: { cwd: '/test', root: '/test' },
+                cost: 1,
+                tokens: {
+                    input: 10,
+                    output: 1,
+                    reasoning: 0,
+                    cache: { read: 0, write: 0 },
+                },
+                finish: 'stop',
+                summary: true,
+            },
+        },
+    };
+}
+function summaryTextPart({ sessionId, messageId, }) {
+    return {
+        id: `prt_${messageId}`,
+        sessionID: sessionId,
+        messageID: messageId,
+        type: 'text',
+        text: 'internal compaction summary must not reach Discord',
+        time: { start: 2, end: 3 },
+    };
+}
+describe('ThreadSessionRuntime compaction summary routing', () => {
+    test('drops summary message parts before fallback buffering or completion', async () => {
+        const sessionId = 'ses_main';
+        const messageId = 'msg_summary_embedded_parts';
+        const event = summaryMessageEvent({ sessionId, messageId });
+        if (event.type !== 'message.updated') {
+            throw new Error('Expected summary message event');
+        }
+        const message = {
+            ...event.properties.info,
+            parts: [summaryTextPart({ sessionId, messageId })],
+        };
+        const runtime = Object.create(ThreadSessionRuntime.prototype);
+        Object.defineProperty(runtime, 'state', {
+            value: { sessionId },
+            configurable: true,
+        });
+        runtime.eventBuffer = [{ event, timestamp: 1 }];
+        runtime.partBuffer = new Map();
+        runtime.flushBufferedParts = async () => {
+            throw new Error('Summary message must not flush parts');
+        };
+        runtime.handleNaturalAssistantCompletion = async () => {
+            throw new Error('Summary message must not complete the Discord turn');
+        };
+        await runtime.handleMessageUpdated(message);
+        expect(runtime.partBuffer.size).toBe(0);
+    });
+    test.each([
+        ['main session', 'ses_main'],
+        ['subagent session', 'ses_child'],
+    ])('preserves summary identity and drops %s parts before buffering', async (_, sessionId) => {
+        const messageId = `msg_summary_${sessionId}`;
+        const runtime = Object.create(ThreadSessionRuntime.prototype);
+        const compacted = runtime.compactEventForEventBuffer(summaryMessageEvent({ sessionId, messageId }));
+        expect(compacted?.type).toBe('message.updated');
+        if (!compacted || compacted.type !== 'message.updated') {
+            throw new Error('Expected compacted summary message event');
+        }
+        expect(compacted.properties.info.summary).toBe(true);
+        runtime.eventBuffer = [{ event: compacted, timestamp: 1 }];
+        runtime.partBuffer = new Map();
+        await runtime.handlePartUpdated(summaryTextPart({ sessionId, messageId }));
+        expect(runtime.partBuffer.size).toBe(0);
+    });
+    test.each([
+        ['main session', 'ses_main'],
+        ['subagent session', 'ses_child'],
+    ])('holds %s parts until summary identity arrives, then drops them', async (_, sessionId) => {
+        const messageId = `msg_summary_unknown_${sessionId}`;
+        const runtime = Object.create(ThreadSessionRuntime.prototype);
+        Object.defineProperty(runtime, 'state', {
+            value: { sessionId: 'ses_main' },
+            configurable: true,
+        });
+        runtime.eventBuffer = [];
+        runtime.partBuffer = new Map();
+        runtime.handleMainPart = async () => {
+            throw new Error('Unknown summary parts must not render');
+        };
+        runtime.handleSubtaskPart = async () => {
+            throw new Error('Unknown summary parts must not render');
+        };
+        runtime.flushBufferedParts = async () => {
+            throw new Error('Summary message must not flush parts');
+        };
+        runtime.handleNaturalAssistantCompletion = async () => {
+            throw new Error('Summary message must not complete the Discord turn');
+        };
+        await runtime.handlePartUpdated(summaryTextPart({ sessionId, messageId }));
+        expect(runtime.partBuffer.get(messageId)?.size).toBe(1);
+        const event = summaryMessageEvent({ sessionId, messageId });
+        if (event.type !== 'message.updated') {
+            throw new Error('Expected summary message event');
+        }
+        await runtime.handleMessageUpdated(event.properties.info);
+        expect(runtime.partBuffer.size).toBe(0);
+    });
+});