@letta-ai/letta-code 0.30.10 → 0.30.11

package/letta.js

@@ -5476,7 +5476,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.30.10",
+    version: "0.30.11",
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
     packageManager: "bun@1.3.0",
@@ -152976,6 +152976,7 @@ function createConversationRuntime(listener, agentId, conversationId) {
     currentToolset: null,
     currentToolsetPreference: "auto",
     currentLoadedTools: [],
+    currentAvailableSkills: [],
     pendingApprovalBatchByToolCallId: new Map,
     approvalMessageIdByToolCallId: new Map,
     pendingInterruptedResults: null,
@@ -157473,6 +157474,7 @@ function getSkillRootRevisions(components) {
 function cloneResult(result) {
   return {
     clientSkills: result.clientSkills.map((s2) => ({ ...s2 })),
+    availableSkills: result.availableSkills.map((skill) => ({ ...skill })),
     skillPathById: { ...result.skillPathById },
     errors: result.errors.map((e2) => ({ ...e2 }))
   };
@@ -157657,6 +157659,13 @@ async function buildClientSkillsPayload(options3 = {}) {
   }
   const result = {
     clientSkills: sortedSkills.map(toClientSkill),
+    availableSkills: sortedSkills.map((skill) => ({
+      id: skill.id,
+      name: skill.name,
+      description: skill.description,
+      path: skill.path,
+      source: skill.source
+    })),
     skillPathById: Object.fromEntries(sortedSkills.filter((skill) => typeof skill.path === "string" && skill.path.length > 0).map((skill) => [skill.id, skill.path])),
     errors: errors7
   };
@@ -157798,6 +157807,7 @@ async function sendMessageStreamWithBackend(backend, conversationId, messages, o
   const { clientTools, contextId } = preparedToolContext;
   const { clientSkills, errors: clientSkillDiscoveryErrors } = await buildClientSkillsPayload({
     agentId: opts.agentId,
+    skillsDirectory: getExecutionContextById(preparedToolContext.contextId)?.runtimeContext.skillsDirectory,
     skillSources: opts.skillSources ?? getSkillSources()
   });
   const resolvedConversationId = conversationId;
@@ -330261,7 +330271,7 @@ function buildDeviceStatus(runtime, params) {
     current_toolset: conversationRuntime?.currentToolset ?? (toolsetPreference === "auto" ? null : toolsetPreference),
     current_toolset_preference: conversationRuntime?.currentToolsetPreference ?? toolsetPreference,
     current_loaded_tools: conversationRuntime?.currentLoadedTools ?? [],
-    current_available_skills: [],
+    current_available_skills: conversationRuntime?.currentAvailableSkills ?? [],
     background_processes: buildBackgroundProcessSnapshot(scopedAgentId, scopedConversationId),
     pending_control_requests: interruptedCacheActive ? [] : getPendingControlRequests(listener, scope),
     experiments: experimentManager.list(),
@@ -356536,7 +356546,8 @@ function createLocalConversationRecord(conversationId, agentId, _sequence, body
     } : {},
     ...modelSettings !== undefined ? { model_settings: modelSettings } : {},
     ...typeof bodyRecord.context_window_limit === "number" ? { context_window_limit: bodyRecord.context_window_limit } : {},
-    ...typeof bodyRecord.hidden === "boolean" ? { hidden: bodyRecord.hidden } : {}
+    ...typeof bodyRecord.hidden === "boolean" ? { hidden: bodyRecord.hidden } : {},
+    ...isStringArray2(bodyRecord.tags) ? { tags: bodyRecord.tags } : {}
   };
 }
 function updateLocalConversationRecord(current, body, updatedAt) {
@@ -411956,6 +411967,217 @@ var init_access_control = __esm(() => {
   CHANNEL_COMMAND_FLOOR = ["help", "status", "whoami"];
 });
 
+// src/channels/command-surface.ts
+function defaultChannelDisplayName(channelId) {
+  return DEFAULT_CHANNEL_DISPLAY_NAMES[channelId] ?? channelId;
+}
+function listChannelSlashCommands() {
+  return CHANNEL_SLASH_COMMANDS.map((definition) => ({
+    ...definition,
+    aliases: definition.aliases ? [...definition.aliases] : undefined
+  }));
+}
+function parseSingleLineChannelCommand(text2, prefix) {
+  const trimmed = text2.trim();
+  const escapedPrefix = prefix === "/" ? "\\/" : "!";
+  const match4 = trimmed.match(new RegExp(`^${escapedPrefix}([A-Za-z][\\w-]*)(?:@[A-Za-z0-9_]+)?(?:[^\\S\\r\\n]+(.*))?$`));
+  if (!match4) {
+    return null;
+  }
+  const [, name, args] = match4;
+  if (!name) {
+    return null;
+  }
+  return {
+    name: name.toLowerCase(),
+    args: args?.trim() ?? "",
+    raw: trimmed
+  };
+}
+function parseAnySingleLineChannelCommand(text2) {
+  return parseSingleLineChannelCommand(text2, "/") ?? parseSingleLineChannelCommand(text2, "!");
+}
+function parseChannelCommand(text2, prefix) {
+  const lines = text2.trim().split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+  const [firstLine, ...remainingLines] = lines;
+  if (!firstLine) {
+    return null;
+  }
+  const firstCommand = parseSingleLineChannelCommand(firstLine, prefix);
+  if (!firstCommand) {
+    return null;
+  }
+  const laterCommand = remainingLines.find((line) => Boolean(parseAnySingleLineChannelCommand(line)));
+  if (laterCommand) {
+    return firstCommand;
+  }
+  const continuationArgs = remainingLines.join(`
+`).trim();
+  if (!continuationArgs) {
+    return firstCommand;
+  }
+  return {
+    ...firstCommand,
+    args: [firstCommand.args, continuationArgs].filter((part) => part.length > 0).join(`
+`)
+  };
+}
+function parseChannelSlashCommand(text2) {
+  return parseChannelCommand(text2, "/");
+}
+function parseChannelBangCommand(text2) {
+  return parseChannelCommand(text2, "!");
+}
+function supportedCommandsText(prefix = "/") {
+  return listChannelSlashCommands().map((definition) => `${prefix}${definition.name}`).join(", ");
+}
+function supportedSlackMentionSlashCommandsText() {
+  return SLACK_MENTION_SLASH_COMMAND_EXAMPLES.join(", ");
+}
+function supportedBangCommandsText() {
+  return SLACK_MENTION_COMMAND_NAMES.map((name) => `!${name}`).join(", ");
+}
+function isSupportedSlackMentionCommand(commandName) {
+  return SLACK_MENTION_COMMAND_NAMES.includes(commandName);
+}
+function buildChannelHelpMessage(channelId, resolveDisplayName = defaultChannelDisplayName) {
+  const displayName = resolveDisplayName(channelId);
+  if (channelId === "slack") {
+    return [
+      `${displayName} is connected to Letta Code.`,
+      "Talk by mentioning the app in a channel thread. Once a thread is routed, normal replies continue the same agent conversation until detached.",
+      "Control commands start immediately after the mention:",
+      "@agent /model - show this thread's current model",
+      "@agent /model list - show available models",
+      "@agent /model <handle-or-id> - switch this thread's model",
+      "@agent /status - show route and listener status",
+      "@agent /cancel - cancel the current turn",
+      "@agent /chat - show the web chat link",
+      "@agent /feedback <message> - send feedback to the Letta team from this routed thread",
+      "@agent /reflection - start a memory reflection pass",
+      "@agent /detach - stop replying in this thread until mentioned again",
+      "@agent /new - start a fresh conversation for this thread",
+      "@agent /reload - reload settings, local mods, and agent secrets",
+      `Legacy bang aliases still work after a mention: ${supportedBangCommandsText()}.`,
+      "If this chat is not connected yet, send a normal message and follow the pairing instructions."
+    ].join(`
+`);
+  }
+  return [
+    `${displayName} is connected to Letta Code.`,
+    "Send a normal message here and the connected agent will reply in this chat.",
+    `Supported slash commands here: ${supportedCommandsText()}.`,
+    "If this chat is not connected yet, send any non-command message and follow the pairing instructions."
+  ].join(`
+
+`);
+}
+function buildUnsupportedChannelCommandMessage(channelId, command, resolveDisplayName = defaultChannelDisplayName) {
+  const displayName = resolveDisplayName(channelId);
+  const isBang = command.raw.startsWith("!");
+  const commandKind = isBang ? "bang" : "slash";
+  const supportedCommands = isBang ? supportedBangCommandsText() : channelId === "slack" ? supportedSlackMentionSlashCommandsText() : supportedCommandsText();
+  const supportedLabel = channelId === "slack" && !isBang ? "Slack mention commands" : `${commandKind} commands`;
+  return [
+    `${displayName} received ${command.raw}, but that ${commandKind} command is not supported in channels yet.`,
+    `Supported ${supportedLabel}: ${supportedCommands}.`,
+    `Send normal messages without a leading ${isBang ? "bang" : "slash"} command to talk to the connected agent.`
+  ].join(`
+
+`);
+}
+var DEFAULT_CHANNEL_DISPLAY_NAMES, CHANNEL_SLASH_COMMANDS, SLACK_MENTION_COMMAND_NAMES, SLACK_MENTION_SLASH_COMMAND_EXAMPLES;
+var init_command_surface = __esm(() => {
+  DEFAULT_CHANNEL_DISPLAY_NAMES = {
+    custom: "Custom",
+    discord: "Discord",
+    signal: "Signal",
+    slack: "Slack",
+    telegram: "Telegram",
+    whatsapp: "WhatsApp"
+  };
+  CHANNEL_SLASH_COMMANDS = [
+    {
+      name: "help",
+      kind: "direct",
+      summary: "Show channel usage guidance."
+    },
+    {
+      name: "status",
+      kind: "direct",
+      summary: "Show this chat's channel connection status."
+    },
+    {
+      name: "whoami",
+      kind: "direct",
+      summary: "Show your access tier and runnable commands here."
+    },
+    {
+      name: "pause",
+      kind: "direct",
+      summary: "Pause agent routing for this chat."
+    },
+    {
+      name: "resume",
+      kind: "direct",
+      summary: "Resume agent routing for this chat."
+    },
+    {
+      name: "cancel",
+      kind: "agent-scoped",
+      summary: "Cancel the in-progress agent turn for this chat."
+    },
+    {
+      name: "chat",
+      kind: "direct",
+      summary: "Show the Letta web chat link for this channel route."
+    },
+    {
+      name: "feedback",
+      kind: "direct",
+      summary: "Send feedback about Letta Code from this routed chat."
+    },
+    {
+      name: "model",
+      kind: "agent-scoped",
+      summary: "Show, list, or switch the model for this chat's routed conversation."
+    },
+    {
+      name: "reflection",
+      aliases: ["reflect"],
+      kind: "agent-scoped",
+      summary: "Start a memory reflection pass for this conversation."
+    },
+    {
+      name: "reload",
+      kind: "agent-scoped",
+      summary: "Reload settings, local mods, and agent secrets."
+    }
+  ];
+  SLACK_MENTION_COMMAND_NAMES = [
+    "help",
+    "detach",
+    "model",
+    "new",
+    "reload"
+  ];
+  SLACK_MENTION_SLASH_COMMAND_EXAMPLES = [
+    "@agent /help",
+    "@agent /status",
+    "@agent /whoami",
+    "@agent /model",
+    "@agent /model list",
+    "@agent /model <handle-or-id>",
+    "@agent /cancel",
+    "@agent /chat",
+    "@agent /feedback <message>",
+    "@agent /reflection",
+    "@agent /detach",
+    "@agent /new",
+    "@agent /reload"
+  ];
+});
+
 // src/channels/feedback.ts
 function channelDisplayName2(channelId) {
   try {
@@ -412224,126 +412446,17 @@ function channelDisplayName4(channelId) {
     return channelId;
   }
 }
-function listChannelSlashCommands() {
-  return CHANNEL_SLASH_COMMANDS.map((definition) => ({
-    ...definition,
-    aliases: definition.aliases ? [...definition.aliases] : undefined
-  }));
-}
-function parseSingleLineChannelCommand(text2, prefix) {
-  const trimmed = text2.trim();
-  const escapedPrefix = prefix === "/" ? "\\/" : "!";
-  const match4 = trimmed.match(new RegExp(`^${escapedPrefix}([A-Za-z][\\w-]*)(?:@[A-Za-z0-9_]+)?(?:[^\\S\\r\\n]+(.*))?$`));
-  if (!match4) {
-    return null;
-  }
-  const [, name, args] = match4;
-  if (!name) {
-    return null;
-  }
-  return {
-    name: name.toLowerCase(),
-    args: args?.trim() ?? "",
-    raw: trimmed
-  };
-}
-function parseAnySingleLineChannelCommand(text2) {
-  return parseSingleLineChannelCommand(text2, "/") ?? parseSingleLineChannelCommand(text2, "!");
-}
-function parseChannelCommand(text2, prefix) {
-  const lines = text2.trim().split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
-  const [firstLine, ...remainingLines] = lines;
-  if (!firstLine) {
-    return null;
-  }
-  const firstCommand = parseSingleLineChannelCommand(firstLine, prefix);
-  if (!firstCommand) {
-    return null;
-  }
-  const laterCommand = remainingLines.find((line) => Boolean(parseAnySingleLineChannelCommand(line)));
-  if (laterCommand) {
-    return firstCommand;
-  }
-  const continuationArgs = remainingLines.join(`
-`).trim();
-  if (!continuationArgs) {
-    return firstCommand;
-  }
-  return {
-    ...firstCommand,
-    args: [firstCommand.args, continuationArgs].filter((part) => part.length > 0).join(`
-`)
-  };
-}
-function parseChannelSlashCommand(text2) {
-  return parseChannelCommand(text2, "/");
-}
-function parseChannelBangCommand(text2) {
-  return parseChannelCommand(text2, "!");
-}
-function supportedCommandsText(prefix = "/") {
-  return listChannelSlashCommands().map((definition) => `${prefix}${definition.name}`).join(", ");
-}
-function supportedSlackMentionSlashCommandsText() {
-  return SLACK_MENTION_SLASH_COMMAND_EXAMPLES.join(", ");
-}
-function supportedBangCommandsText() {
-  return SLACK_MENTION_COMMAND_NAMES.map((name) => `!${name}`).join(", ");
-}
-function isSupportedSlackMentionCommand(commandName) {
-  return SLACK_MENTION_COMMAND_NAMES.includes(commandName);
-}
 function isSlackMentionSlashCommand(msg, command) {
   return msg.channel === "slack" && msg.isMention === true && command.raw.startsWith("/");
 }
 function isSlackMentionControlCommand(msg, command) {
   return command.raw.startsWith("!") || isSlackMentionSlashCommand(msg, command);
 }
-function buildChannelHelpMessage(channelId) {
-  const displayName = channelDisplayName4(channelId);
-  if (channelId === "slack") {
-    return [
-      `${displayName} is connected to Letta Code.`,
-      "Talk by mentioning the app in a channel thread. Once a thread is routed, normal replies continue the same agent conversation until detached.",
-      "Control commands start immediately after the mention:",
-      "@agent /model - show this thread's current model",
-      "@agent /model list - show available models",
-      "@agent /model <handle-or-id> - switch this thread's model",
-      "@agent /status - show route and listener status",
-      "@agent /cancel - cancel the current turn",
-      "@agent /chat - show the web chat link",
-      "@agent /feedback <message> - send feedback to the Letta team from this routed thread",
-      "@agent /reflection - start a memory reflection pass",
-      "@agent /detach - stop replying in this thread until mentioned again",
-      "@agent /new - start a fresh conversation for this thread",
-      "@agent /reload - reload settings, local mods, and agent secrets",
-      `Legacy bang aliases still work after a mention: ${supportedBangCommandsText()}.`,
-      "If this chat is not connected yet, send a normal message and follow the pairing instructions."
-    ].join(`
-`);
-  }
-  return [
-    `${displayName} is connected to Letta Code.`,
-    "Send a normal message here and the connected agent will reply in this chat.",
-    `Supported slash commands here: ${supportedCommandsText()}.`,
-    "If this chat is not connected yet, send any non-command message and follow the pairing instructions."
-  ].join(`
-
-`);
+function buildChannelHelpMessage2(channelId) {
+  return buildChannelHelpMessage(channelId, channelDisplayName4);
 }
-function buildUnsupportedChannelCommandMessage(channelId, command) {
-  const displayName = channelDisplayName4(channelId);
-  const isBang = command.raw.startsWith("!");
-  const commandKind = isBang ? "bang" : "slash";
-  const supportedCommands = isBang ? supportedBangCommandsText() : channelId === "slack" ? supportedSlackMentionSlashCommandsText() : supportedCommandsText();
-  const supportedLabel = channelId === "slack" && !isBang ? "Slack mention commands" : `${commandKind} commands`;
-  return [
-    `${displayName} received ${command.raw}, but that ${commandKind} command is not supported in channels yet.`,
-    `Supported ${supportedLabel}: ${supportedCommands}.`,
-    `Send normal messages without a leading ${isBang ? "bang" : "slash"} command to talk to the connected agent.`
-  ].join(`
-
-`);
+function buildUnsupportedChannelCommandMessage2(channelId, command) {
+  return buildUnsupportedChannelCommandMessage(channelId, command, channelDisplayName4);
 }
 function buildChannelStatusMessage(msg, context3) {
   const displayName = channelDisplayName4(msg.channel);
@@ -412622,7 +412735,7 @@ async function tryHandleChannelSlashCommand(adapter, msg, options3 = {}) {
   const isBangCommand = command.raw.startsWith("!");
   const isSlackMentionControl = isSlackMentionControlCommand(msg, command);
   if (isBangCommand && !isSupportedSlackMentionCommand(command.name)) {
-    await adapter.sendDirectReply(msg.chatId, buildUnsupportedChannelCommandMessage(msg.channel, command), buildDirectReplyOptions(msg));
+    await adapter.sendDirectReply(msg.chatId, buildUnsupportedChannelCommandMessage2(msg.channel, command), buildDirectReplyOptions(msg));
     return true;
   }
   const canonicalName = canonicalizeChannelCommandName(command.name);
@@ -412633,7 +412746,7 @@ async function tryHandleChannelSlashCommand(adapter, msg, options3 = {}) {
   const reply = normalizeDirectReplyPayload(await (async () => {
     switch (command.name) {
       case "help":
-        return buildChannelHelpMessage(msg.channel);
+        return buildChannelHelpMessage2(msg.channel);
       case "whoami":
         return buildChannelWhoamiMessage(msg, options3.commandGate);
       case "status":
@@ -412675,7 +412788,7 @@ async function tryHandleChannelSlashCommand(adapter, msg, options3 = {}) {
         });
       case "detach":
         if (!isSlackMentionControl) {
-          return buildUnsupportedChannelCommandMessage(msg.channel, command);
+          return buildUnsupportedChannelCommandMessage2(msg.channel, command);
         }
         return handleScopedCommand({
           msg,
@@ -412690,7 +412803,7 @@ async function tryHandleChannelSlashCommand(adapter, msg, options3 = {}) {
         });
       case "new":
         if (!isSlackMentionControl) {
-          return buildUnsupportedChannelCommandMessage(msg.channel, command);
+          return buildUnsupportedChannelCommandMessage2(msg.channel, command);
         }
         return handleScopedCommand({
           msg,
@@ -412711,7 +412824,7 @@ async function tryHandleChannelSlashCommand(adapter, msg, options3 = {}) {
           handler: options3.handlers?.reload
         });
       default:
-        return buildUnsupportedChannelCommandMessage(msg.channel, command);
+        return buildUnsupportedChannelCommandMessage2(msg.channel, command);
     }
   })());
   if (reply === null) {
@@ -412724,92 +412837,14 @@ async function tryHandleChannelSlashCommand(adapter, msg, options3 = {}) {
   } : undefined);
   return true;
 }
-var CHANNEL_SLASH_COMMANDS, SLACK_MENTION_COMMAND_NAMES, SLACK_MENTION_SLASH_COMMAND_EXAMPLES, DEFAULT_CHANNEL_MODEL_LIST_LIMIT = 8;
+var DEFAULT_CHANNEL_MODEL_LIST_LIMIT = 8;
 var init_commands = __esm(() => {
   init_access_control();
+  init_command_surface();
   init_feedback2();
   init_plugin_registry();
   init_registry_presentation();
-  CHANNEL_SLASH_COMMANDS = [
-    {
-      name: "help",
-      kind: "direct",
-      summary: "Show channel usage guidance."
-    },
-    {
-      name: "status",
-      kind: "direct",
-      summary: "Show this chat's channel connection status."
-    },
-    {
-      name: "whoami",
-      kind: "direct",
-      summary: "Show your access tier and runnable commands here."
-    },
-    {
-      name: "pause",
-      kind: "direct",
-      summary: "Pause agent routing for this chat."
-    },
-    {
-      name: "resume",
-      kind: "direct",
-      summary: "Resume agent routing for this chat."
-    },
-    {
-      name: "cancel",
-      kind: "agent-scoped",
-      summary: "Cancel the in-progress agent turn for this chat."
-    },
-    {
-      name: "chat",
-      kind: "direct",
-      summary: "Show the Letta web chat link for this channel route."
-    },
-    {
-      name: "feedback",
-      kind: "direct",
-      summary: "Send feedback about Letta Code from this routed chat."
-    },
-    {
-      name: "model",
-      kind: "agent-scoped",
-      summary: "Show, list, or switch the model for this chat's routed conversation."
-    },
-    {
-      name: "reflection",
-      aliases: ["reflect"],
-      kind: "agent-scoped",
-      summary: "Start a memory reflection pass for this conversation."
-    },
-    {
-      name: "reload",
-      kind: "agent-scoped",
-      summary: "Reload settings, local mods, and agent secrets."
-    }
-  ];
-  SLACK_MENTION_COMMAND_NAMES = [
-    "help",
-    "detach",
-    "model",
-    "new",
-    "reload"
-  ];
-  SLACK_MENTION_SLASH_COMMAND_EXAMPLES = [
-    "@agent /help",
-    "@agent /status",
-    "@agent /whoami",
-    "@agent /model",
-    "@agent /model list",
-    "@agent /model <handle-or-id>",
-    "@agent /cancel",
-    "@agent /chat",
-    "@agent /feedback <message>",
-    "@agent /reflection",
-    "@agent /detach",
-    "@agent /new",
-    "@agent /reload"
-  ];
+  init_command_surface();
 });
 
 // src/channels/slack/model-picker-blocks.ts
@@ -424250,10 +424285,24 @@ var init_registry_inbound = __esm(() => {
 });
 
 // src/channels/registry-routes.ts
+async function resolveConversationModelPin(agentId) {
+  try {
+    const agent2 = await getBackend().retrieveAgent(agentId);
+    return {
+      ...agent2.model ? { model: agent2.model } : {},
+      ...agent2.model_settings ? { model_settings: agent2.model_settings } : {}
+    };
+  } catch (error54) {
+    debugWarn("channels", `Failed to resolve model for agent ${agentId}; creating channel conversation without a pinned model`, error54);
+    return {};
+  }
+}
 function createChannelRouteProvisioner(deps) {
   async function createConversationForAgent(agentId, summary) {
+    const modelPin = await resolveConversationModelPin(agentId);
     const conversation = await getBackend().createConversation({
       agent_id: agentId,
+      ...modelPin,
       ...summary ? { summary } : {}
     });
     return conversation.id;
@@ -424596,6 +424645,7 @@ function createChannelRouteProvisioner(deps) {
 }
 var init_registry_routes = __esm(() => {
   init_backend2();
+  init_debug();
   init_accounts();
   init_registry_presentation();
   init_routing();
@@ -437141,7 +437191,7 @@ function formatScheduledTaskPrompt(input) {
   return lines.join(`
 `);
 }
-var AUTONOMOUS_NOTICE = "You are running autonomously: no user is watching this turn and questions will not be answered. Deliver results through your available channels or record them in memory, and work until the task is done or genuinely blocked.";
+var SCHEDULE_ORIGIN_TAG = "origin:schedule", AUTONOMOUS_NOTICE = "You are running autonomously: no user is watching this turn and questions will not be answered. Deliver results through your available channels or record them in memory, and work until the task is done or genuinely blocked.";
 
 // src/cron/prompt.ts
 function getIntendedCronOccurrence(task2, matchedAt) {
@@ -437179,14 +437229,12 @@ function minuteKey(date6) {
 function wrapCronPrompt(task2, timing2) {
   return formatCronPrompt(task2, timing2);
 }
-function getCronConversationSummary(task2) {
-  return `[Schedule] ${task2.name}`;
-}
 async function resolveCronFireConversationId(task2) {
   if (task2.conversation_id === NEW_CONVERSATION_TARGET) {
     const conversation = await getBackend().createConversation({
       agent_id: task2.agent_id,
-      summary: getCronConversationSummary(task2)
+      summary: task2.name,
+      tags: [SCHEDULE_ORIGIN_TAG]
     });
     return conversation.id;
   }
@@ -459397,9 +459445,18 @@ async function prepareListenerTurn(params) {
   if (isInterrupted()) {
     return { kind: "interrupted" };
   }
+  const availableSkills = (await buildClientSkillsPayload({
+    agentId,
+    skillsDirectory: listenerOptions?.skillsDirectory,
+    skillSources: runtime.skillSources
+  })).availableSkills;
+  if (isInterrupted()) {
+    return { kind: "interrupted" };
+  }
   runtime.currentToolset = preparedToolContext.toolset;
   runtime.currentToolsetPreference = preparedToolContext.toolsetPreference;
   runtime.currentLoadedTools = preparedToolContext.preparedToolContext.loadedToolNames;
+  runtime.currentAvailableSkills = availableSkills;
   return {
     kind: "ready",
     getCachedAgent: () => cachedAgent,
@@ -459413,6 +459470,7 @@ async function prepareListenerTurn(params) {
   };
 }
 var init_turn_setup = __esm(async () => {
+  init_client_skills();
   init_context();
   init_backend2();
   init_engine3();
@@ -476801,6 +476859,56 @@ var init_message_channel_formatting = __esm(() => {
   };
 });
 
+// src/channels/message-channel-idempotency.ts
+function isErrorResult(result) {
+  return result.startsWith("Error:");
+}
+function createMessageChannelIdempotencyScope() {
+  const inFlight = new Map;
+  let lastSuccessful = null;
+  let latestInvocation = 0;
+  return {
+    async execute(key2, effect) {
+      if (!key2) {
+        latestInvocation += 1;
+        lastSuccessful = null;
+        return await effect();
+      }
+      const pendingDuplicate = inFlight.get(key2);
+      if (pendingDuplicate) {
+        throw new MessageChannelDuplicateActionError("in-flight");
+      }
+      if (lastSuccessful?.key === key2) {
+        throw new MessageChannelDuplicateActionError("completed");
+      }
+      const invocation = ++latestInvocation;
+      lastSuccessful = null;
+      const pending = Promise.resolve().then(effect);
+      inFlight.set(key2, pending);
+      try {
+        const result = await pending;
+        if (invocation === latestInvocation && !isErrorResult(result)) {
+          lastSuccessful = { key: key2 };
+        }
+        return result;
+      } finally {
+        if (inFlight.get(key2) === pending)
+          inFlight.delete(key2);
+      }
+    }
+  };
+}
+var MessageChannelDuplicateActionError;
+var init_message_channel_idempotency = __esm(() => {
+  MessageChannelDuplicateActionError = class MessageChannelDuplicateActionError extends Error {
+    constructor(state) {
+      const detail = state === "in-flight" ? "an identical text send is already in progress" : "the immediately previous MessageChannel call already sent this exact text to the same destination";
+      super(`Duplicate MessageChannel action suppressed: ${detail}. The duplicate was not sent; continue the turn instead of retrying it.`);
+      this.name = "MessageChannelDuplicateActionError";
+    }
+  };
+});
+
 // src/channels/message-channel-executor.ts
 function firstNonEmptyString4(...values2) {
   for (const value of values2) {
@@ -476950,6 +477058,50 @@ async function dispatchMessageChannelAction(params) {
     formatText: (text2) => formatOutboundChannelMessage(params.request.channel, text2)
   });
 }
+function trimmedOrNull(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function effectiveTextThreadId(request, route) {
+  const requestThreadId = trimmedOrNull(request.threadId);
+  const routeThreadId = trimmedOrNull(route.threadId);
+  if (request.channel === "telegram") {
+    if (requestThreadId)
+      return requestThreadId;
+    if (route.chatType === "direct")
+      return null;
+    return route.chatId.trim().startsWith("-") ? routeThreadId : null;
+  }
+  if (request.channel === "discord") {
+    return route.chatType === "direct" ? route.chatId : requestThreadId ?? routeThreadId;
+  }
+  if (request.channel === "slack") {
+    const isDirect = route.chatType === "direct" || request.chatId.startsWith("D");
+    if (isDirect)
+      return requestThreadId ?? routeThreadId;
+    return request.replyToMessageId ? null : requestThreadId ?? routeThreadId;
+  }
+  return null;
+}
+function effectiveTextReplyId(request, route) {
+  const isSlackDirect = request.channel === "slack" && (route.chatType === "direct" || request.chatId.startsWith("D"));
+  return isSlackDirect ? null : trimmedOrNull(request.replyToMessageId);
+}
+function messageIdempotencyKey(request, route) {
+  if (request.action !== "send" && request.action !== "send-rich" || request.mediaPath) {
+    return null;
+  }
+  return JSON.stringify({
+    action: request.action,
+    channel: request.channel,
+    chatId: route.chatId,
+    accountId: route.accountId ?? null,
+    chatType: route.chatType ?? null,
+    threadId: effectiveTextThreadId(request, route),
+    message: request.message ?? null,
+    replyToMessageId: effectiveTextReplyId(request, route)
+  });
+}
 async function executeMessageChannel(input, options3) {
   const normalized = normalizeMessageChannelInput(input, options3.resolver);
   if (typeof normalized === "string")
@@ -476984,10 +477136,8 @@ async function executeMessageChannel(input, options3) {
         channelTurnSources: options3.channelTurnSources
       });
       const requestThreadId = normalized.action === "download-file" ? normalized.threadId : inferredThreadId ?? (normalized.channel === "telegram" && context4.route.chatType === "direct" ? normalized.threadId : context4.route.threadId ?? normalized.threadId);
-      return await dispatchMessageChannelAction({
-        request: buildMessageChannelRequest(normalized, normalized.chatId, requestThreadId),
-        context: context4
-      });
+      const request2 = buildMessageChannelRequest(normalized, normalized.chatId, requestThreadId);
+      return await dispatchWithIdempotency(request2, context4, options3.idempotencyScope);
     }
     if (normalized.channel !== "slack") {
       return `Error: Explicit MessageChannel targets are not supported on ${normalized.channel}.`;
@@ -477008,17 +477158,23 @@ async function executeMessageChannel(input, options3) {
       transport: proactive.transport,
       messageActions: proactive.messageActions
     };
-    return await dispatchMessageChannelAction({
-      request: buildMessageChannelRequest(normalized, proactive.target.chatId, proactive.target.threadId),
-      context: context3
-    });
+    const request = buildMessageChannelRequest(normalized, proactive.target.chatId, proactive.target.threadId);
+    return await dispatchWithIdempotency(request, context3, options3.idempotencyScope);
   } catch (error54) {
+    if (error54 instanceof MessageChannelDuplicateActionError)
+      throw error54;
     const message = error54 instanceof Error ? error54.message : "unknown error";
     return `Error sending message to ${normalized.channel}: ${message}`;
   }
 }
+function dispatchWithIdempotency(request, context3, scope) {
+  const dispatch = () => dispatchMessageChannelAction({ request, context: context3 });
+  const key2 = messageIdempotencyKey(request, context3.route);
+  return scope ? scope.execute(key2, dispatch) : dispatch();
+}
 var init_message_channel_executor = __esm(() => {
   init_message_channel_formatting();
+  init_message_channel_idempotency();
 });
 
 // src/channels/slack/proactive-accounts.ts
@@ -477140,7 +477296,7 @@ function createLocalMessageChannelResolver() {
     }
   };
 }
-async function message_channel(args) {
+async function message_channel(args, idempotencyScope) {
   if (!getChannelRegistry()) {
     return "Error: Channel system is not initialized. Start with --channels flag.";
   }
@@ -477150,7 +477306,8 @@ async function message_channel(args) {
   return await executeMessageChannel(args, {
     scope: args.parentScope,
     resolver: createLocalMessageChannelResolver(),
-    channelTurnSources: args.channelTurnSources
+    channelTurnSources: args.channelTurnSources,
+    idempotencyScope
   });
 }
 var init_message_channel = __esm(() => {
@@ -478089,8 +478246,9 @@ class ChannelGateway {
     this.hooks = hooks;
     this.disposers.push(client.onMessage((message) => this.handleMessage(message)), client.onExternalToolCall((request) => {
       const state = request.runtime ? this.states.get(runtimeKey(request.runtime)) : undefined;
-      const sources = state?.active?.sources ?? state?.routedSources ?? [];
-      return hooks.executeExternalTool(request, sources);
+      const active = state?.active;
+      const sources = active?.sources ?? state?.routedSources ?? [];
+      return hooks.executeExternalTool(request, sources, active?.idempotencyScope ?? null);
     }));
   }
   close() {
@@ -478178,7 +478336,8 @@ class ChannelGateway {
         batchId: `channel-recovered-${crypto.randomUUID()}`,
         sources: uniqueSources(sources),
         progress: createChannelTurnProgressBuilder(),
-        richDraft: null
+        richDraft: null,
+        idempotencyScope: createMessageChannelIdempotencyScope()
       };
       state.active = recoveredTurn;
     }
@@ -478400,7 +478559,8 @@ class ChannelGateway {
       richDraft: this.hooks.createRichDraft?.({
         batchId: `channel-${clientMessageId}`,
         sources
-      }) ?? null
+      }) ?? null,
+      idempotencyScope: createMessageChannelIdempotencyScope()
     };
     const processingEvent = {
       type: "processing",
@@ -478479,6 +478639,7 @@ class ChannelGateway {
 var MAX_ACCEPTED_CLIENT_MESSAGE_IDS = 2048;
 var init_gateway_core = __esm(() => {
   init_interactive_policy();
+  init_message_channel_idempotency();
   init_progress_builder();
 });
 
@@ -479972,7 +480133,7 @@ async function startLocalChannelGateway(options3) {
     buildExternalTool: async (runtime) => {
       return buildGatewayMessageChannelTool(registry2.resolveTurnSourcesForScope(runtime.agent_id, runtime.conversation_id));
     },
-    executeExternalTool: async (request, sources) => {
+    executeExternalTool: async (request, sources, idempotencyScope) => {
       if (request.tool_name !== "MessageChannel" || !request.runtime) {
         throw new Error(`Unsupported gateway tool: ${request.tool_name}`);
       }
@@ -479985,9 +480146,10 @@ async function startLocalChannelGateway(options3) {
           conversationId: request.runtime.conversation_id
         },
         channelTurnSources: sources
-      });
+      }, idempotencyScope);
       return {
-        content: [{ type: "text", text: text2 }]
+        content: [{ type: "text", text: text2 }],
+        is_error: text2.startsWith("Error:")
       };
     },
     onLifecycle: (event2) => registry2.dispatchTurnLifecycleEvent(event2),
@@ -492535,7 +492697,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.30.10"
+    version: "0.30.11"
   };
 });
 
@@ -559650,4 +559812,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=BC797C70CE06CED564756E2164756E21
+//# debugId=49F16715F241AC4A64756E2164756E21