chat 4.14.0 → 4.16.0

package/README.md

@@ -27,6 +27,7 @@ const bot = new Chat({
     }),
   },
   state: createRedisState({ url: process.env.REDIS_URL! }),
+  dedupeTtlMs: 600_000, // 10 minutes (default: 5 min)
 });
 
 bot.onNewMention(async (thread) => {
@@ -39,6 +40,17 @@ bot.onSubscribedMessage(async (thread, message) => {
 });
 ```
 
+## Configuration
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `userName` | `string` | **required** | Default bot username across all adapters |
+| `adapters` | `Record<string, Adapter>` | **required** | Map of adapter name to adapter instance |
+| `state` | `StateAdapter` | **required** | State adapter for subscriptions, locking, and dedup |
+| `logger` | `Logger \| LogLevel` | `"info"` | Logger instance or log level (`"silent"` to disable) |
+| `streamingUpdateIntervalMs` | `number` | `500` | Update interval for fallback streaming (post + edit) in ms |
+| `dedupeTtlMs` | `number` | `300000` | TTL for message deduplication entries in ms. Increase if webhook cold starts cause platform retries (e.g., Slack's `http_timeout` retry) that arrive after the default window |
+
 ## AI coding agent support
 
 If you use an AI coding agent like [Claude Code](https://docs.anthropic.com/en/docs/claude-code), you can teach it about Chat SDK:

package/dist/{chunk-THM4ACIE.js → chunk-7S5DLTN2.js}

@@ -1,3 +1,280 @@
+// src/markdown.ts
+import { toString as mdastToString } from "mdast-util-to-string";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import remarkStringify from "remark-stringify";
+import { unified } from "unified";
+function isTextNode(node) {
+  return node.type === "text";
+}
+function isParagraphNode(node) {
+  return node.type === "paragraph";
+}
+function isStrongNode(node) {
+  return node.type === "strong";
+}
+function isEmphasisNode(node) {
+  return node.type === "emphasis";
+}
+function isDeleteNode(node) {
+  return node.type === "delete";
+}
+function isInlineCodeNode(node) {
+  return node.type === "inlineCode";
+}
+function isCodeNode(node) {
+  return node.type === "code";
+}
+function isLinkNode(node) {
+  return node.type === "link";
+}
+function isBlockquoteNode(node) {
+  return node.type === "blockquote";
+}
+function isListNode(node) {
+  return node.type === "list";
+}
+function isListItemNode(node) {
+  return node.type === "listItem";
+}
+function isTableNode(node) {
+  return node.type === "table";
+}
+function isTableRowNode(node) {
+  return node.type === "tableRow";
+}
+function isTableCellNode(node) {
+  return node.type === "tableCell";
+}
+function tableToAscii(node) {
+  const rows = [];
+  for (const row of node.children) {
+    const cells = [];
+    for (const cell of row.children) {
+      cells.push(mdastToString(cell));
+    }
+    rows.push(cells);
+  }
+  if (rows.length === 0) {
+    return "";
+  }
+  const headers = rows[0];
+  const dataRows = rows.slice(1);
+  return tableElementToAscii(headers, dataRows);
+}
+function tableElementToAscii(headers, rows) {
+  const allRows = [headers, ...rows];
+  const colCount = Math.max(...allRows.map((r) => r.length));
+  if (colCount === 0) {
+    return "";
+  }
+  const colWidths = Array.from({ length: colCount }, () => 0);
+  for (const row of allRows) {
+    for (let i = 0; i < colCount; i++) {
+      const cellLen = (row[i] || "").length;
+      if (cellLen > colWidths[i]) {
+        colWidths[i] = cellLen;
+      }
+    }
+  }
+  const formatRow = (cells) => Array.from(
+    { length: colCount },
+    (_, i) => (cells[i] || "").padEnd(colWidths[i])
+  ).join(" | ").trimEnd();
+  const lines = [];
+  lines.push(formatRow(headers));
+  lines.push(colWidths.map((w) => "-".repeat(w)).join("-|-"));
+  for (const row of rows) {
+    lines.push(formatRow(row));
+  }
+  return lines.join("\n");
+}
+function getNodeChildren(node) {
+  if ("children" in node && Array.isArray(node.children)) {
+    return node.children;
+  }
+  return [];
+}
+function getNodeValue(node) {
+  if ("value" in node && typeof node.value === "string") {
+    return node.value;
+  }
+  return "";
+}
+function parseMarkdown(markdown) {
+  const processor = unified().use(remarkParse).use(remarkGfm);
+  return processor.parse(markdown);
+}
+function stringifyMarkdown(ast) {
+  const processor = unified().use(remarkStringify).use(remarkGfm);
+  return processor.stringify(ast);
+}
+function toPlainText(ast) {
+  return mdastToString(ast);
+}
+function markdownToPlainText(markdown) {
+  const ast = parseMarkdown(markdown);
+  return mdastToString(ast);
+}
+function walkAst(node, visitor) {
+  if ("children" in node && Array.isArray(node.children)) {
+    node.children = node.children.map((child) => {
+      const result = visitor(child);
+      if (result === null) {
+        return null;
+      }
+      return walkAst(result, visitor);
+    }).filter((n) => n !== null);
+  }
+  return node;
+}
+function text(value) {
+  return { type: "text", value };
+}
+function strong(children) {
+  return { type: "strong", children };
+}
+function emphasis(children) {
+  return { type: "emphasis", children };
+}
+function strikethrough(children) {
+  return { type: "delete", children };
+}
+function inlineCode(value) {
+  return { type: "inlineCode", value };
+}
+function codeBlock(value, lang) {
+  return { type: "code", value, lang };
+}
+function link(url, children, title) {
+  return { type: "link", url, children, title };
+}
+function blockquote(children) {
+  return { type: "blockquote", children };
+}
+function paragraph(children) {
+  return { type: "paragraph", children };
+}
+function root(children) {
+  return { type: "root", children };
+}
+var BaseFormatConverter = class {
+  /**
+   * Default fallback for converting an unknown mdast node to text.
+   * Recursively converts children if present, otherwise extracts the node value.
+   * Adapters should call this in their nodeToX() default case.
+   */
+  defaultNodeToText(node, nodeConverter) {
+    const children = getNodeChildren(node);
+    if (children.length > 0) {
+      return children.map(nodeConverter).join("");
+    }
+    return getNodeValue(node);
+  }
+  /**
+   * Template method for implementing fromAst with a node converter.
+   * Iterates through AST children and converts each using the provided function.
+   * Joins results with double newlines (standard paragraph separation).
+   *
+   * @param ast - The AST to convert
+   * @param nodeConverter - Function to convert each Content node to string
+   * @returns Platform-formatted string
+   */
+  fromAstWithNodeConverter(ast, nodeConverter) {
+    const parts = [];
+    for (const node of ast.children) {
+      parts.push(nodeConverter(node));
+    }
+    return parts.join("\n\n");
+  }
+  extractPlainText(platformText) {
+    return toPlainText(this.toAst(platformText));
+  }
+  // Convenience methods for markdown string I/O
+  fromMarkdown(markdown) {
+    return this.fromAst(parseMarkdown(markdown));
+  }
+  toMarkdown(platformText) {
+    return stringifyMarkdown(this.toAst(platformText));
+  }
+  /** @deprecated Use extractPlainText instead */
+  toPlainText(platformText) {
+    return this.extractPlainText(platformText);
+  }
+  /**
+   * Convert a PostableMessage to platform format (text only).
+   * - string: passed through as raw text (no conversion)
+   * - { raw: string }: passed through as raw text (no conversion)
+   * - { markdown: string }: converted from markdown to platform format
+   * - { ast: Root }: converted from AST to platform format
+   * - { card: CardElement }: returns fallback text (cards should be handled by adapter)
+   * - CardElement: returns fallback text (cards should be handled by adapter)
+   *
+   * Note: For cards, adapters should check for card content first and render
+   * them using platform-specific card APIs, using this method only for fallback.
+   */
+  renderPostable(message) {
+    if (typeof message === "string") {
+      return message;
+    }
+    if ("raw" in message) {
+      return message.raw;
+    }
+    if ("markdown" in message) {
+      return this.fromMarkdown(message.markdown);
+    }
+    if ("ast" in message) {
+      return this.fromAst(message.ast);
+    }
+    if ("card" in message) {
+      return message.fallbackText || this.cardToFallbackText(message.card);
+    }
+    if ("type" in message && message.type === "card") {
+      return this.cardToFallbackText(message);
+    }
+    throw new Error("Invalid PostableMessage format");
+  }
+  /**
+   * Generate fallback text from a card element.
+   * Override in subclasses for platform-specific formatting.
+   */
+  cardToFallbackText(card) {
+    const parts = [];
+    if (card.title) {
+      parts.push(`**${card.title}**`);
+    }
+    if (card.subtitle) {
+      parts.push(card.subtitle);
+    }
+    for (const child of card.children) {
+      const text2 = this.cardChildToFallbackText(child);
+      if (text2) {
+        parts.push(text2);
+      }
+    }
+    return parts.join("\n");
+  }
+  /**
+   * Convert card child element to fallback text.
+   */
+  cardChildToFallbackText(child) {
+    switch (child.type) {
+      case "text":
+        return child.content;
+      case "fields":
+        return child.children.map((f) => `**${f.label}**: ${f.value}`).join("\n");
+      case "actions":
+        return null;
+      case "table":
+        return tableElementToAscii(child.headers, child.rows);
+      case "section":
+        return child.children.map((c) => this.cardChildToFallbackText(c)).filter(Boolean).join("\n");
+      default:
+        return null;
+    }
+  }
+};
+
 // src/cards.ts
 function isCardElement(value) {
   return typeof value === "object" && value !== null && "type" in value && value.type === "card";
@@ -47,7 +324,8 @@ function Button(options) {
     id: options.id,
     label: options.label,
     style: options.style,
-    value: options.value
+    value: options.value,
+    disabled: options.disabled
   };
 }
 function LinkButton(options) {
@@ -71,6 +349,21 @@ function Fields(children) {
     children
   };
 }
+function Table(options) {
+  return {
+    type: "table",
+    headers: options.headers,
+    rows: options.rows,
+    align: options.align
+  };
+}
+function CardLink(options) {
+  return {
+    type: "link",
+    url: options.url,
+    label: options.label
+  };
+}
 function isReactElement(value) {
   if (typeof value !== "object" || value === null) {
     return false;
@@ -91,8 +384,10 @@ var componentMap = /* @__PURE__ */ new Map([
   [Actions, "Actions"],
   [Button, "Button"],
   [LinkButton, "LinkButton"],
+  [CardLink, "CardLink"],
   [Field, "Field"],
-  [Fields, "Fields"]
+  [Fields, "Fields"],
+  [Table, "Table"]
 ]);
 function fromReactElement(element) {
   if (!isReactElement(element)) {
@@ -163,6 +458,13 @@ function fromReactElement(element) {
         style: props.style
       });
     }
+    case "CardLink": {
+      const label = extractTextContent(props.children);
+      return CardLink({
+        url: props.url,
+        label: props.label ?? label
+      });
+    }
     case "Field":
       return Field({
         label: props.label,
@@ -172,6 +474,12 @@ function fromReactElement(element) {
       return Fields(
         convertedChildren.filter((c) => c.type === "field")
       );
+    case "Table":
+      return Table({
+        headers: props.headers,
+        rows: props.rows,
+        align: props.align
+      });
     default:
       return null;
   }
@@ -207,29 +515,33 @@ function extractTextContent(children) {
 function cardToFallbackText(card) {
   const parts = [];
   if (card.title) {
-    parts.push(card.title);
+    parts.push(`**${card.title}**`);
   }
   if (card.subtitle) {
     parts.push(card.subtitle);
   }
   for (const child of card.children) {
-    const text = childToFallbackText(child);
-    if (text) {
-      parts.push(text);
+    const text2 = cardChildToFallbackText(child);
+    if (text2) {
+      parts.push(text2);
     }
   }
   return parts.join("\n");
 }
-function childToFallbackText(child) {
+function cardChildToFallbackText(child) {
   switch (child.type) {
     case "text":
       return child.content;
+    case "link":
+      return `${child.label} (${child.url})`;
     case "fields":
       return child.children.map((f) => `${f.label}: ${f.value}`).join("\n");
     case "actions":
       return null;
+    case "table":
+      return tableElementToAscii(child.headers, child.rows);
     case "section":
-      return child.children.map((c) => childToFallbackText(c)).filter(Boolean).join("\n");
+      return child.children.map((c) => cardChildToFallbackText(c)).filter(Boolean).join("\n");
     default:
       return null;
   }
@@ -459,6 +771,9 @@ function isButtonProps(props) {
 function isLinkButtonProps(props) {
   return "url" in props && typeof props.url === "string" && !("id" in props);
 }
+function isCardLinkProps(props) {
+  return "url" in props && typeof props.url === "string" && !("id" in props) && !("alt" in props) && !("style" in props);
+}
 function isImageProps(props) {
   return "url" in props && typeof props.url === "string";
 }
@@ -522,6 +837,16 @@ function resolveJSXElement(element) {
       style: props.style
     });
   }
+  if (type === CardLink) {
+    if (!isCardLinkProps(props)) {
+      throw new Error("CardLink requires a 'url' prop");
+    }
+    const label = processedChildren.length > 0 ? processedChildren.map(String).join("") : props.label ?? "";
+    return CardLink({
+      url: props.url,
+      label
+    });
+  }
   if (type === Image) {
     if (!isImageProps(props)) {
       throw new Error("Image requires a 'url' prop");
@@ -677,6 +1002,40 @@ function isJSX(value) {
 }
 
 export {
+  isTextNode,
+  isParagraphNode,
+  isStrongNode,
+  isEmphasisNode,
+  isDeleteNode,
+  isInlineCodeNode,
+  isCodeNode,
+  isLinkNode,
+  isBlockquoteNode,
+  isListNode,
+  isListItemNode,
+  isTableNode,
+  isTableRowNode,
+  isTableCellNode,
+  tableToAscii,
+  tableElementToAscii,
+  getNodeChildren,
+  getNodeValue,
+  parseMarkdown,
+  stringifyMarkdown,
+  toPlainText,
+  markdownToPlainText,
+  walkAst,
+  text,
+  strong,
+  emphasis,
+  strikethrough,
+  inlineCode,
+  codeBlock,
+  link,
+  blockquote,
+  paragraph,
+  root,
+  BaseFormatConverter,
   isCardElement,
   Card,
   CardText,
@@ -688,8 +1047,11 @@ export {
   LinkButton,
   Field,
   Fields,
+  Table,
+  CardLink,
   fromReactElement,
   cardToFallbackText,
+  cardChildToFallbackText,
   isModalElement,
   Modal,
   TextInput,
@@ -697,6 +1059,7 @@ export {
   SelectOption,
   RadioSelect,
   fromReactModalElement,
+  isCardLinkProps,
   jsx,
   jsxs,
   jsxDEV,
@@ -705,4 +1068,4 @@ export {
   toModalElement,
   isJSX
 };
-//# sourceMappingURL=chunk-THM4ACIE.js.map
+//# sourceMappingURL=chunk-7S5DLTN2.js.map