@minionry/minion 0.7.36

package/dist/server/cli/headless/claude-invoker-stream.js

@@ -0,0 +1,555 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { applyStreamEventToBackground } from './background-activity.js';
+import { engineAvailability } from './engine-availability.js';
+import { classifyEngineNotice, isSyntheticModel } from './engine-notice.js';
+import { herror, hlog } from './headless-logger.js';
+import { classifyError } from './stall-assessor.js';
+const SESSION_NOT_FOUND_RE = /no conversation found with session\s*id|conversation session[\s\S]{0,80}?(?:does not exist|has expired)|session\s*id[\s\S]{0,40}?(?:does not exist|has expired)/i;
+export function matchesSessionNotFound(text) {
+    return !!text && SESSION_NOT_FOUND_RE.test(text);
+}
+export function verboseLog(verbose, ...msgs) {
+    if (verbose) {
+        for (const msg of msgs)
+            hlog(msg);
+    }
+}
+function handleSessionCapture(parsed, captured) {
+    if (parsed.type === 'system' && parsed.subtype === 'init' && parsed.session_id) {
+        captured.claudeSessionId = parsed.session_id;
+    }
+    if (parsed.type === 'result' && parsed.session_id && !captured.claudeSessionId) {
+        captured.claudeSessionId = parsed.session_id;
+    }
+}
+function handleModelCapture(parsed, ctx) {
+    if (parsed.type === 'system' && parsed.subtype === 'init' && typeof parsed.model === 'string' && parsed.model) {
+        ctx.config.onExecutionTargetResolved?.(parsed.model);
+    }
+}
+function handleMcpServerInit(parsed, ctx) {
+    if (parsed.type !== 'system' || parsed.subtype !== 'init' || !Array.isArray(parsed.mcp_servers)) {
+        return;
+    }
+    const failed = parsed.mcp_servers
+        .filter((s) => s?.status === 'failed' && typeof s.name === 'string' && s.name)
+        .map((s) => s.name);
+    if (failed.length === 0)
+        return;
+    ctx.failedMcpServers = failed;
+    herror(`[MCP] servers failed to connect: ${failed.join(', ')}`);
+    if (failed.includes('minionry-browser')) {
+        ctx.config.outputCallback?.('\n[[MINIONRY_ERROR:BROWSER_MCP_UNAVAILABLE]] The Minionry browser tools failed to connect for this session. ' +
+            'Browser actions cannot run in the visible browser — retry the prompt, and if it persists check `minion doctor` / the browser subsystem.\n');
+    }
+}
+function handleThinkingDelta(event, ctx) {
+    if (event.type !== 'content_block_delta' ||
+        event.delta?.type !== 'thinking_delta' ||
+        !event.delta?.thinking) {
+        return ctx.accumulatedThinking;
+    }
+    ctx.hasReceivedThinkingDeltas = true;
+    if (ctx.resumeAssessmentActive) {
+        ctx.resumeAssessmentActive = false;
+        if (ctx.resumeAssessmentBuffer) {
+            ctx.config.outputCallback?.(ctx.resumeAssessmentBuffer);
+            ctx.resumeAssessmentBuffer = '';
+        }
+    }
+    const thinking = event.delta.thinking;
+    const updated = ctx.accumulatedThinking + thinking;
+    if (ctx.config.thinkingCallback) {
+        ctx.config.thinkingCallback(thinking);
+    }
+    else if (ctx.config.outputCallback) {
+        ctx.config.outputCallback(thinking);
+    }
+    else {
+        process.stdout.write(thinking);
+    }
+    return updated;
+}
+function handleTextDelta(event, ctx) {
+    if (event.type !== 'content_block_delta' ||
+        event.delta?.type !== 'text_delta' ||
+        !event.delta?.text) {
+        return ctx.accumulatedAssistantResponse;
+    }
+    ctx.hasReceivedTextDeltas = true;
+    if (ctx.currentMessageId) {
+        ctx.textDeltaMessageIds ??= new Set();
+        ctx.textDeltaMessageIds.add(ctx.currentMessageId);
+    }
+    const text = event.delta.text;
+    const updated = ctx.accumulatedAssistantResponse + text;
+    const { passthrough, timeouts } = ctx.nativeTimeoutDetector.processChunk(text);
+    for (const timeout of timeouts) {
+        ctx.config.outputCallback?.(`\n[[MINIONRY_NATIVE_TIMEOUT]] ${timeout.toolName} timed out \u2014 ${timeout.action} with ${timeout.preservedCount} results preserved\n`);
+    }
+    if (ctx.resumeAssessmentActive) {
+        if (passthrough) {
+            ctx.resumeAssessmentBuffer += passthrough;
+        }
+        return updated;
+    }
+    if (passthrough && ctx.config.outputCallback) {
+        ctx.config.outputCallback(passthrough);
+    }
+    return updated;
+}
+function applyUsage(usage, ctx) {
+    let changed = false;
+    if (typeof usage.input_tokens === 'number' && usage.input_tokens > 0) {
+        ctx.apiTokenUsage.inputTokens += usage.input_tokens;
+        changed = true;
+    }
+    if (typeof usage.output_tokens === 'number' && usage.output_tokens > 0) {
+        ctx.apiTokenUsage.outputTokens += usage.output_tokens;
+        changed = true;
+    }
+    if (typeof usage.cache_creation_input_tokens === 'number' && usage.cache_creation_input_tokens > 0) {
+        ctx.apiTokenUsage.cacheCreationTokens += usage.cache_creation_input_tokens;
+        changed = true;
+    }
+    if (typeof usage.cache_read_input_tokens === 'number' && usage.cache_read_input_tokens > 0) {
+        ctx.apiTokenUsage.cacheReadTokens += usage.cache_read_input_tokens;
+        changed = true;
+    }
+    return changed;
+}
+function captureSpeed(usage, ctx) {
+    if (typeof usage.speed === 'string' && usage.speed)
+        ctx.apiSpeed = usage.speed;
+}
+function snapshotCurrentTurnInput(usage, ctx) {
+    const input = typeof usage.input_tokens === 'number' ? usage.input_tokens : 0;
+    const cacheCreate = typeof usage.cache_creation_input_tokens === 'number' ? usage.cache_creation_input_tokens : 0;
+    const cacheRead = typeof usage.cache_read_input_tokens === 'number' ? usage.cache_read_input_tokens : 0;
+    const next = input + cacheCreate + cacheRead;
+    if (next <= 0 || next === ctx.apiTokenUsage.currentTurnInputTokens)
+        return false;
+    ctx.apiTokenUsage.currentTurnInputTokens = next;
+    return true;
+}
+function handleMessageStartTokens(event, ctx) {
+    if (event.type !== 'message_start')
+        return false;
+    if (event.message?.id)
+        ctx.currentMessageId = event.message.id;
+    if (!event.message?.usage)
+        return false;
+    const messageId = event.message.id;
+    if (messageId && ctx.seenMessageIds.has(messageId))
+        return false;
+    if (messageId)
+        ctx.seenMessageIds.add(messageId);
+    ctx.currentStepOutputTokens = 0;
+    const u = event.message.usage;
+    captureSpeed(u, ctx);
+    const changed = applyUsage({
+        input_tokens: u.input_tokens,
+        cache_creation_input_tokens: u.cache_creation_input_tokens,
+        cache_read_input_tokens: u.cache_read_input_tokens,
+    }, ctx);
+    const turnChanged = snapshotCurrentTurnInput(u, ctx);
+    verboseLog(ctx.config.verbose, `[TOKENS] message_start id=${messageId ?? 'n/a'}: input=${u.input_tokens ?? 0} cache_create=${u.cache_creation_input_tokens ?? 0} cache_read=${u.cache_read_input_tokens ?? 0} → currentTurn=${ctx.apiTokenUsage.currentTurnInputTokens} totals input=${ctx.apiTokenUsage.inputTokens} cache_create=${ctx.apiTokenUsage.cacheCreationTokens} cache_read=${ctx.apiTokenUsage.cacheReadTokens}`);
+    return changed || turnChanged;
+}
+function handleMessageDeltaTokens(event, ctx) {
+    if (event.type !== 'message_delta' || !event.usage)
+        return false;
+    if (typeof event.usage.output_tokens !== 'number')
+        return false;
+    const increment = event.usage.output_tokens - ctx.currentStepOutputTokens;
+    verboseLog(ctx.config.verbose, `[TOKENS] message_delta: output=${event.usage.output_tokens} (step_prev=${ctx.currentStepOutputTokens} increment=${increment}) → total_output=${ctx.apiTokenUsage.outputTokens + Math.max(increment, 0)}`);
+    if (increment <= 0)
+        return false;
+    ctx.apiTokenUsage.outputTokens += increment;
+    ctx.currentStepOutputTokens = event.usage.output_tokens;
+    return true;
+}
+function handleTokenUsage(event, ctx) {
+    const changed = handleMessageStartTokens(event, ctx) || handleMessageDeltaTokens(event, ctx);
+    if (changed) {
+        ctx.lastTokenActivityTime = Date.now();
+        ctx.config.tokenUsageCallback?.({ ...ctx.apiTokenUsage });
+    }
+}
+function handleAssistantMessageTokens(parsed, ctx) {
+    if (parsed.type !== 'assistant' || !parsed.message?.usage)
+        return;
+    const messageId = parsed.message.id;
+    if (messageId && ctx.seenMessageIds.has(messageId))
+        return;
+    if (messageId)
+        ctx.seenMessageIds.add(messageId);
+    const u = parsed.message.usage;
+    captureSpeed(u, ctx);
+    const changed = applyUsage(u, ctx);
+    const turnChanged = snapshotCurrentTurnInput(u, ctx);
+    verboseLog(ctx.config.verbose, `[TOKENS] assistant id=${messageId ?? 'n/a'}: input=${u.input_tokens ?? 0} output=${u.output_tokens ?? 0} cache_create=${u.cache_creation_input_tokens ?? 0} cache_read=${u.cache_read_input_tokens ?? 0} → currentTurn=${ctx.apiTokenUsage.currentTurnInputTokens} totals input=${ctx.apiTokenUsage.inputTokens} output=${ctx.apiTokenUsage.outputTokens} cache_create=${ctx.apiTokenUsage.cacheCreationTokens} cache_read=${ctx.apiTokenUsage.cacheReadTokens}`);
+    if (changed || turnChanged) {
+        ctx.lastTokenActivityTime = Date.now();
+        ctx.config.tokenUsageCallback?.({ ...ctx.apiTokenUsage });
+    }
+}
+function handleResultTokenUsage(parsed, ctx) {
+    if (!parsed.usage)
+        return;
+    if (parsed.parent_tool_use_id)
+        return;
+    const u = parsed.usage;
+    captureSpeed(u, ctx);
+    const next = {
+        inputTokens: typeof u.input_tokens === 'number' ? u.input_tokens : 0,
+        outputTokens: typeof u.output_tokens === 'number' ? u.output_tokens : 0,
+        cacheCreationTokens: typeof u.cache_creation_input_tokens === 'number' ? u.cache_creation_input_tokens : 0,
+        cacheReadTokens: typeof u.cache_read_input_tokens === 'number' ? u.cache_read_input_tokens : 0,
+        currentTurnInputTokens: ctx.apiTokenUsage.currentTurnInputTokens,
+        isFinal: true,
+    };
+    const total = next.inputTokens + next.outputTokens + next.cacheCreationTokens + next.cacheReadTokens;
+    const current = ctx.apiTokenUsage;
+    const currentTotal = current.inputTokens + current.outputTokens + current.cacheCreationTokens + current.cacheReadTokens;
+    if (current.isFinal && total < currentTotal)
+        return;
+    if (total > 0) {
+        verboseLog(ctx.config.verbose, `[TOKENS] Result event usage (FINAL): input=${next.inputTokens} output=${next.outputTokens} cache_create=${next.cacheCreationTokens} cache_read=${next.cacheReadTokens} ` +
+            `(stream accumulated: input=${ctx.apiTokenUsage.inputTokens} output=${ctx.apiTokenUsage.outputTokens} cache_create=${ctx.apiTokenUsage.cacheCreationTokens} cache_read=${ctx.apiTokenUsage.cacheReadTokens} currentTurn=${ctx.apiTokenUsage.currentTurnInputTokens})`);
+        ctx.apiTokenUsage = next;
+        ctx.lastTokenActivityTime = Date.now();
+        ctx.config.tokenUsageCallback?.({ ...ctx.apiTokenUsage });
+    }
+}
+function handleToolResult(parsed, ctx) {
+    if (parsed.type !== 'user' || !parsed.message?.content) {
+        return;
+    }
+    for (const content of parsed.message.content) {
+        if (content.type !== 'tool_result') {
+            continue;
+        }
+        const toolId = content.tool_use_id;
+        const result = content.content;
+        const isError = content.is_error || false;
+        const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
+        const toolEntry = ctx.accumulatedToolUse.find(t => t.toolId === toolId);
+        if (toolEntry) {
+            toolEntry.result = resultStr;
+            toolEntry.isError = isError;
+            toolEntry.duration = Date.now() - toolEntry.startTime;
+        }
+        if (ctx.config.toolUseCallback) {
+            ctx.config.toolUseCallback({ type: 'tool_result', toolId, result: resultStr, isError });
+        }
+    }
+}
+function isDuplicateOfStreamedText(ctx, messageId, synthetic) {
+    if (synthetic)
+        return false;
+    if (messageId)
+        return ctx.textDeltaMessageIds?.has(messageId) ?? false;
+    return ctx.hasReceivedTextDeltas;
+}
+function handleAssistantTextBlock(block, ctx, messageId, synthetic = false) {
+    if (isDuplicateOfStreamedText(ctx, messageId, synthetic))
+        return;
+    ctx.accumulatedAssistantResponse += block.text;
+    ctx.config.outputCallback?.(block.text);
+}
+export function engineNoticeErrorCode(kind) {
+    switch (kind) {
+        case 'limit': return 'USAGE_LIMIT';
+        case 'auth': return 'AUTH_REQUIRED';
+        case 'server_error': return 'API_SERVER_ERROR';
+    }
+}
+export function recordEngineNotice(ctx, notice) {
+    if (!ctx.engineNotice)
+        ctx.engineNotice = notice;
+    engineAvailability.observe(notice);
+    ctx.surfacedNoticeTexts ??= new Set();
+    if (ctx.surfacedNoticeTexts.has(notice.text))
+        return;
+    ctx.surfacedNoticeTexts.add(notice.text);
+    verboseLog(ctx.config.verbose, `[NOTICE] ${notice.kind} (${notice.source}): ${notice.text.slice(0, 200)}`);
+    ctx.config.outputCallback?.(`\n[[MINIONRY_ERROR:${engineNoticeErrorCode(notice.kind)}]] ${notice.text}\n`);
+}
+function handleSyntheticAssistantMessage(parsed, ctx) {
+    const content = parsed.message?.content ?? [];
+    const text = content.filter((b) => b.type === 'text' && b.text).map((b) => b.text).join('\n').trim();
+    const notice = text ? classifyEngineNotice(text, 'stream') : null;
+    if (!notice) {
+        for (const block of content)
+            handleAssistantContentBlock(block, ctx, parsed.message?.id, true);
+        return;
+    }
+    const alreadyInTranscript = ctx.accumulatedAssistantResponse.includes(text);
+    if (!alreadyInTranscript) {
+        ctx.accumulatedAssistantResponse += `${ctx.accumulatedAssistantResponse ? '\n' : ''}${text}`;
+    }
+    recordEngineNotice(ctx, notice);
+}
+function handleAssistantThinkingBlock(block, ctx) {
+    if (ctx.hasReceivedThinkingDeltas)
+        return;
+    ctx.accumulatedThinking += block.thinking;
+    if (ctx.config.thinkingCallback) {
+        ctx.config.thinkingCallback(block.thinking);
+    }
+    else {
+        ctx.config.outputCallback?.(block.thinking);
+    }
+}
+function handleAssistantToolUseBlock(block, ctx) {
+    if (ctx.accumulatedToolUse.some((t) => t.toolId === block.id))
+        return;
+    const toolInput = block.input || {};
+    ctx.accumulatedToolUse.push({
+        toolName: block.name, toolId: block.id,
+        toolInput, startTime: Date.now(),
+    });
+    ctx.config.toolUseCallback?.({
+        type: 'tool_start', toolName: block.name, toolId: block.id, index: 0,
+    });
+    ctx.config.toolUseCallback?.({
+        type: 'tool_complete', toolName: block.name, toolId: block.id,
+        index: 0, completeInput: toolInput,
+    });
+}
+function handleAssistantContentBlock(block, ctx, messageId, synthetic = false) {
+    if (block.type === 'text' && block.text)
+        handleAssistantTextBlock(block, ctx, messageId, synthetic);
+    else if (block.type === 'thinking' && block.thinking)
+        handleAssistantThinkingBlock(block, ctx);
+    else if (block.type === 'tool_use' && block.name && block.id)
+        handleAssistantToolUseBlock(block, ctx);
+}
+function handleAssistantMessage(parsed, ctx) {
+    if (parsed.type !== 'assistant' || !parsed.message?.content)
+        return;
+    const content = parsed.message.content;
+    if (!Array.isArray(content))
+        return;
+    if (isSyntheticModel(parsed.message.model)) {
+        handleSyntheticAssistantMessage(parsed, ctx);
+    }
+    else {
+        for (const block of content)
+            handleAssistantContentBlock(block, ctx, parsed.message.id, false);
+    }
+    if (ctx.resumeAssessmentActive) {
+        ctx.resumeAssessmentActive = false;
+        if (ctx.resumeAssessmentBuffer) {
+            ctx.config.outputCallback?.(ctx.resumeAssessmentBuffer);
+            ctx.resumeAssessmentBuffer = '';
+        }
+    }
+}
+function extractErrorMessage(parsed) {
+    const errObj = typeof parsed.error === 'object' ? parsed.error?.message : parsed.error;
+    return errObj || String(parsed.message ?? '') || JSON.stringify(parsed);
+}
+function extractResultErrorText(parsed) {
+    if (typeof parsed.error === 'string' && parsed.error)
+        return parsed.error;
+    if (typeof parsed.error === 'object' && parsed.error?.message)
+        return parsed.error.message;
+    if (Array.isArray(parsed.errors) && parsed.errors.length > 0) {
+        const text = parsed.errors.filter((e) => typeof e === 'string' && e).join('; ');
+        if (text)
+            return text;
+    }
+    if (typeof parsed.result === 'string' && parsed.result)
+        return parsed.result;
+    return '';
+}
+function isInterruptedResult(parsed) {
+    return typeof parsed.terminal_reason === 'string' && parsed.terminal_reason.startsWith('aborted');
+}
+function recordResultDiagnostics(parsed, ctx) {
+    if (parsed.parent_tool_use_id)
+        return;
+    if (typeof parsed.subtype === 'string')
+        ctx.resultSubtype = parsed.subtype;
+    if (typeof parsed.terminal_reason === 'string')
+        ctx.terminalReason = parsed.terminal_reason;
+    ctx.resultIsError = !!parsed.is_error;
+}
+function handleResultEvent(parsed, ctx) {
+    handleResultTokenUsage(parsed, ctx);
+    recordResultDiagnostics(parsed, ctx);
+    if (parsed.stop_reason) {
+        ctx.stopReason = parsed.stop_reason;
+    }
+    if (parsed.is_error) {
+        const errorText = extractResultErrorText(parsed);
+        if (matchesSessionNotFound(errorText))
+            ctx.sessionNotFound = true;
+        const engineAbort = isInterruptedResult(parsed) || parsed.subtype === 'error_during_execution';
+        if (engineAbort) {
+            ctx.onEngineAbort?.();
+        }
+        if (isInterruptedResult(parsed)) {
+            ctx.resultInterrupted = true;
+            verboseLog(ctx.config.verbose, `[RESULT] interrupted: terminal_reason=${parsed.terminal_reason} subtype=${parsed.subtype ?? 'n/a'}${errorText ? ` diagnostics=${errorText}` : ''}`);
+            ctx.config.outputCallback?.('\n[[MINIONRY_ERROR:EXECUTION_INTERRUPTED]] Execution was interrupted before completion — completed work is preserved and the session can resume.\n');
+            return true;
+        }
+        const notice = classifyEngineNotice(errorText, 'result');
+        if (notice) {
+            recordEngineNotice(ctx, notice);
+            return true;
+        }
+        const message = errorText ||
+            `Claude reported an error result with no details${parsed.subtype ? ` (${parsed.subtype})` : ''}`;
+        ctx.config.outputCallback?.(`\n[[MINIONRY_ERROR:CLAUDE_RESULT_ERROR]] ${message}\n`);
+        return true;
+    }
+    if (!ctx.accumulatedAssistantResponse && parsed.result && typeof parsed.result === 'string') {
+        ctx.accumulatedAssistantResponse = parsed.result;
+        ctx.config.outputCallback?.(parsed.result);
+    }
+    return false;
+}
+export function processStreamEvent(parsed, ctx) {
+    if (ctx.firstEventAt === undefined)
+        ctx.firstEventAt = Date.now();
+    const pendingBefore = ctx.backgroundActivity.pendingTasks.size;
+    applyStreamEventToBackground(ctx.backgroundActivity, parsed);
+    if (ctx.backgroundActivity.pendingTasks.size !== pendingBefore) {
+        ctx.config.onBackgroundActivity?.(ctx.backgroundActivity.pendingTasks.size);
+    }
+    if (parsed.type === 'error') {
+        const message = extractErrorMessage(parsed);
+        if (matchesSessionNotFound(message))
+            ctx.sessionNotFound = true;
+        const notice = classifyEngineNotice(message, 'result');
+        if (notice) {
+            recordEngineNotice(ctx, notice);
+            return;
+        }
+        ctx.config.outputCallback?.(`\n[[MINIONRY_ERROR:CLAUDE_ERROR]] ${message}\n`);
+        return;
+    }
+    if (parsed.type === 'result') {
+        if (handleResultEvent(parsed, ctx))
+            return;
+    }
+    if (parsed.type === 'stream_event' && parsed.event) {
+        const event = parsed.event;
+        ctx.accumulatedThinking = handleThinkingDelta(event, ctx);
+        ctx.accumulatedAssistantResponse = handleTextDelta(event, ctx);
+        handleToolStreamEvents(event, ctx);
+        handleTokenUsage(event, ctx);
+    }
+    handleAssistantMessage(parsed, ctx);
+    handleAssistantMessageTokens(parsed, ctx);
+    handleToolResult(parsed, ctx);
+}
+function handleToolStart(event, ctx) {
+    if (event.type !== 'content_block_start' || event.content_block?.type !== 'tool_use')
+        return;
+    if (ctx.resumeAssessmentActive) {
+        ctx.resumeAssessmentActive = false;
+        if (ctx.resumeAssessmentBuffer) {
+            ctx.config.outputCallback?.(ctx.resumeAssessmentBuffer);
+            ctx.resumeAssessmentBuffer = '';
+        }
+    }
+    const toolName = event.content_block.name;
+    const toolId = event.content_block.id;
+    const index = event.index;
+    ctx.toolInputBuffers.set(index, { name: toolName, id: toolId, inputJson: '', startTime: Date.now() });
+    ctx.config.toolUseCallback?.({ type: 'tool_start', toolName, toolId, index });
+}
+function handleToolInputDelta(event, ctx) {
+    if (event.type !== 'content_block_delta' || event.delta?.type !== 'input_json_delta')
+        return;
+    const index = event.index;
+    const partialJson = event.delta.partial_json;
+    const toolBuffer = ctx.toolInputBuffers.get(index);
+    if (toolBuffer)
+        toolBuffer.inputJson += partialJson;
+    ctx.lastTokenActivityTime = Date.now();
+    ctx.config.toolUseCallback?.({ type: 'tool_input_delta', partialJson, index });
+}
+function handleToolComplete(event, ctx) {
+    if (event.type !== 'content_block_stop')
+        return;
+    const index = event.index;
+    const toolBuffer = ctx.toolInputBuffers.get(index);
+    if (!toolBuffer)
+        return;
+    let completeInput = {};
+    try {
+        completeInput = JSON.parse(toolBuffer.inputJson);
+    }
+    catch {   }
+    ctx.accumulatedToolUse.push({
+        toolName: toolBuffer.name, toolId: toolBuffer.id,
+        toolInput: completeInput, startTime: toolBuffer.startTime
+    });
+    ctx.toolInputBuffers.delete(index);
+    ctx.config.toolUseCallback?.({
+        type: 'tool_complete', toolName: toolBuffer.name, toolId: toolBuffer.id,
+        index, completeInput
+    });
+}
+function handleToolStreamEvents(event, ctx) {
+    handleToolStart(event, ctx);
+    handleToolInputDelta(event, ctx);
+    handleToolComplete(event, ctx);
+}
+export function processStreamLines(buffer, sessionCapture, ctx) {
+    const lines = buffer.split('\n');
+    const remainder = lines.pop() || '';
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            handleSessionCapture(parsed, sessionCapture);
+            handleMcpServerInit(parsed, ctx);
+            handleModelCapture(parsed, ctx);
+            processStreamEvent(parsed, ctx);
+        }
+        catch {   }
+    }
+    return remainder;
+}
+export function flushNativeTimeoutBuffers(ctx) {
+    const remaining = ctx.nativeTimeoutDetector.flush();
+    const buffered = ctx.nativeTimeoutDetector.bufferedPostTimeoutOutput;
+    const postTimeout = (buffered + remaining) || undefined;
+    if (!postTimeout && remaining) {
+        ctx.config.outputCallback?.(remaining);
+    }
+    return postTimeout;
+}
+export function logFastModeDiagnostic(ctx) {
+    if (!ctx.config.fastMode)
+        return;
+    const model = ctx.config.model ?? 'default';
+    if (ctx.apiSpeed === 'fast') {
+        verboseLog(ctx.config.verbose, `[FASTMODE] active: model=${model} usage.speed=fast`);
+        return;
+    }
+    if (ctx.apiSpeed === undefined && ctx.apiTokenUsage.outputTokens === 0)
+        return;
+    herror(`[FASTMODE] requested but INACTIVE: model=${model} usage.speed=${ctx.apiSpeed ?? 'unknown'} — ran at standard speed (fast mode did not engage). Inspect the outgoing request with: claude -p --settings '{"fastMode":true}' --debug api "hi"`);
+}
+export async function classifyUnmatchedStderr(stderr, errorAlreadySurfaced, code, config) {
+    if (!stderr || errorAlreadySurfaced || code === 0)
+        return;
+    try {
+        const classified = await classifyError(stderr, config.claudeCommand, config.verbose);
+        if (classified) {
+            config.outputCallback?.(`\n[[MINIONRY_ERROR:${classified.errorCode}]] ${classified.message}\n`);
+        }
+    }
+    catch {
+    }
+}