@ganju/utils 0.0.8 → 0.0.10

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,17 @@ 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;
     CRAWL_RENDERER_CHEERIO: "cheerio";
     CRAWL_RENDERER_PLAYWRIGHT: "playwright";
     CRAWL_RENDERERS: ("cheerio" | "playwright")[];
@@ -362,6 +377,9 @@ export declare const constants: {
         model: string;
         label: string;
     }[];
+    LLM_CATALOG_CUSTOM_KEY: string;
+    LLM_BASE_URL_REQUIRED_MESSAGE: string;
+    LLM_BASE_URL_INVALID_MESSAGE: string;
     LLM_SYSTEM_DEFAULT: string;
     MAX_TOOL_LOOPS: number;
     CHANNEL_HISTORY_LIMIT: number;
@@ -431,6 +449,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,32 @@ 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;
 const CRAWL_RENDERER_CHEERIO = 'cheerio';
 const CRAWL_RENDERER_PLAYWRIGHT = 'playwright';
 const CRAWL_RENDERERS = [CRAWL_RENDERER_CHEERIO, CRAWL_RENDERER_PLAYWRIGHT];
@@ -496,8 +522,8 @@ const DEFAULT_LLM_SYSTEM_PROMPT = 'You are a helpful assistant. Answer the user
 const LLM_CATALOG = [
     {
         provider: LLM_PROVIDER_GOOGLE,
-        model: 'gemini-3-flash-preview',
-        label: 'Gemini 3 Flash'
+        model: 'gemini-3.8-flash',
+        label: 'Gemini 3.8 Flash'
     },
     {
         provider: LLM_PROVIDER_GOOGLE,
@@ -506,13 +532,13 @@ const LLM_CATALOG = [
     },
     {
         provider: LLM_PROVIDER_OPENAI,
-        model: 'gpt-4o-mini',
-        label: 'GPT-4o mini'
+        model: 'gpt-5.4-mini',
+        label: 'GPT-5.4 mini'
     },
     {
         provider: LLM_PROVIDER_OPENAI,
-        model: 'gpt-4o',
-        label: 'GPT-4o'
+        model: 'gpt-5.5',
+        label: 'GPT-5.5'
     },
     {
         provider: LLM_PROVIDER_ANTHROPIC,
@@ -521,15 +547,30 @@ const LLM_CATALOG = [
     },
     {
         provider: LLM_PROVIDER_ANTHROPIC,
-        model: 'claude-sonnet-4-6',
-        label: 'Claude Sonnet 4.6'
+        model: 'claude-sonnet-5',
+        label: 'Claude Sonnet 5'
     },
     {
         provider: LLM_PROVIDER_ANTHROPIC,
-        model: 'claude-opus-4.7',
-        label: 'Claude Sonnet 4.7'
+        model: 'claude-opus-5',
+        label: 'Claude Opus 5'
     }
 ];
+// The picker's escape hatch. Anything that speaks the OpenAI chat-completions
+// protocol — a gateway, an aggregator, a self-hosted server — is reachable
+// without a catalog row: the customer supplies the model id and the base URL,
+// and the request goes out through the OpenAI adapter. Not a provider value, so
+// it can never reach the database; the dashboard translates it into
+// LLM_PROVIDER_OPENAI_COMPATIBLE on submit.
+const LLM_CATALOG_CUSTOM_KEY = 'custom';
+// Validation messages for an organization LLM's base URL. Constants rather than
+// inline strings because localizeZodIssue keys its translations on the exact
+// English text, so the two files have to name the same value. Both also carry a
+// word matchStatus recognises ("required", "must be"): the update path re-checks
+// the merged row and throws the message as a plain Error, and anything
+// unrecognised there becomes an opaque 500 instead of a 400.
+const LLM_BASE_URL_REQUIRED_MESSAGE = 'A base URL is required for an OpenAI-compatible model';
+const LLM_BASE_URL_INVALID_MESSAGE = 'Base URL must be a public https:// address';
 const LLM_SYSTEM_DEFAULT = 'SYSTEM_DEFAULT';
 const MAX_TOOL_LOOPS = 8;
 // How many recent messages a channel turn replays as context.
@@ -692,6 +733,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;
@@ -996,8 +1055,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
@@ -1677,7 +1735,8 @@ const PLAN_LIMITS = {
         includedToolCalls: 0,
         toolCallHardCap: 10_000,
         includedMessages: 100,
-        includedEmbeddedBytes: 5 * MB
+        includedEmbeddedBytes: 5 * MB,
+        autoSyncIntervals: []
     },
     PRO: {
         maxProjects: null,
@@ -1700,7 +1759,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,
@@ -1723,7 +1786,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
@@ -1741,6 +1808,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
@@ -1783,7 +1851,7 @@ const POLAR_SERVER_PRODUCTION = 'production';
 const CONSENT_DOCUMENT_TERMS = 'terms';
 const CONSENT_DOCUMENT_PRIVACY = 'privacy';
 const CONSENT_DOCUMENTS = [CONSENT_DOCUMENT_TERMS, CONSENT_DOCUMENT_PRIVACY];
-const CONSENT_CURRENT_VERSION = '2026-08-31';
+const CONSENT_CURRENT_VERSION = '2026-09-10';
 const CONSENT_SOURCE_SIGNUP = 'signup';
 const CONSENT_SOURCE_REACCEPT = 'reaccept';
 const CONSENT_SOURCES = [CONSENT_SOURCE_SIGNUP, CONSENT_SOURCE_REACCEPT];
@@ -1908,6 +1976,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,
@@ -2102,6 +2171,14 @@ 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,
     CRAWL_RENDERER_CHEERIO,
     CRAWL_RENDERER_PLAYWRIGHT,
     CRAWL_RENDERERS,
@@ -2151,6 +2228,9 @@ exports.constants = {
     DEFAULT_LLM_MODEL,
     DEFAULT_LLM_SYSTEM_PROMPT,
     LLM_CATALOG,
+    LLM_CATALOG_CUSTOM_KEY,
+    LLM_BASE_URL_REQUIRED_MESSAGE,
+    LLM_BASE_URL_INVALID_MESSAGE,
     LLM_SYSTEM_DEFAULT,
     MAX_TOOL_LOOPS,
     CHANNEL_HISTORY_LIMIT,
@@ -2220,6 +2300,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,