@thegitai/cli 1.0.0-preview.4 → 1.0.0-preview.41

package/dist/src/api/chat.js

@@ -1,12 +1,16 @@
 import { drainBackgroundJobNotifications } from '../background-jobs.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, transportFailureDetail, normalizeServerUrl, readErrorResponse, } from './http.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 +22,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) {
@@ -52,6 +58,7 @@ function parseSseBlock(block) {
         return { event, data: text };
     }
 }
+let toolStateSeqCounter = 0;
 function toolStateFromSession(session) {
     return {
         autoYes: session.autoYes,
@@ -94,18 +101,43 @@ 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 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 historyHasToolCall(session, callId) {
     return session.history.some((entry) => (entry.parts ?? []).some((part) => String(part?.functionCall?.id ?? '') === callId));
 }
@@ -144,11 +176,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) {
@@ -185,9 +225,32 @@ async function postToolResult({ config, turnId, event, result, session, fetchImp
         toolCallId: event.call.id,
         result,
         toolState: toolStateFromSession(session),
+        toolStateSeq: ++toolStateSeqCounter,
+    };
+    const trace = createTraceContext(traceId);
+    const response = await tagTurnPhase('posting a tool result', () => fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/chat/turn/${encodeURIComponent(turnId)}/tool-result`, {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${config.token}`,
+            'content-type': 'application/json',
+            ...trace.headers,
+        },
+        body: JSON.stringify(payload),
+    }));
+    if (response.status === 410) {
+        return;
+    }
+    if (!response.ok) {
+        throw await readErrorResponse(response, trace.traceId);
+    }
+}
+async function postUserInputResult({ config, turnId, requestId, result, fetchImpl, traceId, }) {
+    const payload = {
+        requestId,
+        result,
     };
     const trace = createTraceContext(traceId);
-    const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/chat/turn/${encodeURIComponent(turnId)}/tool-result`, {
+    const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/chat/turn/${encodeURIComponent(turnId)}/user-input-result`, {
         method: 'POST',
         headers: {
             authorization: `Bearer ${config.token}`,
@@ -203,7 +266,54 @@ async function postToolResult({ config, turnId, event, result, session, fetchImp
         throw await readErrorResponse(response, trace.traceId);
     }
 }
-async function executeAndPostToolResult({ config, projectIndex, session, event, input, fetchImpl, signal, traceId, }) {
+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 response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/chat/turn/${encodeURIComponent(turnId)}/interject`, {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${config.token}`,
+            'content-type': 'application/json',
+            ...trace.headers,
+        },
+        body: JSON.stringify(payload),
+    });
+    if (response.status === 410) {
+        return 'stale';
+    }
+    if (!response.ok) {
+        throw await readErrorResponse(response, trace.traceId);
+    }
+    return 'delivered';
+}
+const turnIdOverrides = new WeakMap();
+function enterServerTurnId(session, serverSessionTurnId) {
+    const active = turnIdOverrides.get(session);
+    if (active) {
+        active.depth += 1;
+        return;
+    }
+    turnIdOverrides.set(session, {
+        previousTurnId: session.turnState.id,
+        depth: 1,
+    });
+    session.turnState.id = serverSessionTurnId;
+}
+function exitServerTurnId(session) {
+    const active = turnIdOverrides.get(session);
+    if (!active)
+        return;
+    active.depth -= 1;
+    if (active.depth === 0) {
+        session.turnState.id = active.previousTurnId;
+        turnIdOverrides.delete(session);
+    }
+}
+async function executeAndPostToolResult({ config, session, event, input, fetchImpl, signal, traceId, }) {
     const turnId = String(event?.turnId ?? '').trim();
     if (!turnId || !event?.call?.id || !event.call.name) {
         throw new Error('Server emitted an invalid tool-call event.');
@@ -211,17 +321,23 @@ async function executeAndPostToolResult({ config, projectIndex, session, event,
     if (signal?.aborted) {
         throw new TurnCancelledError();
     }
-    const previousTurnId = session.turnState.id;
     const serverSessionTurnId = String(event.sessionTurnId ?? '').trim();
     if (serverSessionTurnId) {
-        session.turnState.id = serverSessionTurnId;
+        enterServerTurnId(session, serverSessionTurnId);
         if (!session.clientState.safety.checkpoints.some((checkpoint) => checkpoint.turnId === serverSessionTurnId)) {
             createPromptCheckpoint(session.clientState.safety, 'prompt boundary', serverSessionTurnId);
         }
     }
     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();
@@ -237,10 +353,12 @@ async function executeAndPostToolResult({ config, projectIndex, session, event,
         });
     }
     finally {
-        session.turnState.id = previousTurnId;
+        if (serverSessionTurnId) {
+            exitServerTurnId(session);
+        }
     }
 }
-async function consumeTurnStream({ response, config, projectIndex, session, input, fetchImpl, signal, traceId, }) {
+async function consumeTurnStream({ response, config, session, input, fetchImpl, signal, traceId, onTurnStart, onInterjectionDelivered, }) {
     if (!response.body) {
         throw new Error('Server returned an empty chat stream.');
     }
@@ -250,8 +368,56 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
     const finalResult = {
         current: null,
     };
+    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;
+    }
+    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;
+        }
+    }
     async function handleEvent(event) {
+        if (event.event === 'turn-start') {
+            const turnId = String(event.data?.turnId ?? '').trim();
+            if (turnId)
+                onTurnStart?.(turnId);
+            return;
+        }
+        if (event.event === 'interjection-delivered') {
+            onInterjectionDelivered?.(event.data);
+            return;
+        }
         if (event.event === 'status') {
+            const data = event.data;
+            if (data?.phase === 'analyzing_image') {
+                session.onImageAnalysis?.(Math.max(1, Number(data.imageCount ?? 1) || 1));
+                session.onImageGeneration?.(false);
+            }
+            else if (data?.phase === 'generating_image') {
+                session.onImageGeneration?.(true);
+                session.onImageAnalysis?.(0);
+            }
+            else if (data?.phase) {
+                session.onImageAnalysis?.(0);
+                session.onImageGeneration?.(false);
+            }
             const message = publicStatusMessage(event.data);
             if (message)
                 session.onStatus(message);
@@ -261,11 +427,24 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
             return;
         }
         if (event.event === 'tool-call') {
+            const data = event.data;
+            if (data?.parallelSafe === true) {
+                pendingParallelTools.push(executeAndPostToolResult({
+                    config,
+                    session,
+                    event: data,
+                    input,
+                    fetchImpl,
+                    signal,
+                    traceId,
+                }).then(() => null, (error) => recordParallelFailure(error)));
+                return;
+            }
+            await drainParallelTools();
             await executeAndPostToolResult({
                 config,
-                projectIndex,
                 session,
-                event: event.data,
+                event: data,
                 input,
                 fetchImpl,
                 signal,
@@ -280,36 +459,75 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
             }
             return;
         }
+        if (event.event === 'user-input-request') {
+            await drainParallelTools();
+            const data = event.data;
+            const turnId = String(data?.turnId ?? '').trim();
+            const requestId = String(data?.requestId ?? '').trim();
+            if (!turnId ||
+                !requestId ||
+                !isUserInputQuestionArray(data?.questions)) {
+                throw new Error('Server emitted an invalid user-input request.');
+            }
+            if (!session.requestUserInput) {
+                throw new Error('Interactive user input is unavailable in this client.');
+            }
+            const result = await session.requestUserInput({ questions: data.questions }, signal);
+            if (signal?.aborted) {
+                throw new TurnCancelledError();
+            }
+            await postUserInputResult({
+                config,
+                turnId,
+                requestId,
+                result,
+                fetchImpl,
+                traceId,
+            });
+            return;
+        }
         if (event.event === 'result') {
+            await drainParallelTools();
             finalResult.current = event.data;
             return;
         }
         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);
             }
-            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);
+            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, event.data?.snapshot);
         }
     }
-    while (true) {
-        if (signal?.aborted) {
-            await reader.cancel().catch(() => { });
-            throw new TurnCancelledError();
-        }
-        const read = await reader.read();
-        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');
+    try {
+        while (true) {
+            if (signal?.aborted) {
+                await reader.cancel().catch(() => { });
+                throw new TurnCancelledError();
+            }
+            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');
+            }
         }
+        await drainParallelTools();
+    }
+    catch (error) {
+        await reader.cancel().catch(() => { });
+        throw error;
+    }
+    finally {
+        await drainParallelTools().catch(() => { });
     }
     buffer += decoder.decode();
     const tail = buffer.trim();
@@ -323,7 +541,7 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
     }
     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, }) {
     const autoAttach = autoAttachImages(input, session.rootDir, imageAttachments);
     const requestImageAttachments = autoAttach.attachments.length > 0
         ? [...imageAttachments, ...autoAttach.attachments]
@@ -342,8 +560,11 @@ export async function sendServerUserMessage({ config, projectIndex, session, inp
         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,
     };
@@ -357,7 +578,7 @@ export async function sendServerUserMessage({ config, projectIndex, session, inp
         signal?.addEventListener('abort', preserveOnAbort, { once: true });
     }
     try {
-        const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/chat/turn`, {
+        const response = await tagTurnPhase('opening the turn', () => fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/chat/turn`, {
             method: 'POST',
             headers: {
                 accept: 'text/event-stream',
@@ -367,20 +588,21 @@ export async function sendServerUserMessage({ config, projectIndex, session, inp
             },
             body: JSON.stringify(request),
             signal,
-        });
+        }));
         if (!response.ok) {
             throw await readErrorResponse(response, trace.traceId);
         }
-        const result = await consumeTurnStream({
+        const result = await tagTurnPhase('reading the turn stream', () => consumeTurnStream({
             response,
             config,
-            projectIndex,
             session,
             input: requestInputBase,
             fetchImpl,
             signal,
             traceId: trace.traceId,
-        });
+            onTurnStart,
+            onInterjectionDelivered,
+        }));
         applySessionSnapshot(session, result.snapshot, { preserveAgentMode: true });
         return {
             text: result.text,
@@ -396,11 +618,31 @@ 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 transportDetail = error instanceof ChatTurnFailedError ? 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}]`;
+        }
+        const category = error instanceof ChatTurnFailedError
+            ? error.category
+            :
+                gatewayFailureCategory(error) ?? 'unknown_error';
+        const partial = error instanceof ChatTurnFailedError ? error.partialSnapshot : undefined;
+        if (partial) {
+            applySessionSnapshot(session, partial, { preserveAgentMode: true });
+        }
+        else {
+            session.history.length = preTurnHistoryLength;
+            preserveFailedTurnInput(session, requestInputBase, category);
+        }
+        try {
+            saveSessionState(session, session.env);
+        }
+        catch { }
         throw error;
     }
     finally {
         signal?.removeEventListener('abort', preserveOnAbort);
+        releaseBrowserAfterTurn();
     }
 }

package/dist/src/api/contracts.js

@@ -1 +1,55 @@
-export {};
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+const USER_INPUT_ID_PATTERN = /^[a-z][a-z0-9_]*$/;
+export function isUserInputQuestionArray(value) {
+    if (!Array.isArray(value) || value.length < 1 || value.length > 4) {
+        return false;
+    }
+    const questionIds = new Set();
+    return value.every((question) => {
+        if (!question || typeof question !== 'object' || Array.isArray(question)) {
+            return false;
+        }
+        const candidate = question;
+        if (!nonEmptyString(candidate.id) ||
+            !USER_INPUT_ID_PATTERN.test(candidate.id) ||
+            questionIds.has(candidate.id) ||
+            !nonEmptyString(candidate.header) ||
+            Array.from(candidate.header).length > 12 ||
+            !nonEmptyString(candidate.question) ||
+            typeof candidate.multiSelect !== 'boolean' ||
+            !Array.isArray(candidate.options) ||
+            candidate.options.length < 2 ||
+            candidate.options.length > 4) {
+            return false;
+        }
+        questionIds.add(candidate.id);
+        const optionIds = new Set();
+        const optionsValid = candidate.options.every((option) => {
+            if (!option || typeof option !== 'object' || Array.isArray(option)) {
+                return false;
+            }
+            const item = option;
+            if (!nonEmptyString(item.id) ||
+                !USER_INPUT_ID_PATTERN.test(item.id) ||
+                optionIds.has(item.id) ||
+                !nonEmptyString(item.label) ||
+                !nonEmptyString(item.description)) {
+                return false;
+            }
+            optionIds.add(item.id);
+            return true;
+        });
+        if (!optionsValid) {
+            return false;
+        }
+        if (candidate.recommendedOptionId !== undefined &&
+            (!nonEmptyString(candidate.recommendedOptionId) ||
+                candidate.recommendedOptionId !==
+                    candidate.options[0].id)) {
+            return false;
+        }
+        return true;
+    });
+}

package/dist/src/api/default-host.js

@@ -0,0 +1 @@
+export const DEFAULT_THEGITAI_HOST = 'https://thegit.ai';