@thegitai/cli 1.0.0-preview.3 → 1.0.0-preview.31

package/dist/src/api/chat.js

@@ -1,11 +1,14 @@
 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, normalizeServerUrl, readErrorResponse, } from './http.js';
 import { collectClientEnvironment } from '../client-environment.js';
 import { collectProjectOrientation } from '../project-orientation.js';
 import { autoAttachImages } from '../core/image-path-extractor.js';
+import { formatTurnFailureMarker } from '../turn-failure-marker.js';
 export class TurnCancelledError extends Error {
     name = 'TurnCancelledError';
     constructor(message = 'Turn cancelled.') {
@@ -17,11 +20,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) {
@@ -51,6 +56,7 @@ function parseSseBlock(block) {
         return { event, data: text };
     }
 }
+let toolStateSeqCounter = 0;
 function toolStateFromSession(session) {
     return {
         autoYes: session.autoYes,
@@ -93,17 +99,30 @@ 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: `Turn failed before completion: ${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));
@@ -143,11 +162,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) {
@@ -184,6 +211,7 @@ 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 fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/chat/turn/${encodeURIComponent(turnId)}/tool-result`, {
@@ -202,7 +230,76 @@ 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, }) {
+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)}/user-input-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);
+    }
+}
+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.');
@@ -210,17 +307,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();
@@ -236,10 +339,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.');
     }
@@ -249,8 +354,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);
@@ -260,11 +413,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,
@@ -279,36 +445,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();
@@ -322,7 +527,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]
@@ -373,12 +578,13 @@ export async function sendServerUserMessage({ config, projectIndex, session, inp
         const result = await consumeTurnStream({
             response,
             config,
-            projectIndex,
             session,
             input: requestInputBase,
             fetchImpl,
             signal,
             traceId: trace.traceId,
+            onTurnStart,
+            onInterjectionDelivered,
         });
         applySessionSnapshot(session, result.snapshot, { preserveAgentMode: true });
         return {
@@ -395,8 +601,22 @@ 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 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 {

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';

package/dist/src/api/http.js

@@ -1,16 +1,18 @@
 import { randomUUID } from 'node:crypto';
-const DEFAULT_SERVER_URL = 'https://thegit.ai';
+import { DEFAULT_THEGITAI_HOST } from './default-host.js';
 export const TRACE_ID_HEADER = 'x-thegitai-trace-id';
 export const CLIENT_HEADER = 'x-thegitai-client';
 export const CLIENT_PLATFORM_HEADER = 'x-thegitai-client-platform';
 export class ServerApiError extends Error {
     status;
     traceId;
-    constructor(message, status, traceId) {
+    code;
+    constructor(message, status, traceId, code = '') {
         super(traceId ? `${message}\nTrace ID: ${traceId}` : message);
         this.name = 'ServerApiError';
         this.status = status;
         this.traceId = traceId;
+        this.code = code;
     }
 }
 export function createTraceId() {
@@ -27,6 +29,14 @@ export function createTraceContext(traceId = createTraceId()) {
     };
 }
 export const REQUEST_TIMEOUT_MS = 8000;
+export const STARTUP_REQUEST_TIMEOUT_MS = 3000;
+export const STARTUP_DEADLINE_MS = 10_000;
+export const STARTUP_RETRY_BUDGET = {
+    retries: 3,
+    baseDelayMs: 200,
+    deadlineMs: STARTUP_DEADLINE_MS,
+    timeoutMs: STARTUP_REQUEST_TIMEOUT_MS,
+};
 const TRANSIENT_NETWORK_CODES = new Set([
     'ECONNRESET',
     'ECONNREFUSED',
@@ -58,7 +68,9 @@ export function isTransientNetworkError(error) {
     }
     return false;
 }
-export async function retryTransient(run, { retries = 2, baseDelayMs = 400 } = {}) {
+export async function retryTransient(run, { retries = 2, baseDelayMs = 400, deadlineMs, now = () => Date.now(), } = {}) {
+    const startedAt = now();
+    const remainingMs = () => deadlineMs == null ? Infinity : deadlineMs - (now() - startedAt);
     let attempt = 0;
     for (;;) {
         try {
@@ -68,13 +80,15 @@ export async function retryTransient(run, { retries = 2, baseDelayMs = 400 } = {
             if (attempt >= retries || !isTransientNetworkError(error))
                 throw error;
             const delayMs = baseDelayMs * 2 ** attempt;
+            if (remainingMs() <= delayMs)
+                throw error;
             attempt += 1;
             await new Promise((resolve) => setTimeout(resolve, delayMs));
         }
     }
 }
 export function normalizeServerUrl(serverUrl) {
-    const normalized = String(serverUrl || DEFAULT_SERVER_URL)
+    const normalized = String(serverUrl || DEFAULT_THEGITAI_HOST)
         .trim()
         .replace(/\/+$/, '');
     if (!/^https?:\/\//i.test(normalized)) {
@@ -82,6 +96,41 @@ export function normalizeServerUrl(serverUrl) {
     }
     return normalized;
 }
+const MAX_NON_JSON_BODY_CHARS = 200;
+const GATEWAY_STATUS_MESSAGES = {
+    502: 'Could not reach the TheGitAI server (bad gateway).',
+    503: 'The TheGitAI server is temporarily unavailable.',
+    504: 'The TheGitAI server did not respond in time (gateway timeout).',
+    520: 'The connection to the TheGitAI server failed (edge error 520).',
+    521: 'The TheGitAI server is not accepting connections (edge error 521).',
+    522: 'The connection to the TheGitAI server timed out (edge error 522).',
+    523: 'The TheGitAI server is unreachable (edge error 523).',
+    524: 'The TheGitAI server did not respond in time (edge error 524).',
+};
+function truncateByCodePoint(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const points = Array.from(text);
+    if (points.length <= maxChars)
+        return text;
+    return `${points.slice(0, maxChars).join('').trimEnd()}…`;
+}
+export function nonJsonErrorMessage(body, status) {
+    const rayId = /Cloudflare Ray ID:\s*(?:<[^>]*>\s*)*([0-9a-f]{8,})/i.exec(body)?.[1];
+    const gateway = GATEWAY_STATUS_MESSAGES[status];
+    const summary = truncateByCodePoint(body
+        .replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1>/gi, ' ')
+        .replace(/<[^>]*>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim(), MAX_NON_JSON_BODY_CHARS);
+    const base = gateway ?? (summary || `Request failed with ${status}`);
+    return rayId ? `${base} (Cloudflare Ray ID: ${rayId})` : base;
+}
+export function gatewayFailureCategory(error) {
+    if (!(error instanceof ServerApiError))
+        return null;
+    return error.status in GATEWAY_STATUS_MESSAGES ? 'gateway_error' : null;
+}
 export async function readJsonResponse(response) {
     const text = await response.text();
     if (!text.trim())
@@ -90,15 +139,28 @@ export async function readJsonResponse(response) {
         return JSON.parse(text);
     }
     catch {
-        return { error: { message: text } };
+        return {
+            error: { message: nonJsonErrorMessage(text, response.status) },
+        };
     }
 }
 export function failureMessage(data, status) {
     return String(data?.error?.message ?? data?.message ?? `Request failed with ${status}`);
 }
+export function failureCode(data) {
+    return typeof data?.error?.code === 'string' ? data.error.code : '';
+}
+export function isAuthenticationError(error) {
+    return error instanceof ServerApiError && error.status === 401;
+}
+export function authenticationErrorMessage(error) {
+    return error.code === 'AUTH_TOKEN_EXPIRED'
+        ? 'Your login expired after 48 hours of inactivity. Run `ai login` and resume this saved session.'
+        : 'Your login is no longer valid. Run `ai login` and resume this saved session.';
+}
 export async function readErrorResponse(response, traceId = response.headers.get(TRACE_ID_HEADER) ?? '') {
     const data = await readJsonResponse(response);
-    return new ServerApiError(failureMessage(data, response.status), response.status, traceId);
+    return new ServerApiError(failureMessage(data, response.status), response.status, traceId, failureCode(data));
 }
 export async function authorizedJson({ config, path, method = 'GET', body = null, headers = {}, fetchImpl = globalThis.fetch, timeoutMs = REQUEST_TIMEOUT_MS, }) {
     const trace = createTraceContext();
@@ -115,7 +177,7 @@ export async function authorizedJson({ config, path, method = 'GET', body = null
     });
     const data = await readJsonResponse(response);
     if (!response.ok) {
-        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId);
+        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId, failureCode(data));
     }
     return data;
 }