@ccpocket/bridge 1.72.2 → 1.72.3

package/dist/sdk-process.js

@@ -89,6 +89,7 @@ export function hasExplicitClaudeCredential(env = process.env) {
 function canStartClaudeSdk(env = process.env) {
     return hasExplicitClaudeCredential(env) || isClaudeOAuthOptInEnabled(env);
 }
+const CLAUDE_AUTH_RESOLUTION_TIMEOUT_MS = 500;
 export async function listAvailableClaudeModels(projectPath) {
     if (!canStartClaudeSdk()) {
         throw new Error(CLAUDE_OAUTH_OPT_IN_MESSAGE);
@@ -260,6 +261,63 @@ export function buildAskUserAnswers(input, result) {
 export function resolvePermissionMode(current, requested) {
     return requested ?? current;
 }
+const CLAUDE_SYSTEM_INJECTED_USER_TEXT = /^<(?:local-command-caveat|local-command-std(?:err|out)|task-notification|teammate-message|bash-(?:input|stdout))>/;
+const UNKNOWN_CLAUDE_ASSISTANT_ERROR = {
+    message: "Claude stopped because of an unknown request error.",
+    errorCode: "claude_assistant_error",
+};
+const CLAUDE_ASSISTANT_ERRORS = {
+    authentication_failed: {
+        message: "Claude authentication failed. Sign in again on the Bridge machine.",
+        errorCode: "auth_token_expired",
+    },
+    oauth_org_not_allowed: {
+        message: "This Claude subscription organization cannot be used by the Agent SDK.",
+        errorCode: "claude_oauth_org_not_allowed",
+    },
+    billing_error: {
+        message: "Claude could not continue because of an account billing error.",
+        errorCode: "claude_billing_error",
+    },
+    rate_limit: {
+        message: "Claude is temporarily rate limited. Try again shortly.",
+        errorCode: "claude_rate_limit",
+    },
+    invalid_request: {
+        message: "Claude rejected this request as invalid.",
+        errorCode: "claude_invalid_request",
+    },
+    model_not_found: {
+        message: "The selected Claude model is not available for this account.",
+        errorCode: "claude_model_not_found",
+    },
+    server_error: {
+        message: "Claude encountered a server error.",
+        errorCode: "claude_server_error",
+    },
+    unknown: UNKNOWN_CLAUDE_ASSISTANT_ERROR,
+    max_output_tokens: {
+        message: "Claude reached the maximum response length before finishing.",
+        errorCode: "claude_max_output_tokens",
+    },
+};
+function claudeAssistantErrorMessage(error) {
+    if (typeof error !== "string" || error.length === 0)
+        return null;
+    const details = Object.hasOwn(CLAUDE_ASSISTANT_ERRORS, error)
+        ? CLAUDE_ASSISTANT_ERRORS[error]
+        : UNKNOWN_CLAUDE_ASSISTANT_ERROR;
+    return { type: "error", ...details };
+}
+function isInternalClaudeResultError(error) {
+    return (error.startsWith("[ede_diagnostic]") ||
+        error.includes("Bun is not defined"));
+}
+function isClaudeSystemInjectedUserText(text) {
+    const normalized = text.trimStart();
+    return (CLAUDE_SYSTEM_INJECTED_USER_TEXT.test(normalized) ||
+        normalized.startsWith("Base directory for this skill:"));
+}
 /**
  * Convert SDK messages to the ServerMessage format used by the WebSocket protocol.
  * Exported for testing.
@@ -281,13 +339,39 @@ export function sdkMessageToServerMessage(msg) {
             if (sys.subtype === "compact_boundary") {
                 return { type: "status", status: "compacting" };
             }
+            if (sys.subtype === "status" && sys.compact_result === "failed") {
+                const compactError = typeof sys.compact_error === "string" ? sys.compact_error.trim() : "";
+                return {
+                    type: "error",
+                    message: compactError
+                        ? `Claude context compaction failed: ${compactError}`
+                        : "Claude context compaction failed.",
+                    errorCode: "claude_compaction_failed",
+                };
+            }
             return null;
         }
         case "assistant": {
             const ast = msg;
+            const rawContent = ast.message.content;
+            const content = Array.isArray(rawContent)
+                ? rawContent.filter((block) => {
+                    if (!block || typeof block !== "object")
+                        return true;
+                    const candidate = block;
+                    return !(candidate.type === "thinking" &&
+                        typeof candidate.thinking === "string" &&
+                        candidate.thinking.trim().length === 0);
+                })
+                : rawContent;
+            if (Array.isArray(content) && content.length === 0)
+                return null;
             return {
                 type: "assistant",
-                message: ast.message,
+                message: {
+                    ...ast.message,
+                    content,
+                },
                 ...(ast.uuid ? { messageUuid: ast.uuid } : {}),
             };
         }
@@ -317,11 +401,13 @@ export function sdkMessageToServerMessage(msg) {
                 .filter((c) => c.type === "text")
                 .map((c) => c.text);
             if (texts.length > 0) {
+                const isSynthetic = usr.isSynthetic === true ||
+                    texts.every(isClaudeSystemInjectedUserText);
                 return {
                     type: "user_input",
                     text: texts.join("\n"),
                     ...(usr.uuid ? { userMessageUuid: usr.uuid } : {}),
-                    ...(usr.isSynthetic ? { isSynthetic: true } : {}),
+                    ...(isSynthetic ? { isSynthetic: true } : {}),
                     ...(usr.isMeta ? { isMeta: true } : {}),
                 };
             }
@@ -342,12 +428,19 @@ export function sdkMessageToServerMessage(msg) {
                     ...tokenUsage,
                 };
             }
-            // All other result subtypes are errors
-            const errorText = Array.isArray(res.errors) ? res.errors.join("\n") : "Unknown error";
-            // Suppress spurious CLI runtime errors (SDK bug: Bun API referenced on Node.js)
-            if (errorText.includes("Bun is not defined")) {
+            // Claude Code can misclassify a routine interrupt as
+            // error_during_execution and prepend an internal-only EDE diagnostic.
+            // Its own terminal renderer filters these records, so keep the same
+            // boundary here while preserving any accompanying real error.
+            const rawErrors = Array.isArray(res.errors)
+                ? res.errors.filter((error) => typeof error === "string")
+                : [];
+            const visibleErrors = rawErrors.filter((error) => !isInternalClaudeResultError(error));
+            if (rawErrors.length > 0 && visibleErrors.length === 0) {
                 return null;
             }
+            // All other result subtypes are errors
+            const errorText = visibleErrors.length > 0 ? visibleErrors.join("\n") : "Unknown error";
             return {
                 type: "result",
                 subtype: "error",
@@ -394,6 +487,10 @@ export class SdkProcess extends EventEmitter {
     get permissionMode() { return this._permissionMode; }
     _model;
     get model() { return this._model; }
+    authClassification = "unknown";
+    authGeneration = 0;
+    authResolution = Promise.resolve();
+    authResolutionPending = false;
     sessionAllowRules = new Set();
     initTimeoutId = null;
     sessionEndEmitted = false;
@@ -404,6 +501,7 @@ export class SdkProcess extends EventEmitter {
     _projectPath = null;
     toolCallsSinceLastResult = 0;
     fileEditsSinceLastResult = 0;
+    pendingAssistantError = null;
     launchStartedAt = 0;
     get status() {
         return this._status;
@@ -432,6 +530,10 @@ export class SdkProcess extends EventEmitter {
         }
         this.stopped = false;
         this._sessionId = null;
+        this.authGeneration += 1;
+        this.authClassification = "unknown";
+        this.authResolution = Promise.resolve();
+        this.authResolutionPending = false;
         this.sessionEndEmitted = false;
         this.pendingPermissions.clear();
         this.permissionModeGeneration += 1;
@@ -440,6 +542,7 @@ export class SdkProcess extends EventEmitter {
         this.sessionAllowRules.clear();
         this.toolCallsSinceLastResult = 0;
         this.fileEditsSinceLastResult = 0;
+        this.pendingAssistantError = null;
         this.launchStartedAt = Date.now();
         if (options?.initialInput) {
             this.pendingInputQueue.push({ text: options.initialInput });
@@ -528,14 +631,19 @@ export class SdkProcess extends EventEmitter {
                 },
             },
         });
+        const queryInstance = this.queryInstance;
+        const authGeneration = this.authGeneration;
+        this.authResolution = this.resolveAuthClassification(queryInstance, authGeneration);
         // Background message processing
-        this.processMessages().catch((err) => {
-            if (this.stopped) {
+        this.processMessages(authGeneration, this.authResolution).catch((err) => {
+            if (this.stopped || authGeneration !== this.authGeneration) {
                 // Suppress errors from intentional stop (SDK bug: Bun API referenced on Node.js)
                 return;
             }
             console.error("[sdk-process] Message processing error:", err);
-            this.emitMessage({ type: "error", message: `SDK error: ${err instanceof Error ? err.message : String(err)}` });
+            if (!this.flushPendingAssistantError()) {
+                this.emitMessage({ type: "error", message: `SDK error: ${err instanceof Error ? err.message : String(err)}` });
+            }
             this.stop();
             this.emit("exit", 1);
         });
@@ -548,6 +656,10 @@ export class SdkProcess extends EventEmitter {
             this.initTimeoutId = null;
         }
         this.stopped = true;
+        this.authGeneration += 1;
+        this.authClassification = "unknown";
+        this.authResolution = Promise.resolve();
+        this.authResolutionPending = false;
         this.pendingInputQueue = [];
         if (this.queryInstance) {
             console.log("[sdk-process] Stopping query");
@@ -558,6 +670,7 @@ export class SdkProcess extends EventEmitter {
         this.userMessageResolve = null;
         this.toolCallsSinceLastResult = 0;
         this.fileEditsSinceLastResult = 0;
+        this.pendingAssistantError = null;
         // Emit session_end so listeners can re-persist metadata before cleanup.
         // processMessages() won't reach its session_end emit because close()
         // causes the iterator to throw and the error is suppressed.
@@ -596,15 +709,7 @@ export class SdkProcess extends EventEmitter {
         }
         const resolve = this.userMessageResolve;
         this.userMessageResolve = null;
-        resolve({
-            type: "user",
-            session_id: this._sessionId ?? "",
-            message: {
-                role: "user",
-                content: [{ type: "text", text }],
-            },
-            parent_tool_use_id: null,
-        });
+        this.resolveUserMessage(resolve, text);
         return { queued: false, shouldInterrupt: false };
     }
     sendInput(text) {
@@ -625,31 +730,9 @@ export class SdkProcess extends EventEmitter {
         }
         const resolve = this.userMessageResolve;
         this.userMessageResolve = null;
-        const content = [];
-        // Add image blocks first (Claude processes images before text)
-        for (const image of images) {
-            content.push({
-                type: "image",
-                source: {
-                    type: "base64",
-                    media_type: image.mimeType,
-                    data: image.base64,
-                },
-            });
-        }
-        // Add text block
-        content.push({ type: "text", text });
         const totalKB = images.reduce((sum, img) => sum + Math.round(img.base64.length / 1024), 0);
         console.log(`[sdk-process] Sending message with ${images.length} image(s) (${totalKB}KB base64 total)`);
-        resolve({
-            type: "user",
-            session_id: this._sessionId ?? "",
-            message: {
-                role: "user",
-                content,
-            },
-            parent_tool_use_id: null,
-        });
+        this.resolveUserMessage(resolve, text, images);
         return { queued: false, shouldInterrupt: false };
     }
     sendInputWithImages(text, images) {
@@ -886,33 +969,16 @@ export class SdkProcess extends EventEmitter {
     }
     async *createUserMessageStream() {
         while (!this.stopped) {
-            // Drain queued messages first (FIFO order)
-            if (this.pendingInputQueue.length > 0) {
+            // A queued mid-turn input must wait for result so it cannot overtake
+            // the interrupted turn. Once idle, each consumer request drains FIFO.
+            const turnInProgress = this._status === "running" ||
+                this._status === "compacting" ||
+                this._status === "waiting_approval";
+            if (this.pendingInputQueue.length > 0 && !turnInProgress) {
                 const { text, images } = this.pendingInputQueue.shift();
                 console.log(`[sdk-process] Sending queued input${images ? ` with ${images.length} image(s)` : ""} (remaining: ${this.pendingInputQueue.length})`);
-                const content = [];
-                if (images) {
-                    for (const image of images) {
-                        content.push({
-                            type: "image",
-                            source: {
-                                type: "base64",
-                                media_type: image.mimeType,
-                                data: image.base64,
-                            },
-                        });
-                    }
-                }
-                content.push({ type: "text", text });
-                yield {
-                    type: "user",
-                    session_id: this._sessionId ?? "",
-                    message: {
-                        role: "user",
-                        content,
-                    },
-                    parent_tool_use_id: null,
-                };
+                this.setStatus("running");
+                yield this.buildUserMessage(text, images);
                 continue;
             }
             const msg = await new Promise((resolve) => {
@@ -923,30 +989,99 @@ export class SdkProcess extends EventEmitter {
             yield msg;
         }
     }
-    async processMessages() {
+    async resolveAuthClassification(queryInstance, generation) {
+        if (!queryInstance)
+            return;
+        const initializationResult = queryInstance.initializationResult;
+        if (typeof initializationResult !== "function")
+            return;
+        this.authResolutionPending = true;
+        const initializationPromise = Promise.resolve().then(() => initializationResult.call(queryInstance));
+        const settlement = (async () => {
+            try {
+                const initialization = await initializationPromise;
+                if (generation !== this.authGeneration)
+                    return;
+                this.authResolutionPending = false;
+                this.applyAuthSource(initialization.account?.apiKeySource, generation);
+            }
+            catch (error) {
+                if (generation !== this.authGeneration)
+                    return;
+                this.authResolutionPending = false;
+                console.warn(`[sdk-process] Could not resolve Claude auth source: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        })();
+        let timeoutId;
+        try {
+            const timeout = new Promise((resolve) => {
+                timeoutId = setTimeout(() => resolve(false), CLAUDE_AUTH_RESOLUTION_TIMEOUT_MS);
+            });
+            const settledBeforeTimeout = await Promise.race([
+                settlement.then(() => true),
+                timeout,
+            ]);
+            if (!settledBeforeTimeout && generation === this.authGeneration) {
+                console.warn("[sdk-process] Timed out resolving Claude auth source");
+            }
+        }
+        finally {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+        }
+    }
+    applyAuthSource(source, generation) {
+        if (generation !== this.authGeneration)
+            return true;
+        if (source === "oauth") {
+            this.authClassification = "subscription";
+        }
+        else if (typeof source === "string" &&
+            this.authClassification === "unknown") {
+            this.authClassification = "api_key";
+        }
+        if (this.authClassification === "subscription" &&
+            !isClaudeOAuthOptInEnabled()) {
+            console.log("[sdk-process] OAuth auth source requires explicit opt-in");
+            this.emitMessage({
+                type: "error",
+                message: CLAUDE_OAUTH_OPT_IN_MESSAGE,
+                errorCode: CLAUDE_OAUTH_OPT_IN_ERROR_CODE,
+            });
+            this.stop();
+            this.emit("exit", 1);
+            return false;
+        }
+        return true;
+    }
+    async processMessages(authGeneration, authResolution) {
         if (!this.queryInstance)
             return;
         for await (const message of this.queryInstance) {
-            if (this.stopped)
+            if (this.stopped || authGeneration !== this.authGeneration)
                 break;
             if (message.type === "system" &&
                 "subtype" in message &&
                 message.subtype === "init" &&
-                message.apiKeySource === "oauth" &&
-                !isClaudeOAuthOptInEnabled()) {
-                console.log("[sdk-process] OAuth auth source requires explicit opt-in");
-                this.emitMessage({
-                    type: "error",
-                    message: CLAUDE_OAUTH_OPT_IN_MESSAGE,
-                    errorCode: CLAUDE_OAUTH_OPT_IN_ERROR_CODE,
-                });
-                this.stop();
-                this.emit("exit", 1);
+                !this.applyAuthSource(message.apiKeySource, authGeneration)) {
                 return;
             }
             // Convert SDK message to ServerMessage
             let serverMsg = sdkMessageToServerMessage(message);
+            if (message.type === "assistant" && this.pendingAssistantError === null) {
+                this.pendingAssistantError = claudeAssistantErrorMessage(message.error);
+            }
             if (serverMsg?.type === "result") {
+                if (this.authClassification !== "subscription") {
+                    await authResolution;
+                }
+                if (this.stopped || authGeneration !== this.authGeneration)
+                    return;
+                if (this.authClassification !== "api_key" ||
+                    this.authResolutionPending) {
+                    const { cost: _estimatedApiCost, ...withoutCost } = serverMsg;
+                    serverMsg = withoutCost;
+                }
                 if (this.toolCallsSinceLastResult > 0 || this.fileEditsSinceLastResult > 0) {
                     serverMsg = {
                         ...serverMsg,
@@ -961,6 +1096,23 @@ export class SdkProcess extends EventEmitter {
                 this.toolCallsSinceLastResult = 0;
                 this.fileEditsSinceLastResult = 0;
             }
+            if (message.type === "result" && this.pendingAssistantError) {
+                const result = message;
+                const hasRealResultError = serverMsg?.type === "result" &&
+                    serverMsg.subtype === "error" &&
+                    Array.isArray(result.errors) &&
+                    result.errors.some((error) => typeof error === "string" &&
+                        !isInternalClaudeResultError(error));
+                if (!hasRealResultError) {
+                    this.flushPendingAssistantError();
+                    if (serverMsg?.type === "result" && serverMsg.subtype === "error") {
+                        serverMsg = null;
+                    }
+                }
+                else {
+                    this.pendingAssistantError = null;
+                }
+            }
             if (serverMsg) {
                 this.emitMessage(serverMsg);
             }
@@ -1000,7 +1152,17 @@ export class SdkProcess extends EventEmitter {
             // Update status from message type
             this.updateStatusFromMessage(message);
         }
+        await authResolution;
+        if (this.stopped || authGeneration !== this.authGeneration)
+            return;
+        this.flushPendingAssistantError();
         // Query finished — CLI has completed shutdown including file writes.
+        // Treat natural completion as the end of this auth generation so an
+        // initializationResult that settles after the timeout cannot emit a
+        // second, contradictory terminal event for an already-finished query.
+        this.authGeneration += 1;
+        this.authResolutionPending = false;
+        this.authResolution = Promise.resolve();
         this.queryInstance = null;
         // Emit session_end before exit so listeners can re-persist metadata
         // (e.g. customTitle) that the CLI may have overwritten during shutdown.
@@ -1008,6 +1170,14 @@ export class SdkProcess extends EventEmitter {
         this.setStatus("idle");
         this.emit("exit", 0);
     }
+    flushPendingAssistantError() {
+        if (!this.pendingAssistantError)
+            return false;
+        const message = this.pendingAssistantError;
+        this.pendingAssistantError = null;
+        this.emitMessage(message);
+        return true;
+    }
     /**
      * Core permission handler: called by SDK before each tool execution.
      * Returns a Promise that resolves when the user approves/rejects.
@@ -1053,9 +1223,21 @@ export class SdkProcess extends EventEmitter {
     }
     updateStatusFromMessage(msg) {
         switch (msg.type) {
-            case "system":
-                // Already handled in processMessages for init
+            case "system": {
+                const system = msg;
+                if (system.subtype === "status") {
+                    if (system.status === "compacting") {
+                        this.setStatus("compacting");
+                    }
+                    else if (system.status === "requesting") {
+                        this.setStatus("running");
+                    }
+                    else if (system.status === null && this._status === "compacting") {
+                        this.setStatus("running");
+                    }
+                }
                 break;
+            }
             case "assistant":
                 if (this.pendingPermissions.size === 0) {
                     this.setStatus("running");
@@ -1069,9 +1251,45 @@ export class SdkProcess extends EventEmitter {
             case "result":
                 this.pendingPermissions.clear();
                 this.setStatus("idle");
+                this.deliverQueuedInputIfWaiting();
                 break;
         }
     }
+    buildUserMessage(text, images) {
+        const content = [];
+        if (images) {
+            for (const image of images) {
+                content.push({
+                    type: "image",
+                    source: {
+                        type: "base64",
+                        media_type: image.mimeType,
+                        data: image.base64,
+                    },
+                });
+            }
+        }
+        content.push({ type: "text", text });
+        return {
+            type: "user",
+            session_id: this._sessionId ?? "",
+            message: { role: "user", content },
+            parent_tool_use_id: null,
+        };
+    }
+    deliverQueuedInputIfWaiting() {
+        const resolve = this.userMessageResolve;
+        const queued = this.pendingInputQueue[0];
+        if (!resolve || !queued)
+            return;
+        this.userMessageResolve = null;
+        this.pendingInputQueue.shift();
+        this.resolveUserMessage(resolve, queued.text, queued.images);
+    }
+    resolveUserMessage(resolve, text, images) {
+        this.setStatus("running");
+        resolve(this.buildUserMessage(text, images));
+    }
     handlePostToolUseHook(input) {
         if (!input || typeof input !== "object" || Array.isArray(input)) {
             return;