@letta-ai/letta-code 0.23.6 → 0.23.7

package/letta.js

@@ -3269,7 +3269,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.23.6",
+    version: "0.23.7",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -40138,6 +40138,357 @@ var init_types = __esm(() => {
   SUPPORTED_CHANNEL_IDS = ["telegram", "slack"];
 });
 
+// src/channels/interactive.ts
+function normalizeWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function isAffirmativeResponse(text) {
+  const normalized = normalizeWhitespace(text).toLowerCase();
+  return [
+    "approve",
+    "approved",
+    "allow",
+    "yes",
+    "y",
+    "ok",
+    "okay",
+    "continue",
+    "go ahead",
+    "looks good",
+    "lgtm",
+    "sgtm",
+    "ship it"
+  ].includes(normalized);
+}
+function isNegativeResponse(text) {
+  const normalized = normalizeWhitespace(text).toLowerCase();
+  return [
+    "deny",
+    "denied",
+    "reject",
+    "rejected",
+    "no",
+    "n",
+    "cancel",
+    "skip",
+    "keep planning"
+  ].includes(normalized);
+}
+function stripApprovalPrefix(text) {
+  return normalizeWhitespace(text.replace(/^(approve|allow|yes|y|ok|okay|deny|reject|no|n)\s*[:-]?\s*/i, ""));
+}
+function summarizeControlRequestInput(input) {
+  const serialized = JSON.stringify(input, null, 2);
+  if (!serialized || serialized === "{}") {
+    return null;
+  }
+  if (serialized.length <= 1200) {
+    return serialized;
+  }
+  return `${serialized.slice(0, 1197).trimEnd()}...`;
+}
+function summarizePlanPreview(planContent) {
+  const normalized = planContent.trim();
+  if (!normalized) {
+    return "";
+  }
+  const maxLength = 1800;
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.slice(0, maxLength).trimEnd()}
+
+[Plan preview truncated for channel delivery.]`;
+}
+function buildQuestionPrompt(question, index) {
+  const lines = [
+    `${index + 1}. ${question.question ?? `Question ${index + 1}`}`
+  ];
+  const options = question.options ?? [];
+  options.forEach((option, optionIndex) => {
+    const label = option.label?.trim() || `Option ${optionIndex + 1}`;
+    const description = option.description?.trim();
+    lines.push(description ? `   ${optionIndex + 1}) ${label} — ${description}` : `   ${optionIndex + 1}) ${label}`);
+  });
+  if (question.multiSelect) {
+    lines.push("   Choose one or more options. Separate multiple answers with commas.");
+  }
+  return lines;
+}
+function matchQuestionOption(question, text) {
+  const trimmed = normalizeWhitespace(text);
+  const options = question.options ?? [];
+  if (!trimmed || options.length === 0) {
+    return trimmed;
+  }
+  const numberMatch = trimmed.match(/^(\d+)$/);
+  if (numberMatch?.[1]) {
+    const option = options[Number(numberMatch[1]) - 1];
+    if (option?.label?.trim()) {
+      return option.label.trim();
+    }
+  }
+  const exactLabel = options.find((option) => option.label && normalizeWhitespace(option.label).toLowerCase() === trimmed.toLowerCase());
+  if (exactLabel?.label?.trim()) {
+    return exactLabel.label.trim();
+  }
+  return trimmed;
+}
+function matchQuestionAnswer(question, text) {
+  if (!question.multiSelect) {
+    return matchQuestionOption(question, text);
+  }
+  const normalized = normalizeWhitespace(text);
+  if (!normalized) {
+    return normalized;
+  }
+  const selections = normalized.replace(/\band\b/gi, ",").split(/\s*(?:,|\/|;)\s*/).map((entry) => normalizeWhitespace(entry)).filter(Boolean);
+  if (selections.length <= 1) {
+    return matchQuestionOption(question, normalized);
+  }
+  const matchedSelections = Array.from(new Set(selections.map((selection) => matchQuestionOption(question, selection)).filter(Boolean)));
+  return matchedSelections.length > 0 ? matchedSelections.join(", ") : normalized;
+}
+function parseNumberedAnswers(rawText, questions) {
+  const matches = Array.from(rawText.matchAll(/(?:^|\n)\s*(\d+)[).:-]\s*(.+?)(?=(?:\n\s*\d+[).:-]\s*)|$)/gs));
+  if (matches.length === 0) {
+    return null;
+  }
+  const answers = {};
+  for (const match of matches) {
+    const questionIndex = Number(match[1]) - 1;
+    const question = questions[questionIndex];
+    const answerText = match[2]?.trim();
+    if (!question?.question || !answerText) {
+      continue;
+    }
+    answers[question.question] = matchQuestionAnswer(question, answerText);
+  }
+  return Object.keys(answers).length > 0 ? answers : null;
+}
+function buildAllowResponse(requestId, decision) {
+  return {
+    request_id: requestId,
+    decision
+  };
+}
+function buildDenyResponse(requestId, message) {
+  return {
+    request_id: requestId,
+    decision: {
+      behavior: "deny",
+      message
+    }
+  };
+}
+function getAskUserQuestionInput(input) {
+  return input;
+}
+function formatAskUserQuestionPrompt(event) {
+  const input = getAskUserQuestionInput(event.input);
+  const questions = (input.questions ?? []).filter((question) => normalizeWhitespace(question.question ?? ""));
+  const lines = [
+    "The agent needs an answer before it can continue.",
+    "",
+    ...questions.flatMap((question, index) => buildQuestionPrompt(question, index)),
+    ""
+  ];
+  if (questions.length <= 1) {
+    const singleQuestion = questions[0];
+    lines.push(singleQuestion?.multiSelect ? "Reply with one or more option numbers/labels separated by commas, or just send a freeform answer in your next message." : "Reply with an option number/label, or just send a freeform answer in your next message.");
+  } else {
+    lines.push("Reply with numbered lines, for example:", "1: your answer", "2: your answer", "", "You can also use option numbers or option labels. For multi-select questions, separate multiple answers with commas.");
+  }
+  return lines.join(`
+`);
+}
+function formatEnterPlanModePrompt() {
+  return [
+    "The agent wants to enter plan mode before making changes.",
+    "",
+    "Reply `approve` to let it plan first, or reply `deny` to skip planning and continue normally."
+  ].join(`
+`);
+}
+function formatExitPlanModePrompt(event) {
+  const lines = [
+    "The agent is ready to leave plan mode and start implementing."
+  ];
+  if (event.planContent?.trim()) {
+    lines.push("", "Proposed plan:", summarizePlanPreview(event.planContent));
+    if (event.planFilePath?.trim()) {
+      lines.push("", `Plan file: ${event.planFilePath.trim()}`);
+    }
+  }
+  lines.push("", "Reply `approve` to accept the plan and start coding.", "Reply with feedback instead if you want the agent to keep planning.");
+  return lines.join(`
+`);
+}
+function formatGenericToolApprovalPrompt(event) {
+  const inputSummary = summarizeControlRequestInput(event.input);
+  const lines = [`The agent wants approval to run \`${event.toolName}\`.`];
+  if (inputSummary) {
+    lines.push("", "Tool input:", inputSummary);
+  }
+  lines.push("", "Reply `approve` to allow it.", "Reply with feedback instead if you want to deny it.");
+  return lines.join(`
+`);
+}
+function formatChannelControlRequestPrompt(event) {
+  switch (event.kind) {
+    case "ask_user_question":
+      return formatAskUserQuestionPrompt(event);
+    case "enter_plan_mode":
+      return formatEnterPlanModePrompt();
+    case "exit_plan_mode":
+      return formatExitPlanModePrompt(event);
+    case "generic_tool_approval":
+      return formatGenericToolApprovalPrompt(event);
+    default: {
+      const exhaustiveCheck = event.kind;
+      return exhaustiveCheck;
+    }
+  }
+}
+function parseAskUserQuestionResponse(event, rawText) {
+  const input = getAskUserQuestionInput(event.input);
+  const questions = (input.questions ?? []).filter((question) => normalizeWhitespace(question.question ?? ""));
+  if (questions.length === 0) {
+    return {
+      type: "reprompt",
+      message: "I couldn't find the original question payload. Please ask the agent to try again."
+    };
+  }
+  if (questions.length === 1) {
+    const [question] = questions;
+    if (!question?.question) {
+      return {
+        type: "reprompt",
+        message: "I couldn't find the original question text. Please ask the agent to try again."
+      };
+    }
+    const answer = matchQuestionAnswer(question, rawText);
+    return {
+      type: "response",
+      response: buildAllowResponse(event.requestId, {
+        behavior: "allow",
+        updated_input: {
+          ...event.input,
+          answers: {
+            ...input.answers ?? {},
+            [question.question]: answer
+          }
+        }
+      })
+    };
+  }
+  const numberedAnswers = parseNumberedAnswers(rawText, questions);
+  if (!numberedAnswers) {
+    return {
+      type: "reprompt",
+      message: `Please answer with numbered lines so I can map each reply to the right question.
+Example:
+1: your answer
+2: your answer`
+    };
+  }
+  const missingQuestions = questions.filter((question) => question.question && !Object.hasOwn(numberedAnswers, question.question));
+  if (missingQuestions.length > 0) {
+    return {
+      type: "reprompt",
+      message: `I still need answers for: ${missingQuestions.map((question) => question.question).join(", ")}`
+    };
+  }
+  return {
+    type: "response",
+    response: buildAllowResponse(event.requestId, {
+      behavior: "allow",
+      updated_input: {
+        ...event.input,
+        answers: {
+          ...input.answers ?? {},
+          ...numberedAnswers
+        }
+      }
+    })
+  };
+}
+function parseEnterPlanModeResponse(event, rawText) {
+  if (isAffirmativeResponse(rawText)) {
+    return {
+      type: "response",
+      response: buildAllowResponse(event.requestId, {
+        behavior: "allow"
+      })
+    };
+  }
+  if (isNegativeResponse(rawText)) {
+    return {
+      type: "response",
+      response: buildDenyResponse(event.requestId, "User chose to skip plan mode and continue implementing directly.")
+    };
+  }
+  return {
+    type: "reprompt",
+    message: "Reply `approve` to let the agent enter plan mode, or `deny` to skip planning."
+  };
+}
+function parseExitPlanModeResponse(event, rawText) {
+  if (isAffirmativeResponse(rawText)) {
+    return {
+      type: "response",
+      response: buildAllowResponse(event.requestId, {
+        behavior: "allow"
+      })
+    };
+  }
+  const feedback = stripApprovalPrefix(rawText);
+  return {
+    type: "response",
+    response: buildDenyResponse(event.requestId, feedback || "Please keep planning and revise the proposal.")
+  };
+}
+function parseGenericToolApprovalResponse(event, rawText) {
+  if (isAffirmativeResponse(rawText)) {
+    const message = stripApprovalPrefix(rawText);
+    return {
+      type: "response",
+      response: buildAllowResponse(event.requestId, {
+        behavior: "allow",
+        ...message ? { message } : {}
+      })
+    };
+  }
+  const feedback = stripApprovalPrefix(rawText);
+  return {
+    type: "response",
+    response: buildDenyResponse(event.requestId, feedback || "Denied by channel user.")
+  };
+}
+function parseChannelControlRequestResponse(event, rawText) {
+  const trimmed = rawText.trim();
+  if (!trimmed) {
+    return {
+      type: "reprompt",
+      message: formatChannelControlRequestPrompt(event)
+    };
+  }
+  switch (event.kind) {
+    case "ask_user_question":
+      return parseAskUserQuestionResponse(event, trimmed);
+    case "enter_plan_mode":
+      return parseEnterPlanModeResponse(event, trimmed);
+    case "exit_plan_mode":
+      return parseExitPlanModeResponse(event, trimmed);
+    case "generic_tool_approval":
+      return parseGenericToolApprovalResponse(event, trimmed);
+    default: {
+      const exhaustiveCheck = event.kind;
+      return exhaustiveCheck;
+    }
+  }
+}
+
 // src/channels/telegram/media.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
@@ -41121,6 +41472,13 @@ function createTelegramAdapter(config) {
       } : undefined;
       await telegramBot.api.sendMessage(chatId, text, reply_parameters ? { reply_parameters } : {});
     },
+    async handleControlRequestEvent(event) {
+      const telegramBot = await ensureBot();
+      const reply_parameters = event.source.messageId || event.source.threadId ? {
+        message_id: Number(event.source.threadId ?? event.source.messageId)
+      } : undefined;
+      await telegramBot.api.sendMessage(event.source.chatId, formatChannelControlRequestPrompt(event), reply_parameters ? { reply_parameters } : {});
+    },
     onMessage: undefined
   };
   return adapter;
@@ -42280,6 +42638,16 @@ function createSlackAdapter(config) {
       });
       rememberMessageThread(response.ts, options?.replyToMessageId ?? response.ts ?? null);
     },
+    async handleControlRequestEvent(event) {
+      await ensureApp();
+      const slackClient = await ensureWriteClient();
+      const response = await slackClient.chat.postMessage({
+        channel: event.source.chatId,
+        text: formatChannelControlRequestPrompt(event),
+        ...event.source.threadId ?? event.source.messageId ? { thread_ts: event.source.threadId ?? event.source.messageId } : {}
+      });
+      rememberMessageThread(response.ts, event.source.threadId ?? event.source.messageId ?? response.ts ?? null);
+    },
     async prepareInboundMessage(msg, options) {
       if (!options?.isFirstRouteTurn || msg.channel !== "slack" || msg.chatType !== "channel" || !isNonEmptyString2(msg.threadId) || !isNonEmptyString2(msg.messageId)) {
         return msg;
@@ -43347,6 +43715,14 @@ function buildChannelTurnSource(route, msg) {
     conversationId: route.conversationId
   };
 }
+function getChannelApprovalScopeKey(params) {
+  return [
+    params.channel,
+    params.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID,
+    params.chatId,
+    params.threadId ?? ""
+  ].join(":");
+}
 function getChannelRegistry() {
   return instance;
 }
@@ -43364,7 +43740,10 @@ class ChannelRegistry {
   ready = false;
   messageHandler = null;
   eventHandler = null;
+  approvalResponseHandler = null;
   buffer = [];
+  pendingControlRequestsById = new Map;
+  pendingControlRequestIdByScope = new Map;
   constructor() {
     if (instance) {
       throw new Error("ChannelRegistry is a singleton — use getChannelRegistry()");
@@ -43434,9 +43813,57 @@ class ChannelRegistry {
   setMessageHandler(handler) {
     this.messageHandler = handler;
   }
+  setApprovalResponseHandler(handler) {
+    this.approvalResponseHandler = handler;
+  }
   setEventHandler(handler) {
     this.eventHandler = handler;
   }
+  async registerPendingControlRequest(event) {
+    const scopeKey = getChannelApprovalScopeKey({
+      channel: event.source.channel,
+      accountId: event.source.accountId,
+      chatId: event.source.chatId,
+      threadId: event.source.threadId
+    });
+    const existingRequestId = this.pendingControlRequestIdByScope.get(scopeKey);
+    if (existingRequestId) {
+      this.clearPendingControlRequest(existingRequestId);
+    }
+    this.pendingControlRequestsById.set(event.requestId, event);
+    this.pendingControlRequestIdByScope.set(scopeKey, event.requestId);
+    const adapter = this.getAdapter(event.source.channel, event.source.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID);
+    if (!adapter) {
+      return;
+    }
+    try {
+      if (adapter.handleControlRequestEvent) {
+        await adapter.handleControlRequestEvent(event);
+        return;
+      }
+      await adapter.sendDirectReply(event.source.chatId, formatChannelControlRequestPrompt(event), {
+        replyToMessageId: event.source.threadId ?? event.source.messageId
+      });
+    } catch (error) {
+      console.error(`[Channels] Failed to deliver control request prompt for ${event.source.channel}/${event.source.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID}:`, error instanceof Error ? error.message : error);
+    }
+  }
+  clearPendingControlRequest(requestId) {
+    const pending = this.pendingControlRequestsById.get(requestId);
+    if (!pending) {
+      return;
+    }
+    this.pendingControlRequestsById.delete(requestId);
+    const scopeKey = getChannelApprovalScopeKey({
+      channel: pending.source.channel,
+      accountId: pending.source.accountId,
+      chatId: pending.source.chatId,
+      threadId: pending.source.threadId
+    });
+    if (this.pendingControlRequestIdByScope.get(scopeKey) === requestId) {
+      this.pendingControlRequestIdByScope.delete(scopeKey);
+    }
+  }
   setReady() {
     this.ready = true;
     this.flushBuffer();
@@ -43528,6 +43955,7 @@ class ChannelRegistry {
     this.ready = false;
     this.messageHandler = null;
     this.eventHandler = null;
+    this.approvalResponseHandler = null;
   }
   async stopAll() {
     for (const adapter of Array.from(this.adapters.values())) {
@@ -43538,13 +43966,63 @@ class ChannelRegistry {
     this.ready = false;
     this.messageHandler = null;
     this.eventHandler = null;
+    this.approvalResponseHandler = null;
+    this.pendingControlRequestsById.clear();
+    this.pendingControlRequestIdByScope.clear();
     instance = null;
   }
+  async tryHandlePendingControlRequest(adapter, msg) {
+    const scopeKey = getChannelApprovalScopeKey({
+      channel: msg.channel,
+      accountId: msg.accountId,
+      chatId: msg.chatId,
+      threadId: msg.threadId
+    });
+    const requestId = this.pendingControlRequestIdByScope.get(scopeKey);
+    if (!requestId) {
+      return false;
+    }
+    const pending = this.pendingControlRequestsById.get(requestId);
+    if (!pending) {
+      this.pendingControlRequestIdByScope.delete(scopeKey);
+      return false;
+    }
+    const parsed = parseChannelControlRequestResponse(pending, msg.text);
+    if (parsed.type === "reprompt") {
+      await adapter.sendDirectReply(msg.chatId, parsed.message, {
+        replyToMessageId: msg.threadId ?? msg.messageId
+      });
+      return true;
+    }
+    if (!this.approvalResponseHandler) {
+      await adapter.sendDirectReply(msg.chatId, "I’m reconnecting to Letta Code right now, so I couldn’t use that reply yet. Please send it again in a moment.", {
+        replyToMessageId: msg.threadId ?? msg.messageId
+      });
+      return true;
+    }
+    const handled = await this.approvalResponseHandler({
+      runtime: {
+        agent_id: pending.source.agentId,
+        conversation_id: pending.source.conversationId
+      },
+      response: parsed.response
+    });
+    this.clearPendingControlRequest(requestId);
+    if (!handled) {
+      await adapter.sendDirectReply(msg.chatId, "That approval prompt expired before I could use your reply. Please ask the agent to try again.", {
+        replyToMessageId: msg.threadId ?? msg.messageId
+      });
+    }
+    return true;
+  }
   async handleInboundMessage(msg) {
     const accountId = msg.accountId ?? LEGACY_CHANNEL_ACCOUNT_ID;
     const adapter = this.getAdapter(msg.channel, accountId);
     if (!adapter)
       return;
+    if (await this.tryHandlePendingControlRequest(adapter, msg)) {
+      return;
+    }
     const config = getChannelAccount(msg.channel, accountId);
     if (!config)
       return;
@@ -52599,6 +53077,7 @@ function createConversationRuntime(listener, agentId, conversationId) {
     key: runtimeKey,
     agentId: normalizedAgentId,
     conversationId: normalizedConversationId,
+    activeChannelTurnSources: null,
     messageQueue: Promise.resolve(),
     pendingApprovalResolvers: new Map,
     recoveredApprovalState: null,
@@ -77282,13 +77761,58 @@ function writeCronFile(data) {
   writeFileSync14(tmp, JSON.stringify(data, null, 2), { flush: true });
   renameSync2(tmp, path20);
 }
-function isProcessAlive(pid) {
+function readLinuxProcessIdentity(pid) {
+  try {
+    const stat5 = readFileSync15(`/proc/${pid}/stat`, "utf8");
+    const endCommand = stat5.lastIndexOf(")");
+    if (endCommand === -1) {
+      return null;
+    }
+    const fields = stat5.slice(endCommand + 2).trim().split(/\s+/);
+    const startTicks = fields[19] ?? null;
+    if (!startTicks) {
+      return null;
+    }
+    let bootId = null;
+    try {
+      bootId = readFileSync15("/proc/sys/kernel/random/boot_id", "utf8").trim() || null;
+    } catch {}
+    return { startTicks, bootId };
+  } catch {
+    return null;
+  }
+}
+function readProcessIdentity(pid) {
+  if (readProcessIdentityOverride) {
+    return readProcessIdentityOverride(pid);
+  }
+  return readLinuxProcessIdentity(pid);
+}
+function captureProcessIdentity(pid) {
+  const identity = readProcessIdentity(pid);
+  return {
+    process_start_ticks: identity?.startTicks ?? null,
+    boot_id: identity?.bootId ?? null
+  };
+}
+function isProcessAlive(pid, owner) {
   try {
     process.kill(pid, 0);
-    return true;
   } catch {
     return false;
   }
+  if (owner) {
+    const identity = readProcessIdentity(pid);
+    if (identity) {
+      if (owner.boot_id && identity.bootId && owner.boot_id !== identity.bootId) {
+        return false;
+      }
+      if (owner.process_start_ticks && identity.startTicks && owner.process_start_ticks !== identity.startTicks) {
+        return false;
+      }
+    }
+  }
+  return true;
 }
 function readLockOwner(lockDir) {
   try {
@@ -77311,7 +77835,7 @@ function isLockStale(lockDir) {
       return true;
     }
   }
-  const pidDead = !isProcessAlive(owner.pid);
+  const pidDead = !isProcessAlive(owner.pid, owner);
   const isOld = Date.now() - owner.acquired_at > LOCK_STALE_AGE_MS;
   return pidDead && isOld;
 }
@@ -77330,7 +77854,8 @@ function acquireLock() {
       const owner = {
         pid: process.pid,
         token,
-        acquired_at: Date.now()
+        acquired_at: Date.now(),
+        ...captureProcessIdentity(process.pid)
       };
       writeLockOwner(lockDir, owner);
       return {
@@ -77435,7 +77960,7 @@ function addTask(input) {
     data.tasks.push(task2);
     writeCronFile(data);
     let warning;
-    if (!data.scheduler_owner || !isProcessAlive(data.scheduler_owner.pid)) {
+    if (!data.scheduler_owner || !isProcessAlive(data.scheduler_owner.pid, data.scheduler_owner)) {
       warning = "No letta server is currently running. This task will only execute when a WS listener is active.";
     }
     return { task: task2, warning };
@@ -77483,15 +78008,17 @@ function claimSchedulerLease() {
     const data = readCronFile();
     const token = randomBytes(4).toString("hex");
     if (data.scheduler_owner) {
-      const { pid, token: existingToken } = data.scheduler_owner;
-      if (isProcessAlive(pid)) {
+      const existingOwner = data.scheduler_owner;
+      const { pid, token: existingToken } = existingOwner;
+      if (isProcessAlive(pid, existingOwner)) {
         throw new Error(`Scheduler lease held by PID ${pid} (token ${existingToken}). Cannot claim.`);
       }
     }
     data.scheduler_owner = {
       pid: process.pid,
       token,
-      started_at: new Date().toISOString()
+      started_at: new Date().toISOString(),
+      ...captureProcessIdentity(process.pid)
     };
     writeCronFile(data);
     return token;
@@ -77551,7 +78078,7 @@ function getCronFileMtime() {
     return 0;
   }
 }
-var CRON_FILE_NAME = "crons.json", LOCK_DIR_NAME = "crons.lock", LOCK_TOKEN_FILE = "owner.json", LOCK_TIMEOUT_MS = 5000, LOCK_RETRY_MS = 50, LOCK_STALE_AGE_MS = 30000, MAX_ACTIVE_TASKS_PER_AGENT = 50, TASK_ID_BYTES = 4, GC_AGE_MS;
+var CRON_FILE_NAME = "crons.json", LOCK_DIR_NAME = "crons.lock", LOCK_TOKEN_FILE = "owner.json", LOCK_TIMEOUT_MS = 5000, LOCK_RETRY_MS = 50, LOCK_STALE_AGE_MS = 30000, MAX_ACTIVE_TASKS_PER_AGENT = 50, TASK_ID_BYTES = 4, GC_AGE_MS, readProcessIdentityOverride = null;
 var init_cronFile = __esm(() => {
   init_parseInterval();
   GC_AGE_MS = 24 * 60 * 60 * 1000;
@@ -81837,6 +82364,18 @@ var MIN_SPLIT_LENGTH = 1500;
 function isInteractiveApprovalTool(toolName) {
   return INTERACTIVE_APPROVAL_TOOLS.has(toolName);
 }
+function getInteractiveApprovalKind(toolName) {
+  switch (toolName) {
+    case "AskUserQuestion":
+      return "ask_user_question";
+    case "EnterPlanMode":
+      return "enter_plan_mode";
+    case "ExitPlanMode":
+      return "exit_plan_mode";
+    default:
+      return null;
+  }
+}
 function isHeadlessAutoAllowTool(toolName) {
   return HEADLESS_AUTO_ALLOW_TOOLS.has(toolName);
 }
@@ -88493,7 +89032,46 @@ var init_send = __esm(async () => {
 });
 
 // src/websocket/listener/turn-approval.ts
+import { readFile as readFile11 } from "node:fs/promises";
 import WebSocket2 from "ws";
+function getChannelApprovalSourceScopeKey(source) {
+  return [
+    source.channel,
+    source.accountId ?? "",
+    source.chatId,
+    source.threadId ?? ""
+  ].join(":");
+}
+function resolveChannelApprovalSource(runtime) {
+  const sources = runtime.activeChannelTurnSources ?? [];
+  if (sources.length === 0) {
+    return null;
+  }
+  const sourcesByScope = new Map;
+  for (const source of sources) {
+    sourcesByScope.set(getChannelApprovalSourceScopeKey(source), source);
+  }
+  if (sourcesByScope.size !== 1) {
+    return null;
+  }
+  return [...sourcesByScope.values()].at(-1) ?? null;
+}
+async function maybeReadPlanPreview(toolName, turnPermissionModeState) {
+  if (toolName !== "ExitPlanMode" || !turnPermissionModeState.planFilePath) {
+    return {};
+  }
+  try {
+    const planContent = await readFile11(turnPermissionModeState.planFilePath, "utf8");
+    return {
+      planFilePath: turnPermissionModeState.planFilePath,
+      planContent
+    };
+  } catch {
+    return {
+      planFilePath: turnPermissionModeState.planFilePath
+    };
+  }
+}
 async function handleApprovalStop(params) {
   const {
     approvals,
@@ -88631,6 +89209,18 @@ async function handleApprovalStop(params) {
         agent_id: agentId,
         conversation_id: conversationId
       };
+      const registry = getChannelRegistry();
+      const channelSource = resolveChannelApprovalSource(runtime);
+      if (registry && channelSource) {
+        await registry.registerPendingControlRequest({
+          requestId,
+          kind: getInteractiveApprovalKind(ac.approval.toolName) ?? "generic_tool_approval",
+          source: channelSource,
+          toolName: ac.approval.toolName,
+          input: ac.parsedArgs,
+          ...await maybeReadPlanPreview(ac.approval.toolName, turnPermissionModeState)
+        });
+      }
       let responseBody;
       try {
         responseBody = await requestApprovalOverWS(runtime, socket, requestId, controlRequest);
@@ -88639,6 +89229,8 @@ async function handleApprovalStop(params) {
           return interruptTermination();
         }
         throw error;
+      } finally {
+        registry?.clearPendingControlRequest(requestId);
       }
       if (shouldInterrupt()) {
         return interruptTermination();
@@ -88841,6 +89433,7 @@ async function handleApprovalStop(params) {
   };
 }
 var init_turn_approval = __esm(async () => {
+  init_registry();
   init_diffPreview();
   init_interactivePolicy();
   init_skill_injection();
@@ -90684,6 +91277,7 @@ async function drainQueuedMessages(runtime, socket, opts, processQueuedTurn) {
       }
       let turnError;
       let didThrow = false;
+      runtime.activeChannelTurnSources = channelTurnSources;
       try {
         await processQueuedTurn(queuedTurn, dequeuedBatch);
       } catch (error) {
@@ -90691,6 +91285,7 @@ async function drainQueuedMessages(runtime, socket, opts, processQueuedTurn) {
         turnError = error instanceof Error ? error.message : String(error);
         throw error;
       } finally {
+        runtime.activeChannelTurnSources = null;
         if (channelTurnSources.length > 0) {
           await dispatchChannelTurnLifecycleEvent({
             type: "finished",
@@ -93471,6 +94066,13 @@ function wireChannelIngress(listener, socket, opts, processQueuedTurn) {
     }
     scheduleQueuePump(conversationRuntime, socket, opts, processQueuedTurn);
   });
+  registry.setApprovalResponseHandler(async ({ runtime, response }) => handleApprovalResponseInput(listener, {
+    runtime,
+    response,
+    socket,
+    opts,
+    processQueuedTurn
+  }));
   registry.setEventHandler((event) => {
     handleChannelRegistryEvent(event, socket, listener);
   });
@@ -94380,8 +94982,8 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
         console.log(`[Listen] Received read_file command: path=${parsed.path}, request_id=${parsed.request_id}`);
         runDetachedListenerTask("read_file", async () => {
           try {
-            const { readFile: readFile11 } = await import("node:fs/promises");
-            const content = await readFile11(parsed.path, "utf-8");
+            const { readFile: readFile12 } = await import("node:fs/promises");
+            const content = await readFile12(parsed.path, "utf-8");
             console.log(`[Listen] read_file success: ${parsed.path} (${content.length} bytes)`);
             safeSocketSend(socket, {
               type: "read_file_response",
@@ -94411,10 +95013,10 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
           try {
             const { edit: edit2 } = await Promise.resolve().then(() => (init_Edit2(), exports_Edit));
             const { write: write2 } = await Promise.resolve().then(() => (init_Write2(), exports_Write));
-            const { readFile: readFile11 } = await import("node:fs/promises");
+            const { readFile: readFile12 } = await import("node:fs/promises");
             let currentContent = null;
             try {
-              currentContent = await readFile11(parsed.path, "utf-8");
+              currentContent = await readFile12(parsed.path, "utf-8");
             } catch (readErr) {
               const e = readErr;
               if (e.code !== "ENOENT")
@@ -94522,7 +95124,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
         console.log(`[Listen] Received edit_file command: file_path=${parsed.file_path}, request_id=${parsed.request_id}`);
         runDetachedListenerTask("edit_file", async () => {
           try {
-            const { readFile: readFile11 } = await import("node:fs/promises");
+            const { readFile: readFile12 } = await import("node:fs/promises");
             const { edit: edit2 } = await Promise.resolve().then(() => (init_Edit2(), exports_Edit));
             console.log(`[Listen] Executing edit: old_string="${parsed.old_string.slice(0, 50)}${parsed.old_string.length > 50 ? "..." : ""}"`);
             const result = await edit2({
@@ -94538,7 +95140,7 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
             }
             if (result.replacements > 0) {
               try {
-                const contentAfter = await readFile11(parsed.file_path, "utf-8");
+                const contentAfter = await readFile12(parsed.file_path, "utf-8");
                 safeSocketSend(socket, {
                   type: "file_ops",
                   path: parsed.file_path,
@@ -95453,7 +96055,7 @@ __export(exports_skills2, {
   GLOBAL_SKILLS_DIR: () => GLOBAL_SKILLS_DIR2
 });
 import { existsSync as existsSync28 } from "node:fs";
-import { readdir as readdir8, readFile as readFile11, realpath as realpath4, stat as stat7 } from "node:fs/promises";
+import { readdir as readdir8, readFile as readFile12, realpath as realpath4, stat as stat7 } from "node:fs/promises";
 import { dirname as dirname13, join as join35 } from "node:path";
 import { fileURLToPath as fileURLToPath8 } from "node:url";
 function getBundledSkillsPath2() {
@@ -95584,7 +96186,7 @@ async function findSkillFiles2(currentPath, rootPath, skills, errors, source, vi
   }
 }
 async function parseSkillFile2(filePath, rootPath, source) {
-  const content = await readFile11(filePath, "utf-8");
+  const content = await readFile12(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(content);
   const normalizedRoot = rootPath.endsWith("/") ? rootPath.slice(0, -1) : rootPath;
   const relativePath = filePath.slice(normalizedRoot.length + 1);
@@ -95643,7 +96245,7 @@ __export(exports_fs, {
   writeJsonFile: () => writeJsonFile,
   writeFile: () => writeFile10,
   readJsonFile: () => readJsonFile,
-  readFile: () => readFile12,
+  readFile: () => readFile13,
   mkdir: () => mkdir9,
   exists: () => exists2
 });
@@ -95654,7 +96256,7 @@ import {
   mkdirSync as mkdirSync21
 } from "node:fs";
 import { dirname as dirname14 } from "node:path";
-async function readFile12(path24) {
+async function readFile13(path24) {
   return fsReadFileSync2(path24, { encoding: "utf-8" });
 }
 async function writeFile10(path24, content) {
@@ -95671,7 +96273,7 @@ async function mkdir9(path24, options) {
   mkdirSync21(path24, options);
 }
 async function readJsonFile(path24) {
-  const text = await readFile12(path24);
+  const text = await readFile13(path24);
   return JSON.parse(text);
 }
 async function writeJsonFile(path24, data, options) {
@@ -97510,7 +98112,7 @@ __export(exports_import, {
   extractSkillsFromAf: () => extractSkillsFromAf
 });
 import { createReadStream } from "node:fs";
-import { chmod, mkdir as mkdir10, readFile as readFile13, writeFile as writeFile11 } from "node:fs/promises";
+import { chmod, mkdir as mkdir10, readFile as readFile14, writeFile as writeFile11 } from "node:fs/promises";
 import { dirname as dirname15, resolve as resolve28 } from "node:path";
 async function importAgentFromFile(options) {
   const client = await getClient();
@@ -97543,7 +98145,7 @@ async function importAgentFromFile(options) {
 }
 async function extractSkillsFromAf(afPath, destDir) {
   const extracted = [];
-  const content = await readFile13(afPath, "utf-8");
+  const content = await readFile14(afPath, "utf-8");
   const afData = JSON.parse(content);
   if (!afData.skills || !Array.isArray(afData.skills)) {
     return [];
@@ -124440,7 +125042,7 @@ __export(exports_custom, {
   COMMANDS_DIR: () => COMMANDS_DIR
 });
 import { existsSync as existsSync36 } from "node:fs";
-import { readdir as readdir10, readFile as readFile14 } from "node:fs/promises";
+import { readdir as readdir10, readFile as readFile15 } from "node:fs/promises";
 import { basename as basename11, dirname as dirname17, join as join44 } from "node:path";
 async function getCustomCommands() {
   if (cachedCommands !== null) {
@@ -124499,7 +125101,7 @@ async function findCommandFiles(currentPath, rootPath, commands2, source2) {
   } catch (_error) {}
 }
 async function parseCommandFile(filePath, rootPath, source2) {
-  const content = await readFile14(filePath, "utf-8");
+  const content = await readFile15(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(content);
   const id = basename11(filePath, ".md");
   const relativePath = dirname17(filePath).slice(rootPath.length);
@@ -137231,7 +137833,7 @@ var init_PersonalitySelector = __esm(async () => {
 });
 
 // src/utils/aws-credentials.ts
-import { readFile as readFile15 } from "node:fs/promises";
+import { readFile as readFile16 } from "node:fs/promises";
 import { homedir as homedir36 } from "node:os";
 import { join as join48 } from "node:path";
 async function parseAwsCredentials() {
@@ -137239,11 +137841,11 @@ async function parseAwsCredentials() {
   const configPath = join48(homedir36(), ".aws", "config");
   const profiles = new Map;
   try {
-    const content = await readFile15(credentialsPath, "utf-8");
+    const content = await readFile16(credentialsPath, "utf-8");
     parseIniFile(content, profiles, false);
   } catch {}
   try {
-    const content = await readFile15(configPath, "utf-8");
+    const content = await readFile16(configPath, "utf-8");
     parseIniFile(content, profiles, true);
   } catch {}
   return Array.from(profiles.values());
@@ -143908,7 +144510,7 @@ var exports_export = {};
 __export(exports_export, {
   packageSkills: () => packageSkills
 });
-import { readdir as readdir11, readFile as readFile16 } from "node:fs/promises";
+import { readdir as readdir11, readFile as readFile17 } from "node:fs/promises";
 import { relative as relative17, resolve as resolve32 } from "node:path";
 async function packageSkills(agentId, skillsDir) {
   const skills = [];
@@ -143929,7 +144531,7 @@ async function packageSkills(agentId, skillsDir) {
         const skillDir = resolve32(baseDir, entry.name);
         const skillMdPath = resolve32(skillDir, "SKILL.md");
         try {
-          await readFile16(skillMdPath, "utf-8");
+          await readFile17(skillMdPath, "utf-8");
         } catch {
           console.warn(`Skipping invalid skill ${entry.name}: missing SKILL.md`);
           continue;
@@ -143961,7 +144563,7 @@ async function readSkillFiles(skillDir) {
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
-        const content = await readFile16(fullPath, "utf-8");
+        const content = await readFile17(fullPath, "utf-8");
         const relativePath = relative17(skillDir, fullPath).replace(/\\/g, "/");
         files[relativePath] = content;
       }
@@ -154739,7 +155341,7 @@ __export(exports_import2, {
   extractSkillsFromAf: () => extractSkillsFromAf2
 });
 import { createReadStream as createReadStream2 } from "node:fs";
-import { chmod as chmod2, mkdir as mkdir11, readFile as readFile17, writeFile as writeFile12 } from "node:fs/promises";
+import { chmod as chmod2, mkdir as mkdir11, readFile as readFile18, writeFile as writeFile12 } from "node:fs/promises";
 import { dirname as dirname20, resolve as resolve33 } from "node:path";
 async function importAgentFromFile2(options) {
   const client = await getClient();
@@ -154772,7 +155374,7 @@ async function importAgentFromFile2(options) {
 }
 async function extractSkillsFromAf2(afPath, destDir) {
   const extracted = [];
-  const content = await readFile17(afPath, "utf-8");
+  const content = await readFile18(afPath, "utf-8");
   const afData = JSON.parse(content);
   if (!afData.skills || !Array.isArray(afData.skills)) {
     return [];
@@ -164230,4 +164832,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=B587994115421B1064756E2164756E21
+//# debugId=13707EE7EA6B933364756E2164756E21

package/package.json

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