@letta-ai/letta-code 0.19.3 → 0.19.4

package/dist/types/protocol.d.ts

@@ -312,7 +312,7 @@ export interface QueueBatchDequeuedEvent extends MessageEnvelope {
 }
 /**
  * Why the queue cannot dequeue right now.
- * - streaming: Agent turn is actively streaming
+ * - streaming: Agent turn is actively running/streaming (request, response, or local tool execution)
  * - pending_approvals: Waiting for HITL approval decisions
  * - overlay_open: Plan mode, AskUserQuestion, or other overlay is active
  * - command_running: Slash command is executing

package/letta.js

@@ -3240,7 +3240,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.19.3",
+    version: "0.19.4",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -3313,7 +3313,7 @@ var init_package = __esm(() => {
       "test:update-chain:manual": "bun run src/tests/update-chain-smoke.ts --mode manual",
       "test:update-chain:startup": "bun run src/tests/update-chain-smoke.ts --mode startup",
       prepublishOnly: "bun run build",
-      postinstall: "node scripts/postinstall-patches.js || echo letta: vendor patches skipped"
+      postinstall: `node scripts/postinstall-patches.js || echo letta: vendor patches skipped && node -e "try{require('fs').chmodSync(require('path').join(require.resolve('node-pty/package.json'),'../prebuilds/darwin-arm64/spawn-helper'),0o755)}catch(e){}" || true`
     },
     "lint-staged": {
       "*.{ts,tsx,js,jsx,json}": [
@@ -68043,6 +68043,7 @@ var init_manager3 = __esm(async () => {
     "Glob",
     "Grep",
     "TaskStop",
+    "memory",
     "Read",
     "Skill",
     "Task",
@@ -68052,6 +68053,7 @@ var init_manager3 = __esm(async () => {
   OPENAI_DEFAULT_TOOLS = [
     "shell_command",
     "apply_patch",
+    "memory",
     "update_plan",
     "view_image"
   ];
@@ -68061,6 +68063,7 @@ var init_manager3 = __esm(async () => {
     "list_directory",
     "glob_gemini",
     "search_file_content",
+    "memory",
     "replace",
     "write_file_gemini",
     "write_todos",
@@ -68072,6 +68075,7 @@ var init_manager3 = __esm(async () => {
     "AskUserQuestion",
     "EnterPlanMode",
     "ExitPlanMode",
+    "memory",
     "Task",
     "TaskOutput",
     "TaskStop",
@@ -68085,6 +68089,7 @@ var init_manager3 = __esm(async () => {
     "AskUserQuestion",
     "EnterPlanMode",
     "ExitPlanMode",
+    "memory",
     "Skill",
     "Task",
     "RunShellCommand",
@@ -68175,82 +68180,157 @@ function sendTerminalMessage(socket, message) {
     socket.send(JSON.stringify(message));
   }
 }
+function makeOutputBatcher(onFlush) {
+  let buffer = "";
+  let timer = null;
+  const flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (buffer.length > 0) {
+      onFlush(buffer);
+      buffer = "";
+    }
+  };
+  return (chunk) => {
+    buffer += chunk;
+    if (buffer.length >= MAX_BUFFER_BYTES) {
+      flush();
+    } else if (!timer) {
+      timer = setTimeout(flush, FLUSH_INTERVAL_MS);
+    }
+  };
+}
+function spawnBun(shell2, cwd2, cols, rows, terminal_id, socket) {
+  const handleData = makeOutputBatcher((data) => sendTerminalMessage(socket, { type: "terminal_output", terminal_id, data }));
+  const proc2 = Bun.spawn([shell2], {
+    cwd: cwd2,
+    env: { ...process.env, TERM: "xterm-256color", COLORTERM: "truecolor" },
+    terminal: {
+      cols: cols || 80,
+      rows: rows || 24,
+      data: (_t, chunk) => handleData(new TextDecoder().decode(chunk))
+    }
+  });
+  const terminal = proc2.terminal;
+  if (!terminal) {
+    throw new Error("Bun.spawn terminal object missing — API unavailable");
+  }
+  proc2.exited.then((exitCode) => {
+    const current = terminals.get(terminal_id);
+    if (current && current.pid === proc2.pid) {
+      terminals.delete(terminal_id);
+      sendTerminalMessage(socket, {
+        type: "terminal_exited",
+        terminal_id,
+        exitCode: exitCode ?? 0
+      });
+    }
+  });
+  return {
+    write: (d) => {
+      try {
+        terminal.write(d);
+      } catch {}
+    },
+    resize: (c, r) => {
+      try {
+        terminal.resize(c, r);
+      } catch {}
+    },
+    kill: () => {
+      try {
+        terminal.close();
+      } catch {}
+      try {
+        proc2.kill();
+      } catch {}
+    },
+    pid: proc2.pid,
+    terminalId: terminal_id,
+    spawnedAt: Date.now()
+  };
+}
+function spawnNodePty(shell2, cwd2, cols, rows, terminal_id, socket) {
+  const pty = __require("node-pty");
+  const handleData = makeOutputBatcher((data) => sendTerminalMessage(socket, { type: "terminal_output", terminal_id, data }));
+  const ptyProcess = pty.spawn(shell2, [], {
+    name: "xterm-256color",
+    cols: cols || 80,
+    rows: rows || 24,
+    cwd: cwd2,
+    env: {
+      ...process.env,
+      TERM: "xterm-256color",
+      COLORTERM: "truecolor"
+    }
+  });
+  ptyProcess.onData(handleData);
+  ptyProcess.onExit(({ exitCode }) => {
+    const current = terminals.get(terminal_id);
+    if (current && current.pid === ptyProcess.pid) {
+      terminals.delete(terminal_id);
+      sendTerminalMessage(socket, {
+        type: "terminal_exited",
+        terminal_id,
+        exitCode: exitCode ?? 0
+      });
+    }
+  });
+  return {
+    write: (d) => {
+      try {
+        ptyProcess.write(d);
+      } catch {}
+    },
+    resize: (c, r) => {
+      try {
+        ptyProcess.resize(c, r);
+      } catch {}
+    },
+    kill: () => {
+      try {
+        ptyProcess.kill();
+      } catch {}
+    },
+    pid: ptyProcess.pid,
+    terminalId: terminal_id,
+    spawnedAt: Date.now()
+  };
+}
 function handleTerminalSpawn(msg, socket, cwd2) {
   const { terminal_id, cols, rows } = msg;
-  killTerminal(terminal_id);
-  const shell2 = getDefaultShell();
-  console.log(`[Terminal] Spawning PTY: shell=${shell2}, cwd=${cwd2}, cols=${cols}, rows=${rows}`);
-  try {
-    const proc2 = Bun.spawn([shell2], {
-      cwd: cwd2,
-      env: {
-        ...process.env,
-        TERM: "xterm-256color",
-        COLORTERM: "truecolor"
-      },
-      terminal: {
-        cols: cols || 80,
-        rows: rows || 24,
-        data: (() => {
-          let buffer = "";
-          let flushTimer = null;
-          return (_terminal, data) => {
-            buffer += new TextDecoder().decode(data);
-            if (!flushTimer) {
-              flushTimer = setTimeout(() => {
-                if (buffer.length > 0) {
-                  sendTerminalMessage(socket, {
-                    type: "terminal_output",
-                    terminal_id,
-                    data: buffer
-                  });
-                  buffer = "";
-                }
-                flushTimer = null;
-              }, 16);
-            }
-          };
-        })()
-      }
-    });
-    const terminal = proc2.terminal;
-    console.log(`[Terminal] proc.pid=${proc2.pid}, terminal=${typeof terminal}, keys=${Object.keys(proc2).join(",")}`);
-    if (!terminal) {
-      console.error("[Terminal] terminal object is undefined on proc — Bun.Terminal API may not be available");
+  const existing = terminals.get(terminal_id);
+  if (existing && Date.now() - existing.spawnedAt < 2000) {
+    let alive = true;
+    try {
+      existing.write("\r");
+    } catch {
+      alive = false;
+    }
+    if (alive) {
+      console.log(`[Terminal] Reusing session (age=${Date.now() - existing.spawnedAt}ms), pid=${existing.pid}`);
       sendTerminalMessage(socket, {
-        type: "terminal_exited",
+        type: "terminal_spawned",
         terminal_id,
-        exitCode: 1
+        pid: existing.pid
       });
       return;
     }
-    const session = {
-      process: proc2,
-      terminal,
-      terminalId: terminal_id,
-      spawnedAt: Date.now()
-    };
+    terminals.delete(terminal_id);
+  }
+  killTerminal(terminal_id);
+  const shell2 = getDefaultShell();
+  console.log(`[Terminal] Spawning PTY (${IS_BUN ? "bun" : "node-pty"}): shell=${shell2}, cwd=${cwd2}, cols=${cols}, rows=${rows}`);
+  try {
+    const session = IS_BUN ? spawnBun(shell2, cwd2, cols, rows, terminal_id, socket) : spawnNodePty(shell2, cwd2, cols, rows, terminal_id, socket);
     terminals.set(terminal_id, session);
-    console.log(`[Terminal] Session stored for terminal_id=${terminal_id}, map size=${terminals.size}`);
-    const myPid = proc2.pid;
-    proc2.exited.then((exitCode) => {
-      const current = terminals.get(terminal_id);
-      if (current && current.process.pid === myPid) {
-        console.log(`[Terminal] PTY process exited: terminal_id=${terminal_id}, pid=${myPid}, exitCode=${exitCode}`);
-        terminals.delete(terminal_id);
-        sendTerminalMessage(socket, {
-          type: "terminal_exited",
-          terminal_id,
-          exitCode: exitCode ?? 0
-        });
-      } else {
-        console.log(`[Terminal] Stale PTY exit ignored: terminal_id=${terminal_id}, pid=${myPid} (current pid=${current?.process.pid})`);
-      }
-    });
+    console.log(`[Terminal] Session stored for terminal_id=${terminal_id}, pid=${session.pid}`);
     sendTerminalMessage(socket, {
       type: "terminal_spawned",
       terminal_id,
-      pid: proc2.pid
+      pid: session.pid
     });
   } catch (error) {
     console.error("[Terminal] Failed to spawn PTY:", error);
@@ -68262,16 +68342,10 @@ function handleTerminalSpawn(msg, socket, cwd2) {
   }
 }
 function handleTerminalInput(msg) {
-  const session = terminals.get(msg.terminal_id);
-  if (session) {
-    session.terminal.write(msg.data);
-  }
+  terminals.get(msg.terminal_id)?.write(msg.data);
 }
 function handleTerminalResize(msg) {
-  const session = terminals.get(msg.terminal_id);
-  if (session) {
-    session.terminal.resize(msg.cols, msg.rows);
-  }
+  terminals.get(msg.terminal_id)?.resize(msg.cols, msg.rows);
 }
 function handleTerminalKill(msg) {
   const session = terminals.get(msg.terminal_id);
@@ -68284,11 +68358,8 @@ function handleTerminalKill(msg) {
 function killTerminal(terminalId) {
   const session = terminals.get(terminalId);
   if (session) {
-    console.log(`[Terminal] killTerminal: terminalId=${terminalId}, pid=${session.process.pid}`);
-    try {
-      session.terminal.close();
-    } catch {}
-    session.process.kill();
+    console.log(`[Terminal] killTerminal: terminalId=${terminalId}, pid=${session.pid}`);
+    session.kill();
     terminals.delete(terminalId);
   }
 }
@@ -68297,8 +68368,10 @@ function killAllTerminals() {
     killTerminal(id);
   }
 }
-var terminals;
+var IS_BUN, FLUSH_INTERVAL_MS = 16, MAX_BUFFER_BYTES, terminals;
 var init_terminalHandler = __esm(() => {
+  IS_BUN = typeof Bun !== "undefined";
+  MAX_BUFFER_BYTES = 64 * 1024;
   terminals = new Map;
 });
 
@@ -69172,7 +69245,7 @@ function resolvePendingApprovalResolver(runtime, response) {
   runtime.pendingApprovalResolvers.delete(requestId);
   runtime.listener.approvalRuntimeKeyByRequestId.delete(requestId);
   if (runtime.pendingApprovalResolvers.size === 0) {
-    setLoopStatus(runtime, runtime.isProcessing ? "PROCESSING_API_RESPONSE" : "WAITING_ON_INPUT");
+    setLoopStatus(runtime, "WAITING_ON_INPUT");
   }
   pending.resolve(response);
   emitLoopStatusIfOpen(runtime.listener, {
@@ -69196,7 +69269,7 @@ function rejectPendingApprovalResolvers(runtime, reason) {
       runtime.listener.approvalRuntimeKeyByRequestId.delete(requestId);
     }
   }
-  setLoopStatus(runtime, runtime.isProcessing ? "PROCESSING_API_RESPONSE" : "WAITING_ON_INPUT");
+  setLoopStatus(runtime, "WAITING_ON_INPUT");
   emitLoopStatusIfOpen(runtime.listener, {
     agent_id: runtime.agentId,
     conversation_id: runtime.conversationId
@@ -69857,12 +69930,19 @@ function mergeQueuedTurnInput(queued, options) {
 
 // src/websocket/helpers/listenerQueueAdapter.ts
 function getListenerBlockedReason(c) {
-  if (c.pendingApprovalsLen > 0)
-    return "pending_approvals";
   if (c.cancelRequested)
     return "interrupt_in_progress";
+  if (c.pendingApprovalsLen > 0)
+    return "pending_approvals";
   if (c.isRecoveringApprovals)
     return "runtime_busy";
+  if (c.loopStatus === "WAITING_ON_APPROVAL")
+    return "pending_approvals";
+  if (c.loopStatus === "EXECUTING_COMMAND")
+    return "command_running";
+  if (c.loopStatus === "SENDING_API_REQUEST" || c.loopStatus === "RETRYING_API_REQUEST" || c.loopStatus === "WAITING_FOR_API_RESPONSE" || c.loopStatus === "PROCESSING_API_RESPONSE" || c.loopStatus === "EXECUTING_CLIENT_SIDE_TOOL") {
+    return "streaming";
+  }
   if (c.isProcessing)
     return "runtime_busy";
   return null;
@@ -69876,7 +69956,8 @@ __export(exports_queue, {
   normalizeMessageContentImages: () => normalizeMessageContentImages,
   normalizeInboundMessages: () => normalizeInboundMessages,
   getQueueItemsScope: () => getQueueItemsScope,
-  getQueueItemScope: () => getQueueItemScope
+  getQueueItemScope: () => getQueueItemScope,
+  consumeQueuedTurn: () => consumeQueuedTurn
 });
 function getQueueItemScope(item) {
   if (!item) {
@@ -69895,6 +69976,9 @@ function getQueueItemsScope(items) {
   const sameScope = items.every((item) => (item.agentId ?? null) === (first.agentId ?? null) && (item.conversationId ?? null) === (first.conversationId ?? null));
   return sameScope ? getQueueItemScope(first) : {};
 }
+function hasSameQueueScope(a, b) {
+  return (a.agentId ?? null) === (b.agentId ?? null) && (a.conversationId ?? null) === (b.conversationId ?? null);
+}
 function mergeDequeuedBatchContent(items) {
   const queuedInputs = [];
   for (const item of items) {
@@ -70012,12 +70096,46 @@ function buildQueuedTurnMessage(runtime, batch) {
 function shouldQueueInboundMessage(parsed) {
   return parsed.messages.some((payload) => ("content" in payload));
 }
+function consumeQueuedTurn(runtime) {
+  const queuedItems = runtime.queueRuntime.peek();
+  const firstQueuedItem = queuedItems[0];
+  if (!firstQueuedItem || !isCoalescable(firstQueuedItem.kind)) {
+    return null;
+  }
+  let queueLen = 0;
+  let hasMessage = false;
+  for (const item of queuedItems) {
+    if (!isCoalescable(item.kind) || !hasSameQueueScope(firstQueuedItem, item)) {
+      break;
+    }
+    queueLen += 1;
+    if (item.kind === "message") {
+      hasMessage = true;
+    }
+  }
+  if (!hasMessage || queueLen === 0) {
+    return null;
+  }
+  const dequeuedBatch = runtime.queueRuntime.consumeItems(queueLen);
+  if (!dequeuedBatch) {
+    return null;
+  }
+  const queuedTurn = buildQueuedTurnMessage(runtime, dequeuedBatch);
+  if (!queuedTurn) {
+    return null;
+  }
+  return {
+    dequeuedBatch,
+    queuedTurn
+  };
+}
 function computeListenerQueueBlockedReason(runtime) {
   const activeScope = resolveRuntimeScope(runtime.listener, {
     agent_id: runtime.agentId,
     conversation_id: runtime.conversationId
   });
   return getListenerBlockedReason({
+    loopStatus: runtime.loopStatus,
     isProcessing: runtime.isProcessing,
     pendingApprovalsLen: activeScope ? getPendingControlRequestCount(runtime.listener, activeScope) : 0,
     cancelRequested: runtime.cancelRequested,
@@ -70039,18 +70157,11 @@ async function drainQueuedMessages(runtime, socket, opts, processQueuedTurn) {
         runtime.queueRuntime.tryDequeue(blockedReason);
         return;
       }
-      const queueLen = runtime.queueRuntime.length;
-      if (queueLen === 0) {
-        return;
-      }
-      const dequeuedBatch = runtime.queueRuntime.consumeItems(queueLen);
-      if (!dequeuedBatch) {
+      const consumedQueuedTurn = consumeQueuedTurn(runtime);
+      if (!consumedQueuedTurn) {
         return;
       }
-      const queuedTurn = buildQueuedTurnMessage(runtime, dequeuedBatch);
-      if (!queuedTurn) {
-        continue;
-      }
+      const { dequeuedBatch, queuedTurn } = consumedQueuedTurn;
       emitDequeuedUserMessage(socket, runtime, queuedTurn, dequeuedBatch);
       const preTurnStatus = getListenerStatus(runtime.listener) === "processing" ? "processing" : "receiving";
       if (opts.connectionId && runtime.listener.lastEmittedStatus !== preTurnStatus) {
@@ -70085,6 +70196,7 @@ function scheduleQueuePump(runtime, socket, opts, processQueuedTurn) {
   });
 }
 var init_queue = __esm(async () => {
+  init_queueRuntime();
   init_runtime();
   await __promiseAll([
     init_imageResize(),
@@ -74710,17 +74822,26 @@ async function resolveRecoveredApprovalResponse(runtime, socket, response, proce
     runtime.activeAbortController = null;
     setLoopStatus(runtime, "SENDING_API_REQUEST", scope);
     emitRuntimeStateUpdates(runtime, scope);
+    const continuationMessages = [
+      {
+        type: "approval",
+        approvals: approvalResults
+      }
+    ];
+    let continuationBatchId = `batch-recovered-${crypto.randomUUID()}`;
+    const consumedQueuedTurn = consumeQueuedTurn(runtime);
+    if (consumedQueuedTurn) {
+      const { dequeuedBatch, queuedTurn } = consumedQueuedTurn;
+      continuationBatchId = dequeuedBatch.batchId;
+      continuationMessages.push(...queuedTurn.messages);
+      emitDequeuedUserMessage(socket, runtime, queuedTurn, dequeuedBatch);
+    }
     await processTurn({
       type: "message",
       agentId: recovered.agentId,
       conversationId: recovered.conversationId,
-      messages: [
-        {
-          type: "approval",
-          approvals: approvalResults
-        }
-      ]
-    }, socket, runtime, opts?.onStatusChange, opts?.connectionId, `batch-recovered-${crypto.randomUUID()}`);
+      messages: continuationMessages
+    }, socket, runtime, opts?.onStatusChange, opts?.connectionId, continuationBatchId);
     clearRecoveredApprovalState(runtime);
     return true;
   } catch (error) {
@@ -74753,7 +74874,8 @@ var init_recovery = __esm(async () => {
     init_stream(),
     init_approval(),
     init_interrupts(),
-    init_protocol_outbound()
+    init_protocol_outbound(),
+    init_queue()
   ]);
 });
 
@@ -74877,9 +74999,10 @@ function markAwaitingAcceptedApprovalContinuationRunId(runtime, input) {
     runtime.activeRunId = null;
   }
 }
-async function resolveStaleApprovals(runtime, socket, abortSignal) {
+async function resolveStaleApprovals(runtime, socket, abortSignal, deps = {}) {
   if (!runtime.agentId)
     return null;
+  const getResumeDataImpl = deps.getResumeData ?? getResumeData2;
   const client = await getClient2();
   let agent;
   try {
@@ -74893,7 +75016,7 @@ async function resolveStaleApprovals(runtime, socket, abortSignal) {
   const requestedConversationId = runtime.conversationId !== "default" ? runtime.conversationId : undefined;
   let resumeData;
   try {
-    resumeData = await getResumeData2(client, agent, requestedConversationId, {
+    resumeData = await getResumeDataImpl(client, agent, requestedConversationId, {
       includeMessageHistory: false
     });
   } catch (err) {
@@ -75014,7 +75137,19 @@ async function resolveStaleApprovals(runtime, socket, abortSignal) {
         conversationId: recoveryConversationId
       });
       emitInterruptToolReturnMessage(socket, runtime, approvalResults, runtime.activeRunId ?? undefined, "tool-return");
-      const recoveryStream = await sendApprovalContinuationWithRetry(recoveryConversationId, [{ type: "approval", approvals: approvalResults }], {
+      const continuationMessages = [
+        {
+          type: "approval",
+          approvals: approvalResults
+        }
+      ];
+      const consumedQueuedTurn = consumeQueuedTurn(runtime);
+      if (consumedQueuedTurn) {
+        const { dequeuedBatch, queuedTurn } = consumedQueuedTurn;
+        continuationMessages.push(...queuedTurn.messages);
+        emitDequeuedUserMessage(socket, runtime, queuedTurn, dequeuedBatch);
+      }
+      const recoveryStream = await sendApprovalContinuationWithRetry(recoveryConversationId, continuationMessages, {
         agentId: runtime.agentId ?? undefined,
         streamTokens: true,
         background: true,
@@ -75023,6 +75158,7 @@ async function resolveStaleApprovals(runtime, socket, abortSignal) {
       if (!recoveryStream) {
         throw new Error("Approval recovery send resolved without a continuation stream");
       }
+      setLoopStatus(runtime, "PROCESSING_API_RESPONSE", scope);
       const drainResult = await drainRecoveryStreamWithEmission(recoveryStream, socket, runtime, {
         agentId: runtime.agentId ?? undefined,
         conversationId: recoveryConversationId,
@@ -75317,6 +75453,7 @@ var init_send = __esm(async () => {
     init_approval(),
     init_interrupts(),
     init_protocol_outbound(),
+    init_queue(),
     init_recovery()
   ]);
 });
@@ -76155,6 +76292,7 @@ async function handleApprovalStop(params) {
       terminated: true,
       stream: null,
       currentInput,
+      dequeuedBatchId,
       pendingNormalizationInterruptedToolCallIds: [],
       turnToolContextId,
       lastExecutionResults: null,
@@ -76231,11 +76369,10 @@ async function handleApprovalStop(params) {
           });
         }
       } else {
-        const denyReason = responseBody.error;
         decisions.push({
           type: "deny",
           approval: ac.approval,
-          reason: denyReason
+          reason: responseBody.error
         });
       }
     }
@@ -76250,7 +76387,7 @@ async function handleApprovalStop(params) {
     agent_id: agentId,
     conversation_id: conversationId
   });
-  const executionRunId = runId || runtime.activeRunId || params.msgRunIds[params.msgRunIds.length - 1];
+  const executionRunId = runId || runtime.activeRunId || msgRunIds[msgRunIds.length - 1];
   emitToolExecutionStartedEvents(socket, runtime, {
     toolCallIds: lastExecutingToolCallIds,
     runId: executionRunId,
@@ -76282,6 +76419,14 @@ async function handleApprovalStop(params) {
       approvals: persistedExecutionResults
     }
   ];
+  let continuationBatchId = dequeuedBatchId;
+  const consumedQueuedTurn = consumeQueuedTurn(runtime);
+  if (consumedQueuedTurn) {
+    const { dequeuedBatch, queuedTurn } = consumedQueuedTurn;
+    continuationBatchId = dequeuedBatch.batchId;
+    nextInput.push(...queuedTurn.messages);
+    emitDequeuedUserMessage(socket, runtime, queuedTurn, dequeuedBatch);
+  }
   setLoopStatus(runtime, "SENDING_API_REQUEST", {
     agent_id: agentId,
     conversation_id: conversationId
@@ -76292,6 +76437,7 @@ async function handleApprovalStop(params) {
       terminated: true,
       stream: null,
       currentInput: nextInput,
+      dequeuedBatchId: continuationBatchId,
       pendingNormalizationInterruptedToolCallIds: [],
       turnToolContextId,
       lastExecutionResults,
@@ -76325,6 +76471,7 @@ async function handleApprovalStop(params) {
     terminated: false,
     stream: stream2,
     currentInput: nextInput,
+    dequeuedBatchId: continuationBatchId,
     pendingNormalizationInterruptedToolCallIds: [],
     turnToolContextId: null,
     lastExecutionResults,
@@ -76342,6 +76489,7 @@ var init_turn_approval = __esm(async () => {
     init_approval(),
     init_interrupts(),
     init_protocol_outbound(),
+    init_queue(),
     init_recovery(),
     init_send()
   ]);
@@ -76362,6 +76510,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
   let llmApiErrorRetries = 0;
   let emptyResponseRetries = 0;
   let lastApprovalContinuationAccepted = false;
+  let activeDequeuedBatchId = dequeuedBatchId;
   let lastExecutionResults = null;
   let lastExecutingToolCallIds = [];
   let lastNeedsUserInputToolCallIds = [];
@@ -76723,7 +76872,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
         conversationId,
         turnWorkingDirectory,
         turnPermissionModeState,
-        dequeuedBatchId,
+        dequeuedBatchId: activeDequeuedBatchId,
         runId,
         msgRunIds,
         currentInput,
@@ -76736,6 +76885,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
       }
       stream2 = approvalResult.stream;
       currentInput = approvalResult.currentInput;
+      activeDequeuedBatchId = approvalResult.dequeuedBatchId;
       pendingNormalizationInterruptedToolCallIds = approvalResult.pendingNormalizationInterruptedToolCallIds;
       turnToolContextId = approvalResult.turnToolContextId;
       lastExecutionResults = approvalResult.lastExecutionResults;
@@ -76957,6 +77107,51 @@ async function handleApprovalResponseInput(listener, params, deps = {
   }
   return false;
 }
+async function handleChangeDeviceStateInput(listener, params, deps = {}) {
+  const resolvedDeps = {
+    getActiveRuntime,
+    getOrCreateScopedRuntime,
+    getPendingControlRequestCount,
+    setLoopStatus,
+    handleModeChange,
+    handleCwdChange,
+    emitDeviceStatusUpdate,
+    scheduleQueuePump,
+    ...deps
+  };
+  if (listener !== resolvedDeps.getActiveRuntime() || listener.intentionallyClosed) {
+    return false;
+  }
+  const scope = {
+    agent_id: params.command.payload.agent_id ?? params.command.runtime.agent_id ?? undefined,
+    conversation_id: params.command.payload.conversation_id ?? params.command.runtime.conversation_id ?? undefined
+  };
+  const scopedRuntime = resolvedDeps.getOrCreateScopedRuntime(listener, scope.agent_id, scope.conversation_id);
+  const shouldTrackCommand = !scopedRuntime.isProcessing && resolvedDeps.getPendingControlRequestCount(listener, scope) === 0;
+  if (shouldTrackCommand) {
+    resolvedDeps.setLoopStatus(scopedRuntime, "EXECUTING_COMMAND", scope);
+  }
+  try {
+    if (params.command.payload.mode) {
+      resolvedDeps.handleModeChange({ mode: params.command.payload.mode }, params.socket, listener, scope);
+    }
+    if (params.command.payload.cwd) {
+      await resolvedDeps.handleCwdChange({
+        agentId: scope.agent_id ?? null,
+        conversationId: scope.conversation_id ?? null,
+        cwd: params.command.payload.cwd
+      }, params.socket, scopedRuntime);
+    } else if (!params.command.payload.mode) {
+      resolvedDeps.emitDeviceStatusUpdate(params.socket, listener, scope);
+    }
+  } finally {
+    if (shouldTrackCommand) {
+      resolvedDeps.setLoopStatus(scopedRuntime, "WAITING_ON_INPUT", scope);
+      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);
@@ -77241,36 +77436,15 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
       return;
     }
     if (parsed.type === "change_device_state") {
-      if (runtime !== getActiveRuntime() || runtime.intentionallyClosed) {
-        return;
-      }
-      const scope = {
-        agent_id: parsed.payload.agent_id ?? parsed.runtime.agent_id ?? undefined,
-        conversation_id: parsed.payload.conversation_id ?? parsed.runtime.conversation_id ?? undefined
-      };
-      const scopedRuntime = getOrCreateScopedRuntime(runtime, scope.agent_id, scope.conversation_id);
-      const shouldTrackCommand = !scopedRuntime.isProcessing && getPendingControlRequestCount(runtime, scope) === 0;
-      if (shouldTrackCommand) {
-        setLoopStatus(scopedRuntime, "EXECUTING_COMMAND", scope);
-      }
-      try {
-        if (parsed.payload.mode) {
-          handleModeChange({ mode: parsed.payload.mode }, socket, runtime, scope);
-        }
-        if (parsed.payload.cwd) {
-          await handleCwdChange({
-            agentId: scope.agent_id ?? null,
-            conversationId: scope.conversation_id ?? null,
-            cwd: parsed.payload.cwd
-          }, socket, scopedRuntime);
-        } else if (!parsed.payload.mode) {
-          emitDeviceStatusUpdate(socket, runtime, scope);
-        }
-      } finally {
-        if (shouldTrackCommand) {
-          setLoopStatus(scopedRuntime, "WAITING_ON_INPUT", scope);
-        }
-      }
+      await handleChangeDeviceStateInput(runtime, {
+        command: parsed,
+        socket,
+        opts: {
+          onStatusChange: opts.onStatusChange,
+          connectionId: opts.connectionId
+        },
+        processQueuedTurn
+      });
       return;
     }
     if (parsed.type === "abort_message") {
@@ -77626,10 +77800,13 @@ var init_client4 = __esm(async () => {
     shouldAttemptPostStopApprovalRecovery,
     getApprovalContinuationRecoveryDisposition,
     markAwaitingAcceptedApprovalContinuationRunId,
+    resolveStaleApprovals,
     normalizeMessageContentImages,
     normalizeInboundMessages,
+    consumeQueuedTurn,
     handleIncomingMessage,
     handleApprovalResponseInput,
+    handleChangeDeviceStateInput,
     scheduleQueuePump,
     recoverApprovalStateForSync,
     clearRecoveredApprovalStateForScope: (runtime, scope) => clearRecoveredApprovalStateForScope(asListenerRuntimeForTests(runtime), scope),
@@ -141191,6 +141368,7 @@ var ANTHROPIC_DEFAULT_TOOLS2 = [
   "Glob",
   "Grep",
   "TaskStop",
+  "memory",
   "Read",
   "Skill",
   "Task",
@@ -141201,6 +141379,7 @@ var OPENAI_PASCAL_TOOLS2 = [
   "AskUserQuestion",
   "EnterPlanMode",
   "ExitPlanMode",
+  "memory",
   "Task",
   "TaskOutput",
   "TaskStop",
@@ -141214,6 +141393,7 @@ var GEMINI_PASCAL_TOOLS2 = [
   "AskUserQuestion",
   "EnterPlanMode",
   "ExitPlanMode",
+  "memory",
   "Skill",
   "Task",
   "RunShellCommand",
@@ -142972,4 +143152,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=9B4D5740B8FA924E64756E2164756E21
+//# debugId=D1C8E311510A3C4964756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.19.3",
+  "version": "0.19.4",
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
   "bin": {
@@ -73,7 +73,7 @@
     "test:update-chain:manual": "bun run src/tests/update-chain-smoke.ts --mode manual",
     "test:update-chain:startup": "bun run src/tests/update-chain-smoke.ts --mode startup",
     "prepublishOnly": "bun run build",
-    "postinstall": "node scripts/postinstall-patches.js || echo letta: vendor patches skipped"
+    "postinstall": "node scripts/postinstall-patches.js || echo letta: vendor patches skipped && node -e \"try{require('fs').chmodSync(require('path').join(require.resolve('node-pty/package.json'),'../prebuilds/darwin-arm64/spawn-helper'),0o755)}catch(e){}\" || true"
   },
   "lint-staged": {
     "*.{ts,tsx,js,jsx,json}": [