@letta-ai/letta-code 0.30.10 → 0.30.11

package/dist/gateway-core.js

@@ -14,6 +14,53 @@ function getInteractiveApprovalKind(toolName) {
   }
 }
 
+// src/channels/message-channel-idempotency.ts
+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";
+  }
+}
+function isErrorResult(result) {
+  return result.startsWith("Error:");
+}
+function createMessageChannelIdempotencyScope() {
+  const inFlight = new Map;
+  let lastSuccessful = null;
+  let latestInvocation = 0;
+  return {
+    async execute(key, effect) {
+      if (!key) {
+        latestInvocation += 1;
+        lastSuccessful = null;
+        return await effect();
+      }
+      const pendingDuplicate = inFlight.get(key);
+      if (pendingDuplicate) {
+        throw new MessageChannelDuplicateActionError("in-flight");
+      }
+      if (lastSuccessful?.key === key) {
+        throw new MessageChannelDuplicateActionError("completed");
+      }
+      const invocation = ++latestInvocation;
+      lastSuccessful = null;
+      const pending = Promise.resolve().then(effect);
+      inFlight.set(key, pending);
+      try {
+        const result = await pending;
+        if (invocation === latestInvocation && !isErrorResult(result)) {
+          lastSuccessful = { key };
+        }
+        return result;
+      } finally {
+        if (inFlight.get(key) === pending)
+          inFlight.delete(key);
+      }
+    }
+  };
+}
+
 // src/channels/progress-formatting.ts
 var MAX_PROGRESS_TEXT_LENGTH = 140;
 var MAX_PROGRESS_DETAILS_LENGTH = 180;
@@ -844,8 +891,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() {
@@ -933,7 +981,8 @@ class ChannelGateway {
         batchId: `channel-recovered-${crypto.randomUUID()}`,
         sources: uniqueSources(sources),
         progress: createChannelTurnProgressBuilder(),
-        richDraft: null
+        richDraft: null,
+        idempotencyScope: createMessageChannelIdempotencyScope()
       };
       state.active = recoveredTurn;
     }
@@ -1155,7 +1204,8 @@ class ChannelGateway {
       richDraft: this.hooks.createRichDraft?.({
         batchId: `channel-${clientMessageId}`,
         sources
-      }) ?? null
+      }) ?? null,
+      idempotencyScope: createMessageChannelIdempotencyScope()
     };
     const processingEvent = {
       type: "processing",
@@ -1897,6 +1947,50 @@ async function dispatchMessageChannelAction(params) {
     formatText: (text) => formatOutboundChannelMessage(params.request.channel, text)
   });
 }
+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, options) {
   const normalized = normalizeMessageChannelInput(input, options.resolver);
   if (typeof normalized === "string")
@@ -1931,10 +2025,8 @@ async function executeMessageChannel(input, options) {
         channelTurnSources: options.channelTurnSources
       });
       const requestThreadId = normalized.action === "download-file" ? normalized.threadId : inferredThreadId ?? (normalized.channel === "telegram" && context2.route.chatType === "direct" ? normalized.threadId : context2.route.threadId ?? normalized.threadId);
-      return await dispatchMessageChannelAction({
-        request: buildMessageChannelRequest(normalized, normalized.chatId, requestThreadId),
-        context: context2
-      });
+      const request2 = buildMessageChannelRequest(normalized, normalized.chatId, requestThreadId);
+      return await dispatchWithIdempotency(request2, context2, options.idempotencyScope);
     }
     if (normalized.channel !== "slack") {
       return `Error: Explicit MessageChannel targets are not supported on ${normalized.channel}.`;
@@ -1955,15 +2047,20 @@ async function executeMessageChannel(input, options) {
       transport: proactive.transport,
       messageActions: proactive.messageActions
     };
-    return await dispatchMessageChannelAction({
-      request: buildMessageChannelRequest(normalized, proactive.target.chatId, proactive.target.threadId),
-      context
-    });
+    const request = buildMessageChannelRequest(normalized, proactive.target.chatId, proactive.target.threadId);
+    return await dispatchWithIdempotency(request, context, options.idempotencyScope);
   } catch (error) {
+    if (error instanceof MessageChannelDuplicateActionError)
+      throw error;
     const message = error instanceof Error ? error.message : "unknown error";
     return `Error sending message to ${normalized.channel}: ${message}`;
   }
 }
+function dispatchWithIdempotency(request, context, scope) {
+  const dispatch = () => dispatchMessageChannelAction({ request, context });
+  const key = messageIdempotencyKey(request, context.route);
+  return scope ? scope.execute(key, dispatch) : dispatch();
+}
 // src/tools/descriptions/MessageChannel.md
 var MessageChannel_default = '# MessageChannel\n\nSend a message or channel action to an external channel.\n\nWhen you receive a `<channel-notification>`, use this tool to reply directly to the user on the same external channel. A normal assistant response is not delivered back to the external channel automatically.\n\nThere are two supported send modes:\n- Reply mode: use `channel` + `chat_id` from the notification to respond in the current routed chat.\n- Proactive mode: use `channel` + `target` on supported channels to send to an explicit outbound destination.\n\nPreferred reply pattern:\n- `action="send"` to send a normal reply\n- `channel` + `chat_id` from the notification attributes\n- `message` for the text body\n\nParameters:\n- `action`: The action to perform. The exact available actions depend on the active channel plugins and are reflected in the JSON schema.\n- `channel`: The platform to send to.\n- `chat_id`: Reply target for the current routed chat. Use this when responding to a channel notification.\n- `target`: Explicit outbound target for proactive sends on supported channels.\n- `accountId`: Optional channel account selector when multiple eligible accounts are available.\n- `message`: Text body for `action="send"`.\n- `replyTo`: Optional message ID to reply to. Omit this unless you intentionally want the platform\'s quote/reply UI.\n- `messageId`: Optional target message id for message-scoped actions like reactions.\n- `emoji`: Optional reaction payload for channels that support reactions.\n- `remove`: Optional boolean to remove a reaction instead of adding it.\n- `media`: Optional absolute local file path for file/media uploads on channels that support uploads.\n- `filename`: Optional uploaded filename override when supported by the channel.\n- `title`: Optional uploaded attachment title when supported by the channel.\n\nRules:\n- Always pass `action` explicitly, even for a normal reply.\n- Pass exactly one of `chat_id` or `target`.\n- `react` should be its own call.\n- `upload-file` can include both `media` and `message` so the uploaded file has a caption/comment when the channel supports it.\n- Telegram supports `action="send-rich"` for Bot API Rich Messages from Markdown content. Use it for headings, lists, tables, rich block quotes, details blocks, formulas, and longer structured messages; use `upload-file` for local media files.\n\nTelegram rich messages:\n- In Telegram private chats, normal `action="send"` messages are sent through Bot API Rich Messages by default when the Telegram account enables `rich_private_chat_default`; with that setting disabled, use explicit `action="send-rich"` for rich delivery.\n- Use `action="send-rich"` with `channel="telegram"` for structured Markdown rendered by Telegram Bot API Rich Messages.\n- Use this when the output benefits from real headings, tables, block quotes, collapsible details, footnotes, task lists, or formulas.\n- The `message` field is passed as Telegram rich Markdown. Supported examples include:\n  - headings: `# Heading`, `## Heading`\n  - lists: `- item`, `1. item`, `- [ ] task`, `- [x] done`\n  - tables: GitHub-style pipe tables\n  - block quotes: `> quoted text`\n  - collapsible details: `<details><summary>Title</summary>content</details>`\n  - inline math: `$E = mc^2$`\n  - display math: `$$E = mc^2$$` or fenced `math` code blocks\n  - footnotes: `text[^id]` with `[^id]: definition`\n- Prefer dollar-delimited math. `\\(...\\)` and `\\[...\\]` do not reliably render as formulas in Telegram rich Markdown.\n- Do not use `send-rich` for local file uploads. Use `upload-file`; rich Markdown media blocks only support HTTP/HTTPS URLs.\n- Rich messages persist only when the final `send-rich` call executes. If Telegram draft streaming is enabled for the account, the channel runtime may show ephemeral previews automatically; do not try to manage draft lifecycle from the tool call.\n';
 // src/tools/schemas/MessageChannel.json
@@ -2211,4 +2308,4 @@ export {
   ChannelGateway
 };
 
-//# debugId=CF539D37E789E01964756E2164756E21
+//# debugId=DFB30BEB2B5EB10F64756E2164756E21