@ganju/utils 0.0.9 → 0.0.11

package/dist/channelDebounce.d.ts

@@ -2,7 +2,17 @@ export interface BufferedChannelMessage {
     text: string;
     externalMessageId: string | null;
     receivedAt: number;
+    immediate?: boolean;
+    command?: BufferedChannelCommand | null;
+    reply?: Record<string, unknown> | null;
 }
+export interface BufferedChannelCommand {
+    promptId: string;
+    artifactPromptId: string | null;
+    promptTitle: string;
+    args: Record<string, string>;
+}
+export declare const batchCommand: (messages: BufferedChannelMessage[]) => BufferedChannelCommand | null;
 export interface ChannelBufferEnvelope {
     channelId: string;
     platform: string;
@@ -17,6 +27,7 @@ export interface ChannelBufferEnvelope {
 export interface ChannelBufferFlush {
     envelope: ChannelBufferEnvelope;
     messages: BufferedChannelMessage[];
+    batchId: string;
 }
 export declare const resolveDebounceMs: (config: unknown) => number;
 export declare const channelBufferKey: (channelId: string, externalConversationId: string, externalParticipantId: string) => string;

package/dist/channelDebounce.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"channelDebounce.d.ts","sourceRoot":"","sources":["../src/channelDebounce.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;CACpB;AAOD,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,sBAAsB,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACpD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAGD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,qBAAqB,CAAC;IAChC,QAAQ,EAAE,sBAAsB,EAAE,CAAC;CACpC;AAOD,eAAO,MAAM,iBAAiB,GAAI,QAAQ,OAAO,KAAG,MAYnD,CAAC;AAKF,eAAO,MAAM,gBAAgB,GAC3B,WAAW,MAAM,EACjB,wBAAwB,MAAM,EAC9B,uBAAuB,MAAM,KAC5B,MAA2E,CAAC;AAI/E,eAAO,MAAM,oBAAoB,GAC/B,UAAU,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,KAChC,MAIuC,CAAC"}
+{"version":3,"file":"channelDebounce.d.ts","sourceRoot":"","sources":["../src/channelDebounce.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;IAKnB,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB,OAAO,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAAC;IAKxC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CACxC;AAID,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B;AAID,eAAO,MAAM,YAAY,GACvB,UAAU,sBAAsB,EAAE,KACjC,sBAAsB,GAAG,IAM3B,CAAC;AAOF,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,sBAAsB,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACpD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAGD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,qBAAqB,CAAC;IAChC,QAAQ,EAAE,sBAAsB,EAAE,CAAC;IAGnC,OAAO,EAAE,MAAM,CAAC;CACjB;AAOD,eAAO,MAAM,iBAAiB,GAAI,QAAQ,OAAO,KAAG,MAYnD,CAAC;AAKF,eAAO,MAAM,gBAAgB,GAC3B,WAAW,MAAM,EACjB,wBAAwB,MAAM,EAC9B,uBAAuB,MAAM,KAC5B,MAA2E,CAAC;AAI/E,eAAO,MAAM,oBAAoB,GAC/B,UAAU,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,KAChC,MAIuC,CAAC"}

package/dist/channelDebounce.js

@@ -1,7 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.joinBufferedMessages = exports.channelBufferKey = exports.resolveDebounceMs = void 0;
+exports.joinBufferedMessages = exports.channelBufferKey = exports.resolveDebounceMs = exports.batchCommand = void 0;
 const constants_1 = require("./constants");
+// The prompt a batch runs: the newest command in it, since that is the one the
+// participant asked for last. Null for a batch of plain text.
+const batchCommand = (messages) => {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const command = messages[i].command;
+        if (command)
+            return command;
+    }
+    return null;
+};
+exports.batchCommand = batchCommand;
 // Read the channel's debounce window off its `config`, clamped to the supported
 // range. An unset value takes the default; an explicit 0 disables buffering, so
 // the channel answers every message as it arrives. Anything malformed (a string,

package/dist/chunking.d.ts

@@ -6,6 +6,17 @@ export declare const chunkText: (text: string, options?: {
     targetChars?: number;
     overlapChars?: number;
 }) => string[];
+export type HeadingSyntax = 'markdown' | 'html';
+/**
+ * Which heading syntax a document is written in, or null when it has none we
+ * can trust. Plain text is left out on purpose: a line that happens to start
+ * with "# " there is as likely a comment or a list as a title.
+ */
+export declare const headingSyntaxFor: (input: {
+    mimeType?: string | null;
+    fileName?: string | null;
+    isWebPage?: boolean;
+}) => HeadingSyntax | null;
 export declare const buildHeader: (input: {
     title?: string | null;
     description?: string | null;
@@ -13,9 +24,10 @@ export declare const buildHeader: (input: {
     mimeType?: string | null;
     fileName?: string | null;
 }) => string;
-export interface ChunkMetadata extends ExtractedDocumentMetadata {
-    chunkIndexInPage: number;
-    chunksInPage: number;
+export interface ChunkMetadata extends Partial<ExtractedDocumentMetadata> {
+    chunkIndexInPage?: number;
+    chunksInPage?: number;
+    headingPath?: string[];
 }
 export interface PreparedChunk {
     content: string;
@@ -24,5 +36,7 @@ export interface PreparedChunk {
 export declare const prepareChunks: (header: string, documents: ExtractedDocument[] | null, fallbackContent: string | null, options?: {
     targetChars?: number;
     overlapChars?: number;
+    mimeType?: string | null;
+    fileName?: string | null;
 }) => PreparedChunk[];
 //# sourceMappingURL=chunking.d.ts.map

package/dist/chunking.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunking.d.ts","sourceRoot":"","sources":["../src/chunking.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,OAAO,KAAK,EACV,iBAAiB,EACjB,yBAAyB,EAC1B,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,SAAS,CAAC,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AASpE,eAAO,MAAM,cAAc,GACzB,MAAM,MAAM,EACZ,QAAQ,MAAM,EACd,aAAY,SAAS,SAAS,EAA+B,KAC5D,MAAM,EA8BR,CAAC;AAEF,eAAO,MAAM,SAAS,GACpB,MAAM,MAAM,EACZ,UAAU;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,KACxD,MAAM,EAeR,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,OAAO;IACjC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,KAAG,MASW,CAAC;AAEhB,MAAM,WAAW,aAAc,SAAQ,yBAAyB;IAC9D,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,aAAa,GAAG,IAAI,CAAC;CAChC;AAED,eAAO,MAAM,aAAa,GACxB,QAAQ,MAAM,EACd,WAAW,iBAAiB,EAAE,GAAG,IAAI,EACrC,iBAAiB,MAAM,GAAG,IAAI,EAC9B,UAAU;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,KACxD,aAAa,EAgCf,CAAC"}
+{"version":3,"file":"chunking.d.ts","sourceRoot":"","sources":["../src/chunking.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC,OAAO,KAAK,EACV,iBAAiB,EACjB,yBAAyB,EAC1B,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,SAAS,CAAC,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AASpE,eAAO,MAAM,cAAc,GACzB,MAAM,MAAM,EACZ,QAAQ,MAAM,EACd,aAAY,SAAS,SAAS,EAA+B,KAC5D,MAAM,EA8BR,CAAC;AA4BF,eAAO,MAAM,SAAS,GACpB,MAAM,MAAM,EACZ,UAAU;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,KACxD,MAAM,EAAoD,CAAC;AAE9D,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,MAAM,CAAC;AAehD;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO;IACtC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,KAAG,aAAa,GAAG,IAUnB,CAAC;AAuEF,eAAO,MAAM,WAAW,GAAI,OAAO;IACjC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,KAAG,MASW,CAAC;AAIhB,MAAM,WAAW,aAAc,SAAQ,OAAO,CAAC,yBAAyB,CAAC;IACvE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IAGtB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,aAAa,GAAG,IAAI,CAAC;CAChC;AAID,eAAO,MAAM,aAAa,GACxB,QAAQ,MAAM,EACd,WAAW,iBAAiB,EAAE,GAAG,IAAI,EACrC,iBAAiB,MAAM,GAAG,IAAI,EAC9B,UAAU;IACR,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IAGtB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,KACA,aAAa,EA4Cf,CAAC"}

package/dist/chunking.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepareChunks = exports.buildHeader = exports.chunkText = exports.splitRecursive = void 0;
+exports.prepareChunks = exports.buildHeader = exports.headingSyntaxFor = exports.chunkText = exports.splitRecursive = void 0;
 const constants_1 = require("./constants");
+const sanitize_1 = require("./sanitize");
 const trySplit = (text, sep) => {
     if (typeof sep === 'string') {
         return text.includes(sep) ? text.split(sep) : null;
@@ -40,23 +41,115 @@ const splitRecursive = (text, target, separators = constants_1.constants.CHUNK_S
     return chunks;
 };
 exports.splitRecursive = splitRecursive;
-const chunkText = (text, options) => {
+// Each piece keeps its `raw` text — the slice of the input it covers, without
+// the overlap borrowed from the piece before — so a caller can walk the input
+// in order without reading any of it twice.
+const chunkPieces = (text, options) => {
     const target = options?.targetChars ?? constants_1.constants.CHUNK_TARGET_CHARS;
     const overlap = options?.overlapChars ?? constants_1.constants.CHUNK_OVERLAP_CHARS;
     const trimmed = text.trim();
     if (!trimmed)
         return [];
     if (trimmed.length <= target)
-        return [trimmed];
+        return [{ raw: trimmed, content: trimmed }];
     const rawChunks = (0, exports.splitRecursive)(trimmed, target);
-    const withOverlap = [];
+    const pieces = [];
     for (let i = 0; i < rawChunks.length; i++) {
         const prev = i > 0 ? rawChunks[i - 1].slice(-overlap) : '';
-        withOverlap.push((prev ? prev + '\n' : '') + rawChunks[i]);
+        pieces.push({
+            raw: rawChunks[i],
+            content: (prev ? prev + '\n' : '') + rawChunks[i]
+        });
     }
-    return withOverlap.filter(c => c.trim().length > 0);
+    return pieces.filter(p => p.content.trim().length > 0);
 };
+const chunkText = (text, options) => chunkPieces(text, options).map(p => p.content);
 exports.chunkText = chunkText;
+const MARKDOWN_HEADING = /^ {0,3}(#{1,6})[ \t]+(.+?)(?:[ \t]+#+)?[ \t]*$/;
+const MARKDOWN_FENCE = /^ {0,3}(```|~~~)/;
+const HTML_HEADING = /<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1\s*>/gi;
+const MAX_HEADING_CHARS = 120;
+const MARKDOWN_FILE_NAME = /\.(md|markdown|mdx)$/i;
+/**
+ * Which heading syntax a document is written in, or null when it has none we
+ * can trust. Plain text is left out on purpose: a line that happens to start
+ * with "# " there is as likely a comment or a list as a title.
+ */
+const headingSyntaxFor = (input) => {
+    // Crawled pages are flattened to text with their headings written back as
+    // Markdown lines, whatever the page's own content type was.
+    if (input.isWebPage)
+        return 'markdown';
+    if (input.mimeType === constants_1.constants.MIMETYPE_TEXT_MARKDOWN)
+        return 'markdown';
+    if (input.mimeType === constants_1.constants.MIMETYPE_TEXT_HTML)
+        return 'html';
+    if (input.fileName && MARKDOWN_FILE_NAME.test(input.fileName)) {
+        return 'markdown';
+    }
+    return null;
+};
+exports.headingSyntaxFor = headingSyntaxFor;
+const cleanHeading = (text) => text.replace(/\s+/g, ' ').trim().slice(0, MAX_HEADING_CHARS);
+const scanMarkdownHeadings = (text, state) => {
+    const events = [];
+    let offset = 0;
+    for (const line of text.split('\n')) {
+        // A `#` inside a fenced block is a shell comment or a preprocessor line,
+        // not a title — and a fence can open in one chunk and close in the next.
+        if (MARKDOWN_FENCE.test(line)) {
+            state.inFence = !state.inFence;
+        }
+        else if (!state.inFence) {
+            const match = MARKDOWN_HEADING.exec(line);
+            const heading = match ? cleanHeading(match[2]) : '';
+            if (match && heading) {
+                events.push({ offset, level: match[1].length, text: heading });
+            }
+        }
+        offset += line.length + 1;
+    }
+    return events;
+};
+const scanHtmlHeadings = (text) => [...text.matchAll(HTML_HEADING)]
+    .map(match => ({
+    offset: match.index ?? 0,
+    level: Number(match[1]),
+    text: cleanHeading((0, sanitize_1.decodeEntities)(match[2].replace(/<[^>]*>/g, ' ')))
+}))
+    .filter(event => event.text);
+/**
+ * Follows the heading hierarchy across a document's chunks, fed in order.
+ * Returns, for each chunk, the path of headings it sits under — the section a
+ * reader would be pointed to. A chunk that opens with a heading belongs to that
+ * heading; one that starts mid-section belongs to the section it continues,
+ * even when a later heading begins inside it.
+ */
+const createHeadingTracker = (syntax) => {
+    let stack = [];
+    const fence = { inFence: false };
+    const apply = (event) => {
+        stack = stack.filter(h => h.level < event.level);
+        stack.push({ level: event.level, text: event.text });
+    };
+    return (raw) => {
+        const events = syntax === 'markdown'
+            ? scanMarkdownHeadings(raw, fence)
+            : scanHtmlHeadings(raw);
+        const [first, ...rest] = events;
+        // Before a document's first heading there is no section to continue — only
+        // the metadata header, or the markup around an HTML body — so a chunk that
+        // holds the first heading belongs to it wherever in the chunk it falls.
+        const opensWithHeading = first !== undefined &&
+            (stack.length === 0 || raw.slice(0, first.offset).trim() === '');
+        if (opensWithHeading)
+            apply(first);
+        const path = stack.map(h => h.text);
+        for (const event of opensWithHeading ? rest : events)
+            apply(event);
+        return path;
+    };
+};
 const buildHeader = (input) => [
     input.title ? `Title: ${input.title}` : null,
     input.description ? `Description: ${input.description}` : null,
@@ -67,37 +160,50 @@ const buildHeader = (input) => [
     .filter(Boolean)
     .join('\n');
 exports.buildHeader = buildHeader;
+const CONTROL_CHARS = /[\x00-\x08\x0B\x0C\x0E-\x1F]/g;
 const prepareChunks = (header, documents, fallbackContent, options) => {
     if (documents && documents.length > 0) {
         const out = [];
         documents.forEach((doc, docIndex) => {
-            const body = (doc.pageContent || '')
-                .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '')
-                .trim();
+            const body = (doc.pageContent || '').replace(CONTROL_CHARS, '').trim();
             if (!body)
                 return;
             const text = docIndex === 0 && header ? `${header}\n\n${body}` : body;
-            const pieces = (0, exports.chunkText)(text, options);
+            const syntax = (0, exports.headingSyntaxFor)({
+                mimeType: doc.metadata?.source?.mimeType ?? options?.mimeType,
+                fileName: doc.metadata?.source?.fileName ?? options?.fileName,
+                isWebPage: !!doc.metadata?.web
+            });
+            const headingPathOf = syntax ? createHeadingTracker(syntax) : null;
+            const pieces = chunkPieces(text, options);
             pieces.forEach((piece, pieceIndex) => {
+                const headingPath = headingPathOf?.(piece.raw) ?? [];
                 out.push({
-                    content: piece,
+                    content: piece.content,
                     metadata: {
                         ...doc.metadata,
                         chunkIndexInPage: pieceIndex,
-                        chunksInPage: pieces.length
+                        chunksInPage: pieces.length,
+                        ...(headingPath.length > 0 ? { headingPath } : {})
                     }
                 });
             });
         });
         return out;
     }
-    const body = (fallbackContent || '')
-        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '')
-        .trim();
+    const body = (fallbackContent || '').replace(CONTROL_CHARS, '').trim();
     const fullText = [header, body].filter(Boolean).join('\n\n');
-    return (0, exports.chunkText)(fullText, options).map(content => ({
-        content,
-        metadata: null
-    }));
+    const syntax = (0, exports.headingSyntaxFor)({
+        mimeType: options?.mimeType,
+        fileName: options?.fileName
+    });
+    const headingPathOf = syntax ? createHeadingTracker(syntax) : null;
+    return chunkPieces(fullText, options).map(piece => {
+        const headingPath = headingPathOf?.(piece.raw) ?? [];
+        return {
+            content: piece.content,
+            metadata: headingPath.length > 0 ? { headingPath } : null
+        };
+    });
 };
 exports.prepareChunks = prepareChunks;

package/dist/constants.d.ts

@@ -6,6 +6,8 @@ declare const ONE_DRIVE_TAB_MY_FILES: "my-files";
 declare const ONE_DRIVE_TAB_SHARED_WITH_ME: "shared-with-me";
 declare const ONE_DRIVE_TAB_RECENT: "recent";
 declare const ONE_DRIVE_TAB_DRIVES: "drives";
+declare const RESOURCE_SYNC_INTERVAL_DAILY: "daily";
+declare const RESOURCE_SYNC_INTERVAL_WEEKLY: "weekly";
 declare const LLM_PROVIDER_ANTHROPIC: "anthropic";
 declare const LLM_PROVIDER_OPENAI: "openai";
 declare const LLM_PROVIDER_GOOGLE: "google";
@@ -59,6 +61,7 @@ interface PlanLimits {
     toolCallHardCap: number | null;
     includedMessages: number;
     includedEmbeddedBytes: number;
+    autoSyncIntervals: ReadonlyArray<typeof RESOURCE_SYNC_INTERVAL_DAILY | typeof RESOURCE_SYNC_INTERVAL_WEEKLY>;
 }
 export type { PlanLimits };
 export declare const constants: {
@@ -104,6 +107,7 @@ export declare const constants: {
     PLAN_FEATURE_EMBEDDED_STORAGE: "embeddedStorage";
     PLAN_FEATURE_MESSAGE: "message";
     PLAN_FEATURE_TOOL_CALL: "toolCall";
+    PLAN_FEATURE_RESOURCE_SYNC: "resourceSync";
     PLAN_LIMIT_ERROR_CODE: string;
     BILLING_METER_MESSAGES: string;
     BILLING_METER_SHARED_MESSAGES: string;
@@ -309,6 +313,18 @@ export declare const constants: {
     RESOURCE_SOURCE_TYPE_ONE_DRIVE_FOLDER: "ONE_DRIVE_FOLDER";
     RESOURCE_SOURCE_TYPE_CUSTOM_CODE: "CUSTOM_CODE";
     RESOURCE_SOURCE_TYPES: ("FILE" | "WEBSITE" | "GOOGLE_DRIVE_FOLDER" | "ONE_DRIVE_FOLDER" | "CUSTOM_CODE")[];
+    RESOURCE_SYNC_INTERVAL_OFF: "off";
+    RESOURCE_SYNC_INTERVAL_DAILY: "daily";
+    RESOURCE_SYNC_INTERVAL_WEEKLY: "weekly";
+    RESOURCE_SYNC_INTERVALS: readonly ["off", "daily", "weekly"];
+    RESOURCE_SYNC_INTERVAL_DEFAULT: "weekly";
+    RESOURCE_SYNC_INTERVAL_MS: {
+        readonly daily: number;
+        readonly weekly: number;
+    };
+    RESOURCE_SYNC_BATCH_SIZE: number;
+    RESOURCE_SYNC_MANUAL_COOLDOWN_MS: number;
+    RESOURCE_SYNC_STALE_MS: number;
     CRAWL_RENDERER_CHEERIO: "cheerio";
     CRAWL_RENDERER_PLAYWRIGHT: "playwright";
     CRAWL_RENDERERS: ("cheerio" | "playwright")[];
@@ -371,6 +387,11 @@ export declare const constants: {
     SHARED_KEY_HISTORY_LIMIT: number;
     SHARED_KEY_MAX_TOOL_LOOPS: number;
     CHANNEL_MAX_TOOLS: number;
+    TOOL_CONFIRMATION_TTL_MS: number;
+    TOOL_CONFIRMATION_REQUIRED_RESULT: string;
+    TOOL_CONFIRMATION_FALLBACK_QUESTION: string;
+    TOOL_CONFIRMATION_ASK_INSTRUCTION: string;
+    TOOL_CONFIRMATION_SYSTEM_NOTE: string;
     CHANNEL_DEBOUNCE_DEFAULT_MS: number;
     CHANNEL_DEBOUNCE_MIN_MS: number;
     CHANNEL_DEBOUNCE_MAX_MS: number;
@@ -403,8 +424,10 @@ export declare const constants: {
     DISCORD_TIMESTAMP_HEADER: string;
     DISCORD_INTERACTION_TYPE_PING: number;
     DISCORD_INTERACTION_TYPE_APPLICATION_COMMAND: number;
+    DISCORD_INTERACTION_TYPE_MESSAGE_COMPONENT: number;
     DISCORD_INTERACTION_RESPONSE_PONG: number;
     DISCORD_INTERACTION_RESPONSE_DEFERRED: number;
+    DISCORD_INTERACTION_RESPONSE_UPDATE_MESSAGE: number;
     DISCORD_CHANNEL_TYPE_DM: number;
     DISCORD_CHANNEL_TYPE_GROUP_DM: number;
     DISCORD_GATEWAY_OP_DISPATCH: number;
@@ -419,6 +442,7 @@ export declare const constants: {
     WHATSAPP_API_BASE: string;
     WHATSAPP_API_VERSION: string;
     WHATSAPP_MESSAGE_LIMIT: number;
+    WHATSAPP_INTERACTIVE_BODY_LIMIT: number;
     WHATSAPP_SIGNATURE_HEADER: string;
     WHATSAPP_SIGNATURE_PREFIX: string;
     WHATSAPP_HUB_MODE_PARAM: string;
@@ -434,6 +458,12 @@ export declare const constants: {
     CHUNK_TARGET_CHARS: number;
     CHUNK_OVERLAP_CHARS: number;
     EMBED_BATCH_SIZE: number;
+    RESOURCE_SEARCH_CANDIDATES: number;
+    RESOURCE_SEARCH_RRF_K: number;
+    RESOURCE_SEARCH_COMMON_TERM_DIVISOR: number;
+    RESOURCE_SEARCH_COMMON_TERM_MIN: number;
+    RESOURCE_SEARCH_RERANK_CANDIDATES: number;
+    RESOURCE_SEARCH_RERANK_MODEL: string;
     RESOURCE_HANDLER_SLEEP_AFTER: string;
     DOCS_URL: string;
     BASE64_DATA_URI_RE: RegExp;

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"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"}

package/dist/constants.js

@@ -208,6 +208,42 @@ const RESOURCE_SOURCE_TYPES = [
     RESOURCE_SOURCE_TYPE_ONE_DRIVE_FOLDER,
     RESOURCE_SOURCE_TYPE_CUSTOM_CODE
 ];
+// How often a source that lives somewhere else — a crawled website, a Drive or
+// OneDrive folder, a file imported from either — is refreshed from it. Every
+// source is stored with an interval, weekly unless its owner changes it; the
+// hourly sync job only acts on it for a plan that includes automatic sync, so a
+// Free org's sources start syncing the moment it upgrades.
+const RESOURCE_SYNC_INTERVAL_OFF = 'off';
+const RESOURCE_SYNC_INTERVAL_DAILY = 'daily';
+const RESOURCE_SYNC_INTERVAL_WEEKLY = 'weekly';
+const RESOURCE_SYNC_INTERVALS = [
+    RESOURCE_SYNC_INTERVAL_OFF,
+    RESOURCE_SYNC_INTERVAL_DAILY,
+    RESOURCE_SYNC_INTERVAL_WEEKLY
+];
+const RESOURCE_SYNC_INTERVAL_DEFAULT = RESOURCE_SYNC_INTERVAL_WEEKLY;
+const RESOURCE_SYNC_INTERVAL_MS = {
+    [RESOURCE_SYNC_INTERVAL_DAILY]: 24 * 60 * 60 * 1000,
+    [RESOURCE_SYNC_INTERVAL_WEEKLY]: 7 * 24 * 60 * 60 * 1000
+};
+// Sources started per hourly run. A sync is cheap to start and expensive to
+// run — a website re-crawls every page — so the job works through a backlog
+// over several hours rather than launching all of it at once.
+const RESOURCE_SYNC_BATCH_SIZE = 50;
+// How soon a source can be synced by hand again. Manual sync is open to every
+// plan, and a website sync re-crawls every page, so it can't be a button to
+// press in a loop.
+const RESOURCE_SYNC_MANUAL_COOLDOWN_MS = 5 * 60 * 1000;
+// How long a sync may stay PENDING before it counts as stuck rather than
+// running. A lost queue message or a job that exhausted its retries never
+// completes its root, and a root that stays PENDING would otherwise be skipped
+// by the hourly job and refused by "Sync now" forever. Twelve hours outlasts
+// any realistic wait: the crawl-page queue runs 5 at a time for every org, and
+// one hourly run can queue 50 sites — thousands of pages, hours of backlog. A
+// shorter window restarts syncs that are merely queued, re-fetching every page
+// into the same backlog; a longer one leaves a stuck daily source missing more
+// than one sync.
+const RESOURCE_SYNC_STALE_MS = 12 * 60 * 60 * 1000;
 const CRAWL_RENDERER_CHEERIO = 'cheerio';
 const CRAWL_RENDERER_PLAYWRIGHT = 'playwright';
 const CRAWL_RENDERERS = [CRAWL_RENDERER_CHEERIO, CRAWL_RENDERER_PLAYWRIGHT];
@@ -594,6 +630,44 @@ const CHANNEL_DEBOUNCE_JOIN = '\n';
 // and how many times it tries before dropping the batch rather than looping.
 const CHANNEL_DEBOUNCE_RETRY_MS = 5000;
 const CHANNEL_DEBOUNCE_MAX_ATTEMPTS = 3;
+// Confirming sensitive actions, for organizations that turn it on. A channel
+// bot that wants to run a tool annotated `destructiveHint` asks first, and the
+// call runs only if the participant's next message is a plain yes.
+//
+// How long the question stays open. An answer after that is read as a new
+// message, never as consent to something asked long ago.
+const TOOL_CONFIRMATION_TTL_MS = 30 * 60 * 1000;
+// The tool result the model gets instead of running the call. It is what makes
+// the model write the question — in the participant's language, naming what
+// the call would do — rather than claiming the action happened.
+// The call's exact arguments are listed under the model's question by the
+// runner, so the model only has to say what it is about to do.
+const TOOL_CONFIRMATION_REQUIRED_RESULT = 'Not run yet: this action needs the user to confirm it first. In one or ' +
+    'two sentences, tell them what it will do (who it goes to, what will be ' +
+    'changed or deleted) and ask them to answer yes to go ahead or no to ' +
+    'cancel — in their own language, never quoting English words at someone ' +
+    'writing in another one. The exact details are listed for them under your ' +
+    'message. It runs only if their next message is yes. Do not say it was done.';
+// Told to the model on every turn of an organization that confirms: the
+// asking is done for it, so it calls the tool when asked instead of asking
+// first itself — and calls every action a request needs in one step, since
+// the turn stops at the first held call and each later one would be a
+// question of its own.
+const TOOL_CONFIRMATION_SYSTEM_NOTE = 'Actions that send, change or delete something are confirmed with the ' +
+    'user by the system before they run. Ask for any detail you are missing, ' +
+    'but once you have what the action needs, call the tool — do not ask the ' +
+    'user to confirm it yourself; the system asks them and runs it on their ' +
+    'yes. When a request needs several such actions (say, delete an event ' +
+    'and create its replacement), call them all in the same step, so the ' +
+    'user confirms them together once.';
+// The system-prompt addition for the step that writes the question, with the
+// held actions' names in place of {{actions}}.
+const TOOL_CONFIRMATION_ASK_INSTRUCTION = 'IMPORTANT: these actions have NOT been done: {{actions}}. They are ' +
+    'waiting for the user to confirm them. Your reply must ask the user to ' +
+    'confirm, and must not say or suggest that they were done, nor describe ' +
+    'or make up any result from them.';
+// The question when the model wrote none, above the runner's own summary.
+const TOOL_CONFIRMATION_FALLBACK_QUESTION = 'Before I do this, please confirm. Reply yes to go ahead, or no to cancel.';
 const TELEGRAM_SECRET_HEADER = 'x-telegram-bot-api-secret-token';
 const TELEGRAM_API_BASE = 'https://api.telegram.org';
 const TELEGRAM_MESSAGE_LIMIT = 3500;
@@ -650,8 +724,12 @@ const DISCORD_TIMESTAMP_HEADER = 'x-signature-timestamp';
 // Interaction request types and response types (Discord API).
 const DISCORD_INTERACTION_TYPE_PING = 1;
 const DISCORD_INTERACTION_TYPE_APPLICATION_COMMAND = 2;
+// A tap on a message button — the Yes/No under a confirmation question.
+const DISCORD_INTERACTION_TYPE_MESSAGE_COMPONENT = 3;
 const DISCORD_INTERACTION_RESPONSE_PONG = 1;
 const DISCORD_INTERACTION_RESPONSE_DEFERRED = 5;
+// Edits the message the tapped button is on, in the same response.
+const DISCORD_INTERACTION_RESPONSE_UPDATE_MESSAGE = 7;
 // Channel types we map to conversation scopes: DM (1) / group DM (3) = private;
 // everything else (guild text channels, threads) = channel.
 const DISCORD_CHANNEL_TYPE_DM = 1;
@@ -679,6 +757,8 @@ const WHATSAPP_API_BASE = 'https://graph.facebook.com';
 const WHATSAPP_API_VERSION = 'v25.0';
 // A WhatsApp text message body caps at 4096 chars; we chunk a bit under that.
 const WHATSAPP_MESSAGE_LIMIT = 4000;
+// The body of an interactive (reply-button) message holds at most this much.
+const WHATSAPP_INTERACTIVE_BODY_LIMIT = 1024;
 const WHATSAPP_SIGNATURE_HEADER = 'x-hub-signature-256';
 const WHATSAPP_SIGNATURE_PREFIX = 'sha256=';
 // GET-handshake query params + the expected hub.mode value.
@@ -707,6 +787,24 @@ const EMBEDDING_DIMENSIONS = 1536;
 const CHUNK_TARGET_CHARS = 2000;
 const CHUNK_OVERLAP_CHARS = 200;
 const EMBED_BATCH_SIZE = 96;
+// Hybrid resource search. Each ranker contributes its top candidates, and the
+// two lists are merged with reciprocal rank fusion: score = sum of 1/(k + rank).
+// Fusion reads ranks, never raw scores, so a cosine distance and a ts_rank never
+// have to be put on one scale. k = 60 is the constant from the original RRF
+// paper; it keeps one list's #1 from outweighing a chunk both lists agree on.
+const RESOURCE_SEARCH_CANDIDATES = 50;
+const RESOURCE_SEARCH_RRF_K = 60;
+// A query word found in more than 1 of every 10 chunks of the artifact is
+// dropped from the lexical query — never below 5 chunks, so a small artifact
+// keeps its words.
+const RESOURCE_SEARCH_COMMON_TERM_DIVISOR = 10;
+const RESOURCE_SEARCH_COMMON_TERM_MIN = 5;
+// Second stage, on wherever the Worker has an AI binding: the top fused
+// candidates are re-scored by a cross-encoder, which reads query and chunk
+// together instead of comparing two independently computed vectors. One model
+// call per search; a failure falls back to the fused order.
+const RESOURCE_SEARCH_RERANK_CANDIDATES = 30;
+const RESOURCE_SEARCH_RERANK_MODEL = '@cf/baai/bge-reranker-base';
 const RESOURCE_HANDLER_SLEEP_AFTER = '10m';
 const DOCS_URL = 'https://docs.ganju.ai';
 const BASE64_DATA_URI_RE = /data:image\/[a-zA-Z0-9+\-.]+;base64,[A-Za-z0-9+/=\s]+/g;
@@ -1011,8 +1109,7 @@ const MCP_PROXY_TOOL_NAME_MAX = 64;
 //
 // The row's config holds only `activeVersionId` plus the egress/limit settings;
 // names and schemas live on the version. That's what keeps MCP boot off the
-// dispatcher — a slow or broken script must never break tools/list. See
-// docs/CUSTOM_TOOLS.md ("Boot contract").
+// dispatcher — a slow or broken script must never break tools/list.
 const TOOL_DEFINITION_KEY_CUSTOM_CODE = 'custom-code';
 // A version is uploaded as `draft`, becomes `published` when it is made active,
 // and is `archived` when a later version replaces it. Exactly one version per
@@ -1692,7 +1789,8 @@ const PLAN_LIMITS = {
         includedToolCalls: 0,
         toolCallHardCap: 10_000,
         includedMessages: 100,
-        includedEmbeddedBytes: 5 * MB
+        includedEmbeddedBytes: 5 * MB,
+        autoSyncIntervals: []
     },
     PRO: {
         maxProjects: null,
@@ -1715,7 +1813,11 @@ const PLAN_LIMITS = {
         includedToolCalls: PRICING_INCLUDED_TOOL_CALLS,
         toolCallHardCap: PRICING_TOOL_CALL_HARD_CAP,
         includedMessages: PRICING_INCLUDED_MESSAGES,
-        includedEmbeddedBytes: PRICING_INCLUDED_EMBEDDED_GB * GB
+        includedEmbeddedBytes: PRICING_INCLUDED_EMBEDDED_GB * GB,
+        autoSyncIntervals: [
+            RESOURCE_SYNC_INTERVAL_DAILY,
+            RESOURCE_SYNC_INTERVAL_WEEKLY
+        ]
     },
     ENTERPRISE: {
         maxProjects: null,
@@ -1738,7 +1840,11 @@ const PLAN_LIMITS = {
         // contract; don't make one plan's abuse limit another plan's product limit.
         toolCallHardCap: null,
         includedMessages: PRICING_INCLUDED_MESSAGES,
-        includedEmbeddedBytes: PRICING_INCLUDED_EMBEDDED_GB * GB
+        includedEmbeddedBytes: PRICING_INCLUDED_EMBEDDED_GB * GB,
+        autoSyncIntervals: [
+            RESOURCE_SYNC_INTERVAL_DAILY,
+            RESOURCE_SYNC_INTERVAL_WEEKLY
+        ]
     }
 };
 // Quota features — used as the `feature` discriminator on PlanLimitError so the
@@ -1756,6 +1862,7 @@ const PLAN_FEATURE_RAW_STORAGE = 'rawStorage';
 const PLAN_FEATURE_EMBEDDED_STORAGE = 'embeddedStorage';
 const PLAN_FEATURE_MESSAGE = 'message';
 const PLAN_FEATURE_TOOL_CALL = 'toolCall';
+const PLAN_FEATURE_RESOURCE_SYNC = 'resourceSync';
 // Stable code returned on a quota block so clients can branch on it (402).
 const PLAN_LIMIT_ERROR_CODE = 'PLAN_LIMIT_EXCEEDED';
 // Billing meter event names. The metering cron reports per-period OVERAGE
@@ -1923,6 +2030,7 @@ exports.constants = {
     PLAN_FEATURE_EMBEDDED_STORAGE,
     PLAN_FEATURE_MESSAGE,
     PLAN_FEATURE_TOOL_CALL,
+    PLAN_FEATURE_RESOURCE_SYNC,
     PLAN_LIMIT_ERROR_CODE,
     BILLING_METER_MESSAGES,
     BILLING_METER_SHARED_MESSAGES,
@@ -2117,6 +2225,15 @@ exports.constants = {
     RESOURCE_SOURCE_TYPE_ONE_DRIVE_FOLDER,
     RESOURCE_SOURCE_TYPE_CUSTOM_CODE,
     RESOURCE_SOURCE_TYPES,
+    RESOURCE_SYNC_INTERVAL_OFF,
+    RESOURCE_SYNC_INTERVAL_DAILY,
+    RESOURCE_SYNC_INTERVAL_WEEKLY,
+    RESOURCE_SYNC_INTERVALS,
+    RESOURCE_SYNC_INTERVAL_DEFAULT,
+    RESOURCE_SYNC_INTERVAL_MS,
+    RESOURCE_SYNC_BATCH_SIZE,
+    RESOURCE_SYNC_MANUAL_COOLDOWN_MS,
+    RESOURCE_SYNC_STALE_MS,
     CRAWL_RENDERER_CHEERIO,
     CRAWL_RENDERER_PLAYWRIGHT,
     CRAWL_RENDERERS,
@@ -2175,6 +2292,11 @@ exports.constants = {
     SHARED_KEY_HISTORY_LIMIT,
     SHARED_KEY_MAX_TOOL_LOOPS,
     CHANNEL_MAX_TOOLS,
+    TOOL_CONFIRMATION_TTL_MS,
+    TOOL_CONFIRMATION_REQUIRED_RESULT,
+    TOOL_CONFIRMATION_FALLBACK_QUESTION,
+    TOOL_CONFIRMATION_ASK_INSTRUCTION,
+    TOOL_CONFIRMATION_SYSTEM_NOTE,
     CHANNEL_DEBOUNCE_DEFAULT_MS,
     CHANNEL_DEBOUNCE_MIN_MS,
     CHANNEL_DEBOUNCE_MAX_MS,
@@ -2207,8 +2329,10 @@ exports.constants = {
     DISCORD_TIMESTAMP_HEADER,
     DISCORD_INTERACTION_TYPE_PING,
     DISCORD_INTERACTION_TYPE_APPLICATION_COMMAND,
+    DISCORD_INTERACTION_TYPE_MESSAGE_COMPONENT,
     DISCORD_INTERACTION_RESPONSE_PONG,
     DISCORD_INTERACTION_RESPONSE_DEFERRED,
+    DISCORD_INTERACTION_RESPONSE_UPDATE_MESSAGE,
     DISCORD_CHANNEL_TYPE_DM,
     DISCORD_CHANNEL_TYPE_GROUP_DM,
     DISCORD_GATEWAY_OP_DISPATCH,
@@ -2223,6 +2347,7 @@ exports.constants = {
     WHATSAPP_API_BASE,
     WHATSAPP_API_VERSION,
     WHATSAPP_MESSAGE_LIMIT,
+    WHATSAPP_INTERACTIVE_BODY_LIMIT,
     WHATSAPP_SIGNATURE_HEADER,
     WHATSAPP_SIGNATURE_PREFIX,
     WHATSAPP_HUB_MODE_PARAM,
@@ -2238,6 +2363,12 @@ exports.constants = {
     CHUNK_TARGET_CHARS,
     CHUNK_OVERLAP_CHARS,
     EMBED_BATCH_SIZE,
+    RESOURCE_SEARCH_CANDIDATES,
+    RESOURCE_SEARCH_RRF_K,
+    RESOURCE_SEARCH_COMMON_TERM_DIVISOR,
+    RESOURCE_SEARCH_COMMON_TERM_MIN,
+    RESOURCE_SEARCH_RERANK_CANDIDATES,
+    RESOURCE_SEARCH_RERANK_MODEL,
     RESOURCE_HANDLER_SLEEP_AFTER,
     DOCS_URL,
     BASE64_DATA_URI_RE,