@letta-ai/letta-code 0.30.11 → 0.30.12

package/dist/channels-public.js

@@ -1,4 +1,5 @@
 // src/channels/command-surface.ts
+var DEFAULT_EXTRA_COMMANDS_LABEL = "Host commands";
 var DEFAULT_CHANNEL_DISPLAY_NAMES = {
   custom: "Custom",
   discord: "Discord",
@@ -75,11 +76,51 @@ var SLACK_MENTION_COMMAND_NAMES = [
   "new",
   "reload"
 ];
-function listChannelSlashCommands() {
-  return CHANNEL_SLASH_COMMANDS.map((definition) => ({
+function copyDefinition(definition) {
+  return {
     ...definition,
     aliases: definition.aliases ? [...definition.aliases] : undefined
-  }));
+  };
+}
+function dedupedExtraCommands(options) {
+  const extras = options?.extraCommands;
+  if (!extras || extras.length === 0) {
+    return [];
+  }
+  const takenNames = new Set(SLACK_MENTION_COMMAND_NAMES);
+  for (const definition of CHANNEL_SLASH_COMMANDS) {
+    takenNames.add(definition.name.toLowerCase());
+    for (const alias of definition.aliases ?? []) {
+      takenNames.add(alias.toLowerCase());
+    }
+  }
+  const surviving = [];
+  for (const extra of extras) {
+    const nameKey = extra.name.toLowerCase();
+    if (takenNames.has(nameKey)) {
+      continue;
+    }
+    takenNames.add(nameKey);
+    const aliases = (extra.aliases ?? []).filter((alias) => {
+      const aliasKey = alias.toLowerCase();
+      if (takenNames.has(aliasKey)) {
+        return false;
+      }
+      takenNames.add(aliasKey);
+      return true;
+    });
+    surviving.push({
+      ...extra,
+      aliases: aliases.length > 0 ? aliases : undefined
+    });
+  }
+  return surviving;
+}
+function listChannelSlashCommands(options) {
+  return [
+    ...CHANNEL_SLASH_COMMANDS.map(copyDefinition),
+    ...dedupedExtraCommands(options)
+  ];
 }
 function parseSingleLineChannelCommand(text, prefix) {
   const trimmed = text.trim();
@@ -132,8 +173,8 @@ function parseChannelSlashCommand(text) {
 function parseChannelBangCommand(text) {
   return parseChannelCommand(text, "!");
 }
-function supportedCommandsText(prefix = "/") {
-  return listChannelSlashCommands().map((definition) => `${prefix}${definition.name}`).join(", ");
+function supportedCommandsText(prefix = "/", options) {
+  return listChannelSlashCommands(options).map((definition) => `${prefix}${definition.name}`).join(", ");
 }
 var SLACK_MENTION_SLASH_COMMAND_EXAMPLES = [
   "@agent /help",
@@ -150,15 +191,22 @@ var SLACK_MENTION_SLASH_COMMAND_EXAMPLES = [
   "@agent /new",
   "@agent /reload"
 ];
-function supportedSlackMentionSlashCommandsText() {
-  return SLACK_MENTION_SLASH_COMMAND_EXAMPLES.join(", ");
+function supportedSlackMentionSlashCommandsText(options) {
+  const extras = dedupedExtraCommands(options).map((definition) => `@agent /${definition.name}`);
+  return [...SLACK_MENTION_SLASH_COMMAND_EXAMPLES, ...extras].join(", ");
 }
 function supportedBangCommandsText() {
   return SLACK_MENTION_COMMAND_NAMES.map((name) => `!${name}`).join(", ");
 }
-function buildChannelHelpMessage(channelId, resolveDisplayName = defaultChannelDisplayName) {
+function buildChannelHelpMessage(channelId, resolveDisplayName = defaultChannelDisplayName, options) {
   const displayName = resolveDisplayName(channelId);
+  const extras = dedupedExtraCommands(options);
+  const extrasLabel = options?.extraCommandsLabel ?? DEFAULT_EXTRA_COMMANDS_LABEL;
   if (channelId === "slack") {
+    const extraLines = extras.length > 0 ? [
+      `${extrasLabel}:`,
+      ...extras.map((definition) => `@agent /${definition.name} - ${definition.summary}`)
+    ] : [];
     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.",
@@ -174,25 +222,30 @@ function buildChannelHelpMessage(channelId, resolveDisplayName = defaultChannelD
       "@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",
+      ...extraLines,
       `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(`
 `);
   }
+  const extraParagraphs = extras.length > 0 ? [
+    `${extrasLabel} here: ${extras.map((definition) => `/${definition.name}`).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()}.`,
+    ...extraParagraphs,
     "If this chat is not connected yet, send any non-command message and follow the pairing instructions."
   ].join(`
 
 `);
 }
-function buildUnsupportedChannelCommandMessage(channelId, command, resolveDisplayName = defaultChannelDisplayName) {
+function buildUnsupportedChannelCommandMessage(channelId, command, resolveDisplayName = defaultChannelDisplayName, options) {
   const displayName = resolveDisplayName(channelId);
   const isBang = command.raw.startsWith("!");
   const commandKind = isBang ? "bang" : "slash";
-  const supportedCommands = isBang ? supportedBangCommandsText() : channelId === "slack" ? supportedSlackMentionSlashCommandsText() : supportedCommandsText();
+  const supportedCommands = isBang ? supportedBangCommandsText() : channelId === "slack" ? supportedSlackMentionSlashCommandsText(options) : supportedCommandsText("/", options);
   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.`,
@@ -202,6 +255,229 @@ function buildUnsupportedChannelCommandMessage(channelId, command, resolveDispla
 
 `);
 }
+
+// src/channels/command-runtime-executor.ts
+var DEFAULT_CHANNEL_MODEL_LIST_LIMIT = 8;
+function getModelEntryRank(entry) {
+  if (entry.isDefault)
+    return 0;
+  if (entry.isFeatured)
+    return 1;
+  const effort = entry.updateArgs?.reasoning_effort;
+  if (effort === "medium")
+    return 2;
+  if (effort === "high")
+    return 3;
+  return 4;
+}
+function preferModelEntry(current, candidate) {
+  return getModelEntryRank(candidate) < getModelEntryRank(current) ? candidate : current;
+}
+function buildModelEntriesByHandle(entries) {
+  const byHandle = new Map;
+  for (const entry of entries) {
+    const current = byHandle.get(entry.handle);
+    byHandle.set(entry.handle, current ? preferModelEntry(current, entry) : entry);
+  }
+  return byHandle;
+}
+function makeUnknownModelEntry(handle) {
+  return {
+    id: handle,
+    handle,
+    label: handle,
+    description: ""
+  };
+}
+function resolveModelHandles(params) {
+  const { handles, byHandle, availableHandles } = params;
+  const seen = new Set;
+  const resolved = [];
+  for (const handle of handles) {
+    if (!handle || seen.has(handle))
+      continue;
+    seen.add(handle);
+    if (availableHandles && !availableHandles.has(handle))
+      continue;
+    resolved.push(byHandle.get(handle) ?? makeUnknownModelEntry(handle));
+  }
+  return resolved;
+}
+function getFallbackModelEntries(byHandle) {
+  const preferred = Array.from(byHandle.values()).filter((entry) => entry.isDefault || entry.isFeatured);
+  return preferred.length > 0 ? preferred : Array.from(byHandle.values());
+}
+function modelCommandPrefix(channelId) {
+  return channelId === "slack" ? "@agent /model" : "/model";
+}
+function buildChannelModelNotFoundText(channelId) {
+  return `Model not found. Use ${modelCommandPrefix(channelId)} list to see available models.`;
+}
+function buildChannelCurrentModelMessage(channelId, params, displayNameResolver = defaultChannelDisplayName) {
+  const displayName = displayNameResolver(channelId);
+  const scope = params.scope === "agent" ? "agent" : "conversation";
+  const handleText = params.modelHandle && params.modelHandle !== params.modelLabel ? ` (${params.modelHandle})` : "";
+  const switchCommand = modelCommandPrefix(channelId);
+  return [
+    `${displayName} current ${scope} model: ${params.modelLabel}${handleText}.`,
+    `Use ${switchCommand} list to see available models, or ${switchCommand} <handle-or-id> to switch.`
+  ].join(`
+`);
+}
+function formatChannelModelEntry(channelId, entry) {
+  const selector = entry.id || entry.handle;
+  const handleText = entry.handle === entry.label ? "" : ` — ${entry.handle}`;
+  return `• ${entry.label}${handleText} (${modelCommandPrefix(channelId)} ${selector})`;
+}
+function appendModelEntrySection(lines, channelId, title, entries, limit) {
+  if (entries.length === 0)
+    return;
+  lines.push("", `${title}:`);
+  for (const entry of entries.slice(0, limit)) {
+    lines.push(formatChannelModelEntry(channelId, entry));
+  }
+  const remaining = entries.length - limit;
+  if (remaining > 0) {
+    lines.push(`…and ${remaining} more.`);
+  }
+}
+function buildChannelModelListMessage(channelId, params, displayNameResolver = defaultChannelDisplayName) {
+  const displayName = displayNameResolver(channelId);
+  const limit = params.limit ?? DEFAULT_CHANNEL_MODEL_LIST_LIMIT;
+  const entries = params.entries;
+  const byHandle = buildModelEntriesByHandle(entries);
+  const availableHandleList = Array.isArray(params.availableHandles) ? params.availableHandles : null;
+  const availableSet = availableHandleList ? new Set(availableHandleList) : null;
+  const recentEntries = resolveModelHandles({
+    handles: params.recentHandles ?? [],
+    byHandle,
+    availableHandles: availableSet
+  });
+  const availableEntries = availableHandleList ? resolveModelHandles({ handles: availableHandleList, byHandle }) : getFallbackModelEntries(byHandle);
+  const lines = [`${displayName} model selector`];
+  if (params.availableHandles === null) {
+    lines.push("Availability lookup failed; showing built-in recommended models.");
+  } else if (params.availableHandles === undefined) {
+    lines.push("Available model data was not returned; showing built-in recommended models.");
+  }
+  appendModelEntrySection(lines, channelId, "Recent models", recentEntries, limit);
+  appendModelEntrySection(lines, channelId, "Available models", availableEntries, limit);
+  if (availableEntries.length === 0) {
+    lines.push("", "No available models were reported. Use /connect in Letta Code to configure a provider, then try again.");
+  }
+  lines.push("");
+  if (channelId === "slack") {
+    lines.push("Mention the app with @agent /model <handle-or-id> to switch this thread's routed model. Use @agent /model to show the current model. Legacy !model still works after a mention.");
+  } else {
+    lines.push("Use /model <handle-or-id> to switch this chat's routed model, or /model to show the current model.");
+  }
+  return lines.join(`
+`);
+}
+function buildChannelModelListUnavailableMessage(channelId, error, displayNameResolver = defaultChannelDisplayName) {
+  const displayName = displayNameResolver(channelId);
+  return `${displayName} could not load the model list: ${error}`;
+}
+function buildChannelCurrentModelUnavailableMessage(channelId, error, displayNameResolver = defaultChannelDisplayName) {
+  const displayName = displayNameResolver(channelId);
+  return `${displayName} could not load the current model: ${error}`;
+}
+function buildChannelModelUpdatedMessage(channelId, params, displayNameResolver = defaultChannelDisplayName) {
+  const displayName = displayNameResolver(channelId);
+  const scope = params.appliedTo === "agent" ? "agent" : "conversation";
+  const handleText = params.modelHandle === params.modelLabel ? "" : ` (${params.modelHandle})`;
+  return `${displayName} updated this ${scope}'s model to ${params.modelLabel}${handleText}.`;
+}
+function buildChannelModelUpdateFailedMessage(channelId, identifier, error, displayNameResolver = defaultChannelDisplayName) {
+  const displayName = displayNameResolver(channelId);
+  return `${displayName} could not switch this chat's routed model to ${identifier}: ${error}`;
+}
+function buildChannelCancelAcceptedMessage(channelId, displayNameResolver = defaultChannelDisplayName) {
+  const displayName = displayNameResolver(channelId);
+  return `${displayName} cancelled the in-progress agent turn for this chat.`;
+}
+function buildChannelCancelNoActiveTurnMessage(channelId, displayNameResolver = defaultChannelDisplayName) {
+  const displayName = displayNameResolver(channelId);
+  return `${displayName} received /cancel, but there is no in-progress agent turn to cancel for this chat.`;
+}
+function parseChannelModelCommand(args) {
+  const modelIdentifier = args.trim();
+  if (!modelIdentifier) {
+    return { kind: "current" };
+  }
+  if (modelIdentifier.toLowerCase() === "list") {
+    return { kind: "list" };
+  }
+  return { kind: "update", modelIdentifier };
+}
+async function runChannelModelListCommand(params) {
+  const displayNameResolver = params.channelDisplayName ?? defaultChannelDisplayName;
+  const result = await params.client.listModels();
+  return {
+    handled: true,
+    text: result.success ? buildChannelModelListMessage(params.channelId, {
+      entries: result.entries,
+      availableHandles: result.availableHandles,
+      recentHandles: params.recentHandles
+    }, displayNameResolver) : buildChannelModelListUnavailableMessage(params.channelId, result.error ?? "Failed to list models", displayNameResolver)
+  };
+}
+async function runChannelModelUpdateCommand(params) {
+  const displayNameResolver = params.channelDisplayName ?? defaultChannelDisplayName;
+  const result = await params.client.updateModel({
+    runtime: params.runtime,
+    modelIdentifier: params.modelIdentifier
+  });
+  if (!result.success) {
+    return {
+      handled: true,
+      success: false,
+      text: buildChannelModelUpdateFailedMessage(params.channelId, params.modelIdentifier, result.error ?? "Failed to update model", displayNameResolver)
+    };
+  }
+  const appliedHandle = result.modelHandle ?? params.modelIdentifier;
+  return {
+    handled: true,
+    success: true,
+    modelHandle: appliedHandle,
+    text: buildChannelModelUpdatedMessage(params.channelId, {
+      modelLabel: params.resolveModelLabel?.(appliedHandle) ?? params.modelIdentifier,
+      modelHandle: appliedHandle,
+      appliedTo: result.appliedTo
+    }, displayNameResolver)
+  };
+}
+async function runChannelCancelCommand(params) {
+  const response = await params.client.abortMessage({
+    runtime: params.runtime,
+    runId: null
+  });
+  const cancelled = response.success && response.aborted;
+  if (params.channelId === undefined) {
+    return { handled: true, cancelled };
+  }
+  const displayNameResolver = params.channelDisplayName ?? defaultChannelDisplayName;
+  return {
+    handled: true,
+    cancelled,
+    text: cancelled ? buildChannelCancelAcceptedMessage(params.channelId, displayNameResolver) : buildChannelCancelNoActiveTurnMessage(params.channelId, displayNameResolver)
+  };
+}
+async function runChannelExecuteCommand(params) {
+  const trimmedArgs = params.args?.trim();
+  const response = await params.client.executeCommand({
+    runtime: params.runtime,
+    commandId: params.commandId,
+    ...trimmedArgs ? { args: trimmedArgs } : {}
+  });
+  return { handled: true, text: response.output };
+}
+function runChannelReflectionCommand(params) {
+  return runChannelExecuteCommand({ ...params, commandId: "reflect" });
+}
+function runChannelReloadCommand(params) {
+  return runChannelExecuteCommand({ ...params, commandId: "reload" });
+}
 // src/channels/core-stream.ts
 var LETTA_STREAM_NO_ASSISTANT_MESSAGE_ERROR = "No assistant message received in stream";
 
@@ -1607,7 +1883,13 @@ function createChannelTurnProgressBuilder(options = {}) {
 }
 export {
   sanitizeChannelLifecycleErrorText,
+  runChannelReloadCommand,
+  runChannelReflectionCommand,
+  runChannelModelUpdateCommand,
+  runChannelModelListCommand,
+  runChannelCancelCommand,
   parseChannelSlashCommand,
+  parseChannelModelCommand,
   parseChannelBangCommand,
   normalizeChannelLifecycleErrorMessage,
   listChannelSlashCommands,
@@ -1623,11 +1905,20 @@ export {
   buildUnsupportedChannelCommandMessage,
   buildOutboundChannelMessageFromTurnSource,
   buildChannelTurnSource,
+  buildChannelModelUpdatedMessage,
+  buildChannelModelUpdateFailedMessage,
+  buildChannelModelNotFoundText,
+  buildChannelModelListUnavailableMessage,
+  buildChannelModelListMessage,
   buildChannelHelpMessage,
+  buildChannelCurrentModelUnavailableMessage,
+  buildChannelCurrentModelMessage,
+  buildChannelCancelNoActiveTurnMessage,
+  buildChannelCancelAcceptedMessage,
   LettaStreamNoAssistantMessageError,
   LettaStreamCoreError,
   LETTA_STREAM_NO_ASSISTANT_MESSAGE_ERROR,
   CHANNEL_LIFECYCLE_FALLBACK_ERROR_MESSAGE
 };
 
-//# debugId=A70285B59041328B64756E2164756E21
+//# debugId=7BECF32CA37A743264756E2164756E21