@letta-ai/letta-code 0.30.10 → 0.30.11

package/dist/channels-public.js

@@ -1,3 +1,207 @@
+// src/channels/command-surface.ts
+var DEFAULT_CHANNEL_DISPLAY_NAMES = {
+  custom: "Custom",
+  discord: "Discord",
+  signal: "Signal",
+  slack: "Slack",
+  telegram: "Telegram",
+  whatsapp: "WhatsApp"
+};
+function defaultChannelDisplayName(channelId) {
+  return DEFAULT_CHANNEL_DISPLAY_NAMES[channelId] ?? channelId;
+}
+var 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."
+  }
+];
+var SLACK_MENTION_COMMAND_NAMES = [
+  "help",
+  "detach",
+  "model",
+  "new",
+  "reload"
+];
+function listChannelSlashCommands() {
+  return CHANNEL_SLASH_COMMANDS.map((definition) => ({
+    ...definition,
+    aliases: definition.aliases ? [...definition.aliases] : undefined
+  }));
+}
+function parseSingleLineChannelCommand(text, prefix) {
+  const trimmed = text.trim();
+  const escapedPrefix = prefix === "/" ? "\\/" : "!";
+  const match = trimmed.match(new RegExp(`^${escapedPrefix}([A-Za-z][\\w-]*)(?:@[A-Za-z0-9_]+)?(?:[^\\S\\r\\n]+(.*))?$`));
+  if (!match) {
+    return null;
+  }
+  const [, name, args] = match;
+  if (!name) {
+    return null;
+  }
+  return {
+    name: name.toLowerCase(),
+    args: args?.trim() ?? "",
+    raw: trimmed
+  };
+}
+function parseAnySingleLineChannelCommand(text) {
+  return parseSingleLineChannelCommand(text, "/") ?? parseSingleLineChannelCommand(text, "!");
+}
+function parseChannelCommand(text, prefix) {
+  const lines = text.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(text) {
+  return parseChannelCommand(text, "/");
+}
+function parseChannelBangCommand(text) {
+  return parseChannelCommand(text, "!");
+}
+function supportedCommandsText(prefix = "/") {
+  return listChannelSlashCommands().map((definition) => `${prefix}${definition.name}`).join(", ");
+}
+var 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"
+];
+function supportedSlackMentionSlashCommandsText() {
+  return SLACK_MENTION_SLASH_COMMAND_EXAMPLES.join(", ");
+}
+function supportedBangCommandsText() {
+  return SLACK_MENTION_COMMAND_NAMES.map((name) => `!${name}`).join(", ");
+}
+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(`
+
+`);
+}
 // src/channels/core-stream.ts
 var LETTA_STREAM_NO_ASSISTANT_MESSAGE_ERROR = "No assistant message received in stream";
 
@@ -148,6 +352,199 @@ async function collectLettaSseAssistantText(body, options = {}) {
     stopReason
   };
 }
+// src/utils/conversation-busy-error.ts
+var CONVERSATION_BUSY_ERROR_PATTERNS = [
+  /another request is (?:currently )?(?:being )?processed/i,
+  /currently being processed for this conversation/i,
+  /busy with another active run/i,
+  /already processing for this conversation/i,
+  /turn still running/i
+];
+var CONVERSATION_BUSY_TITLE = "Turn still running";
+function isConversationBusyErrorText(errorText) {
+  if (!errorText)
+    return false;
+  return CONVERSATION_BUSY_ERROR_PATTERNS.some((pattern) => pattern.test(errorText));
+}
+function buildConversationBusyErrorBody(automaticRetry) {
+  return automaticRetry ? "Another request is already processing for this conversation. I’ll wait for it to finish and retry automatically." : "Another request is already processing for this conversation. Please wait for it to finish, then try again.";
+}
+
+// src/channels/lifecycle-error.ts
+var RAW_LOOP_ERROR_PATTERN = /^Unexpected stop reason:\s*error$/i;
+var APP_CHAT_URL_PATTERN = /https:\/\/app\.letta\.com\/chat\/\S+/i;
+var ESCAPE_CHARACTER = String.fromCharCode(27);
+var OSC8_PREFIX = `${ESCAPE_CHARACTER}]8;;`;
+var OSC8_TERMINATOR = `${ESCAPE_CHARACTER}\\`;
+var APPROVAL_PENDING_ERROR_PATTERNS = [
+  /waiting for approval/i,
+  /pending request before continuing/i,
+  /approve or deny the pending request/i
+];
+var DATABASE_LOCK_TIMEOUT_PATTERN = /\bcancel(?:l)?ing statement due to lock timeout\b/i;
+var POSTGRES_LOCK_NOT_AVAILABLE_CODE_PATTERN = /\b55P03\b/i;
+var POSTGRES_LOCK_NOT_AVAILABLE_SQLSTATE_PATTERN = /\b(?:sqlstate|pgcode)\s*[:=]?\s*["']?55P03\b/i;
+var POSTGRES_LOCK_NOT_AVAILABLE_CONTEXT_PATTERN = /\b(?:postgres(?:ql)?|psycopg|sqlalchemy|lock[_ -]?not[_ -]?available|lock timeout)\b/i;
+var RUN_ID_PATTERNS = [
+  /"run_id"\s*:\s*"([^"\\]+)"/i,
+  /\brun[_\s-]?id\b["']?\s*[:=]\s*["']?([A-Za-z0-9_-]+)/i,
+  /\(run:\s*([A-Za-z0-9_-]+)\)/i
+];
+var CHANNEL_LIFECYCLE_FALLBACK_ERROR_MESSAGE = "Something went wrong while processing that message. Please try again.";
+var CHANNEL_LIFECYCLE_APPROVAL_PENDING_MESSAGE = "The agent is still waiting on a tool approval from an earlier turn. Please approve or deny that pending request, then send your message again.";
+var CHANNEL_LIFECYCLE_TRANSIENT_ERROR_MESSAGE = "A temporary error interrupted this turn. Please try again.";
+var CHANNEL_LIFECYCLE_CONVERSATION_BUSY_TITLE = CONVERSATION_BUSY_TITLE;
+function stripTrailingRunIdPunctuation(runId) {
+  return runId.replace(/[)"'.,;]+$/g, "");
+}
+function extractChannelLifecycleRunId(errorText) {
+  if (!errorText)
+    return;
+  for (const pattern of RUN_ID_PATTERNS) {
+    const match = errorText.match(pattern);
+    const runId = match?.[1]?.trim();
+    if (runId) {
+      return stripTrailingRunIdPunctuation(runId);
+    }
+  }
+  return;
+}
+function stripOsc8TerminalLinks(errorText) {
+  let output = "";
+  let cursor = 0;
+  while (cursor < errorText.length) {
+    const linkStart = errorText.indexOf(OSC8_PREFIX, cursor);
+    if (linkStart === -1) {
+      output += errorText.slice(cursor);
+      break;
+    }
+    const labelStart = errorText.indexOf(OSC8_TERMINATOR, linkStart + OSC8_PREFIX.length);
+    if (labelStart === -1) {
+      output += errorText.slice(cursor);
+      break;
+    }
+    const closeStart = errorText.indexOf(OSC8_PREFIX, labelStart + OSC8_TERMINATOR.length);
+    if (closeStart === -1) {
+      output += errorText.slice(cursor);
+      break;
+    }
+    const closeEnd = errorText.indexOf(OSC8_TERMINATOR, closeStart + OSC8_PREFIX.length);
+    if (closeEnd === -1) {
+      output += errorText.slice(cursor);
+      break;
+    }
+    output += errorText.slice(cursor, linkStart);
+    output += errorText.slice(labelStart + OSC8_TERMINATOR.length, closeStart);
+    cursor = closeEnd + OSC8_TERMINATOR.length;
+  }
+  return output;
+}
+function sanitizeChannelLifecycleErrorText(errorText) {
+  if (!errorText)
+    return "";
+  const withoutTerminalLinks = stripOsc8TerminalLinks(errorText);
+  return withoutTerminalLinks.split(`
+`).filter((line) => {
+    const trimmed = line.trim();
+    if (/^View agent:/i.test(trimmed))
+      return false;
+    if (APP_CHAT_URL_PATTERN.test(trimmed))
+      return false;
+    return true;
+  }).join(`
+`).replace(/[ \t]+\n/g, `
+`).trim();
+}
+function truncateLifecycleMessage(text, maxLength) {
+  if (text.length <= maxLength)
+    return text;
+  return `${text.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}
+function isDatabaseLockErrorText(errorText) {
+  return DATABASE_LOCK_TIMEOUT_PATTERN.test(errorText) || POSTGRES_LOCK_NOT_AVAILABLE_SQLSTATE_PATTERN.test(errorText) || POSTGRES_LOCK_NOT_AVAILABLE_CODE_PATTERN.test(errorText) && POSTGRES_LOCK_NOT_AVAILABLE_CONTEXT_PATTERN.test(errorText);
+}
+function getChannelLifecycleErrorDisplay(errorText, options = {}) {
+  const normalized = sanitizeChannelLifecycleErrorText(errorText);
+  const optionsRunId = options.runId?.trim();
+  const runId = optionsRunId || extractChannelLifecycleRunId(errorText);
+  if (!normalized || RAW_LOOP_ERROR_PATTERN.test(normalized)) {
+    return {
+      kind: "generic",
+      title: "Turn failed",
+      body: CHANNEL_LIFECYCLE_FALLBACK_ERROR_MESSAGE,
+      runId
+    };
+  }
+  if (isDatabaseLockErrorText(normalized)) {
+    return {
+      kind: "database_lock_timeout",
+      title: "Turn failed",
+      body: CHANNEL_LIFECYCLE_TRANSIENT_ERROR_MESSAGE,
+      runId
+    };
+  }
+  if (isConversationBusyErrorText(normalized)) {
+    return {
+      kind: "conversation_busy",
+      title: CHANNEL_LIFECYCLE_CONVERSATION_BUSY_TITLE,
+      body: buildConversationBusyErrorBody(options.automaticRetry ?? false),
+      runId
+    };
+  }
+  if (APPROVAL_PENDING_ERROR_PATTERNS.some((pattern) => pattern.test(normalized))) {
+    return {
+      kind: "approval_pending",
+      title: "Turn failed",
+      body: CHANNEL_LIFECYCLE_APPROVAL_PENDING_MESSAGE,
+      runId
+    };
+  }
+  return {
+    kind: "generic",
+    title: "Turn failed",
+    body: normalized,
+    runId
+  };
+}
+function normalizeChannelLifecycleErrorMessage(errorText, options = {}) {
+  return getChannelLifecycleErrorDisplay(errorText, options).body;
+}
+function formatChannelLifecycleErrorMessage(errorText, options = {}) {
+  const display = getChannelLifecycleErrorDisplay(errorText, options);
+  const maxLength = options.maxLength ?? Number.POSITIVE_INFINITY;
+  const body = truncateLifecycleMessage(display.body, maxLength);
+  if (display.kind === "conversation_busy") {
+    const lines2 = [display.title, body];
+    if (display.runId) {
+      lines2.push("", `Run ID: ${display.runId}`);
+    }
+    return lines2.join(`
+`);
+  }
+  if (display.kind === "database_lock_timeout") {
+    const lines2 = [`${display.title}:`, body];
+    if (display.runId) {
+      lines2.push("", `Run ID: ${display.runId}`);
+    }
+    return lines2.join(`
+`);
+  }
+  if (options.codeBlock) {
+    const escaped = body.replace(/```/g, "``​`");
+    const lines2 = [`${display.title}:`, "```", escaped, "```"];
+    if (display.runId) {
+      lines2.push("", `Run ID: ${display.runId}`);
+    }
+    return lines2.join(`
+`);
+  }
+  const lines = [`${display.title}:`, body];
+  if (display.runId) {
+    lines.push("", `Run ID: ${display.runId}`);
+  }
+  return lines.join(`
+`);
+}
 // src/constants.ts
 var SYSTEM_REMINDER_TAG = "system-reminder";
 var SYSTEM_REMINDER_OPEN = `<${SYSTEM_REMINDER_TAG}>`;
@@ -1209,16 +1606,28 @@ function createChannelTurnProgressBuilder(options = {}) {
   return { buildUpdates };
 }
 export {
+  sanitizeChannelLifecycleErrorText,
+  parseChannelSlashCommand,
+  parseChannelBangCommand,
+  normalizeChannelLifecycleErrorMessage,
+  listChannelSlashCommands,
+  getChannelLifecycleErrorDisplay,
   formatLettaStreamCoreErrorForChannel,
   formatInboundChannelMessageForAgent,
+  formatChannelLifecycleErrorMessage,
   formatBatchedChannelMessagesForAgent,
+  extractChannelLifecycleRunId,
+  defaultChannelDisplayName,
   createChannelTurnProgressBuilder,
   collectLettaSseAssistantText,
+  buildUnsupportedChannelCommandMessage,
   buildOutboundChannelMessageFromTurnSource,
   buildChannelTurnSource,
+  buildChannelHelpMessage,
   LettaStreamNoAssistantMessageError,
   LettaStreamCoreError,
-  LETTA_STREAM_NO_ASSISTANT_MESSAGE_ERROR
+  LETTA_STREAM_NO_ASSISTANT_MESSAGE_ERROR,
+  CHANNEL_LIFECYCLE_FALLBACK_ERROR_MESSAGE
 };
 
-//# debugId=39670CE4D9784BEC64756E2164756E21
+//# debugId=A70285B59041328B64756E2164756E21