@letta-ai/letta-code 0.11.2-next.4 → 0.12.1

package/letta.js

@@ -3237,7 +3237,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.11.2-next.4",
+    version: "0.12.1",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -29951,6 +29951,10 @@ var init_WelcomeScreen = __esm(async () => {
 });
 
 // src/permissions/readOnlyShell.ts
+function isReadOnlySkillScript(scriptPath) {
+  const normalized = scriptPath.replace(/\\/g, "/");
+  return BUNDLED_READ_ONLY_SCRIPTS.some((pattern) => normalized.endsWith(pattern));
+}
 function isReadOnlyShellCommand(command) {
   if (!command) {
     return false;
@@ -30018,6 +30022,13 @@ function isSafeSegment(segment) {
     if (command === "sort") {
       return !/\s-o\b/.test(segment);
     }
+    if (command === "npx" && tokens[1] === "tsx") {
+      const scriptPath = tokens[2];
+      if (scriptPath && isReadOnlySkillScript(scriptPath)) {
+        return true;
+      }
+      return false;
+    }
     return false;
   }
   return true;
@@ -30050,7 +30061,7 @@ function extractDashCArgument(tokens) {
   }
   return;
 }
-var ALWAYS_SAFE_COMMANDS, SAFE_GIT_SUBCOMMANDS, DANGEROUS_OPERATOR_PATTERN;
+var ALWAYS_SAFE_COMMANDS, SAFE_GIT_SUBCOMMANDS, BUNDLED_READ_ONLY_SCRIPTS, DANGEROUS_OPERATOR_PATTERN;
 var init_readOnlyShell = __esm(() => {
   ALWAYS_SAFE_COMMANDS = new Set([
     "cat",
@@ -30113,6 +30124,12 @@ var init_readOnlyShell = __esm(() => {
     "tag",
     "remote"
   ]);
+  BUNDLED_READ_ONLY_SCRIPTS = [
+    "/skills/searching-messages/scripts/search-messages.ts",
+    "/skills/searching-messages/scripts/get-messages.ts",
+    "/skills/builtin/searching-messages/scripts/search-messages.ts",
+    "/skills/builtin/searching-messages/scripts/get-messages.ts"
+  ];
   DANGEROUS_OPERATOR_PATTERN = /(>>|>|\$\(|`)/;
 });
 
@@ -31629,6 +31646,46 @@ Remember: You're planning, not implementing. Don't make changes, just create a r
 `;
 var init_plan = () => {};
 
+// src/agent/subagents/builtin/recall.md
+var recall_default = `---
+name: recall
+description: Search conversation history to recall past discussions, decisions, and context
+tools: Skill, Bash, Read, BashOutput
+model: haiku
+memoryBlocks: human, persona
+mode: stateless
+---
+
+You are a subagent launched via the Task tool to search conversation history. You run autonomously and return a single final report when done. You CANNOT ask questions mid-execution.
+
+## Instructions
+
+### Step 1: Load the searching-messages skill
+\`\`\`
+Skill({ command: "load", skills: ["searching-messages"] })
+\`\`\`
+
+The skill content will appear in your loaded_skills block with script paths and search strategies.
+
+### Step 2: Search the parent agent's history
+
+**CRITICAL - Two rules:**
+
+1. **DO NOT use \`conversation_search\`** - That tool only searches YOUR history (empty). You MUST use the Bash scripts from the skill.
+
+2. **ALWAYS add \`--agent-id $LETTA_PARENT_AGENT_ID\`** - This searches the parent agent's history. The only exception is \`--all-agents\` searches.
+
+Follow the strategies documented in the loaded skill.
+
+## Output Format
+
+1. **Direct answer** - What the user asked about
+2. **Key findings** - Relevant quotes or summaries from past conversations
+3. **When discussed** - Timestamps of relevant discussions
+4. **Outcome/Decision** - What was decided or concluded (if applicable)
+`;
+var init_recall = () => {};
+
 // src/agent/subagents/index.ts
 var exports_subagents = {};
 __export(exports_subagents, {
@@ -31793,7 +31850,13 @@ var init_subagents = __esm(() => {
   init_explore();
   init_general_purpose();
   init_plan();
-  BUILTIN_SOURCES = [explore_default, general_purpose_default, plan_default];
+  init_recall();
+  BUILTIN_SOURCES = [
+    explore_default,
+    general_purpose_default,
+    plan_default,
+    recall_default
+  ];
   GLOBAL_AGENTS_DIR = join3(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents");
   VALID_MEMORY_BLOCKS = new Set(MEMORY_BLOCK_LABELS);
   cache3 = {
@@ -43281,11 +43344,16 @@ async function executeSubagent(type, config, model, userPrompt, baseURL, subagen
   try {
     const cliArgs = buildSubagentArgs(type, config, model, userPrompt);
     const lettaCmd = process.env.LETTA_CODE_BIN || "letta";
+    let parentAgentId;
+    try {
+      parentAgentId = getCurrentAgentId();
+    } catch {}
     const proc2 = spawn3(lettaCmd, cliArgs, {
       cwd: process.cwd(),
       env: {
         ...process.env,
-        LETTA_CODE_AGENT_ROLE: "subagent"
+        LETTA_CODE_AGENT_ROLE: "subagent",
+        ...parentAgentId && { LETTA_PARENT_AGENT_ID: parentAgentId }
       }
     });
     let wasAborted = false;
@@ -45644,7 +45712,13 @@ var init_subagents2 = __esm(() => {
   init_explore();
   init_general_purpose();
   init_plan();
-  BUILTIN_SOURCES2 = [explore_default, general_purpose_default, plan_default];
+  init_recall();
+  BUILTIN_SOURCES2 = [
+    explore_default,
+    general_purpose_default,
+    plan_default,
+    recall_default
+  ];
   GLOBAL_AGENTS_DIR2 = join10(process.env.HOME || process.env.USERPROFILE || "~", ".letta/agents");
   VALID_MEMORY_BLOCKS2 = new Set(MEMORY_BLOCK_LABELS);
   cache4 = {
@@ -48326,7 +48400,9 @@ var init_checker = __esm(() => {
     "explore",
     "Explore",
     "plan",
-    "Plan"
+    "Plan",
+    "recall",
+    "Recall"
   ]);
 });
 
@@ -49510,7 +49586,7 @@ var init_create = __esm(async () => {
 });
 
 // src/agent/message.ts
-async function sendMessageStream(agentId, messages, opts = { streamTokens: true, background: true }) {
+async function sendMessageStream(agentId, messages, opts = { streamTokens: true, background: true }, requestOptions = { maxRetries: 0 }) {
   const client = await getClient2();
   return client.agents.messages.create(agentId, {
     messages,
@@ -49518,7 +49594,7 @@ async function sendMessageStream(agentId, messages, opts = { streamTokens: true,
     stream_tokens: opts.streamTokens ?? true,
     background: opts.background ?? true,
     client_tools: getClientToolsFromRegistry()
-  });
+  }, requestOptions);
 }
 var init_message = __esm(async () => {
   await __promiseAll([
@@ -49636,8 +49712,10 @@ function markCurrentLineAsFinished(b) {
     markAsFinished(b, b.lastOtid);
   } else {}
 }
-function markIncompleteToolsAsCancelled(b) {
-  b.interrupted = true;
+function markIncompleteToolsAsCancelled(b, setInterruptedFlag = true) {
+  if (setInterruptedFlag) {
+    b.interrupted = true;
+  }
   let anyToolsCancelled = false;
   for (const [id, line] of b.byId.entries()) {
     if (line.kind === "tool_call" && line.phase !== "finished") {
@@ -50032,6 +50110,10 @@ async function drainStream(stream2, buffers, refresh, abortSignal, onFirstMessag
         queueMicrotask(refresh);
         break;
       }
+      const errObj = chunk.error;
+      if (errObj?.detail?.includes("No tool call is currently awaiting approval")) {
+        continue;
+      }
       onChunk(buffers, chunk);
       queueMicrotask(refresh);
       if (chunk.message_type === "stop_reason") {
@@ -50113,7 +50195,7 @@ async function drainStreamWithResume(stream2, buffers, refresh, abortSignal, onF
       const resumeStream = await client.runs.messages.stream(result.lastRunId, {
         starting_after: result.lastSeqId,
         batch_size: 1000
-      });
+      }, { maxRetries: 0 });
       const resumeResult = await drainStream(resumeStream, buffers, refresh, abortSignal);
       result = resumeResult;
     } catch (_e) {
@@ -70528,6 +70610,7 @@ function App2({
   }, [agentId]);
   const [streaming, setStreaming, streamingRef] = useSyncedState(false);
   const processingConversationRef = import_react76.useRef(0);
+  const conversationGenerationRef = import_react76.useRef(0);
   const [interruptRequested, setInterruptRequested] = import_react76.useState(false);
   const [commandRunning, setCommandRunning, commandRunningRef] = useSyncedState(false);
   const [profileConfirmPending, setProfileConfirmPending] = import_react76.useState(null);
@@ -70917,6 +71000,10 @@ function App2({
   const processConversation = import_react76.useCallback(async (initialInput, options) => {
     const currentInput = [...initialInput];
     const allowReentry = options?.allowReentry ?? false;
+    const myGeneration = options?.submissionGeneration ?? conversationGenerationRef.current;
+    if (myGeneration !== conversationGenerationRef.current) {
+      return;
+    }
     if (processingConversationRef.current > 0 && !allowReentry) {
       return;
     }
@@ -70930,20 +71017,29 @@ function App2({
         userCancelledRef.current = false;
         return;
       }
+      if (myGeneration !== conversationGenerationRef.current) {
+        return;
+      }
       setStreaming(true);
       abortControllerRef.current = new AbortController;
-      markIncompleteToolsAsCancelled(buffersRef.current);
+      markIncompleteToolsAsCancelled(buffersRef.current, false);
       buffersRef.current.interrupted = false;
       clearCompletedSubagents();
       while (true) {
         const signal = abortControllerRef.current?.signal;
         if (signal?.aborted) {
-          setStreaming(false);
+          const isStaleAtAbort = myGeneration !== conversationGenerationRef.current;
+          if (!isStaleAtAbort) {
+            setStreaming(false);
+          }
           return;
         }
         const stream2 = await sendMessageStream(agentIdRef.current, currentInput);
         if (signal?.aborted) {
-          setStreaming(false);
+          const isStaleAtAbort = myGeneration !== conversationGenerationRef.current;
+          if (!isStaleAtAbort) {
+            setStreaming(false);
+          }
           return;
         }
         const syncAgentState = async () => {
@@ -70987,6 +71083,10 @@ function App2({
         const wasInterrupted = !!buffersRef.current.interrupted;
         const wasAborted = !!signal?.aborted;
         let stopReasonToHandle = wasAborted ? "cancelled" : stopReason;
+        const isStaleAfterDrain = myGeneration !== conversationGenerationRef.current;
+        if (isStaleAfterDrain) {
+          return;
+        }
         if (!wasInterrupted) {
           refreshDerived();
         }
@@ -71306,7 +71406,8 @@ function App2({
           sendDesktopNotification();
           return;
         }
-        const isApprovalPayload = currentInput.length === 1 && currentInput[0]?.type === "approval";
+        const hasApprovalInPayload = currentInput.some((item) => item?.type === "approval");
+        const isApprovalOnlyPayload = hasApprovalInPayload && currentInput.length === 1;
         let latestErrorText = null;
         for (let i = buffersRef.current.order.length - 1;i >= 0; i -= 1) {
           const id = buffersRef.current.order[i];
@@ -71321,7 +71422,7 @@ function App2({
         const detailFromRun = await fetchRunErrorDetail(lastRunId);
         const desyncDetected = isApprovalStateDesyncError(detailFromRun) || isApprovalStateDesyncError(latestErrorText);
         const lastFailureMessage = latestErrorText || detailFromRun || null;
-        if (isApprovalPayload && desyncDetected) {
+        if (hasApprovalInPayload && desyncDetected) {
           if (llmApiErrorRetriesRef.current < LLM_API_ERROR_MAX_RETRIES2) {
             llmApiErrorRetriesRef.current += 1;
             const statusId = uid4("status");
@@ -71334,10 +71435,20 @@ function App2({
             });
             buffersRef.current.order.push(statusId);
             refreshDerived();
-            currentInput.splice(0, currentInput.length, buildApprovalRecoveryMessage());
+            if (isApprovalOnlyPayload) {
+              currentInput.splice(0, currentInput.length, buildApprovalRecoveryMessage());
+            } else {
+              const messageItems = currentInput.filter((item) => item?.type !== "approval");
+              if (messageItems.length > 0) {
+                currentInput.splice(0, currentInput.length, ...messageItems);
+              } else {
+                currentInput.splice(0, currentInput.length, buildApprovalRecoveryMessage());
+              }
+            }
             buffersRef.current.byId.delete(statusId);
             buffersRef.current.order = buffersRef.current.order.filter((id) => id !== statusId);
             refreshDerived();
+            buffersRef.current.interrupted = false;
             continue;
           }
           const errorToShow = lastFailureMessage || `An error occurred during agent execution
@@ -71377,6 +71488,7 @@ function App2({
           buffersRef.current.order = buffersRef.current.order.filter((id) => id !== statusId);
           refreshDerived();
           if (!cancelled) {
+            buffersRef.current.interrupted = false;
             continue;
           }
         }
@@ -71449,8 +71561,11 @@ function App2({
       sendDesktopNotification();
       refreshDerived();
     } finally {
+      const isStale = myGeneration !== conversationGenerationRef.current;
       abortControllerRef.current = null;
-      processingConversationRef.current = Math.max(0, processingConversationRef.current - 1);
+      if (!isStale) {
+        processingConversationRef.current = Math.max(0, processingConversationRef.current - 1);
+      }
     }
   }, [
     appendError,
@@ -71493,8 +71608,9 @@ function App2({
       }, 50);
       return;
     }
-    if (!streaming || interruptRequested)
+    if (!streaming || interruptRequested) {
       return;
+    }
     if (waitingForQueueCancelRef.current) {
       setRestoreQueueOnCancel(true);
     }
@@ -71507,11 +71623,22 @@ function App2({
         abortControllerRef.current = null;
       }
       userCancelledRef.current = true;
+      conversationGenerationRef.current += 1;
+      processingConversationRef.current = 0;
       setStreaming(false);
       if (!toolsCancelled) {
         appendError(INTERRUPT_MESSAGE, true);
       }
       refreshDerived();
+      if (pendingApprovals.length > 0) {
+        const denialResults = pendingApprovals.map((approval) => ({
+          type: "approval",
+          tool_call_id: approval.toolCallId,
+          approve: false,
+          reason: "User interrupted the stream"
+        }));
+        setQueuedApprovalResults(denialResults);
+      }
       setPendingApprovals([]);
       setApprovalContexts([]);
       setApprovalResults([]);
@@ -71544,7 +71671,8 @@ function App2({
     appendError,
     isExecutingTool,
     refreshDerived,
-    setStreaming
+    setStreaming,
+    pendingApprovals
   ]);
   const processConversationRef = import_react76.useRef(processConversation);
   import_react76.useEffect(() => {
@@ -71759,6 +71887,96 @@ function App2({
     }
     refreshDerived();
   }, [refreshDerived]);
+  const checkPendingApprovalsForSlashCommand = import_react76.useCallback(async () => {
+    if (!CHECK_PENDING_APPROVALS_BEFORE_SEND) {
+      return { blocked: false };
+    }
+    try {
+      const client = await getClient2();
+      const agent = await client.agents.retrieve(agentId);
+      const { pendingApprovals: existingApprovals } = await getResumeData2(client, agent);
+      if (!existingApprovals || existingApprovals.length === 0) {
+        return { blocked: false };
+      }
+      const approvalResults2 = await Promise.all(existingApprovals.map(async (approvalItem) => {
+        if (!approvalItem.toolName) {
+          return {
+            approval: approvalItem,
+            permission: {
+              decision: "deny",
+              reason: "Tool call incomplete - missing name"
+            },
+            context: null
+          };
+        }
+        const parsedArgs = safeJsonParseOr(approvalItem.toolArgs, {});
+        const permission = await checkToolPermission(approvalItem.toolName, parsedArgs);
+        const context3 = await analyzeToolApproval(approvalItem.toolName, parsedArgs);
+        return { approval: approvalItem, permission, context: context3 };
+      }));
+      const needsUserInput = [];
+      const autoAllowed = [];
+      const autoDenied = [];
+      for (const ac of approvalResults2) {
+        const { approval, permission } = ac;
+        let decision = permission.decision;
+        if (alwaysRequiresUserInput(approval.toolName) && decision === "allow") {
+          decision = "ask";
+        }
+        if (decision === "ask") {
+          needsUserInput.push(ac);
+        } else if (decision === "deny") {
+          autoDenied.push(ac);
+        } else {
+          autoAllowed.push(ac);
+        }
+      }
+      if (needsUserInput.length > 0) {
+        setPendingApprovals(needsUserInput.map((ac) => ac.approval));
+        setApprovalContexts(needsUserInput.map((ac) => ac.context).filter((ctx) => ctx !== null));
+        return { blocked: true };
+      }
+      const allResults = [];
+      if (autoAllowed.length > 0) {
+        const autoAllowedResults = await executeAutoAllowedTools(autoAllowed, (chunk) => onChunk(buffersRef.current, chunk));
+        allResults.push(...autoAllowedResults.map((ar) => ({
+          type: "tool",
+          tool_call_id: ar.toolCallId,
+          tool_return: ar.result.toolReturn,
+          status: ar.result.status,
+          stdout: ar.result.stdout,
+          stderr: ar.result.stderr
+        })));
+      }
+      for (const ac of autoDenied) {
+        const reason = ac.permission.reason || "Permission denied";
+        onChunk(buffersRef.current, {
+          message_type: "tool_return_message",
+          id: "dummy",
+          date: new Date().toISOString(),
+          tool_call_id: ac.approval.toolCallId,
+          tool_return: `Error: request to call tool denied. User reason: ${reason}`,
+          status: "error",
+          stdout: null,
+          stderr: null
+        });
+        allResults.push({
+          type: "approval",
+          tool_call_id: ac.approval.toolCallId,
+          approve: false,
+          reason
+        });
+      }
+      if (allResults.length > 0) {
+        await processConversation([
+          { type: "approval", approvals: allResults }
+        ]);
+      }
+      return { blocked: false };
+    } catch {
+      return { blocked: false };
+    }
+  }, [agentId, processConversation]);
   const onSubmit = import_react76.useCallback(async (message) => {
     const msg = message?.trim() ?? "";
     if (profileConfirmPending && !msg) {
@@ -71787,6 +72005,7 @@ function App2({
     }
     if (!msg)
       return { submitted: false };
+    const submissionGeneration = conversationGenerationRef.current;
     telemetry2.trackUserInput(msg, "user", currentModelId || "unknown");
     if (pendingApprovals.length > 0) {
       return { submitted: false };
@@ -71799,6 +72018,9 @@ function App2({
         if (!isSlashCommand && streamingRef.current && !waitingForQueueCancelRef.current) {
           waitingForQueueCancelRef.current = true;
           queueSnapshotRef.current = [...newQueue];
+          if (toolAbortControllerRef.current) {
+            toolAbortControllerRef.current.abort();
+          }
           getClient2().then((client) => client.agents.messages.cancel(agentId)).then(() => {}).catch(() => {
             waitingForQueueCancelRef.current = false;
           });
@@ -72477,6 +72699,10 @@ Press Enter to continue, or type anything to cancel.`, false, "running");
         return { submitted: true };
       }
       if (trimmed.startsWith("/skill")) {
+        const approvalCheck = await checkPendingApprovalsForSlashCommand();
+        if (approvalCheck.blocked) {
+          return { submitted: false };
+        }
         const cmdId2 = uid4("cmd");
         const [, ...rest] = trimmed.split(/\s+/);
         const description = rest.join(" ").trim();
@@ -72535,6 +72761,10 @@ ${SKILL_CREATOR_PROMPT3}${userDescriptionLine}
         return { submitted: true };
       }
       if (trimmed.startsWith("/remember")) {
+        const approvalCheck = await checkPendingApprovalsForSlashCommand();
+        if (approvalCheck.blocked) {
+          return { submitted: false };
+        }
         const cmdId2 = uid4("cmd");
         const [, ...rest] = trimmed.split(/\s+/);
         const userText = rest.join(" ").trim();
@@ -72591,6 +72821,10 @@ The user did not specify what to remember. Look at the recent conversation conte
         return { submitted: true };
       }
       if (trimmed === "/init") {
+        const approvalCheck = await checkPendingApprovalsForSlashCommand();
+        if (approvalCheck.blocked) {
+          return { submitted: false };
+        }
         const cmdId2 = uid4("cmd");
         buffersRef.current.byId.set(cmdId2, {
           kind: "command",
@@ -72707,6 +72941,10 @@ ${gitContext}
       const commandName = trimmed.split(/\s+/)[0]?.slice(1) || "";
       const matchedCustom = await findCustomCommand2(commandName);
       if (matchedCustom) {
+        const approvalCheck = await checkPendingApprovalsForSlashCommand();
+        if (approvalCheck.blocked) {
+          return { submitted: false };
+        }
         const cmdId2 = uid4("cmd");
         const args = trimmed.slice(`/${matchedCustom.id}`.length).trim();
         let prompt = substituteArguments2(matchedCustom.content, args);
@@ -73106,7 +73344,7 @@ DO NOT respond to these messages or otherwise consider them in your response unl
       role: "user",
       content: messageContent
     });
-    await processConversation(initialInput);
+    await processConversation(initialInput, { submissionGeneration });
     clearPlaceholdersInText(msg);
     return { submitted: true };
   }, [
@@ -73228,6 +73466,8 @@ DO NOT respond to these messages or otherwise consider them in your response unl
           setQueuedApprovalResults(allResults);
         }
         setStreaming(false);
+        waitingForQueueCancelRef.current = false;
+        queueSnapshotRef.current = [];
       } else {
         await processConversation([
           {
@@ -73330,7 +73570,11 @@ DO NOT respond to these messages or otherwise consider them in your response unl
           }
         }
         setIsExecutingTool(true);
+        const approvalResultsSnapshot = [...approvalResults];
+        const autoHandledSnapshot = [...autoHandledResults];
+        const autoDeniedSnapshot = [...autoDeniedApprovals];
         const allDecisions = [
+          ...approvalResultsSnapshot,
           { type: "approve", approval: currentApproval2 },
           ...nowAutoAllowed.map((r) => ({
             type: "approve",
@@ -73350,12 +73594,29 @@ DO NOT respond to these messages or otherwise consider them in your response unl
             onChunk(buffersRef.current, chunk);
             refreshDerived();
           });
+          const allResults = [
+            ...autoHandledSnapshot.map((ar) => ({
+              type: "tool",
+              tool_call_id: ar.toolCallId,
+              tool_return: ar.result.toolReturn,
+              status: ar.result.status,
+              stdout: ar.result.stdout,
+              stderr: ar.result.stderr
+            })),
+            ...autoDeniedSnapshot.map((ad) => ({
+              type: "approval",
+              tool_call_id: ad.approval.toolCallId,
+              approve: false,
+              reason: ad.reason
+            })),
+            ...executedResults
+          ];
           setThinkingMessage(getRandomThinkingVerb());
           refreshDerived();
           await processConversation([
             {
               type: "approval",
-              approvals: executedResults
+              approvals: allResults
             }
           ]);
         } finally {
@@ -73369,6 +73630,8 @@ DO NOT respond to these messages or otherwise consider them in your response unl
     approvalResults,
     approvalContexts,
     pendingApprovals,
+    autoHandledResults,
+    autoDeniedApprovals,
     handleApproveCurrent,
     processConversation,
     refreshDerived,
@@ -73976,7 +74239,6 @@ Plan file path: ${planFilePath}`;
   ]);
   return /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Box_default, {
     flexDirection: "column",
-    gap: 1,
     children: [
       /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Static, {
         items: staticItems,
@@ -74022,7 +74284,6 @@ Plan file path: ${planFilePath}`;
       }, staticRenderEpoch, false, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Box_default, {
         flexDirection: "column",
-        gap: 1,
         children: [
           loadingState !== "ready" && /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(WelcomeScreen, {
             loadingState,
@@ -74217,7 +74478,7 @@ Plan file path: ${planFilePath}`;
                 ]
               }, undefined, true, undefined, this),
               /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Box_default, {
-                marginTop: liveItems.length > 0 ? 0 : 1,
+                marginTop: 1,
                 children: /* @__PURE__ */ jsx_dev_runtime56.jsxDEV(Input, {
                   visible: !showExitStats && pendingApprovals.length === 0 && !anySelectorOpen,
                   streaming: streaming && !abortControllerRef.current?.signal.aborted,
@@ -77531,13 +77792,19 @@ Error: ${message}`);
             try {
               await client.agents.retrieve(localProjectSettings.lastAgent);
               resumingAgentId = localProjectSettings.lastAgent;
-            } catch {}
+            } catch {
+              setLoadingState("selecting_global");
+              return;
+            }
           }
           if (!resumingAgentId && continueSession && settings.lastAgent) {
             try {
               await client.agents.retrieve(settings.lastAgent);
               resumingAgentId = settings.lastAgent;
-            } catch {}
+            } catch {
+              setLoadingState("selecting_global");
+              return;
+            }
           }
           if (!resumingAgentId && selectedGlobalAgentId) {
             try {
@@ -77592,22 +77859,22 @@ Error: ${message}`);
           agent = result.agent;
           setAgentProvenance(result.provenance);
         }
-        if (!agent) {
-          await settingsManager2.loadLocalProjectSettings();
-          const localProjectSettings = settingsManager2.getLocalProjectSettings();
-          if (localProjectSettings?.lastAgent) {
-            try {
-              agent = await client.agents.retrieve(localProjectSettings.lastAgent);
-            } catch (error) {
-              console.error(`Project agent ${localProjectSettings.lastAgent} not found (error: ${JSON.stringify(error)}), creating new one...`);
-            }
+        if (!agent && resumingAgentId) {
+          try {
+            agent = await client.agents.retrieve(resumingAgentId);
+          } catch (error) {
+            console.error(`Agent ${resumingAgentId} not found (error: ${JSON.stringify(error)})`);
+            setLoadingState("selecting_global");
+            return;
           }
         }
         if (!agent && continueSession && settings.lastAgent) {
           try {
             agent = await client.agents.retrieve(settings.lastAgent);
           } catch (error) {
-            console.error(`Previous agent ${settings.lastAgent} not found (error: ${JSON.stringify(error)}), creating new one...`);
+            console.error(`Previous agent ${settings.lastAgent} not found (error: ${JSON.stringify(error)})`);
+            setLoadingState("selecting_global");
+            return;
           }
         }
         if (!agent) {
@@ -77770,4 +78037,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=91C0453F45E8BBAD64756E2164756E21
+//# debugId=D2E37E4C34BABD1E64756E2164756E21

package/package.json

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