kimaki 0.25.0 → 0.26.0

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

@@ -4,7 +4,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { describe, expect, test } from 'vitest';
 import {} from './opencode-session-event-log.js';
-import { derivePendingPermissionRequests, getAssistantMessageIdsForLatestUserTurn, getDerivedSubagentSessions, getEventBufferSessionId, getCurrentTurnStartTime, getDerivedSubtaskIndex, getLatestAssistantMessageIdForLatestUserTurn, getLatestRunInfo, hasAssistantMessageCompletedBefore, doesLatestUserTurnHaveNaturalCompletion, isAssistantMessageInLatestUserTurn, isAssistantMessageNaturalCompletion, isSessionBusy, } from './event-stream-state.js';
+import { derivePendingPermissionRequests, getAssistantMessageIdsForLatestUserTurn, getDerivedSubagentSessions, getEventBufferSessionId, getCurrentTurnStartTime, getDerivedSubtaskIndex, getLatestAssistantMessageIdForLatestUserTurn, getLatestRunInfo, getLatestTurnTokenUsage, getIdleTokenUsageDelta, 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');
@@ -741,3 +741,439 @@ describe('real-session-footer-suppressed-on-pre-idle-interrupt', () => {
         })).toBe(true);
     });
 });
+describe('getLatestTurnTokenUsage', () => {
+    function userEvent({ sessionId, messageId, created, }) {
+        return eventEntry({
+            type: 'message.updated',
+            properties: {
+                sessionID: sessionId,
+                info: {
+                    id: messageId,
+                    sessionID: sessionId,
+                    role: 'user',
+                    time: { created },
+                    agent: 'build',
+                    model: {
+                        providerID: 'openai',
+                        modelID: 'gpt-5.3-codex',
+                    },
+                },
+            },
+        });
+    }
+    function assistantEvent({ sessionId, messageId, parentID, created, tokens, cost = 0, modelID = 'gpt-5.3-codex', providerID = 'openai', }) {
+        return eventEntry({
+            type: 'message.updated',
+            properties: {
+                sessionID: sessionId,
+                info: {
+                    id: messageId,
+                    sessionID: sessionId,
+                    role: 'assistant',
+                    time: { created, completed: created + 1 },
+                    parentID,
+                    modelID,
+                    providerID,
+                    mode: 'build',
+                    agent: 'build',
+                    path: { cwd: '/test', root: '/test' },
+                    cost,
+                    tokens,
+                    finish: 'stop',
+                },
+            },
+        });
+    }
+    test('sums latest snapshot per assistant message in the latest turn', () => {
+        const sessionId = 'ses_tokens';
+        const events = [
+            userEvent({ sessionId, messageId: 'msg_user_1', created: 1 }),
+            assistantEvent({
+                sessionId,
+                messageId: 'msg_asst_1',
+                parentID: 'msg_user_1',
+                created: 2,
+                tokens: {
+                    input: 0,
+                    output: 0,
+                    reasoning: 0,
+                    cache: { read: 0, write: 0 },
+                },
+            }),
+            assistantEvent({
+                sessionId,
+                messageId: 'msg_asst_1',
+                parentID: 'msg_user_1',
+                created: 2,
+                tokens: {
+                    input: 100,
+                    output: 20,
+                    reasoning: 5,
+                    cache: { read: 10, write: 2 },
+                },
+                cost: 1,
+            }),
+            assistantEvent({
+                sessionId,
+                messageId: 'msg_asst_2',
+                parentID: 'msg_user_1',
+                created: 3,
+                tokens: {
+                    input: 50,
+                    output: 8,
+                    reasoning: 1,
+                    cache: { read: 4, write: 0 },
+                },
+                cost: 2,
+            }),
+        ];
+        expect(getLatestTurnTokenUsage({ events, sessionId })).toEqual({
+            input: 150,
+            output: 28,
+            reasoning: 6,
+            cacheRead: 14,
+            cacheWrite: 2,
+            total: 200,
+            cost: 3,
+            model: 'gpt-5.3-codex',
+            providerID: 'openai',
+            assistantMessageCount: 2,
+            userMessageId: 'msg_user_1',
+        });
+    });
+    test('ignores previous-turn assistant messages', () => {
+        const sessionId = 'ses_tokens_turns';
+        const events = [
+            userEvent({ sessionId, messageId: 'msg_user_1', created: 1 }),
+            assistantEvent({
+                sessionId,
+                messageId: 'msg_asst_1',
+                parentID: 'msg_user_1',
+                created: 2,
+                tokens: {
+                    input: 1000,
+                    output: 100,
+                    reasoning: 0,
+                    cache: { read: 0, write: 0 },
+                },
+            }),
+            userEvent({ sessionId, messageId: 'msg_user_2', created: 3 }),
+            assistantEvent({
+                sessionId,
+                messageId: 'msg_asst_2',
+                parentID: 'msg_user_2',
+                created: 4,
+                tokens: {
+                    input: 7,
+                    output: 3,
+                    reasoning: 0,
+                    cache: { read: 0, write: 0 },
+                },
+                modelID: 'gemini-2.5-flash',
+                providerID: 'google',
+            }),
+        ];
+        expect(getLatestTurnTokenUsage({ events, sessionId })).toEqual({
+            input: 7,
+            output: 3,
+            reasoning: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            total: 10,
+            cost: 0,
+            model: 'gemini-2.5-flash',
+            providerID: 'google',
+            assistantMessageCount: 1,
+            userMessageId: 'msg_user_2',
+        });
+    });
+    test('returns zeros when the latest turn has no assistant tokens', () => {
+        const sessionId = 'ses_empty';
+        const events = [
+            userEvent({ sessionId, messageId: 'msg_user_1', created: 1 }),
+        ];
+        expect(getLatestTurnTokenUsage({ events, sessionId })).toEqual({
+            input: 0,
+            output: 0,
+            reasoning: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            total: 0,
+            cost: 0,
+            model: undefined,
+            providerID: undefined,
+            assistantMessageCount: 0,
+            userMessageId: 'msg_user_1',
+        });
+    });
+    test('real-session-task-normal uses the completed assistant snapshot', () => {
+        const events = loadFixture('real-session-task-normal.jsonl');
+        const sessionId = getSessionId(events);
+        expect(getLatestTurnTokenUsage({ events, sessionId })).toEqual({
+            input: 39025,
+            output: 0,
+            reasoning: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            total: 39025,
+            cost: 0,
+            model: 'gemini-2.5-flash',
+            providerID: 'cached-google-real-events',
+            assistantMessageCount: 1,
+            userMessageId: 'msg_cb9aae4c9001CxCOkoqgiXRsi1',
+        });
+    });
+    test('real-session-task-user-interruption sums both assistant steps', () => {
+        const events = loadFixture('real-session-task-user-interruption.jsonl');
+        const sessionId = getSessionId(events);
+        expect(getLatestTurnTokenUsage({ events, sessionId })).toEqual({
+            input: 82526,
+            output: 79,
+            reasoning: 115,
+            cacheRead: 0,
+            cacheWrite: 0,
+            total: 82720,
+            cost: 0,
+            model: 'gemini-2.5-flash',
+            providerID: 'cached-google-real-events',
+            assistantMessageCount: 2,
+            userMessageId: 'msg_cb9b0ba6c001i3YH7bGffdB6BF',
+        });
+    });
+    test('uses tokens.total when it differs from the component sum', () => {
+        const sessionId = 'ses_canonical_total';
+        const events = [
+            userEvent({ sessionId, messageId: 'msg_user_1', created: 1 }),
+            assistantEvent({
+                sessionId,
+                messageId: 'msg_asst_1',
+                parentID: 'msg_user_1',
+                created: 2,
+                tokens: {
+                    total: 47319,
+                    input: 1217,
+                    output: 278,
+                    reasoning: 54,
+                    cache: { read: 45824, write: 0 },
+                },
+            }),
+        ];
+        expect(getLatestTurnTokenUsage({ events, sessionId })).toMatchObject({
+            input: 1217,
+            output: 278,
+            reasoning: 54,
+            cacheRead: 45824,
+            cacheWrite: 0,
+            total: 47319,
+            assistantMessageCount: 1,
+        });
+    });
+    test('real-session-task-three-parallel-sleeps uses billed totals', () => {
+        const events = loadFixture('real-session-task-three-parallel-sleeps.jsonl');
+        const sessionId = getSessionId(events);
+        expect(getLatestTurnTokenUsage({ events, sessionId })).toMatchObject({
+            input: 47139,
+            output: 1093,
+            reasoning: 472,
+            cacheRead: 45824,
+            cacheWrite: 0,
+            total: 94056,
+            model: 'gpt-5.3-codex',
+            providerID: 'openai',
+            assistantMessageCount: 2,
+        });
+    });
+    test('returns empty when the session has no user message', () => {
+        const sessionId = 'ses_no_user';
+        const events = [
+            assistantEvent({
+                sessionId,
+                messageId: 'msg_asst_1',
+                parentID: 'msg_missing',
+                created: 2,
+                tokens: {
+                    input: 100,
+                    output: 10,
+                    reasoning: 0,
+                    cache: { read: 0, write: 0 },
+                },
+            }),
+        ];
+        expect(getLatestTurnTokenUsage({ events, sessionId })).toEqual({
+            input: 0,
+            output: 0,
+            reasoning: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            total: 0,
+            cost: 0,
+            model: undefined,
+            providerID: undefined,
+            assistantMessageCount: 0,
+            userMessageId: undefined,
+        });
+    });
+});
+describe('getIdleTokenUsageDelta', () => {
+    function idleEvent(sessionId) {
+        return eventEntry({
+            type: 'session.idle',
+            properties: { sessionID: sessionId },
+        });
+    }
+    test('emits the first idle snapshot and skips a later idle with the same tokens', () => {
+        const sessionId = 'ses_delta';
+        const events = [
+            eventEntry({
+                type: 'message.updated',
+                properties: {
+                    sessionID: sessionId,
+                    info: {
+                        id: 'msg_user_1',
+                        sessionID: sessionId,
+                        role: 'user',
+                        time: { created: 1 },
+                        agent: 'build',
+                        model: {
+                            providerID: 'openai',
+                            modelID: 'gpt-5.3-codex',
+                        },
+                    },
+                },
+            }),
+            eventEntry({
+                type: 'message.updated',
+                properties: {
+                    sessionID: sessionId,
+                    info: {
+                        id: 'msg_asst_1',
+                        sessionID: sessionId,
+                        role: 'assistant',
+                        time: { created: 2, completed: 3 },
+                        parentID: 'msg_user_1',
+                        modelID: 'gpt-5.3-codex',
+                        providerID: 'openai',
+                        mode: 'build',
+                        agent: 'build',
+                        path: { cwd: '/test', root: '/test' },
+                        cost: 0,
+                        tokens: {
+                            input: 10,
+                            output: 5,
+                            reasoning: 0,
+                            cache: { read: 0, write: 0 },
+                        },
+                        finish: 'stop',
+                    },
+                },
+            }),
+            idleEvent(sessionId),
+            idleEvent(sessionId),
+        ];
+        const firstIdleIndex = events.length - 2;
+        const secondIdleIndex = events.length - 1;
+        expect(getIdleTokenUsageDelta({
+            events,
+            sessionId,
+            idleEventIndex: firstIdleIndex,
+        })).toMatchObject({
+            total: 15,
+        });
+        expect(getIdleTokenUsageDelta({
+            events,
+            sessionId,
+            idleEventIndex: secondIdleIndex,
+        })).toBeUndefined();
+    });
+    test('emits the growth after an early idle that saw zero tokens', () => {
+        const sessionId = 'ses_late_tokens';
+        const events = [
+            eventEntry({
+                type: 'message.updated',
+                properties: {
+                    sessionID: sessionId,
+                    info: {
+                        id: 'msg_user_1',
+                        sessionID: sessionId,
+                        role: 'user',
+                        time: { created: 1 },
+                        agent: 'build',
+                        model: {
+                            providerID: 'openai',
+                            modelID: 'gpt-5.3-codex',
+                        },
+                    },
+                },
+            }),
+            eventEntry({
+                type: 'message.updated',
+                properties: {
+                    sessionID: sessionId,
+                    info: {
+                        id: 'msg_asst_1',
+                        sessionID: sessionId,
+                        role: 'assistant',
+                        time: { created: 2 },
+                        parentID: 'msg_user_1',
+                        modelID: 'gpt-5.3-codex',
+                        providerID: 'openai',
+                        mode: 'build',
+                        agent: 'build',
+                        path: { cwd: '/test', root: '/test' },
+                        cost: 0,
+                        tokens: {
+                            input: 0,
+                            output: 0,
+                            reasoning: 0,
+                            cache: { read: 0, write: 0 },
+                        },
+                    },
+                },
+            }),
+            idleEvent(sessionId),
+            eventEntry({
+                type: 'message.updated',
+                properties: {
+                    sessionID: sessionId,
+                    info: {
+                        id: 'msg_asst_1',
+                        sessionID: sessionId,
+                        role: 'assistant',
+                        time: { created: 2, completed: 4 },
+                        parentID: 'msg_user_1',
+                        modelID: 'gpt-5.3-codex',
+                        providerID: 'openai',
+                        mode: 'build',
+                        agent: 'build',
+                        path: { cwd: '/test', root: '/test' },
+                        cost: 0,
+                        tokens: {
+                            total: 20,
+                            input: 12,
+                            output: 8,
+                            reasoning: 3,
+                            cache: { read: 0, write: 0 },
+                        },
+                        finish: 'stop',
+                    },
+                },
+            }),
+            idleEvent(sessionId),
+        ];
+        expect(getIdleTokenUsageDelta({
+            events,
+            sessionId,
+            idleEventIndex: 2,
+        })).toBeUndefined();
+        expect(getIdleTokenUsageDelta({
+            events,
+            sessionId,
+            idleEventIndex: events.length - 1,
+        })).toMatchObject({
+            input: 12,
+            output: 8,
+            reasoning: 3,
+            total: 20,
+        });
+    });
+});

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

@@ -16,8 +16,8 @@ import { isAbortError } from '../utils.js';
 import { registerEventListener, unregisterEventListener, waitForGlobalEventListener, } from './global-event-listener.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { sendThreadMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, } from '../discord-utils.js';
-import { formatPart } from '../message-formatting.js';
-import { getChannelVerbosity, getPartMessageIds, getDb, setPartMessage, getThreadSession, setThreadSession, getThreadParentSessionId, setThreadParentSessionId, getThreadWorktreeOrWorkspace, setSessionAgent, clearSessionModel, getVariantCascade, setSessionStartSource, appendSessionEventsSinceLastTimestamp, getSessionEventSnapshot, } from '../database.js';
+import { formatPart, formatTaskToolTitle } from '../message-formatting.js';
+import { getChannelVerbosity, getPartMessageIds, getDb, setPartMessage, getThreadSession, setThreadSession, getThreadParentSessionId, setThreadParentSessionId, getThreadWorktreeOrWorkspace, setSessionAgent, clearSessionModel, getVariantCascade, setSessionStartSource, completeScheduledTaskRunsForSession, failScheduledTaskRunsForSession, startScheduledTaskRunSession, appendSessionEventsSinceLastTimestamp, getSessionEventSnapshot, } from '../database.js';
 import * as orm from 'drizzle-orm';
 import * as schema from '../schema.js';
 import { showPermissionButtons, addPermissionRequestToContext, arePatternsCoveredBy, pendingPermissionContexts, } from '../commands/permissions.js';
@@ -30,7 +30,7 @@ import { getDataDir } from '../config.js';
 import { trackEvent, } from '../analytics.js';
 import { resolveValidatedAgentPreference } from './agent-utils.js';
 import { appendOpencodeSessionEventLog, getOpencodeEventSessionId, isOpencodeSessionEventLogEnabled, } from './opencode-session-event-log.js';
-import { doesLatestUserTurnHaveNaturalCompletion, didQuestionQueueHandoffSinceLatestQuestionAsked, getAssistantMessageIdsForLatestUserTurn, getCurrentTurnStartTime, isSessionBusy, getLatestRunInfo, getDerivedSubtaskIndex, getDerivedSubtaskAgentType, getLatestAssistantMessageIdForLatestUserTurn, hasAssistantMessageCompletedBefore, isAssistantMessageInLatestUserTurn, isAssistantMessageNaturalCompletion, } from './event-stream-state.js';
+import { doesLatestUserTurnHaveNaturalCompletion, didQuestionQueueHandoffSinceLatestQuestionAsked, getAssistantMessageIdsForLatestUserTurn, getCurrentTurnStartTime, isSessionBusy, getLatestRunInfo, getIdleTokenUsageDelta, getDerivedSubtaskIndex, getDerivedSubtaskAgentType, getLatestAssistantMessageIdForLatestUserTurn, hasAssistantMessageCompletedBefore, isAssistantMessageInLatestUserTurn, isAssistantMessageNaturalCompletion, } from './event-stream-state.js';
 // Track multiple pending permissions per thread (keyed by permission ID).
 // OpenCode handles blocking/sequencing — we just need to track all pending
 // permissions to avoid duplicates and properly clean up on reply/teardown.
@@ -949,9 +949,20 @@ export class ThreadSessionRuntime {
                 await this.handlePartUpdated(event.properties.part);
                 break;
             case 'session.idle':
+                await completeScheduledTaskRunsForSession(event.properties.sessionID);
                 await this.handleSessionIdle(event.properties.sessionID);
                 break;
             case 'session.error':
+                if (event.properties.sessionID) {
+                    const sessionError = event.properties.error;
+                    const errorMessage = sessionError && typeof sessionError === 'object'
+                        ? String(sessionError.data?.message || sessionError.name || 'Session failed')
+                        : 'Session failed';
+                    await failScheduledTaskRunsForSession({
+                        sessionId: event.properties.sessionID,
+                        error: errorMessage,
+                    });
+                }
                 await this.handleSessionError(event.properties);
                 break;
             case 'permission.asked':
@@ -1433,6 +1444,35 @@ export class ThreadSessionRuntime {
             this.ensureTypingNow();
             return;
         }
+        if (part.type === 'tool' &&
+            part.tool === 'task' &&
+            !this.state?.sentPartIds.has(part.id)) {
+            const taskDisplay = formatTaskToolTitle(part);
+            if (taskDisplay && (await this.getVerbosity()) !== 'text_only') {
+                await this.flushBufferedParts({
+                    messageID: part.messageID,
+                    force: true,
+                    skipPartId: part.id,
+                });
+                threadState.updateThread(this.threadId, (t) => {
+                    const newIds = new Set(t.sentPartIds);
+                    newIds.add(part.id);
+                    return { ...t, sentPartIds: newIds };
+                });
+                const sendResult = await sendThreadMessage(this.thread, taskDisplay + '\n\n')
+                    .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
+                if (sendResult instanceof Error) {
+                    threadState.updateThread(this.threadId, (t) => {
+                        const newIds = new Set(t.sentPartIds);
+                        newIds.delete(part.id);
+                        return { ...t, sentPartIds: newIds };
+                    });
+                    discordLogger.error(`ERROR: Failed to send task part ${part.id}:`, sendResult);
+                    return;
+                }
+                await setPartMessage({ partId: part.id, messageId: sendResult.id, threadId: this.thread.id });
+            }
+        }
         if (part.type === 'tool' && part.state.status === 'running') {
             await this.flushBufferedParts({
                 messageID: part.messageID,
@@ -1440,40 +1480,6 @@ export class ThreadSessionRuntime {
                 skipPartId: part.id,
             });
             await this.sendPartMessage({ part });
-            // Track task tool spawning subtask sessions
-            if (part.tool === 'task' && !this.state?.sentPartIds.has(part.id)) {
-                const description = typeof part.state.input?.description === 'string'
-                    ? part.state.input.description
-                    : '';
-                const agent = typeof part.state.input?.subagent_type === 'string'
-                    ? part.state.input.subagent_type
-                    : 'task';
-                const childSessionId = typeof part.state.metadata?.sessionId === 'string'
-                    ? part.state.metadata.sessionId
-                    : '';
-                if (description && childSessionId) {
-                    if ((await this.getVerbosity()) !== 'text_only') {
-                        const taskDisplay = `┣ ${agent} **${description}**`;
-                        threadState.updateThread(this.threadId, (t) => {
-                            const newIds = new Set(t.sentPartIds);
-                            newIds.add(part.id);
-                            return { ...t, sentPartIds: newIds };
-                        });
-                        const sendResult = await sendThreadMessage(this.thread, taskDisplay + '\n\n')
-                            .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
-                        if (sendResult instanceof Error) {
-                            threadState.updateThread(this.threadId, (t) => {
-                                const newIds = new Set(t.sentPartIds);
-                                newIds.delete(part.id);
-                                return { ...t, sentPartIds: newIds };
-                            });
-                            discordLogger.error(`ERROR: Failed to send task part ${part.id}:`, sendResult);
-                            return;
-                        }
-                        await setPartMessage({ partId: part.id, messageId: sendResult.id, threadId: this.thread.id });
-                    }
-                }
-            }
             return;
         }
         // Action buttons tool handler
@@ -1637,7 +1643,47 @@ export class ThreadSessionRuntime {
         await setPartMessage({ partId: part.id, messageId: sendResult.id, threadId: this.thread.id });
         this.requestTypingRepulse();
     }
+    trackIdleTokenUsage(idleSessionId) {
+        let idleEventIndex;
+        for (let i = this.eventBuffer.length - 1; i >= 0; i--) {
+            const event = this.eventBuffer[i]?.event;
+            if (event?.type === 'session.idle' && event.properties.sessionID === idleSessionId) {
+                idleEventIndex = i;
+                break;
+            }
+        }
+        if (idleEventIndex === undefined) {
+            return;
+        }
+        const usage = getIdleTokenUsageDelta({
+            events: this.eventBuffer,
+            sessionId: idleSessionId,
+            idleEventIndex,
+        });
+        if (!usage) {
+            return;
+        }
+        const properties = {
+            tokens_input: usage.input,
+            tokens_output: usage.output,
+            tokens_reasoning: usage.reasoning,
+            tokens_cache_read: usage.cacheRead,
+            tokens_cache_write: usage.cacheWrite,
+            tokens_total: usage.total,
+            cost: usage.cost,
+            assistant_message_count: usage.assistantMessageCount,
+            is_subagent: Boolean(this.getSubtaskInfoForSession(idleSessionId)),
+        };
+        if (usage.model) {
+            properties.model = usage.model;
+        }
+        if (usage.providerID) {
+            properties.provider = usage.providerID;
+        }
+        trackEvent('tokens_used', properties);
+    }
     async handleSessionIdle(idleSessionId) {
+        this.trackIdleTokenUsage(idleSessionId);
         const sessionId = this.state?.sessionId;
         // ── Subtask idle ──────────────────────────────────────────
         const subtask = this.getSubtaskInfoForSession(idleSessionId);
@@ -2331,6 +2377,13 @@ export class ThreadSessionRuntime {
                 await cleanupOnError(`✗ OpenCode API error: ${errorMessage}`);
                 return;
             }
+            if (input.sessionStartSource?.scheduledTaskRunId) {
+                await startScheduledTaskRunSession({
+                    runId: input.sessionStartSource.scheduledTaskRunId,
+                    sessionId: session.id,
+                    projectDirectory: this.sdkDirectory,
+                });
+            }
             logger.log(`[INGRESS] promptAsync accepted by opencode queue sessionId=${session.id} threadId=${this.threadId}`);
             if (!input.noReply) {
                 trackTurnStarted({

package/dist/subagent-rate-limit-plugin.js

@@ -10,6 +10,9 @@ const RATE_LIMIT_TEXT_PATTERNS = [
     'retry after',
     'too many requests',
     'quota exceeded',
+    'balance exhausted',
+    'spending-limit',
+    'run out of credits',
 ];
 function isRateLimitText(text) {
     if (!text) {
@@ -66,7 +69,7 @@ function extractRateLimitReason(event) {
     }
     if (event.type === 'message.part.updated' && event.properties.part.type === 'retry') {
         const retryError = event.properties.part.error;
-        if (retryError.data.statusCode === 429) {
+        if (retryError.data.statusCode === 429 || retryError.data.statusCode === 402) {
             return retryError.data.message;
         }
         if (isRateLimitText(retryError.data.responseBody)) {
@@ -90,9 +93,17 @@ function extractRateLimitReason(event) {
     if (!apiError) {
         return undefined;
     }
-    if (apiError.statusCode === 429) {
+    if (apiError.statusCode === 429 || apiError.statusCode === 402) {
         return apiError.message;
     }
+    // xAI returns 403 with spending-limit or run out of credits text.
+    // Only treat 403 as a usage limit if the body matches specific patterns,
+    // not all 403s (which can be auth errors handled elsewhere).
+    if (apiError.statusCode === 403) {
+        const errorText = [apiError.message, apiError.responseBody].filter(Boolean).join(' ');
+        if (isRateLimitText(errorText))
+            return apiError.message;
+    }
     if (isRateLimitText(apiError.responseBody)) {
         return apiError.responseBody;
     }