@geminilight/mindos 1.1.26 → 1.1.28

package/dist/agent/stream-consumer.js

@@ -1,664 +1,2 @@
-import { parseMindosSseLine } from '../session/index.js';
-import { redactSensitiveObject, redactSensitiveText } from './redaction.js';
-/** Tools that modify files — trigger files-changed notification on completion */
-const FILE_MUTATING_TOOLS = new Set([
-    'write_file', 'create_file', 'batch_create_files',
-    'append_to_file', 'insert_after_heading', 'update_section',
-    'edit_lines', 'delete_file', 'rename_file', 'move_file',
-    'append_csv', 'create_space',
-]);
-/**
- * Extract the file paths a mutating tool touched from its input args.
- * Returns undefined when no recognizable path input exists — the
- * files-changed event then degrades to "unknown, assume anything changed".
- */
-function collectMutatedPaths(input) {
-    if (!isRecord(input))
-        return undefined;
-    const paths = [];
-    const add = (value) => {
-        if (typeof value === 'string' && value.trim())
-            paths.push(value);
-    };
-    add(input.path);
-    add(input.from_path);
-    add(input.to_path);
-    if (Array.isArray(input.files)) {
-        for (const file of input.files) {
-            if (isRecord(file))
-                add(file.path);
-        }
-    }
-    // rename_file: the new path is the old directory + new_name.
-    if (typeof input.new_name === 'string' && input.new_name.trim() && typeof input.path === 'string' && input.path.trim()) {
-        const slash = input.path.lastIndexOf('/');
-        add((slash >= 0 ? input.path.slice(0, slash + 1) : '') + input.new_name);
-    }
-    return paths.length > 0 ? paths : undefined;
-}
-function parseSseLineAsRecord(line) {
-    const parsed = parseMindosSseLine(line);
-    if (parsed)
-        return parsed;
-    if (!line.startsWith('data:'))
-        return null;
-    const payload = line.slice(5).trim();
-    if (!payload || payload === '[DONE]')
-        return null;
-    try {
-        const fallback = JSON.parse(payload);
-        return fallback && typeof fallback === 'object' && !Array.isArray(fallback)
-            ? fallback
-            : null;
-    }
-    catch {
-        return null;
-    }
-}
-function isRuntimeBindingStatus(value) {
-    return value === 'active'
-        || value === 'missing'
-        || value === 'signed-out'
-        || value === 'archived'
-        || value === 'failed';
-}
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
-function normalizeUserQuestionAnswers(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.filter(isRecord).map((answer) => ({
-        questionIndex: typeof answer.questionIndex === 'number' ? answer.questionIndex : -1,
-        question: typeof answer.question === 'string' ? redactSensitiveText(answer.question) : '',
-        kind: answer.kind === 'custom' || answer.kind === 'chat' || answer.kind === 'multi' ? answer.kind : 'option',
-        answer: typeof answer.answer === 'string' ? redactSensitiveText(answer.answer) : null,
-        ...(Array.isArray(answer.selected) ? { selected: answer.selected.filter((item) => typeof item === 'string').map(redactSensitiveText) } : {}),
-        ...(typeof answer.notes === 'string' ? { notes: redactSensitiveText(answer.notes) } : {}),
-        ...(typeof answer.preview === 'string' ? { preview: redactSensitiveText(answer.preview) } : {}),
-    }));
-}
-function normalizeRuntime(value) {
-    return value === 'mindos' || value === 'acp' || value === 'codex' || value === 'claude'
-        ? value
-        : undefined;
-}
-function normalizeRuntimePermissionIntent(value) {
-    return value === 'allow' || value === 'deny' || value === 'cancel' ? value : undefined;
-}
-function normalizeRuntimePermissionScope(value) {
-    return value === 'once' || value === 'session' || value === 'always' || value === 'turn' ? value : undefined;
-}
-function normalizeRuntimePermissionRisk(value) {
-    if (!isRecord(value))
-        return undefined;
-    const level = value.level === 'low' || value.level === 'medium' || value.level === 'high' ? value.level : undefined;
-    const summary = typeof value.summary === 'string' ? redactSensitiveText(value.summary) : undefined;
-    if (!level || !summary)
-        return undefined;
-    return {
-        level,
-        summary,
-        ...(Array.isArray(value.reasons)
-            ? { reasons: value.reasons.filter((reason) => typeof reason === 'string').map(redactSensitiveText) }
-            : {}),
-    };
-}
-function shortToolName(toolName) {
-    const parts = toolName.split('__');
-    return parts[parts.length - 1] || toolName;
-}
-function isAskUserQuestionToolName(toolName) {
-    if (!toolName)
-        return false;
-    const normalized = shortToolName(toolName).replace(/[-_\s]/g, '').toLowerCase();
-    return normalized === 'askuserquestion';
-}
-function isGenericToolCompletionOutput(output) {
-    return /^Codex item (completed|success|succeeded)$/i.test(output.trim());
-}
-function extractQuestionPayload(input) {
-    if (!isRecord(input))
-        return input;
-    if (Array.isArray(input.questions))
-        return input.questions;
-    if (isRecord(input.input) && Array.isArray(input.input.questions))
-        return input.input.questions;
-    if (isRecord(input.params) && Array.isArray(input.params.questions))
-        return input.params.questions;
-    if (isRecord(input.arguments) && Array.isArray(input.arguments.questions))
-        return input.arguments.questions;
-    return undefined;
-}
-export async function consumeUIMessageStream(body, onUpdate, signal, options = {}) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-    const filesChanged = options.filesChanged;
-    // Mutable working copies
-    const parts = [];
-    const toolCalls = new Map();
-    let currentTextId = null;
-    let currentReasoningPart = null;
-    const startedAt = Date.now();
-    /**
-     * Structural sharing: cache the immutable clone of each mutable part and
-     * reuse it across emissions until the part is mutated again (touch()).
-     * Unchanged parts keep object identity so memoized children skip re-render.
-     */
-    const cloneCache = new Map();
-    /** Mark a mutable part as changed — its next snapshot gets a fresh clone. */
-    function touch(part) {
-        cloneCache.delete(part);
-    }
-    function clonePart(p) {
-        if (p.type === 'text')
-            return { type: 'text', text: p.text };
-        if (p.type === 'reasoning')
-            return { type: 'reasoning', text: p.text };
-        if (p.type === 'image')
-            return { ...p };
-        if (p.type === 'runtime-status')
-            return { ...p };
-        if (p.type === 'agent-run-timeline') {
-            return {
-                ...p,
-                runs: p.runs.map(run => ({
-                    ...run,
-                    ...(run.metadata ? { metadata: { ...run.metadata } } : {}),
-                })),
-            };
-        }
-        // ToolCallPart — shallow copy safe (primitive fields, input is replaced not mutated)
-        return {
-            ...p,
-            ...(p.userQuestion ? {
-                userQuestion: {
-                    ...p.userQuestion,
-                    questions: p.userQuestion.questions.map(q => ({
-                        ...q,
-                        options: q.options.map(o => ({ ...o })),
-                    })),
-                    ...(p.userQuestion.answers ? { answers: p.userQuestion.answers.map(a => ({ ...a, selected: a.selected ? [...a.selected] : undefined })) } : {}),
-                },
-            } : {}),
-            ...(p.runtimePermission ? {
-                runtimePermission: {
-                    ...p.runtimePermission,
-                    options: p.runtimePermission.options.map(option => ({ ...option })),
-                },
-            } : {}),
-        };
-    }
-    /** Build an immutable Message snapshot from current parts */
-    function buildMessage() {
-        const clonedParts = parts.map(p => {
-            const cached = cloneCache.get(p);
-            if (cached)
-                return cached;
-            const clone = clonePart(p);
-            cloneCache.set(p, clone);
-            return clone;
-        });
-        const textContent = clonedParts
-            .filter((p) => p.type === 'text')
-            .map(p => p.text)
-            .join('');
-        return {
-            role: 'assistant',
-            content: textContent,
-            parts: clonedParts,
-            timestamp: startedAt,
-        };
-    }
-    // ---------------------------------------------------------------------------
-    // Emit coalescing: streaming runs can deliver hundreds of chunks per second;
-    // emitting per read batch made rendering O(L²). Leading emit + trailing
-    // flush within emitCoalesceMs; terminal state always flushes immediately.
-    const emitCoalesceMs = options.emitCoalesceMs ?? 50;
-    let lastEmitAt = Number.NEGATIVE_INFINITY;
-    let trailingTimer = null;
-    let pendingEmit = false;
-    let runEnded = false;
-    function emitNow() {
-        pendingEmit = false;
-        lastEmitAt = Date.now();
-        onUpdate(buildMessage());
-    }
-    function scheduleEmit() {
-        if (emitCoalesceMs <= 0) {
-            emitNow();
-            return;
-        }
-        if (trailingTimer === null && Date.now() - lastEmitAt >= emitCoalesceMs) {
-            emitNow(); // leading edge — first chunk renders without delay
-            return;
-        }
-        pendingEmit = true;
-        if (trailingTimer === null) {
-            trailingTimer = setTimeout(() => {
-                trailingTimer = null;
-                if (!runEnded && pendingEmit)
-                    emitNow();
-            }, emitCoalesceMs);
-        }
-    }
-    /** Terminal flush — completion/error/abort must never be delayed. */
-    function flushEmit() {
-        runEnded = true;
-        if (trailingTimer !== null) {
-            clearTimeout(trailingTimer);
-            trailingTimer = null;
-        }
-        if (pendingEmit)
-            emitNow();
-    }
-    /** Get or create the last text part with given ID */
-    function findOrCreateTextPart(id) {
-        if (currentTextId === id) {
-            const last = parts[parts.length - 1];
-            if (last && last.type === 'text')
-                return last;
-        }
-        const part = { type: 'text', text: '' };
-        parts.push(part);
-        currentTextId = id;
-        return part;
-    }
-    /** Get or create a tool call part */
-    function findOrCreateToolCall(toolCallId, toolName) {
-        let tc = toolCalls.get(toolCallId);
-        if (!tc) {
-            tc = {
-                type: 'tool-call',
-                toolCallId,
-                toolName: toolName ?? 'unknown',
-                input: undefined,
-                state: 'pending',
-            };
-            toolCalls.set(toolCallId, tc);
-            parts.push(tc);
-            currentTextId = null;
-        }
-        return tc;
-    }
-    function upsertRuntimeStatus(message, runtime) {
-        const safeMessage = redactSensitiveText(message);
-        const last = parts[parts.length - 1];
-        if (last?.type === 'runtime-status' && last.runtime === runtime) {
-            last.message = safeMessage;
-            touch(last);
-            return;
-        }
-        parts.push({
-            type: 'runtime-status',
-            message: safeMessage,
-            ...(runtime ? { runtime } : {}),
-        });
-        currentTextId = null;
-    }
-    function normalizeUserQuestions(value) {
-        if (!Array.isArray(value))
-            return [];
-        return value
-            .filter((item) => Boolean(item) && typeof item === 'object' && !Array.isArray(item))
-            .map((question) => ({
-            question: typeof question.question === 'string' ? redactSensitiveText(question.question) : '',
-            header: typeof question.header === 'string' ? redactSensitiveText(question.header) : '',
-            multiSelect: question.multiSelect === true,
-            options: Array.isArray(question.options)
-                ? question.options
-                    .filter((option) => Boolean(option) && typeof option === 'object' && !Array.isArray(option))
-                    .map(option => ({
-                    label: typeof option.label === 'string' ? redactSensitiveText(option.label) : '',
-                    description: typeof option.description === 'string' ? redactSensitiveText(option.description) : '',
-                    ...(typeof option.preview === 'string' ? { preview: redactSensitiveText(option.preview) } : {}),
-                }))
-                : [],
-        }));
-    }
-    // Cancelling the reader is the only way to interrupt a pending read();
-    // the aborted check at the top of the loop can't fire while the stream is
-    // quiet, which left aborted runs awaiting a read that never resolves.
-    const cancelOnAbort = () => { void reader.cancel().catch(() => { }); };
-    if (signal?.aborted) {
-        cancelOnAbort();
-    }
-    else {
-        signal?.addEventListener('abort', cancelOnAbort, { once: true });
-    }
-    try {
-        while (true) {
-            if (signal?.aborted)
-                break;
-            const { done, value } = await reader.read();
-            if (done && !buffer)
-                break;
-            if (!done)
-                buffer += decoder.decode(value, { stream: true });
-            // Process complete SSE lines
-            const lines = done ? [buffer] : buffer.split('\n');
-            buffer = done ? '' : lines.pop() ?? ''; // keep incomplete last line
-            let changed = false;
-            for (const line of lines) {
-                const trimmed = line.trim();
-                const eventRecord = parseSseLineAsRecord(trimmed);
-                if (!eventRecord)
-                    continue;
-                const type = typeof eventRecord.type === 'string' ? eventRecord.type : '';
-                switch (type) {
-                    case 'agent_run_context': {
-                        if (typeof eventRecord.rootRunId !== 'string' || !eventRecord.rootRunId)
-                            break;
-                        options.onAgentRunContext?.({
-                            rootRunId: eventRecord.rootRunId,
-                            ...(typeof eventRecord.chatSessionId === 'string' ? { chatSessionId: eventRecord.chatSessionId } : {}),
-                            startedAt: typeof eventRecord.startedAt === 'number' && Number.isFinite(eventRecord.startedAt)
-                                ? eventRecord.startedAt
-                                : Date.now(),
-                        });
-                        break;
-                    }
-                    case 'text_delta': {
-                        // Regular text from assistant
-                        const part = findOrCreateTextPart('text');
-                        part.text += eventRecord.delta ?? '';
-                        touch(part);
-                        changed = true;
-                        break;
-                    }
-                    case 'thinking_delta': {
-                        // Extended thinking (Anthropic)
-                        if (!currentReasoningPart) {
-                            currentReasoningPart = { type: 'reasoning', text: '' };
-                            parts.push(currentReasoningPart);
-                            currentTextId = null;
-                        }
-                        currentReasoningPart.text += eventRecord.delta ?? '';
-                        touch(currentReasoningPart);
-                        changed = true;
-                        break;
-                    }
-                    case 'tool_start': {
-                        // Beginning of tool execution
-                        const toolCallId = eventRecord.toolCallId;
-                        if (!toolCallId)
-                            break;
-                        const toolName = eventRecord.toolName;
-                        const tc = findOrCreateToolCall(toolCallId, toolName);
-                        const safeArgs = redactSensitiveObject(eventRecord.args);
-                        tc.input = safeArgs;
-                        tc.runtime = normalizeRuntime(eventRecord.runtime);
-                        if (isAskUserQuestionToolName(toolName)) {
-                            const questions = normalizeUserQuestions(extractQuestionPayload(safeArgs));
-                            if (questions.length > 0) {
-                                const runId = typeof eventRecord.runId === 'string' ? eventRecord.runId : '';
-                                tc.userQuestion = {
-                                    runId,
-                                    questions,
-                                    status: 'waiting',
-                                    readOnly: !runId,
-                                    ...(tc.runtime ? { runtime: tc.runtime } : {}),
-                                };
-                            }
-                        }
-                        tc.state = 'running';
-                        touch(tc);
-                        changed = true;
-                        break;
-                    }
-                    case 'tool_delta': {
-                        const toolCallId = eventRecord.toolCallId;
-                        if (!toolCallId)
-                            break;
-                        const toolName = typeof eventRecord.toolName === 'string' ? eventRecord.toolName : undefined;
-                        const tc = findOrCreateToolCall(toolCallId, toolName);
-                        if (toolName && tc.toolName === 'unknown')
-                            tc.toolName = toolName;
-                        tc.runtime = normalizeRuntime(eventRecord.runtime) ?? tc.runtime;
-                        tc.output = `${tc.output ?? ''}${typeof eventRecord.delta === 'string' ? redactSensitiveText(eventRecord.delta) : ''}`;
-                        if (tc.state === 'pending')
-                            tc.state = 'running';
-                        touch(tc);
-                        changed = true;
-                        break;
-                    }
-                    case 'tool_end': {
-                        // Tool execution finished
-                        const toolCallId = eventRecord.toolCallId;
-                        if (!toolCallId)
-                            break;
-                        // Use findOrCreateToolCall so tool_end still works even if tool_start was lost
-                        const tc = findOrCreateToolCall(toolCallId, eventRecord.toolName);
-                        if (typeof eventRecord.toolName === 'string' && eventRecord.toolName && tc.toolName === 'unknown') {
-                            tc.toolName = eventRecord.toolName;
-                        }
-                        tc.runtime = normalizeRuntime(eventRecord.runtime) ?? tc.runtime;
-                        const output = typeof eventRecord.output === 'string' ? redactSensitiveText(eventRecord.output) : '';
-                        const shouldPreserveExistingOutput = Boolean(tc.output &&
-                            !eventRecord.isError &&
-                            (!output || isGenericToolCompletionOutput(output)));
-                        if (!shouldPreserveExistingOutput) {
-                            tc.output = output;
-                        }
-                        tc.state = (eventRecord.isError ? 'error' : 'done');
-                        if (eventRecord.isError && tc.userQuestion?.readOnly) {
-                            tc.userQuestion.status = 'cancelled';
-                            tc.userQuestion.reason = output || 'tool_error';
-                        }
-                        touch(tc);
-                        changed = true;
-                        // Notify when a file-modifying tool completes successfully —
-                        // batched into one files-changed notification per run.
-                        if (!eventRecord.isError && FILE_MUTATING_TOOLS.has(tc.toolName)) {
-                            filesChanged?.queue(collectMutatedPaths(tc.input));
-                        }
-                        break;
-                    }
-                    case 'runtime_permission_request': {
-                        const toolCallId = eventRecord.toolCallId;
-                        const runId = eventRecord.runId;
-                        const requestId = eventRecord.requestId;
-                        const runtime = normalizeRuntime(eventRecord.runtime);
-                        if (!toolCallId || !runId || !requestId || (runtime !== 'codex' && runtime !== 'claude'))
-                            break;
-                        const toolName = typeof eventRecord.toolName === 'string' && eventRecord.toolName ? eventRecord.toolName : 'approval_request';
-                        const tc = findOrCreateToolCall(toolCallId, toolName);
-                        tc.toolName = toolName;
-                        tc.input = redactSensitiveObject(eventRecord.input);
-                        tc.runtime = runtime;
-                        tc.runtimePermission = {
-                            runId,
-                            requestId,
-                            runtime,
-                            status: 'waiting',
-                            options: Array.isArray(eventRecord.options)
-                                ? eventRecord.options
-                                    .filter(isRecord)
-                                    .map(option => ({
-                                    id: typeof option.id === 'string' ? option.id : '',
-                                    label: typeof option.label === 'string' ? redactSensitiveText(option.label) : '',
-                                    ...(typeof option.description === 'string' ? { description: redactSensitiveText(option.description) } : {}),
-                                    ...(normalizeRuntimePermissionIntent(option.intent) ? { intent: normalizeRuntimePermissionIntent(option.intent) } : {}),
-                                    ...(normalizeRuntimePermissionScope(option.scope) ? { scope: normalizeRuntimePermissionScope(option.scope) } : {}),
-                                }))
-                                    .filter(option => option.id && option.label)
-                                : [],
-                            ...(typeof eventRecord.reason === 'string' ? { reason: redactSensitiveText(eventRecord.reason) } : {}),
-                            ...(typeof eventRecord.action === 'string' ? { action: redactSensitiveText(eventRecord.action) } : {}),
-                            ...(typeof eventRecord.resource === 'string' ? { resource: redactSensitiveText(eventRecord.resource) } : {}),
-                            ...(normalizeRuntimePermissionRisk(eventRecord.risk) ? { risk: normalizeRuntimePermissionRisk(eventRecord.risk) } : {}),
-                        };
-                        tc.state = 'running';
-                        touch(tc);
-                        changed = true;
-                        break;
-                    }
-                    case 'runtime_permission_resolved': {
-                        const toolCallId = eventRecord.toolCallId;
-                        if (!toolCallId)
-                            break;
-                        const tc = findOrCreateToolCall(toolCallId, 'approval_request');
-                        tc.runtime = normalizeRuntime(eventRecord.runtime) ?? tc.runtime;
-                        const decision = typeof eventRecord.decision === 'string' ? eventRecord.decision : '';
-                        const denied = decision === 'decline' || decision === 'deny' || decision === 'denied';
-                        if (tc.runtimePermission) {
-                            tc.runtimePermission.decision = decision;
-                            if (typeof eventRecord.decisionLabel === 'string')
-                                tc.runtimePermission.decisionLabel = redactSensitiveText(eventRecord.decisionLabel);
-                            const decisionIntent = normalizeRuntimePermissionIntent(eventRecord.decisionIntent);
-                            if (decisionIntent)
-                                tc.runtimePermission.decisionIntent = decisionIntent;
-                            const decisionScope = normalizeRuntimePermissionScope(eventRecord.decisionScope);
-                            if (decisionScope)
-                                tc.runtimePermission.decisionScope = decisionScope;
-                            tc.runtimePermission.status = eventRecord.cancelled === true
-                                ? 'cancelled'
-                                : decisionIntent === 'deny' || denied
-                                    ? 'denied'
-                                    : 'approved';
-                        }
-                        if (eventRecord.cancelled === true || denied) {
-                            tc.state = 'error';
-                            tc.output = decision
-                                ? `Permission decision forwarded: ${decision}`
-                                : 'Permission decision forwarded.';
-                        }
-                        touch(tc);
-                        changed = true;
-                        break;
-                    }
-                    case 'user_question_start': {
-                        const toolCallId = eventRecord.toolCallId;
-                        const runId = eventRecord.runId;
-                        if (!toolCallId || !runId)
-                            break;
-                        const tc = findOrCreateToolCall(toolCallId, 'ask_user_question');
-                        tc.toolName = 'ask_user_question';
-                        tc.userQuestion = {
-                            runId,
-                            questions: normalizeUserQuestions(eventRecord.questions),
-                            status: 'waiting',
-                        };
-                        tc.state = 'running';
-                        touch(tc);
-                        changed = true;
-                        break;
-                    }
-                    case 'user_question_answered': {
-                        const toolCallId = eventRecord.toolCallId;
-                        if (!toolCallId)
-                            break;
-                        const tc = findOrCreateToolCall(toolCallId, 'ask_user_question');
-                        if (tc.userQuestion) {
-                            tc.userQuestion.status = 'submitted';
-                            tc.userQuestion.answers = normalizeUserQuestionAnswers(eventRecord.answers);
-                        }
-                        tc.state = 'done';
-                        touch(tc);
-                        changed = true;
-                        break;
-                    }
-                    case 'user_question_cancelled': {
-                        const toolCallId = eventRecord.toolCallId;
-                        if (!toolCallId)
-                            break;
-                        const tc = findOrCreateToolCall(toolCallId, 'ask_user_question');
-                        if (tc.userQuestion) {
-                            tc.userQuestion.status = 'cancelled';
-                            tc.userQuestion.reason = typeof eventRecord.reason === 'string' ? redactSensitiveText(eventRecord.reason) : undefined;
-                        }
-                        tc.state = 'error';
-                        tc.output = typeof eventRecord.reason === 'string' && eventRecord.reason
-                            ? redactSensitiveText(eventRecord.reason)
-                            : 'Question cancelled.';
-                        touch(tc);
-                        changed = true;
-                        break;
-                    }
-                    case 'runtime_binding': {
-                        const runtime = eventRecord.runtime;
-                        const externalSessionId = eventRecord.externalSessionId;
-                        if ((runtime === 'acp' || runtime === 'codex' || runtime === 'claude') &&
-                            typeof externalSessionId === 'string' &&
-                            externalSessionId) {
-                            options.onRuntimeBinding?.({
-                                runtime,
-                                externalSessionId,
-                                ...(typeof eventRecord.cwd === 'string' ? { cwd: eventRecord.cwd } : {}),
-                                ...(isRuntimeBindingStatus(eventRecord.status) ? { status: eventRecord.status } : {}),
-                                ...(typeof eventRecord.reason === 'string' ? { reason: redactSensitiveText(eventRecord.reason) } : {}),
-                            });
-                        }
-                        break;
-                    }
-                    case 'status': {
-                        if (eventRecord.visible !== true || typeof eventRecord.message !== 'string' || !eventRecord.message.trim()) {
-                            break;
-                        }
-                        upsertRuntimeStatus(eventRecord.message.trim(), normalizeRuntime(eventRecord.runtime));
-                        changed = true;
-                        break;
-                    }
-                    case 'error': {
-                        // Stream error
-                        const message = eventRecord.message;
-                        parts.push({
-                            type: 'text',
-                            text: `\n\n**Stream Error:** ${redactSensitiveText(message)}`,
-                        });
-                        currentTextId = null;
-                        changed = true;
-                        break;
-                    }
-                    case 'done': {
-                        // Stream completed cleanly — usage data is optional
-                        // No state change needed; just marks end of SSE stream
-                        break;
-                    }
-                    default:
-                        // Ignore unknown event types
-                        break;
-                }
-            }
-            // Emit at most once per coalescing window, not per SSE line/batch
-            if (changed) {
-                scheduleEmit();
-            }
-            if (done)
-                break;
-        }
-    }
-    finally {
-        signal?.removeEventListener('abort', cancelOnAbort);
-        if (signal?.aborted) {
-            // Release the underlying connection; safe if already cancelled/closed.
-            try {
-                await reader.cancel();
-            }
-            catch { /* stream already settled */ }
-        }
-        reader.releaseLock();
-        // Terminal state (completion, error, abort) must never be delayed:
-        // flush any pending coalesced snapshot and the batched files-changed
-        // notification before the caller observes the run as finished.
-        flushEmit();
-        filesChanged?.flush();
-    }
-    // Finalize any tool calls still in running/pending state
-    // (stream ended unexpectedly — abort, network error, step limit)
-    let finalized = false;
-    for (const tc of toolCalls.values()) {
-        if (tc.state === 'running' || tc.state === 'pending') {
-            tc.state = 'error';
-            tc.output = tc.output ?? 'Stream ended before tool completed';
-            touch(tc);
-            finalized = true;
-        }
-    }
-    if (finalized) {
-        onUpdate(buildMessage());
-    }
-    return buildMessage();
-}
+export * from './stream/stream-consumer.js';
 //# sourceMappingURL=stream-consumer.js.map