kimaki 0.26.0 → 0.28.0

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

@@ -9,6 +9,50 @@ export function getEventBufferSessionId(event) {
     }
     return getOpencodeEventSessionId(event);
 }
+function isCompactionContinuePart(part) {
+    if (part.type !== 'text') {
+        return false;
+    }
+    return part.synthetic === true && part.metadata?.compaction_continue === true;
+}
+function isInternalOpenCodeUserMessageId({ events, sessionId, messageId, upToIndex, }) {
+    const end = upToIndex ?? events.length - 1;
+    for (let i = 0; i <= end; i++) {
+        const event = events[i]?.event;
+        if (event?.type !== 'message.part.updated') {
+            continue;
+        }
+        const part = event.properties.part;
+        if (part.sessionID !== sessionId || part.messageID !== messageId) {
+            continue;
+        }
+        if (part.type === 'compaction') {
+            return true;
+        }
+        if (isCompactionContinuePart(part)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isUserFacingAssistantMessage(message) {
+    return message.summary !== true;
+}
+export function getAssistantMessageKind({ events, sessionId, messageId, upToIndex, }) {
+    const end = upToIndex ?? events.length - 1;
+    for (let i = end; i >= 0; i--) {
+        const event = events[i]?.event;
+        if (event?.type !== 'message.updated') {
+            continue;
+        }
+        const info = event.properties.info;
+        if (info.sessionID !== sessionId || info.role !== 'assistant' || info.id !== messageId) {
+            continue;
+        }
+        return info.summary === true ? 'summary' : 'user-facing';
+    }
+    return 'unknown';
+}
 function getTaskChildSessionId({ part, }) {
     // Event-shape reference:
     // - cli/src/session-handler/event-stream-fixtures/real-session-task-three-parallel-sleeps.jsonl
@@ -93,6 +137,78 @@ export function didQuestionQueueHandoffSinceLatestQuestionAsked({ events, sessio
     }
     return false;
 }
+// OpenCode emits question.asked when the tool starts, often before the
+// preceding text part gets time.end. Discord must wait for that end event
+// or the question UI posts first and the text dumps later.
+export function isAssistantTextReadyForQuestion({ events, sessionId, messageId, upToIndex, }) {
+    const end = upToIndex ?? events.length - 1;
+    for (let i = end; i >= 0; i--) {
+        const event = events[i]?.event;
+        if (!event || event.type !== 'message.part.updated') {
+            continue;
+        }
+        const part = event.properties.part;
+        if (part.sessionID !== sessionId) {
+            continue;
+        }
+        if (part.messageID !== messageId) {
+            continue;
+        }
+        if (part.type !== 'text') {
+            continue;
+        }
+        return Boolean(part.time?.end);
+    }
+    return true;
+}
+export function deriveLatestUnansweredQuestion({ 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;
+        if (getEventBufferSessionId(event) !== sessionId) {
+            continue;
+        }
+        if (event.type === 'question.replied' || event.type === 'question.rejected') {
+            return undefined;
+        }
+        if (event.type === 'message.part.updated') {
+            const part = event.properties.part;
+            if (part.type === 'tool'
+                && part.tool === 'question'
+                && (part.state.status === 'error' || part.state.status === 'completed')) {
+                return undefined;
+            }
+        }
+        if (event.type === 'question.asked') {
+            const messageId = event.properties.tool?.messageID;
+            const latestUserMessage = getLatestUserMessage({
+                events,
+                sessionId,
+                upToIndex: end,
+            });
+            if (messageId
+                && latestUserMessage
+                && !isAssistantMessageInLatestUserTurn({
+                    events,
+                    sessionId,
+                    messageId,
+                    upToIndex: end,
+                })) {
+                return undefined;
+            }
+            return {
+                id: event.properties.id,
+                questions: event.properties.questions,
+                tool: event.properties.tool,
+            };
+        }
+    }
+    return undefined;
+}
 export function derivePendingPermissionRequests({ events, sessionId, }) {
     const permissions = new Set();
     for (const entry of events) {
@@ -112,6 +228,9 @@ export function derivePendingPermissionRequests({ events, sessionId, }) {
     return [...permissions];
 }
 export function isAssistantMessageNaturalCompletion({ message, }) {
+    if (!isUserFacingAssistantMessage(message)) {
+        return false;
+    }
     if (typeof message.time.completed !== 'number') {
         return false;
     }
@@ -162,6 +281,14 @@ export function getLatestUserMessage({ events, sessionId, upToIndex, }) {
         if (info.sessionID !== sessionId || info.role !== 'user') {
             continue;
         }
+        if (isInternalOpenCodeUserMessageId({
+            events,
+            sessionId,
+            messageId: info.id,
+            upToIndex: end,
+        })) {
+            continue;
+        }
         if (!latestUserMessage) {
             latestUserMessage = info;
             continue;
@@ -199,62 +326,118 @@ function emptyTurnTokenUsage() {
         userMessageId: undefined,
     };
 }
-// Latest billed token snapshot for the current user turn.
-// Sums the last message.updated tokens per assistant message id so streaming
-// updates are not double-counted. Scoped to sessionId so subagent idles
-// report their own usage.
-export function getLatestTurnTokenUsage({ events, sessionId, upToIndex, }) {
-    const latestUserMessage = getLatestUserMessage({
-        events,
-        sessionId,
-        upToIndex,
-    });
-    if (!latestUserMessage) {
-        return emptyTurnTokenUsage();
+function addAssistantTokens({ usage, message, }) {
+    if (message.tokens) {
+        usage.input += message.tokens.input;
+        usage.output += message.tokens.output;
+        usage.reasoning += message.tokens.reasoning;
+        usage.cacheRead += message.tokens.cache.read;
+        usage.cacheWrite += message.tokens.cache.write;
+        usage.total += message.tokens.total ?? getTokenTotal(message.tokens);
+    }
+    usage.cost += message.cost;
+    usage.model = message.modelID;
+    usage.providerID = message.providerID;
+}
+function sumAssistantMessages({ messages, userMessageId, }) {
+    if (messages.size === 0) {
+        return {
+            ...emptyTurnTokenUsage(),
+            userMessageId,
+        };
     }
-    const end = upToIndex ?? events.length - 1;
+    const usage = emptyTurnTokenUsage();
+    usage.userMessageId = userMessageId;
+    usage.assistantMessageCount = messages.size;
+    for (const message of messages.values()) {
+        addAssistantTokens({ usage, message });
+    }
+    return usage;
+}
+function collectAssistantMessages({ events, sessionId, upToIndex, parentID, }) {
     const latestByMessageId = new Map();
-    for (let i = 0; i <= end; i++) {
-        const entry = events[i];
-        if (!entry) {
-            continue;
-        }
-        const event = entry.event;
-        if (event.type !== 'message.updated') {
+    for (let i = 0; i <= upToIndex; i++) {
+        const event = events[i]?.event;
+        if (event?.type !== 'message.updated') {
             continue;
         }
         const info = event.properties.info;
         if (info.sessionID !== sessionId || info.role !== 'assistant') {
             continue;
         }
-        if (info.parentID !== latestUserMessage.id) {
+        if (parentID && info.parentID !== parentID) {
             continue;
         }
         latestByMessageId.set(info.id, info);
     }
-    if (latestByMessageId.size === 0) {
-        return {
-            ...emptyTurnTokenUsage(),
-            userMessageId: latestUserMessage?.id,
-        };
+    return latestByMessageId;
+}
+function getSessionInfoTokenUsage({ events, sessionId, upToIndex, }) {
+    for (let i = upToIndex; i >= 0; i--) {
+        const event = events[i]?.event;
+        if (event?.type !== 'session.updated' && event?.type !== 'session.created') {
+            continue;
+        }
+        const info = event.properties.info;
+        if (info.id !== sessionId) {
+            continue;
+        }
+        if (!info.tokens) {
+            continue;
+        }
+        const usage = emptyTurnTokenUsage();
+        usage.input = info.tokens.input;
+        usage.output = info.tokens.output;
+        usage.reasoning = info.tokens.reasoning;
+        usage.cacheRead = info.tokens.cache.read;
+        usage.cacheWrite = info.tokens.cache.write;
+        usage.total = getTokenTotal(info.tokens);
+        usage.cost = info.cost ?? 0;
+        usage.model = info.model?.id;
+        usage.providerID = info.model?.providerID;
+        return usage.total > 0 || usage.cost > 0 ? usage : undefined;
     }
-    const usage = emptyTurnTokenUsage();
-    usage.userMessageId = latestUserMessage.id;
-    usage.assistantMessageCount = latestByMessageId.size;
-    for (const message of latestByMessageId.values()) {
-        if (message.tokens) {
-            usage.input += message.tokens.input;
-            usage.output += message.tokens.output;
-            usage.reasoning += message.tokens.reasoning;
-            usage.cacheRead += message.tokens.cache.read;
-            usage.cacheWrite += message.tokens.cache.write;
-            usage.total += message.tokens.total ?? getTokenTotal(message.tokens);
-        }
-        usage.cost += message.cost;
-        usage.model = message.modelID;
-        usage.providerID = message.providerID;
+    return undefined;
+}
+// Latest billed token snapshot for the current user turn.
+// Sums the last message.updated tokens per assistant message id so streaming
+// updates are not double-counted. Scoped to sessionId so subagent idles
+// report their own usage. Child task sessions often have no user message in
+// the buffer; fall back to all assistant messages, then Session.tokens on
+// session.updated (OpenCode projects per-session usage there).
+export function getLatestTurnTokenUsage({ events, sessionId, upToIndex, }) {
+    const end = upToIndex ?? events.length - 1;
+    const latestUserMessage = getLatestUserMessage({
+        events,
+        sessionId,
+        upToIndex,
+    });
+    if (latestUserMessage) {
+        return sumAssistantMessages({
+            messages: collectAssistantMessages({
+                events,
+                sessionId,
+                upToIndex: end,
+                parentID: latestUserMessage.id,
+            }),
+            userMessageId: latestUserMessage.id,
+        });
     }
-    return usage;
+    const sessionAssistants = sumAssistantMessages({
+        messages: collectAssistantMessages({
+            events,
+            sessionId,
+            upToIndex: end,
+        }),
+    });
+    if (sessionAssistants.total > 0 || sessionAssistants.assistantMessageCount > 0) {
+        return sessionAssistants;
+    }
+    return getSessionInfoTokenUsage({
+        events,
+        sessionId,
+        upToIndex: end,
+    }) ?? emptyTurnTokenUsage();
 }
 function findFirstUserMessageIndex({ events, userMessageId, upToIndex, }) {
     for (let i = 0; i <= upToIndex; i++) {
@@ -292,24 +475,44 @@ function subtractTokenUsage({ current, previous, }) {
         userMessageId: current.userMessageId,
     };
 }
+function findFirstSessionEventIndex({ events, sessionId, upToIndex, }) {
+    for (let i = 0; i <= upToIndex; i++) {
+        const event = events[i]?.event;
+        if (!event) {
+            continue;
+        }
+        if (getEventBufferSessionId(event) === sessionId) {
+            return i;
+        }
+    }
+    return 0;
+}
 // Tokens billed since the previous session.idle in this user turn.
 // Survives process restart because both idles stay in the event buffer.
+// Child task sessions may have no user message.updated; scope from the first
+// event for that sessionId instead so their tokens still emit.
 export function getIdleTokenUsageDelta({ events, sessionId, idleEventIndex, }) {
     const current = getLatestTurnTokenUsage({
         events,
         sessionId,
         upToIndex: idleEventIndex,
     });
-    if (!current.userMessageId) {
+    if (current.total <= 0) {
         return undefined;
     }
-    const firstUserMessageIndex = findFirstUserMessageIndex({
-        events,
-        userMessageId: current.userMessageId,
-        upToIndex: idleEventIndex,
-    });
+    const firstUserMessageIndex = current.userMessageId
+        ? findFirstUserMessageIndex({
+            events,
+            userMessageId: current.userMessageId,
+            upToIndex: idleEventIndex,
+        })
+        : findFirstSessionEventIndex({
+            events,
+            sessionId,
+            upToIndex: idleEventIndex,
+        });
     if (firstUserMessageIndex === undefined) {
-        return undefined;
+        return current;
     }
     const previousIdleIndex = findPreviousIdleIndexInTurn({
         events,
@@ -318,7 +521,7 @@ export function getIdleTokenUsageDelta({ events, sessionId, idleEventIndex, }) {
         beforeIndex: idleEventIndex,
     });
     if (previousIdleIndex === undefined) {
-        return current.total > 0 ? current : undefined;
+        return current;
     }
     const previous = getLatestTurnTokenUsage({
         events,
@@ -354,6 +557,9 @@ export function getLatestRunInfo({ events, sessionId, upToIndex, }) {
         if (msg.sessionID !== sessionId || msg.role !== 'assistant') {
             continue;
         }
+        if (!isUserFacingAssistantMessage(msg)) {
+            continue;
+        }
         return {
             model: msg.modelID,
             providerID: msg.providerID,
@@ -389,12 +595,35 @@ export function getAssistantMessageIdsForLatestUserTurn({ events, sessionId, upT
         if (msg.sessionID !== sessionId || msg.role !== 'assistant') {
             continue;
         }
+        if (!isUserFacingAssistantMessage(msg)) {
+            continue;
+        }
         if (msg.parentID === latestUserMessage.id) {
             assistantMessageIds.add(msg.id);
         }
     }
     return assistantMessageIds;
 }
+export function didLatestUserTurnUseSleepTool({ events, sessionId, upToIndex, }) {
+    const assistantMessageIds = getAssistantMessageIdsForLatestUserTurn({
+        events,
+        sessionId,
+        upToIndex,
+    });
+    const end = upToIndex ?? events.length - 1;
+    for (let i = end; i >= 0; i--) {
+        const event = events[i]?.event;
+        if (event?.type !== 'message.part.updated')
+            continue;
+        const part = event.properties.part;
+        if (part.sessionID !== sessionId || part.type !== 'tool')
+            continue;
+        if (part.tool === 'kimaki_sleep' && assistantMessageIds.has(part.messageID)) {
+            return true;
+        }
+    }
+    return false;
+}
 export function getLatestAssistantMessageIdForLatestUserTurn({ events, sessionId, upToIndex, }) {
     const latestUserMessage = getLatestUserMessage({
         events,
@@ -419,6 +648,9 @@ export function getLatestAssistantMessageIdForLatestUserTurn({ events, sessionId
         if (info.sessionID !== sessionId || info.role !== 'assistant') {
             continue;
         }
+        if (!isUserFacingAssistantMessage(info)) {
+            continue;
+        }
         if (info.parentID !== latestUserMessage.id) {
             continue;
         }
@@ -549,6 +781,14 @@ export function isAssistantMessageInLatestUserTurn({ events, sessionId, messageI
     });
     return assistantMessageIds.has(messageId);
 }
+export function isSummaryAssistantMessage({ events, sessionId, messageId, upToIndex, }) {
+    return getAssistantMessageKind({
+        events,
+        sessionId,
+        messageId,
+        upToIndex,
+    }) === 'summary';
+}
 // Returns a stable 1-based subtask index for candidateSessionId.
 // Indexing scope is the parent assistant message that spawned the task tool calls,
 // so numbering restarts at 1 for each assistant message.
@@ -640,3 +880,104 @@ export function getDerivedSubagentSessions({ events, mainSessionId, upToIndex, }
     }
     return sessions;
 }
+function getParentIdFromSessionEvent(event) {
+    if (event.type !== 'session.created' && event.type !== 'session.updated') {
+        return undefined;
+    }
+    const parentID = event.properties.info.parentID;
+    if (typeof parentID !== 'string' || parentID.length === 0) {
+        return undefined;
+    }
+    return {
+        sessionId: event.properties.info.id,
+        parentID,
+    };
+}
+// Global SSE is broadcast to every thread. Buffer only this thread's session
+// plus its task/subagent children. /btw fork clones history onto a new
+// sessionId; those events must not evict the parent's latest-turn buffer.
+export function shouldBufferSessionEvent({ event, mainSessionId, isKnownChildSession, }) {
+    if (event.type === 'session.diff' || event.type.endsWith('.delta')) {
+        return false;
+    }
+    if (event.type === 'tui.toast.show') {
+        return true;
+    }
+    const eventSessionId = getEventBufferSessionId(event);
+    if (!eventSessionId) {
+        return true;
+    }
+    // A new /btw thread registers the SSE listener before ensureSession.
+    // Until the child session id is bound, drop every scoped event so the
+    // parent clone flood cannot fill this buffer first.
+    if (!mainSessionId) {
+        return false;
+    }
+    if (eventSessionId === mainSessionId) {
+        return true;
+    }
+    if (isKnownChildSession(eventSessionId)) {
+        return true;
+    }
+    const parented = getParentIdFromSessionEvent(event);
+    if (!parented) {
+        return false;
+    }
+    return parented.parentID === mainSessionId || isKnownChildSession(parented.parentID);
+}
+// Child sessions of the main thread: task tool metadata.sessionId, plus
+// session.created/updated parentID (available before task metadata lands).
+export function getDerivedChildSessionIds({ events, mainSessionId, upToIndex, }) {
+    const end = upToIndex ?? events.length - 1;
+    const ids = new Set();
+    for (const session of getDerivedSubagentSessions({
+        events,
+        mainSessionId,
+        upToIndex,
+    })) {
+        ids.add(session.childSessionId);
+    }
+    let grew = true;
+    while (grew) {
+        grew = false;
+        for (let i = 0; i <= end; i++) {
+            const event = events[i]?.event;
+            if (!event) {
+                continue;
+            }
+            const parented = getParentIdFromSessionEvent(event);
+            if (!parented || ids.has(parented.sessionId)) {
+                continue;
+            }
+            if (parented.parentID !== mainSessionId && !ids.has(parented.parentID)) {
+                continue;
+            }
+            ids.add(parented.sessionId);
+            grew = true;
+        }
+    }
+    return ids;
+}
+export function isDerivedChildSession({ events, mainSessionId, candidateSessionId, upToIndex, }) {
+    if (candidateSessionId === mainSessionId) {
+        return false;
+    }
+    return getDerivedChildSessionIds({
+        events,
+        mainSessionId,
+        upToIndex,
+    }).has(candidateSessionId);
+}
+export function getTokenUsageSessionIdsForIdle({ events, mainSessionId, idleSessionId, upToIndex, }) {
+    if (idleSessionId !== mainSessionId) {
+        return [idleSessionId];
+    }
+    return [
+        mainSessionId,
+        ...getDerivedChildSessionIds({
+            events,
+            mainSessionId,
+            upToIndex,
+        }),
+    ];
+}