@thegitai/cli 1.0.0-preview.5 → 1.0.0-preview.51

package/dist/src/api/chat.js

@@ -1,12 +1,19 @@
+import { randomUUID } from 'node:crypto';
 import { drainBackgroundJobNotifications } from '../background-jobs.js';
+import { cancelActiveCommand } from '../executor.js';
 import { createPromptCheckpoint, sanitizeSessionSafetyForServer, } from '../session-safety.js';
-import { applySessionSnapshot, snapshotFromSession, } from '../session-store.js';
+import { applySessionSnapshot, saveSessionState, snapshotFromSession, } from '../session-store.js';
 import { executeLocalToolCall } from '../tool-executor.js';
-import { createTraceContext, normalizeServerUrl, readErrorResponse, } from './http.js';
+import { saveGeneratedImage } from '../tools/save-generated-image.js';
+import { isUserInputQuestionArray } from './contracts.js';
+import { createTraceContext, gatewayFailureCategory, normalizeServerUrl, QUOTA_EXCEEDED_CODE, readErrorResponse, ServerApiError, transportFailureDetail, } from './http.js';
+import { createTurnRecovery, fetchTurnAttempt, interruptedStream, isRetryableTurnStatus, isTurnRecoveryExhausted, readTurnChunk, } from './turn-recovery.js';
 import { collectClientEnvironment } from '../client-environment.js';
 import { collectProjectOrientation } from '../project-orientation.js';
+import { describeSessionImageStore } from '../core/session-image-store.js';
 import { autoAttachImages } from '../core/image-path-extractor.js';
 import { formatTurnFailureMarker } from '../turn-failure-marker.js';
+import { browserExtensionSeen, releaseBrowserAfterTurn } from '../browser/session-bridge.js';
 export class TurnCancelledError extends Error {
     name = 'TurnCancelledError';
     constructor(message = 'Turn cancelled.') {
@@ -18,11 +25,13 @@ export class ChatTurnFailedError extends Error {
     category;
     retryable;
     traceId;
-    constructor(message, category = 'unknown_error', retryable = false, traceId = '') {
+    partialSnapshot;
+    constructor(message, category = 'unknown_error', retryable = false, traceId = '', partialSnapshot) {
         super(traceId ? `${message}\nTrace ID: ${traceId}` : message);
         this.category = category;
         this.retryable = retryable;
         this.traceId = traceId;
+        this.partialSnapshot = partialSnapshot;
     }
 }
 export function isTurnCancelledError(error) {
@@ -32,8 +41,13 @@ export function isTurnCancelledError(error) {
 }
 function parseSseBlock(block) {
     let event = 'message';
+    let id = '';
     const dataLines = [];
     for (const line of block.split(/\r?\n/)) {
+        if (line.startsWith('id:')) {
+            id = line.slice(3).trim();
+            continue;
+        }
         if (line.startsWith('event:')) {
             event = line.slice('event:'.length).trim() || event;
             continue;
@@ -46,10 +60,10 @@ function parseSseBlock(block) {
         return null;
     const text = dataLines.join('\n');
     try {
-        return { event, data: JSON.parse(text) };
+        return { id, event, data: JSON.parse(text) };
     }
     catch {
-        return { event, data: text };
+        throw new Error('Server emitted invalid event JSON.');
     }
 }
 let toolStateSeqCounter = 0;
@@ -86,7 +100,7 @@ export function preserveCancelledTurnInput(session, input) {
         return;
     for (let i = session.history.length - 1; i >= 0; i--) {
         const entry = session.history[i];
-        if (!entry || entry.role !== 'user')
+        if (!entry || entry.role !== 'user' || entry.kind === 'userInterjection')
             continue;
         const prior = userHistoryText(entry);
         if (!prior)
@@ -95,24 +109,46 @@ export function preserveCancelledTurnInput(session, input) {
             return;
         break;
     }
-    session.history.push({ role: 'user', parts: [{ text }], kind: 'turnStart' });
+    session.history.push({
+        role: 'user',
+        parts: [{ text }],
+        kind: 'turnStart',
+        userInput: text,
+    });
+}
+function appendTurnFailureMarker(session, category) {
+    session.history.push({
+        role: 'model',
+        parts: [{ text: formatTurnFailureMarker(category) }],
+    });
 }
 function preserveFailedTurnInput(session, input, category) {
     const text = input.trim();
     if (!text)
         return;
-    session.history.push({ role: 'user', parts: [{ text }], kind: 'turnStart' });
     session.history.push({
-        role: 'model',
-        parts: [{ text: formatTurnFailureMarker(category) }],
+        role: 'user',
+        parts: [{ text }],
+        kind: 'turnStart',
+        userInput: text,
     });
+    appendTurnFailureMarker(session, category);
 }
-function historyHasToolCall(session, callId) {
-    return session.history.some((entry) => (entry.parts ?? []).some((part) => String(part?.functionCall?.id ?? '') === callId));
+function tagTurnPhase(phase, run) {
+    return run().catch((error) => {
+        if (error && typeof error === 'object' && !error.thegitaiPhase) {
+            error.thegitaiPhase = phase;
+        }
+        throw error;
+    });
+}
+function turnPhaseOf(error) {
+    const phase = error?.thegitaiPhase;
+    return typeof phase === 'string' ? phase : null;
 }
 function preserveCancelledTurnToolResult(session, input, event, result) {
     const callId = String(event.call.id ?? '').trim();
-    if (!callId || historyHasToolCall(session, callId))
+    if (!callId)
         return;
     preserveCancelledTurnInput(session, input);
     session.history.push({
@@ -132,6 +168,22 @@ function preserveCancelledTurnToolResult(session, input, event, result) {
         ],
     });
 }
+const turnInterjections = new Map();
+function preserveTurnInterjection(session, input, sent) {
+    sent.delivered = true;
+    preserveCancelledTurnInput(session, input);
+    session.history.push({
+        role: 'user',
+        parts: [{ text: sent.text }],
+        kind: 'userInterjection',
+        userInput: sent.text,
+    });
+}
+function preserveTurnAnswer(session, input, requestId, questions, result) {
+    preserveCancelledTurnInput(session, input);
+    session.history.push({ role: 'model', parts: [{ userInputRequest: { requestId, questions } }] });
+    session.history.push({ role: 'user', parts: [{ userInputResult: { requestId, result } }] });
+}
 function publicStatusMessage(data) {
     if (!data || typeof data !== 'object')
         return null;
@@ -145,11 +197,19 @@ function publicStatusMessage(data) {
         ? event.toolName
         : 'tool';
     if (event.phase === 'thinking')
-        return 'Thinking...';
+        return 'Exploring options...';
+    if (event.phase === 'analyzing_image') {
+        return (event.imageCount ?? 1) > 1 ? 'Analyzing images...' : 'Analyzing image...';
+    }
+    if (event.phase === 'generating_image') {
+        return 'Generating image...';
+    }
     if (event.phase === 'running_tool')
         return `Running ${toolName}...`;
     if (event.phase === 'waiting_for_tool')
         return `Running ${toolName} locally...`;
+    if (event.phase === 'waiting_for_user_input')
+        return 'Waiting for your input...';
     return null;
 }
 function normalizeShellJobToolCall(call) {
@@ -181,15 +241,33 @@ function normalizeShellJobToolCall(call) {
     }
     return changed ? { ...call, args } : call;
 }
-async function postToolResult({ config, turnId, event, result, session, fetchImpl, traceId, }) {
+function createTurnRequester({ fetchImpl, recovery, signal, traceId, }) {
+    return (operation, url, init) => {
+        const caller = init.signal ? AbortSignal.any([signal, init.signal]) : signal;
+        return tagTurnPhase(operation, () => recovery.run(operation, async () => {
+            const response = await fetchTurnAttempt(fetchImpl, url, init, caller, {
+                readBody: true,
+            });
+            if (isRetryableTurnStatus(response.status)) {
+                throw await readErrorResponse(response, traceId);
+            }
+            return response;
+        }, caller));
+    };
+}
+function turnUrl(config, turnId, action) {
+    return `${normalizeServerUrl(config.serverUrl)}/v1/chat/turn/${encodeURIComponent(turnId)}/${action}`;
+}
+async function postToolResult({ config, turnId, event, result, session, request, traceId, delivery, }) {
     const payload = {
+        executionId: event.executionId,
         toolCallId: event.call.id,
         result,
         toolState: toolStateFromSession(session),
         toolStateSeq: ++toolStateSeqCounter,
     };
     const trace = createTraceContext(traceId);
-    const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/chat/turn/${encodeURIComponent(turnId)}/tool-result`, {
+    const response = await request('posting a tool result', turnUrl(config, turnId, 'tool-result'), {
         method: 'POST',
         headers: {
             authorization: `Bearer ${config.token}`,
@@ -197,14 +275,88 @@ async function postToolResult({ config, turnId, event, result, session, fetchImp
             ...trace.headers,
         },
         body: JSON.stringify(payload),
+        signal: delivery,
     });
-    if (response.status === 410) {
+    if (response.status === 410)
         return;
+    if (!response.ok) {
+        throw await readErrorResponse(response, trace.traceId);
     }
+}
+async function postUserInputResult({ config, turnId, requestId, result, request, traceId, delivery, }) {
+    const payload = {
+        requestId,
+        result,
+    };
+    const trace = createTraceContext(traceId);
+    const response = await request('posting your answer', turnUrl(config, turnId, 'user-input-result'), {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${config.token}`,
+            'content-type': 'application/json',
+            ...trace.headers,
+        },
+        body: JSON.stringify(payload),
+        signal: delivery,
+    });
+    if (response.status === 410)
+        return;
     if (!response.ok) {
         throw await readErrorResponse(response, trace.traceId);
     }
 }
+const activeTurnRequesters = new Map();
+export async function postInterjection({ config, turnId, text, messageId, imageAttachments = [], fetchImpl = globalThis.fetch, traceId, }) {
+    const payload = {
+        text,
+        messageId,
+        ...(imageAttachments.length > 0 ? { imageAttachments } : {}),
+    };
+    const trace = createTraceContext(traceId);
+    const url = turnUrl(config, turnId, 'interject');
+    const init = {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${config.token}`,
+            'content-type': 'application/json',
+            ...trace.headers,
+        },
+        body: JSON.stringify(payload),
+    };
+    const request = activeTurnRequesters.get(turnId);
+    const sent = turnInterjections.get(turnId);
+    const record = {
+        messageId,
+        text,
+        hasImages: imageAttachments.length > 0,
+        delivered: false,
+    };
+    sent?.push(record);
+    const forget = () => {
+        const index = sent?.indexOf(record) ?? -1;
+        if (index !== -1)
+            sent.splice(index, 1);
+    };
+    let response;
+    try {
+        response = request
+            ? await request('posting a message into the turn', url, init)
+            : await fetchImpl(url, init);
+    }
+    catch (error) {
+        forget();
+        throw error;
+    }
+    if (response.status === 410) {
+        forget();
+        return 'stale';
+    }
+    if (!response.ok) {
+        forget();
+        throw await readErrorResponse(response, trace.traceId);
+    }
+    return 'delivered';
+}
 const turnIdOverrides = new WeakMap();
 function enterServerTurnId(session, serverSessionTurnId) {
     const active = turnIdOverrides.get(session);
@@ -228,14 +380,13 @@ function exitServerTurnId(session) {
         turnIdOverrides.delete(session);
     }
 }
-async function executeAndPostToolResult({ config, projectIndex, session, event, input, fetchImpl, signal, traceId, }) {
+async function executeAndPostToolResult({ config, session, event, input, request, signal, delivery, executed, traceId, }) {
     const turnId = String(event?.turnId ?? '').trim();
-    if (!turnId || !event?.call?.id || !event.call.name) {
+    if (!turnId || !event?.executionId || !event?.call?.id || !event.call.name) {
         throw new Error('Server emitted an invalid tool-call event.');
     }
-    if (signal?.aborted) {
-        throw new TurnCancelledError();
-    }
+    signal.throwIfAborted();
+    delivery.throwIfAborted();
     const serverSessionTurnId = String(event.sessionTurnId ?? '').trim();
     if (serverSessionTurnId) {
         enterServerTurnId(session, serverSessionTurnId);
@@ -245,19 +396,28 @@ async function executeAndPostToolResult({ config, projectIndex, session, event,
     }
     try {
         const call = normalizeShellJobToolCall(event.call);
-        const rawResult = await executeLocalToolCall({ projectIndex }, session, call);
+        const rawResult = event.generatedImage
+            ? saveGeneratedImage({
+                base64Data: event.generatedImage.base64Data,
+                mimeType: event.generatedImage.mimeType,
+                suggestedFilename: event.generatedImage.suggestedFilename ||
+                    String(call.args?.filename ?? call.args?.file_name ?? ''),
+            })
+            : await executeLocalToolCall(session, call);
         preserveCancelledTurnToolResult(session, input, { ...event, call }, rawResult);
-        if (signal?.aborted) {
-            throw new TurnCancelledError();
-        }
+        executed();
+        signal.throwIfAborted();
+        if (delivery.aborted)
+            return;
         await postToolResult({
             config,
             turnId,
             event,
             result: rawResult,
             session,
-            fetchImpl,
+            request,
             traceId,
+            delivery,
         });
     }
     finally {
@@ -266,142 +426,312 @@ async function executeAndPostToolResult({ config, projectIndex, session, event,
         }
     }
 }
-async function consumeTurnStream({ response, config, projectIndex, session, input, fetchImpl, signal, traceId, }) {
-    if (!response.body) {
-        throw new Error('Server returned an empty chat stream.');
+function createTurnWork() {
+    const executions = new Map();
+    const inFlight = new Set();
+    const running = new Set();
+    let lastSerial = Promise.resolve();
+    let hasFailed = false;
+    let rejectFailed;
+    const failed = new Promise((_, reject) => {
+        rejectFailed = reject;
+    });
+    failed.catch(() => { });
+    function dispatch(key, parallel, run) {
+        if (executions.has(key))
+            return;
+        const prior = parallel ? lastSerial : Promise.all([lastSerial, ...inFlight]);
+        let executed;
+        const local = new Promise((resolve) => {
+            executed = resolve;
+        });
+        running.add(local);
+        void local.then(() => running.delete(local));
+        const execution = prior.then(() => run(executed));
+        execution.then(executed, executed);
+        executions.set(key, execution);
+        inFlight.add(execution);
+        if (!parallel)
+            lastSerial = execution;
+        execution.then(() => inFlight.delete(execution), (error) => {
+            inFlight.delete(execution);
+            hasFailed = true;
+            rejectFailed(error);
+        });
     }
-    const decoder = new TextDecoder();
-    const reader = response.body.getReader();
-    let buffer = '';
-    const finalResult = {
-        current: null,
+    return {
+        dispatch,
+        failed,
+        get hasFailed() {
+            return hasFailed;
+        },
+        async executed() {
+            await Promise.all([...running]);
+        },
+        async settled() {
+            await Promise.allSettled([...inFlight]);
+        },
     };
-    const pendingParallelTools = [];
-    let firstParallelFailure = null;
-    let rejectOnParallelFailure = null;
-    const parallelToolFailure = new Promise((_, reject) => {
-        rejectOnParallelFailure = reject;
-    });
-    parallelToolFailure.catch(() => { });
-    function recordParallelFailure(error) {
-        const failure = error ?? new Error('Local tool execution failed.');
-        if (firstParallelFailure == null) {
-            firstParallelFailure = failure;
-            rejectOnParallelFailure?.(failure);
-        }
-        return failure;
+}
+function terminalFailure(event, traceId) {
+    const data = (event.data ?? {});
+    const message = String(data.message ?? 'The turn failed before completion.');
+    const eventTraceId = typeof data.traceId === 'string' ? data.traceId : traceId;
+    if (event.event === 'cancelled') {
+        return new TurnCancelledError(message);
     }
-    async function drainParallelTools() {
-        if (!pendingParallelTools.length)
-            return;
-        const pending = pendingParallelTools.splice(0);
-        const outcomes = await Promise.all(pending);
-        for (const outcome of outcomes) {
-            if (outcome != null)
-                throw outcome;
-        }
+    if (data.code === QUOTA_EXCEEDED_CODE) {
+        return new ServerApiError(message, 429, eventTraceId, QUOTA_EXCEEDED_CODE, data.details ?? {});
     }
-    async function handleEvent(event) {
-        if (event.event === 'status') {
-            const message = publicStatusMessage(event.data);
-            if (message)
-                session.onStatus(message);
+    return new ChatTurnFailedError(message, typeof data.category === 'string' ? data.category : 'unknown_error', Boolean(data.retryable), eventTraceId, data.snapshot);
+}
+const TURN_EVENT_ACK_INTERVAL_MS = 5_000;
+const MAX_TURN_EVENT_BYTES = 64 * 1024 * 1024;
+function createEventAcknowledger(send) {
+    let latest = '';
+    let confirmed = '';
+    let inFlight = false;
+    let stopped = false;
+    let timer = null;
+    const schedule = () => {
+        if (timer || stopped)
             return;
-        }
-        if (event.event === 'context') {
+        timer = setTimeout(flush, TURN_EVENT_ACK_INTERVAL_MS);
+        timer.unref?.();
+    };
+    const flush = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = null;
+        if (stopped || inFlight || !latest || latest === confirmed)
             return;
+        const eventId = latest;
+        inFlight = true;
+        send(eventId)
+            .then(() => {
+            confirmed = eventId;
+        }, () => { })
+            .finally(() => {
+            inFlight = false;
+            if (latest !== confirmed)
+                schedule();
+        });
+    };
+    return {
+        note(eventId) {
+            latest = eventId;
+            schedule();
+        },
+        flush,
+        stop() {
+            stopped = true;
+            if (timer)
+                clearTimeout(timer);
+            timer = null;
+        },
+    };
+}
+async function runTurnStream({ openStream, config, session, input, request, recovery, signal, traceId, acknowledge, stopLocalWork, interjections, onTurnStart, onInterjectionDelivered, }) {
+    const seen = new Set();
+    const work = createTurnWork();
+    const deliveries = new AbortController();
+    const delivery = AbortSignal.any([signal, deliveries.signal]);
+    const streamToken = {};
+    let lastEventId = '';
+    let registeredTurnId = '';
+    function handleEvent(event) {
+        if (!event.id) {
+            throw new Error('The server sent a turn event without an id.');
         }
-        if (event.event === 'tool-call') {
-            const data = event.data;
-            if (data?.parallelSafe === true) {
-                pendingParallelTools.push(executeAndPostToolResult({
+        if (seen.has(event.id))
+            return null;
+        seen.add(event.id);
+        lastEventId = event.id;
+        const data = event.data;
+        switch (event.event) {
+            case 'turn-start': {
+                const turnId = String(data?.turnId ?? '').trim();
+                if (!turnId)
+                    throw new Error('The server sent a turn without an id.');
+                registeredTurnId = turnId;
+                activeTurnRequesters.set(turnId, request);
+                turnInterjections.set(turnId, interjections);
+                onTurnStart?.(turnId);
+                break;
+            }
+            case 'interjection-delivered': {
+                const delivered = data;
+                for (const messageId of delivered?.messageIds ?? []) {
+                    const sent = interjections.find((item) => item.messageId === messageId);
+                    if (sent && !sent.delivered)
+                        preserveTurnInterjection(session, input, sent);
+                }
+                onInterjectionDelivered?.(delivered);
+                break;
+            }
+            case 'status': {
+                const status = (data ?? {});
+                if (status.phase === 'analyzing_image') {
+                    session.onImageAnalysis?.(Math.max(1, Number(status.imageCount ?? 1) || 1));
+                    session.onImageGeneration?.(false);
+                }
+                else if (status.phase === 'generating_image') {
+                    session.onImageGeneration?.(true);
+                    session.onImageAnalysis?.(0);
+                }
+                else if (status.phase) {
+                    session.onImageAnalysis?.(0);
+                    session.onImageGeneration?.(false);
+                }
+                const message = publicStatusMessage(data);
+                if (message)
+                    session.onStatus(message);
+                break;
+            }
+            case 'tool-call': {
+                const toolCall = data;
+                if (!toolCall?.executionId || !toolCall.call?.name) {
+                    throw new Error('Server emitted an invalid tool-call event.');
+                }
+                work.dispatch(`tool:${toolCall.executionId}`, toolCall.parallelSafe === true, (executed) => executeAndPostToolResult({
                     config,
-                    projectIndex,
                     session,
-                    event: data,
+                    event: toolCall,
                     input,
-                    fetchImpl,
+                    request,
                     signal,
+                    delivery,
+                    executed,
                     traceId,
-                }).then(() => null, (error) => recordParallelFailure(error)));
-                return;
+                }));
+                break;
             }
-            await drainParallelTools();
-            await executeAndPostToolResult({
-                config,
-                projectIndex,
-                session,
-                event: data,
-                input,
-                fetchImpl,
-                signal,
-                traceId,
-            });
-            return;
-        }
-        if (event.event === 'tool-result') {
-            const data = event.data;
-            if (data?.call?.name) {
-                session.onToolEvent?.({ call: data.call, result: data.result });
+            case 'tool-result': {
+                const toolResult = data;
+                if (toolResult?.call?.name) {
+                    session.onToolEvent?.({ call: toolResult.call, result: toolResult.result });
+                }
+                break;
             }
-            return;
-        }
-        if (event.event === 'result') {
-            await drainParallelTools();
-            finalResult.current = event.data;
-            return;
+            case 'user-input-request': {
+                const question = data;
+                const turnId = String(question?.turnId ?? '').trim();
+                const requestId = String(question?.requestId ?? '').trim();
+                if (!turnId || !requestId || !isUserInputQuestionArray(question?.questions)) {
+                    throw new Error('Server emitted an invalid user-input request.');
+                }
+                work.dispatch(`question:${requestId}`, false, async (executed) => {
+                    if (!session.requestUserInput) {
+                        throw new Error('Interactive user input is unavailable in this client.');
+                    }
+                    const result = await session.requestUserInput({ questions: question.questions }, signal);
+                    executed();
+                    signal.throwIfAborted();
+                    preserveTurnAnswer(session, input, requestId, question.questions, result);
+                    if (delivery.aborted)
+                        return;
+                    await postUserInputResult({
+                        config,
+                        turnId,
+                        requestId,
+                        result,
+                        request,
+                        traceId,
+                        delivery,
+                    });
+                });
+                break;
+            }
+            case 'result':
+                if (!data?.snapshot)
+                    throw new Error('Server returned an invalid chat result.');
+                return { kind: 'result', result: data };
+            case 'error':
+            case 'cancelled':
+                return { kind: 'failed', error: terminalFailure(event, traceId) };
+            default:
+                break;
         }
-        if (event.event === 'cancelled' || event.event === 'error') {
-            await drainParallelTools().catch(() => { });
-            const message = String(event.data?.message ?? 'Server chat failed.');
-            if (event.event === 'cancelled') {
-                throw new TurnCancelledError(message);
+        acknowledge.note(event.id);
+        return null;
+    }
+    async function readUntilOutcome(response) {
+        if (!response.body)
+            throw interruptedStream('The server returned an empty turn stream.');
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            for (;;) {
+                const read = await Promise.race([readTurnChunk(reader, signal), work.failed]);
+                if (read.done)
+                    throw interruptedStream();
+                buffer += decoder.decode(read.value, { stream: true });
+                for (let match = /\r?\n\r?\n/.exec(buffer); match; match = /\r?\n\r?\n/.exec(buffer)) {
+                    const block = buffer.slice(0, match.index);
+                    buffer = buffer.slice(match.index + match[0].length);
+                    signal.throwIfAborted();
+                    const event = parseSseBlock(block);
+                    if (!event)
+                        continue;
+                    recovery.restored(streamToken);
+                    const outcome = handleEvent(event);
+                    if (outcome)
+                        return outcome;
+                }
+                if (buffer.length > MAX_TURN_EVENT_BYTES) {
+                    throw new Error('The server sent a turn event larger than the protocol allows.');
+                }
             }
-            throw new ChatTurnFailedError(message, typeof event.data?.category === 'string' ? event.data.category : 'unknown_error', Boolean(event.data?.retryable), typeof event.data?.traceId === 'string' ? event.data.traceId : traceId);
+        }
+        finally {
+            await reader.cancel().catch(() => { });
         }
     }
     try {
-        while (true) {
-            if (signal?.aborted) {
-                await reader.cancel().catch(() => { });
-                throw new TurnCancelledError();
+        for (;;) {
+            let outcome;
+            try {
+                signal.throwIfAborted();
+                const response = await openStream(lastEventId);
+                recovery.reconnected(streamToken);
+                outcome = await readUntilOutcome(response);
             }
-            const read = await Promise.race([reader.read(), parallelToolFailure]);
-            if (read.done)
-                break;
-            buffer += decoder.decode(read.value, { stream: true });
-            let separatorIndex = buffer.indexOf('\n\n');
-            while (separatorIndex !== -1) {
-                const block = buffer.slice(0, separatorIndex);
-                buffer = buffer.slice(separatorIndex + 2);
-                const event = parseSseBlock(block);
-                if (event)
-                    await handleEvent(event);
-                separatorIndex = buffer.indexOf('\n\n');
+            catch (error) {
+                signal.throwIfAborted();
+                if (work.hasFailed)
+                    throw error;
+                await recovery.retryAfter(streamToken, lastEventId ? 'reading the turn stream' : 'opening the turn', error);
+                continue;
             }
+            acknowledge.note(lastEventId);
+            acknowledge.flush();
+            if (outcome.kind === 'result') {
+                deliveries.abort(new Error('The turn already finished.'));
+                await work.executed();
+                signal.throwIfAborted();
+            }
+            else {
+                stopLocalWork();
+                await work.settled();
+            }
+            return outcome;
         }
-        await drainParallelTools();
     }
     catch (error) {
-        await reader.cancel().catch(() => { });
-        throw error;
+        const outcome = signal.aborted ? signal.reason : error;
+        stopLocalWork();
+        await work.settled();
+        throw outcome;
     }
     finally {
-        await drainParallelTools().catch(() => { });
-    }
-    buffer += decoder.decode();
-    const tail = buffer.trim();
-    if (tail) {
-        const event = parseSseBlock(tail);
-        if (event)
-            await handleEvent(event);
-    }
-    if (!finalResult.current?.snapshot) {
-        throw new Error('Server returned an invalid chat result.');
+        if (registeredTurnId) {
+            activeTurnRequesters.delete(registeredTurnId);
+            turnInterjections.delete(registeredTurnId);
+        }
     }
-    return finalResult.current;
 }
-export async function sendServerUserMessage({ config, projectIndex, session, input, imageAttachments = [], fetchImpl = globalThis.fetch, signal, }) {
+export async function sendServerUserMessage({ config, session, input, imageAttachments = [], fetchImpl = globalThis.fetch, signal, onTurnStart, onInterjectionDelivered, recoverySleep, }) {
     const autoAttach = autoAttachImages(input, session.rootDir, imageAttachments);
     const requestImageAttachments = autoAttach.attachments.length > 0
         ? [...imageAttachments, ...autoAttach.attachments]
@@ -414,57 +744,99 @@ export async function sendServerUserMessage({ config, projectIndex, session, inp
         session.onStatus(`Image: ${err}`);
     }
     const request = {
+        clientTurnId: randomUUID(),
         modelId: session.modelId,
         session: snapshotForServer(session),
         input: requestInputBase,
         backgroundJobUpdate: backgroundJobUpdate || undefined,
         clientEnvironment: collectClientEnvironment({ env: session.env }),
         projectOrientation: collectProjectOrientation(session.rootDir) ?? undefined,
+        sessionImageStore: describeSessionImageStore(session.env) ?? undefined,
         imageAttachments: imageAttachmentsForServer(requestImageAttachments),
-        maxToolSteps: session.maxToolSteps,
+        ...(session.maxToolStepsWasExplicit || !browserExtensionSeen(session.env)
+            ? { maxToolSteps: session.maxToolSteps }
+            : {}),
         autoYes: session.autoYes,
         agentMode: session.agentMode,
     };
     const trace = createTraceContext();
+    let completed = false;
+    let turnEnded = false;
+    const reportRecovery = (status) => {
+        if (!turnEnded)
+            session.onRecovery?.(status);
+    };
+    const startAttempt = (turnRequest, onStart) => startTurnAttempt({
+        config,
+        session,
+        turnRequest,
+        input: requestInputBase,
+        trace,
+        fetchImpl,
+        recoverySleep,
+        reportRecovery,
+        onTurnStart: onStart,
+        onInterjectionDelivered,
+    });
+    let attempt = startAttempt(request, onTurnStart);
+    const cancelTurn = () => attempt.cancel();
     const preTurnHistoryLength = session.history.length;
     const preserveOnAbort = () => preserveCancelledTurnInput(session, requestInputBase);
     if (signal?.aborted) {
         preserveOnAbort();
+        cancelTurn();
     }
     else {
         signal?.addEventListener('abort', preserveOnAbort, { once: true });
+        signal?.addEventListener('abort', cancelTurn, { once: true });
     }
     try {
-        const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/chat/turn`, {
-            method: 'POST',
-            headers: {
-                accept: 'text/event-stream',
-                authorization: `Bearer ${config.token}`,
-                'content-type': 'application/json',
-                ...trace.headers,
-            },
-            body: JSON.stringify(request),
-            signal,
-        });
-        if (!response.ok) {
-            throw await readErrorResponse(response, trace.traceId);
+        let outcome;
+        try {
+            outcome = await attempt.run();
         }
-        const result = await consumeTurnStream({
-            response,
-            config,
-            projectIndex,
-            session,
-            input: requestInputBase,
-            fetchImpl,
-            signal,
-            traceId: trace.traceId,
-        });
-        applySessionSnapshot(session, result.snapshot, { preserveAgentMode: true });
+        catch (error) {
+            const sent = attempt.interjections;
+            if (!isTurnLostByServer(error) || sent.some((item) => item.hasImages))
+                throw error;
+            attempt.close(false);
+            if (signal?.aborted)
+                throw new TurnCancelledError();
+            const carried = sent.filter((item) => !item.delivered);
+            for (const item of carried)
+                preserveTurnInterjection(session, requestInputBase, item);
+            reportRecovery({ phase: 'continuing' });
+            attempt = startAttempt({
+                ...request,
+                clientTurnId: randomUUID(),
+                session: snapshotForServer(session),
+                continuation: {
+                    clientTurnId: request.clientTurnId,
+                    historyIndex: preTurnHistoryLength,
+                },
+            }, (turnId) => {
+                reportRecovery({ phase: 'continued' });
+                onTurnStart?.(turnId);
+                if (carried.length > 0) {
+                    onInterjectionDelivered?.({
+                        turnId,
+                        step: 0,
+                        deliveredAt: 'tool_round_boundary',
+                        messageIds: carried.map((item) => item.messageId),
+                    });
+                }
+            });
+            outcome = await attempt.run();
+        }
+        if (outcome.kind === 'failed')
+            throw outcome.error;
+        applySessionSnapshot(session, outcome.result.snapshot, { preserveAgentMode: true });
+        completed = true;
         return {
-            text: result.text,
-            waitingForApproval: result.waitingForApproval,
-            toolBudgetReached: result.toolBudgetReached,
-            usageSummary: result.usageSummary,
+            text: outcome.result.text,
+            waitingForApproval: outcome.result.waitingForApproval,
+            toolBudgetReached: outcome.result.toolBudgetReached,
+            usageSummary: outcome.result.usageSummary,
         };
     }
     catch (error) {
@@ -474,11 +846,153 @@ export async function sendServerUserMessage({ config, projectIndex, session, inp
                 ? error
                 : new TurnCancelledError();
         }
-        session.history.length = preTurnHistoryLength;
-        preserveFailedTurnInput(session, requestInputBase, error instanceof ChatTurnFailedError ? error.category : 'unknown_error');
+        const exhausted = isTurnRecoveryExhausted(error);
+        const carriesTrace = error instanceof ChatTurnFailedError || error instanceof ServerApiError;
+        const transportDetail = carriesTrace || exhausted ? null : transportFailureDetail(error);
+        if (transportDetail && error instanceof Error) {
+            const phase = turnPhaseOf(error) ?? 'reaching the server';
+            error.message = `connection lost while ${phase}: ${transportDetail} [trace ${trace.traceId}]`;
+        }
+        else if (!carriesTrace && error instanceof Error) {
+            error.message = `${error.message} [trace ${trace.traceId}]`;
+        }
+        const category = error instanceof ChatTurnFailedError
+            ? error.category
+            : exhausted
+                ? 'connection_error'
+                :
+                    (gatewayFailureCategory(error) ?? 'unknown_error');
+        const partial = error instanceof ChatTurnFailedError ? error.partialSnapshot : undefined;
+        if (partial) {
+            applySessionSnapshot(session, partial, { preserveAgentMode: true });
+        }
+        else if (session.history.length === preTurnHistoryLength) {
+            preserveFailedTurnInput(session, requestInputBase, category);
+        }
+        else {
+            appendTurnFailureMarker(session, category);
+        }
+        try {
+            saveSessionState(session, session.env);
+        }
+        catch { }
         throw error;
     }
     finally {
+        turnEnded = true;
         signal?.removeEventListener('abort', preserveOnAbort);
+        signal?.removeEventListener('abort', cancelTurn);
+        attempt.close(completed);
+        releaseBrowserAfterTurn();
     }
 }
+function isTurnLostByServer(error) {
+    return error instanceof ServerApiError && error.code === 'RECOVERY_UNAVAILABLE';
+}
+function startTurnAttempt({ config, session, turnRequest, input, trace, fetchImpl, recoverySleep, reportRecovery, onTurnStart, onInterjectionDelivered, }) {
+    const requestBody = JSON.stringify(turnRequest);
+    const interjections = [];
+    const turnController = new AbortController();
+    const turnSignal = turnController.signal;
+    session.turnAbortSignal = turnSignal;
+    let serverSettled = false;
+    let cancellationSent = false;
+    const sendCancellation = () => {
+        if (cancellationSent)
+            return;
+        cancellationSent = true;
+        const cancelController = new AbortController();
+        void fetchTurnAttempt(fetchImpl, turnUrl(config, turnRequest.clientTurnId, 'cancel'), {
+            method: 'POST',
+            headers: {
+                authorization: `Bearer ${config.token}`,
+                'content-type': 'application/json',
+                ...trace.headers,
+            },
+            body: JSON.stringify({ sessionId: turnRequest.session.id }),
+        }, cancelController.signal, { readBody: true }).catch(() => { });
+    };
+    const stopLocalWork = () => {
+        turnController.abort(new TurnCancelledError());
+        cancelActiveCommand();
+    };
+    const recovery = createTurnRecovery({
+        signal: turnSignal,
+        sleep: recoverySleep,
+        onStatus: reportRecovery,
+    });
+    const requester = createTurnRequester({
+        fetchImpl,
+        recovery,
+        signal: turnSignal,
+        traceId: trace.traceId,
+    });
+    const acknowledge = createEventAcknowledger(async (eventId) => {
+        const response = await fetchTurnAttempt(fetchImpl, turnUrl(config, turnRequest.clientTurnId, 'ack'), {
+            method: 'POST',
+            headers: {
+                authorization: `Bearer ${config.token}`,
+                'content-type': 'application/json',
+                ...trace.headers,
+            },
+            body: JSON.stringify({ eventId }),
+        }, new AbortController().signal, { readBody: true });
+        if (!response.ok)
+            throw await readErrorResponse(response, trace.traceId);
+    });
+    const openStream = async (lastEventId) => {
+        const response = await fetchTurnAttempt(fetchImpl, `${normalizeServerUrl(config.serverUrl)}/v1/chat/turn`, {
+            method: 'POST',
+            headers: {
+                accept: 'text/event-stream',
+                authorization: `Bearer ${config.token}`,
+                'content-type': 'application/json',
+                ...trace.headers,
+                ...(lastEventId ? { 'last-event-id': lastEventId } : {}),
+            },
+            body: requestBody,
+        }, turnSignal);
+        if (!response.ok) {
+            throw await readErrorResponse(response, trace.traceId);
+        }
+        return response;
+    };
+    return {
+        interjections,
+        cancel() {
+            stopLocalWork();
+            sendCancellation();
+        },
+        async run() {
+            const outcome = await runTurnStream({
+                openStream,
+                config,
+                session,
+                input,
+                request: requester,
+                recovery,
+                signal: turnSignal,
+                traceId: trace.traceId,
+                acknowledge,
+                stopLocalWork,
+                interjections,
+                onTurnStart,
+                onInterjectionDelivered,
+            });
+            serverSettled = true;
+            return outcome;
+        },
+        close(completed) {
+            acknowledge.stop();
+            if (!serverSettled)
+                sendCancellation();
+            if (!completed)
+                turnController.abort(new TurnCancelledError());
+            if (session.turnAbortSignal === turnSignal)
+                session.turnAbortSignal = undefined;
+        },
+    };
+}
+export function isTurnOutcomeKnown(error) {
+    return error instanceof ChatTurnFailedError;
+}