@letta-ai/letta-code 0.17.0 → 0.17.1

package/letta.js

@@ -3222,7 +3222,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.17.0",
+    version: "0.17.1",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -7319,14 +7319,14 @@ var init_models2 = __esm(() => {
     {
       id: "auto",
       handle: "letta/auto",
-      label: "Auto",
+      label: "Auto (Beta)",
       description: "Automatically select the best model",
       isFeatured: true
     },
     {
       id: "auto-fast",
       handle: "letta/auto-fast",
-      label: "Auto Fast",
+      label: "Auto Fast (Beta)",
       description: "Automatically select the best fast model",
       isFeatured: true
     },
@@ -7908,6 +7908,72 @@ var init_models2 = __esm(() => {
         parallel_tool_calls: true
       }
     },
+    {
+      id: "gpt-5.4-none",
+      handle: "openai/gpt-5.4",
+      label: "GPT-5.4",
+      description: "OpenAI's most capable model (no reasoning)",
+      updateArgs: {
+        reasoning_effort: "none",
+        verbosity: "medium",
+        context_window: 272000,
+        max_output_tokens: 128000,
+        parallel_tool_calls: true
+      }
+    },
+    {
+      id: "gpt-5.4-low",
+      handle: "openai/gpt-5.4",
+      label: "GPT-5.4",
+      description: "OpenAI's most capable model (low reasoning)",
+      updateArgs: {
+        reasoning_effort: "low",
+        verbosity: "medium",
+        context_window: 272000,
+        max_output_tokens: 128000,
+        parallel_tool_calls: true
+      }
+    },
+    {
+      id: "gpt-5.4-medium",
+      handle: "openai/gpt-5.4",
+      label: "GPT-5.4",
+      description: "OpenAI's most capable model (med reasoning)",
+      updateArgs: {
+        reasoning_effort: "medium",
+        verbosity: "medium",
+        context_window: 272000,
+        max_output_tokens: 128000,
+        parallel_tool_calls: true
+      }
+    },
+    {
+      id: "gpt-5.4-high",
+      handle: "openai/gpt-5.4",
+      label: "GPT-5.4",
+      description: "OpenAI's most capable model (high reasoning)",
+      isFeatured: true,
+      updateArgs: {
+        reasoning_effort: "high",
+        verbosity: "medium",
+        context_window: 272000,
+        max_output_tokens: 128000,
+        parallel_tool_calls: true
+      }
+    },
+    {
+      id: "gpt-5.4-xhigh",
+      handle: "openai/gpt-5.4",
+      label: "GPT-5.4",
+      description: "OpenAI's most capable model (max reasoning)",
+      updateArgs: {
+        reasoning_effort: "xhigh",
+        verbosity: "medium",
+        context_window: 272000,
+        max_output_tokens: 128000,
+        parallel_tool_calls: true
+      }
+    },
     {
       id: "gpt-5.3-codex-none",
       handle: "openai/gpt-5.3-codex",
@@ -8556,7 +8622,7 @@ function getDefaultModel() {
 }
 function getDefaultModelForTier(billingTier) {
   if (billingTier?.toLowerCase() === "free") {
-    const freeDefault = models.find((m) => m.id === "minimax-m2.5");
+    const freeDefault = models.find((m) => m.id === "glm-5");
     if (freeDefault)
       return freeDefault.handle;
   }
@@ -34859,7 +34925,7 @@ function getDefaultModel2() {
 }
 function getDefaultModelForTier2(billingTier) {
   if (billingTier?.toLowerCase() === "free") {
-    const freeDefault = models2.find((m) => m.id === "minimax-m2.5");
+    const freeDefault = models2.find((m) => m.id === "glm-5");
     if (freeDefault)
       return freeDefault.handle;
   }
@@ -60378,6 +60444,15 @@ async function getPrimaryAgentModelHandle() {
     return null;
   }
 }
+async function getCurrentBillingTier() {
+  try {
+    const client = await getClient2();
+    const balance = await client.get("/v1/metadata/balance");
+    return balance.billing_tier ?? null;
+  } catch {
+    return null;
+  }
+}
 function isProviderNotSupportedError(errorOutput) {
   return errorOutput.includes("Provider") && errorOutput.includes("is not supported") && errorOutput.includes("supported providers:");
 }
@@ -60401,13 +60476,16 @@ function swapProviderPrefix(parentHandle, recommendedHandle) {
   return `${parentProvider}/${modelPortion}`;
 }
 async function resolveSubagentModel(options) {
-  const { userModel, recommendedModel, parentModelHandle } = options;
+  const { userModel, recommendedModel, parentModelHandle, billingTier } = options;
   if (userModel)
     return userModel;
   let recommendedHandle = null;
   if (recommendedModel && recommendedModel !== "inherit") {
     recommendedHandle = resolveModel2(recommendedModel);
   }
+  if (recommendedModel !== "inherit" && billingTier?.toLowerCase() === "free") {
+    recommendedHandle = getDefaultModelForTier2(billingTier);
+  }
   let availableHandles = options.availableHandles ?? null;
   const isAvailable = async (handle) => {
     try {
@@ -60810,10 +60888,12 @@ async function spawnSubagent(type, prompt, userModel, subagentId, signal, existi
   }
   const isDeployingExisting = Boolean(existingAgentId || existingConversationId);
   const parentModelHandle = await getPrimaryAgentModelHandle();
+  const billingTier = await getCurrentBillingTier();
   const model = isDeployingExisting ? null : await resolveSubagentModel({
     userModel,
     recommendedModel: config.recommendedModel,
-    parentModelHandle
+    parentModelHandle,
+    billingTier
   });
   const baseURL = getBaseURL();
   let finalPrompt = prompt;
@@ -65791,7 +65871,7 @@ async function loadSpecificTools(toolNames) {
     releaseSwitchLock();
   }
 }
-async function loadTools(modelIdentifier) {
+async function loadTools(modelIdentifier, options) {
   acquireSwitchLock();
   try {
     const { toolFilter: toolFilter2 } = await Promise.resolve().then(() => (init_filter(), exports_filter));
@@ -65812,6 +65892,10 @@ async function loadTools(modelIdentifier) {
     } else {
       baseToolNames = TOOL_NAMES;
     }
+    if (options?.exclude && options.exclude.length > 0) {
+      const excludeSet = new Set(options.exclude);
+      baseToolNames = baseToolNames.filter((name) => !excludeSet.has(name));
+    }
     const newRegistry = new Map;
     for (const name of baseToolNames) {
       if (!toolFilter2.isEnabled(name)) {
@@ -66593,341 +66677,6 @@ var init_approval_execution = __esm(async () => {
   ]);
 });
 
-// src/agent/check-approval.ts
-var exports_check_approval = {};
-__export(exports_check_approval, {
-  prepareMessageHistory: () => prepareMessageHistory2,
-  getResumeData: () => getResumeData2,
-  extractApprovals: () => extractApprovals2
-});
-function isPrimaryMessageType2(messageType) {
-  return messageType === "user_message" || messageType === "assistant_message" || messageType === "event_message" || messageType === "summary_message";
-}
-function isAnchorMessageType2(messageType) {
-  return messageType === "user_message" || messageType === "assistant_message";
-}
-function isBackfillEnabled2() {
-  const val = process.env.LETTA_BACKFILL;
-  return val !== "0" && val !== "false";
-}
-function extractApprovals2(messageToCheck) {
-  const approvalMsg = messageToCheck;
-  const toolCalls = Array.isArray(approvalMsg.tool_calls) ? approvalMsg.tool_calls : approvalMsg.tool_call ? [approvalMsg.tool_call] : [];
-  const pendingApprovals = toolCalls.filter((tc) => !!tc && !!tc.tool_call_id).map((tc) => ({
-    toolCallId: tc.tool_call_id,
-    toolName: tc.name || "",
-    toolArgs: tc.arguments || ""
-  }));
-  const pendingApproval = pendingApprovals[0] || null;
-  if (pendingApprovals.length > 0) {
-    debugWarn("check-approval", `Found ${pendingApprovals.length} pending approval(s): ${pendingApprovals.map((a) => a.toolName).join(", ")}`);
-  }
-  return { pendingApproval, pendingApprovals };
-}
-function prepareMessageHistory2(messages, opts) {
-  const isRenderable = (msg) => {
-    const t = msg.message_type;
-    if (t === "user_message" || t === "assistant_message" || t === "reasoning_message" || t === "tool_call_message" || t === "tool_return_message" || t === "approval_request_message" || t === "approval_response_message") {
-      return true;
-    }
-    const ts = t;
-    return ts === "event_message" || ts === "summary_message";
-  };
-  const renderable = messages.filter(isRenderable);
-  if (opts?.primaryOnly) {
-    const convo = renderable.filter((m) => isPrimaryMessageType2(m.message_type));
-    let trimmed = convo.slice(-BACKFILL_PRIMARY_MESSAGE_LIMIT2);
-    const hasAssistant = trimmed.some((m) => m.message_type === "assistant_message");
-    if (!hasAssistant) {
-      const lastAssistantIndex = convo.map((m) => m.message_type).lastIndexOf("assistant_message");
-      if (lastAssistantIndex >= 0) {
-        const lastAssistant = convo[lastAssistantIndex];
-        if (lastAssistant) {
-          const tailLimit = Math.max(BACKFILL_PRIMARY_MESSAGE_LIMIT2 - 1, 0);
-          const newestTail = tailLimit > 0 ? convo.slice(-tailLimit) : [];
-          trimmed = [lastAssistant, ...newestTail];
-        }
-      }
-    }
-    if (trimmed.length > 0)
-      return trimmed;
-    const reasoning = renderable.filter((m) => m.message_type === "reasoning_message");
-    if (reasoning.length > 0) {
-      return reasoning.slice(-BACKFILL_PRIMARY_MESSAGE_LIMIT2);
-    }
-    return [];
-  }
-  const isPrimary = (msg) => {
-    const t = msg.message_type;
-    return t === "user_message" || t === "assistant_message" || t === "reasoning_message" || t === "event_message" || t === "summary_message";
-  };
-  let primaryCount = 0;
-  let startIndex = Math.max(0, renderable.length - 1);
-  for (let i = renderable.length - 1;i >= 0; i -= 1) {
-    const msg = renderable[i];
-    if (!msg)
-      continue;
-    if (isPrimary(msg)) {
-      primaryCount += 1;
-      if (primaryCount >= BACKFILL_PRIMARY_MESSAGE_LIMIT2) {
-        startIndex = i;
-        break;
-      }
-    }
-    startIndex = i;
-  }
-  let messageHistory = renderable.slice(startIndex);
-  if (messageHistory.length > BACKFILL_MAX_RENDERABLE_MESSAGES2) {
-    messageHistory = messageHistory.slice(-BACKFILL_MAX_RENDERABLE_MESSAGES2);
-  }
-  if (messageHistory[0]?.message_type === "tool_return_message") {
-    messageHistory = messageHistory.slice(1);
-  }
-  return messageHistory;
-}
-function sortChronological2(messages) {
-  return [...messages].sort((a, b) => {
-    const ta = a.date ? new Date(a.date).getTime() : 0;
-    const tb = b.date ? new Date(b.date).getTime() : 0;
-    if (!Number.isFinite(ta) && !Number.isFinite(tb))
-      return 0;
-    if (!Number.isFinite(ta))
-      return -1;
-    if (!Number.isFinite(tb))
-      return 1;
-    return ta - tb;
-  });
-}
-async function fetchConversationBackfillMessages2(client, conversationId) {
-  const collected = [];
-  const seen = new Set;
-  let cursorBefore = null;
-  let assistantCount = 0;
-  let anchorCount = 0;
-  for (let pageIndex = 0;pageIndex < BACKFILL_MAX_PAGES2; pageIndex += 1) {
-    const page = await client.conversations.messages.list(conversationId, {
-      limit: BACKFILL_PAGE_LIMIT2,
-      order: "desc",
-      ...cursorBefore ? { before: cursorBefore } : {}
-    });
-    const items = page.getPaginatedItems();
-    if (items.length === 0)
-      break;
-    cursorBefore = items[items.length - 1]?.id ?? null;
-    for (const m of items) {
-      if (!m?.id)
-        continue;
-      const key = "otid" in m && m.otid ? `otid:${String(m.otid)}` : `id:${m.id}:${m.message_type ?? ""}`;
-      if (seen.has(key))
-        continue;
-      seen.add(key);
-      collected.push(m);
-      if (m.message_type === "assistant_message")
-        assistantCount += 1;
-      if (isAnchorMessageType2(m.message_type))
-        anchorCount += 1;
-    }
-    if (assistantCount >= BACKFILL_MIN_ASSISTANT2 && anchorCount >= BACKFILL_ANCHOR_MESSAGE_LIMIT2) {
-      break;
-    }
-    if (items.length < BACKFILL_PAGE_LIMIT2)
-      break;
-  }
-  if (assistantCount < BACKFILL_MIN_ASSISTANT2) {
-    debugWarn("check-approval", `Backfill scan found 0 assistant messages in last ${collected.length} messages (tool-heavy conversation?)`);
-  }
-  return sortChronological2(collected);
-}
-async function getResumeData2(client, agent, conversationId, options = {}) {
-  try {
-    const includeMessageHistory = options.includeMessageHistory ?? true;
-    let inContextMessageIds;
-    let messages = [];
-    const useConversationsApi = conversationId && conversationId !== "default";
-    if (useConversationsApi) {
-      const conversation = await client.conversations.retrieve(conversationId);
-      inContextMessageIds = conversation.in_context_message_ids;
-      if (!inContextMessageIds || inContextMessageIds.length === 0) {
-        debugWarn("check-approval", "No in-context messages - no pending approvals");
-        if (includeMessageHistory && isBackfillEnabled2()) {
-          try {
-            const backfill = await fetchConversationBackfillMessages2(client, conversationId);
-            return {
-              pendingApproval: null,
-              pendingApprovals: [],
-              messageHistory: prepareMessageHistory2(backfill, {
-                primaryOnly: true
-              })
-            };
-          } catch (backfillError) {
-            debugWarn("check-approval", `Failed to load message history: ${backfillError instanceof Error ? backfillError.message : String(backfillError)}`);
-          }
-        }
-        return {
-          pendingApproval: null,
-          pendingApprovals: [],
-          messageHistory: []
-        };
-      }
-      const lastInContextId = inContextMessageIds.at(-1);
-      if (!lastInContextId) {
-        throw new Error("Expected at least one in-context message");
-      }
-      const retrievedMessages = await client.messages.retrieve(lastInContextId);
-      if (includeMessageHistory && isBackfillEnabled2()) {
-        try {
-          messages = await fetchConversationBackfillMessages2(client, conversationId);
-        } catch (backfillError) {
-          debugWarn("check-approval", `Failed to load message history: ${backfillError instanceof Error ? backfillError.message : String(backfillError)}`);
-        }
-      }
-      const messageToCheck = retrievedMessages.find((msg) => msg.message_type === "approval_request_message") ?? retrievedMessages[0];
-      if (messageToCheck) {
-        debugWarn("check-approval", `Found last in-context message: ${messageToCheck.id} (type: ${messageToCheck.message_type})` + (retrievedMessages.length > 1 ? ` - had ${retrievedMessages.length} variants` : ""));
-        if (messageToCheck.message_type === "approval_request_message") {
-          const { pendingApproval, pendingApprovals } = extractApprovals2(messageToCheck);
-          return {
-            pendingApproval,
-            pendingApprovals,
-            messageHistory: prepareMessageHistory2(messages, {
-              primaryOnly: true
-            })
-          };
-        }
-      } else {
-        debugWarn("check-approval", `Last in-context message ${lastInContextId} not found via retrieve`);
-      }
-      return {
-        pendingApproval: null,
-        pendingApprovals: [],
-        messageHistory: prepareMessageHistory2(messages, { primaryOnly: true })
-      };
-    } else {
-      inContextMessageIds = agent.message_ids;
-      if (!inContextMessageIds || inContextMessageIds.length === 0) {
-        debugWarn("check-approval", "No in-context messages (default/agent API) - no pending approvals");
-        return {
-          pendingApproval: null,
-          pendingApprovals: [],
-          messageHistory: []
-        };
-      }
-      const lastInContextId = inContextMessageIds.at(-1);
-      if (!lastInContextId) {
-        throw new Error("Expected at least one in-context message");
-      }
-      const retrievedMessages = await client.messages.retrieve(lastInContextId);
-      if (includeMessageHistory && isBackfillEnabled2()) {
-        try {
-          const messagesPage = await client.conversations.messages.list("default", {
-            agent_id: agent.id,
-            limit: BACKFILL_PAGE_LIMIT2,
-            order: "desc"
-          });
-          messages = sortChronological2(messagesPage.getPaginatedItems());
-          if (process.env.DEBUG) {
-            console.log(`[DEBUG] conversations.messages.list(default, agent_id=${agent.id}) returned ${messages.length} messages`);
-          }
-        } catch (backfillError) {
-          debugWarn("check-approval", `Failed to load message history: ${backfillError instanceof Error ? backfillError.message : String(backfillError)}`);
-        }
-      }
-      const messageToCheck = retrievedMessages.find((msg) => msg.message_type === "approval_request_message") ?? retrievedMessages[0];
-      if (messageToCheck) {
-        debugWarn("check-approval", `Found last in-context message: ${messageToCheck.id} (type: ${messageToCheck.message_type})` + (retrievedMessages.length > 1 ? ` - had ${retrievedMessages.length} variants` : ""));
-        if (messageToCheck.message_type === "approval_request_message") {
-          const { pendingApproval, pendingApprovals } = extractApprovals2(messageToCheck);
-          return {
-            pendingApproval,
-            pendingApprovals,
-            messageHistory: prepareMessageHistory2(messages, {
-              primaryOnly: true
-            })
-          };
-        }
-      } else {
-        debugWarn("check-approval", `Last in-context message ${lastInContextId} not found via retrieve (default/agent API)`);
-      }
-      return {
-        pendingApproval: null,
-        pendingApprovals: [],
-        messageHistory: prepareMessageHistory2(messages, { primaryOnly: true })
-      };
-    }
-  } catch (error) {
-    if (error instanceof APIError2 && (error.status === 404 || error.status === 422)) {
-      throw error;
-    }
-    console.error("Error getting resume data:", error);
-    return { pendingApproval: null, pendingApprovals: [], messageHistory: [] };
-  }
-}
-var BACKFILL_PRIMARY_MESSAGE_LIMIT2 = 12, BACKFILL_MAX_RENDERABLE_MESSAGES2 = 80, BACKFILL_ANCHOR_MESSAGE_LIMIT2 = 6, BACKFILL_PAGE_LIMIT2 = 200, BACKFILL_MAX_PAGES2 = 25, BACKFILL_MIN_ASSISTANT2 = 1;
-var init_check_approval = __esm(() => {
-  init_error();
-  init_debug();
-});
-
-// src/agent/message.ts
-function getStreamRequestStartTime(stream2) {
-  return streamRequestStartTimes.get(stream2);
-}
-function getStreamToolContextId(stream2) {
-  return streamToolContextIds.get(stream2) ?? null;
-}
-function getStreamRequestContext(stream2) {
-  return streamRequestContexts.get(stream2);
-}
-async function sendMessageStream(conversationId, messages, opts = { streamTokens: true, background: true }, requestOptions = {
-  maxRetries: 0
-}) {
-  const requestStartTime = isTimingsEnabled() ? performance.now() : undefined;
-  const requestStartedAtMs = Date.now();
-  const client = await getClient2();
-  await waitForToolsetReady();
-  const { clientTools, contextId } = captureToolExecutionContext();
-  const isDefaultConversation = conversationId === "default";
-  if (isDefaultConversation && !opts.agentId) {
-    throw new Error("agentId is required in opts when using default conversation");
-  }
-  const resolvedConversationId = conversationId;
-  const requestBody = {
-    messages,
-    streaming: true,
-    stream_tokens: opts.streamTokens ?? true,
-    background: opts.background ?? true,
-    client_tools: clientTools,
-    include_compaction_messages: true,
-    ...isDefaultConversation ? { agent_id: opts.agentId } : {}
-  };
-  if (process.env.DEBUG) {
-    console.log(`[DEBUG] sendMessageStream: conversationId=${conversationId}, agentId=${opts.agentId ?? "(none)"}`);
-  }
-  const stream2 = await client.conversations.messages.create(resolvedConversationId, requestBody, requestOptions);
-  if (requestStartTime !== undefined) {
-    streamRequestStartTimes.set(stream2, requestStartTime);
-  }
-  streamToolContextIds.set(stream2, contextId);
-  streamRequestContexts.set(stream2, {
-    conversationId,
-    resolvedConversationId,
-    agentId: opts.agentId ?? null,
-    requestStartedAtMs
-  });
-  return stream2;
-}
-var streamRequestStartTimes, streamToolContextIds, streamRequestContexts;
-var init_message = __esm(async () => {
-  init_timing();
-  await __promiseAll([
-    init_manager3(),
-    init_client2()
-  ]);
-  streamRequestStartTimes = new WeakMap;
-  streamToolContextIds = new WeakMap;
-  streamRequestContexts = new WeakMap;
-});
-
 // src/cli/helpers/errorFormatter.ts
 function extractReasonList2(value) {
   if (!Array.isArray(value))
@@ -67631,6 +67380,359 @@ var init_turn_recovery_policy = __esm(() => {
   RETRYABLE_429_PATTERN = /Error code:\s*429|rate limit|too many requests/i;
 });
 
+// src/agent/approval-recovery.ts
+async function fetchRunErrorDetail(runId) {
+  if (!runId)
+    return null;
+  try {
+    const client = await getClient2();
+    const run = await client.runs.retrieve(runId);
+    const metaError = run.metadata?.error;
+    return metaError?.detail ?? metaError?.message ?? metaError?.error?.detail ?? metaError?.error?.message ?? null;
+  } catch {
+    return null;
+  }
+}
+var init_approval_recovery = __esm(async () => {
+  init_turn_recovery_policy();
+  await init_client2();
+});
+
+// src/agent/check-approval.ts
+var exports_check_approval = {};
+__export(exports_check_approval, {
+  prepareMessageHistory: () => prepareMessageHistory2,
+  getResumeData: () => getResumeData2,
+  extractApprovals: () => extractApprovals2
+});
+function isPrimaryMessageType2(messageType) {
+  return messageType === "user_message" || messageType === "assistant_message" || messageType === "event_message" || messageType === "summary_message";
+}
+function isAnchorMessageType2(messageType) {
+  return messageType === "user_message" || messageType === "assistant_message";
+}
+function isBackfillEnabled2() {
+  const val = process.env.LETTA_BACKFILL;
+  return val !== "0" && val !== "false";
+}
+function extractApprovals2(messageToCheck) {
+  const approvalMsg = messageToCheck;
+  const toolCalls = Array.isArray(approvalMsg.tool_calls) ? approvalMsg.tool_calls : approvalMsg.tool_call ? [approvalMsg.tool_call] : [];
+  const pendingApprovals = toolCalls.filter((tc) => !!tc && !!tc.tool_call_id).map((tc) => ({
+    toolCallId: tc.tool_call_id,
+    toolName: tc.name || "",
+    toolArgs: tc.arguments || ""
+  }));
+  const pendingApproval = pendingApprovals[0] || null;
+  if (pendingApprovals.length > 0) {
+    debugWarn("check-approval", `Found ${pendingApprovals.length} pending approval(s): ${pendingApprovals.map((a) => a.toolName).join(", ")}`);
+  }
+  return { pendingApproval, pendingApprovals };
+}
+function prepareMessageHistory2(messages, opts) {
+  const isRenderable = (msg) => {
+    const t = msg.message_type;
+    if (t === "user_message" || t === "assistant_message" || t === "reasoning_message" || t === "tool_call_message" || t === "tool_return_message" || t === "approval_request_message" || t === "approval_response_message") {
+      return true;
+    }
+    const ts = t;
+    return ts === "event_message" || ts === "summary_message";
+  };
+  const renderable = messages.filter(isRenderable);
+  if (opts?.primaryOnly) {
+    const convo = renderable.filter((m) => isPrimaryMessageType2(m.message_type));
+    let trimmed = convo.slice(-BACKFILL_PRIMARY_MESSAGE_LIMIT2);
+    const hasAssistant = trimmed.some((m) => m.message_type === "assistant_message");
+    if (!hasAssistant) {
+      const lastAssistantIndex = convo.map((m) => m.message_type).lastIndexOf("assistant_message");
+      if (lastAssistantIndex >= 0) {
+        const lastAssistant = convo[lastAssistantIndex];
+        if (lastAssistant) {
+          const tailLimit = Math.max(BACKFILL_PRIMARY_MESSAGE_LIMIT2 - 1, 0);
+          const newestTail = tailLimit > 0 ? convo.slice(-tailLimit) : [];
+          trimmed = [lastAssistant, ...newestTail];
+        }
+      }
+    }
+    if (trimmed.length > 0)
+      return trimmed;
+    const reasoning = renderable.filter((m) => m.message_type === "reasoning_message");
+    if (reasoning.length > 0) {
+      return reasoning.slice(-BACKFILL_PRIMARY_MESSAGE_LIMIT2);
+    }
+    return [];
+  }
+  const isPrimary = (msg) => {
+    const t = msg.message_type;
+    return t === "user_message" || t === "assistant_message" || t === "reasoning_message" || t === "event_message" || t === "summary_message";
+  };
+  let primaryCount = 0;
+  let startIndex = Math.max(0, renderable.length - 1);
+  for (let i = renderable.length - 1;i >= 0; i -= 1) {
+    const msg = renderable[i];
+    if (!msg)
+      continue;
+    if (isPrimary(msg)) {
+      primaryCount += 1;
+      if (primaryCount >= BACKFILL_PRIMARY_MESSAGE_LIMIT2) {
+        startIndex = i;
+        break;
+      }
+    }
+    startIndex = i;
+  }
+  let messageHistory = renderable.slice(startIndex);
+  if (messageHistory.length > BACKFILL_MAX_RENDERABLE_MESSAGES2) {
+    messageHistory = messageHistory.slice(-BACKFILL_MAX_RENDERABLE_MESSAGES2);
+  }
+  if (messageHistory[0]?.message_type === "tool_return_message") {
+    messageHistory = messageHistory.slice(1);
+  }
+  return messageHistory;
+}
+function sortChronological2(messages) {
+  return [...messages].sort((a, b) => {
+    const ta = a.date ? new Date(a.date).getTime() : 0;
+    const tb = b.date ? new Date(b.date).getTime() : 0;
+    if (!Number.isFinite(ta) && !Number.isFinite(tb))
+      return 0;
+    if (!Number.isFinite(ta))
+      return -1;
+    if (!Number.isFinite(tb))
+      return 1;
+    return ta - tb;
+  });
+}
+async function fetchConversationBackfillMessages2(client, conversationId) {
+  const collected = [];
+  const seen = new Set;
+  let cursorBefore = null;
+  let assistantCount = 0;
+  let anchorCount = 0;
+  for (let pageIndex = 0;pageIndex < BACKFILL_MAX_PAGES2; pageIndex += 1) {
+    const page = await client.conversations.messages.list(conversationId, {
+      limit: BACKFILL_PAGE_LIMIT2,
+      order: "desc",
+      ...cursorBefore ? { before: cursorBefore } : {}
+    });
+    const items = page.getPaginatedItems();
+    if (items.length === 0)
+      break;
+    cursorBefore = items[items.length - 1]?.id ?? null;
+    for (const m of items) {
+      if (!m?.id)
+        continue;
+      const key = "otid" in m && m.otid ? `otid:${String(m.otid)}` : `id:${m.id}:${m.message_type ?? ""}`;
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      collected.push(m);
+      if (m.message_type === "assistant_message")
+        assistantCount += 1;
+      if (isAnchorMessageType2(m.message_type))
+        anchorCount += 1;
+    }
+    if (assistantCount >= BACKFILL_MIN_ASSISTANT2 && anchorCount >= BACKFILL_ANCHOR_MESSAGE_LIMIT2) {
+      break;
+    }
+    if (items.length < BACKFILL_PAGE_LIMIT2)
+      break;
+  }
+  if (assistantCount < BACKFILL_MIN_ASSISTANT2) {
+    debugWarn("check-approval", `Backfill scan found 0 assistant messages in last ${collected.length} messages (tool-heavy conversation?)`);
+  }
+  return sortChronological2(collected);
+}
+async function getResumeData2(client, agent, conversationId, options = {}) {
+  try {
+    const includeMessageHistory = options.includeMessageHistory ?? true;
+    let inContextMessageIds;
+    let messages = [];
+    const useConversationsApi = conversationId && conversationId !== "default";
+    if (useConversationsApi) {
+      const conversation = await client.conversations.retrieve(conversationId);
+      inContextMessageIds = conversation.in_context_message_ids;
+      if (!inContextMessageIds || inContextMessageIds.length === 0) {
+        debugWarn("check-approval", "No in-context messages - no pending approvals");
+        if (includeMessageHistory && isBackfillEnabled2()) {
+          try {
+            const backfill = await fetchConversationBackfillMessages2(client, conversationId);
+            return {
+              pendingApproval: null,
+              pendingApprovals: [],
+              messageHistory: prepareMessageHistory2(backfill, {
+                primaryOnly: true
+              })
+            };
+          } catch (backfillError) {
+            debugWarn("check-approval", `Failed to load message history: ${backfillError instanceof Error ? backfillError.message : String(backfillError)}`);
+          }
+        }
+        return {
+          pendingApproval: null,
+          pendingApprovals: [],
+          messageHistory: []
+        };
+      }
+      const lastInContextId = inContextMessageIds.at(-1);
+      if (!lastInContextId) {
+        throw new Error("Expected at least one in-context message");
+      }
+      const retrievedMessages = await client.messages.retrieve(lastInContextId);
+      if (includeMessageHistory && isBackfillEnabled2()) {
+        try {
+          messages = await fetchConversationBackfillMessages2(client, conversationId);
+        } catch (backfillError) {
+          debugWarn("check-approval", `Failed to load message history: ${backfillError instanceof Error ? backfillError.message : String(backfillError)}`);
+        }
+      }
+      const messageToCheck = retrievedMessages.find((msg) => msg.message_type === "approval_request_message") ?? retrievedMessages[0];
+      if (messageToCheck) {
+        debugWarn("check-approval", `Found last in-context message: ${messageToCheck.id} (type: ${messageToCheck.message_type})` + (retrievedMessages.length > 1 ? ` - had ${retrievedMessages.length} variants` : ""));
+        if (messageToCheck.message_type === "approval_request_message") {
+          const { pendingApproval, pendingApprovals } = extractApprovals2(messageToCheck);
+          return {
+            pendingApproval,
+            pendingApprovals,
+            messageHistory: prepareMessageHistory2(messages, {
+              primaryOnly: true
+            })
+          };
+        }
+      } else {
+        debugWarn("check-approval", `Last in-context message ${lastInContextId} not found via retrieve`);
+      }
+      return {
+        pendingApproval: null,
+        pendingApprovals: [],
+        messageHistory: prepareMessageHistory2(messages, { primaryOnly: true })
+      };
+    } else {
+      inContextMessageIds = agent.message_ids;
+      if (!inContextMessageIds || inContextMessageIds.length === 0) {
+        debugWarn("check-approval", "No in-context messages (default/agent API) - no pending approvals");
+        return {
+          pendingApproval: null,
+          pendingApprovals: [],
+          messageHistory: []
+        };
+      }
+      const lastInContextId = inContextMessageIds.at(-1);
+      if (!lastInContextId) {
+        throw new Error("Expected at least one in-context message");
+      }
+      const retrievedMessages = await client.messages.retrieve(lastInContextId);
+      if (includeMessageHistory && isBackfillEnabled2()) {
+        try {
+          const messagesPage = await client.conversations.messages.list("default", {
+            agent_id: agent.id,
+            limit: BACKFILL_PAGE_LIMIT2,
+            order: "desc"
+          });
+          messages = sortChronological2(messagesPage.getPaginatedItems());
+          if (process.env.DEBUG) {
+            console.log(`[DEBUG] conversations.messages.list(default, agent_id=${agent.id}) returned ${messages.length} messages`);
+          }
+        } catch (backfillError) {
+          debugWarn("check-approval", `Failed to load message history: ${backfillError instanceof Error ? backfillError.message : String(backfillError)}`);
+        }
+      }
+      const messageToCheck = retrievedMessages.find((msg) => msg.message_type === "approval_request_message") ?? retrievedMessages[0];
+      if (messageToCheck) {
+        debugWarn("check-approval", `Found last in-context message: ${messageToCheck.id} (type: ${messageToCheck.message_type})` + (retrievedMessages.length > 1 ? ` - had ${retrievedMessages.length} variants` : ""));
+        if (messageToCheck.message_type === "approval_request_message") {
+          const { pendingApproval, pendingApprovals } = extractApprovals2(messageToCheck);
+          return {
+            pendingApproval,
+            pendingApprovals,
+            messageHistory: prepareMessageHistory2(messages, {
+              primaryOnly: true
+            })
+          };
+        }
+      } else {
+        debugWarn("check-approval", `Last in-context message ${lastInContextId} not found via retrieve (default/agent API)`);
+      }
+      return {
+        pendingApproval: null,
+        pendingApprovals: [],
+        messageHistory: prepareMessageHistory2(messages, { primaryOnly: true })
+      };
+    }
+  } catch (error) {
+    if (error instanceof APIError2 && (error.status === 404 || error.status === 422)) {
+      throw error;
+    }
+    console.error("Error getting resume data:", error);
+    return { pendingApproval: null, pendingApprovals: [], messageHistory: [] };
+  }
+}
+var BACKFILL_PRIMARY_MESSAGE_LIMIT2 = 12, BACKFILL_MAX_RENDERABLE_MESSAGES2 = 80, BACKFILL_ANCHOR_MESSAGE_LIMIT2 = 6, BACKFILL_PAGE_LIMIT2 = 200, BACKFILL_MAX_PAGES2 = 25, BACKFILL_MIN_ASSISTANT2 = 1;
+var init_check_approval = __esm(() => {
+  init_error();
+  init_debug();
+});
+
+// src/agent/message.ts
+function getStreamRequestStartTime(stream2) {
+  return streamRequestStartTimes.get(stream2);
+}
+function getStreamToolContextId(stream2) {
+  return streamToolContextIds.get(stream2) ?? null;
+}
+function getStreamRequestContext(stream2) {
+  return streamRequestContexts.get(stream2);
+}
+async function sendMessageStream(conversationId, messages, opts = { streamTokens: true, background: true }, requestOptions = {
+  maxRetries: 0
+}) {
+  const requestStartTime = isTimingsEnabled() ? performance.now() : undefined;
+  const requestStartedAtMs = Date.now();
+  const client = await getClient2();
+  await waitForToolsetReady();
+  const { clientTools, contextId } = captureToolExecutionContext();
+  const isDefaultConversation = conversationId === "default";
+  if (isDefaultConversation && !opts.agentId) {
+    throw new Error("agentId is required in opts when using default conversation");
+  }
+  const resolvedConversationId = conversationId;
+  const requestBody = {
+    messages,
+    streaming: true,
+    stream_tokens: opts.streamTokens ?? true,
+    background: opts.background ?? true,
+    client_tools: clientTools,
+    include_compaction_messages: true,
+    ...isDefaultConversation ? { agent_id: opts.agentId } : {}
+  };
+  if (process.env.DEBUG) {
+    console.log(`[DEBUG] sendMessageStream: conversationId=${conversationId}, agentId=${opts.agentId ?? "(none)"}`);
+  }
+  const stream2 = await client.conversations.messages.create(resolvedConversationId, requestBody, requestOptions);
+  if (requestStartTime !== undefined) {
+    streamRequestStartTimes.set(stream2, requestStartTime);
+  }
+  streamToolContextIds.set(stream2, contextId);
+  streamRequestContexts.set(stream2, {
+    conversationId,
+    resolvedConversationId,
+    agentId: opts.agentId ?? null,
+    requestStartedAtMs
+  });
+  return stream2;
+}
+var streamRequestStartTimes, streamToolContextIds, streamRequestContexts;
+var init_message = __esm(async () => {
+  init_timing();
+  await __promiseAll([
+    init_manager3(),
+    init_client2()
+  ]);
+  streamRequestStartTimes = new WeakMap;
+  streamToolContextIds = new WeakMap;
+  streamRequestContexts = new WeakMap;
+});
+
 // src/cli/helpers/backfill.ts
 function getDisplayableToolReturn2(content) {
   if (!content)
@@ -71054,6 +71156,9 @@ function createRuntime() {
     cancelRequested: false,
     isRecoveringApprovals: false,
     pendingApprovalBatchByToolCallId: new Map,
+    pendingInterruptedResults: null,
+    pendingInterruptedContext: null,
+    continuationEpoch: 0,
     coalescedSkipQueueItemIds: new Set,
     pendingTurns: 0,
     queueRuntime: null
@@ -71168,6 +71273,12 @@ function resolvePendingApprovalBatchId(runtime, pendingApprovals) {
   }
   return batchIds.values().next().value ?? null;
 }
+function resolveRecoveryBatchId(runtime, pendingApprovals) {
+  if (runtime.pendingApprovalBatchByToolCallId.size === 0) {
+    return `recovery-${crypto.randomUUID()}`;
+  }
+  return resolvePendingApprovalBatchId(runtime, pendingApprovals);
+}
 function clearPendingApprovalBatchIds(runtime, approvals) {
   for (const approval of approvals) {
     runtime.pendingApprovalBatchByToolCallId.delete(approval.toolCallId);
@@ -71182,6 +71293,9 @@ function stopRuntime(runtime, suppressCallbacks) {
   clearRuntimeTimers(runtime);
   rejectPendingApprovalResolvers(runtime, "Listener runtime stopped");
   runtime.pendingApprovalBatchByToolCallId.clear();
+  runtime.pendingInterruptedResults = null;
+  runtime.pendingInterruptedContext = null;
+  runtime.continuationEpoch++;
   if (!runtime.socket) {
     return;
   }
@@ -71366,9 +71480,201 @@ function emitToWS(socket, event) {
     socket.send(JSON.stringify(outbound));
   }
 }
+function normalizeToolReturnValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === null || value === undefined) {
+    return "";
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function extractInterruptToolReturns(approvals) {
+  if (!approvals || approvals.length === 0) {
+    return [];
+  }
+  return approvals.flatMap((approval) => {
+    if (!approval || typeof approval !== "object") {
+      return [];
+    }
+    if ("type" in approval && approval.type === "tool") {
+      const toolCallId = "tool_call_id" in approval && typeof approval.tool_call_id === "string" ? approval.tool_call_id : null;
+      if (!toolCallId) {
+        return [];
+      }
+      const status = "status" in approval && approval.status === "success" ? "success" : "error";
+      const stdout = "stdout" in approval && Array.isArray(approval.stdout) ? approval.stdout.filter((entry) => typeof entry === "string") : undefined;
+      const stderr = "stderr" in approval && Array.isArray(approval.stderr) ? approval.stderr.filter((entry) => typeof entry === "string") : undefined;
+      return [
+        {
+          tool_call_id: toolCallId,
+          status,
+          tool_return: "tool_return" in approval ? normalizeToolReturnValue(approval.tool_return) : "",
+          ...stdout ? { stdout } : {},
+          ...stderr ? { stderr } : {}
+        }
+      ];
+    }
+    if ("type" in approval && approval.type === "approval") {
+      const toolCallId = "tool_call_id" in approval && typeof approval.tool_call_id === "string" ? approval.tool_call_id : null;
+      if (!toolCallId) {
+        return [];
+      }
+      const reason = "reason" in approval && typeof approval.reason === "string" ? approval.reason : "User interrupted the stream";
+      return [
+        {
+          tool_call_id: toolCallId,
+          status: "error",
+          tool_return: reason
+        }
+      ];
+    }
+    return [];
+  });
+}
+function emitInterruptToolReturnMessage(socket, runtime, approvals, runId, uuidPrefix = "interrupt-tool-return") {
+  const toolReturns = extractInterruptToolReturns(approvals);
+  if (toolReturns.length === 0) {
+    return;
+  }
+  const resolvedRunId = runId ?? runtime.activeRunId ?? undefined;
+  for (const toolReturn of toolReturns) {
+    emitToWS(socket, {
+      type: "message",
+      message_type: "tool_return_message",
+      id: `message-${crypto.randomUUID()}`,
+      date: new Date().toISOString(),
+      run_id: resolvedRunId,
+      tool_call_id: toolReturn.tool_call_id,
+      tool_return: toolReturn.tool_return,
+      status: toolReturn.status,
+      ...toolReturn.stdout ? { stdout: toolReturn.stdout } : {},
+      ...toolReturn.stderr ? { stderr: toolReturn.stderr } : {},
+      tool_returns: [toolReturn],
+      session_id: runtime.sessionId,
+      uuid: `${uuidPrefix}-${crypto.randomUUID()}`
+    });
+  }
+}
+function getInterruptApprovalsForEmission(runtime, params) {
+  if (params.lastExecutionResults && params.lastExecutionResults.length > 0) {
+    return params.lastExecutionResults;
+  }
+  const context3 = runtime.pendingInterruptedContext;
+  if (!context3 || context3.agentId !== params.agentId || context3.conversationId !== params.conversationId || context3.continuationEpoch !== runtime.continuationEpoch) {
+    return null;
+  }
+  if (!runtime.pendingInterruptedResults || runtime.pendingInterruptedResults.length === 0) {
+    return null;
+  }
+  return runtime.pendingInterruptedResults;
+}
+function populateInterruptQueue(runtime, input) {
+  const shouldPopulate = !runtime.pendingInterruptedResults || runtime.pendingInterruptedResults.length === 0 || !runtime.pendingInterruptedContext;
+  if (!shouldPopulate)
+    return false;
+  if (input.lastExecutionResults && input.lastExecutionResults.length > 0) {
+    runtime.pendingInterruptedResults = input.lastExecutionResults;
+    runtime.pendingInterruptedContext = {
+      agentId: input.agentId,
+      conversationId: input.conversationId,
+      continuationEpoch: runtime.continuationEpoch
+    };
+    return true;
+  }
+  const batchToolCallIds = [...runtime.pendingApprovalBatchByToolCallId.keys()];
+  const pendingIds = batchToolCallIds.length > 0 ? batchToolCallIds : input.lastNeedsUserInputToolCallIds;
+  if (pendingIds.length > 0) {
+    runtime.pendingInterruptedResults = pendingIds.map((toolCallId) => ({
+      type: "approval",
+      tool_call_id: toolCallId,
+      approve: false,
+      reason: "User interrupted the stream"
+    }));
+    runtime.pendingInterruptedContext = {
+      agentId: input.agentId,
+      conversationId: input.conversationId,
+      continuationEpoch: runtime.continuationEpoch
+    };
+    return true;
+  }
+  if (process.env.DEBUG) {
+    console.warn("[Listen] Cancel during approval loop but no tool_call_ids available " + "for interrupted queue — next turn may hit pre-stream conflict. " + `batchMap=${runtime.pendingApprovalBatchByToolCallId.size}, ` + `lastNeedsUserInput=${input.lastNeedsUserInputToolCallIds.length}`);
+  }
+  return false;
+}
+function consumeInterruptQueue(runtime, agentId, conversationId) {
+  if (!runtime.pendingInterruptedResults || runtime.pendingInterruptedResults.length === 0) {
+    return null;
+  }
+  const ctx = runtime.pendingInterruptedContext;
+  let result = null;
+  if (ctx && ctx.agentId === agentId && ctx.conversationId === conversationId && ctx.continuationEpoch === runtime.continuationEpoch) {
+    result = {
+      type: "approval",
+      approvals: runtime.pendingInterruptedResults
+    };
+  }
+  runtime.pendingInterruptedResults = null;
+  runtime.pendingInterruptedContext = null;
+  runtime.pendingApprovalBatchByToolCallId.clear();
+  return result;
+}
+async function resolveStaleApprovals(runtime, abortSignal) {
+  if (!runtime.activeAgentId)
+    return;
+  const client = await getClient2();
+  let agent;
+  try {
+    agent = await client.agents.retrieve(runtime.activeAgentId);
+  } catch (err) {
+    if (err instanceof APIError2 && (err.status === 404 || err.status === 422)) {
+      return;
+    }
+    throw err;
+  }
+  const requestedConversationId = runtime.activeConversationId && runtime.activeConversationId !== "default" ? runtime.activeConversationId : undefined;
+  let resumeData;
+  try {
+    resumeData = await getResumeData2(client, agent, requestedConversationId, {
+      includeMessageHistory: false
+    });
+  } catch (err) {
+    if (err instanceof APIError2 && (err.status === 404 || err.status === 422)) {
+      return;
+    }
+    throw err;
+  }
+  const pendingApprovals = resumeData.pendingApprovals || [];
+  if (pendingApprovals.length === 0)
+    return;
+  if (abortSignal.aborted)
+    throw new Error("Cancelled");
+  const denialResults = pendingApprovals.map((approval) => ({
+    type: "approval",
+    tool_call_id: approval.toolCallId,
+    approve: false,
+    reason: "Auto-denied during pre-stream approval recovery"
+  }));
+  const recoveryConversationId = runtime.activeConversationId || "default";
+  const recoveryStream = await sendMessageStream(recoveryConversationId, [{ type: "approval", approvals: denialResults }], {
+    agentId: runtime.activeAgentId,
+    streamTokens: true,
+    background: true
+  }, { maxRetries: 0, signal: abortSignal });
+  const drainResult = await drainStreamWithResume(recoveryStream, createBuffers(runtime.activeAgentId), () => {}, abortSignal);
+  if (drainResult.stopReason === "error") {
+    throw new Error("Pre-stream approval recovery drain ended with error");
+  }
+}
 async function sendMessageStreamWithRetry(conversationId, messages, opts, socket, runtime, abortSignal) {
   let transientRetries = 0;
   let conversationBusyRetries = 0;
+  let preStreamRecoveryAttempts = 0;
   const MAX_CONVERSATION_BUSY_RETRIES = 1;
   while (true) {
     if (abortSignal?.aborted) {
@@ -71387,7 +71693,20 @@ async function sendMessageStreamWithRetry(conversationId, messages, opts, socket
         maxTransientRetries: LLM_API_ERROR_MAX_RETRIES
       });
       if (action === "resolve_approval_pending") {
-        throw preStreamError;
+        if (abortSignal?.aborted)
+          throw new Error("Cancelled by user");
+        if (abortSignal && preStreamRecoveryAttempts < MAX_PRE_STREAM_RECOVERY) {
+          preStreamRecoveryAttempts++;
+          try {
+            await resolveStaleApprovals(runtime, abortSignal);
+            continue;
+          } catch (_recoveryError) {
+            if (abortSignal.aborted)
+              throw new Error("Cancelled by user");
+          }
+        }
+        const detail = await fetchRunErrorDetail(runtime.activeRunId);
+        throw new Error(detail || `Pre-stream approval conflict (resolve_approval_pending) after ${preStreamRecoveryAttempts} recovery attempts`);
       }
       if (action === "retry_transient") {
         const attempt = transientRetries + 1;
@@ -71529,6 +71848,13 @@ function buildApprovalExecutionPlan(approvalMessage, pendingApprovals) {
   return { slots, decisions };
 }
 async function recoverPendingApprovals(runtime, socket, msg) {
+  console.debug("[listener] recover_pending_approvals received", JSON.stringify({
+    agentId: msg.agentId,
+    conversationId: msg.conversationId ?? null,
+    isProcessing: runtime.isProcessing,
+    isRecovering: runtime.isRecoveringApprovals,
+    batchMapSize: runtime.pendingApprovalBatchByToolCallId.size
+  }));
   if (runtime.isProcessing || runtime.isRecoveringApprovals) {
     return;
   }
@@ -71557,11 +71883,11 @@ async function recoverPendingApprovals(runtime, socket, msg) {
     if (pendingApprovals.length === 0) {
       return;
     }
-    const recoveryBatchId = resolvePendingApprovalBatchId(runtime, pendingApprovals);
+    const recoveryBatchId = resolveRecoveryBatchId(runtime, pendingApprovals);
     if (!recoveryBatchId) {
       emitToWS(socket, {
         type: "error",
-        message: "Unable to recover pending approvals without originating batch correlation",
+        message: "Unable to recover pending approvals: ambiguous batch correlation",
         stop_reason: "error",
         session_id: runtime.sessionId,
         uuid: `error-${crypto.randomUUID()}`
@@ -71604,6 +71930,7 @@ async function recoverPendingApprovals(runtime, socket, msg) {
         runtime.lastStopReason = "requires_approval";
         return;
       }
+      runtime.lastStopReason = "requires_approval";
       for (const ac of needsUserInput) {
         const requestId = `perm-${ac.approval.toolCallId}`;
         const diffs = await computeDiffPreviews(ac.approval.toolName, ac.parsedArgs);
@@ -71816,6 +72143,14 @@ async function connectWithRetry(runtime, opts, attempt = 0, startTime = Date.now
       if (hasPendingApprovals) {
         rejectPendingApprovalResolvers(runtime, "Cancelled by user");
       }
+      const cancelConversationId = runtime.activeConversationId;
+      const cancelAgentId = runtime.activeAgentId;
+      if (cancelAgentId) {
+        getClient2().then((client) => {
+          const cancelId = cancelConversationId === "default" || !cancelConversationId ? cancelAgentId : cancelConversationId;
+          return client.conversations.cancel(cancelId);
+        }).catch(() => {});
+      }
       emitCancelAck(socket, runtime, {
         requestId,
         accepted: true,
@@ -72014,6 +72349,8 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
   const msgStartTime = performance.now();
   let msgTurnCount = 0;
   const msgRunIds = [];
+  let lastExecutionResults = null;
+  let lastNeedsUserInputToolCallIds = [];
   runtime.isProcessing = true;
   runtime.cancelRequested = false;
   runtime.activeAbortController = new AbortController;
@@ -72036,8 +72373,13 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
     if (connectionId) {
       onStatusChange?.("processing", connectionId);
     }
-    let messagesToSend = msg.messages;
+    let messagesToSend = [];
     let turnToolContextId = null;
+    const consumed = consumeInterruptQueue(runtime, agentId || "", conversationId);
+    if (consumed) {
+      messagesToSend.push(consumed);
+    }
+    messagesToSend.push(...msg.messages);
     const firstMessage = msg.messages[0];
     const isApprovalMessage = firstMessage && "type" in firstMessage && firstMessage.type === "approval" && "approvals" in firstMessage;
     if (isApprovalMessage) {
@@ -72078,6 +72420,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
           approvals: rebuiltApprovals
         }
       ];
+      emitInterruptToolReturnMessage(socket, runtime, rebuiltApprovals, runtime.activeRunId ?? undefined, "tool-return");
     }
     let stream2 = await sendMessageStreamWithRetry(conversationId, messagesToSend, { agentId, streamTokens: true, background: true }, socket, runtime, runtime.activeAbortController.signal);
     turnToolContextId = getStreamToolContextId(stream2);
@@ -72185,13 +72528,45 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
         break;
       }
       if (stopReason !== "requires_approval") {
-        runtime.lastStopReason = stopReason;
+        const effectiveStopReason = runtime.cancelRequested ? "cancelled" : stopReason || "error";
+        if (effectiveStopReason === "cancelled") {
+          runtime.lastStopReason = "cancelled";
+          runtime.isProcessing = false;
+          clearActiveRunState(runtime);
+          if (runtime.controlResponseCapable) {
+            emitToWS(socket, {
+              type: "result",
+              subtype: "interrupted",
+              agent_id: agentId,
+              conversation_id: conversationId,
+              duration_ms: performance.now() - msgStartTime,
+              duration_api_ms: 0,
+              num_turns: msgTurnCount,
+              result: null,
+              run_ids: msgRunIds,
+              usage: null,
+              stop_reason: "cancelled",
+              session_id: runtime.sessionId,
+              uuid: `result-${crypto.randomUUID()}`
+            });
+          } else {
+            sendClientMessage(socket, {
+              type: "result",
+              success: false,
+              stopReason: "cancelled"
+            });
+          }
+          break;
+        }
+        runtime.lastStopReason = effectiveStopReason;
         runtime.isProcessing = false;
         clearActiveRunState(runtime);
+        const errorDetail = await fetchRunErrorDetail(runId).catch(() => null);
+        const errorMessage = errorDetail || `Unexpected stop reason: ${stopReason}`;
         emitToWS(socket, {
           type: "error",
-          message: `Unexpected stop reason: ${stopReason}`,
-          stop_reason: stopReason || "error",
+          message: errorMessage,
+          stop_reason: effectiveStopReason,
           run_id: runId,
           session_id: runtime.sessionId,
           uuid: `error-${crypto.randomUUID()}`
@@ -72208,7 +72583,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
             result: null,
             run_ids: msgRunIds,
             usage: null,
-            stop_reason: stopReason || "error",
+            stop_reason: effectiveStopReason,
             session_id: runtime.sessionId,
             uuid: `result-${crypto.randomUUID()}`
           });
@@ -72216,7 +72591,7 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
           sendClientMessage(socket, {
             type: "result",
             success: false,
-            stopReason
+            stopReason: effectiveStopReason
           });
         }
         break;
@@ -72238,6 +72613,8 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
         treatAskAsDeny: false,
         requireArgsForAutoApprove: true
       });
+      lastNeedsUserInputToolCallIds = needsUserInput.map((ac) => ac.approval.toolCallId);
+      lastExecutionResults = null;
       for (const ac of autoAllowed) {
         emitToWS(socket, {
           type: "auto_approval",
@@ -72332,6 +72709,8 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
         toolContextId: turnToolContextId ?? undefined,
         abortSignal: runtime.activeAbortController.signal
       });
+      lastExecutionResults = executionResults;
+      emitInterruptToolReturnMessage(socket, runtime, executionResults, runtime.activeRunId || runId || msgRunIds[msgRunIds.length - 1] || undefined, "tool-return");
       clearPendingApprovalBatchIds(runtime, decisions.map((decision) => decision.approval));
       stream2 = await sendMessageStreamWithRetry(conversationId, [
         {
@@ -72339,10 +72718,26 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
           approvals: executionResults
         }
       ], { agentId, streamTokens: true, background: true }, socket, runtime, runtime.activeAbortController.signal);
+      lastExecutionResults = null;
+      lastNeedsUserInputToolCallIds = [];
       turnToolContextId = getStreamToolContextId(stream2);
     }
   } catch (error) {
     if (runtime.cancelRequested) {
+      populateInterruptQueue(runtime, {
+        lastExecutionResults,
+        lastNeedsUserInputToolCallIds,
+        agentId: agentId || "",
+        conversationId
+      });
+      const approvalsForEmission = getInterruptApprovalsForEmission(runtime, {
+        lastExecutionResults,
+        agentId: agentId || "",
+        conversationId
+      });
+      if (approvalsForEmission) {
+        emitInterruptToolReturnMessage(socket, runtime, approvalsForEmission, runtime.activeRunId || msgRunIds[msgRunIds.length - 1] || undefined);
+      }
       runtime.lastStopReason = "cancelled";
       runtime.isProcessing = false;
       clearActiveRunState(runtime);
@@ -72374,6 +72769,22 @@ async function handleIncomingMessage(msg, socket, runtime, onStatusChange, conne
     runtime.lastStopReason = "error";
     runtime.isProcessing = false;
     clearActiveRunState(runtime);
+    if (msgRunIds.length === 0) {
+      const errorPayload = {
+        message: error instanceof Error ? error.message : String(error)
+      };
+      if (error instanceof APIError2) {
+        errorPayload.status = error.status;
+        if (error.error && typeof error.error === "object") {
+          errorPayload.body = error.error;
+        }
+      }
+      sendClientMessage(socket, {
+        type: "run_request_error",
+        error: errorPayload,
+        batch_id: dequeuedBatchId
+      });
+    }
     const errorMessage = error instanceof Error ? error.message : String(error);
     emitToWS(socket, {
       type: "error",
@@ -72424,7 +72835,7 @@ function stopListenerClient() {
   activeRuntime = null;
   stopRuntime(runtime, true);
 }
-var activeRuntime = null, MAX_RETRY_DURATION_MS, INITIAL_RETRY_DELAY_MS = 1000, MAX_RETRY_DELAY_MS = 30000, LLM_API_ERROR_MAX_RETRIES = 3, __listenClientTestUtils;
+var activeRuntime = null, MAX_RETRY_DURATION_MS, INITIAL_RETRY_DELAY_MS = 1000, MAX_RETRY_DELAY_MS = 30000, LLM_API_ERROR_MAX_RETRIES = 3, MAX_PRE_STREAM_RECOVERY = 2, __listenClientTestUtils;
 var init_listen_client = __esm(async () => {
   init_error();
   init_check_approval();
@@ -72435,6 +72846,7 @@ var init_listen_client = __esm(async () => {
   init_interactivePolicy();
   await __promiseAll([
     init_approval_execution(),
+    init_approval_recovery(),
     init_client2(),
     init_message(),
     init_accumulator(),
@@ -72450,7 +72862,13 @@ var init_listen_client = __esm(async () => {
     emitToWS,
     rememberPendingApprovalBatchIds,
     resolvePendingApprovalBatchId,
-    clearPendingApprovalBatchIds
+    resolveRecoveryBatchId,
+    clearPendingApprovalBatchIds,
+    populateInterruptQueue,
+    consumeInterruptQueue,
+    extractInterruptToolReturns,
+    emitInterruptToolReturnMessage,
+    getInterruptApprovalsForEmission
   };
 });
 
@@ -74104,24 +74522,6 @@ var init_cli2 = __esm(() => {
   cliPermissions2 = new CliPermissions2;
 });
 
-// src/agent/approval-recovery.ts
-async function fetchRunErrorDetail(runId) {
-  if (!runId)
-    return null;
-  try {
-    const client = await getClient2();
-    const run = await client.runs.retrieve(runId);
-    const metaError = run.metadata?.error;
-    return metaError?.detail ?? metaError?.message ?? metaError?.error?.detail ?? metaError?.error?.message ?? null;
-  } catch {
-    return null;
-  }
-}
-var init_approval_recovery = __esm(async () => {
-  init_turn_recovery_policy();
-  await init_client2();
-});
-
 // src/agent/listMessagesRouting.ts
 function resolveListMessagesRoute(listReq, sessionConvId, sessionAgentId) {
   const targetConvId = listReq.conversation_id ?? sessionConvId;
@@ -91084,7 +91484,11 @@ var init_InputRich = __esm(async () => {
     }, [backgroundAgents.length]);
     const bgAgentText = backgroundAgents.length === 0 ? "" : backgroundAgents.map((a) => {
       const elapsedS = Math.round((Date.now() - a.startTime) / 1000);
-      return `${a.type.toLowerCase()} (${elapsedS}s)`;
+      const agentId = a.agentURL?.match(/\/agents\/([^/]+)/)?.[1];
+      const chatUrl = agentId ? buildChatUrl(agentId) : null;
+      const typeLabel = a.type.toLowerCase();
+      const linkedType = chatUrl ? `\x1B]8;;${chatUrl}\x1B\\${typeLabel}\x1B]8;;\x1B\\` : typeLabel;
+      return `${linkedType} (${elapsedS}s)`;
     }).join(" · ");
     const bgIndicatorWidth = backgroundAgents.length > 0 ? 2 + stringWidth(bgAgentText) + 3 : 0;
     const maxAgentChars = Math.max(10, Math.floor(rightColumnWidth * 0.45));
@@ -97438,12 +97842,11 @@ var init_ModelReasoningSelector = __esm(async () => {
 });
 
 // src/cli/components/ModelSelector.tsx
-function getModelCategories(billingTier, isSelfHosted) {
+function getModelCategories(_billingTier, isSelfHosted) {
   if (isSelfHosted) {
     return ["server-recommended", "server-all"];
   }
-  const isFreeTier = billingTier?.toLowerCase() === "free";
-  return isFreeTier ? ["byok", "byok-all", "supported", "all"] : ["supported", "all", "byok", "byok-all"];
+  return ["supported", "all", "byok", "byok-all"];
 }
 function filterModelsByAvailabilityForSelector(typedModels, availableHandles, allApiHandles) {
   if (availableHandles === null) {
@@ -97522,7 +97925,6 @@ function ModelSelector({
     const staticCandidates = typedModels.filter((m) => m.handle === handle);
     return staticCandidates.find((m) => m.isDefault) ?? staticCandidates.find((m) => m.isFeatured) ?? staticCandidates.find((m) => m.updateArgs?.reasoning_effort === "medium") ?? staticCandidates.find((m) => m.updateArgs?.reasoning_effort === "high") ?? staticCandidates[0];
   }, [typedModels]);
-  const isFreeTier = billingTier?.toLowerCase() === "free";
   const supportedModels = import_react79.useMemo(() => {
     if (availableHandles === undefined)
       return [];
@@ -97542,13 +97944,6 @@ function ModelSelector({
       seen.add(m.handle);
       deduped.push(pickPreferredStaticModel(m.handle) ?? m);
     }
-    if (isFreeTier) {
-      const freeModels = deduped.filter((m) => m.free);
-      const paidModels = deduped.filter((m) => !m.free);
-      const featured2 = paidModels.filter((m) => m.isFeatured);
-      const nonFeatured2 = paidModels.filter((m) => !m.isFeatured);
-      return [...freeModels, ...featured2, ...nonFeatured2];
-    }
     const featured = deduped.filter((m) => m.isFeatured);
     const nonFeatured = deduped.filter((m) => !m.isFeatured);
     return [...featured, ...nonFeatured];
@@ -97558,7 +97953,6 @@ function ModelSelector({
     allApiHandles,
     filterProvider,
     searchQuery,
-    isFreeTier,
     pickPreferredStaticModel
   ]);
   const isByokHandle = import_react79.useCallback((handle) => BYOK_PROVIDER_PREFIXES.some((prefix) => handle.startsWith(prefix)), []);
@@ -107151,7 +107545,7 @@ function App2({
         if (cancelled)
           return;
         debugLog("conversation-model", "Failed to sync conversation model override: %O", error);
-        applyAgentModelLocally();
+        debugLog("conversation-model", "Keeping current model state after sync error (override in DB is authoritative)");
       }
     };
     syncConversationModel();
@@ -120397,7 +120791,7 @@ function replaceRegistry2(newTools) {
     toolRegistry2.set(key, value);
   }
 }
-async function loadTools2(modelIdentifier) {
+async function loadTools2(modelIdentifier, options) {
   acquireSwitchLock2();
   try {
     const { toolFilter: toolFilter2 } = await Promise.resolve().then(() => (init_filter(), exports_filter));
@@ -120418,6 +120812,10 @@ async function loadTools2(modelIdentifier) {
     } else {
       baseToolNames = TOOL_NAMES2;
     }
+    if (options?.exclude && options.exclude.length > 0) {
+      const excludeSet = new Set(options.exclude);
+      baseToolNames = baseToolNames.filter((name) => !excludeSet.has(name));
+    }
     const newRegistry = new Map;
     for (const name of baseToolNames) {
       if (!toolFilter2.isEnabled(name)) {
@@ -121250,7 +121648,7 @@ Error: ${message}`);
   if (isHeadless) {
     markMilestone2("HEADLESS_MODE_START");
     const modelForTools = getModelForToolLoading(specifiedModel, specifiedToolset);
-    await loadTools2(modelForTools);
+    await loadTools2(modelForTools, { exclude: ["AskUserQuestion"] });
     markMilestone2("TOOLS_LOADED");
     const headlessValues = specifiedAgentId && values.agent !== specifiedAgentId ? { ...values, agent: specifiedAgentId } : values;
     const { handleHeadlessCommand: handleHeadlessCommand2 } = await init_headless().then(() => exports_headless);
@@ -122010,4 +122408,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=B02B981CD008C36564756E2164756E21
+//# debugId=FE66CA162A20D40F64756E2164756E21