@letta-ai/letta-code 0.21.8 → 0.21.9

package/letta.js

@@ -3269,7 +3269,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.21.8",
+    version: "0.21.9",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     bin: {
@@ -77004,8 +77004,8 @@ function isValidApprovalResponseBody(value) {
   if (decision.behavior === "allow") {
     const hasMessage = decision.message === undefined || typeof decision.message === "string";
     const hasUpdatedInput = decision.updated_input === undefined || decision.updated_input === null || typeof decision.updated_input === "object";
-    const hasUpdatedPermissions = decision.updated_permissions === undefined || Array.isArray(decision.updated_permissions) && decision.updated_permissions.every((entry) => typeof entry === "string");
-    return hasMessage && hasUpdatedInput && hasUpdatedPermissions;
+    const hasSelectedPermissionSuggestionIds = decision.selected_permission_suggestion_ids === undefined || Array.isArray(decision.selected_permission_suggestion_ids) && decision.selected_permission_suggestion_ids.every((entry) => typeof entry === "string");
+    return hasMessage && hasUpdatedInput && hasSelectedPermissionSuggestionIds;
   }
   if (decision.behavior === "deny") {
     return typeof decision.message === "string";
@@ -77565,99 +77565,6 @@ var init_permissionMode = __esm(() => {
   init_remote_settings();
 });
 
-// src/cli/helpers/safeJsonParse.ts
-function safeJsonParse(json) {
-  try {
-    const data = JSON.parse(json);
-    return { success: true, data };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-function safeJsonParseOr(json, defaultValue) {
-  const result = safeJsonParse(json);
-  return result.success ? result.data : defaultValue;
-}
-
-// src/cli/helpers/approvalClassification.ts
-async function getMissingRequiredArgs(toolName, parsedArgs) {
-  const schema = getToolSchema(toolName);
-  const required = schema?.input_schema?.required || [];
-  return required.filter((key) => !(key in parsedArgs) || parsedArgs[key] == null);
-}
-async function classifyApprovals(approvals, opts = {}) {
-  const needsUserInput = [];
-  const autoAllowed = [];
-  const autoDenied = [];
-  const denyReasonForAsk = opts.denyReasonForAsk ?? "Tool requires approval (headless mode)";
-  const missingNameReason = opts.missingNameReason ?? "Tool call incomplete - missing name";
-  for (const approval of approvals) {
-    const toolName = approval.toolName;
-    if (!toolName) {
-      autoDenied.push({
-        approval,
-        permission: { decision: "deny", reason: missingNameReason },
-        context: null,
-        parsedArgs: {},
-        denyReason: missingNameReason
-      });
-      continue;
-    }
-    const parsedArgs = safeJsonParseOr(approval.toolArgs || "{}", {});
-    const permission = await checkToolPermission(toolName, parsedArgs, opts.workingDirectory, opts.permissionModeState);
-    const context3 = opts.getContext ? await opts.getContext(toolName, parsedArgs, opts.workingDirectory) : null;
-    let decision = permission.decision;
-    if (opts.alwaysRequiresUserInput?.(toolName) && decision === "allow") {
-      decision = "ask";
-    }
-    if (decision === "ask" && opts.treatAskAsDeny) {
-      autoDenied.push({
-        approval,
-        permission,
-        context: context3,
-        parsedArgs,
-        denyReason: denyReasonForAsk
-      });
-      continue;
-    }
-    if (decision === "allow" && opts.requireArgsForAutoApprove) {
-      const missingRequiredArgs = await getMissingRequiredArgs(toolName, parsedArgs);
-      if (missingRequiredArgs.length > 0) {
-        const denyReason = opts.missingArgsReason ? opts.missingArgsReason(missingRequiredArgs) : `Missing required parameter${missingRequiredArgs.length > 1 ? "s" : ""}: ${missingRequiredArgs.join(", ")}`;
-        autoDenied.push({
-          approval,
-          permission,
-          context: context3,
-          parsedArgs,
-          missingRequiredArgs,
-          denyReason
-        });
-        continue;
-      }
-    }
-    const entry = {
-      approval,
-      permission,
-      context: context3,
-      parsedArgs
-    };
-    if (decision === "ask") {
-      needsUserInput.push(entry);
-    } else if (decision === "deny") {
-      autoDenied.push(entry);
-    } else {
-      autoAllowed.push(entry);
-    }
-  }
-  return { needsUserInput, autoAllowed, autoDenied };
-}
-var init_approvalClassification = __esm(async () => {
-  await init_manager3();
-});
-
 // node_modules/diff/libesm/diff/base.js
 class Diff {
   diff(oldStr, newStr, options = {}) {
@@ -79017,6 +78924,162 @@ async function computeDiffPreviews(toolName, toolArgs, workingDirectory = proces
 var cachedDiffDeps = null;
 var init_diffPreview = () => {};
 
+// src/cli/helpers/safeJsonParse.ts
+function safeJsonParse(json) {
+  try {
+    const data = JSON.parse(json);
+    return { success: true, data };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function safeJsonParseOr(json, defaultValue) {
+  const result = safeJsonParse(json);
+  return result.success ? result.data : defaultValue;
+}
+
+// src/cli/helpers/approvalClassification.ts
+async function getMissingRequiredArgs(toolName, parsedArgs) {
+  const schema = getToolSchema(toolName);
+  const required = schema?.input_schema?.required || [];
+  return required.filter((key) => !(key in parsedArgs) || parsedArgs[key] == null);
+}
+async function classifyApprovals(approvals, opts = {}) {
+  const needsUserInput = [];
+  const autoAllowed = [];
+  const autoDenied = [];
+  const denyReasonForAsk = opts.denyReasonForAsk ?? "Tool requires approval (headless mode)";
+  const missingNameReason = opts.missingNameReason ?? "Tool call incomplete - missing name";
+  for (const approval of approvals) {
+    const toolName = approval.toolName;
+    if (!toolName) {
+      autoDenied.push({
+        approval,
+        permission: { decision: "deny", reason: missingNameReason },
+        context: null,
+        parsedArgs: {},
+        denyReason: missingNameReason
+      });
+      continue;
+    }
+    const parsedArgs = safeJsonParseOr(approval.toolArgs || "{}", {});
+    const permission = await checkToolPermission(toolName, parsedArgs, opts.workingDirectory, opts.permissionModeState);
+    const context3 = opts.getContext ? await opts.getContext(toolName, parsedArgs, opts.workingDirectory) : null;
+    let decision = permission.decision;
+    if (opts.alwaysRequiresUserInput?.(toolName) && decision === "allow") {
+      decision = "ask";
+    }
+    if (decision === "ask" && opts.treatAskAsDeny) {
+      autoDenied.push({
+        approval,
+        permission,
+        context: context3,
+        parsedArgs,
+        denyReason: denyReasonForAsk
+      });
+      continue;
+    }
+    if (decision === "allow" && opts.requireArgsForAutoApprove) {
+      const missingRequiredArgs = await getMissingRequiredArgs(toolName, parsedArgs);
+      if (missingRequiredArgs.length > 0) {
+        const denyReason = opts.missingArgsReason ? opts.missingArgsReason(missingRequiredArgs) : `Missing required parameter${missingRequiredArgs.length > 1 ? "s" : ""}: ${missingRequiredArgs.join(", ")}`;
+        autoDenied.push({
+          approval,
+          permission,
+          context: context3,
+          parsedArgs,
+          missingRequiredArgs,
+          denyReason
+        });
+        continue;
+      }
+    }
+    const entry = {
+      approval,
+      permission,
+      context: context3,
+      parsedArgs
+    };
+    if (decision === "ask") {
+      needsUserInput.push(entry);
+    } else if (decision === "deny") {
+      autoDenied.push(entry);
+    } else {
+      autoAllowed.push(entry);
+    }
+  }
+  return { needsUserInput, autoAllowed, autoDenied };
+}
+var init_approvalClassification = __esm(async () => {
+  await init_manager3();
+});
+
+// src/websocket/listener/approval-suggestions.ts
+function getSuggestedPermissionRule(context3) {
+  if (!context3?.allowPersistence || context3.recommendedRule.trim().length === 0) {
+    return null;
+  }
+  return context3.recommendedRule;
+}
+function getApprovalPermissionSuggestions(context3) {
+  const suggestedRule = getSuggestedPermissionRule(context3);
+  if (suggestedRule === null || !context3) {
+    return [];
+  }
+  const text = context3.approveAlwaysText.trim();
+  if (text.length === 0) {
+    return [];
+  }
+  return [
+    {
+      suggestion: {
+        id: "save-default",
+        text
+      },
+      rule: suggestedRule,
+      scope: context3.defaultScope
+    }
+  ];
+}
+function buildApprovalSuggestionPayload(context3) {
+  return {
+    permission_suggestions: getApprovalPermissionSuggestions(context3).map(({ suggestion }) => suggestion)
+  };
+}
+async function classifyApprovalsWithSuggestions(approvals, opts = {}) {
+  return classifyApprovals(approvals, {
+    ...opts,
+    getContext: async (toolName, parsedArgs, workingDirectory) => analyzeToolApproval(toolName, parsedArgs, workingDirectory)
+  });
+}
+async function applySuggestedPermissionsForApproval(params) {
+  const { decision, context: context3, workingDirectory } = params;
+  if (!context3?.allowPersistence || context3.defaultScope === undefined) {
+    return false;
+  }
+  const selectedIds = decision.selected_permission_suggestion_ids ?? [];
+  if (selectedIds.length === 0) {
+    return false;
+  }
+  const matchedSuggestions = getApprovalPermissionSuggestions(context3).filter(({ suggestion }) => selectedIds.includes(suggestion.id));
+  if (matchedSuggestions.length === 0) {
+    return false;
+  }
+  for (const matchedSuggestion of matchedSuggestions) {
+    await savePermissionRule2(matchedSuggestion.rule, "allow", matchedSuggestion.scope, workingDirectory);
+  }
+  return true;
+}
+var init_approval_suggestions = __esm(async () => {
+  await __promiseAll([
+    init_approvalClassification(),
+    init_manager3()
+  ]);
+});
+
 // src/websocket/listener/recovery.ts
 function isApprovalToolCallDesyncError(detail) {
   if (isInvalidToolCallIdsError(detail) || isApprovalPendingError(detail)) {
@@ -79232,12 +79295,13 @@ async function recoverApprovalStateForSync(runtime, scope) {
     return;
   }
   const workingDirectory = getConversationWorkingDirectory(runtime.listener, scope.agent_id, scope.conversation_id);
-  const { needsUserInput, autoAllowed, autoDenied } = await classifyApprovals(pendingApprovals, {
+  const permissionModeState = getOrCreateConversationPermissionModeStateRef(runtime.listener, scope.agent_id, scope.conversation_id);
+  const { needsUserInput, autoAllowed, autoDenied } = await classifyApprovalsWithSuggestions(pendingApprovals, {
     alwaysRequiresUserInput: isInteractiveApprovalTool,
     requireArgsForAutoApprove: true,
     missingNameReason: "Tool call incomplete - missing name",
     workingDirectory,
-    permissionModeState: getOrCreateConversationPermissionModeStateRef(runtime.listener, scope.agent_id, scope.conversation_id)
+    permissionModeState
   });
   const autoDecisions = buildRecoveredAutoDecisions(autoAllowed, autoDenied);
   if (needsUserInput.length === 0) {
@@ -79252,6 +79316,7 @@ async function recoverApprovalStateForSync(runtime, scope) {
     const diffs = await computeDiffPreviews(approval.toolName, input, workingDirectory);
     approvalsByRequestId.set(requestId, {
       approval,
+      approvalContext: approvalEntry.context,
       controlRequest: {
         type: "control_request",
         request_id: requestId,
@@ -79260,7 +79325,7 @@ async function recoverApprovalStateForSync(runtime, scope) {
           tool_name: approval.toolName,
           input,
           tool_call_id: approval.toolCallId,
-          permission_suggestions: [],
+          ...buildApprovalSuggestionPayload(approvalEntry.context),
           blocked_path: null,
           ...diffs.length > 0 ? { diffs } : {}
         },
@@ -79290,6 +79355,40 @@ async function resolveRecoveredApprovalResponse(runtime, socket, response, proce
   }
   recovered.responsesByRequestId.set(requestId, response);
   recovered.pendingRequestIds.delete(requestId);
+  const workingDirectory = getConversationWorkingDirectory(runtime.listener, recovered.agentId, recovered.conversationId);
+  const respondedEntry = recovered.approvalsByRequestId.get(requestId);
+  if (respondedEntry && "decision" in response && response.decision.behavior === "allow") {
+    const savedSuggestions = await applySuggestedPermissionsForApproval({
+      decision: response.decision,
+      context: respondedEntry.approvalContext,
+      workingDirectory
+    });
+    if (savedSuggestions && recovered.pendingRequestIds.size > 0) {
+      const remainingRecoveredEntries = [...recovered.pendingRequestIds].map((id) => recovered.approvalsByRequestId.get(id)).filter((entry) => !!entry);
+      const reclassified = await classifyApprovalsWithSuggestions(remainingRecoveredEntries.map((entry) => entry.approval), {
+        alwaysRequiresUserInput: isInteractiveApprovalTool,
+        requireArgsForAutoApprove: true,
+        missingNameReason: "Tool call incomplete - missing name",
+        workingDirectory,
+        permissionModeState: getOrCreateConversationPermissionModeStateRef(runtime.listener, recovered.agentId, recovered.conversationId)
+      });
+      if (reclassified.autoAllowed.length > 0 || reclassified.autoDenied.length > 0) {
+        recovered.autoDecisions = [
+          ...recovered.autoDecisions ?? [],
+          ...buildRecoveredAutoDecisions(reclassified.autoAllowed, reclassified.autoDenied)
+        ];
+        const reclassifiedToolCallIds = new Set([...reclassified.autoAllowed, ...reclassified.autoDenied].map((entry) => entry.approval.toolCallId));
+        for (const pendingId of [...recovered.pendingRequestIds]) {
+          const pendingEntry = recovered.approvalsByRequestId.get(pendingId);
+          if (pendingEntry && reclassifiedToolCallIds.has(pendingEntry.approval.toolCallId)) {
+            recovered.pendingRequestIds.delete(pendingId);
+            recovered.approvalsByRequestId.delete(pendingId);
+            recovered.responsesByRequestId.delete(pendingId);
+          }
+        }
+      }
+    }
+  }
   if (recovered.pendingRequestIds.size > 0) {
     emitRuntimeStateUpdates(runtime, {
       agent_id: recovered.agentId,
@@ -79342,7 +79441,7 @@ async function resolveRecoveredApprovalResponse(runtime, socket, response, proce
   recovered.pendingRequestIds.clear();
   emitRuntimeStateUpdates(runtime, scope);
   runtime.isProcessing = true;
-  runtime.activeWorkingDirectory = getConversationWorkingDirectory(runtime.listener, recovered.agentId, recovered.conversationId);
+  runtime.activeWorkingDirectory = workingDirectory;
   runtime.activeExecutingToolCallIds = [...approvedToolCallIds];
   setLoopStatus(runtime, "EXECUTING_CLIENT_SIDE_TOOL", scope);
   emitRuntimeStateUpdates(runtime, scope);
@@ -79367,7 +79466,7 @@ async function resolveRecoveredApprovalResponse(runtime, socket, response, proce
     const approvalResults = await executeApprovalBatch(decisions, undefined, {
       abortSignal: recoveryAbortController.signal,
       toolContextId: preparedToolContext.preparedToolContext.contextId,
-      workingDirectory: getConversationWorkingDirectory(runtime.listener, recovered.agentId, recovered.conversationId),
+      workingDirectory,
       parentScope: recovered.agentId && recovered.conversationId ? {
         agentId: recovered.agentId,
         conversationId: recovered.conversationId
@@ -79434,9 +79533,9 @@ var init_recovery = __esm(async () => {
     init_approval_execution(),
     init_client2(),
     init_accumulator(),
-    init_approvalClassification(),
     init_stream(),
     init_toolset(),
+    init_approval_suggestions(),
     init_interrupts(),
     init_protocol_outbound(),
     init_queue()
@@ -79526,12 +79625,13 @@ async function resolveStaleApprovals(runtime, socket, abortSignal, deps = {}) {
       throw new Error("Ambiguous pending approval batch mapping during recovery");
     }
     rememberPendingApprovalBatchIds(runtime, pendingApprovals, recoveryBatchId);
-    const { autoAllowed, autoDenied, needsUserInput } = await classifyApprovals(pendingApprovals, {
+    const permissionModeState = getOrCreateConversationPermissionModeStateRef(runtime.listener, runtime.agentId, runtime.conversationId);
+    const { autoAllowed, autoDenied, needsUserInput } = await classifyApprovalsWithSuggestions(pendingApprovals, {
       alwaysRequiresUserInput: isInteractiveApprovalTool,
       requireArgsForAutoApprove: true,
       missingNameReason: "Tool call incomplete - missing name",
       workingDirectory: recoveryWorkingDirectory,
-      permissionModeState: getOrCreateConversationPermissionModeStateRef(runtime.listener, runtime.agentId, runtime.conversationId)
+      permissionModeState
     });
     const decisions = [
       ...autoAllowed.map((ac) => ({
@@ -79544,11 +79644,16 @@ async function resolveStaleApprovals(runtime, socket, abortSignal, deps = {}) {
         reason: ac.denyReason || ac.permission.reason || "Permission denied"
       }))
     ];
-    if (needsUserInput.length > 0) {
+    let pendingNeedsUserInput = [...needsUserInput];
+    if (pendingNeedsUserInput.length > 0) {
       runtime.lastStopReason = "requires_approval";
       setLoopStatus(runtime, "WAITING_ON_APPROVAL", scope);
       emitRuntimeStateUpdates(runtime, scope);
-      for (const ac of needsUserInput) {
+      while (pendingNeedsUserInput.length > 0) {
+        const ac = pendingNeedsUserInput.shift();
+        if (!ac) {
+          break;
+        }
         if (abortSignal.aborted)
           throw new Error("Cancelled");
         const requestId = `perm-${ac.approval.toolCallId}`;
@@ -79561,7 +79666,7 @@ async function resolveStaleApprovals(runtime, socket, abortSignal, deps = {}) {
             tool_name: ac.approval.toolName,
             input: ac.parsedArgs,
             tool_call_id: ac.approval.toolCallId,
-            permission_suggestions: [],
+            ...buildApprovalSuggestionPayload(ac.context),
             blocked_path: null,
             ...diffs.length > 0 ? { diffs } : {}
           },
@@ -79572,6 +79677,11 @@ async function resolveStaleApprovals(runtime, socket, abortSignal, deps = {}) {
         if ("decision" in responseBody) {
           const response = responseBody.decision;
           if (response.behavior === "allow") {
+            const savedSuggestions = await applySuggestedPermissionsForApproval({
+              decision: response,
+              context: ac.context,
+              workingDirectory: recoveryWorkingDirectory
+            });
             decisions.push({
               type: "approve",
               approval: response.updated_input ? {
@@ -79580,6 +79690,24 @@ async function resolveStaleApprovals(runtime, socket, abortSignal, deps = {}) {
               } : ac.approval,
               reason: response.message
             });
+            if (savedSuggestions && pendingNeedsUserInput.length > 0) {
+              const reclassified = await classifyApprovalsWithSuggestions(pendingNeedsUserInput.map((entry) => entry.approval), {
+                alwaysRequiresUserInput: isInteractiveApprovalTool,
+                requireArgsForAutoApprove: true,
+                missingNameReason: "Tool call incomplete - missing name",
+                workingDirectory: recoveryWorkingDirectory,
+                permissionModeState
+              });
+              decisions.push(...reclassified.autoAllowed.map((entry) => ({
+                type: "approve",
+                approval: entry.approval
+              })), ...reclassified.autoDenied.map((entry) => ({
+                type: "deny",
+                approval: entry.approval,
+                reason: entry.denyReason || entry.permission.reason || "Permission denied"
+              })));
+              pendingNeedsUserInput = [...reclassified.needsUserInput];
+            }
           } else {
             decisions.push({
               type: "deny",
@@ -79929,9 +80057,9 @@ var init_send = __esm(async () => {
     init_approval_recovery(),
     init_client2(),
     init_message(),
-    init_approvalClassification(),
     init_toolset(),
     init_approval(),
+    init_approval_suggestions(),
     init_interrupts(),
     init_protocol_outbound(),
     init_queue(),
@@ -79997,7 +80125,7 @@ async function handleApprovalStop(params) {
   }
   clearPendingApprovalBatchIds(runtime, approvals);
   rememberPendingApprovalBatchIds(runtime, approvals, dequeuedBatchId);
-  const { autoAllowed, autoDenied, needsUserInput } = await classifyApprovals(approvals, {
+  const { autoAllowed, autoDenied, needsUserInput } = await classifyApprovalsWithSuggestions(approvals, {
     alwaysRequiresUserInput: isInteractiveApprovalTool,
     treatAskAsDeny: false,
     requireArgsForAutoApprove: true,
@@ -80005,7 +80133,8 @@ async function handleApprovalStop(params) {
     workingDirectory: turnWorkingDirectory,
     permissionModeState: turnPermissionModeState
   });
-  const lastNeedsUserInputToolCallIds = needsUserInput.map((ac) => ac.approval.toolCallId);
+  let pendingNeedsUserInput = [...needsUserInput];
+  let lastNeedsUserInputToolCallIds = pendingNeedsUserInput.map((ac) => ac.approval.toolCallId);
   let lastExecutionResults = null;
   let lastExecutingToolCallIds = [];
   const shouldInterrupt = () => abortController.signal.aborted || runtime.cancelRequested;
@@ -80044,7 +80173,7 @@ async function handleApprovalStop(params) {
   if (shouldInterrupt()) {
     return interruptTermination();
   }
-  if (needsUserInput.length > 0) {
+  if (pendingNeedsUserInput.length > 0) {
     if (shouldInterrupt()) {
       return interruptTermination();
     }
@@ -80053,7 +80182,11 @@ async function handleApprovalStop(params) {
       agent_id: agentId,
       conversation_id: conversationId
     });
-    for (const ac of needsUserInput) {
+    while (pendingNeedsUserInput.length > 0) {
+      const ac = pendingNeedsUserInput.shift();
+      if (!ac) {
+        break;
+      }
       if (shouldInterrupt()) {
         return interruptTermination();
       }
@@ -80070,7 +80203,7 @@ async function handleApprovalStop(params) {
           tool_name: ac.approval.toolName,
           input: ac.parsedArgs,
           tool_call_id: ac.approval.toolCallId,
-          permission_suggestions: [],
+          ...buildApprovalSuggestionPayload(ac.context),
           blocked_path: null,
           ...diffs.length > 0 ? { diffs } : {}
         },
@@ -80092,6 +80225,11 @@ async function handleApprovalStop(params) {
       if ("decision" in responseBody) {
         const response = responseBody.decision;
         if (response.behavior === "allow") {
+          const savedSuggestions = await applySuggestedPermissionsForApproval({
+            decision: response,
+            context: ac.context,
+            workingDirectory: turnWorkingDirectory
+          });
           const finalApproval = response.updated_input ? {
             ...ac.approval,
             toolArgs: JSON.stringify(response.updated_input)
@@ -80101,6 +80239,26 @@ async function handleApprovalStop(params) {
             approval: finalApproval,
             reason: response.message
           });
+          if (savedSuggestions && pendingNeedsUserInput.length > 0) {
+            const reclassified = await classifyApprovalsWithSuggestions(pendingNeedsUserInput.map((entry) => entry.approval), {
+              alwaysRequiresUserInput: isInteractiveApprovalTool,
+              treatAskAsDeny: false,
+              requireArgsForAutoApprove: true,
+              missingNameReason: "Tool call incomplete - missing name",
+              workingDirectory: turnWorkingDirectory,
+              permissionModeState: turnPermissionModeState
+            });
+            decisions.push(...reclassified.autoAllowed.map((entry) => ({
+              type: "approve",
+              approval: entry.approval
+            })), ...reclassified.autoDenied.map((entry) => ({
+              type: "deny",
+              approval: entry.approval,
+              reason: entry.denyReason || entry.permission.reason || "Permission denied"
+            })));
+            pendingNeedsUserInput = [...reclassified.needsUserInput];
+            lastNeedsUserInputToolCallIds = pendingNeedsUserInput.map((entry) => entry.approval.toolCallId);
+          }
         } else {
           decisions.push({
             type: "deny",
@@ -80248,8 +80406,8 @@ var init_turn_approval = __esm(async () => {
   init_skill_injection();
   await __promiseAll([
     init_approval_execution(),
-    init_approvalClassification(),
     init_approval(),
+    init_approval_suggestions(),
     init_interrupts(),
     init_protocol_outbound(),
     init_queue(),
@@ -152041,4 +152199,4 @@ Error during initialization: ${message}`);
 }
 main();
 
-//# debugId=55BEE0B212809B3B64756E2164756E21
+//# debugId=594F8E4675FBE99864756E2164756E21

package/package.json

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