@loicngr/kobo 1.6.14 → 1.7.0

package/dist/server/services/agent/engines/claude-code/engine.js

@@ -1,166 +1,271 @@
-import { spawn } from 'node:child_process';
-import readline from 'node:readline';
-import { buildClaudeArgs } from './args-builder.js';
+import { query, } from '@anthropic-ai/claude-agent-sdk';
+import { nanoid } from 'nanoid';
 import { CLAUDE_CODE_CAPABILITIES } from './capabilities.js';
-import { cleanupMcpConfig, writeMcpConfig } from './mcp-config.js';
-import { createParserState, parseClaudeLine } from './stream-parser.js';
+import { createMapperState, mapSdkMessage } from './event-mapper.js';
+import { buildClaudeOptions } from './options-builder.js';
+import { buildPreCompactCustomInstructions } from './precompact-hook.js';
+function toMcpServersMap(specs) {
+    if (!specs || specs.length === 0)
+        return undefined;
+    const map = {};
+    for (const s of specs) {
+        // `alwaysLoad: true` is required: without it, MCP tools sit behind the
+        // SDK's ToolSearch indirection that — even under bypassPermissions —
+        // surfaces a "haven't granted it yet" gate. With it, MCP tools behave
+        // like built-ins, matching pre-SDK CLI behaviour.
+        map[s.name] = { type: 'stdio', command: s.command, args: s.args, env: s.env, alwaysLoad: true };
+    }
+    return map;
+}
 export function createClaudeCodeEngine() {
     return {
         id: 'claude-code',
         displayName: 'Claude Code',
         capabilities: CLAUDE_CODE_CAPABILITIES,
         async start(options, onEvent) {
-            // Write MCP config if any servers requested + engine supports MCP
-            let mcpConfigPath;
-            if (options.mcpServers && options.mcpServers.length > 0) {
-                mcpConfigPath = writeMcpConfig(options.workingDir, options.mcpServers);
-            }
-            const { args } = buildClaudeArgs({
+            const abortController = new AbortController();
+            const mapperState = createMapperState();
+            // Pending canUseTool callbacks, keyed by SDK ctx.toolUseID.
+            const pendingResolvers = new Map();
+            const isInteractive = options.agentPermissionMode === 'interactive';
+            const canUseTool = (toolName, input, ctx) => {
+                const toolCallId = typeof ctx.toolUseID === 'string' && ctx.toolUseID.length > 0 ? ctx.toolUseID : `tu_${nanoid()}`;
+                // Non-interactive modes: the SDK has already applied its permissionMode
+                // rules before reaching us, so allow through unchanged. AskUserQuestion
+                // is the exception — it always defers to the user.
+                if (toolName !== 'AskUserQuestion' && !isInteractive) {
+                    return Promise.resolve({ behavior: 'allow', updatedInput: input });
+                }
+                const requestKind = toolName === 'AskUserQuestion' ? 'question' : 'permission';
+                return new Promise((resolve, reject) => {
+                    const resolver = { resolve, input, requestKind };
+                    pendingResolvers.set(toolCallId, resolver);
+                    const onAbort = () => {
+                        if (pendingResolvers.get(toolCallId) === resolver) {
+                            pendingResolvers.delete(toolCallId);
+                            const abortError = new Error('Pending user input aborted');
+                            abortError.name = 'AbortError';
+                            reject(abortError);
+                        }
+                    };
+                    if (ctx.signal.aborted) {
+                        onAbort();
+                        return;
+                    }
+                    ctx.signal.addEventListener('abort', onAbort, { once: true });
+                    onEvent({
+                        kind: 'session:user-input-requested',
+                        requestKind,
+                        toolCallId,
+                        toolName,
+                        payload: input,
+                    });
+                });
+            };
+            // PreCompact's hookSpecificOutput is missing from the SDK type union
+            // (SyncHookJSONOutput omits it), but the runtime accepts
+            // `additionalContext` as custom compaction instructions. Cast through
+            // `unknown` to satisfy the strict union.
+            const hooks = {
+                PreCompact: [
+                    {
+                        hooks: [
+                            async () => {
+                                const reminder = buildPreCompactCustomInstructions(options.workspaceId);
+                                if (!reminder)
+                                    return {};
+                                return {
+                                    hookSpecificOutput: {
+                                        hookEventName: 'PreCompact',
+                                        additionalContext: reminder,
+                                    },
+                                };
+                            },
+                        ],
+                    },
+                ],
+            };
+            const { options: sdkOptions, effectivePrompt } = buildClaudeOptions({
                 prompt: options.prompt,
                 model: options.model,
                 effort: options.effort,
-                permissionMode: options.permissionMode ?? 'auto-accept',
-                skipPermissions: options.settings.dangerouslySkipPermissions ?? true,
-                permissionProfile: options.permissionProfile,
+                agentPermissionMode: options.agentPermissionMode ?? 'bypass',
                 resumeFromEngineSessionId: options.resumeFromEngineSessionId,
-                mcpConfigPath,
-            });
-            const proc = spawn('claude', args, {
-                cwd: options.workingDir,
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            const parserState = createParserState();
-            if (!proc.stdout)
-                throw new Error('Claude process has no stdout');
-            const rl = readline.createInterface({
-                input: proc.stdout,
-                crlfDelay: Number.POSITIVE_INFINITY,
+                workingDir: options.workingDir,
+                mcpServers: toMcpServersMap(options.mcpServers),
+                hooks,
+                canUseTool,
+                stderr: (data) => {
+                    const lower = data.toLowerCase();
+                    if (lower.includes('rate limit exceeded') ||
+                        lower.includes('rate_limit_exceeded') ||
+                        (lower.includes('429') && lower.includes('rate')) ||
+                        lower.includes('quota exceeded')) {
+                        onEvent({ kind: 'error', category: 'quota', message: data });
+                    }
+                    else if (lower.includes('no conversation found with session id')) {
+                        onEvent({ kind: 'error', category: 'resume_failed', message: data });
+                    }
+                    else if (data.trim().length > 0) {
+                        console.warn(`[claude-engine stderr] ${data}`);
+                    }
+                },
             });
+            sdkOptions.abortController = abortController;
+            const q = query({ prompt: effectivePrompt, options: sdkOptions });
             let discoveredSessionId;
-            rl.on('line', (line) => {
-                const { events } = parseClaudeLine(line, parserState);
-                for (const ev of events) {
-                    if (ev.kind === 'session:started')
-                        discoveredSessionId = ev.engineSessionId;
+            // A throwing onEvent handler (e.g. DB query against a closed connection
+            // during async test teardown) must not escape as an unhandled rejection.
+            const safeEmit = (ev) => {
+                try {
                     onEvent(ev);
                 }
-            });
-            // Line-buffer stderr so we see one event per log line instead of
-            // arbitrary byte chunks, and restrict quota detection to clear rate-
-            // limit signals (not every occurrence of the word "rate" or "quota").
-            // Non-quota stderr lines are logged to the console but do NOT emit
-            // an error event — this avoids false positives flooding the UI.
-            const stderrRl = proc.stderr
-                ? readline.createInterface({
-                    input: proc.stderr,
-                    crlfDelay: Number.POSITIVE_INFINITY,
-                })
-                : undefined;
-            // Known benign stderr lines from the Claude CLI that should NOT be
-            // logged — they flood the dev console and carry no actionable info.
-            // Strip ANSI color codes before matching.
-            // biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escapes by design
-            const stripAnsi = (s) => s.replace(/\u001b\[\d+m/g, '');
-            function isBenignStderr(line) {
-                const cleaned = stripAnsi(line).trim();
-                return /^warning: no stdin data received in \d+s/i.test(cleaned);
-            }
-            stderrRl?.on('line', (line) => {
-                const lower = line.toLowerCase();
-                const isQuota = lower.includes('rate limit exceeded') ||
-                    lower.includes('rate_limit_exceeded') ||
-                    (lower.includes('429') && lower.includes('rate')) ||
-                    lower.includes('quota exceeded');
-                const isResumeFailed = lower.includes('no conversation found with session id');
-                if (isQuota) {
-                    onEvent({ kind: 'error', category: 'quota', message: line });
+                catch (err) {
+                    console.error('[claude-engine] onEvent handler threw:', err);
                 }
-                else if (isResumeFailed) {
-                    onEvent({ kind: 'error', category: 'resume_failed', message: line });
-                    console.warn(`[claude-engine stderr] ${line}`);
+            };
+            let iteratorRunning = false;
+            let userInterrupted = false;
+            const iteratorPromise = (async () => {
+                iteratorRunning = true;
+                try {
+                    for await (const msg of q) {
+                        const events = mapSdkMessage(msg, mapperState);
+                        for (const ev of events) {
+                            if (ev.kind === 'session:started')
+                                discoveredSessionId = ev.engineSessionId;
+                            safeEmit(ev);
+                        }
+                    }
+                    // If the SDK ended with a `result.subtype === 'error_*'`, the
+                    // event-mapper already surfaced an `error` event but the iterator
+                    // still terminated naturally. Reflect that in the session:ended
+                    // reason so the orchestrator transitions the workspace to `error`.
+                    safeEmit({
+                        kind: 'session:ended',
+                        reason: mapperState.sawErrorResult ? 'error' : 'completed',
+                        exitCode: mapperState.sawErrorResult ? null : 0,
+                    });
                 }
-                else if (line.trim().length > 0 && !isBenignStderr(line)) {
-                    console.warn(`[claude-engine stderr] ${line}`);
+                catch (err) {
+                    // Treat any abort we triggered (stop() → abortController.abort()) as
+                    // a clean kill. The SDK sometimes throws a generic Error with message
+                    // "Claude Code process aborted by user" instead of a typed AbortError.
+                    const error = err;
+                    const isAbort = userInterrupted ||
+                        error.name === 'AbortError' ||
+                        abortController.signal.aborted ||
+                        /aborted by user|process aborted|abortError|ede_diagnostic/i.test(error.message ?? '');
+                    if (isAbort) {
+                        safeEmit({ kind: 'session:ended', reason: 'killed', exitCode: null });
+                    }
+                    else {
+                        safeEmit({
+                            kind: 'error',
+                            category: 'spawn_failed',
+                            message: error.message,
+                        });
+                        safeEmit({ kind: 'session:ended', reason: 'error', exitCode: null });
+                    }
                 }
-            });
-            // 'error' fires when spawn itself fails (e.g. ENOENT if the `claude`
-            // binary is missing from PATH). In that case 'exit' never fires, so we
-            // emit the lifecycle pair here and clean the MCP config ourselves.
-            proc.on('error', (err) => {
-                onEvent({ kind: 'error', category: 'spawn_failed', message: err.message });
-                onEvent({ kind: 'session:ended', reason: 'error', exitCode: null });
-                cleanupMcpConfig(options.workingDir);
-                rl.close();
-                stderrRl?.close();
-            });
-            proc.on('exit', (code) => {
-                cleanupMcpConfig(options.workingDir);
-                rl.close();
-                stderrRl?.close();
-                onEvent({
-                    kind: 'session:ended',
-                    reason: code === 0 ? 'completed' : code === null ? 'killed' : 'error',
-                    exitCode: code,
-                });
-            });
+                finally {
+                    // Drain any callback still pending (SDK terminated while awaiting an
+                    // answer). canUseTool's abort path covers signalled stops; this
+                    // covers natural iterator completion.
+                    for (const resolver of pendingResolvers.values()) {
+                        try {
+                            resolver.resolve({ behavior: 'deny', message: 'session ended', interrupt: false });
+                        }
+                        catch {
+                            // best-effort
+                        }
+                    }
+                    pendingResolvers.clear();
+                    iteratorRunning = false;
+                }
+            })();
             const engineProcess = {
                 get pid() {
-                    return proc.pid;
+                    return undefined;
                 },
                 get engineSessionId() {
                     return discoveredSessionId;
                 },
-                sendMessage(text) {
-                    if (!proc.stdin?.writable)
-                        throw new Error('Agent stdin not writable');
-                    proc.stdin.write(`${text}\n`);
+                isAlive() {
+                    return iteratorRunning;
                 },
-                interrupt() {
-                    if (proc.pid !== undefined)
-                        process.kill(proc.pid, 'SIGINT');
+                sendMessage() {
+                    throw new Error('sendMessage not supported in single-shot SDK mode');
                 },
-                stop() {
-                    return new Promise((resolve) => {
-                        if (proc.killed || proc.exitCode !== null)
-                            return resolve();
-                        let resolved = false;
-                        let killTimer;
-                        let hardTimeout;
-                        const doResolve = () => {
-                            if (resolved)
-                                return;
-                            resolved = true;
-                            if (killTimer)
-                                clearTimeout(killTimer);
-                            if (hardTimeout)
-                                clearTimeout(hardTimeout);
-                            resolve();
-                        };
-                        proc.once('exit', doResolve);
+                interrupt() {
+                    userInterrupted = true;
+                    const qq = q;
+                    if (typeof qq.interrupt === 'function') {
                         try {
-                            proc.kill('SIGTERM');
+                            const r = qq.interrupt();
+                            if (r && typeof r.catch === 'function') {
+                                ;
+                                r.catch(() => {
+                                    /* ignore */
+                                });
+                            }
                         }
                         catch {
-                            // Already dead
+                            abortController.abort();
                         }
-                        killTimer = setTimeout(() => {
-                            try {
-                                if (!proc.killed)
-                                    proc.kill('SIGKILL');
-                            }
-                            catch {
-                                // Ignore
-                            }
-                        }, 5000);
-                        killTimer.unref?.();
-                        // Hard-timeout safety net: if the process hasn't exited within 10s
-                        // (5s after SIGKILL), resolve anyway so callers never hang forever.
-                        hardTimeout = setTimeout(() => {
-                            console.warn('[claude-engine] stop() hard-timeout reached, resolving anyway');
-                            doResolve();
-                        }, 10000);
-                        hardTimeout.unref?.();
+                    }
+                    else {
+                        abortController.abort();
+                    }
+                },
+                async stop() {
+                    abortController.abort();
+                    try {
+                        await iteratorPromise;
+                    }
+                    catch {
+                        // swallow — best effort
+                    }
+                },
+                resolvePendingUserInput(toolCallId, response) {
+                    const resolver = pendingResolvers.get(toolCallId);
+                    if (!resolver)
+                        return false;
+                    pendingResolvers.delete(toolCallId);
+                    if (response.kind === 'question') {
+                        // Echo the original questions array + answers so the SDK
+                        // reconstructs the AskUserQuestion tool input.
+                        const original = resolver.input;
+                        const questions = original.questions;
+                        resolver.resolve({
+                            behavior: 'allow',
+                            updatedInput: {
+                                ...(typeof questions !== 'undefined' ? { questions } : {}),
+                                answers: response.answers,
+                            },
+                        });
+                        return true;
+                    }
+                    if (response.kind === 'question-cancel') {
+                        // Deny so the agent gets an error tool_result and can adapt.
+                        resolver.resolve({
+                            behavior: 'deny',
+                            message: response.reason ?? 'User cancelled the question',
+                            interrupt: false,
+                        });
+                        return true;
+                    }
+                    if (response.kind === 'permission-allow') {
+                        resolver.resolve({ behavior: 'allow', updatedInput: resolver.input });
+                        return true;
+                    }
+                    // permission-deny
+                    resolver.resolve({
+                        behavior: 'deny',
+                        message: response.reason ?? 'denied by user',
+                        interrupt: false,
                     });
+                    return true;
                 },
             };
             return engineProcess;

package/dist/server/services/agent/engines/claude-code/event-mapper.js

@@ -0,0 +1,234 @@
+// ── Helpers ───────────────────────────────────────────────────────────────────
+// `rate_limit_info` is shaped for claude.ai subscriptions and may evolve.
+// Keep the defensive normalisation so a schema bump doesn't drop bucket info.
+function normalizeResetsAt(raw) {
+    if (typeof raw === 'string' && raw.length > 0)
+        return raw;
+    if (typeof raw === 'number' && Number.isFinite(raw))
+        return new Date(raw * 1000).toISOString();
+    return undefined;
+}
+function extractUsedPct(source) {
+    const raw = (source.utilization ?? source.used_percent ?? source.percent_used ?? source.usedPct);
+    if (typeof raw === 'number' && Number.isFinite(raw))
+        return raw <= 1 ? raw * 100 : raw;
+    const used = source.used ?? source.current ?? source.spent;
+    const limit = source.limit ?? source.max ?? source.allowed;
+    if (typeof used === 'number' && typeof limit === 'number' && limit > 0)
+        return (used / limit) * 100;
+    return null;
+}
+function makeBucket(id, source) {
+    const usedPct = extractUsedPct(source) ?? source.__fallbackPct ?? null;
+    if (usedPct === null)
+        return null;
+    const resetsAt = normalizeResetsAt(source.resets_at ?? source.reset_at ?? source.resetsAt ?? source.resetAt);
+    const label = (typeof source.label === 'string' && source.label) || undefined;
+    const used = source.used ?? source.current ?? source.spent;
+    const limit = source.limit ?? source.max ?? source.allowed;
+    const details = used !== undefined && limit !== undefined ? `${String(used)} / ${String(limit)}` : undefined;
+    return { id, label, usedPct: Math.max(0, Math.min(100, usedPct)), resetsAt, details };
+}
+function normalizeRateLimitInfo(info) {
+    const buckets = [];
+    if (typeof info.rateLimitType === 'string') {
+        const b = makeBucket(info.rateLimitType, { ...info, __fallbackPct: 0 });
+        if (b)
+            buckets.push(b);
+    }
+    if (Array.isArray(info.buckets)) {
+        for (const entry of info.buckets) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const obj = entry;
+            const id = (typeof obj.id === 'string' && obj.id) ||
+                (typeof obj.name === 'string' && obj.name) ||
+                (typeof obj.rateLimitType === 'string' && obj.rateLimitType) ||
+                'unknown';
+            const b = makeBucket(id, obj);
+            if (b)
+                buckets.push(b);
+        }
+    }
+    return { buckets };
+}
+export function createMapperState() {
+    return { sessionStartedEmitted: false, openMessages: new Map(), sawErrorResult: false };
+}
+/** Known SDK `result` subtypes that indicate the run failed. */
+const KNOWN_ERROR_RESULT_SUBTYPES = new Set(['error_max_turns', 'error_during_execution']);
+function isErrorResultSubtype(subtype) {
+    if (!subtype)
+        return false;
+    if (KNOWN_ERROR_RESULT_SUBTYPES.has(subtype))
+        return true;
+    return subtype.startsWith('error');
+}
+/**
+ * Maps a single typed `SDKMessage` to zero or more `AgentEvent`s, mutating
+ * `state` as needed.
+ */
+export function mapSdkMessage(msg, state) {
+    // Treat as a generic record — the SDK discriminated union is too broad to
+    // narrow per branch here.
+    const parsed = msg;
+    const type = parsed.type;
+    const subtype = parsed.subtype;
+    const sessionId = typeof parsed.session_id === 'string' ? parsed.session_id : undefined;
+    const events = [];
+    // Rate-limit events are top-level in the SDK (no longer nested under `system`).
+    if (type === 'rate_limit_event') {
+        const info = parsed.rate_limit_info;
+        if (info && typeof info === 'object') {
+            events.push({ kind: 'rate_limit', info: normalizeRateLimitInfo(info) });
+        }
+        return events;
+    }
+    if (type === 'system') {
+        if (subtype === 'compact' || subtype === 'compact_boundary') {
+            events.push({ kind: 'session:compacted' });
+            return events;
+        }
+        if (subtype === 'task_started' || subtype === 'task_progress' || subtype === 'task_notification') {
+            const toolCallId = typeof parsed.tool_use_id === 'string' ? parsed.tool_use_id : undefined;
+            if (toolCallId) {
+                const usage = parsed.usage;
+                const taskStatus = typeof parsed.status === 'string' ? parsed.status : undefined;
+                const isDone = subtype === 'task_notification' &&
+                    taskStatus !== undefined &&
+                    ['completed', 'stopped', 'failed', 'cancelled'].includes(taskStatus);
+                events.push({
+                    kind: 'subagent:progress',
+                    toolCallId,
+                    status: isDone ? 'done' : 'running',
+                    description: typeof parsed.description === 'string' ? parsed.description : undefined,
+                    taskType: typeof parsed.task_type === 'string' ? parsed.task_type : undefined,
+                    lastToolName: typeof parsed.last_tool_name === 'string' ? parsed.last_tool_name : undefined,
+                    totalTokens: typeof usage?.total_tokens === 'number' ? usage.total_tokens : undefined,
+                    toolUses: typeof usage?.tool_uses === 'number' ? usage.tool_uses : undefined,
+                    durationMs: typeof usage?.duration_ms === 'number' ? usage.duration_ms : undefined,
+                });
+            }
+            return events;
+        }
+        if (subtype === 'init') {
+            if (sessionId && (!state.sessionStartedEmitted || state.sessionId !== sessionId)) {
+                events.push({
+                    kind: 'session:started',
+                    engineSessionId: sessionId,
+                    model: typeof parsed.model === 'string' ? parsed.model : undefined,
+                });
+                state.sessionStartedEmitted = true;
+                state.sessionId = sessionId;
+            }
+            if (Array.isArray(parsed.slash_commands) && parsed.slash_commands.length > 0) {
+                events.push({ kind: 'skills:discovered', skills: parsed.slash_commands });
+            }
+            return events;
+        }
+        return events;
+    }
+    if (type === 'assistant') {
+        const message = parsed.message;
+        const messageId = typeof message?.id === 'string' ? message.id : 'unknown';
+        const content = Array.isArray(message?.content) ? message?.content : [];
+        // SDK runs sometimes finish implicitly when the next turn begins. Close
+        // stale openMessages so the UI's streaming spinner doesn't hang.
+        for (const openId of Array.from(state.openMessages.keys())) {
+            if (openId !== messageId) {
+                events.push({ kind: 'message:end', messageId: openId });
+                state.openMessages.delete(openId);
+            }
+        }
+        if (!state.openMessages.has(messageId)) {
+            state.openMessages.set(messageId, { sawText: false });
+        }
+        const msgState = state.openMessages.get(messageId);
+        if (!msgState)
+            return events;
+        for (const block of content) {
+            const blockType = block.type;
+            if (blockType === 'text' && typeof block.text === 'string') {
+                events.push({ kind: 'message:text', messageId, text: block.text, streaming: true });
+                msgState.sawText = true;
+                if (block.text.includes('[BRAINSTORM_COMPLETE]')) {
+                    events.push({ kind: 'session:brainstorm-complete' });
+                }
+            }
+            if (blockType === 'tool_use') {
+                events.push({
+                    kind: 'tool:call',
+                    messageId,
+                    toolCallId: typeof block.id === 'string' ? block.id : 'unknown',
+                    name: typeof block.name === 'string' ? block.name : 'unknown',
+                    input: block.input ?? {},
+                });
+            }
+            if (blockType === 'thinking') {
+                events.push({
+                    kind: 'message:thinking',
+                    messageId,
+                    text: typeof block.thinking === 'string' ? block.thinking : '',
+                });
+            }
+        }
+        // Only terminal turns carry non-null `stop_reason`; intermediate deltas
+        // have `null` and must NOT trigger message:end.
+        const stopReason = message?.stop_reason;
+        const isStop = parsed.message_stop === true || (stopReason !== undefined && stopReason !== null);
+        if (isStop) {
+            events.push({ kind: 'message:end', messageId });
+            state.openMessages.delete(messageId);
+        }
+        return events;
+    }
+    if (type === 'user') {
+        const message = parsed.message;
+        const content = Array.isArray(message?.content) ? message?.content : [];
+        for (const block of content) {
+            if (block.type === 'tool_result') {
+                events.push({
+                    kind: 'tool:result',
+                    toolCallId: typeof block.tool_use_id === 'string' ? block.tool_use_id : 'unknown',
+                    output: block.content ?? null,
+                    isError: block.is_error === true,
+                });
+            }
+        }
+        return events;
+    }
+    if (type === 'result') {
+        // Terminal event — close any still-streaming messages.
+        for (const openId of Array.from(state.openMessages.keys())) {
+            events.push({ kind: 'message:end', messageId: openId });
+            state.openMessages.delete(openId);
+        }
+        // Detect error variants of `result` (e.g. `error_max_turns`,
+        // `error_during_execution`) and surface them as a proper `error` event so
+        // the orchestrator can transition the workspace to `error` instead of
+        // `completed`. The flag on `state` lets the engine override the
+        // post-loop session:ended reason.
+        if (isErrorResultSubtype(subtype)) {
+            state.sawErrorResult = true;
+            const detail = (typeof parsed.error === 'string' && parsed.error) || (typeof parsed.result === 'string' && parsed.result) || '';
+            const message = detail ? `Agent run failed (${subtype}): ${detail}` : `Agent run failed (${subtype})`;
+            events.push({ kind: 'error', category: 'other', message });
+        }
+        const usage = parsed.usage;
+        if (usage) {
+            const costUsd = typeof parsed.total_cost_usd === 'number' ? parsed.total_cost_usd : undefined;
+            events.push({
+                kind: 'usage',
+                inputTokens: Number(usage.input_tokens ?? 0),
+                outputTokens: Number(usage.output_tokens ?? 0),
+                cacheRead: typeof usage.cache_read_input_tokens === 'number' ? usage.cache_read_input_tokens : undefined,
+                cacheWrite: typeof usage.cache_creation_input_tokens === 'number'
+                    ? usage.cache_creation_input_tokens
+                    : undefined,
+                costUsd,
+            });
+        }
+        return events;
+    }
+    return events;
+}