@letta-ai/letta-code 0.21.10 → 0.21.11

package/letta.js

@@ -3269,7 +3269,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.21.10",
+    version: "0.21.11",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -73402,18 +73402,29 @@ var init_turn_recovery_policy = __esm(() => {
 });
 
 // src/agent/approval-recovery.ts
-async function fetchRunErrorDetail(runId) {
+async function fetchRunErrorInfo(runId) {
   if (!runId)
     return null;
   try {
     const client = await getClient();
     const run = await client.runs.retrieve(runId);
     const metaError = run.metadata?.error;
-    return metaError?.detail ?? metaError?.message ?? metaError?.error?.detail ?? metaError?.error?.message ?? null;
+    const nestedError = metaError?.error;
+    const errorInfo = {
+      error_type: metaError?.error_type ?? metaError?.type ?? nestedError?.error_type ?? nestedError?.type,
+      message: metaError?.message ?? nestedError?.message,
+      detail: metaError?.detail ?? nestedError?.detail,
+      run_id: metaError?.run_id ?? nestedError?.run_id ?? runId
+    };
+    return errorInfo.error_type || errorInfo.message || errorInfo.detail ? errorInfo : null;
   } catch {
     return null;
   }
 }
+async function fetchRunErrorDetail(runId) {
+  const errorInfo = await fetchRunErrorInfo(runId);
+  return errorInfo?.detail ?? errorInfo?.message ?? null;
+}
 var init_approval_recovery = __esm(async () => {
   init_turn_recovery_policy();
   await init_client2();
@@ -75857,6 +75868,7 @@ class StreamProcessor {
       const errorDetail = chunkWithError.error.detail || "";
       errorInfo = {
         message: errorDetail ? `${errorText}: ${errorDetail}` : errorText,
+        detail: errorDetail || undefined,
         run_id: this.lastRunId || undefined
       };
     }
@@ -77186,13 +77198,52 @@ function requestApprovalOverWS(runtime, socket, requestId, controlRequest) {
   if (socket.readyState !== WebSocket.OPEN) {
     return Promise.reject(new Error("WebSocket not open"));
   }
+  const abortSignal = runtime.activeAbortController?.signal ?? null;
+  const isInterrupted = () => runtime.cancelRequested || abortSignal?.aborted === true;
+  if (isInterrupted()) {
+    return Promise.reject(new Error("Cancelled by user"));
+  }
   return new Promise((resolve23, reject) => {
+    let settled = false;
+    const cleanupAbortListener = () => {
+      abortSignal?.removeEventListener("abort", handleAbort);
+    };
+    const wrappedResolve = (response) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanupAbortListener();
+      resolve23(response);
+    };
+    const wrappedReject = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanupAbortListener();
+      reject(error);
+    };
+    const handleAbort = () => {
+      runtime.pendingApprovalResolvers.delete(requestId);
+      runtime.listener.approvalRuntimeKeyByRequestId.delete(requestId);
+      wrappedReject(new Error("Cancelled by user"));
+    };
+    abortSignal?.addEventListener("abort", handleAbort, { once: true });
+    if (isInterrupted()) {
+      handleAbort();
+      return;
+    }
     runtime.pendingApprovalResolvers.set(requestId, {
-      resolve: resolve23,
-      reject,
+      resolve: wrappedResolve,
+      reject: wrappedReject,
       controlRequest
     });
     runtime.listener.approvalRuntimeKeyByRequestId.set(requestId, runtime.key);
+    if (isInterrupted()) {
+      handleAbort();
+      return;
+    }
     runtime.lastStopReason = "requires_approval";
     setLoopStatus(runtime, "WAITING_ON_APPROVAL");
     emitLoopStatusIfOpen(runtime.listener, {
@@ -77489,12 +77540,18 @@ function populateInterruptQueue(runtime, input) {
   return false;
 }
 function consumeInterruptQueue(runtime, agentId, conversationId) {
+  const ctx = runtime.pendingInterruptedContext;
+  const matchingContext = !!ctx && ctx.agentId === agentId && ctx.conversationId === conversationId && ctx.continuationEpoch === runtime.continuationEpoch;
   if (!runtime.pendingInterruptedResults || runtime.pendingInterruptedResults.length === 0) {
+    if (matchingContext) {
+      runtime.pendingInterruptedResults = null;
+      runtime.pendingInterruptedContext = null;
+      runtime.pendingInterruptedToolCallIds = null;
+    }
     return null;
   }
-  const ctx = runtime.pendingInterruptedContext;
   let result = null;
-  if (ctx && ctx.agentId === agentId && ctx.conversationId === conversationId && ctx.continuationEpoch === runtime.continuationEpoch) {
+  if (matchingContext) {
     result = {
       approvalMessage: {
         type: "approval",
@@ -77691,6 +77748,104 @@ function mirrorRecoverableNoticeToDesktopDebugPanel(message) {
 `);
   } catch {}
 }
+function toStructuredApiError(errorInfo) {
+  if (!errorInfo?.error_type || !errorInfo.run_id) {
+    return;
+  }
+  return {
+    message_type: "error_message",
+    message: errorInfo.message || errorInfo.detail || "An error occurred",
+    error_type: errorInfo.error_type,
+    run_id: errorInfo.run_id,
+    ...errorInfo.detail ? { detail: errorInfo.detail } : {}
+  };
+}
+function getStructuredApiErrorFromError(error) {
+  if (!(error instanceof Error)) {
+    return;
+  }
+  const errorWithStructuredInfo = error;
+  return errorWithStructuredInfo.apiError ?? toStructuredApiError(errorWithStructuredInfo.runErrorInfo);
+}
+function buildStructuredFormatInput(apiError) {
+  return {
+    error: {
+      error: {
+        type: apiError.error_type,
+        message: apiError.message,
+        ...apiError.detail ? { detail: apiError.detail } : {}
+      },
+      run_id: apiError.run_id
+    }
+  };
+}
+function isAbortLikeError(error) {
+  if (error instanceof APIUserAbortError) {
+    return true;
+  }
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const errorWithCode = error;
+  return error.name === "AbortError" || error.message === "The operation was aborted" || errorWithCode.code === "ABORT_ERR";
+}
+function isTerminatedProcessNoise(message) {
+  return message.trim().toLowerCase() === "terminated";
+}
+function isProxyTransportError(detail, error, message) {
+  if (error instanceof APIError2 && error.status >= 500 && detail.toLowerCase().includes("trying to proxy")) {
+    return true;
+  }
+  return detail.toLowerCase().includes("error occurred while trying to proxy") || message.toLowerCase().includes("error occurred while trying to proxy");
+}
+function getLoopErrorNoticeDecision(params) {
+  const apiError = params.apiError ?? toStructuredApiError(params.errorInfo) ?? toStructuredApiError(params.runErrorInfo) ?? getStructuredApiErrorFromError(params.error);
+  const detail = apiError?.detail ?? params.errorInfo?.detail ?? params.runErrorInfo?.detail ?? extractConflictDetail(params.error) ?? "";
+  if (params.cancelRequested || params.abortSignal?.aborted || isAbortLikeError(params.error) || isTerminatedProcessNoise(params.message)) {
+    return {
+      visibility: "debug_only",
+      message: params.message
+    };
+  }
+  const cloudflareMessage = checkCloudflareEdgeError2(detail) ?? checkCloudflareEdgeError2(params.message);
+  if (cloudflareMessage) {
+    return {
+      visibility: "transcript",
+      message: cloudflareMessage,
+      apiError
+    };
+  }
+  if (isProxyTransportError(detail, params.error, params.message)) {
+    return {
+      visibility: "transcript",
+      message: "Connection to Letta service failed. Please retry.",
+      apiError
+    };
+  }
+  const formattedMessage = formatErrorDetails2(apiError ? buildStructuredFormatInput(apiError) : params.error ?? params.message, params.agentId ?? undefined, params.conversationId ?? undefined);
+  return {
+    visibility: "transcript",
+    message: formattedMessage,
+    apiError
+  };
+}
+function emitLoopErrorNotice(socket, runtime, params) {
+  const decision = getLoopErrorNoticeDecision(params);
+  if (decision.visibility === "debug_only") {
+    debugLog("recovery", `Debug-only loop error (${params.stopReason}): ${params.message}`);
+    mirrorRecoverableNoticeToDesktopDebugPanel(params.message);
+    return;
+  }
+  emitLoopErrorDelta(socket, runtime, {
+    message: decision.message,
+    stopReason: params.stopReason,
+    isTerminal: params.isTerminal,
+    runId: params.runId,
+    agentId: params.agentId,
+    conversationId: params.conversationId,
+    apiError: decision.apiError
+  });
+}
 function emitRecoverableStatusNotice(socket, runtime, params) {
   const visibility = getRecoverableStatusNoticeVisibility(params.kind);
   if (visibility === "debug_only") {
@@ -77726,6 +77881,9 @@ function emitRecoverableRetryNotice(socket, runtime, params) {
 }
 var DESKTOP_DEBUG_PANEL_INFO_PREFIX = "[LETTA_DESKTOP_DEBUG_PANEL_INFO]";
 var init_recoverable_notices = __esm(async () => {
+  init_error();
+  init_turn_recovery_policy();
+  init_errorFormatter();
   init_debug();
   await init_protocol_outbound();
 });
@@ -79309,13 +79467,15 @@ async function drainRecoveryStreamWithEmission(recoveryStream, socket, runtime,
       }
     }
     if (errorInfo) {
-      emitLoopErrorDelta(socket, runtime, {
+      emitLoopErrorNotice(socket, runtime, {
         message: errorInfo.message || "Stream error",
         stopReason: errorInfo.error_type || "error",
         isTerminal: false,
         runId: runtime.activeRunId || errorInfo.run_id,
         agentId: params.agentId ?? undefined,
-        conversationId: params.conversationId
+        conversationId: params.conversationId,
+        errorInfo,
+        abortSignal: params.abortSignal
       });
     }
     if (shouldOutput) {
@@ -79366,7 +79526,7 @@ function finalizeHandledRecoveryTurn(runtime, socket, params) {
   const runId = runtime.activeRunId;
   clearActiveRunState(runtime);
   emitRuntimeStateUpdates(runtime, scope);
-  emitLoopErrorDelta(socket, runtime, {
+  emitLoopErrorNotice(socket, runtime, {
     message: `Recovery continuation ended unexpectedly: ${terminalStopReason}`,
     stopReason: terminalStopReason,
     isTerminal: true,
@@ -79703,7 +79863,8 @@ var init_recovery = __esm(async () => {
     init_approval_suggestions(),
     init_interrupts(),
     init_protocol_outbound(),
-    init_queue()
+    init_queue(),
+    init_recoverable_notices()
   ]);
 });
 
@@ -80004,8 +80165,8 @@ async function sendMessageStreamWithRetry(conversationId, messages, opts, socket
               throw new Error("Cancelled by user");
           }
         }
-        const detail = await fetchRunErrorDetail(runtime.activeRunId);
-        throw new Error(detail || `Pre-stream approval conflict after ${preStreamRecoveryAttempts} recovery attempts`);
+        const runErrorInfo = await fetchRunErrorInfo(runtime.activeRunId);
+        throw Object.assign(new Error(runErrorInfo?.detail || runErrorInfo?.message || `Pre-stream approval conflict after ${preStreamRecoveryAttempts} recovery attempts`), { runErrorInfo });
       }
       if (action === "retry_transient") {
         runtime.isRecoveringApprovals = true;
@@ -80138,8 +80299,8 @@ async function sendApprovalContinuationWithRetry(conversationId, messages, opts,
           }
           continue;
         }
-        const detail = await fetchRunErrorDetail(runtime.activeRunId);
-        throw new Error(detail || `Approval continuation conflict after ${preStreamRecoveryAttempts} recovery attempts`);
+        const runErrorInfo = await fetchRunErrorInfo(runtime.activeRunId);
+        throw Object.assign(new Error(runErrorInfo?.detail || runErrorInfo?.message || `Approval continuation conflict after ${preStreamRecoveryAttempts} recovery attempts`), { runErrorInfo });
       }
       if (action === "retry_transient") {
         runtime.isRecoveringApprovals = true;
@@ -80265,7 +80426,7 @@ async function handleApprovalStop(params) {
       agent_id: agentId,
       conversation_id: conversationId
     });
-    emitLoopErrorDelta(socket, runtime, {
+    emitLoopErrorNotice(socket, runtime, {
       message: "requires_approval stop returned no approvals",
       stopReason: "error",
       isTerminal: true,
@@ -80568,6 +80729,7 @@ var init_turn_approval = __esm(async () => {
     init_interrupts(),
     init_protocol_outbound(),
     init_queue(),
+    init_recoverable_notices(),
     init_recovery(),
     init_send()
   ]);
@@ -80899,13 +81061,16 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
         }
         if (errorInfo) {
           latestErrorText = errorInfo.message || latestErrorText;
-          emitLoopErrorDelta(socket, runtime, {
+          emitLoopErrorNotice(socket, runtime, {
             message: errorInfo.message || "Stream error",
             stopReason: errorInfo.error_type || "error",
             isTerminal: false,
             runId: runId || errorInfo.run_id,
             agentId,
-            conversationId
+            conversationId,
+            errorInfo,
+            cancelRequested: runtime.cancelRequested,
+            abortSignal: turnAbortSignal
           });
         }
         if (shouldOutput) {
@@ -80965,7 +81130,8 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
       }
       if (stopReason !== "requires_approval") {
         const lastRunId = runId || msgRunIds[msgRunIds.length - 1] || null;
-        const errorDetail = latestErrorText || (lastRunId ? await fetchRunErrorDetail(lastRunId) : null);
+        const runErrorInfo = lastRunId ? await fetchRunErrorInfo(lastRunId) : null;
+        const errorDetail = latestErrorText || runErrorInfo?.detail || runErrorInfo?.message || null;
         if (shouldAttemptPostStopApprovalRecovery({
           stopReason,
           runIdsSeen: msgRunIds.length,
@@ -81127,13 +81293,16 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
           conversation_id: conversationId
         });
         const errorMessage = errorDetail || `Unexpected stop reason: ${stopReason}`;
-        emitLoopErrorDelta(socket, runtime, {
+        emitLoopErrorNotice(socket, runtime, {
           message: errorMessage,
           stopReason: effectiveStopReason,
           isTerminal: true,
           runId,
           agentId,
-          conversationId
+          conversationId,
+          runErrorInfo: runErrorInfo ?? undefined,
+          cancelRequested: runtime.cancelRequested,
+          abortSignal: turnAbortSignal
         });
         break;
       }
@@ -81217,12 +81386,15 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
       conversation_id: conversationId
     });
     const errorMessage = error instanceof Error ? error.message : String(error);
-    emitLoopErrorDelta(socket, runtime, {
+    emitLoopErrorNotice(socket, runtime, {
       message: errorMessage,
       stopReason: "error",
       isTerminal: true,
       agentId: agentId || undefined,
-      conversationId
+      conversationId,
+      error,
+      cancelRequested: runtime.cancelRequested,
+      abortSignal: turnAbortSignal
     });
     if (isDebugEnabled()) {
       console.error("[Listen] Error handling message:", error);
@@ -81829,7 +82001,8 @@ function emitLoopErrorDelta(socket, runtime, params) {
     ...createLifecycleMessageBase("loop_error", params.runId),
     message: params.message,
     stop_reason: params.stopReason,
-    is_terminal: params.isTerminal
+    is_terminal: params.isTerminal,
+    ...params.apiError ? { api_error: params.apiError } : {}
   }, {
     agent_id: params.agentId,
     conversation_id: params.conversationId
@@ -83072,12 +83245,13 @@ function handleModeChange(msg, socket, runtime, scope) {
     }
   } catch (error) {
     trackListenerError("listener_mode_change_failed", error, "listener_mode_change");
-    emitLoopErrorDelta(socket, runtime, {
+    emitLoopErrorNotice(socket, runtime, {
       message: error instanceof Error ? error.message : "Mode change failed",
       stopReason: "error",
       isTerminal: false,
       agentId: scope?.agent_id,
-      conversationId: scope?.conversation_id
+      conversationId: scope?.conversation_id,
+      error
     });
     if (isDebugEnabled()) {
       console.error("[Listen] Mode change failed:", error);
@@ -83827,6 +84001,7 @@ async function handleAbortMessageInput(listener, params, deps = {}) {
   }
   const interruptedRunId = scopedRuntime.activeRunId;
   scopedRuntime.cancelRequested = true;
+  const pendingRequestsSnapshot = hasPendingApprovals ? resolvedDeps.getPendingControlRequests(listener, scope) : [];
   if (scopedRuntime.activeExecutingToolCallIds.length > 0 && (!scopedRuntime.pendingInterruptedResults || scopedRuntime.pendingInterruptedResults.length === 0)) {
     scopedRuntime.pendingInterruptedResults = scopedRuntime.activeExecutingToolCallIds.map((toolCallId) => ({
       type: "tool",
@@ -83872,9 +84047,8 @@ async function handleAbortMessageInput(listener, params, deps = {}) {
       agentId: scope.agent_id,
       conversationId: scope.conversation_id
     });
-  } else if (hasPendingApprovals) {
-    const pendingRequests = resolvedDeps.getPendingControlRequests(listener, scope);
-    scopedRuntime.pendingInterruptedResults = pendingRequests.map((req) => ({
+  } else if (hasPendingApprovals && (!scopedRuntime.pendingInterruptedResults || scopedRuntime.pendingInterruptedResults.length === 0) && pendingRequestsSnapshot.length > 0) {
+    scopedRuntime.pendingInterruptedResults = pendingRequestsSnapshot.map((req) => ({
       type: "approval",
       tool_call_id: req.request.tool_call_id,
       approve: false,
@@ -83885,6 +84059,7 @@ async function handleAbortMessageInput(listener, params, deps = {}) {
       conversationId: scope.conversation_id,
       continuationEpoch: scopedRuntime.continuationEpoch
     };
+    scopedRuntime.pendingInterruptedToolCallIds = null;
     resolvedDeps.emitInterruptedStatusDelta(params.socket, scopedRuntime, {
       runId: interruptedRunId,
       agentId: scope.agent_id,
@@ -83929,12 +84104,13 @@ async function handleCwdChange(msg, socket, runtime) {
       conversation_id: conversationId
     });
   } catch (error) {
-    emitLoopErrorDelta(socket, runtime, {
+    emitLoopErrorNotice(socket, runtime, {
       message: error instanceof Error ? error.message : "Working directory change failed",
       stopReason: "error",
       isTerminal: false,
       agentId,
-      conversationId
+      conversationId,
+      error
     });
   }
 }
@@ -84153,7 +84329,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
         return;
       }
       if (parsed.type === "__invalid_input") {
-        emitLoopErrorDelta(socket, runtime, {
+        emitLoopErrorNotice(socket, runtime, {
           message: parsed.reason,
           stopReason: "error",
           isTerminal: false,
@@ -84196,7 +84372,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
         }
         const inputPayload = parsed.payload;
         if (inputPayload.kind !== "create_message") {
-          emitLoopErrorDelta(socket, runtime, {
+          emitLoopErrorNotice(socket, runtime, {
             message: `Unsupported input payload kind: ${String(inputPayload.kind)}`,
             stopReason: "error",
             isTerminal: false,
@@ -84213,7 +84389,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
         };
         const hasApprovalPayload = incoming.messages.some((payload) => ("type" in payload) && payload.type === "approval");
         if (hasApprovalPayload) {
-          emitLoopErrorDelta(socket, runtime, {
+          emitLoopErrorNotice(socket, runtime, {
             message: "Protocol violation: approval payloads are not allowed in input.kind=create_message. Use input.kind=approval_response.",
             stopReason: "error",
             isTerminal: false,
@@ -84770,12 +84946,13 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
       if (!parsedScope) {
         return;
       }
-      emitLoopErrorDelta(socket, runtime, {
+      emitLoopErrorNotice(socket, runtime, {
         message: error instanceof Error ? error.message : "Failed to process listener message",
         stopReason: "error",
         isTerminal: false,
         agentId: parsedScope.agent_id,
-        conversationId: parsedScope.conversation_id
+        conversationId: parsedScope.conversation_id,
+        error
       });
     }
   });
@@ -85073,6 +85250,7 @@ var init_client4 = __esm(async () => {
     init_protocol_inbound(),
     init_protocol_outbound(),
     init_queue(),
+    init_recoverable_notices(),
     init_recovery(),
     init_send(),
     init_turn(),
@@ -152557,4 +152735,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=275910C1663139CA64756E2164756E21
+//# debugId=AA1793542E1A081B64756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.21.10",
+  "version": "0.21.11",
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
   "bin": {