@letta-ai/letta-code 0.19.9 → 0.19.10

package/letta.js

@@ -3255,7 +3255,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.19.9",
+    version: "0.19.10",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -48039,6 +48039,7 @@ __export(exports_runtime, {
   setActiveRuntime: () => setActiveRuntime,
   safeEmitWsEvent: () => safeEmitWsEvent,
   nextEventSeq: () => nextEventSeq,
+  hasInterruptedCacheForScope: () => hasInterruptedCacheForScope,
   getRecoveredApprovalStateForScope: () => getRecoveredApprovalStateForScope,
   getPendingControlRequests: () => getPendingControlRequests,
   getPendingControlRequestCount: () => getPendingControlRequestCount,
@@ -48253,6 +48254,19 @@ function getPendingControlRequests(runtime, params) {
   }
   return requests;
 }
+function hasInterruptedCacheForScope(runtime, params) {
+  const scopedAgentId = resolveScopedAgentId(runtime, params);
+  const scopedConversationId = resolveScopedConversationId(runtime, params);
+  const conversationRuntime = getConversationRuntime(runtime, scopedAgentId, scopedConversationId);
+  if (!conversationRuntime) {
+    return false;
+  }
+  const context3 = conversationRuntime.pendingInterruptedContext;
+  if (context3 && context3.agentId === (scopedAgentId ?? "") && context3.conversationId === scopedConversationId && context3.continuationEpoch === conversationRuntime.continuationEpoch && conversationRuntime.pendingInterruptedResults && conversationRuntime.pendingInterruptedResults.length > 0) {
+    return true;
+  }
+  return false;
+}
 function getPendingControlRequestCount(runtime, params) {
   return getPendingControlRequests(runtime, params).length;
 }
@@ -70022,6 +70036,7 @@ function buildDeviceStatus(runtime, params) {
     }
   })();
   const conversationPermissionModeState = getConversationPermissionModeState(listener, scopedAgentId, scopedConversationId);
+  const interruptedCacheActive = hasInterruptedCacheForScope(listener, scope);
   return {
     current_connection_id: listener.connectionId,
     connection_name: listener.connectionName,
@@ -70035,7 +70050,7 @@ function buildDeviceStatus(runtime, params) {
     current_loaded_tools: getToolNames(),
     current_available_skills: [],
     background_processes: [],
-    pending_control_requests: getPendingControlRequests(listener, scope),
+    pending_control_requests: interruptedCacheActive ? [] : getPendingControlRequests(listener, scope),
     memory_directory: scopedAgentId ? getMemoryFilesystemRoot(scopedAgentId) : null
   };
 }
@@ -70048,11 +70063,12 @@ function buildLoopStatus(runtime, params) {
   const scopedAgentId = resolveScopedAgentId(listener, scope);
   const scopedConversationId = resolveScopedConversationId(listener, scope);
   const conversationRuntime = getConversationRuntime(listener, scopedAgentId, scopedConversationId);
+  const interruptedCacheActive = hasInterruptedCacheForScope(listener, scope);
   const recovered = getRecoveredApprovalStateForScope(listener, scope);
-  const status = recovered && recovered.pendingRequestIds.size > 0 && conversationRuntime?.loopStatus === "WAITING_ON_INPUT" ? "WAITING_ON_APPROVAL" : conversationRuntime?.loopStatus ?? "WAITING_ON_INPUT";
+  const status = interruptedCacheActive ? !conversationRuntime?.isProcessing ? "WAITING_ON_INPUT" : conversationRuntime?.loopStatus ?? "WAITING_ON_INPUT" : recovered && recovered.pendingRequestIds.size > 0 && conversationRuntime?.loopStatus === "WAITING_ON_INPUT" ? "WAITING_ON_APPROVAL" : conversationRuntime?.loopStatus ?? "WAITING_ON_INPUT";
   return {
     status,
-    active_run_ids: conversationRuntime?.activeRunId ? [conversationRuntime.activeRunId] : []
+    active_run_ids: interruptedCacheActive && !conversationRuntime?.isProcessing ? [] : conversationRuntime?.activeRunId ? [conversationRuntime.activeRunId] : []
   };
 }
 function buildQueueSnapshot(runtime, params) {
@@ -70423,7 +70439,7 @@ function resolvePendingApprovalResolver(runtime, response) {
   }
   runtime.pendingApprovalResolvers.delete(requestId);
   runtime.listener.approvalRuntimeKeyByRequestId.delete(requestId);
-  if (runtime.pendingApprovalResolvers.size === 0) {
+  if (runtime.pendingApprovalResolvers.size === 0 && !runtime.isProcessing) {
     setLoopStatus(runtime, "WAITING_ON_INPUT");
   }
   pending.resolve(response);
@@ -75999,6 +76015,10 @@ async function debugLogApprovalResumeState(runtime, params) {
   }
 }
 async function recoverApprovalStateForSync(runtime, scope) {
+  if (hasInterruptedCacheForScope(runtime.listener, scope)) {
+    clearRecoveredApprovalState(runtime);
+    return;
+  }
   const sameActiveScope = runtime.agentId === scope.agent_id && runtime.conversationId === scope.conversation_id;
   if (sameActiveScope && (runtime.isProcessing || runtime.loopStatus !== "WAITING_ON_INPUT")) {
     clearRecoveredApprovalState(runtime);
@@ -76122,6 +76142,11 @@ async function resolveRecoveredApprovalResponse(runtime, socket, response, proce
     agent_id: recovered.agentId,
     conversation_id: recovered.conversationId
   };
+  if (hasInterruptedCacheForScope(runtime.listener, scope)) {
+    clearRecoveredApprovalState(runtime);
+    emitRuntimeStateUpdates(runtime, scope);
+    return true;
+  }
   const approvedToolCallIds = decisions.filter((decision) => decision.type === "approve").map((decision) => decision.approval.toolCallId);
   recovered.pendingRequestIds.clear();
   emitRuntimeStateUpdates(runtime, scope);
@@ -77664,6 +77689,29 @@ async function handleApprovalStop(params) {
   });
   const lastNeedsUserInputToolCallIds = needsUserInput.map((ac) => ac.approval.toolCallId);
   let lastExecutionResults = null;
+  let lastExecutingToolCallIds = [];
+  const shouldInterrupt = () => abortController.signal.aborted || runtime.cancelRequested;
+  const interruptTermination = (interruptedInput = currentInput, interruptedBatchId = dequeuedBatchId) => {
+    populateInterruptQueue(runtime, {
+      lastExecutionResults,
+      lastExecutingToolCallIds,
+      lastNeedsUserInputToolCallIds,
+      agentId: agentId || "",
+      conversationId
+    });
+    return {
+      terminated: true,
+      stream: null,
+      currentInput: interruptedInput,
+      dequeuedBatchId: interruptedBatchId,
+      pendingNormalizationInterruptedToolCallIds: [],
+      turnToolContextId,
+      lastExecutionResults,
+      lastExecutingToolCallIds,
+      lastNeedsUserInputToolCallIds,
+      lastApprovalContinuationAccepted: false
+    };
+  };
   const decisions = [
     ...autoAllowed.map((ac) => ({
       type: "approve",
@@ -77675,15 +77723,27 @@ async function handleApprovalStop(params) {
       reason: ac.denyReason || ac.permission.reason || "Permission denied"
     }))
   ];
+  if (shouldInterrupt()) {
+    return interruptTermination();
+  }
   if (needsUserInput.length > 0) {
+    if (shouldInterrupt()) {
+      return interruptTermination();
+    }
     runtime.lastStopReason = "requires_approval";
     setLoopStatus(runtime, "WAITING_ON_APPROVAL", {
       agent_id: agentId,
       conversation_id: conversationId
     });
     for (const ac of needsUserInput) {
+      if (shouldInterrupt()) {
+        return interruptTermination();
+      }
       const requestId = `perm-${ac.approval.toolCallId}`;
       const diffs = await computeDiffPreviews(ac.approval.toolName, ac.parsedArgs, turnWorkingDirectory);
+      if (shouldInterrupt()) {
+        return interruptTermination();
+      }
       const controlRequest = {
         type: "control_request",
         request_id: requestId,
@@ -77699,7 +77759,18 @@ async function handleApprovalStop(params) {
         agent_id: agentId,
         conversation_id: conversationId
       };
-      const responseBody = await requestApprovalOverWS(runtime, socket, requestId, controlRequest);
+      let responseBody;
+      try {
+        responseBody = await requestApprovalOverWS(runtime, socket, requestId, controlRequest);
+      } catch (error) {
+        if (shouldInterrupt()) {
+          return interruptTermination();
+        }
+        throw error;
+      }
+      if (shouldInterrupt()) {
+        return interruptTermination();
+      }
       if ("decision" in responseBody) {
         const response = responseBody.decision;
         if (response.behavior === "allow") {
@@ -77728,7 +77799,10 @@ async function handleApprovalStop(params) {
       }
     }
   }
-  const lastExecutingToolCallIds = decisions.filter((decision) => decision.type === "approve").map((decision) => decision.approval.toolCallId);
+  if (shouldInterrupt()) {
+    return interruptTermination();
+  }
+  lastExecutingToolCallIds = decisions.filter((decision) => decision.type === "approve").map((decision) => decision.approval.toolCallId);
   runtime.activeExecutingToolCallIds = [...lastExecutingToolCallIds];
   setLoopStatus(runtime, "EXECUTING_CLIENT_SIDE_TOOL", {
     agent_id: agentId,
@@ -77745,6 +77819,9 @@ async function handleApprovalStop(params) {
     agentId,
     conversationId
   });
+  if (shouldInterrupt()) {
+    return interruptTermination();
+  }
   const executionResults = await executeApprovalBatch(decisions, undefined, {
     toolContextId: turnToolContextId ?? undefined,
     abortSignal: abortController.signal,
@@ -77765,6 +77842,9 @@ async function handleApprovalStop(params) {
   });
   lastExecutionResults = persistedExecutionResults;
   emitInterruptToolReturnMessage(socket, runtime, persistedExecutionResults, runtime.activeRunId || runId || msgRunIds[msgRunIds.length - 1] || undefined, "tool-return");
+  if (shouldInterrupt()) {
+    return interruptTermination();
+  }
   const nextInput = [
     {
       type: "approval",
@@ -77780,11 +77860,22 @@ async function handleApprovalStop(params) {
     emitDequeuedUserMessage(socket, runtime, queuedTurn, dequeuedBatch);
   }
   const nextInputWithSkillContent = injectQueuedSkillContent(nextInput);
+  if (shouldInterrupt()) {
+    return interruptTermination(nextInputWithSkillContent, continuationBatchId);
+  }
   setLoopStatus(runtime, "SENDING_API_REQUEST", {
     agent_id: agentId,
     conversation_id: conversationId
   });
-  const stream2 = await sendApprovalContinuationWithRetry(conversationId, nextInputWithSkillContent, buildSendOptions(), socket, runtime, abortController.signal);
+  let stream2;
+  try {
+    stream2 = await sendApprovalContinuationWithRetry(conversationId, nextInputWithSkillContent, buildSendOptions(), socket, runtime, abortController.signal);
+  } catch (error) {
+    if (shouldInterrupt()) {
+      return interruptTermination(nextInputWithSkillContent, continuationBatchId);
+    }
+    throw error;
+  }
   if (!stream2) {
     return {
       terminated: true,
@@ -77850,6 +77941,25 @@ var init_turn_approval = __esm(async () => {
 });
 
 // src/websocket/listener/turn.ts
+function finalizeInterruptedTurn(socket, runtime, params) {
+  const scope = {
+    agent_id: params.agentId ?? null,
+    conversation_id: params.conversationId
+  };
+  const alreadyProjected = runtime.cancelRequested && !runtime.isProcessing && runtime.loopStatus === "WAITING_ON_INPUT" && runtime.activeRunId === null && runtime.activeAbortController === null;
+  runtime.lastStopReason = "cancelled";
+  runtime.isProcessing = false;
+  if (!alreadyProjected) {
+    emitInterruptedStatusDelta(socket, runtime, {
+      runId: params.runId,
+      agentId: params.agentId,
+      conversationId: params.conversationId
+    });
+    clearActiveRunState(runtime);
+    setLoopStatus(runtime, "WAITING_ON_INPUT", scope);
+    emitRuntimeStateUpdates(runtime, scope);
+  }
+}
 async function handleIncomingMessage(msg, socket, runtime, onStatusChange, connectionId, dequeuedBatchId = `batch-direct-${crypto.randomUUID()}`) {
   const agentId = msg.agentId;
   const requestedConversationId = msg.conversationId || undefined;
@@ -77868,7 +77978,9 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
   let lastNeedsUserInputToolCallIds = [];
   runtime.isProcessing = true;
   runtime.cancelRequested = false;
-  runtime.activeAbortController = new AbortController;
+  const turnAbortController = new AbortController;
+  runtime.activeAbortController = turnAbortController;
+  const turnAbortSignal = turnAbortController.signal;
   runtime.activeWorkingDirectory = turnWorkingDirectory;
   runtime.activeRunId = null;
   runtime.activeRunStartedAt = new Date().toISOString();
@@ -77888,10 +78000,10 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
   try {
     if (!agentId) {
       runtime.isProcessing = false;
+      clearActiveRunState(runtime);
       setLoopStatus(runtime, "WAITING_ON_INPUT", {
         conversation_id: conversationId
       });
-      clearActiveRunState(runtime);
       emitRuntimeStateUpdates(runtime, {
         conversation_id: conversationId
       });
@@ -77951,7 +78063,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
     });
     const isPureApprovalContinuation = isApprovalOnlyInput(currentInput);
     const currentInputWithSkillContent = injectQueuedSkillContent(currentInput);
-    let stream2 = isPureApprovalContinuation ? await sendApprovalContinuationWithRetry(conversationId, currentInputWithSkillContent, buildSendOptions(), socket, runtime, runtime.activeAbortController.signal) : await sendMessageStreamWithRetry(conversationId, currentInputWithSkillContent, buildSendOptions(), socket, runtime, runtime.activeAbortController.signal);
+    let stream2 = isPureApprovalContinuation ? await sendApprovalContinuationWithRetry(conversationId, currentInputWithSkillContent, buildSendOptions(), socket, runtime, turnAbortSignal) : await sendMessageStreamWithRetry(conversationId, currentInputWithSkillContent, buildSendOptions(), socket, runtime, turnAbortSignal);
     currentInput = currentInputWithSkillContent;
     if (!stream2) {
       return;
@@ -77969,7 +78081,10 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
     while (true) {
       runIdSent = false;
       let latestErrorText = null;
-      const result = await drainStreamWithResume(stream2, buffers, () => {}, runtime.activeAbortController.signal, undefined, ({ chunk, shouldOutput, errorInfo }) => {
+      const result = await drainStreamWithResume(stream2, buffers, () => {}, turnAbortSignal, undefined, ({ chunk, shouldOutput, errorInfo }) => {
+        if (runtime.cancelRequested) {
+          return;
+        }
         const maybeRunId = chunk.run_id;
         if (typeof maybeRunId === "string") {
           runId = maybeRunId;
@@ -78013,14 +78128,22 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
       const stopReason = result.stopReason;
       const approvals = result.approvals || [];
       lastApprovalContinuationAccepted = false;
+      if (stopReason === "end_turn" && runtime.cancelRequested) {
+        finalizeInterruptedTurn(socket, runtime, {
+          runId: runId || runtime.activeRunId,
+          agentId: agentId ?? null,
+          conversationId
+        });
+        break;
+      }
       if (stopReason === "end_turn") {
         runtime.lastStopReason = "end_turn";
         runtime.isProcessing = false;
+        clearActiveRunState(runtime);
         setLoopStatus(runtime, "WAITING_ON_INPUT", {
           agent_id: agentId,
           conversation_id: conversationId
         });
-        clearActiveRunState(runtime);
         emitRuntimeStateUpdates(runtime, {
           agent_id: agentId,
           conversation_id: conversationId
@@ -78028,22 +78151,11 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
         break;
       }
       if (stopReason === "cancelled") {
-        runtime.lastStopReason = "cancelled";
-        runtime.isProcessing = false;
-        emitInterruptedStatusDelta(socket, runtime, {
+        finalizeInterruptedTurn(socket, runtime, {
           runId: runId || runtime.activeRunId,
-          agentId,
+          agentId: agentId ?? null,
           conversationId
         });
-        setLoopStatus(runtime, "WAITING_ON_INPUT", {
-          agent_id: agentId,
-          conversation_id: conversationId
-        });
-        clearActiveRunState(runtime);
-        emitRuntimeStateUpdates(runtime, {
-          agent_id: agentId,
-          conversation_id: conversationId
-        });
         break;
       }
       if (stopReason !== "requires_approval") {
@@ -78078,7 +78190,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
           });
           const isPureApprovalContinuationRetry = isApprovalOnlyInput(currentInput);
           const retryInputWithSkillContent = injectQueuedSkillContent(currentInput);
-          stream2 = isPureApprovalContinuationRetry ? await sendApprovalContinuationWithRetry(conversationId, retryInputWithSkillContent, buildSendOptions(), socket, runtime, runtime.activeAbortController.signal) : await sendMessageStreamWithRetry(conversationId, retryInputWithSkillContent, buildSendOptions(), socket, runtime, runtime.activeAbortController.signal);
+          stream2 = isPureApprovalContinuationRetry ? await sendApprovalContinuationWithRetry(conversationId, retryInputWithSkillContent, buildSendOptions(), socket, runtime, turnAbortSignal) : await sendMessageStreamWithRetry(conversationId, retryInputWithSkillContent, buildSendOptions(), socket, runtime, turnAbortSignal);
           currentInput = retryInputWithSkillContent;
           if (!stream2) {
             return;
@@ -78120,7 +78232,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
             conversationId
           });
           await new Promise((resolve23) => setTimeout(resolve23, delayMs));
-          if (runtime.activeAbortController.signal.aborted) {
+          if (turnAbortSignal.aborted) {
             throw new Error("Cancelled by user");
           }
           setLoopStatus(runtime, "SENDING_API_REQUEST", {
@@ -78129,7 +78241,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
           });
           const isPureApprovalContinuationRetry = isApprovalOnlyInput(currentInput);
           const retryInputWithSkillContent = injectQueuedSkillContent(currentInput);
-          stream2 = isPureApprovalContinuationRetry ? await sendApprovalContinuationWithRetry(conversationId, retryInputWithSkillContent, buildSendOptions(), socket, runtime, runtime.activeAbortController.signal) : await sendMessageStreamWithRetry(conversationId, retryInputWithSkillContent, buildSendOptions(), socket, runtime, runtime.activeAbortController.signal);
+          stream2 = isPureApprovalContinuationRetry ? await sendApprovalContinuationWithRetry(conversationId, retryInputWithSkillContent, buildSendOptions(), socket, runtime, turnAbortSignal) : await sendMessageStreamWithRetry(conversationId, retryInputWithSkillContent, buildSendOptions(), socket, runtime, turnAbortSignal);
           currentInput = retryInputWithSkillContent;
           if (!stream2) {
             return;
@@ -78164,7 +78276,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
             conversationId
           });
           await new Promise((resolve23) => setTimeout(resolve23, delayMs));
-          if (runtime.activeAbortController.signal.aborted) {
+          if (turnAbortSignal.aborted) {
             throw new Error("Cancelled by user");
           }
           setLoopStatus(runtime, "SENDING_API_REQUEST", {
@@ -78173,7 +78285,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
           });
           const isPureApprovalContinuationRetry = isApprovalOnlyInput(currentInput);
           const retryInputWithSkillContent = injectQueuedSkillContent(currentInput);
-          stream2 = isPureApprovalContinuationRetry ? await sendApprovalContinuationWithRetry(conversationId, retryInputWithSkillContent, buildSendOptions(), socket, runtime, runtime.activeAbortController.signal) : await sendMessageStreamWithRetry(conversationId, retryInputWithSkillContent, buildSendOptions(), socket, runtime, runtime.activeAbortController.signal);
+          stream2 = isPureApprovalContinuationRetry ? await sendApprovalContinuationWithRetry(conversationId, retryInputWithSkillContent, buildSendOptions(), socket, runtime, turnAbortSignal) : await sendMessageStreamWithRetry(conversationId, retryInputWithSkillContent, buildSendOptions(), socket, runtime, turnAbortSignal);
           currentInput = retryInputWithSkillContent;
           if (!stream2) {
             return;
@@ -78189,31 +78301,20 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
         }
         const effectiveStopReason = runtime.cancelRequested ? "cancelled" : stopReason || "error";
         if (effectiveStopReason === "cancelled") {
-          runtime.lastStopReason = "cancelled";
-          runtime.isProcessing = false;
-          emitInterruptedStatusDelta(socket, runtime, {
+          finalizeInterruptedTurn(socket, runtime, {
             runId: runId || runtime.activeRunId,
-            agentId,
+            agentId: agentId ?? null,
             conversationId
           });
-          setLoopStatus(runtime, "WAITING_ON_INPUT", {
-            agent_id: agentId,
-            conversation_id: conversationId
-          });
-          clearActiveRunState(runtime);
-          emitRuntimeStateUpdates(runtime, {
-            agent_id: agentId,
-            conversation_id: conversationId
-          });
           break;
         }
         runtime.lastStopReason = effectiveStopReason;
         runtime.isProcessing = false;
+        clearActiveRunState(runtime);
         setLoopStatus(runtime, "WAITING_ON_INPUT", {
           agent_id: agentId,
           conversation_id: conversationId
         });
-        clearActiveRunState(runtime);
         emitRuntimeStateUpdates(runtime, {
           agent_id: agentId,
           conversation_id: conversationId
@@ -78284,31 +78385,20 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
           emitInterruptToolReturnMessage(socket, runtime, approvalsForEmission, runtime.activeRunId || msgRunIds[msgRunIds.length - 1] || undefined);
         }
       }
-      runtime.lastStopReason = "cancelled";
-      runtime.isProcessing = false;
-      emitInterruptedStatusDelta(socket, runtime, {
+      finalizeInterruptedTurn(socket, runtime, {
         runId: runtime.activeRunId || msgRunIds[msgRunIds.length - 1],
         agentId: agentId || null,
         conversationId
       });
-      setLoopStatus(runtime, "WAITING_ON_INPUT", {
-        agent_id: agentId || null,
-        conversation_id: conversationId
-      });
-      clearActiveRunState(runtime);
-      emitRuntimeStateUpdates(runtime, {
-        agent_id: agentId || null,
-        conversation_id: conversationId
-      });
       return;
     }
     runtime.lastStopReason = "error";
     runtime.isProcessing = false;
+    clearActiveRunState(runtime);
     setLoopStatus(runtime, "WAITING_ON_INPUT", {
       agent_id: agentId || null,
       conversation_id: conversationId
     });
-    clearActiveRunState(runtime);
     emitRuntimeStateUpdates(runtime, {
       agent_id: agentId || null,
       conversation_id: conversationId
@@ -78552,6 +78642,11 @@ async function handleApprovalResponseInput(listener, params, deps = {
     return true;
   }
   const targetRuntime = approvalRuntime ?? deps.getOrCreateScopedRuntime(listener, params.runtime.agent_id, params.runtime.conversation_id);
+  if (targetRuntime.cancelRequested && !targetRuntime.isProcessing) {
+    targetRuntime.cancelRequested = false;
+    deps.scheduleQueuePump(targetRuntime, params.socket, params.opts, params.processQueuedTurn);
+    return false;
+  }
   if (await deps.resolveRecoveredApprovalResponse(targetRuntime, params.socket, params.response, handleIncomingMessage, {
     onStatusChange: params.opts.onStatusChange,
     connectionId: params.opts.connectionId
@@ -78606,6 +78701,96 @@ async function handleChangeDeviceStateInput(listener, params, deps = {}) {
   }
   return true;
 }
+async function handleAbortMessageInput(listener, params, deps = {}) {
+  const resolvedDeps = {
+    getActiveRuntime,
+    getPendingControlRequestCount,
+    getOrCreateScopedRuntime,
+    getRecoveredApprovalStateForScope,
+    stashRecoveredApprovalInterrupts,
+    rejectPendingApprovalResolvers,
+    setLoopStatus,
+    clearActiveRunState,
+    emitRuntimeStateUpdates,
+    emitInterruptedStatusDelta,
+    scheduleQueuePump,
+    cancelConversation: async (agentId, conversationId) => {
+      const client = await getClient2();
+      const cancelId = conversationId === "default" || !conversationId ? agentId : conversationId;
+      await client.conversations.cancel(cancelId);
+    },
+    ...deps
+  };
+  if (listener !== resolvedDeps.getActiveRuntime() || listener.intentionallyClosed) {
+    return false;
+  }
+  const scope = {
+    agent_id: params.command.runtime.agent_id,
+    conversation_id: params.command.runtime.conversation_id
+  };
+  const hasPendingApprovals = resolvedDeps.getPendingControlRequestCount(listener, scope) > 0;
+  const scopedRuntime = resolvedDeps.getOrCreateScopedRuntime(listener, scope.agent_id, scope.conversation_id);
+  const hasActiveTurn = scopedRuntime.isProcessing;
+  if (!hasActiveTurn && !hasPendingApprovals) {
+    return false;
+  }
+  const interruptedRunId = scopedRuntime.activeRunId;
+  scopedRuntime.cancelRequested = true;
+  if (scopedRuntime.activeExecutingToolCallIds.length > 0 && (!scopedRuntime.pendingInterruptedResults || scopedRuntime.pendingInterruptedResults.length === 0)) {
+    scopedRuntime.pendingInterruptedResults = scopedRuntime.activeExecutingToolCallIds.map((toolCallId) => ({
+      type: "tool",
+      tool_call_id: toolCallId,
+      tool_return: INTERRUPTED_BY_USER,
+      status: "error"
+    }));
+    scopedRuntime.pendingInterruptedContext = {
+      agentId: scopedRuntime.agentId || "",
+      conversationId: scopedRuntime.conversationId,
+      continuationEpoch: scopedRuntime.continuationEpoch
+    };
+    scopedRuntime.pendingInterruptedToolCallIds = [
+      ...scopedRuntime.activeExecutingToolCallIds
+    ];
+  }
+  if (scopedRuntime.activeAbortController && !scopedRuntime.activeAbortController.signal.aborted) {
+    scopedRuntime.activeAbortController.abort();
+  }
+  const recoveredApprovalState = resolvedDeps.getRecoveredApprovalStateForScope(listener, scope);
+  if (recoveredApprovalState && !hasActiveTurn) {
+    resolvedDeps.stashRecoveredApprovalInterrupts(scopedRuntime, recoveredApprovalState);
+  }
+  if (hasPendingApprovals) {
+    resolvedDeps.rejectPendingApprovalResolvers(scopedRuntime, "Cancelled by user");
+  }
+  if (hasActiveTurn) {
+    scopedRuntime.lastStopReason = "cancelled";
+    scopedRuntime.isProcessing = false;
+    resolvedDeps.clearActiveRunState(scopedRuntime);
+    resolvedDeps.setLoopStatus(scopedRuntime, "WAITING_ON_INPUT", scope);
+    resolvedDeps.emitRuntimeStateUpdates(scopedRuntime, scope);
+    resolvedDeps.emitInterruptedStatusDelta(params.socket, scopedRuntime, {
+      runId: interruptedRunId,
+      agentId: scope.agent_id,
+      conversationId: scope.conversation_id
+    });
+  } else if (hasPendingApprovals) {
+    resolvedDeps.emitInterruptedStatusDelta(params.socket, scopedRuntime, {
+      runId: interruptedRunId,
+      agentId: scope.agent_id,
+      conversationId: scope.conversation_id
+    });
+  }
+  if (!hasActiveTurn) {
+    scopedRuntime.cancelRequested = false;
+  }
+  const cancelConversationId = scopedRuntime.conversationId;
+  const cancelAgentId = scopedRuntime.agentId;
+  if (cancelAgentId) {
+    resolvedDeps.cancelConversation(cancelAgentId, cancelConversationId).catch(() => {});
+  }
+  resolvedDeps.scheduleQueuePump(scopedRuntime, params.socket, params.opts, params.processQueuedTurn);
+  return true;
+}
 async function handleCwdChange(msg, socket, runtime) {
   const conversationId = normalizeConversationId(msg.conversationId);
   const agentId = normalizeCwdAgentId(msg.agentId);
@@ -78927,64 +79112,15 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
       return;
     }
     if (parsed.type === "abort_message") {
-      if (runtime !== getActiveRuntime() || runtime.intentionallyClosed) {
-        return;
-      }
-      const hasPendingApprovals = getPendingControlRequestCount(runtime, {
-        agent_id: parsed.runtime.agent_id,
-        conversation_id: parsed.runtime.conversation_id
-      }) > 0;
-      const scopedRuntime = getOrCreateScopedRuntime(runtime, parsed.runtime.agent_id, parsed.runtime.conversation_id);
-      const hasActiveTurn = scopedRuntime.isProcessing;
-      if (!hasActiveTurn && !hasPendingApprovals) {
-        return;
-      }
-      scopedRuntime.cancelRequested = true;
-      if (scopedRuntime.activeExecutingToolCallIds.length > 0 && (!scopedRuntime.pendingInterruptedResults || scopedRuntime.pendingInterruptedResults.length === 0)) {
-        scopedRuntime.pendingInterruptedResults = scopedRuntime.activeExecutingToolCallIds.map((toolCallId) => ({
-          type: "tool",
-          tool_call_id: toolCallId,
-          tool_return: INTERRUPTED_BY_USER,
-          status: "error"
-        }));
-        scopedRuntime.pendingInterruptedContext = {
-          agentId: scopedRuntime.agentId || "",
-          conversationId: scopedRuntime.conversationId,
-          continuationEpoch: scopedRuntime.continuationEpoch
-        };
-        scopedRuntime.pendingInterruptedToolCallIds = [
-          ...scopedRuntime.activeExecutingToolCallIds
-        ];
-      }
-      if (scopedRuntime.activeAbortController && !scopedRuntime.activeAbortController.signal.aborted) {
-        scopedRuntime.activeAbortController.abort();
-      }
-      const recoveredApprovalState = getRecoveredApprovalStateForScope(runtime, {
-        agent_id: parsed.runtime.agent_id,
-        conversation_id: parsed.runtime.conversation_id
+      await handleAbortMessageInput(runtime, {
+        command: parsed,
+        socket,
+        opts: {
+          onStatusChange: opts.onStatusChange,
+          connectionId: opts.connectionId
+        },
+        processQueuedTurn
       });
-      if (recoveredApprovalState && !hasActiveTurn) {
-        stashRecoveredApprovalInterrupts(scopedRuntime, recoveredApprovalState);
-      }
-      if (hasPendingApprovals) {
-        rejectPendingApprovalResolvers(scopedRuntime, "Cancelled by user");
-      }
-      if (!hasActiveTurn && hasPendingApprovals) {
-        emitInterruptedStatusDelta(socket, scopedRuntime, {
-          runId: scopedRuntime.activeRunId,
-          agentId: parsed.runtime.agent_id,
-          conversationId: parsed.runtime.conversation_id
-        });
-      }
-      const cancelConversationId = scopedRuntime.conversationId;
-      const cancelAgentId = scopedRuntime.agentId;
-      if (cancelAgentId) {
-        getClient2().then((client) => {
-          const cancelId = cancelConversationId === "default" || !cancelConversationId ? cancelAgentId : cancelConversationId;
-          return client.conversations.cancel(cancelId);
-        }).catch(() => {});
-      }
-      scheduleQueuePump(scopedRuntime, socket, opts, processQueuedTurn);
       return;
     }
     if (isSearchFilesCommand(parsed)) {
@@ -79499,6 +79635,7 @@ var init_client4 = __esm(async () => {
     consumeQueuedTurn,
     handleIncomingMessage,
     handleApprovalResponseInput,
+    handleAbortMessageInput,
     handleChangeDeviceStateInput,
     scheduleQueuePump,
     recoverApprovalStateForSync,
@@ -145316,4 +145453,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=773D326804039A9D64756E2164756E21
+//# debugId=8449D2836CF8EFF864756E2164756E21

package/package.json

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