@letta-ai/letta-code 0.14.15 → 0.14.16

package/letta.js

@@ -3122,7 +3122,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.14.15",
+    version: "0.14.16",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -38464,6 +38464,10 @@ var init_EnterPlanMode2 = __esm(() => {
 
 // src/tools/impl/ExitPlanMode.ts
 async function exit_plan_mode() {
+  if (permissionMode2.getMode() === "plan") {
+    const restoredMode = permissionMode2.getModeBeforePlan() ?? "default";
+    permissionMode2.setMode(restoredMode);
+  }
   return {
     message: `User has approved your plan. You can now start coding.
 ` + `Start with updating your todo list if applicable.
@@ -38471,6 +38475,9 @@ async function exit_plan_mode() {
 ` + "Tip: If this plan will be referenced in the future by your future-self, " + "other agents, or humans, consider renaming the plan file to something easily " + "identifiable with a timestamp (e.g., `2026-01-auth-refactor.md`) rather than the random name."
   };
 }
+var init_ExitPlanMode2 = __esm(() => {
+  init_mode();
+});
 
 // src/tools/impl/Glob.ts
 import { execFile } from "node:child_process";
@@ -55625,7 +55632,7 @@ var init_EnterPlanMode3 = __esm(() => {
 
 // src/tools/schemas/ExitPlanMode.json
 var ExitPlanMode_default2;
-var init_ExitPlanMode2 = __esm(() => {
+var init_ExitPlanMode3 = __esm(() => {
   ExitPlanMode_default2 = {
     type: "object",
     properties: {},
@@ -56576,6 +56583,7 @@ var init_toolDefinitions = __esm(async () => {
   init_BashOutput2();
   init_Edit2();
   init_EnterPlanMode2();
+  init_ExitPlanMode2();
   init_Glob2();
   init_GlobGemini2();
   init_Grep2();
@@ -56600,7 +56608,7 @@ var init_toolDefinitions = __esm(async () => {
   init_BashOutput3();
   init_Edit3();
   init_EnterPlanMode3();
-  init_ExitPlanMode2();
+  init_ExitPlanMode3();
   init_Glob3();
   init_GlobGemini3();
   init_Grep3();
@@ -59127,25 +59135,32 @@ var init_filter = __esm(() => {
 var exports_manager2 = {};
 __export(exports_manager2, {
   waitForToolsetReady: () => waitForToolsetReady,
+  setExternalToolExecutor: () => setExternalToolExecutor,
   savePermissionRule: () => savePermissionRule2,
   requiresApproval: () => requiresApproval,
+  registerExternalTools: () => registerExternalTools,
   loadTools: () => loadTools,
   loadSpecificTools: () => loadSpecificTools,
   isToolsetSwitchInProgress: () => isToolsetSwitchInProgress,
   isOpenAIModel: () => isOpenAIModel,
   isGeminiModel: () => isGeminiModel,
+  isExternalTool: () => isExternalTool,
   getToolSchemas: () => getToolSchemas,
   getToolSchema: () => getToolSchema,
   getToolPermissions: () => getToolPermissions,
   getToolNames: () => getToolNames,
   getServerToolName: () => getServerToolName,
   getInternalToolName: () => getInternalToolName,
+  getExternalToolsAsClientTools: () => getExternalToolsAsClientTools,
+  getExternalToolDefinition: () => getExternalToolDefinition,
   getClientToolsFromRegistry: () => getClientToolsFromRegistry,
   getAllLettaToolNames: () => getAllLettaToolNames,
   executeTool: () => executeTool,
+  executeExternalTool: () => executeExternalTool,
   clipToolReturn: () => clipToolReturn,
   clearToolsWithLock: () => clearToolsWithLock,
   clearTools: () => clearTools,
+  clearExternalTools: () => clearExternalTools,
   checkToolPermission: () => checkToolPermission,
   analyzeToolApproval: () => analyzeToolApproval,
   TOOL_NAMES: () => TOOL_NAMES,
@@ -59219,8 +59234,65 @@ function resolveInternalToolName(name) {
   }
   return;
 }
+function getExternalToolsRegistry() {
+  const global2 = globalThis;
+  if (!global2[EXTERNAL_TOOLS_KEY]) {
+    global2[EXTERNAL_TOOLS_KEY] = new Map;
+  }
+  return global2[EXTERNAL_TOOLS_KEY];
+}
+function registerExternalTools(tools) {
+  const registry = getExternalToolsRegistry();
+  for (const tool of tools) {
+    registry.set(tool.name, tool);
+  }
+}
+function setExternalToolExecutor(executor) {
+  globalThis[EXTERNAL_EXECUTOR_KEY] = executor;
+}
+function clearExternalTools() {
+  getExternalToolsRegistry().clear();
+  delete globalThis[EXTERNAL_EXECUTOR_KEY];
+}
+function isExternalTool(name) {
+  return getExternalToolsRegistry().has(name);
+}
+function getExternalToolDefinition(name) {
+  return getExternalToolsRegistry().get(name);
+}
+function getExternalToolsAsClientTools() {
+  return Array.from(getExternalToolsRegistry().values()).map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters
+  }));
+}
+async function executeExternalTool(toolCallId, toolName, input) {
+  const executor = globalThis[EXTERNAL_EXECUTOR_KEY];
+  if (!executor) {
+    return {
+      toolReturn: `External tool executor not set for tool: ${toolName}`,
+      status: "error"
+    };
+  }
+  try {
+    const result = await executor(toolCallId, toolName, input);
+    const textContent = result.content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join(`
+`);
+    return {
+      toolReturn: textContent || JSON.stringify(result.content),
+      status: result.isError ? "error" : "success"
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      toolReturn: `External tool execution error: ${errorMessage}`,
+      status: "error"
+    };
+  }
+}
 function getClientToolsFromRegistry() {
-  return Array.from(toolRegistry.entries()).map(([name, tool]) => {
+  const builtInTools = Array.from(toolRegistry.entries()).map(([name, tool]) => {
     const serverName = getServerToolName(name);
     return {
       name: serverName,
@@ -59228,6 +59300,8 @@ function getClientToolsFromRegistry() {
       parameters: tool.schema.input_schema
     };
   });
+  const externalTools = getExternalToolsAsClientTools();
+  return [...builtInTools, ...externalTools];
 }
 function getToolPermissions(toolName) {
   return TOOL_PERMISSIONS[toolName] || { requiresApproval: false };
@@ -59489,6 +59563,9 @@ ${files.join(`
   return JSON.stringify(result);
 }
 async function executeTool(name, args, options) {
+  if (isExternalTool(name)) {
+    return executeExternalTool(options?.toolCallId ?? `ext-${Date.now()}`, name, args);
+  }
   const internalName = resolveInternalToolName(name);
   if (!internalName) {
     return {
@@ -59655,7 +59732,7 @@ function clearToolsWithLock() {
     releaseSwitchLock();
   }
 }
-var TOOL_NAMES, STREAMING_SHELL_TOOLS, TOOL_NAME_MAPPINGS, ANTHROPIC_DEFAULT_TOOLS, OPENAI_DEFAULT_TOOLS, GEMINI_DEFAULT_TOOLS, OPENAI_PASCAL_TOOLS, GEMINI_PASCAL_TOOLS, TOOL_PERMISSIONS, REGISTRY_KEY, SWITCH_LOCK_KEY, toolRegistry;
+var TOOL_NAMES, STREAMING_SHELL_TOOLS, TOOL_NAME_MAPPINGS, ANTHROPIC_DEFAULT_TOOLS, OPENAI_DEFAULT_TOOLS, GEMINI_DEFAULT_TOOLS, OPENAI_PASCAL_TOOLS, GEMINI_PASCAL_TOOLS, TOOL_PERMISSIONS, REGISTRY_KEY, SWITCH_LOCK_KEY, toolRegistry, EXTERNAL_TOOLS_KEY, EXTERNAL_EXECUTOR_KEY;
 var init_manager3 = __esm(async () => {
   init_model();
   init_subagents();
@@ -59817,6 +59894,8 @@ var init_manager3 = __esm(async () => {
   REGISTRY_KEY = Symbol.for("@letta/toolRegistry");
   SWITCH_LOCK_KEY = Symbol.for("@letta/toolSwitchLock");
   toolRegistry = getRegistry();
+  EXTERNAL_TOOLS_KEY = Symbol.for("@letta/externalTools");
+  EXTERNAL_EXECUTOR_KEY = Symbol.for("@letta/externalToolExecutor");
 });
 
 // src/agent/approval-execution.ts
@@ -62112,6 +62191,23 @@ function isConversationBusyError(detail) {
     return false;
   return detail.toLowerCase().includes(CONVERSATION_BUSY_DETAIL_FRAGMENT);
 }
+function classifyPreStreamConflict(detail) {
+  if (isApprovalPendingError(detail))
+    return "approval_pending";
+  if (isConversationBusyError(detail))
+    return "conversation_busy";
+  return null;
+}
+function getPreStreamErrorAction(detail, conversationBusyRetries, maxConversationBusyRetries) {
+  const kind = classifyPreStreamConflict(detail);
+  if (kind === "approval_pending") {
+    return "resolve_approval_pending";
+  }
+  if (kind === "conversation_busy" && conversationBusyRetries < maxConversationBusyRetries) {
+    return "retry_conversation_busy";
+  }
+  return "rethrow";
+}
 async function fetchRunErrorDetail(runId) {
   if (!runId)
     return null;
@@ -62124,7 +62220,7 @@ async function fetchRunErrorDetail(runId) {
     return null;
   }
 }
-var INVALID_TOOL_CALL_IDS_FRAGMENT = "invalid tool call ids", APPROVAL_PENDING_DETAIL_FRAGMENT = "cannot send a new message", CONVERSATION_BUSY_DETAIL_FRAGMENT = "another request is currently being processed";
+var INVALID_TOOL_CALL_IDS_FRAGMENT = "invalid tool call ids", APPROVAL_PENDING_DETAIL_FRAGMENT = "waiting for approval", CONVERSATION_BUSY_DETAIL_FRAGMENT = "another request is currently being processed";
 var init_approval_recovery = __esm(async () => {
   await init_client2();
 });
@@ -62356,7 +62452,7 @@ function buildModelSettings(modelHandle, updateArgs) {
   } else {
     settings = {};
   }
-  if (typeof updateArgs?.max_output_tokens === "number") {
+  if (typeof updateArgs?.max_output_tokens === "number" && "provider_type" in settings) {
     settings.max_output_tokens = updateArgs.max_output_tokens;
   }
   return settings;
@@ -62369,7 +62465,10 @@ async function updateAgentLLMConfig(agentId, modelHandle, updateArgs) {
   await client.agents.update(agentId, {
     model: modelHandle,
     ...hasModelSettings && { model_settings: modelSettings },
-    ...contextWindow && { context_window_limit: contextWindow }
+    ...contextWindow && { context_window_limit: contextWindow },
+    ...typeof updateArgs?.max_output_tokens === "number" && {
+      max_tokens: updateArgs.max_output_tokens
+    }
   });
   const finalAgent = await client.agents.retrieve(agentId);
   return finalAgent.llm_config;
@@ -63249,6 +63348,181 @@ function findLastSafeSplitPoint(content) {
 }
 var MIN_SPLIT_LENGTH = 1500;
 
+// src/tools/interactivePolicy.ts
+function isInteractiveApprovalTool(toolName) {
+  return INTERACTIVE_APPROVAL_TOOLS.has(toolName);
+}
+function isHeadlessAutoAllowTool(toolName) {
+  return HEADLESS_AUTO_ALLOW_TOOLS.has(toolName);
+}
+var INTERACTIVE_APPROVAL_TOOLS, RUNTIME_USER_INPUT_TOOLS, HEADLESS_AUTO_ALLOW_TOOLS;
+var init_interactivePolicy = __esm(() => {
+  INTERACTIVE_APPROVAL_TOOLS = new Set([
+    "AskUserQuestion",
+    "EnterPlanMode",
+    "ExitPlanMode"
+  ]);
+  RUNTIME_USER_INPUT_TOOLS = new Set(["AskUserQuestion", "ExitPlanMode"]);
+  HEADLESS_AUTO_ALLOW_TOOLS = new Set(["EnterPlanMode"]);
+});
+
+// src/tools/toolset.ts
+var exports_toolset = {};
+__export(exports_toolset, {
+  switchToolsetForModel: () => switchToolsetForModel,
+  reattachMemoryTool: () => reattachMemoryTool,
+  forceToolsetSwitch: () => forceToolsetSwitch,
+  ensureCorrectMemoryTool: () => ensureCorrectMemoryTool,
+  detachMemoryTools: () => detachMemoryTools,
+  MEMORY_TOOL_NAMES: () => MEMORY_TOOL_NAMES
+});
+async function ensureCorrectMemoryTool(agentId, modelIdentifier, useMemoryPatch) {
+  const resolvedModel = resolveModel(modelIdentifier) ?? modelIdentifier;
+  const client = await getClient2();
+  const shouldUsePatch = useMemoryPatch !== undefined ? useMemoryPatch : isOpenAIModel(resolvedModel);
+  try {
+    const agentWithTools = await client.agents.retrieve(agentId, {
+      include: ["agent.tools"]
+    });
+    const currentTools = agentWithTools.tools || [];
+    const mapByName = new Map(currentTools.map((t) => [t.name, t.id]));
+    const hasAnyMemoryTool = mapByName.has("memory") || mapByName.has("memory_apply_patch");
+    if (!hasAnyMemoryTool) {
+      return;
+    }
+    const desiredMemoryTool = shouldUsePatch ? "memory_apply_patch" : "memory";
+    const otherMemoryTool = desiredMemoryTool === "memory" ? "memory_apply_patch" : "memory";
+    let desiredId = mapByName.get(desiredMemoryTool);
+    if (!desiredId) {
+      const resp = await client.tools.list({ name: desiredMemoryTool });
+      desiredId = resp.items[0]?.id;
+    }
+    if (!desiredId) {
+      return;
+    }
+    const otherId = mapByName.get(otherMemoryTool);
+    if (mapByName.has(desiredMemoryTool) && !otherId) {
+      return;
+    }
+    const currentIds = currentTools.map((t) => t.id).filter((id) => typeof id === "string");
+    const newIds = new Set(currentIds);
+    if (otherId)
+      newIds.delete(otherId);
+    newIds.add(desiredId);
+    const updatedRules = (agentWithTools.tool_rules || []).map((r) => r.tool_name === otherMemoryTool ? { ...r, tool_name: desiredMemoryTool } : r);
+    await client.agents.update(agentId, {
+      tool_ids: Array.from(newIds),
+      tool_rules: updatedRules
+    });
+  } catch (err) {
+    console.warn(`Warning: Failed to sync memory tool: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function detachMemoryTools(agentId) {
+  const client = await getClient2();
+  try {
+    const agentWithTools = await client.agents.retrieve(agentId, {
+      include: ["agent.tools"]
+    });
+    const currentTools = agentWithTools.tools || [];
+    let detachedAny = false;
+    for (const tool of currentTools) {
+      if (tool.name && MEMORY_TOOL_NAMES.has(tool.name)) {
+        if (tool.id) {
+          await client.agents.tools.detach(tool.id, { agent_id: agentId });
+          detachedAny = true;
+        }
+      }
+    }
+    return detachedAny;
+  } catch (err) {
+    console.warn(`Warning: Failed to detach memory tools: ${err instanceof Error ? err.message : String(err)}`);
+    return false;
+  }
+}
+async function reattachMemoryTool(agentId, modelIdentifier) {
+  const resolvedModel = resolveModel(modelIdentifier) ?? modelIdentifier;
+  const client = await getClient2();
+  const shouldUsePatch = isOpenAIModel(resolvedModel);
+  try {
+    const agentWithTools = await client.agents.retrieve(agentId, {
+      include: ["agent.tools"]
+    });
+    const currentTools = agentWithTools.tools || [];
+    const mapByName = new Map(currentTools.map((t) => [t.name, t.id]));
+    const desiredMemoryTool = shouldUsePatch ? "memory_apply_patch" : "memory";
+    if (mapByName.has(desiredMemoryTool)) {
+      return;
+    }
+    const resp = await client.tools.list({ name: desiredMemoryTool });
+    const toolId = resp.items[0]?.id;
+    if (!toolId) {
+      console.warn(`Memory tool "${desiredMemoryTool}" not found on server`);
+      return;
+    }
+    await client.agents.tools.attach(toolId, { agent_id: agentId });
+  } catch (err) {
+    console.warn(`Warning: Failed to reattach memory tool: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function forceToolsetSwitch(toolsetName, agentId) {
+  let modelForLoading;
+  if (toolsetName === "none") {
+    clearToolsWithLock();
+    return;
+  } else if (toolsetName === "codex") {
+    await loadSpecificTools([...CODEX_TOOLS]);
+    modelForLoading = "openai/gpt-4";
+  } else if (toolsetName === "codex_snake") {
+    await loadTools("openai/gpt-4");
+    modelForLoading = "openai/gpt-4";
+  } else if (toolsetName === "gemini") {
+    await loadSpecificTools([...GEMINI_TOOLS]);
+    modelForLoading = "google_ai/gemini-3-pro-preview";
+  } else if (toolsetName === "gemini_snake") {
+    await loadTools("google_ai/gemini-3-pro-preview");
+    modelForLoading = "google_ai/gemini-3-pro-preview";
+  } else {
+    await loadTools("anthropic/claude-sonnet-4");
+    modelForLoading = "anthropic/claude-sonnet-4";
+  }
+  const useMemoryPatch = toolsetName === "codex" || toolsetName === "codex_snake";
+  await ensureCorrectMemoryTool(agentId, modelForLoading, useMemoryPatch);
+}
+async function switchToolsetForModel(modelIdentifier, agentId) {
+  const resolvedModel = resolveModel(modelIdentifier) ?? modelIdentifier;
+  await loadTools(resolvedModel);
+  const loadedAfterPrimary = getToolNames().length;
+  if (loadedAfterPrimary === 0 && !toolFilter.isActive()) {
+    await loadTools();
+    if (getToolNames().length === 0) {
+      throw new Error(`Failed to load any Letta tools for model "${resolvedModel}".`);
+    }
+  }
+  await ensureCorrectMemoryTool(agentId, resolvedModel);
+  const { isGeminiModel: isGeminiModel3 } = await init_manager3().then(() => exports_manager2);
+  const toolsetName = isOpenAIModel(resolvedModel) ? "codex" : isGeminiModel3(resolvedModel) ? "gemini" : "default";
+  return toolsetName;
+}
+var CODEX_TOOLS, GEMINI_TOOLS, MEMORY_TOOL_NAMES;
+var init_toolset = __esm(async () => {
+  init_model();
+  init_filter();
+  await __promiseAll([
+    init_client2(),
+    init_manager3()
+  ]);
+  CODEX_TOOLS = OPENAI_PASCAL_TOOLS;
+  GEMINI_TOOLS = GEMINI_PASCAL_TOOLS;
+  MEMORY_TOOL_NAMES = new Set([
+    "memory",
+    "memory_apply_patch",
+    "memory_insert",
+    "memory_replace",
+    "memory_rethink"
+  ]);
+});
+
 // src/cli/helpers/toolNameMapping.ts
 function getDisplayToolName(rawName) {
   if (rawName === "write")
@@ -63351,10 +63625,10 @@ function isPlanTool(rawName, displayName) {
   return rawName === "update_plan" || rawName === "UpdatePlan" || displayName === "Planning";
 }
 function alwaysRequiresUserInput(name) {
-  return name === "AskUserQuestion" || name === "EnterPlanMode" || name === "ExitPlanMode";
+  return isInteractiveApprovalTool(name);
 }
 function isMemoryTool(name) {
-  return name === "memory" || name === "memory_apply_patch";
+  return MEMORY_TOOL_NAMES.has(name);
 }
 function isFileEditTool(name) {
   return name === "edit" || name === "Edit" || name === "multi_edit" || name === "MultiEdit" || name === "Replace" || name === "replace";
@@ -63378,6 +63652,10 @@ function isSearchTool(name) {
 function isGlobTool(name) {
   return name === "glob" || name === "Glob" || name === "glob_gemini" || name === "GlobGemini";
 }
+var init_toolNameMapping = __esm(async () => {
+  init_interactivePolicy();
+  await init_toolset();
+});
 
 // src/cli/helpers/accumulator.ts
 function appendStreamingOutput(state, chunk, startTime, isStderr = false) {
@@ -63837,6 +64115,11 @@ function onChunk(b, chunk, ctx) {
           eventData: eventChunk.event_data || {},
           phase: "running"
         }));
+        if (eventType === "compaction") {
+          runPreCompactHooks(ctx?.lastContextTokens, undefined, b.agentId, undefined).catch((error) => {
+            debugLog("hooks", "PreCompact hook error (accumulator)", error);
+          });
+        }
         break;
       }
       break;
@@ -63881,7 +64164,10 @@ var init_accumulator = __esm(async () => {
   init_constants();
   init_debug();
   init_backfill();
-  await init_hooks();
+  await __promiseAll([
+    init_hooks(),
+    init_toolNameMapping()
+  ]);
   CANCEL_REASON_TEXT = {
     user_interrupt: INTERRUPTED_BY_USER,
     stream_error: "Stream error",
@@ -64102,8 +64388,69 @@ function isCreditExhaustedError(e, reasons) {
     return false;
   return hasErrorReason(e, "not-enough-credits", reasons);
 }
+function findEncryptedContentDetail(e) {
+  if (typeof e !== "object" || e === null)
+    return;
+  const obj = e;
+  if (typeof obj.detail === "string" && obj.detail.includes("invalid_encrypted_content")) {
+    return obj.detail;
+  }
+  if (obj.error && typeof obj.error === "object") {
+    const errObj = obj.error;
+    if (errObj.error && typeof errObj.error === "object") {
+      const inner = errObj.error;
+      if (typeof inner.detail === "string" && inner.detail.includes("invalid_encrypted_content")) {
+        return inner.detail;
+      }
+    }
+    if (typeof errObj.detail === "string" && errObj.detail.includes("invalid_encrypted_content")) {
+      return errObj.detail;
+    }
+  }
+  return;
+}
+function checkEncryptedContentError(e) {
+  const detail = findEncryptedContentDetail(e);
+  if (!detail) {
+    try {
+      const errorStr = typeof e === "string" ? e : JSON.stringify(e);
+      if (!errorStr.includes("invalid_encrypted_content"))
+        return;
+    } catch {
+      return;
+    }
+    return "OpenAI error: Encrypted content could not be verified — organization mismatch." + ENCRYPTED_CONTENT_HINT;
+  }
+  try {
+    const jsonStart = detail.indexOf("{");
+    if (jsonStart >= 0) {
+      const parsed = JSON.parse(detail.slice(jsonStart));
+      const innerError = parsed.error || parsed;
+      if (innerError.code === "invalid_encrypted_content") {
+        const msg = String(innerError.message || "Encrypted content verification failed.").replaceAll('"', "\\\"");
+        return [
+          "OpenAI error:",
+          "  {",
+          `    type: "${innerError.type || "invalid_request_error"}",`,
+          `    code: "${innerError.code}",`,
+          `    message: "${msg}"`,
+          "  }",
+          ENCRYPTED_CONTENT_HINT
+        ].join(`
+`);
+      }
+    }
+  } catch {}
+  return "OpenAI error: Encrypted content could not be verified — organization mismatch." + ENCRYPTED_CONTENT_HINT;
+}
+function isEncryptedContentError(e) {
+  return findEncryptedContentDetail(e) !== undefined;
+}
 function formatErrorDetails(e, agentId, conversationId) {
   let runId;
+  const encryptedContentMsg = checkEncryptedContentError(e);
+  if (encryptedContentMsg)
+    return encryptedContentMsg;
   if (e instanceof APIError2) {
     const reasons = getErrorReasons(e);
     const rateLimitResetMs = getRateLimitResetMs(e);
@@ -64202,10 +64549,18 @@ function createAgentLink(runId, agentId, conversationId) {
   const url = `https://app.letta.com/agents/${agentId}${conversationId ? `?conversation=${conversationId}` : ""}`;
   return `View agent: \x1B]8;;${url}\x1B\\${agentId}\x1B]8;;\x1B\\ (run: ${runId})`;
 }
-var LETTA_USAGE_URL = "https://app.letta.com/settings/organization/usage", LETTA_AGENTS_URL = "https://app.letta.com/projects/default-project/agents";
+var LETTA_USAGE_URL = "https://app.letta.com/settings/organization/usage", LETTA_AGENTS_URL = "https://app.letta.com/projects/default-project/agents", ENCRYPTED_CONTENT_HINT;
 var init_errorFormatter = __esm(() => {
   init_error();
   init_errorContext();
+  ENCRYPTED_CONTENT_HINT = [
+    "",
+    "This occurs when the conversation contains messages with encrypted",
+    "reasoning from a different OpenAI authentication scope (e.g. switching",
+    "between ChatGPT OAuth and an OpenAI API key).",
+    "Use /clear to start a new conversation."
+  ].join(`
+`);
 });
 
 // src/cli/helpers/streamProcessor.ts
@@ -64478,155 +64833,6 @@ var init_stream = __esm(async () => {
   ]);
 });
 
-// src/tools/toolset.ts
-var exports_toolset = {};
-__export(exports_toolset, {
-  switchToolsetForModel: () => switchToolsetForModel,
-  reattachMemoryTool: () => reattachMemoryTool,
-  forceToolsetSwitch: () => forceToolsetSwitch,
-  ensureCorrectMemoryTool: () => ensureCorrectMemoryTool,
-  detachMemoryTools: () => detachMemoryTools
-});
-async function ensureCorrectMemoryTool(agentId, modelIdentifier, useMemoryPatch) {
-  const resolvedModel = resolveModel(modelIdentifier) ?? modelIdentifier;
-  const client = await getClient2();
-  const shouldUsePatch = useMemoryPatch !== undefined ? useMemoryPatch : isOpenAIModel(resolvedModel);
-  try {
-    const agentWithTools = await client.agents.retrieve(agentId, {
-      include: ["agent.tools"]
-    });
-    const currentTools = agentWithTools.tools || [];
-    const mapByName = new Map(currentTools.map((t) => [t.name, t.id]));
-    const hasAnyMemoryTool = mapByName.has("memory") || mapByName.has("memory_apply_patch");
-    if (!hasAnyMemoryTool) {
-      return;
-    }
-    const desiredMemoryTool = shouldUsePatch ? "memory_apply_patch" : "memory";
-    const otherMemoryTool = desiredMemoryTool === "memory" ? "memory_apply_patch" : "memory";
-    let desiredId = mapByName.get(desiredMemoryTool);
-    if (!desiredId) {
-      const resp = await client.tools.list({ name: desiredMemoryTool });
-      desiredId = resp.items[0]?.id;
-    }
-    if (!desiredId) {
-      return;
-    }
-    const otherId = mapByName.get(otherMemoryTool);
-    if (mapByName.has(desiredMemoryTool) && !otherId) {
-      return;
-    }
-    const currentIds = currentTools.map((t) => t.id).filter((id) => typeof id === "string");
-    const newIds = new Set(currentIds);
-    if (otherId)
-      newIds.delete(otherId);
-    newIds.add(desiredId);
-    const updatedRules = (agentWithTools.tool_rules || []).map((r) => r.tool_name === otherMemoryTool ? { ...r, tool_name: desiredMemoryTool } : r);
-    await client.agents.update(agentId, {
-      tool_ids: Array.from(newIds),
-      tool_rules: updatedRules
-    });
-  } catch (err) {
-    console.warn(`Warning: Failed to sync memory tool: ${err instanceof Error ? err.message : String(err)}`);
-  }
-}
-async function detachMemoryTools(agentId) {
-  const client = await getClient2();
-  try {
-    const agentWithTools = await client.agents.retrieve(agentId, {
-      include: ["agent.tools"]
-    });
-    const currentTools = agentWithTools.tools || [];
-    let detachedAny = false;
-    for (const tool of currentTools) {
-      if (tool.name === "memory" || tool.name === "memory_apply_patch") {
-        if (tool.id) {
-          await client.agents.tools.detach(tool.id, { agent_id: agentId });
-          detachedAny = true;
-        }
-      }
-    }
-    return detachedAny;
-  } catch (err) {
-    console.warn(`Warning: Failed to detach memory tools: ${err instanceof Error ? err.message : String(err)}`);
-    return false;
-  }
-}
-async function reattachMemoryTool(agentId, modelIdentifier) {
-  const resolvedModel = resolveModel(modelIdentifier) ?? modelIdentifier;
-  const client = await getClient2();
-  const shouldUsePatch = isOpenAIModel(resolvedModel);
-  try {
-    const agentWithTools = await client.agents.retrieve(agentId, {
-      include: ["agent.tools"]
-    });
-    const currentTools = agentWithTools.tools || [];
-    const mapByName = new Map(currentTools.map((t) => [t.name, t.id]));
-    const desiredMemoryTool = shouldUsePatch ? "memory_apply_patch" : "memory";
-    if (mapByName.has(desiredMemoryTool)) {
-      return;
-    }
-    const resp = await client.tools.list({ name: desiredMemoryTool });
-    const toolId = resp.items[0]?.id;
-    if (!toolId) {
-      console.warn(`Memory tool "${desiredMemoryTool}" not found on server`);
-      return;
-    }
-    await client.agents.tools.attach(toolId, { agent_id: agentId });
-  } catch (err) {
-    console.warn(`Warning: Failed to reattach memory tool: ${err instanceof Error ? err.message : String(err)}`);
-  }
-}
-async function forceToolsetSwitch(toolsetName, agentId) {
-  let modelForLoading;
-  if (toolsetName === "none") {
-    clearToolsWithLock();
-    return;
-  } else if (toolsetName === "codex") {
-    await loadSpecificTools([...CODEX_TOOLS]);
-    modelForLoading = "openai/gpt-4";
-  } else if (toolsetName === "codex_snake") {
-    await loadTools("openai/gpt-4");
-    modelForLoading = "openai/gpt-4";
-  } else if (toolsetName === "gemini") {
-    await loadSpecificTools([...GEMINI_TOOLS]);
-    modelForLoading = "google_ai/gemini-3-pro-preview";
-  } else if (toolsetName === "gemini_snake") {
-    await loadTools("google_ai/gemini-3-pro-preview");
-    modelForLoading = "google_ai/gemini-3-pro-preview";
-  } else {
-    await loadTools("anthropic/claude-sonnet-4");
-    modelForLoading = "anthropic/claude-sonnet-4";
-  }
-  const useMemoryPatch = toolsetName === "codex" || toolsetName === "codex_snake";
-  await ensureCorrectMemoryTool(agentId, modelForLoading, useMemoryPatch);
-}
-async function switchToolsetForModel(modelIdentifier, agentId) {
-  const resolvedModel = resolveModel(modelIdentifier) ?? modelIdentifier;
-  await loadTools(resolvedModel);
-  const loadedAfterPrimary = getToolNames().length;
-  if (loadedAfterPrimary === 0 && !toolFilter.isActive()) {
-    await loadTools();
-    if (getToolNames().length === 0) {
-      throw new Error(`Failed to load any Letta tools for model "${resolvedModel}".`);
-    }
-  }
-  await ensureCorrectMemoryTool(agentId, resolvedModel);
-  const { isGeminiModel: isGeminiModel3 } = await init_manager3().then(() => exports_manager2);
-  const toolsetName = isOpenAIModel(resolvedModel) ? "codex" : isGeminiModel3(resolvedModel) ? "gemini" : "default";
-  return toolsetName;
-}
-var CODEX_TOOLS, GEMINI_TOOLS;
-var init_toolset = __esm(async () => {
-  init_model();
-  init_filter();
-  await __promiseAll([
-    init_client2(),
-    init_manager3()
-  ]);
-  CODEX_TOOLS = OPENAI_PASCAL_TOOLS;
-  GEMINI_TOOLS = GEMINI_PASCAL_TOOLS;
-});
-
 // src/agent/github-utils.ts
 var exports_github_utils = {};
 __export(exports_github_utils, {
@@ -64662,6 +64868,7 @@ function parseDirNames(entries) {
 // src/agent/import.ts
 var exports_import = {};
 __export(exports_import, {
+  importAgentFromRegistry: () => importAgentFromRegistry,
   importAgentFromFile: () => importAgentFromFile,
   extractSkillsFromAf: () => extractSkillsFromAf
 });
@@ -64769,6 +64976,45 @@ async function downloadGitHubDirectory(entries, destDir, owner, repo, branch, ba
     }
   }
 }
+function parseRegistryHandle(handle) {
+  const normalized = handle.startsWith("@") ? handle.slice(1) : handle;
+  const parts = normalized.split("/");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new Error(`Invalid import handle "${handle}". Use format: @author/agentname`);
+  }
+  return { author: parts[0], name: parts[1] };
+}
+async function importAgentFromRegistry(options) {
+  const { tmpdir: tmpdir2 } = await import("node:os");
+  const { join: join20 } = await import("node:path");
+  const { writeFile: writeFile5, unlink: unlink2 } = await import("node:fs/promises");
+  const { author, name } = parseRegistryHandle(options.handle);
+  const rawUrl = `https://raw.githubusercontent.com/${AGENT_REGISTRY_OWNER}/${AGENT_REGISTRY_REPO}/refs/heads/${AGENT_REGISTRY_BRANCH}/agents/@${author}/${name}/${name}.af`;
+  const response = await fetch(rawUrl);
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new Error(`Agent @${author}/${name} not found in registry. Check that the agent exists at https://github.com/${AGENT_REGISTRY_OWNER}/${AGENT_REGISTRY_REPO}/tree/${AGENT_REGISTRY_BRANCH}/agents/@${author}/${name}`);
+    }
+    throw new Error(`Failed to download agent @${author}/${name}: ${response.statusText}`);
+  }
+  const afContent = await response.text();
+  const tempPath = join20(tmpdir2(), `letta-import-${author}-${name}-${Date.now()}.af`);
+  await writeFile5(tempPath, afContent, "utf-8");
+  try {
+    const result = await importAgentFromFile({
+      filePath: tempPath,
+      modelOverride: options.modelOverride,
+      stripMessages: options.stripMessages ?? true,
+      stripSkills: options.stripSkills ?? false
+    });
+    return result;
+  } finally {
+    try {
+      await unlink2(tempPath);
+    } catch {}
+  }
+}
+var AGENT_REGISTRY_OWNER = "letta-ai", AGENT_REGISTRY_REPO = "agent-file", AGENT_REGISTRY_BRANCH = "main";
 var init_import = __esm(async () => {
   init_model();
   await __promiseAll([
@@ -65220,6 +65466,7 @@ In headless mode, use:
       process.exit(1);
     }
   }
+  let isRegistryImport = false;
   if (fromAfFile) {
     if (specifiedAgentId) {
       console.error("Error: --from-af cannot be used with --agent");
@@ -65233,6 +65480,15 @@ In headless mode, use:
       console.error("Error: --from-af cannot be used with --new");
       process.exit(1);
     }
+    if (fromAfFile.startsWith("@")) {
+      isRegistryImport = true;
+      const normalized = fromAfFile.slice(1);
+      const parts = normalized.split("/");
+      if (parts.length !== 2 || !parts[0] || !parts[1]) {
+        console.error(`Error: Invalid registry handle "${fromAfFile}". Use format: @author/agentname`);
+        process.exit(1);
+      }
+    }
   }
   if (initBlocksRaw && !forceNew) {
     console.error("Error: --init-blocks can only be used together with --new to control initial memory blocks.");
@@ -65315,13 +65571,24 @@ In headless mode, use:
     }
   }
   if (!agent && fromAfFile) {
-    const { importAgentFromFile: importAgentFromFile2 } = await init_import().then(() => exports_import);
-    const result = await importAgentFromFile2({
-      filePath: fromAfFile,
-      modelOverride: model,
-      stripMessages: true,
-      stripSkills: false
-    });
+    let result;
+    if (isRegistryImport) {
+      const { importAgentFromRegistry: importAgentFromRegistry2 } = await init_import().then(() => exports_import);
+      result = await importAgentFromRegistry2({
+        handle: fromAfFile,
+        modelOverride: model,
+        stripMessages: true,
+        stripSkills: false
+      });
+    } else {
+      const { importAgentFromFile: importAgentFromFile2 } = await init_import().then(() => exports_import);
+      result = await importAgentFromFile2({
+        filePath: fromAfFile,
+        modelOverride: model,
+        stripMessages: true,
+        stripSkills: false
+      });
+    }
     agent = result.agent;
     isNewlyCreatedAgent = true;
     if (result.skills && result.skills.length > 0) {
@@ -65524,8 +65791,11 @@ In headless mode, use:
     console.error(`Error: Invalid input format "${inputFormat}". Valid formats: stream-json`);
     process.exit(1);
   }
+  const { getClientToolsFromRegistry: getClientToolsFromRegistry2 } = await init_manager3().then(() => exports_manager2);
+  const loadedToolNames = getClientToolsFromRegistry2().map((t) => t.name);
+  const availableTools = loadedToolNames.length > 0 ? loadedToolNames : agent.tools?.map((t) => t.name).filter((n) => !!n) || [];
   if (isBidirectionalMode) {
-    await runBidirectionalMode(agent, conversationId, client, outputFormat, includePartialMessages);
+    await runBidirectionalMode(agent, conversationId, client, outputFormat, includePartialMessages, availableTools);
     return;
   }
   const buffers = createBuffers(agent.id);
@@ -65539,7 +65809,7 @@ In headless mode, use:
       agent_id: agent.id,
       conversation_id: conversationId,
       model: agent.llm_config?.model ?? "",
-      tools: agent.tools?.map((t) => t.name).filter((n) => !!n) || [],
+      tools: availableTools,
       cwd: process.cwd(),
       mcp_servers: [],
       permission_mode: "",
@@ -65565,6 +65835,7 @@ In headless mode, use:
       if (pendingApprovals.length === 0)
         break;
       const { autoAllowed, autoDenied } = await classifyApprovals(pendingApprovals, {
+        alwaysRequiresUserInput: isInteractiveApprovalTool,
         treatAskAsDeny: true,
         denyReasonForAsk: "Tool requires approval (headless mode)",
         requireArgsForAutoApprove: true,
@@ -65744,7 +66015,24 @@ ${SYSTEM_REMINDER_CLOSE}
         if (!errorDetail && preStreamError instanceof Error) {
           errorDetail = preStreamError.message;
         }
-        if (isConversationBusyError(errorDetail) && conversationBusyRetries < CONVERSATION_BUSY_MAX_RETRIES) {
+        const preStreamAction = getPreStreamErrorAction(errorDetail, conversationBusyRetries, CONVERSATION_BUSY_MAX_RETRIES);
+        if (preStreamAction === "resolve_approval_pending") {
+          if (outputFormat === "stream-json") {
+            const recoveryMsg = {
+              type: "recovery",
+              recovery_type: "approval_pending",
+              message: "Detected pending approval conflict on send; resolving before retry",
+              session_id: sessionId,
+              uuid: `recovery-pre-stream-${crypto.randomUUID()}`
+            };
+            console.log(JSON.stringify(recoveryMsg));
+          } else {
+            console.error("Pending approval detected, resolving before retry...");
+          }
+          await resolveAllPendingApprovals();
+          continue;
+        }
+        if (preStreamAction === "retry_conversation_busy") {
           conversationBusyRetries += 1;
           if (outputFormat === "stream-json") {
             const retryMsg = {
@@ -65817,6 +66105,7 @@ ${SYSTEM_REMINDER_CLOSE}
           }
           if (updatedApproval && !autoApprovalEmitted.has(updatedApproval.toolCallId)) {
             const { autoAllowed } = await classifyApprovals([updatedApproval], {
+              alwaysRequiresUserInput: isInteractiveApprovalTool,
               requireArgsForAutoApprove: true,
               missingNameReason: "Tool call incomplete - missing name"
             });
@@ -65895,9 +66184,8 @@ ${SYSTEM_REMINDER_CLOSE}
           console.error("Unexpected empty approvals array");
           process.exit(1);
         }
-        const { autoAllowed, autoDenied } = await classifyApprovals(approvals, {
-          treatAskAsDeny: true,
-          denyReasonForAsk: "Tool requires approval (headless mode)",
+        const { autoAllowed, autoDenied, needsUserInput } = await classifyApprovals(approvals, {
+          alwaysRequiresUserInput: isInteractiveApprovalTool,
           requireArgsForAutoApprove: true,
           missingNameReason: "Tool call incomplete - missing name"
         });
@@ -65906,6 +66194,19 @@ ${SYSTEM_REMINDER_CLOSE}
             type: "approve",
             approval: ac.approval
           })),
+          ...needsUserInput.map((ac) => {
+            if (isHeadlessAutoAllowTool(ac.approval.toolName)) {
+              return {
+                type: "approve",
+                approval: ac.approval
+              };
+            }
+            return {
+              type: "deny",
+              approval: ac.approval,
+              reason: "Tool requires approval (headless mode)"
+            };
+          }),
           ...autoDenied.map((ac) => {
             const fallback = "matchedRule" in ac.permission && ac.permission.matchedRule ? `Permission denied: ${ac.permission.matchedRule}` : ac.permission.reason ? `Permission denied: ${ac.permission.reason}` : "Permission denied: Unknown reason";
             return {
@@ -66168,7 +66469,7 @@ ${SYSTEM_REMINDER_CLOSE}
   markMilestone("HEADLESS_COMPLETE");
   reportAllMilestones();
 }
-async function runBidirectionalMode(agent, conversationId, _client, _outputFormat, includePartialMessages) {
+async function runBidirectionalMode(agent, conversationId, client, _outputFormat, includePartialMessages, availableTools) {
   const sessionId = agent.id;
   const readline = await import("node:readline");
   const initEvent = {
@@ -66178,12 +66479,74 @@ async function runBidirectionalMode(agent, conversationId, _client, _outputForma
     agent_id: agent.id,
     conversation_id: conversationId,
     model: agent.llm_config?.model,
-    tools: agent.tools?.map((t) => t.name) || [],
+    tools: availableTools,
     cwd: process.cwd(),
     uuid: `init-${agent.id}`
   };
   console.log(JSON.stringify(initEvent));
   let currentAbortController = null;
+  const resolveAllPendingApprovals = async () => {
+    const { getResumeData: getResumeData3 } = await Promise.resolve().then(() => (init_check_approval(), exports_check_approval));
+    while (true) {
+      const freshAgent = await client.agents.retrieve(agent.id);
+      let resume;
+      try {
+        resume = await getResumeData3(client, freshAgent, conversationId);
+      } catch (error) {
+        if (error instanceof APIError2 && (error.status === 404 || error.status === 422)) {
+          break;
+        }
+        throw error;
+      }
+      const pendingApprovals = resume.pendingApprovals || [];
+      if (pendingApprovals.length === 0)
+        break;
+      const { autoAllowed, autoDenied } = await classifyApprovals(pendingApprovals, {
+        treatAskAsDeny: true,
+        denyReasonForAsk: "Tool requires approval (headless mode)",
+        requireArgsForAutoApprove: true,
+        missingNameReason: "Tool call incomplete - missing name"
+      });
+      const decisions = [
+        ...autoAllowed.map((ac) => ({
+          type: "approve",
+          approval: ac.approval,
+          reason: ac.permission.reason || "Allowed by permission rule",
+          matchedRule: "matchedRule" in ac.permission && ac.permission.matchedRule ? ac.permission.matchedRule : "auto-approved"
+        })),
+        ...autoDenied.map((ac) => {
+          const fallback = "matchedRule" in ac.permission && ac.permission.matchedRule ? `Permission denied: ${ac.permission.matchedRule}` : ac.permission.reason ? `Permission denied: ${ac.permission.reason}` : "Permission denied: Unknown reason";
+          return {
+            type: "deny",
+            approval: ac.approval,
+            reason: ac.denyReason ?? fallback
+          };
+        })
+      ];
+      const { executeApprovalBatch: executeApprovalBatch2 } = await init_approval_execution().then(() => exports_approval_execution);
+      const executedResults = await executeApprovalBatch2(decisions);
+      const approvalInput = {
+        type: "approval",
+        approvals: executedResults
+      };
+      const approvalMessages = [approvalInput];
+      {
+        const { consumeQueuedSkillContent: consumeQueuedSkillContent2 } = await Promise.resolve().then(() => (init_skillContentRegistry(), exports_skillContentRegistry));
+        const skillContents = consumeQueuedSkillContent2();
+        if (skillContents.length > 0) {
+          approvalMessages.push({
+            role: "user",
+            content: skillContents.map((sc) => ({
+              type: "text",
+              text: sc.content
+            }))
+          });
+        }
+      }
+      const approvalStream = await sendMessageStream(conversationId, approvalMessages, { agentId: agent.id });
+      await drainStreamWithResume(approvalStream, createBuffers(agent.id), () => {});
+    }
+  };
   const rl = readline.createInterface({
     input: process.stdin,
     terminal: false
@@ -66303,7 +66666,7 @@ async function runBidirectionalMode(agent, conversationId, _client, _outputForma
             response: {
               agent_id: agent.id,
               model: agent.llm_config?.model,
-              tools: agent.tools?.map((t) => t.name) || []
+              tools: availableTools
             }
           },
           session_id: sessionId,
@@ -66325,6 +66688,54 @@ async function runBidirectionalMode(agent, conversationId, _client, _outputForma
           uuid: crypto.randomUUID()
         };
         console.log(JSON.stringify(interruptResponse));
+      } else if (subtype === "register_external_tools") {
+        const toolsRequest = message.request;
+        const tools = toolsRequest.tools ?? [];
+        registerExternalTools(tools);
+        setExternalToolExecutor(async (toolCallId, toolName, input) => {
+          const execRequest = {
+            type: "control_request",
+            request_id: `ext-${toolCallId}`,
+            request: {
+              subtype: "execute_external_tool",
+              tool_call_id: toolCallId,
+              tool_name: toolName,
+              input
+            }
+          };
+          console.log(JSON.stringify(execRequest));
+          while (true) {
+            const line2 = await getNextLine();
+            if (line2 === null) {
+              return {
+                content: [{ type: "text", text: "stdin closed" }],
+                isError: true
+              };
+            }
+            if (!line2.trim())
+              continue;
+            try {
+              const msg = JSON.parse(line2);
+              if (msg.type === "control_response" && msg.response?.subtype === "external_tool_result" && msg.response?.tool_call_id === toolCallId) {
+                return {
+                  content: msg.response.content ?? [{ type: "text", text: "" }],
+                  isError: msg.response.is_error ?? false
+                };
+              }
+            } catch {}
+          }
+        });
+        const registerResponse = {
+          type: "control_response",
+          response: {
+            subtype: "success",
+            request_id: requestId ?? "",
+            response: { registered: tools.length }
+          },
+          session_id: sessionId,
+          uuid: crypto.randomUUID()
+        };
+        console.log(JSON.stringify(registerResponse));
       } else {
         const errorResponse = {
           type: "control_response",
@@ -66393,9 +66804,40 @@ ${enrichedContent}`;
               ];
             }
           }
-          const stream2 = await sendMessageStream(conversationId, currentInput, {
-            agentId: agent.id
-          });
+          let stream2;
+          try {
+            stream2 = await sendMessageStream(conversationId, currentInput, {
+              agentId: agent.id
+            });
+          } catch (preStreamError) {
+            let errorDetail = "";
+            if (preStreamError instanceof APIError2 && preStreamError.error && typeof preStreamError.error === "object") {
+              const errObj = preStreamError.error;
+              if (errObj.error && typeof errObj.error === "object" && "detail" in errObj.error) {
+                const nested = errObj.error;
+                errorDetail = typeof nested.detail === "string" ? nested.detail : "";
+              }
+              if (!errorDetail && typeof errObj.detail === "string") {
+                errorDetail = errObj.detail;
+              }
+            }
+            if (!errorDetail && preStreamError instanceof Error) {
+              errorDetail = preStreamError.message;
+            }
+            if (isApprovalPendingError(errorDetail)) {
+              const recoveryMsg = {
+                type: "recovery",
+                recovery_type: "approval_pending",
+                message: "Detected pending approval conflict on send; resolving before retry",
+                session_id: sessionId,
+                uuid: `recovery-bidir-${crypto.randomUUID()}`
+              };
+              console.log(JSON.stringify(recoveryMsg));
+              await resolveAllPendingApprovals();
+              continue;
+            }
+            throw preStreamError;
+          }
           const streamJsonHook = ({
             chunk,
             shouldOutput,
@@ -66463,6 +66905,7 @@ ${enrichedContent}`;
               break;
             }
             const { autoAllowed, autoDenied, needsUserInput } = await classifyApprovals(approvals, {
+              alwaysRequiresUserInput: isInteractiveApprovalTool,
               requireArgsForAutoApprove: true,
               missingNameReason: "Tool call incomplete - missing name"
             });
@@ -66620,6 +67063,7 @@ var init_headless = __esm(async () => {
   init_model();
   init_errorFormatter();
   init_constants();
+  init_interactivePolicy();
   init_timing();
   await __promiseAll([
     init_approval_recovery(),
@@ -66630,7 +67074,8 @@ var init_headless = __esm(async () => {
     init_accumulator(),
     init_approvalClassification(),
     init_stream(),
-    init_settings_manager()
+    init_settings_manager(),
+    init_manager3()
   ]);
 });
 
@@ -68532,7 +68977,9 @@ function formatArgsDisplay(argsJson, toolName) {
   return { display, parsed };
 }
 var isRecord3 = (v) => typeof v === "object" && v !== null;
-var init_formatArgsDisplay = () => {};
+var init_formatArgsDisplay = __esm(async () => {
+  await init_toolNameMapping();
+});
 
 // node_modules/diff/libesm/diff/base.js
 class Diff {
@@ -70410,11 +70857,11 @@ function getFileEditHeader(toolName, toolArgs) {
 }
 var import_react33, jsx_dev_runtime14, SOLID_LINE5 = "─", DOTTED_LINE2 = "╌", ApprovalPreview;
 var init_ApprovalPreview = __esm(async () => {
-  init_formatArgsDisplay();
   init_useTerminalWidth();
   init_colors();
   await __promiseAll([
     init_build2(),
+    init_formatArgsDisplay(),
     init_AdvancedDiffRenderer(),
     init_BashPreview(),
     init_PlanPreview(),
@@ -71123,13 +71570,13 @@ function getDiffKind(toolName) {
 var import_react38, jsx_dev_runtime17, SOLID_LINE8 = "─", DOTTED_LINE3 = "╌", InlineFileEditApproval;
 var init_InlineFileEditApproval = __esm(async () => {
   init_diff2();
-  init_formatArgsDisplay();
   init_useProgressIndicator();
   init_useTerminalWidth();
   init_useTextInputCursor();
   init_colors();
   await __promiseAll([
     init_build2(),
+    init_formatArgsDisplay(),
     init_AdvancedDiffRenderer(),
     init_Text2()
   ]);
@@ -72704,6 +73151,7 @@ function getQuestions(approval) {
 var import_react43, jsx_dev_runtime22, ApprovalSwitch;
 var init_ApprovalSwitch = __esm(async () => {
   await __promiseAll([
+    init_toolNameMapping(),
     init_InlineBashApproval(),
     init_InlineEnterPlanModeApproval(),
     init_InlineFileEditApproval(),
@@ -80690,9 +81138,15 @@ function SlashCommandAutocomplete({
     manageActiveState: false
   });
   import_react64.useLayoutEffect(() => {
-    const isActive = matches.length > 0 || showNoMatches;
+    const queryLength = queryInfo?.query.length ?? 0;
+    const isActive = !hideAutocomplete && (matches.length > 0 || queryLength > 0);
     onActiveChange?.(isActive);
-  }, [matches.length, showNoMatches, onActiveChange]);
+  }, [
+    hideAutocomplete,
+    matches.length,
+    onActiveChange,
+    queryInfo?.query.length
+  ]);
   if (!currentInput.startsWith("/")) {
     return null;
   }
@@ -88777,13 +89231,14 @@ function isShellTool2(name) {
 var import_react85, jsx_dev_runtime65, ToolCallMessage;
 var init_ToolCallMessageRich = __esm(async () => {
   init_constants();
-  init_formatArgsDisplay();
   init_subagentState();
   init_useTerminalWidth();
   init_colors();
   await __promiseAll([
     init_build2(),
     init_manager3(),
+    init_formatArgsDisplay(),
+    init_toolNameMapping(),
     init_Text2(),
     init_AdvancedDiffRenderer(),
     init_BlinkDot(),
@@ -90612,8 +91067,9 @@ function createSubagentGroupItem(taskToolCalls) {
     agents
   };
 }
-var init_subagentAggregation = __esm(() => {
+var init_subagentAggregation = __esm(async () => {
   init_subagentState();
+  await init_toolNameMapping();
 });
 
 // src/cli/helpers/subagentTurnStart.ts
@@ -93322,7 +93778,7 @@ function App2({
         continue;
       if (!line.toolCallId || !line.name)
         continue;
-      if (line.name !== "memory" && line.name !== "memory_apply_patch")
+      if (!isMemoryTool(line.name))
         continue;
       if (memorySyncProcessedToolCallsRef.current.has(line.toolCallId))
         continue;
@@ -94393,7 +94849,9 @@ ${feedback}
               };
               const errorDetails = formatErrorDetails(errorObject, agentIdRef.current);
               appendError(errorDetails, true);
-              appendError(getErrorHintForStopReason(stopReasonToHandle, currentModelId), true);
+              if (!isEncryptedContentError(errorObject)) {
+                appendError(getErrorHintForStopReason(stopReasonToHandle, currentModelId), true);
+              }
             } else {
               appendError(`An error occurred during agent execution
 (run_id: ${lastRunId}, stop_reason: ${stopReason})`, true);
@@ -98775,12 +99233,10 @@ var init_App2 = __esm(async () => {
   init_diff2();
   init_errorContext();
   init_errorFormatter();
-  init_formatArgsDisplay();
   init_messageQueueBridge();
   init_pasteRegistry();
   init_planName();
   init_queuedMessageParts();
-  init_subagentAggregation();
   init_subagentState();
   init_thinkingMessages();
   init_useSyncedState();
@@ -98838,9 +99294,13 @@ var init_App2 = __esm(async () => {
     init_WelcomeScreen(),
     init_accumulator(),
     init_approvalClassification(),
+    init_formatArgsDisplay(),
     init_memoryReminder(),
     init_sessionContext(),
     init_stream(),
+    init_subagentAggregation(),
+    init_toolNameMapping(),
+    init_toolNameMapping(),
     init_useSuspend()
   ]);
   import_react91 = __toESM(require_react(), 1);
@@ -99712,6 +100172,7 @@ var init_create3 = __esm(async () => {
 // src/agent/import.ts
 var exports_import2 = {};
 __export(exports_import2, {
+  importAgentFromRegistry: () => importAgentFromRegistry2,
   importAgentFromFile: () => importAgentFromFile2,
   extractSkillsFromAf: () => extractSkillsFromAf2
 });
@@ -99819,6 +100280,45 @@ async function downloadGitHubDirectory2(entries, destDir, owner, repo, branch, b
     }
   }
 }
+function parseRegistryHandle2(handle) {
+  const normalized = handle.startsWith("@") ? handle.slice(1) : handle;
+  const parts = normalized.split("/");
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new Error(`Invalid import handle "${handle}". Use format: @author/agentname`);
+  }
+  return { author: parts[0], name: parts[1] };
+}
+async function importAgentFromRegistry2(options) {
+  const { tmpdir: tmpdir4 } = await import("node:os");
+  const { join: join31 } = await import("node:path");
+  const { writeFile: writeFile6, unlink: unlink2 } = await import("node:fs/promises");
+  const { author, name } = parseRegistryHandle2(options.handle);
+  const rawUrl = `https://raw.githubusercontent.com/${AGENT_REGISTRY_OWNER2}/${AGENT_REGISTRY_REPO2}/refs/heads/${AGENT_REGISTRY_BRANCH2}/agents/@${author}/${name}/${name}.af`;
+  const response = await fetch(rawUrl);
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new Error(`Agent @${author}/${name} not found in registry. Check that the agent exists at https://github.com/${AGENT_REGISTRY_OWNER2}/${AGENT_REGISTRY_REPO2}/tree/${AGENT_REGISTRY_BRANCH2}/agents/@${author}/${name}`);
+    }
+    throw new Error(`Failed to download agent @${author}/${name}: ${response.statusText}`);
+  }
+  const afContent = await response.text();
+  const tempPath = join31(tmpdir4(), `letta-import-${author}-${name}-${Date.now()}.af`);
+  await writeFile6(tempPath, afContent, "utf-8");
+  try {
+    const result = await importAgentFromFile2({
+      filePath: tempPath,
+      modelOverride: options.modelOverride,
+      stripMessages: options.stripMessages ?? true,
+      stripSkills: options.stripSkills ?? false
+    });
+    return result;
+  } finally {
+    try {
+      await unlink2(tempPath);
+    } catch {}
+  }
+}
+var AGENT_REGISTRY_OWNER2 = "letta-ai", AGENT_REGISTRY_REPO2 = "agent-file", AGENT_REGISTRY_BRANCH2 = "main";
 var init_import2 = __esm(async () => {
   init_model();
   await __promiseAll([
@@ -99919,7 +100419,7 @@ function buildModelSettings2(modelHandle, updateArgs) {
   } else {
     settings = {};
   }
-  if (typeof updateArgs?.max_output_tokens === "number") {
+  if (typeof updateArgs?.max_output_tokens === "number" && "provider_type" in settings) {
     settings.max_output_tokens = updateArgs.max_output_tokens;
   }
   return settings;
@@ -99932,7 +100432,10 @@ async function updateAgentLLMConfig2(agentId, modelHandle, updateArgs) {
   await client.agents.update(agentId, {
     model: modelHandle,
     ...hasModelSettings && { model_settings: modelSettings },
-    ...contextWindow && { context_window_limit: contextWindow }
+    ...contextWindow && { context_window_limit: contextWindow },
+    ...typeof updateArgs?.max_output_tokens === "number" && {
+      max_tokens: updateArgs.max_output_tokens
+    }
   });
   const finalAgent = await client.agents.retrieve(agentId);
   return finalAgent.llm_config;
@@ -103760,6 +104263,8 @@ function releaseSwitchLock2() {
     lock.resolve = null;
   }
 }
+var EXTERNAL_TOOLS_KEY2 = Symbol.for("@letta/externalTools");
+var EXTERNAL_EXECUTOR_KEY2 = Symbol.for("@letta/externalToolExecutor");
 function replaceRegistry2(newTools) {
   toolRegistry2.clear();
   for (const [key, value] of newTools) {
@@ -103958,6 +104463,7 @@ OPTIONS
   --skills <path>       Custom path to skills directory (default: .skills in current directory)
   --sleeptime           Enable sleeptime memory management (only for new agents)
   --from-af <path>      Create agent from an AgentFile (.af) template
+                        Use @author/name to import from the agent registry
   --memfs               Enable memory filesystem for this agent
   --no-memfs            Disable memory filesystem for this agent
 
@@ -104407,6 +104913,7 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
       process.exit(1);
     }
   }
+  let isRegistryImport = false;
   if (fromAfFile) {
     if (specifiedAgentId) {
       console.error("Error: --from-af cannot be used with --agent");
@@ -104424,12 +104931,22 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
       console.error("Error: --from-af cannot be used with --new");
       process.exit(1);
     }
-    const { resolve: resolve23 } = await import("path");
-    const { existsSync: existsSync19 } = await import("fs");
-    const resolvedPath = resolve23(fromAfFile);
-    if (!existsSync19(resolvedPath)) {
-      console.error(`Error: AgentFile not found: ${resolvedPath}`);
-      process.exit(1);
+    if (fromAfFile.startsWith("@")) {
+      isRegistryImport = true;
+      const normalized = fromAfFile.slice(1);
+      const parts = normalized.split("/");
+      if (parts.length !== 2 || !parts[0] || !parts[1]) {
+        console.error(`Error: Invalid registry handle "${fromAfFile}". Use format: @author/agentname`);
+        process.exit(1);
+      }
+    } else {
+      const { resolve: resolve23 } = await import("path");
+      const { existsSync: existsSync19 } = await import("fs");
+      const resolvedPath = resolve23(fromAfFile);
+      if (!existsSync19(resolvedPath)) {
+        console.error(`Error: AgentFile not found: ${resolvedPath}`);
+        process.exit(1);
+      }
     }
   }
   if (specifiedAgentName) {
@@ -104573,7 +105090,8 @@ Error: ${message}`);
     systemPromptPreset: systemPromptPreset2,
     toolset,
     skillsDirectory: skillsDirectory2,
-    fromAfFile: fromAfFile2
+    fromAfFile: fromAfFile2,
+    isRegistryImport: isRegistryImport2
   }) {
     const [showKeybindingSetup, setShowKeybindingSetup] = useState45(null);
     const [loadingState, setLoadingState] = useState45("selecting");
@@ -104870,13 +105388,24 @@ Error: ${message}`);
         let isNewlyCreatedAgent = false;
         if (fromAfFile2) {
           setLoadingState("importing");
-          const { importAgentFromFile: importAgentFromFile3 } = await init_import2().then(() => exports_import2);
-          const result = await importAgentFromFile3({
-            filePath: fromAfFile2,
-            modelOverride: model,
-            stripMessages: true,
-            stripSkills: false
-          });
+          let result;
+          if (isRegistryImport2) {
+            const { importAgentFromRegistry: importAgentFromRegistry3 } = await init_import2().then(() => exports_import2);
+            result = await importAgentFromRegistry3({
+              handle: fromAfFile2,
+              modelOverride: model,
+              stripMessages: true,
+              stripSkills: false
+            });
+          } else {
+            const { importAgentFromFile: importAgentFromFile3 } = await init_import2().then(() => exports_import2);
+            result = await importAgentFromFile3({
+              filePath: fromAfFile2,
+              modelOverride: model,
+              stripMessages: true,
+              stripSkills: false
+            });
+          }
           agent = result.agent;
           isNewlyCreatedAgent = true;
           setAgentProvenance({
@@ -105236,11 +105765,12 @@ Error during initialization: ${message}`);
     systemPromptPreset,
     toolset: specifiedToolset,
     skillsDirectory,
-    fromAfFile
+    fromAfFile,
+    isRegistryImport
   }), {
     exitOnCtrlC: false
   });
 }
 main();
 
-//# debugId=F0DE08B3E2B6D4FD64756E2164756E21
+//# debugId=333508E0ED33A45564756E2164756E21