@letta-ai/letta-code 0.1.19 → 0.2.0

package/letta.js

@@ -67,13 +67,13 @@ var init_tslib = () => {};
 
 // node_modules/@letta-ai/letta-client/internal/utils/uuid.mjs
 var uuid4 = function() {
-  const { crypto } = globalThis;
-  if (crypto?.randomUUID) {
-    uuid4 = crypto.randomUUID.bind(crypto);
-    return crypto.randomUUID();
+  const { crypto: crypto2 } = globalThis;
+  if (crypto2?.randomUUID) {
+    uuid4 = crypto2.randomUUID.bind(crypto2);
+    return crypto2.randomUUID();
   }
   const u8 = new Uint8Array(1);
-  const randomByte = crypto ? () => crypto.getRandomValues(u8)[0] : () => Math.random() * 255 & 255;
+  const randomByte = crypto2 ? () => crypto2.getRandomValues(u8)[0] : () => Math.random() * 255 & 255;
   return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ randomByte() & 15 >> +c / 4).toString(16));
 };
 
@@ -240,7 +240,7 @@ var init_values = __esm(() => {
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 // node_modules/@letta-ai/letta-client/version.mjs
-var VERSION = "1.0.0-alpha.14";
+var VERSION = "1.0.0-alpha.15";
 
 // node_modules/@letta-ai/letta-client/internal/detect-platform.mjs
 function getDetectedPlatform() {
@@ -3054,7 +3054,7 @@ async function requestDeviceCode() {
   }
   return await response.json();
 }
-async function pollForToken(deviceCode, interval = 5, expiresIn = 900) {
+async function pollForToken(deviceCode, interval = 5, expiresIn = 900, deviceId, deviceName) {
   const startTime = Date.now();
   const expiresInMs = expiresIn * 1000;
   let pollInterval = interval * 1000;
@@ -3067,7 +3067,9 @@ async function pollForToken(deviceCode, interval = 5, expiresIn = 900) {
         body: JSON.stringify({
           grant_type: "urn:ietf:params:oauth:grant-type:device_code",
           client_id: OAUTH_CONFIG.clientId,
-          device_code: deviceCode
+          device_code: deviceCode,
+          ...deviceId && { device_id: deviceId },
+          ...deviceName && { device_name: deviceName }
         })
       });
       const result = await response.json();
@@ -3412,6 +3414,8 @@ var init_settings_manager = __esm(() => {
     uiMode: "simple",
     lastAgent: null,
     tokenStreaming: false,
+    parallelToolCalls: true,
+    enableSleeptime: false,
     globalSharedBlockIds: {}
   };
   DEFAULT_PROJECT_SETTINGS = {
@@ -6715,7 +6719,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.1.19",
+    version: "0.2.0",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -6737,7 +6741,7 @@ var init_package = __esm(() => {
       access: "public"
     },
     dependencies: {
-      "@letta-ai/letta-client": "1.0.0-alpha.14",
+      "@letta-ai/letta-client": "1.0.0-alpha.15",
       "ink-link": "^5.0.0",
       open: "^10.2.0"
     },
@@ -31681,6 +31685,7 @@ var init_open = __esm(() => {
 });
 
 // src/auth/setup-ui.tsx
+import { hostname } from "os";
 function SetupUI({ onComplete }) {
   const [mode, setMode] = import_react22.useState("menu");
   const [selectedOption, setSelectedOption] = import_react22.useState(0);
@@ -31717,7 +31722,13 @@ function SetupUI({ onComplete }) {
       } catch (openErr) {
         console.error("Failed to auto-open browser:", openErr);
       }
-      pollForToken(deviceData.device_code, deviceData.interval, deviceData.expires_in).then((tokens) => {
+      let deviceId = settingsManager.getSetting("deviceId");
+      if (!deviceId) {
+        deviceId = crypto.randomUUID();
+        settingsManager.updateSettings({ deviceId });
+      }
+      const deviceName = hostname();
+      pollForToken(deviceData.device_code, deviceData.interval, deviceData.expires_in, deviceId, deviceName).then((tokens) => {
         const now = Date.now();
         settingsManager.updateSettings({
           env: {
@@ -31929,7 +31940,7 @@ async function requestDeviceCode2() {
   }
   return await response.json();
 }
-async function pollForToken2(deviceCode, interval = 5, expiresIn = 900) {
+async function pollForToken2(deviceCode, interval = 5, expiresIn = 900, deviceId, deviceName) {
   const startTime = Date.now();
   const expiresInMs = expiresIn * 1000;
   let pollInterval = interval * 1000;
@@ -31942,7 +31953,9 @@ async function pollForToken2(deviceCode, interval = 5, expiresIn = 900) {
         body: JSON.stringify({
           grant_type: "urn:ietf:params:oauth:grant-type:device_code",
           client_id: OAUTH_CONFIG2.clientId,
-          device_code: deviceCode
+          device_code: deviceCode,
+          ...deviceId && { device_id: deviceId },
+          ...deviceName && { device_name: deviceName }
         })
       });
       const result = await response.json();
@@ -33727,6 +33740,10 @@ var init_matcher = __esm(() => {
 });
 
 // src/permissions/mode.ts
+var exports_mode = {};
+__export(exports_mode, {
+  permissionMode: () => permissionMode2
+});
 function getGlobalMode2() {
   const global2 = globalThis;
   if (!global2[MODE_KEY2]) {
@@ -34939,6 +34956,15 @@ description: A memory block to store information about this coding project. This
 `;
 var init_project = () => {};
 
+// src/agent/prompts/skills.mdx
+var skills_default = `---
+label: skills
+description: A memory block to store all available Skills with their metadata (name and description). Whenever a new Skill is discovered / created or an existing Skill is updated, I should store it here. I should always check the \`.skills\` directory for an updated skill list.
+---
+
+[CURRENTLY EMPTY: CREATE A LIST OF AVAILABLE SKILLS (DIRECTORIES WITH SKILL.MD FILE) WITH DESCRIPTIONS IN THIS MEMORY BLOCK. ALWAYS CHECK THE \`.skills\` DIRECTORY TO MAKE SURE YOU HAVE AN UPDATED LIST OF SKILLS]`;
+var init_skills = () => {};
+
 // src/agent/prompts/style.mdx
 var style_default = `---
 label: style
@@ -34975,7 +35001,21 @@ Your memory consists of memory blocks and external memory:
 
 Memory management tools allow you to edit existing memory blocks and query for external memories.
 Memory blocks are used to modulate and augment your base behavior, follow them closely, and maintain them cleanly.
-They are the foundation which makes you *you*.`;
+They are the foundation which makes you *you*.
+
+# Skills
+You have access to Skills—folders of instructions, scripts, and resources that you can load dynamically to improve performance on specialized tasks. Skills teach you how to complete specific tasks in a repeatable way. Skills work through progressive disclosure—you should determine which Skills are relevant to complete a task and load them, helping to prevent context window overload. 
+Each Skill directory includes:
+- \`SKILL.md\` file that starts with YAML frontmatter containing required metadata: name and description
+- Additional files within the Skill directory referenced by name from \`SKILL.md\`. These additional linked files should be navigated and discovered only as needed.
+How to use Skills:
+- Skills are automatically discovered on bootup. The Skills directory and any available Skills are stored in the \`skills\` memory block.
+- Review available Skills from the \`skills\` block when you are asked to complete a task.
+- If a Skill is relevant, first load the Skill by reading its full \`SKILL.md\` into context.
+- Then, navigate and discover additional linked files in its directory as needed. Don't load additional files immediately, only load them when needed.
+- When you load / use Skills, explicitly mention which Skills are loaded / used.
+- When the task is completed or when you load new Skills, unload irrelevant Skills by removing them from the context.
+Remember to always keep only the full \`SKILL.md\` into context for all Skills relevant to the current task. Use additional files as needed.`;
 var init_system_prompt = () => {};
 
 // src/agent/promptAssets.ts
@@ -34992,6 +35032,7 @@ var init_promptAssets = __esm(() => {
   init_persona_kawaii();
   init_plan_mode_reminder();
   init_project();
+  init_skills();
   init_style();
   init_system_prompt();
   SYSTEM_PROMPT = system_prompt_default;
@@ -35000,6 +35041,7 @@ var init_promptAssets = __esm(() => {
     "persona.mdx": persona_default,
     "human.mdx": human_default,
     "project.mdx": project_default,
+    "skills.mdx": skills_default,
     "style.mdx": style_default,
     "persona_kawaii.mdx": persona_kawaii_default
   };
@@ -35028,7 +35070,7 @@ function parseMdxFrontmatter(content) {
 }
 async function loadMemoryBlocksFromMdx() {
   const memoryBlocks = [];
-  const mdxFiles = ["persona.mdx", "human.mdx", "project.mdx"];
+  const mdxFiles = ["persona.mdx", "human.mdx", "project.mdx", "skills.mdx"];
   for (const filename of mdxFiles) {
     try {
       const content = MEMORY_PROMPTS[filename];
@@ -35109,15 +35151,6 @@ var init_models2 = __esm(() => {
         context_window: 272000
       }
     },
-    {
-      id: "glm-4.6",
-      handle: "openrouter/z-ai/glm-4.6:exacto",
-      label: "GLM-4.6",
-      description: "The best open weights coding model",
-      updateArgs: {
-        context_window: 200000
-      }
-    },
     {
       id: "gpt-5-minimal",
       handle: "openai/gpt-5",
@@ -35162,6 +35195,64 @@ var init_models2 = __esm(() => {
         context_window: 272000
       }
     },
+    {
+      id: "gpt-5-mini-medium",
+      handle: "openai/gpt-5-mini-2025-08-07",
+      label: "GPT-5-Mini (medium)",
+      description: "OpenAI's latest mini model (using their recommended reasoning level)",
+      updateArgs: {
+        reasoning_effort: "medium",
+        verbosity: "medium",
+        context_window: 272000
+      }
+    },
+    {
+      id: "gpt-5-nano-medium",
+      handle: "openai/gpt-5-nano-2025-08-07",
+      label: "GPT-5-Nano (medium)",
+      description: "OpenAI's latest nano model (using their recommended reasoning level)",
+      updateArgs: {
+        reasoning_effort: "medium",
+        verbosity: "medium",
+        context_window: 272000
+      }
+    },
+    {
+      id: "glm-4.6",
+      handle: "openrouter/z-ai/glm-4.6:exacto",
+      label: "GLM-4.6",
+      description: "The best open weights coding model",
+      updateArgs: {
+        context_window: 200000
+      }
+    },
+    {
+      id: "minimax-m2",
+      handle: "openrouter/minimax/minimax-m2",
+      label: "Minimax M2",
+      description: "Minimax's latest model",
+      updateArgs: {
+        context_window: 196000
+      }
+    },
+    {
+      id: "kimi-k2",
+      handle: "openrouter/moonshotai/kimi-k2-0905",
+      label: "Kimi K2",
+      description: "Kimi's latest model",
+      updateArgs: {
+        context_window: 262144
+      }
+    },
+    {
+      id: "deepseek-chat-v3.1",
+      handle: "openrouter/deepseek/deepseek-chat-v3.1",
+      label: "DeepSeek Chat V3.1",
+      description: "DeepSeek V3.1 model",
+      updateArgs: {
+        context_window: 128000
+      }
+    },
     {
       id: "gemini-flash",
       handle: "google_ai/gemini-2.5-flash",
@@ -35181,7 +35272,21 @@ var init_models2 = __esm(() => {
       handle: "openai/gpt-4.1",
       label: "GPT-4.1",
       description: "OpenAI's most recent non-reasoner model",
-      updateArgs: { context_window: 180000 }
+      updateArgs: { context_window: 1047576 }
+    },
+    {
+      id: "gpt-4.1-mini",
+      handle: "openai/gpt-4.1-mini-2025-04-14",
+      label: "GPT-4.1-Mini",
+      description: "OpenAI's most recent non-reasoner model (mini version)",
+      updateArgs: { context_window: 1047576 }
+    },
+    {
+      id: "gpt-4.1-nano",
+      handle: "openai/gpt-4.1-nano-2025-04-14",
+      label: "GPT-4.1-Nano",
+      description: "OpenAI's most recent non-reasoner model (nano version)",
+      updateArgs: { context_window: 1047576 }
     },
     {
       id: "o4-mini",
@@ -35250,30 +35355,299 @@ var init_model = __esm(() => {
 // src/agent/modify.ts
 var exports_modify = {};
 __export(exports_modify, {
-  updateAgentLLMConfig: () => updateAgentLLMConfig
+  updateAgentLLMConfig: () => updateAgentLLMConfig,
+  unlinkToolsFromAgent: () => unlinkToolsFromAgent,
+  linkToolsToAgent: () => linkToolsToAgent
 });
-async function updateAgentLLMConfig(agentId, modelHandle, updateArgs) {
+async function updateAgentLLMConfig(agentId, modelHandle, updateArgs, preserveParallelToolCalls) {
   const client = await getClient2();
-  await client.agents.modify(agentId, { model: modelHandle });
-  const agent = await client.agents.retrieve(agentId);
-  let finalConfig = agent.llm_config;
-  if (updateArgs && Object.keys(updateArgs).length > 0) {
-    const updatedLlmConfig = {
-      ...finalConfig,
-      ...updateArgs
+  const currentAgent = await client.agents.retrieve(agentId);
+  const originalParallelToolCalls = preserveParallelToolCalls ? currentAgent.llm_config?.parallel_tool_calls ?? undefined : undefined;
+  const updatedLlmConfig = {
+    ...currentAgent.llm_config,
+    ...updateArgs,
+    ...originalParallelToolCalls !== undefined && {
+      parallel_tool_calls: originalParallelToolCalls
+    }
+  };
+  await client.agents.modify(agentId, {
+    llm_config: updatedLlmConfig,
+    parallel_tool_calls: originalParallelToolCalls
+  });
+  const finalAgent = await client.agents.retrieve(agentId);
+  return finalAgent.llm_config;
+}
+async function linkToolsToAgent(agentId) {
+  try {
+    const client = await getClient2();
+    const agent = await client.agents.retrieve(agentId);
+    const currentTools = agent.tools || [];
+    const currentToolIds = currentTools.map((t) => t.id).filter((id) => typeof id === "string");
+    const currentToolNames = new Set(currentTools.map((t) => t.name).filter((name) => typeof name === "string"));
+    const lettaCodeToolNames = getToolNames();
+    const toolsToAdd = lettaCodeToolNames.filter((name) => !currentToolNames.has(name));
+    if (toolsToAdd.length === 0) {
+      return {
+        success: true,
+        message: "All Letta Code tools already attached",
+        addedCount: 0
+      };
+    }
+    const toolsToAddIds = [];
+    for (const toolName of toolsToAdd) {
+      const tools = await client.tools.list({ name: toolName });
+      const tool = tools[0];
+      if (tool?.id) {
+        toolsToAddIds.push(tool.id);
+      }
+    }
+    const newToolIds = [...currentToolIds, ...toolsToAddIds];
+    const currentToolRules = agent.tool_rules || [];
+    const newToolRules = [
+      ...currentToolRules,
+      ...toolsToAdd.map((toolName) => ({
+        tool_name: toolName,
+        type: "requires_approval",
+        prompt_template: null
+      }))
+    ];
+    await client.agents.modify(agentId, {
+      tool_ids: newToolIds,
+      tool_rules: newToolRules
+    });
+    return {
+      success: true,
+      message: `Attached ${toolsToAddIds.length} Letta Code tool(s) to agent`,
+      addedCount: toolsToAddIds.length
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function unlinkToolsFromAgent(agentId) {
+  try {
+    const client = await getClient2();
+    const agent = await client.agents.retrieve(agentId);
+    const allTools = agent.tools || [];
+    const lettaCodeToolNames = new Set(getToolNames());
+    const remainingTools = allTools.filter((t) => t.name && !lettaCodeToolNames.has(t.name));
+    const removedCount = allTools.length - remainingTools.length;
+    const remainingToolIds = remainingTools.map((t) => t.id).filter((id) => typeof id === "string");
+    const currentToolRules = agent.tool_rules || [];
+    const remainingToolRules = currentToolRules.filter((rule) => rule.type !== "requires_approval" || !lettaCodeToolNames.has(rule.tool_name));
+    await client.agents.modify(agentId, {
+      tool_ids: remainingToolIds,
+      tool_rules: remainingToolRules
+    });
+    return {
+      success: true,
+      message: `Removed ${removedCount} Letta Code tool(s) from agent`,
+      removedCount
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed: ${error instanceof Error ? error.message : String(error)}`
     };
-    await client.agents.modify(agentId, { llm_config: updatedLlmConfig });
-    const finalAgent = await client.agents.retrieve(agentId);
-    finalConfig = finalAgent.llm_config;
   }
-  return finalConfig;
 }
 var init_modify = __esm(() => {
+  init_manager();
   init_client2();
 });
 
+// src/agent/skills.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { readdir as readdir2, readFile as readFile2 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+function parseFrontmatter(content) {
+  const frontmatterRegex = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
+  const match2 = content.match(frontmatterRegex);
+  if (!match2 || !match2[1] || !match2[2]) {
+    return { frontmatter: {}, body: content };
+  }
+  const frontmatterText = match2[1];
+  const body = match2[2];
+  const frontmatter = {};
+  const lines = frontmatterText.split(`
+`);
+  let currentKey = null;
+  let currentArray = [];
+  for (const line of lines) {
+    if (line.trim().startsWith("-") && currentKey) {
+      const value = line.trim().slice(1).trim();
+      currentArray.push(value);
+      continue;
+    }
+    if (currentKey && currentArray.length > 0) {
+      frontmatter[currentKey] = currentArray;
+      currentKey = null;
+      currentArray = [];
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      const value = line.slice(colonIndex + 1).trim();
+      currentKey = key;
+      if (value) {
+        frontmatter[key] = value;
+        currentKey = null;
+      } else {
+        currentArray = [];
+      }
+    }
+  }
+  if (currentKey && currentArray.length > 0) {
+    frontmatter[currentKey] = currentArray;
+  }
+  return { frontmatter, body: body.trim() };
+}
+async function discoverSkills(skillsPath = join6(process.cwd(), SKILLS_DIR)) {
+  const errors = [];
+  if (!existsSync3(skillsPath)) {
+    return { skills: [], errors: [] };
+  }
+  const skills = [];
+  try {
+    await findSkillFiles(skillsPath, skillsPath, skills, errors);
+  } catch (error) {
+    errors.push({
+      path: skillsPath,
+      message: `Failed to read skills directory: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+  return { skills, errors };
+}
+async function findSkillFiles(currentPath, rootPath, skills, errors) {
+  try {
+    const entries = await readdir2(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join6(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        await findSkillFiles(fullPath, rootPath, skills, errors);
+      } else if (entry.isFile() && entry.name.toUpperCase() === "SKILL.MD") {
+        try {
+          const skill = await parseSkillFile(fullPath, rootPath);
+          if (skill) {
+            skills.push(skill);
+          }
+        } catch (error) {
+          errors.push({
+            path: fullPath,
+            message: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    }
+  } catch (error) {
+    errors.push({
+      path: currentPath,
+      message: `Failed to read directory: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+}
+async function parseSkillFile(filePath, rootPath) {
+  const content = await readFile2(filePath, "utf-8");
+  const { frontmatter, body } = parseFrontmatter(content);
+  const normalizedRoot = rootPath.endsWith("/") ? rootPath.slice(0, -1) : rootPath;
+  const relativePath = filePath.slice(normalizedRoot.length + 1);
+  const dirPath = relativePath.slice(0, -"/SKILL.MD".length);
+  const defaultId = dirPath || "root";
+  const id = (typeof frontmatter.id === "string" ? frontmatter.id : null) || defaultId;
+  const name = (typeof frontmatter.name === "string" ? frontmatter.name : null) || (typeof frontmatter.title === "string" ? frontmatter.title : null) || (id.split("/").pop() ?? "").replace(/-/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
+  let description = typeof frontmatter.description === "string" ? frontmatter.description : null;
+  if (!description) {
+    const firstParagraph = body.trim().split(`
+
+`)[0];
+    description = firstParagraph || "No description available";
+  }
+  description = description.trim();
+  if (description.startsWith('"') && description.endsWith('"') || description.startsWith("'") && description.endsWith("'")) {
+    description = description.slice(1, -1);
+  }
+  let tags;
+  if (Array.isArray(frontmatter.tags)) {
+    tags = frontmatter.tags;
+  } else if (typeof frontmatter.tags === "string") {
+    tags = [frontmatter.tags];
+  }
+  return {
+    id,
+    name,
+    description,
+    category: typeof frontmatter.category === "string" ? frontmatter.category : undefined,
+    tags,
+    path: filePath
+  };
+}
+function formatSkillsForMemory(skills, skillsDirectory) {
+  let output = `Skills Directory: ${skillsDirectory}
+
+`;
+  if (skills.length === 0) {
+    return `${output}[NO SKILLS AVAILABLE]`;
+  }
+  output += `Available Skills:
+
+`;
+  const categorized = new Map;
+  const uncategorized = [];
+  for (const skill of skills) {
+    if (skill.category) {
+      const existing = categorized.get(skill.category) || [];
+      existing.push(skill);
+      categorized.set(skill.category, existing);
+    } else {
+      uncategorized.push(skill);
+    }
+  }
+  for (const [category, categorySkills] of categorized) {
+    output += `## ${category}
+
+`;
+    for (const skill of categorySkills) {
+      output += formatSkill(skill);
+    }
+    output += `
+`;
+  }
+  if (uncategorized.length > 0) {
+    if (categorized.size > 0) {
+      output += `## Other
+
+`;
+    }
+    for (const skill of uncategorized) {
+      output += formatSkill(skill);
+    }
+  }
+  return output.trim();
+}
+function formatSkill(skill) {
+  let output = `### ${skill.name}
+`;
+  output += `ID: \`${skill.id}\`
+`;
+  output += `Description: ${skill.description}
+`;
+  if (skill.tags && skill.tags.length > 0) {
+    output += `Tags: ${skill.tags.map((t) => `\`${t}\``).join(", ")}
+`;
+  }
+  output += `
+`;
+  return output;
+}
+var SKILLS_DIR = ".skills";
+var init_skills2 = () => {};
+
 // src/agent/create.ts
-async function createAgent(name = "letta-cli-agent", model, embeddingModel = "openai/text-embedding-3-small", updateArgs, forceNewBlocks = false) {
+import { join as join7 } from "node:path";
+async function createAgent(name = "letta-cli-agent", model, embeddingModel = "openai/text-embedding-3-small", updateArgs, forceNewBlocks = false, skillsDirectory, parallelToolCalls = true, enableSleeptime = false) {
   let modelHandle;
   if (model) {
     const resolved = resolveModel(model);
@@ -35296,6 +35670,22 @@ async function createAgent(name = "letta-cli-agent", model, embeddingModel = "op
     "fetch_webpage"
   ];
   const defaultMemoryBlocks = await getDefaultMemoryBlocks();
+  const resolvedSkillsDirectory = skillsDirectory || join7(process.cwd(), SKILLS_DIR);
+  try {
+    const { skills, errors } = await discoverSkills(resolvedSkillsDirectory);
+    if (errors.length > 0) {
+      console.warn("Errors encountered during skill discovery:");
+      for (const error of errors) {
+        console.warn(`  ${error.path}: ${error.message}`);
+      }
+    }
+    const skillsBlock = defaultMemoryBlocks.find((b) => b.label === "skills");
+    if (skillsBlock) {
+      skillsBlock.value = formatSkillsForMemory(skills, resolvedSkillsDirectory);
+    }
+  } catch (error) {
+    console.warn(`Failed to discover skills: ${error instanceof Error ? error.message : String(error)}`);
+  }
   const settings = settingsManager.getSettings();
   const globalSharedBlockIds = settings.globalSharedBlockIds;
   await settingsManager.loadProjectSettings();
@@ -35342,7 +35732,7 @@ async function createAgent(name = "letta-cli-agent", model, embeddingModel = "op
         throw new Error(`Created block ${label} has no ID`);
       }
       blockIds.push(createdBlock.id);
-      if (label === "project") {
+      if (label === "project" || label === "skills") {
         newLocalBlockIds[label] = createdBlock.id;
       } else {
         newGlobalBlockIds[label] = createdBlock.id;
@@ -35368,25 +35758,31 @@ async function createAgent(name = "letta-cli-agent", model, embeddingModel = "op
       }
     }, process.cwd());
   }
+  const modelUpdateArgs = getModelUpdateArgs(modelHandle);
+  const contextWindow = modelUpdateArgs?.context_window || 200000;
   const agent = await client.agents.create({
     agent_type: "letta_v1_agent",
     system: SYSTEM_PROMPT,
     name,
     embedding: embeddingModel,
     model: modelHandle,
-    context_window_limit: 200000,
+    context_window_limit: contextWindow,
     tools: toolNames,
     block_ids: blockIds,
     tags: ["origin:letta-code"],
     include_base_tools: false,
     include_base_tool_rules: false,
-    initial_message_sequence: []
+    initial_message_sequence: [],
+    parallel_tool_calls: parallelToolCalls,
+    enable_sleeptime: enableSleeptime
   });
   if (updateArgs && Object.keys(updateArgs).length > 0) {
-    await updateAgentLLMConfig(agent.id, modelHandle, updateArgs);
-    return await client.agents.retrieve(agent.id);
+    const { context_window, ...otherArgs } = updateArgs;
+    if (Object.keys(otherArgs).length > 0) {
+      await updateAgentLLMConfig(agent.id, modelHandle, otherArgs, true);
+    }
   }
-  return agent;
+  return await client.agents.retrieve(agent.id);
 }
 var init_create = __esm(() => {
   init_settings_manager();
@@ -35396,6 +35792,7 @@ var init_create = __esm(() => {
   init_model();
   init_modify();
   init_promptAssets();
+  init_skills2();
 });
 
 // src/agent/message.ts
@@ -35610,6 +36007,12 @@ function onChunk(b, chunk) {
           if (existing && existing.kind === "reasoning") {
             markAsFinished(b, id);
             id = `${id}-tool`;
+          } else if (existing && existing.kind === "tool_call") {
+            if (toolCallId) {
+              id = `${id}-${toolCallId.slice(-8)}`;
+            } else {
+              id = `${id}-${Date.now().toString(36)}`;
+            }
           }
         }
         handleOtidTransition(b, id ?? undefined);
@@ -35621,7 +36024,7 @@ function onChunk(b, chunk) {
       }
       if (!id)
         break;
-      const desiredPhase = chunk.message_type === "approval_request_message" ? "ready" : "streaming";
+      const desiredPhase = "ready";
       const line = ensure(b, id, () => ({
         kind: "tool_call",
         id,
@@ -35642,24 +36045,33 @@ function onChunk(b, chunk) {
       break;
     }
     case "tool_return_message": {
-      const toolCallId = chunk.tool_call_id;
-      const resultText = chunk.tool_return;
-      const status = chunk.status;
-      const id = toolCallId ? b.toolCallIdToLineId.get(toolCallId) : undefined;
-      if (!id)
-        break;
-      const line = ensure(b, id, () => ({
-        kind: "tool_call",
-        id,
-        phase: "finished"
-      }));
-      const updatedLine = {
-        ...line,
-        resultText,
-        phase: "finished",
-        resultOk: status === "success"
-      };
-      b.byId.set(id, updatedLine);
+      const toolReturns = Array.isArray(chunk.tool_returns) && chunk.tool_returns.length > 0 ? chunk.tool_returns : chunk.tool_call_id ? [
+        {
+          tool_call_id: chunk.tool_call_id,
+          status: chunk.status,
+          func_response: chunk.tool_return
+        }
+      ] : [];
+      for (const toolReturn of toolReturns) {
+        const toolCallId = toolReturn.tool_call_id;
+        const resultText = ("func_response" in toolReturn ? toolReturn.func_response : undefined) || ("tool_return" in toolReturn ? toolReturn.tool_return : undefined) || "";
+        const status = toolReturn.status;
+        const id = toolCallId ? b.toolCallIdToLineId.get(toolCallId) : undefined;
+        if (!id)
+          continue;
+        const line = ensure(b, id, () => ({
+          kind: "tool_call",
+          id,
+          phase: "finished"
+        }));
+        const updatedLine = {
+          ...line,
+          resultText,
+          phase: "finished",
+          resultOk: status === "success"
+        };
+        b.byId.set(id, updatedLine);
+      }
       break;
     }
     case "usage_statistics": {
@@ -35711,18 +36123,11 @@ function safeJsonParseOr(json, defaultValue) {
 // src/cli/helpers/stream.ts
 async function drainStream(stream, buffers, refresh, abortSignal) {
   const startTime = performance.now();
-  let approvalRequestId = null;
-  let toolCallId = null;
-  let toolName = null;
-  let toolArgs = null;
+  let _approvalRequestId = null;
+  const pendingApprovals = new Map;
   let stopReason = null;
   let lastRunId = null;
   let lastSeqId = null;
-  const resetToolState = () => {
-    toolCallId = null;
-    toolName = null;
-    toolArgs = null;
-  };
   for await (const chunk of stream) {
     if (abortSignal?.aborted) {
       stopReason = "cancelled";
@@ -35737,28 +36142,30 @@ async function drainStream(stream, buffers, refresh, abortSignal) {
     if (chunk.message_type === "ping")
       continue;
     if (chunk.message_type === "tool_return_message") {
-      resetToolState();
+      if (chunk.tool_call_id) {
+        pendingApprovals.delete(chunk.tool_call_id);
+      }
     }
     if (chunk.message_type === "approval_request_message") {
-      approvalRequestId = chunk.id;
+      _approvalRequestId = chunk.id;
     }
-    if (chunk.message_type === "tool_call_message" || chunk.message_type === "approval_request_message") {
-      const toolCall = chunk.tool_call || (Array.isArray(chunk.tool_calls) && chunk.tool_calls.length > 0 ? chunk.tool_calls[0] : null);
-      if (toolCall?.tool_call_id) {
-        if (toolCallId && toolCall.tool_call_id !== toolCallId) {
-          resetToolState();
+    if (chunk.message_type === "approval_request_message") {
+      const toolCalls = Array.isArray(chunk.tool_calls) ? chunk.tool_calls : chunk.tool_call ? [chunk.tool_call] : [];
+      for (const toolCall of toolCalls) {
+        if (!toolCall?.tool_call_id)
+          continue;
+        const existing = pendingApprovals.get(toolCall.tool_call_id) || {
+          toolCallId: toolCall.tool_call_id,
+          toolName: "",
+          toolArgs: ""
+        };
+        if (toolCall.name) {
+          existing.toolName = toolCall.name;
         }
-        toolCallId = toolCall.tool_call_id;
-      }
-      if (toolCall?.name) {
-        toolName = toolCall.name;
-      }
-      if (toolCall?.arguments) {
-        if (toolArgs) {
-          toolArgs = toolArgs + toolCall.arguments;
-        } else {
-          toolArgs = toolCall.arguments;
+        if (toolCall.arguments) {
+          existing.toolArgs += toolCall.arguments;
         }
+        pendingApprovals.set(toolCall.tool_call_id, existing);
       }
     }
     onChunk(buffers, chunk);
@@ -35776,26 +36183,28 @@ async function drainStream(stream, buffers, refresh, abortSignal) {
   markCurrentLineAsFinished(buffers);
   queueMicrotask(refresh);
   let approval = null;
+  let approvals = [];
   if (stopReason === "requires_approval") {
-    if (!toolCallId || !toolName || !toolArgs || !approvalRequestId) {
-      console.error("[drainStream] Incomplete approval state at end of turn:", {
-        hasToolCallId: !!toolCallId,
-        hasToolName: !!toolName,
-        hasToolArgs: !!toolArgs,
-        hasApprovalRequestId: !!approvalRequestId
-      });
+    const allPending = Array.from(pendingApprovals.values());
+    approvals = allPending.filter((a) => a.toolCallId && a.toolName && a.toolArgs);
+    if (approvals.length === 0) {
+      console.error("[drainStream] No valid approvals collected despite requires_approval stop reason");
+      console.error("[drainStream] Pending approvals map:", allPending);
     } else {
-      approval = {
-        toolCallId,
-        toolName,
-        toolArgs
-      };
+      approval = approvals[0] || null;
     }
-    resetToolState();
-    approvalRequestId = null;
+    pendingApprovals.clear();
+    _approvalRequestId = null;
   }
   const apiDurationMs = performance.now() - startTime;
-  return { stopReason, approval, lastRunId, lastSeqId, apiDurationMs };
+  return {
+    stopReason,
+    approval,
+    approvals,
+    lastRunId,
+    lastSeqId,
+    apiDurationMs
+  };
 }
 async function drainStreamWithResume(stream, buffers, refresh, abortSignal) {
   const overallStartTime = performance.now();
@@ -35828,11 +36237,19 @@ async function getResumeData2(client, agent) {
     const messagesPage = await client.agents.messages.list(agent.id);
     const messages = messagesPage.items;
     if (!messages || messages.length === 0) {
-      return { pendingApproval: null, messageHistory: [] };
+      return {
+        pendingApproval: null,
+        pendingApprovals: [],
+        messageHistory: []
+      };
     }
     const cursorLastMessage = messages[messages.length - 1];
     if (!cursorLastMessage) {
-      return { pendingApproval: null, messageHistory: [] };
+      return {
+        pendingApproval: null,
+        pendingApprovals: [],
+        messageHistory: []
+      };
     }
     const inContextLastMessageId = agent.message_ids && agent.message_ids.length > 0 ? agent.message_ids[agent.message_ids.length - 1] : null;
     let messageToCheck = cursorLastMessage;
@@ -35853,18 +36270,17 @@ async function getResumeData2(client, agent) {
       }
     }
     let pendingApproval = null;
+    let pendingApprovals = [];
     if (messageToCheck.message_type === "approval_request_message") {
       const approvalMsg = messageToCheck;
       const toolCalls = Array.isArray(approvalMsg.tool_calls) ? approvalMsg.tool_calls : approvalMsg.tool_call ? [approvalMsg.tool_call] : [];
-      if (toolCalls.length > 0) {
-        const toolCall = toolCalls[0];
-        if (toolCall?.tool_call_id && toolCall.name && toolCall.arguments) {
-          pendingApproval = {
-            toolCallId: toolCall.tool_call_id,
-            toolName: toolCall.name,
-            toolArgs: toolCall.arguments
-          };
-        }
+      pendingApprovals = toolCalls.filter((tc) => tc?.tool_call_id && tc.name && tc.arguments).map((tc) => ({
+        toolCallId: tc.tool_call_id,
+        toolName: tc.name,
+        toolArgs: tc.arguments
+      }));
+      if (pendingApprovals.length > 0) {
+        pendingApproval = pendingApprovals[0] || null;
       }
     }
     const historyCount = Math.min(MESSAGE_HISTORY_LIMIT2, messages.length);
@@ -35872,21 +36288,97 @@ async function getResumeData2(client, agent) {
     if (messageHistory[0]?.message_type === "tool_return_message") {
       messageHistory = messageHistory.slice(1);
     }
-    return { pendingApproval, messageHistory };
+    return { pendingApproval, pendingApprovals, messageHistory };
   } catch (error) {
     console.error("Error getting resume data:", error);
-    return { pendingApproval: null, messageHistory: [] };
+    return { pendingApproval: null, pendingApprovals: [], messageHistory: [] };
   }
 }
 var MESSAGE_HISTORY_LIMIT2 = 15;
 
+// src/agent/approval-execution.ts
+var exports_approval_execution = {};
+__export(exports_approval_execution, {
+  executeApprovalBatch: () => executeApprovalBatch
+});
+async function executeApprovalBatch(decisions, onChunk2) {
+  const results = [];
+  for (const decision of decisions) {
+    if (decision.type === "approve") {
+      try {
+        const parsedArgs = typeof decision.approval.toolArgs === "string" ? JSON.parse(decision.approval.toolArgs) : decision.approval.toolArgs || {};
+        const toolResult = await executeTool(decision.approval.toolName, parsedArgs);
+        if (onChunk2) {
+          onChunk2({
+            message_type: "tool_return_message",
+            id: "dummy",
+            date: new Date().toISOString(),
+            tool_call_id: decision.approval.toolCallId,
+            tool_return: toolResult.toolReturn,
+            status: toolResult.status,
+            stdout: toolResult.stdout,
+            stderr: toolResult.stderr
+          });
+        }
+        results.push({
+          type: "tool",
+          tool_call_id: decision.approval.toolCallId,
+          tool_return: toolResult.toolReturn,
+          status: toolResult.status,
+          stdout: toolResult.stdout,
+          stderr: toolResult.stderr
+        });
+      } catch (e) {
+        const errorMessage = `Error executing tool: ${String(e)}`;
+        if (onChunk2) {
+          onChunk2({
+            message_type: "tool_return_message",
+            id: "dummy",
+            date: new Date().toISOString(),
+            tool_call_id: decision.approval.toolCallId,
+            tool_return: errorMessage,
+            status: "error"
+          });
+        }
+        results.push({
+          type: "tool",
+          tool_call_id: decision.approval.toolCallId,
+          tool_return: errorMessage,
+          status: "error"
+        });
+      }
+    } else {
+      if (onChunk2) {
+        onChunk2({
+          message_type: "tool_return_message",
+          id: "dummy",
+          date: new Date().toISOString(),
+          tool_call_id: decision.approval.toolCallId,
+          tool_return: `Error: request to call tool denied. User reason: ${decision.reason}`,
+          status: "error"
+        });
+      }
+      results.push({
+        type: "approval",
+        tool_call_id: decision.approval.toolCallId,
+        approve: false,
+        reason: decision.reason
+      });
+    }
+  }
+  return results;
+}
+var init_approval_execution = __esm(() => {
+  init_manager();
+});
+
 // src/headless.ts
 var exports_headless = {};
 __export(exports_headless, {
   handleHeadlessCommand: () => handleHeadlessCommand
 });
 import { parseArgs } from "node:util";
-async function handleHeadlessCommand(argv, model) {
+async function handleHeadlessCommand(argv, model, skillsDirectory) {
   const settings = settingsManager.getSettings();
   const { values, positionals } = parseArgs({
     args: argv,
@@ -35896,7 +36388,18 @@ async function handleHeadlessCommand(argv, model) {
       agent: { type: "string", short: "a" },
       model: { type: "string", short: "m" },
       prompt: { type: "boolean", short: "p" },
-      "output-format": { type: "string" }
+      "output-format": { type: "string" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" },
+      run: { type: "boolean" },
+      tools: { type: "string" },
+      allowedTools: { type: "string" },
+      disallowedTools: { type: "string" },
+      "permission-mode": { type: "string" },
+      yolo: { type: "boolean" },
+      skills: { type: "string" },
+      link: { type: "boolean" },
+      unlink: { type: "boolean" }
     },
     strict: false,
     allowPositionals: true
@@ -35929,7 +36432,7 @@ async function handleHeadlessCommand(argv, model) {
   }
   if (!agent && forceNew) {
     const updateArgs = getModelUpdateArgs(model);
-    agent = await createAgent(undefined, model, undefined, updateArgs, forceNew);
+    agent = await createAgent(undefined, model, undefined, updateArgs, forceNew, skillsDirectory, settings.parallelToolCalls, settings.enableSleeptime);
   }
   if (!agent) {
     await settingsManager.loadLocalProjectSettings();
@@ -35951,7 +36454,7 @@ async function handleHeadlessCommand(argv, model) {
   }
   if (!agent) {
     const updateArgs = getModelUpdateArgs(model);
-    agent = await createAgent(undefined, model, undefined, updateArgs);
+    agent = await createAgent(undefined, model, undefined, updateArgs, false, skillsDirectory, settings.parallelToolCalls, settings.enableSleeptime);
   }
   await settingsManager.loadLocalProjectSettings();
   settingsManager.updateLocalProjectSettings({ lastAgent: agent.id });
@@ -35977,58 +36480,57 @@ async function handleHeadlessCommand(argv, model) {
     while (true) {
       const freshAgent = await client.agents.retrieve(agent.id);
       const resume = await getResumeData3(client, freshAgent);
-      if (!resume.pendingApproval)
+      const pendingApprovals = resume.pendingApprovals || [];
+      if (pendingApprovals.length === 0)
         break;
-      const { toolCallId, toolName, toolArgs } = resume.pendingApproval;
-      const parsedArgs = safeJsonParseOr(toolArgs || "{}", {});
-      const permission = await checkToolPermission(toolName, parsedArgs);
-      let approvalInput;
-      if (permission.decision === "deny" || permission.decision === "ask") {
-        const denyReason = permission.decision === "ask" ? "Tool requires approval (headless mode)" : `Permission denied: ${permission.matchedRule || permission.reason}`;
-        approvalInput = {
-          type: "approval",
-          approval_request_id: toolCallId,
-          approve: false,
-          reason: denyReason
-        };
-      } else {
+      const decisions = [];
+      for (const currentApproval of pendingApprovals) {
+        const { toolCallId, toolName, toolArgs } = currentApproval;
+        const parsedArgs = safeJsonParseOr(toolArgs || "{}", {});
+        const permission = await checkToolPermission(toolName, parsedArgs);
+        if (permission.decision === "deny" || permission.decision === "ask") {
+          const denyReason = permission.decision === "ask" ? "Tool requires approval (headless mode)" : `Permission denied: ${permission.matchedRule || permission.reason}`;
+          decisions.push({
+            type: "deny",
+            approval: currentApproval,
+            reason: denyReason
+          });
+          continue;
+        }
         const { getToolSchema: getToolSchema2 } = await Promise.resolve().then(() => (init_manager(), exports_manager));
         const schema = getToolSchema2(toolName);
         const required = schema?.input_schema?.required || [];
         const missing = required.filter((key) => !(key in parsedArgs) || String(parsedArgs[key] ?? "").length === 0);
         if (missing.length > 0) {
-          approvalInput = {
-            type: "approval",
-            approval_request_id: toolCallId,
-            approve: false,
+          decisions.push({
+            type: "deny",
+            approval: currentApproval,
             reason: `Missing required parameter${missing.length > 1 ? "s" : ""}: ${missing.join(", ")}`
-          };
-        } else {
-          const toolResult = await executeTool(toolName, parsedArgs);
-          if (outputFormat === "stream-json") {
+          });
+          continue;
+        }
+        decisions.push({
+          type: "approve",
+          approval: currentApproval
+        });
+      }
+      const { executeApprovalBatch: executeApprovalBatch2 } = await Promise.resolve().then(() => (init_approval_execution(), exports_approval_execution));
+      if (outputFormat === "stream-json") {
+        for (const decision of decisions) {
+          if (decision.type === "approve") {
             console.log(JSON.stringify({
               type: "auto_approval",
-              tool_name: toolName,
-              tool_call_id: toolCallId,
-              reason: permission.reason,
-              matched_rule: permission.matchedRule
+              tool_name: decision.approval.toolName,
+              tool_call_id: decision.approval.toolCallId
             }));
           }
-          approvalInput = {
-            type: "approval",
-            approvals: [
-              {
-                type: "tool",
-                tool_call_id: toolCallId,
-                tool_return: toolResult.toolReturn,
-                status: toolResult.status,
-                stdout: toolResult.stdout,
-                stderr: toolResult.stderr
-              }
-            ]
-          };
         }
       }
+      const executedResults = await executeApprovalBatch2(decisions);
+      const approvalInput = {
+        type: "approval",
+        approvals: executedResults
+      };
       const approvalStream = await sendMessageStream(agent.id, [approvalInput]);
       if (outputFormat === "stream-json") {
         for await (const _ of approvalStream) {}
@@ -36038,17 +36540,23 @@ async function handleHeadlessCommand(argv, model) {
     }
   };
   await resolveAllPendingApprovals();
+  const { permissionMode: permissionMode3 } = await Promise.resolve().then(() => (init_mode(), exports_mode));
+  let messageContent = prompt;
+  if (permissionMode3.getMode() === "plan") {
+    const { PLAN_MODE_REMINDER: PLAN_MODE_REMINDER2 } = await Promise.resolve().then(() => (init_promptAssets(), exports_promptAssets));
+    messageContent = PLAN_MODE_REMINDER2 + prompt;
+  }
   let currentInput = [
     {
       role: "user",
-      content: [{ type: "text", text: prompt }]
+      content: [{ type: "text", text: messageContent }]
     }
   ];
   try {
     while (true) {
       const stream = await sendMessageStream(agent.id, currentInput);
       let stopReason;
-      let approval = null;
+      let approvals = [];
       let apiDurationMs;
       let lastRunId = null;
       if (outputFormat === "stream-json") {
@@ -36091,40 +36599,47 @@ async function handleHeadlessCommand(argv, model) {
             const chunkWithTools = chunk;
             const toolCalls = Array.isArray(chunkWithTools.tool_calls) ? chunkWithTools.tool_calls : chunkWithTools.tool_call ? [chunkWithTools.tool_call] : [];
             for (const toolCall of toolCalls) {
-              if (toolCall?.tool_call_id && toolCall?.name) {
-                const id = toolCall.tool_call_id;
-                _lastApprovalId = id;
-                const prev = approvalRequests.get(id);
-                const base2 = prev && prev.args !== "{}" ? prev.args : "";
-                const incomingArgs = toolCall.arguments && toolCall.arguments.trim().length > 0 ? `${base2}${toolCall.arguments}` : base2 || "{}";
-                approvalRequests.set(id, {
-                  toolName: toolCall.name,
-                  args: incomingArgs
-                });
-                approval = {
-                  toolCallId: id,
-                  toolName: toolCall.name,
-                  toolArgs: incomingArgs
-                };
-                if (!autoApprovalEmitted.has(id)) {
-                  const parsedArgs = safeJsonParseOr(incomingArgs || "{}", null);
-                  const permission = await checkToolPermission(toolCall.name, parsedArgs || {});
-                  if (permission.decision === "allow" && parsedArgs) {
-                    const { getToolSchema: getToolSchema2 } = await Promise.resolve().then(() => (init_manager(), exports_manager));
-                    const schema = getToolSchema2(toolCall.name);
-                    const required = schema?.input_schema?.required || [];
-                    const missing = required.filter((key) => !(key in parsedArgs) || String(parsedArgs[key] ?? "").length === 0);
-                    if (missing.length === 0) {
-                      shouldOutputChunk = false;
-                      console.log(JSON.stringify({
-                        type: "auto_approval",
-                        tool_name: toolCall.name,
-                        tool_call_id: id,
-                        reason: permission.reason,
-                        matched_rule: permission.matchedRule
-                      }));
-                      autoApprovalEmitted.add(id);
-                    }
+              const id = toolCall?.tool_call_id;
+              if (!id)
+                continue;
+              _lastApprovalId = id;
+              const prev = approvalRequests.get(id);
+              const base2 = prev?.args ?? "";
+              const incomingArgs = toolCall?.arguments && toolCall.arguments.trim().length > 0 ? base2 + toolCall.arguments : base2;
+              const nextName = toolCall?.name || prev?.toolName || "";
+              approvalRequests.set(id, {
+                toolName: nextName,
+                args: incomingArgs
+              });
+              const existingIndex = approvals.findIndex((a) => a.toolCallId === id);
+              const approvalObj = {
+                toolCallId: id,
+                toolName: nextName,
+                toolArgs: incomingArgs
+              };
+              if (existingIndex >= 0) {
+                approvals[existingIndex] = approvalObj;
+              } else {
+                approvals.push(approvalObj);
+              }
+              if (!autoApprovalEmitted.has(id) && nextName) {
+                const parsedArgs = safeJsonParseOr(incomingArgs || "{}", null);
+                const permission = await checkToolPermission(nextName, parsedArgs || {});
+                if (permission.decision === "allow" && parsedArgs) {
+                  const { getToolSchema: getToolSchema2 } = await Promise.resolve().then(() => (init_manager(), exports_manager));
+                  const schema = getToolSchema2(nextName);
+                  const required = schema?.input_schema?.required || [];
+                  const missing = required.filter((key) => !(key in parsedArgs) || String(parsedArgs[key] ?? "").length === 0);
+                  if (missing.length === 0) {
+                    shouldOutputChunk = false;
+                    console.log(JSON.stringify({
+                      type: "auto_approval",
+                      tool_name: nextName,
+                      tool_call_id: id,
+                      reason: permission.reason,
+                      matched_rule: permission.matchedRule
+                    }));
+                    autoApprovalEmitted.add(id);
                   }
                 }
               }
@@ -36150,7 +36665,7 @@ async function handleHeadlessCommand(argv, model) {
       } else {
         const result = await drainStreamWithResume(stream, buffers, () => {});
         stopReason = result.stopReason;
-        approval = result.approval || null;
+        approvals = result.approvals || [];
         apiDurationMs = result.apiDurationMs;
         lastRunId = result.lastRunId || null;
       }
@@ -36159,65 +36674,55 @@ async function handleHeadlessCommand(argv, model) {
         break;
       }
       if (stopReason === "requires_approval") {
-        if (!approval) {
-          console.error("Unexpected null approval");
+        if (approvals.length === 0) {
+          console.error("Unexpected empty approvals array");
           process.exit(1);
         }
-        const { toolCallId, toolName, toolArgs } = approval;
-        const parsedArgs = safeJsonParseOr(toolArgs, {});
-        const permission = await checkToolPermission(toolName, parsedArgs);
-        if (permission.decision === "deny") {
-          const denyReason = `Permission denied: ${permission.matchedRule || permission.reason}`;
-          currentInput = [
-            {
-              type: "approval",
-              approval_request_id: toolCallId,
-              approve: false,
+        const decisions = [];
+        for (const currentApproval of approvals) {
+          const { toolCallId, toolName, toolArgs } = currentApproval;
+          const parsedArgs = safeJsonParseOr(toolArgs, {});
+          const permission = await checkToolPermission(toolName, parsedArgs);
+          if (permission.decision === "deny") {
+            const denyReason = `Permission denied: ${permission.matchedRule || permission.reason}`;
+            decisions.push({
+              type: "deny",
+              approval: currentApproval,
               reason: denyReason
-            }
-          ];
-          continue;
-        }
-        if (permission.decision === "ask") {
-          currentInput = [
-            {
-              type: "approval",
-              approval_request_id: toolCallId,
-              approve: false,
+            });
+            continue;
+          }
+          if (permission.decision === "ask") {
+            decisions.push({
+              type: "deny",
+              approval: currentApproval,
               reason: "Tool requires approval (headless mode)"
-            }
-          ];
-          continue;
-        }
-        const { getToolSchema: getToolSchema2 } = await Promise.resolve().then(() => (init_manager(), exports_manager));
-        const schema = getToolSchema2(toolName);
-        const required = schema?.input_schema?.required || [];
-        const missing = required.filter((key) => !(key in parsedArgs) || String(parsedArgs[key] ?? "").length === 0);
-        if (missing.length > 0) {
-          currentInput = [
-            {
-              type: "approval",
-              approval_request_id: toolCallId,
-              approve: false,
+            });
+            continue;
+          }
+          const { getToolSchema: getToolSchema2 } = await Promise.resolve().then(() => (init_manager(), exports_manager));
+          const schema = getToolSchema2(toolName);
+          const required = schema?.input_schema?.required || [];
+          const missing = required.filter((key) => !(key in parsedArgs) || String(parsedArgs[key] ?? "").length === 0);
+          if (missing.length > 0) {
+            decisions.push({
+              type: "deny",
+              approval: currentApproval,
               reason: `Missing required parameter${missing.length > 1 ? "s" : ""}: ${missing.join(", ")}`
-            }
-          ];
-          continue;
+            });
+            continue;
+          }
+          decisions.push({
+            type: "approve",
+            approval: currentApproval
+          });
         }
-        const toolResult = await executeTool(toolName, parsedArgs);
+        const { executeApprovalBatch: executeApprovalBatch2 } = await Promise.resolve().then(() => (init_approval_execution(), exports_approval_execution));
+        const executedResults = await executeApprovalBatch2(decisions);
         currentInput = [
           {
             type: "approval",
-            approvals: [
-              {
-                type: "tool",
-                tool_call_id: toolCallId,
-                tool_return: toolResult.toolReturn,
-                status: toolResult.status,
-                stdout: toolResult.stdout,
-                stderr: toolResult.stderr
-              }
-            ]
+            approvals: executedResults
           }
         ];
         continue;
@@ -37457,15 +37962,15 @@ var init_colors = __esm(() => {
       header: brandColors.primaryAccent
     },
     code: {
-      inline: brandColors.statusSuccess
+      inline: "green"
     },
     link: {
-      text: brandColors.primaryAccent,
-      url: brandColors.primaryAccent
+      text: "cyan",
+      url: "blue"
     },
     heading: {
-      primary: brandColors.primaryAccent,
-      secondary: brandColors.blue
+      primary: "cyan",
+      secondary: "blue"
     },
     status: {
       error: brandColors.statusError,
@@ -38114,7 +38619,7 @@ var init_build4 = __esm(async () => {
 
 // src/cli/helpers/clipboard.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync2, statSync } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync2, statSync } from "node:fs";
 import { basename as basename3, extname, isAbsolute as isAbsolute7, resolve as resolve7 } from "node:path";
 function countLines2(text) {
   return (text.match(/\r\n|\r|\n/g) || []).length + 1;
@@ -38165,7 +38670,7 @@ function translatePasteForImages(paste) {
       if (!isAbsolute7(filePath))
         filePath = resolve7(process.cwd(), filePath);
       const ext2 = extname(filePath || "").toLowerCase();
-      if (IMAGE_EXTS.has(ext2) && existsSync3(filePath) && statSync(filePath).isFile()) {
+      if (IMAGE_EXTS.has(ext2) && existsSync4(filePath) && statSync(filePath).isFile()) {
         const buf = readFileSync2(filePath);
         const b64 = buf.toString("base64");
         const mt = ext2 === ".png" ? "image/png" : ext2 === ".jpg" || ext2 === ".jpeg" ? "image/jpeg" : ext2 === ".gif" ? "image/gif" : ext2 === ".webp" ? "image/webp" : ext2 === ".bmp" ? "image/bmp" : ext2 === ".svg" ? "image/svg+xml" : ext2 === ".tif" || ext2 === ".tiff" ? "image/tiff" : ext2 === ".heic" ? "image/heic" : ext2 === ".heif" ? "image/heif" : ext2 === ".avif" ? "image/avif" : "application/octet-stream";
@@ -38640,34 +39145,46 @@ var init_ApprovalDialogRich = __esm(async () => {
   });
   OptionsRenderer.displayName = "OptionsRenderer";
   ApprovalDialog = import_react28.memo(function ApprovalDialog2({
-    approvalRequest,
-    approvalContext,
-    onApprove,
+    approvals,
+    approvalContexts,
+    progress,
+    totalTools,
+    isExecuting,
+    onApproveAll,
     onApproveAlways,
-    onDeny
+    onDenyAll
   }) {
     const [selectedOption, setSelectedOption] = import_react28.useState(0);
     const [isEnteringReason, setIsEnteringReason] = import_react28.useState(false);
     const [denyReason, setDenyReason] = import_react28.useState("");
+    const approvalRequest = approvals[0];
+    const approvalContext = approvalContexts[0] || null;
+    import_react28.useEffect(() => {
+      setSelectedOption(0);
+      setIsEnteringReason(false);
+      setDenyReason("");
+    }, [progress?.current]);
     const options = import_react28.useMemo(() => {
-      const opts = [{ label: "Yes, just this once", action: onApprove }];
+      const approvalLabel = progress && progress.total > 1 ? "Yes, approve this tool" : "Yes, just this once";
+      const opts = [{ label: approvalLabel, action: onApproveAll }];
       if (approvalContext?.allowPersistence) {
         opts.push({
           label: approvalContext.approveAlwaysText,
           action: () => onApproveAlways(approvalContext.defaultScope === "user" ? "session" : approvalContext.defaultScope)
         });
       }
+      const denyLabel = progress && progress.total > 1 ? "No, deny this tool (esc)" : "No, and tell Letta what to do differently (esc)";
       opts.push({
-        label: "No, and tell Letta what to do differently (esc)",
+        label: denyLabel,
         action: () => {}
       });
       return opts;
-    }, [approvalContext, onApprove, onApproveAlways]);
+    }, [progress, approvalContext, onApproveAll, onApproveAlways]);
     use_input_default((_input, key) => {
       if (isEnteringReason) {
         if (key.return) {
           const resolvedReason = resolvePlaceholders(denyReason);
-          onDeny(resolvedReason);
+          onDenyAll(resolvedReason);
         } else if (key.escape) {
           setIsEnteringReason(false);
           setDenyReason("");
@@ -38707,10 +39224,10 @@ var init_ApprovalDialogRich = __esm(async () => {
     });
     let parsedArgs = null;
     try {
-      parsedArgs = JSON.parse(approvalRequest.toolArgs);
+      parsedArgs = approvalRequest?.toolArgs ? JSON.parse(approvalRequest.toolArgs) : null;
     } catch {}
     const precomputedDiff = import_react28.useMemo(() => {
-      if (!parsedArgs)
+      if (!parsedArgs || !approvalRequest)
         return null;
       const toolName = approvalRequest.toolName.toLowerCase();
       if (toolName === "write") {
@@ -38739,6 +39256,9 @@ var init_ApprovalDialogRich = __esm(async () => {
       }
       return null;
     }, [approvalRequest, parsedArgs]);
+    if (!approvalRequest) {
+      return null;
+    }
     const headerLabel = getHeaderLabel(approvalRequest.toolName);
     if (isEnteringReason) {
       return /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Box_default, {
@@ -38791,7 +39311,22 @@ var init_ApprovalDialogRich = __esm(async () => {
             /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
               bold: true,
               color: colors.approval.header,
-              children: headerLabel
+              children: progress && progress.total > 1 ? `${progress.total} tools require approval${totalTools && totalTools > progress.total ? ` (${totalTools} total)` : ""}` : headerLabel
+            }, undefined, false, undefined, this),
+            progress && progress.total > 1 && /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
+              dimColor: true,
+              children: [
+                "(",
+                progress.current - 1,
+                " reviewed,",
+                " ",
+                progress.total - (progress.current - 1),
+                " remaining)"
+              ]
+            }, undefined, true, undefined, this),
+            isExecuting && progress && progress.total > 1 && /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
+              dimColor: true,
+              children: "Executing tool..."
             }, undefined, false, undefined, this),
             /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Box_default, {
               height: 1
@@ -42207,6 +42742,24 @@ var init_registry = __esm(() => {
       handler: () => {
         return "Clearing credentials...";
       }
+    },
+    "/link": {
+      desc: "Attach Letta Code tools to current agent",
+      handler: () => {
+        return "Attaching tools...";
+      }
+    },
+    "/unlink": {
+      desc: "Remove Letta Code tools from current agent",
+      handler: () => {
+        return "Removing tools...";
+      }
+    },
+    "/rename": {
+      desc: "Rename the current agent",
+      handler: () => {
+        return "Renaming agent...";
+      }
     }
   };
 });
@@ -42215,12 +42768,14 @@ var init_registry = __esm(() => {
 function CommandPreview({
   currentInput,
   agentId,
+  agentName,
   serverUrl
 }) {
   if (!currentInput.startsWith("/")) {
     return null;
   }
-  const showAgentUrl = agentId && agentId !== "loading" && serverUrl?.includes("api.letta.com");
+  const isCloudUser = serverUrl?.includes("api.letta.com");
+  const showBottomBar = agentId && agentId !== "loading";
   return /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
     flexDirection: "column",
     borderStyle: "round",
@@ -42228,31 +42783,46 @@ function CommandPreview({
     paddingX: 1,
     children: [
       commandList.map((item) => /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
-        justifyContent: "space-between",
-        width: 40,
-        children: [
-          /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
-            children: item.cmd
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
-            dimColor: true,
-            children: item.desc
-          }, undefined, false, undefined, this)
-        ]
-      }, item.cmd, true, undefined, this)),
-      showAgentUrl && /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
+        children: /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
+          children: [
+            item.cmd.padEnd(15),
+            " ",
+            /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
+              dimColor: true,
+              children: item.desc
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      }, item.cmd, false, undefined, this)),
+      showBottomBar && /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Box_default, {
         marginTop: 1,
         paddingTop: 1,
         borderTop: true,
         borderColor: "gray",
-        children: /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(dist_default4, {
-          url: `https://app.letta.com/agents/${agentId}`,
-          children: /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
+        flexDirection: "column",
+        children: [
+          agentName && /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
             dimColor: true,
-            children: "View agent:"
-          }, undefined, false, undefined, this)
-        }, undefined, false, undefined, this)
-      }, undefined, false, undefined, this)
+            children: [
+              "Agent: ",
+              agentName
+            ]
+          }, undefined, true, undefined, this),
+          isCloudUser ? /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(dist_default4, {
+            url: `https://app.letta.com/agents/${agentId}`,
+            children: /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
+              dimColor: true,
+              children: "View agent in ADE"
+            }, undefined, false, undefined, this)
+          }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime11.jsxDEV(Text, {
+            dimColor: true,
+            children: [
+              "Connected to agent located at ",
+              serverUrl
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
     ]
   }, undefined, true, undefined, this);
 }
@@ -42273,7 +42843,7 @@ var init_CommandPreview = __esm(async () => {
 
 // src/cli/helpers/fileSearch.ts
 import { readdirSync, statSync as statSync2 } from "node:fs";
-import { join as join6, resolve as resolve8 } from "node:path";
+import { join as join8, resolve as resolve8 } from "node:path";
 function searchDirectoryRecursive(dir, pattern, maxResults = 200, results = []) {
   if (results.length >= maxResults) {
     return results;
@@ -42285,7 +42855,7 @@ function searchDirectoryRecursive(dir, pattern, maxResults = 200, results = [])
         continue;
       }
       try {
-        const fullPath = join6(dir, entry);
+        const fullPath = join8(dir, entry);
         const stats = statSync2(fullPath);
         const matches = pattern.length === 0 || entry.toLowerCase().includes(pattern.toLowerCase());
         if (matches) {
@@ -42334,7 +42904,7 @@ async function searchFiles(query, deep = false) {
       const matchingEntries = searchPattern.length === 0 ? entries : entries.filter((entry) => entry.toLowerCase().includes(searchPattern.toLowerCase()));
       for (const entry of matchingEntries.slice(0, 50)) {
         try {
-          const fullPath = join6(searchDir, entry);
+          const fullPath = join8(searchDir, entry);
           const stats = statSync2(fullPath);
           const relativePath = fullPath.startsWith(process.cwd()) ? fullPath.slice(process.cwd().length + 1) : fullPath;
           results.push({
@@ -42556,6 +43126,7 @@ function InputAssist({
   onFileSelect,
   onAutocompleteActiveChange,
   agentId,
+  agentName,
   serverUrl
 }) {
   if (currentInput.includes("@")) {
@@ -42570,6 +43141,7 @@ function InputAssist({
     return /* @__PURE__ */ jsx_dev_runtime13.jsxDEV(CommandPreview, {
       currentInput,
       agentId,
+      agentName,
       serverUrl
     }, undefined, false, undefined, this);
   }
@@ -42622,7 +43194,8 @@ function Input({
   onExit,
   onInterrupt,
   interruptRequested = false,
-  agentId
+  agentId,
+  agentName
 }) {
   const [value, setValue] = import_react34.useState("");
   const [escapePressed, setEscapePressed] = import_react34.useState(false);
@@ -42969,6 +43542,7 @@ function Input({
             onFileSelect: handleFileSelect,
             onAutocompleteActiveChange: setIsAutocompleteActive,
             agentId,
+            agentName,
             serverUrl
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime15.jsxDEV(Box_default, {
@@ -43654,7 +44228,7 @@ var init_ToolCallMessageRich = __esm(async () => {
           ]
         }, undefined, true, undefined, this);
       }
-      const displayResultText = clipToolReturn(line.resultText);
+      const displayResultText = clipToolReturn(line.resultText).replace(/\n+$/, "");
       const isTodoTool = rawName === "todo_write" || rawName === "TodoWrite" || displayName === "TODO";
       if (isTodoTool && line.resultOk !== false && line.argsText) {
         try {
@@ -43853,6 +44427,12 @@ function WelcomeScreen({
     if (loadingState === "upserting") {
       return "Upserting tools...";
     }
+    if (loadingState === "linking") {
+      return "Attaching Letta Code tools...";
+    }
+    if (loadingState === "unlinking") {
+      return "Removing Letta Code tools...";
+    }
     if (loadingState === "checking") {
       return "Checking for pending approvals...";
     }
@@ -44016,42 +44596,63 @@ function backfillBuffers(buffers, history) {
       case "tool_call_message":
       case "approval_request_message": {
         const toolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls : msg.tool_call ? [msg.tool_call] : [];
-        if (toolCalls.length > 0 && toolCalls[0]?.tool_call_id) {
-          const toolCall = toolCalls[0];
+        for (let i = 0;i < toolCalls.length; i++) {
+          const toolCall = toolCalls[i];
+          if (!toolCall?.tool_call_id)
+            continue;
           const toolCallId = toolCall.tool_call_id;
           if (!toolCallId || !toolCall.name || !toolCall.arguments)
-            break;
-          const exists2 = buffers.byId.has(lineId);
-          buffers.byId.set(lineId, {
+            continue;
+          let uniqueLineId = lineId;
+          if (buffers.byId.has(lineId)) {
+            const existing = buffers.byId.get(lineId);
+            if (existing && existing.kind === "tool_call") {
+              uniqueLineId = `${lineId}-${toolCallId.slice(-8)}`;
+            }
+          }
+          const exists2 = buffers.byId.has(uniqueLineId);
+          buffers.byId.set(uniqueLineId, {
             kind: "tool_call",
-            id: lineId,
+            id: uniqueLineId,
             toolCallId,
             name: toolCall.name,
             argsText: toolCall.arguments,
             phase: "ready"
           });
           if (!exists2)
-            buffers.order.push(lineId);
-          buffers.toolCallIdToLineId.set(toolCallId, lineId);
+            buffers.order.push(uniqueLineId);
+          buffers.toolCallIdToLineId.set(toolCallId, uniqueLineId);
         }
         break;
       }
       case "tool_return_message": {
-        const toolCallId = msg.tool_call_id;
-        if (!toolCallId)
-          break;
-        const toolCallLineId = buffers.toolCallIdToLineId.get(toolCallId);
-        if (!toolCallLineId)
-          break;
-        const existingLine = buffers.byId.get(toolCallLineId);
-        if (!existingLine || existingLine.kind !== "tool_call")
-          break;
-        buffers.byId.set(toolCallLineId, {
-          ...existingLine,
-          resultText: msg.tool_return,
-          resultOk: msg.status === "success",
-          phase: "finished"
-        });
+        const toolReturns = Array.isArray(msg.tool_returns) && msg.tool_returns.length > 0 ? msg.tool_returns : msg.tool_call_id ? [
+          {
+            tool_call_id: msg.tool_call_id,
+            status: msg.status,
+            func_response: msg.tool_return,
+            stdout: msg.stdout,
+            stderr: msg.stderr
+          }
+        ] : [];
+        for (const toolReturn of toolReturns) {
+          const toolCallId = toolReturn.tool_call_id;
+          if (!toolCallId)
+            continue;
+          const toolCallLineId = buffers.toolCallIdToLineId.get(toolCallId);
+          if (!toolCallLineId)
+            continue;
+          const existingLine = buffers.byId.get(toolCallLineId);
+          if (!existingLine || existingLine.kind !== "tool_call")
+            continue;
+          const resultText = ("func_response" in toolReturn ? toolReturn.func_response : undefined) || ("tool_return" in toolReturn ? toolReturn.tool_return : undefined) || "";
+          buffers.byId.set(toolCallLineId, {
+            ...existingLine,
+            resultText,
+            resultOk: toolReturn.status === "success",
+            phase: "finished"
+          });
+        }
         break;
       }
       default:
@@ -44125,17 +44726,23 @@ function App2({
   loadingState = "ready",
   continueSession = false,
   startupApproval = null,
+  startupApprovals = [],
   messageHistory = [],
   tokenStreaming = true
 }) {
   const [streaming, setStreaming] = import_react40.useState(false);
   const [interruptRequested, setInterruptRequested] = import_react40.useState(false);
   const [commandRunning, setCommandRunning] = import_react40.useState(false);
-  const [pendingApproval, setPendingApproval] = import_react40.useState(null);
-  const [approvalContext, setApprovalContext] = import_react40.useState(null);
+  const [pendingApprovals, setPendingApprovals] = import_react40.useState([]);
+  const [approvalContexts, setApprovalContexts] = import_react40.useState([]);
+  const [approvalResults, setApprovalResults] = import_react40.useState([]);
+  const [isExecutingTool, setIsExecutingTool] = import_react40.useState(false);
+  const [autoHandledResults, setAutoHandledResults] = import_react40.useState([]);
+  const [autoDeniedApprovals, setAutoDeniedApprovals] = import_react40.useState([]);
   const [planApprovalPending, setPlanApprovalPending] = import_react40.useState(null);
   const [modelSelectorOpen, setModelSelectorOpen] = import_react40.useState(false);
   const [llmConfig, setLlmConfig] = import_react40.useState(null);
+  const [agentName, setAgentName] = import_react40.useState(null);
   const [tokenStreamingEnabled, setTokenStreamingEnabled] = import_react40.useState(tokenStreaming);
   const [tokenCount, setTokenCount] = import_react40.useState(0);
   const [thinkingMessage, setThinkingMessage] = import_react40.useState(getRandomThinkingMessage());
@@ -44207,30 +44814,34 @@ function App2({
     }
   }, [refreshDerived]);
   import_react40.useEffect(() => {
-    if (loadingState === "ready" && startupApproval) {
-      if (startupApproval.toolName === "ExitPlanMode") {
-        const parsedArgs = safeJsonParseOr(startupApproval.toolArgs, {});
+    const approvals = startupApprovals?.length > 0 ? startupApprovals : startupApproval ? [startupApproval] : [];
+    if (loadingState === "ready" && approvals.length > 0) {
+      const planApproval = approvals.find((a) => a.toolName === "ExitPlanMode");
+      if (planApproval) {
+        const parsedArgs = safeJsonParseOr(planApproval.toolArgs, {});
         const plan = parsedArgs.plan || "No plan provided";
         setPlanApprovalPending({
           plan,
-          toolCallId: startupApproval.toolCallId,
-          toolArgs: startupApproval.toolArgs
+          toolCallId: planApproval.toolCallId,
+          toolArgs: planApproval.toolArgs
         });
       } else {
-        setPendingApproval(startupApproval);
-        const analyzeStartupApproval = async () => {
+        setPendingApprovals(approvals);
+        const analyzeStartupApprovals = async () => {
           try {
-            const parsedArgs = safeJsonParseOr(startupApproval.toolArgs, {});
-            const context = await analyzeToolApproval(startupApproval.toolName, parsedArgs);
-            setApprovalContext(context);
+            const contexts = await Promise.all(approvals.map(async (approval) => {
+              const parsedArgs = safeJsonParseOr(approval.toolArgs, {});
+              return await analyzeToolApproval(approval.toolName, parsedArgs);
+            }));
+            setApprovalContexts(contexts);
           } catch (error) {
-            console.error("Failed to analyze startup approval:", error);
+            console.error("Failed to analyze startup approvals:", error);
           }
         };
-        analyzeStartupApproval();
+        analyzeStartupApprovals();
       }
     }
-  }, [loadingState, startupApproval]);
+  }, [loadingState, startupApproval, startupApprovals]);
   import_react40.useEffect(() => {
     if (loadingState === "ready" && messageHistory.length > 0 && !hasBackfilledRef.current) {
       hasBackfilledRef.current = true;
@@ -44270,8 +44881,9 @@ function App2({
           const client = await getClient3();
           const agent = await client.agents.retrieve(agentId);
           setLlmConfig(agent.llm_config);
+          setAgentName(agent.name);
         } catch (error) {
-          console.error("Error fetching llm_config:", error);
+          console.error("Error fetching agent config:", error);
         }
       };
       fetchConfig();
@@ -44288,13 +44900,13 @@ function App2({
     refreshDerived();
   }, [refreshDerived]);
   const processConversation = import_react40.useCallback(async (initialInput) => {
-    let currentInput = initialInput;
+    const currentInput = initialInput;
     try {
       setStreaming(true);
       abortControllerRef.current = new AbortController;
       while (true) {
         const stream = await sendMessageStream(agentId, currentInput);
-        const { stopReason, approval, apiDurationMs, lastRunId } = await drainStreamWithResume(stream, buffersRef.current, refreshDerivedThrottled, abortControllerRef.current.signal);
+        const { stopReason, approval, approvals, apiDurationMs, lastRunId } = await drainStreamWithResume(stream, buffersRef.current, refreshDerivedThrottled, abortControllerRef.current.signal);
         sessionStatsRef.current.endTurn(apiDurationMs);
         sessionStatsRef.current.updateUsageFromBuffers(buffersRef.current);
         refreshDerived();
@@ -44308,69 +44920,91 @@ function App2({
           return;
         }
         if (stopReason === "requires_approval") {
-          if (!approval) {
-            appendError(`Unexpected null approval with stop reason: ${stopReason}`);
+          const approvalsToProcess = approvals && approvals.length > 0 ? approvals : approval ? [approval] : [];
+          if (approvalsToProcess.length === 0) {
+            appendError(`Unexpected empty approvals with stop reason: ${stopReason}`);
             setStreaming(false);
             return;
           }
-          const { toolCallId, toolName, toolArgs } = approval;
-          if (toolName === "ExitPlanMode") {
-            const parsedArgs2 = safeJsonParseOr(toolArgs, {});
-            const plan = parsedArgs2.plan || "No plan provided";
-            setPlanApprovalPending({ plan, toolCallId, toolArgs });
+          const planApproval = approvalsToProcess.find((a) => a.toolName === "ExitPlanMode");
+          if (planApproval) {
+            const parsedArgs = safeJsonParseOr(planApproval.toolArgs, {});
+            const plan = parsedArgs.plan || "No plan provided";
+            setPlanApprovalPending({
+              plan,
+              toolCallId: planApproval.toolCallId,
+              toolArgs: planApproval.toolArgs
+            });
             setStreaming(false);
             return;
           }
-          const parsedArgs = safeJsonParseOr(toolArgs, {});
-          const permission = await checkToolPermission(toolName, parsedArgs);
-          if (permission.decision === "deny") {
-            const denyReason = `Permission denied by rule: ${permission.matchedRule || permission.reason}`;
+          const approvalResults2 = await Promise.all(approvalsToProcess.map(async (approvalItem) => {
+            const parsedArgs = safeJsonParseOr(approvalItem.toolArgs, {});
+            const permission = await checkToolPermission(approvalItem.toolName, parsedArgs);
+            const context = await analyzeToolApproval(approvalItem.toolName, parsedArgs);
+            return { approval: approvalItem, permission, context };
+          }));
+          const needsUserInput = approvalResults2.filter((ac) => ac.permission.decision === "ask");
+          const autoDenied = approvalResults2.filter((ac) => ac.permission.decision === "deny");
+          const autoAllowed = approvalResults2.filter((ac) => ac.permission.decision === "allow");
+          const autoAllowedResults = await Promise.all(autoAllowed.map(async (ac) => {
+            const parsedArgs = safeJsonParseOr(ac.approval.toolArgs, {});
+            const result = await executeTool(ac.approval.toolName, parsedArgs);
+            onChunk(buffersRef.current, {
+              message_type: "tool_return_message",
+              id: "dummy",
+              date: new Date().toISOString(),
+              tool_call_id: ac.approval.toolCallId,
+              tool_return: result.toolReturn,
+              status: result.status,
+              stdout: result.stdout,
+              stderr: result.stderr
+            });
+            return {
+              toolCallId: ac.approval.toolCallId,
+              result
+            };
+          }));
+          const autoDeniedResults = autoDenied.map((ac) => ({
+            approval: ac.approval,
+            reason: `Permission denied by rule: ${ac.permission.matchedRule || ac.permission.reason}`
+          }));
+          if (needsUserInput.length === 0) {
             setThinkingMessage(getRandomThinkingMessage());
+            refreshDerived();
+            const allResults = [
+              ...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
+              })),
+              ...autoDeniedResults.map((ad) => ({
+                type: "tool",
+                tool_call_id: ad.approval.toolCallId,
+                tool_return: JSON.stringify({
+                  status: "error",
+                  message: ad.reason
+                }),
+                status: "error"
+              }))
+            ];
             await processConversation([
               {
                 type: "approval",
-                approval_request_id: toolCallId,
-                approve: false,
-                reason: denyReason
+                approvals: allResults
               }
             ]);
             return;
           }
-          if (permission.decision === "ask") {
-            const context = await analyzeToolApproval(toolName, parsedArgs);
-            setPendingApproval({ toolCallId, toolName, toolArgs });
-            setApprovalContext(context);
-            setStreaming(false);
-            return;
-          }
-          const toolResult = await executeTool(toolName, parsedArgs);
-          onChunk(buffersRef.current, {
-            message_type: "tool_return_message",
-            id: "dummy",
-            date: new Date().toISOString(),
-            tool_call_id: toolCallId,
-            tool_return: toolResult.toolReturn,
-            status: toolResult.status,
-            stdout: toolResult.stdout,
-            stderr: toolResult.stderr
-          });
-          refreshDerived();
-          currentInput = [
-            {
-              type: "approval",
-              approvals: [
-                {
-                  type: "tool",
-                  tool_call_id: toolCallId,
-                  tool_return: toolResult.toolReturn,
-                  status: toolResult.status,
-                  stdout: toolResult.stdout,
-                  stderr: toolResult.stderr
-                }
-              ]
-            }
-          ];
-          continue;
+          setPendingApprovals(needsUserInput.map((ac) => ac.approval));
+          setApprovalContexts(needsUserInput.map((ac) => ac.context));
+          setAutoHandledResults(autoAllowedResults);
+          setAutoDeniedApprovals(autoDeniedResults);
+          setStreaming(false);
+          return;
         }
         markIncompleteToolsAsCancelled(buffersRef.current);
         let errorDetails = `Unexpected stop reason: ${stopReason}`;
@@ -44598,6 +45232,138 @@ ${detail}` : "";
         }
         return { submitted: true };
       }
+      if (msg.trim() === "/link") {
+        const cmdId2 = uid("cmd");
+        buffersRef.current.byId.set(cmdId2, {
+          kind: "command",
+          id: cmdId2,
+          input: msg,
+          output: "Attaching Letta Code tools to agent...",
+          phase: "running"
+        });
+        buffersRef.current.order.push(cmdId2);
+        refreshDerived();
+        setCommandRunning(true);
+        try {
+          const result = await linkToolsToAgent(agentId);
+          buffersRef.current.byId.set(cmdId2, {
+            kind: "command",
+            id: cmdId2,
+            input: msg,
+            output: result.message,
+            phase: "finished",
+            success: result.success
+          });
+          refreshDerived();
+        } catch (error) {
+          buffersRef.current.byId.set(cmdId2, {
+            kind: "command",
+            id: cmdId2,
+            input: msg,
+            output: `Failed: ${error instanceof Error ? error.message : String(error)}`,
+            phase: "finished",
+            success: false
+          });
+          refreshDerived();
+        } finally {
+          setCommandRunning(false);
+        }
+        return { submitted: true };
+      }
+      if (msg.trim() === "/unlink") {
+        const cmdId2 = uid("cmd");
+        buffersRef.current.byId.set(cmdId2, {
+          kind: "command",
+          id: cmdId2,
+          input: msg,
+          output: "Removing Letta Code tools from agent...",
+          phase: "running"
+        });
+        buffersRef.current.order.push(cmdId2);
+        refreshDerived();
+        setCommandRunning(true);
+        try {
+          const result = await unlinkToolsFromAgent(agentId);
+          buffersRef.current.byId.set(cmdId2, {
+            kind: "command",
+            id: cmdId2,
+            input: msg,
+            output: result.message,
+            phase: "finished",
+            success: result.success
+          });
+          refreshDerived();
+        } catch (error) {
+          buffersRef.current.byId.set(cmdId2, {
+            kind: "command",
+            id: cmdId2,
+            input: msg,
+            output: `Failed: ${error instanceof Error ? error.message : String(error)}`,
+            phase: "finished",
+            success: false
+          });
+          refreshDerived();
+        } finally {
+          setCommandRunning(false);
+        }
+        return { submitted: true };
+      }
+      if (msg.trim().startsWith("/rename")) {
+        const parts = msg.trim().split(/\s+/);
+        const newName = parts.slice(1).join(" ");
+        if (!newName) {
+          const cmdId3 = uid("cmd");
+          buffersRef.current.byId.set(cmdId3, {
+            kind: "command",
+            id: cmdId3,
+            input: msg,
+            output: "Please provide a new name: /rename <name>",
+            phase: "finished",
+            success: false
+          });
+          buffersRef.current.order.push(cmdId3);
+          refreshDerived();
+          return { submitted: true };
+        }
+        const cmdId2 = uid("cmd");
+        buffersRef.current.byId.set(cmdId2, {
+          kind: "command",
+          id: cmdId2,
+          input: msg,
+          output: `Renaming agent to "${newName}"...`,
+          phase: "running"
+        });
+        buffersRef.current.order.push(cmdId2);
+        refreshDerived();
+        setCommandRunning(true);
+        try {
+          const client = await getClient2();
+          await client.agents.modify(agentId, { name: newName });
+          setAgentName(newName);
+          buffersRef.current.byId.set(cmdId2, {
+            kind: "command",
+            id: cmdId2,
+            input: msg,
+            output: `Agent renamed to "${newName}"`,
+            phase: "finished",
+            success: true
+          });
+          refreshDerived();
+        } catch (error) {
+          buffersRef.current.byId.set(cmdId2, {
+            kind: "command",
+            id: cmdId2,
+            input: msg,
+            output: `Failed: ${error instanceof Error ? error.message : String(error)}`,
+            phase: "finished",
+            success: false
+          });
+          refreshDerived();
+        } finally {
+          setCommandRunning(false);
+        }
+        return { submitted: true };
+      }
       const cmdId = uid("cmd");
       buffersRef.current.byId.set(cmdId, {
         kind: "command",
@@ -44660,10 +45426,10 @@ ${detail}` : "";
         const { pendingApproval: existingApproval } = await getResumeData2(client, agent);
         if (existingApproval) {
           setStreaming(false);
-          setPendingApproval(existingApproval);
+          setPendingApprovals([existingApproval]);
           const parsedArgs = safeJsonParseOr(existingApproval.toolArgs, {});
           const context = await analyzeToolApproval(existingApproval.toolName, parsedArgs);
-          setApprovalContext(context);
+          setApprovalContexts([context]);
           return { submitted: false };
         }
       } catch (error) {
@@ -44688,48 +45454,85 @@ ${detail}` : "";
     agentId,
     handleExit
   ]);
-  const handleApprove = import_react40.useCallback(async () => {
-    if (!pendingApproval)
+  const sendAllResults = import_react40.useCallback(async (additionalDecision) => {
+    const allDecisions = [
+      ...approvalResults,
+      ...additionalDecision ? [additionalDecision] : []
+    ];
+    const { executeApprovalBatch: executeApprovalBatch2 } = await Promise.resolve().then(() => (init_approval_execution(), exports_approval_execution));
+    const executedResults = await executeApprovalBatch2(allDecisions, (chunk) => {
+      onChunk(buffersRef.current, chunk);
+      if (chunk.status === "error" && chunk.message_type === "tool_return_message") {
+        const isToolError = chunk.tool_return?.startsWith("Error executing tool:");
+        if (isToolError) {
+          appendError(chunk.tool_return);
+        }
+      }
+    });
+    const allResults = [
+      ...autoHandledResults.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
+      })),
+      ...autoDeniedApprovals.map((ad) => ({
+        type: "approval",
+        tool_call_id: ad.approval.toolCallId,
+        approve: false,
+        reason: ad.reason
+      })),
+      ...executedResults
+    ];
+    setPendingApprovals([]);
+    setApprovalContexts([]);
+    setApprovalResults([]);
+    setAutoHandledResults([]);
+    setAutoDeniedApprovals([]);
+    setThinkingMessage(getRandomThinkingMessage());
+    refreshDerived();
+    await processConversation([
+      {
+        type: "approval",
+        approvals: allResults
+      }
+    ]);
+  }, [
+    approvalResults,
+    autoHandledResults,
+    autoDeniedApprovals,
+    processConversation,
+    refreshDerived,
+    appendError
+  ]);
+  const handleApproveCurrent = import_react40.useCallback(async () => {
+    const currentIndex = approvalResults.length;
+    const currentApproval = pendingApprovals[currentIndex];
+    if (!currentApproval)
       return;
-    const { toolCallId, toolName, toolArgs } = pendingApproval;
-    setPendingApproval(null);
     try {
-      const parsedArgs = safeJsonParseOr(toolArgs, {});
-      const toolResult = await executeTool(toolName, parsedArgs);
-      onChunk(buffersRef.current, {
-        message_type: "tool_return_message",
-        id: "dummy",
-        date: new Date().toISOString(),
-        tool_call_id: toolCallId,
-        tool_return: toolResult.toolReturn,
-        status: toolResult.status,
-        stdout: toolResult.stdout,
-        stderr: toolResult.stderr
-      });
-      setThinkingMessage(getRandomThinkingMessage());
-      refreshDerived();
-      await processConversation([
-        {
-          type: "approval",
-          approvals: [
-            {
-              type: "tool",
-              tool_call_id: toolCallId,
-              tool_return: toolResult.toolReturn,
-              status: toolResult.status,
-              stdout: toolResult.stdout,
-              stderr: toolResult.stderr
-            }
-          ]
-        }
-      ]);
+      const decision = {
+        type: "approve",
+        approval: currentApproval
+      };
+      if (currentIndex + 1 >= pendingApprovals.length) {
+        await sendAllResults(decision);
+      } else {
+        setApprovalResults((prev) => [...prev, decision]);
+      }
     } catch (e) {
       appendError(String(e));
       setStreaming(false);
     }
-  }, [pendingApproval, processConversation, appendError, refreshDerived]);
+  }, [pendingApprovals, approvalResults, sendAllResults, appendError]);
   const handleApproveAlways = import_react40.useCallback(async (scope) => {
-    if (!pendingApproval || !approvalContext)
+    if (pendingApprovals.length === 0 || approvalContexts.length === 0)
+      return;
+    const currentIndex = approvalResults.length;
+    const approvalContext = approvalContexts[currentIndex];
+    if (!approvalContext)
       return;
     const rule = approvalContext.recommendedRule;
     const actualScope = scope || approvalContext.defaultScope;
@@ -44744,29 +45547,36 @@ ${detail}` : "";
     });
     buffersRef.current.order.push(cmdId);
     refreshDerived();
-    setApprovalContext(null);
-    await handleApprove();
-  }, [pendingApproval, approvalContext, handleApprove, refreshDerived]);
-  const handleDeny = import_react40.useCallback(async (reason) => {
-    if (!pendingApproval)
+    await handleApproveCurrent();
+  }, [
+    approvalResults,
+    approvalContexts,
+    pendingApprovals,
+    handleApproveCurrent,
+    refreshDerived
+  ]);
+  const handleDenyCurrent = import_react40.useCallback(async (reason) => {
+    const currentIndex = approvalResults.length;
+    const currentApproval = pendingApprovals[currentIndex];
+    if (!currentApproval)
       return;
-    const { toolCallId } = pendingApproval;
-    setPendingApproval(null);
     try {
-      setThinkingMessage(getRandomThinkingMessage());
-      await processConversation([
-        {
-          type: "approval",
-          approval_request_id: toolCallId,
-          approve: false,
-          reason: reason || "User denied the tool execution"
-        }
-      ]);
+      const decision = {
+        type: "deny",
+        approval: currentApproval,
+        reason: reason || "User denied the tool execution"
+      };
+      if (currentIndex + 1 >= pendingApprovals.length) {
+        setThinkingMessage(getRandomThinkingMessage());
+        await sendAllResults(decision);
+      } else {
+        setApprovalResults((prev) => [...prev, decision]);
+      }
     } catch (e) {
       appendError(String(e));
       setStreaming(false);
     }
-  }, [pendingApproval, processConversation, appendError]);
+  }, [pendingApprovals, approvalResults, sendAllResults, appendError]);
   const handleModelSelect = import_react40.useCallback(async (modelId) => {
     setModelSelectorOpen(false);
     let cmdId = null;
@@ -44898,8 +45708,6 @@ ${detail}` : "";
         return ln.phase === "running";
       }
       if (ln.kind === "tool_call") {
-        if (!tokenStreamingEnabled && ln.phase === "streaming")
-          return false;
         return ln.phase !== "finished";
       }
       if (!tokenStreamingEnabled && ln.phase === "streaming")
@@ -44968,7 +45776,7 @@ ${detail}` : "";
           }, undefined, false, undefined, this),
           loadingState === "ready" && /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(jsx_dev_runtime24.Fragment, {
             children: [
-              liveItems.length > 0 && !pendingApproval && !planApprovalPending && /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
+              liveItems.length > 0 && pendingApprovals.length === 0 && !planApprovalPending && /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
                 flexDirection: "column",
                 children: liveItems.map((ln) => /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
                   marginTop: 1,
@@ -44995,7 +45803,7 @@ ${detail}` : "";
                 agentId
               }, undefined, false, undefined, this),
               /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Input, {
-                visible: !showExitStats && !pendingApproval && !modelSelectorOpen && !planApprovalPending,
+                visible: !showExitStats && pendingApprovals.length === 0 && !modelSelectorOpen && !planApprovalPending,
                 streaming,
                 commandRunning,
                 tokenCount,
@@ -45006,7 +45814,8 @@ ${detail}` : "";
                 onExit: handleExit,
                 onInterrupt: handleInterrupt,
                 interruptRequested,
-                agentId
+                agentId,
+                agentName
               }, undefined, false, undefined, this),
               modelSelectorOpen && /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(ModelSelector, {
                 currentModel: llmConfig?.model,
@@ -45026,17 +45835,23 @@ ${detail}` : "";
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this),
-              pendingApproval && /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(jsx_dev_runtime24.Fragment, {
+              pendingApprovals.length > 0 && /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(jsx_dev_runtime24.Fragment, {
                 children: [
                   /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(Box_default, {
                     height: 1
                   }, undefined, false, undefined, this),
                   /* @__PURE__ */ jsx_dev_runtime24.jsxDEV(ApprovalDialog, {
-                    approvalRequest: pendingApproval,
-                    approvalContext,
-                    onApprove: handleApprove,
+                    approvals: pendingApprovals[approvalResults.length] ? [pendingApprovals[approvalResults.length]] : [],
+                    approvalContexts: approvalContexts[approvalResults.length] ? [approvalContexts[approvalResults.length]] : [],
+                    progress: {
+                      current: approvalResults.length + 1,
+                      total: pendingApprovals.length
+                    },
+                    totalTools: autoHandledResults.length + pendingApprovals.length,
+                    isExecuting: isExecutingTool,
+                    onApproveAll: handleApproveCurrent,
                     onApproveAlways: handleApproveAlways,
-                    onDeny: handleDeny
+                    onDenyAll: handleDenyCurrent
                   }, undefined, false, undefined, this)
                 ]
               }, undefined, true, undefined, this)
@@ -45052,6 +45867,7 @@ var init_App2 = __esm(async () => {
   init_error();
   init_client2();
   init_message();
+  init_modify();
   init_mode();
   init_manager();
   init_pasteRegistry();
@@ -45077,12 +45893,120 @@ var init_App2 = __esm(async () => {
   jsx_dev_runtime24 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
+// src/agent/modify.ts
+var exports_modify2 = {};
+__export(exports_modify2, {
+  updateAgentLLMConfig: () => updateAgentLLMConfig2,
+  unlinkToolsFromAgent: () => unlinkToolsFromAgent2,
+  linkToolsToAgent: () => linkToolsToAgent2
+});
+async function updateAgentLLMConfig2(agentId, modelHandle, updateArgs, preserveParallelToolCalls) {
+  const client = await getClient2();
+  const currentAgent = await client.agents.retrieve(agentId);
+  const originalParallelToolCalls = preserveParallelToolCalls ? currentAgent.llm_config?.parallel_tool_calls ?? undefined : undefined;
+  const updatedLlmConfig = {
+    ...currentAgent.llm_config,
+    ...updateArgs,
+    ...originalParallelToolCalls !== undefined && {
+      parallel_tool_calls: originalParallelToolCalls
+    }
+  };
+  await client.agents.modify(agentId, {
+    llm_config: updatedLlmConfig,
+    parallel_tool_calls: originalParallelToolCalls
+  });
+  const finalAgent = await client.agents.retrieve(agentId);
+  return finalAgent.llm_config;
+}
+async function linkToolsToAgent2(agentId) {
+  try {
+    const client = await getClient2();
+    const agent = await client.agents.retrieve(agentId);
+    const currentTools = agent.tools || [];
+    const currentToolIds = currentTools.map((t) => t.id).filter((id) => typeof id === "string");
+    const currentToolNames = new Set(currentTools.map((t) => t.name).filter((name) => typeof name === "string"));
+    const lettaCodeToolNames = getToolNames();
+    const toolsToAdd = lettaCodeToolNames.filter((name) => !currentToolNames.has(name));
+    if (toolsToAdd.length === 0) {
+      return {
+        success: true,
+        message: "All Letta Code tools already attached",
+        addedCount: 0
+      };
+    }
+    const toolsToAddIds = [];
+    for (const toolName of toolsToAdd) {
+      const tools = await client.tools.list({ name: toolName });
+      const tool = tools[0];
+      if (tool?.id) {
+        toolsToAddIds.push(tool.id);
+      }
+    }
+    const newToolIds = [...currentToolIds, ...toolsToAddIds];
+    const currentToolRules = agent.tool_rules || [];
+    const newToolRules = [
+      ...currentToolRules,
+      ...toolsToAdd.map((toolName) => ({
+        tool_name: toolName,
+        type: "requires_approval",
+        prompt_template: null
+      }))
+    ];
+    await client.agents.modify(agentId, {
+      tool_ids: newToolIds,
+      tool_rules: newToolRules
+    });
+    return {
+      success: true,
+      message: `Attached ${toolsToAddIds.length} Letta Code tool(s) to agent`,
+      addedCount: toolsToAddIds.length
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+async function unlinkToolsFromAgent2(agentId) {
+  try {
+    const client = await getClient2();
+    const agent = await client.agents.retrieve(agentId);
+    const allTools = agent.tools || [];
+    const lettaCodeToolNames = new Set(getToolNames());
+    const remainingTools = allTools.filter((t) => t.name && !lettaCodeToolNames.has(t.name));
+    const removedCount = allTools.length - remainingTools.length;
+    const remainingToolIds = remainingTools.map((t) => t.id).filter((id) => typeof id === "string");
+    const currentToolRules = agent.tool_rules || [];
+    const remainingToolRules = currentToolRules.filter((rule) => rule.type !== "requires_approval" || !lettaCodeToolNames.has(rule.tool_name));
+    await client.agents.modify(agentId, {
+      tool_ids: remainingToolIds,
+      tool_rules: remainingToolRules
+    });
+    return {
+      success: true,
+      message: `Removed ${removedCount} Letta Code tool(s) from agent`,
+      removedCount
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+var init_modify2 = __esm(() => {
+  init_manager();
+  init_client2();
+});
+
 // src/agent/create.ts
 var exports_create = {};
 __export(exports_create, {
   createAgent: () => createAgent2
 });
-async function createAgent2(name = "letta-cli-agent", model, embeddingModel = "openai/text-embedding-3-small", updateArgs, forceNewBlocks = false) {
+import { join as join9 } from "node:path";
+async function createAgent2(name = "letta-cli-agent", model, embeddingModel = "openai/text-embedding-3-small", updateArgs, forceNewBlocks = false, skillsDirectory, parallelToolCalls = true, enableSleeptime = false) {
   let modelHandle;
   if (model) {
     const resolved = resolveModel(model);
@@ -45105,6 +46029,22 @@ async function createAgent2(name = "letta-cli-agent", model, embeddingModel = "o
     "fetch_webpage"
   ];
   const defaultMemoryBlocks = await getDefaultMemoryBlocks();
+  const resolvedSkillsDirectory = skillsDirectory || join9(process.cwd(), SKILLS_DIR);
+  try {
+    const { skills, errors } = await discoverSkills(resolvedSkillsDirectory);
+    if (errors.length > 0) {
+      console.warn("Errors encountered during skill discovery:");
+      for (const error of errors) {
+        console.warn(`  ${error.path}: ${error.message}`);
+      }
+    }
+    const skillsBlock = defaultMemoryBlocks.find((b) => b.label === "skills");
+    if (skillsBlock) {
+      skillsBlock.value = formatSkillsForMemory(skills, resolvedSkillsDirectory);
+    }
+  } catch (error) {
+    console.warn(`Failed to discover skills: ${error instanceof Error ? error.message : String(error)}`);
+  }
   const settings = settingsManager.getSettings();
   const globalSharedBlockIds = settings.globalSharedBlockIds;
   await settingsManager.loadProjectSettings();
@@ -45151,7 +46091,7 @@ async function createAgent2(name = "letta-cli-agent", model, embeddingModel = "o
         throw new Error(`Created block ${label} has no ID`);
       }
       blockIds.push(createdBlock.id);
-      if (label === "project") {
+      if (label === "project" || label === "skills") {
         newLocalBlockIds[label] = createdBlock.id;
       } else {
         newGlobalBlockIds[label] = createdBlock.id;
@@ -45177,25 +46117,31 @@ async function createAgent2(name = "letta-cli-agent", model, embeddingModel = "o
       }
     }, process.cwd());
   }
+  const modelUpdateArgs = getModelUpdateArgs(modelHandle);
+  const contextWindow = modelUpdateArgs?.context_window || 200000;
   const agent = await client.agents.create({
     agent_type: "letta_v1_agent",
     system: SYSTEM_PROMPT,
     name,
     embedding: embeddingModel,
     model: modelHandle,
-    context_window_limit: 200000,
+    context_window_limit: contextWindow,
     tools: toolNames,
     block_ids: blockIds,
     tags: ["origin:letta-code"],
     include_base_tools: false,
     include_base_tool_rules: false,
-    initial_message_sequence: []
+    initial_message_sequence: [],
+    parallel_tool_calls: parallelToolCalls,
+    enable_sleeptime: enableSleeptime
   });
   if (updateArgs && Object.keys(updateArgs).length > 0) {
-    await updateAgentLLMConfig(agent.id, modelHandle, updateArgs);
-    return await client.agents.retrieve(agent.id);
+    const { context_window, ...otherArgs } = updateArgs;
+    if (Object.keys(otherArgs).length > 0) {
+      await updateAgentLLMConfig(agent.id, modelHandle, otherArgs, true);
+    }
   }
-  return agent;
+  return await client.agents.retrieve(agent.id);
 }
 var init_create3 = __esm(() => {
   init_settings_manager();
@@ -45205,6 +46151,7 @@ var init_create3 = __esm(() => {
   init_model();
   init_modify();
   init_promptAssets();
+  init_skills2();
 });
 
 // src/agent/model.ts
@@ -45271,11 +46218,19 @@ async function getResumeData(client, agent) {
     const messagesPage = await client.agents.messages.list(agent.id);
     const messages = messagesPage.items;
     if (!messages || messages.length === 0) {
-      return { pendingApproval: null, messageHistory: [] };
+      return {
+        pendingApproval: null,
+        pendingApprovals: [],
+        messageHistory: []
+      };
     }
     const cursorLastMessage = messages[messages.length - 1];
     if (!cursorLastMessage) {
-      return { pendingApproval: null, messageHistory: [] };
+      return {
+        pendingApproval: null,
+        pendingApprovals: [],
+        messageHistory: []
+      };
     }
     const inContextLastMessageId = agent.message_ids && agent.message_ids.length > 0 ? agent.message_ids[agent.message_ids.length - 1] : null;
     let messageToCheck = cursorLastMessage;
@@ -45296,18 +46251,17 @@ async function getResumeData(client, agent) {
       }
     }
     let pendingApproval = null;
+    let pendingApprovals = [];
     if (messageToCheck.message_type === "approval_request_message") {
       const approvalMsg = messageToCheck;
       const toolCalls = Array.isArray(approvalMsg.tool_calls) ? approvalMsg.tool_calls : approvalMsg.tool_call ? [approvalMsg.tool_call] : [];
-      if (toolCalls.length > 0) {
-        const toolCall = toolCalls[0];
-        if (toolCall?.tool_call_id && toolCall.name && toolCall.arguments) {
-          pendingApproval = {
-            toolCallId: toolCall.tool_call_id,
-            toolName: toolCall.name,
-            toolArgs: toolCall.arguments
-          };
-        }
+      pendingApprovals = toolCalls.filter((tc) => tc?.tool_call_id && tc.name && tc.arguments).map((tc) => ({
+        toolCallId: tc.tool_call_id,
+        toolName: tc.name,
+        toolArgs: tc.arguments
+      }));
+      if (pendingApprovals.length > 0) {
+        pendingApproval = pendingApprovals[0] || null;
       }
     }
     const historyCount = Math.min(MESSAGE_HISTORY_LIMIT, messages.length);
@@ -45315,10 +46269,10 @@ async function getResumeData(client, agent) {
     if (messageHistory[0]?.message_type === "tool_return_message") {
       messageHistory = messageHistory.slice(1);
     }
-    return { pendingApproval, messageHistory };
+    return { pendingApproval, pendingApprovals, messageHistory };
   } catch (error) {
     console.error("Error getting resume data:", error);
-    return { pendingApproval: null, messageHistory: [] };
+    return { pendingApproval: null, pendingApprovals: [], messageHistory: [] };
   }
 }
 
@@ -45443,6 +46397,8 @@ var DEFAULT_SETTINGS2 = {
   uiMode: "simple",
   lastAgent: null,
   tokenStreaming: false,
+  parallelToolCalls: true,
+  enableSleeptime: false,
   globalSharedBlockIds: {}
 };
 var DEFAULT_PROJECT_SETTINGS2 = {
@@ -45806,6 +46762,7 @@ OPTIONS
   -p, --prompt          Headless prompt mode
   --output-format <fmt> Output format for headless mode (text, json, stream-json)
                         Default: text
+  --skills <path>       Custom path to skills directory (default: .skills in current directory)
 
 BEHAVIOR
   By default, letta auto-resumes the last agent used in the current directory
@@ -45856,7 +46813,10 @@ async function main() {
         disallowedTools: { type: "string" },
         "permission-mode": { type: "string" },
         yolo: { type: "boolean" },
-        "output-format": { type: "string" }
+        "output-format": { type: "string" },
+        skills: { type: "string" },
+        link: { type: "boolean" },
+        unlink: { type: "boolean" }
       },
       strict: true,
       allowPositionals: true
@@ -45889,6 +46849,7 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
   const forceNew = values.new ?? false;
   const specifiedAgentId = values.agent ?? null;
   const specifiedModel = values.model ?? undefined;
+  const skillsDirectory = values.skills ?? undefined;
   const isHeadless = values.prompt || values.run || !process.stdin.isTTY;
   const apiKey = process.env.LETTA_API_KEY || settings.env?.LETTA_API_KEY;
   const baseURL = process.env.LETTA_BASE_URL || settings.env?.LETTA_BASE_URL || "https://api.letta.com";
@@ -45958,37 +46919,59 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
       }
     }
   }
+  const shouldLink = values.link;
+  const shouldUnlink = values.unlink;
+  if (shouldLink || shouldUnlink) {
+    if (!specifiedAgentId) {
+      console.error(`Error: --${shouldLink ? "link" : "unlink"} requires --agent <id>`);
+      process.exit(1);
+    }
+  }
   if (isHeadless) {
     await loadTools();
     const client = await getClient();
     await upsertToolsToServer(client);
     const { handleHeadlessCommand: handleHeadlessCommand2 } = await Promise.resolve().then(() => (init_headless(), exports_headless));
-    await handleHeadlessCommand2(process.argv, specifiedModel);
+    await handleHeadlessCommand2(process.argv, specifiedModel, skillsDirectory);
     return;
   }
   const React13 = await Promise.resolve().then(() => __toESM(require_react2(), 1));
   const { render: render2 } = await init_build3().then(() => exports_build);
-  const { useState: useState15, useEffect: useEffect12 } = React13;
+  const { useState: useState15, useEffect: useEffect13 } = React13;
   const AppModule = await init_App2().then(() => exports_App);
   const App3 = AppModule.default;
   function LoadingApp({
     continueSession,
     forceNew: forceNew2,
     agentIdArg,
-    model
+    model,
+    skillsDirectory: skillsDirectory2
   }) {
     const [loadingState, setLoadingState] = useState15("assembling");
     const [agentId, setAgentId] = useState15(null);
     const [agentState, setAgentState] = useState15(null);
     const [resumeData, setResumeData] = useState15(null);
     const [isResumingSession, setIsResumingSession] = useState15(false);
-    useEffect12(() => {
+    useEffect13(() => {
       async function init() {
         setLoadingState("assembling");
         await loadTools();
         setLoadingState("upserting");
         const client = await getClient();
         await upsertToolsToServer(client);
+        if (shouldLink || shouldUnlink) {
+          if (!agentIdArg) {
+            console.error("Error: --link/--unlink requires --agent <id>");
+            process.exit(1);
+          }
+          setLoadingState(shouldLink ? "linking" : "unlinking");
+          const { linkToolsToAgent: linkToolsToAgent3, unlinkToolsFromAgent: unlinkToolsFromAgent3 } = await Promise.resolve().then(() => (init_modify2(), exports_modify2));
+          const result = shouldLink ? await linkToolsToAgent3(agentIdArg) : await unlinkToolsFromAgent3(agentIdArg);
+          if (!result.success) {
+            console.error(`\u2717 ${result.message}`);
+            process.exit(1);
+          }
+        }
         setLoadingState("initializing");
         const { createAgent: createAgent3 } = await Promise.resolve().then(() => (init_create3(), exports_create));
         const { getModelUpdateArgs: getModelUpdateArgs3 } = await Promise.resolve().then(() => (init_model2(), exports_model2));
@@ -45997,12 +46980,15 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
           try {
             agent = await client.agents.retrieve(agentIdArg);
           } catch (error) {
-            console.error(`Agent ${agentIdArg} not found (error: ${JSON.stringify(error)}), creating new one...`);
+            console.error(`Agent ${agentIdArg} not found (error: ${JSON.stringify(error)})`);
+            console.error("When using --agent, the specified agent ID must exist.");
+            console.error("Run 'letta' without --agent to create a new agent.");
+            process.exit(1);
           }
         }
         if (!agent && forceNew2) {
           const updateArgs = getModelUpdateArgs3(model);
-          agent = await createAgent3(undefined, model, undefined, updateArgs, forceNew2);
+          agent = await createAgent3(undefined, model, undefined, updateArgs, forceNew2, skillsDirectory2, settings.parallelToolCalls, settings.enableSleeptime);
         }
         if (!agent) {
           await settingsManager2.loadLocalProjectSettings();
@@ -46024,7 +47010,7 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
         }
         if (!agent) {
           const updateArgs = getModelUpdateArgs3(model);
-          agent = await createAgent3(undefined, model, undefined, updateArgs);
+          agent = await createAgent3(undefined, model, undefined, updateArgs, false, skillsDirectory2, settings.parallelToolCalls, settings.enableSleeptime);
         }
         try {
           settingsManager2.getLocalProjectSettings();
@@ -46054,6 +47040,7 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
         loadingState,
         continueSession: isResumingSession,
         startupApproval: resumeData?.pendingApproval ?? null,
+        startupApprovals: resumeData?.pendingApprovals ?? [],
         messageHistory: resumeData?.messageHistory ?? [],
         tokenStreaming: settings.tokenStreaming
       });
@@ -46064,6 +47051,7 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
       loadingState,
       continueSession: isResumingSession,
       startupApproval: resumeData?.pendingApproval ?? null,
+      startupApprovals: resumeData?.pendingApprovals ?? [],
       messageHistory: resumeData?.messageHistory ?? [],
       tokenStreaming: settings.tokenStreaming
     });
@@ -46072,11 +47060,12 @@ Note: Flags should use double dashes for full names (e.g., --yolo, not -yolo)`);
     continueSession: shouldContinue,
     forceNew,
     agentIdArg: specifiedAgentId,
-    model: specifiedModel
+    model: specifiedModel,
+    skillsDirectory
   }), {
     exitOnCtrlC: false
   });
 }
 main();
 
-//# debugId=2DFAA80260F695BF64756E2164756E21
+//# debugId=924A0340512AB0DC64756E2164756E21