@agent-native/core 0.151.2 → 0.152.0

package/dist/ingestion/office.js

@@ -12,6 +12,24 @@ export async function parseOfficeDocument(input, parser) {
             warnings: [],
         };
     }
+    if (fileType === "xlsx" || fileType === "xls") {
+        const workbook = await parseSpreadsheetDocument(input);
+        return {
+            text: workbook.text,
+            fileType,
+            title: workbook.title,
+            parser: workbook.parser,
+            parts: workbook.parts.map((part) => ({
+                kind: "sheet",
+                index: part.index,
+                title: part.title,
+                text: part.text,
+                metadata: part.metadata,
+            })),
+            metadata: workbook.metadata,
+            warnings: workbook.warnings,
+        };
+    }
     if (fileType === "pptx") {
         const presentation = await parsePptxPresentation(input.data);
         const parts = presentation.slides.map((slide, index) => {
@@ -107,12 +125,15 @@ export function detectOfficeDocumentType(fileName, mimeType) {
         return "md";
     if (mime.includes("csv"))
         return "csv";
+    const spreadsheetType = detectSpreadsheetDocumentType(fileName, mimeType);
+    if (spreadsheetType)
+        return spreadsheetType;
     if (mime.startsWith("text/"))
         return "txt";
     const extension = fileName.toLowerCase().match(/\.([a-z0-9]+)$/)?.[1];
     if (isOfficeDocumentType(extension))
         return extension;
-    throw new Error(`Unsupported upload type ${mimeType ?? extension ?? "unknown"}; supported formats are PPTX, DOCX, PDF, and text.`);
+    throw new Error(`Unsupported upload type ${mimeType ?? extension ?? "unknown"}; supported formats are PPTX, DOCX, PDF, XLS, XLSX, and text.`);
 }
 export function normalizeDocumentText(value) {
     return value
@@ -133,7 +154,8 @@ async function loadOfficeParser() {
 }
 function isOfficeDocumentType(value) {
     return (typeof value === "string" &&
-        ["pptx", "docx", "pdf", "txt", "md", "csv"].includes(value));
+        ["pptx", "docx", "pdf", "txt", "md", "csv", "xlsx", "xls"].includes(value));
 }
 import { parseDocxDocument, sanitizeInertDocumentHtml } from "./docx.js";
 import { parsePptxPresentation, } from "./pptx.js";
+import { detectSpreadsheetDocumentType, parseSpreadsheetDocument, } from "./spreadsheet.js";

package/dist/ingestion/spreadsheet.d.ts

@@ -0,0 +1,41 @@
+export type SpreadsheetDocumentType = "xlsx" | "xls";
+export interface ParseSpreadsheetDocumentInput {
+    data: Uint8Array;
+    fileName: string;
+    mimeType?: string;
+    maxBytes?: number;
+    maxChars?: number;
+    maxColumns?: number;
+    maxRowsPerSheet?: number;
+    maxSheets?: number;
+}
+export interface ParsedSpreadsheetSheet {
+    index: number;
+    title: string;
+    text: string;
+    metadata: {
+        sheetName: string;
+        rowCount: number;
+        columnCount: number;
+        sampledRowCount: number;
+        sampledColumnCount: number;
+        truncated: boolean;
+    };
+}
+export interface ParsedSpreadsheetDocument {
+    text: string;
+    fileType: SpreadsheetDocumentType;
+    title: string;
+    parser: "sheetjs-workbook";
+    parts: ParsedSpreadsheetSheet[];
+    metadata: {
+        sheetNames: string[];
+        sheetCount: number;
+        sampledSheetCount: number;
+        truncated: boolean;
+    };
+    warnings: string[];
+}
+export declare function isSpreadsheetDocument(fileName: string, mimeType?: string): boolean;
+export declare function detectSpreadsheetDocumentType(fileName: string, mimeType?: string): SpreadsheetDocumentType | null;
+export declare function parseSpreadsheetDocument(input: ParseSpreadsheetDocumentInput): Promise<ParsedSpreadsheetDocument>;

package/dist/ingestion/spreadsheet.js

@@ -0,0 +1,172 @@
+const DEFAULT_MAX_BYTES = 20 * 1024 * 1024;
+const DEFAULT_MAX_CHARS = 24_000;
+const DEFAULT_MAX_COLUMNS = 24;
+const DEFAULT_MAX_ROWS_PER_SHEET = 40;
+const DEFAULT_MAX_SHEETS = 12;
+const MAX_CELL_CHARS = 500;
+export function isSpreadsheetDocument(fileName, mimeType) {
+    return detectSpreadsheetDocumentType(fileName, mimeType) !== null;
+}
+export function detectSpreadsheetDocumentType(fileName, mimeType) {
+    const normalizedMime = mimeType?.toLowerCase().split(";")[0].trim() ?? "";
+    if (normalizedMime ===
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" ||
+        normalizedMime === "application/vnd.ms-excel") {
+        return normalizedMime.includes("openxml") ? "xlsx" : "xls";
+    }
+    const extension = fileName.toLowerCase().match(/\.([a-z0-9]+)$/)?.[1];
+    return extension === "xlsx" || extension === "xls" ? extension : null;
+}
+function normalizeCell(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (value instanceof Date)
+        return value.toISOString();
+    return String(value)
+        .replace(/\r\n?/g, " ")
+        .replace(/[\t\n]+/g, " ")
+        .trim()
+        .slice(0, MAX_CELL_CHARS);
+}
+function escapePreviewValue(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+async function loadXlsx() {
+    try {
+        return await import("xlsx");
+    }
+    catch {
+        throw new Error("Parsing Excel workbooks requires the optional xlsx dependency.");
+    }
+}
+function appendBoundedText(current, next, maxChars) {
+    if (maxChars <= 0)
+        return { text: "", truncated: true };
+    const separator = current ? "\n\n" : "";
+    const remaining = maxChars - current.length - separator.length;
+    if (remaining <= 0)
+        return { text: current, truncated: true };
+    if (next.length <= remaining) {
+        return { text: `${current}${separator}${next}`, truncated: false };
+    }
+    const marker = "\n[Spreadsheet preview truncated.]";
+    const markerText = marker.slice(0, remaining);
+    const available = Math.max(0, remaining - markerText.length);
+    return {
+        text: `${current}${separator}${next.slice(0, available)}${markerText}`,
+        truncated: true,
+    };
+}
+export async function parseSpreadsheetDocument(input) {
+    const fileType = detectSpreadsheetDocumentType(input.fileName, input.mimeType);
+    if (!fileType) {
+        throw new Error(`Unsupported spreadsheet type ${input.mimeType ?? input.fileName}. Expected XLS or XLSX.`);
+    }
+    const maxBytes = input.maxBytes ?? DEFAULT_MAX_BYTES;
+    if (input.data.byteLength > maxBytes) {
+        throw new Error(`Spreadsheet exceeds the ${Math.round(maxBytes / 1024 / 1024)} MB parsing limit.`);
+    }
+    const maxChars = input.maxChars ?? DEFAULT_MAX_CHARS;
+    const maxColumns = input.maxColumns ?? DEFAULT_MAX_COLUMNS;
+    const maxRowsPerSheet = input.maxRowsPerSheet ?? DEFAULT_MAX_ROWS_PER_SHEET;
+    const maxSheets = input.maxSheets ?? DEFAULT_MAX_SHEETS;
+    const xlsx = await loadXlsx();
+    const workbook = xlsx.read(input.data, {
+        type: "array",
+        cellDates: true,
+        cellNF: false,
+        cellText: true,
+    });
+    const sheetNames = workbook.SheetNames.map(String);
+    if (sheetNames.length === 0) {
+        throw new Error("Spreadsheet does not contain any worksheets.");
+    }
+    const parts = [];
+    let text = "";
+    let truncated = false;
+    for (const [index, sheetName] of sheetNames.slice(0, maxSheets).entries()) {
+        const sheet = workbook.Sheets[sheetName];
+        if (!sheet)
+            continue;
+        const range = sheet["!ref"]
+            ? xlsx.utils.decode_range(sheet["!ref"])
+            : null;
+        const rowCount = range ? range.e.r - range.s.r + 1 : 0;
+        const columnCount = range ? range.e.c - range.s.c + 1 : 0;
+        const rows = xlsx.utils.sheet_to_json(sheet, {
+            header: 1,
+            raw: false,
+            blankrows: false,
+            defval: "",
+        });
+        const sampledRows = rows.slice(0, maxRowsPerSheet);
+        const sampledColumnCount = Math.min(maxColumns, sampledRows.reduce((max, row) => Math.max(max, row.length), 0));
+        const lines = [
+            `Sheet: ${sheetName}`,
+            `Rows: ${rowCount}; columns: ${columnCount}`,
+            `Preview rows: ${sampledRows.length}; preview columns: ${sampledColumnCount}`,
+        ];
+        if (sampledRows.length === 0) {
+            lines.push("(empty sheet)");
+        }
+        else {
+            for (const row of sampledRows) {
+                lines.push(row
+                    .slice(0, maxColumns)
+                    .map((cell) => escapePreviewValue(normalizeCell(cell)))
+                    .join("\t"));
+            }
+        }
+        const sheetTruncated = sampledRows.length < rowCount || sampledColumnCount < columnCount;
+        if (sheetTruncated) {
+            lines.push("[This sheet preview is bounded; use the original workbook for the remaining rows or columns.]");
+        }
+        const sheetText = lines.join("\n");
+        const bounded = appendBoundedText(text, sheetText, maxChars);
+        text = bounded.text;
+        if (bounded.truncated) {
+            truncated = true;
+            break;
+        }
+        parts.push({
+            index,
+            title: sheetName,
+            text: sheetText,
+            metadata: {
+                sheetName,
+                rowCount,
+                columnCount,
+                sampledRowCount: sampledRows.length,
+                sampledColumnCount,
+                truncated: sheetTruncated,
+            },
+        });
+    }
+    if (sheetNames.length > maxSheets)
+        truncated = true;
+    const warnings = [];
+    if (sheetNames.length > maxSheets) {
+        warnings.push(`Only the first ${maxSheets} of ${sheetNames.length} worksheets were included in the preview.`);
+    }
+    if (truncated &&
+        !warnings.some((warning) => warning.includes("worksheets"))) {
+        warnings.push(`The preview was limited to ${maxChars.toLocaleString()} characters.`);
+    }
+    return {
+        text,
+        fileType,
+        title: input.fileName,
+        parser: "sheetjs-workbook",
+        parts,
+        metadata: {
+            sheetNames,
+            sheetCount: sheetNames.length,
+            sampledSheetCount: parts.length,
+            truncated,
+        },
+        warnings,
+    };
+}

package/dist/integrations/adapters/slack.js

@@ -493,10 +493,11 @@ export function slackAdapter(options = {}) {
             };
             const token = await resolveBotToken(targetContext);
             if (!token) {
-                console.error("[slack] no bot token for outbound target" +
+                const errorMessage = "[slack] no bot token for outbound target" +
                     (target.tenantId ? ` (tenant ${target.tenantId})` : "") +
-                    "; set SLACK_BOT_TOKEN or pass installationKey to name the app");
-                return;
+                    "; set SLACK_BOT_TOKEN or pass installationKey to name the app";
+                console.error(errorMessage);
+                throw new Error(errorMessage);
             }
             const chunks = splitNonEmptyMessage(message.text, SLACK_MAX_LENGTH);
             if (chunks.length === 0)
@@ -520,6 +521,9 @@ export function slackAdapter(options = {}) {
                     if (!data.ok) {
                         throw new Error(data.error || "chat.postMessage failed");
                     }
+                    if (!data.ts) {
+                        throw new Error("chat.postMessage returned no message timestamp; delivery was not confirmed");
+                    }
                 }
                 catch (err) {
                     console.error("[slack] Failed to send proactive message:", err);

package/dist/localization/default-messages.d.ts

@@ -679,6 +679,9 @@ declare const messages: {
         shareLink: string;
         addPeopleByEmail: string;
         notifyPeople: string;
+        addMessage: string;
+        hideMessage: string;
+        messagePlaceholder: string;
         peopleWithAccess: string;
         ownerRole: string;
         remove: string;

package/dist/localization/default-messages.js

@@ -685,6 +685,9 @@ const messages = {
         shareLink: "Share link",
         addPeopleByEmail: "Add people by email",
         notifyPeople: "Notify people",
+        addMessage: "Add a message",
+        hideMessage: "Hide message",
+        messagePlaceholder: "Add a short note (optional)",
         peopleWithAccess: "People with access",
         ownerRole: "Owner",
         remove: "Remove",

package/dist/mcp/embed-app.js

@@ -1459,10 +1459,21 @@ export function embedApp(options = {}) {
     });
 
     window.addEventListener("message", (event) => {
-      if (!appFrame || event.source !== appFrame.contentWindow) return;
-      if (!event.data) return;
+      const message = event.data;
+      const expiredSessionMessage =
+        message?.type === "agentNative.embedSessionExpired" &&
+        typeof message.embedStartUrl === "string" &&
+        event.source === null &&
+        (message.embedStartUrl === appFrame?.src ||
+          message.embedStartUrl === lastFrameSrc);
+      if (
+        !appFrame ||
+        (!expiredSessionMessage && event.source !== appFrame.contentWindow)
+      )
+        return;
+      if (!message) return;
       const data = event.data.data || {};
-      if (event.data.type === "agentNative.embeddedAppReady") {
+      if (message.type === "agentNative.embeddedAppReady") {
         appFrameReady = true;
         embedSessionRefreshAttempts = 0;
         clearFrameLoadTimer();
@@ -1470,7 +1481,7 @@ export function embedApp(options = {}) {
         notifyOuterMcpAppReady();
         return;
       }
-      if (event.data.type === "agentNative.contentHeight") {
+      if (message.type === "agentNative.contentHeight") {
         const next = finiteNumber(data && data.height);
         if (next && Math.abs(next - reportedContentHeight) >= 1) {
           reportedContentHeight = next;
@@ -1478,23 +1489,23 @@ export function embedApp(options = {}) {
         }
         return;
       }
-      if (event.data.type === "agentNative.embedSessionExpired") {
+      if (message.type === "agentNative.embedSessionExpired") {
         refreshExpiredEmbedSession();
         return;
       }
-      if (event.data.type === "agentNative.submitChat") {
+      if (message.type === "agentNative.submitChat") {
         void sendHostChat(data);
         return;
       }
-      if (event.data.type === "agentNative.mcpHost.updateModelContext") {
+      if (message.type === "agentNative.mcpHost.updateModelContext") {
         respondToAppFrame(data.requestId, updateHostModelContext(data));
         return;
       }
-      if (event.data.type === "agentNative.mcpHost.openLink") {
+      if (message.type === "agentNative.mcpHost.openLink") {
         respondToAppFrame(data.requestId, openHostLink(data));
         return;
       }
-      if (event.data.type === "agentNative.mcpHost.requestDisplayMode") {
+      if (message.type === "agentNative.mcpHost.requestDisplayMode") {
         respondToAppFrame(data.requestId, requestHostDisplayMode(data.mode));
       }
     });

package/dist/mcp/screen-memory-stdio.d.ts

@@ -137,13 +137,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
+            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -159,6 +159,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
+            count?: undefined;
             query: {
                 type: string;
                 description: string;
@@ -174,7 +175,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -190,6 +190,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
+            count?: undefined;
             minutes: {
                 type: string;
                 description: string;
@@ -199,7 +200,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -216,6 +216,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
+            count?: undefined;
             query: {
                 type: string;
                 description: string;
@@ -234,7 +235,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             };
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -250,6 +250,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
+            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
@@ -263,7 +264,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
                 description: string;
             };
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             includeMicrophone?: undefined;
@@ -314,13 +314,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
+            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt: {
                 type: string;
                 description: string;
@@ -349,13 +349,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
+            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;

package/dist/notifications/routes.d.ts

@@ -13,21 +13,21 @@
 export declare function createNotificationsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<"" | import("./types.js").Notification[] | {
     count: number;
     updated?: undefined;
-    error?: undefined;
     ok?: undefined;
+    error?: undefined;
 } | {
+    count?: undefined;
     updated: number;
-    error?: undefined;
     ok?: undefined;
-    count?: undefined;
+    error?: undefined;
 } | {
+    count?: undefined;
     updated?: undefined;
     error: string;
     ok?: undefined;
-    count?: undefined;
 } | {
+    count?: undefined;
     updated?: undefined;
-    error?: undefined;
     ok: boolean;
-    count?: undefined;
+    error?: undefined;
 }>>;

package/dist/oauth-tokens/migrations.d.ts

@@ -0,0 +1,8 @@
+import type { MigrationEntry } from "../db/migrations.js";
+export declare const OAUTH_TOKEN_MIGRATIONS_TABLE = "_oauth_token_migrations";
+/**
+ * Framework-owned OAuth token storage. The token store still probes for
+ * compatibility with local and older deployments, but production release
+ * jobs own this schema so request functions never issue DDL.
+ */
+export declare const OAUTH_TOKEN_MIGRATIONS: MigrationEntry[];

package/dist/oauth-tokens/migrations.js

@@ -0,0 +1,36 @@
+export const OAUTH_TOKEN_MIGRATIONS_TABLE = "_oauth_token_migrations";
+/**
+ * Framework-owned OAuth token storage. The token store still probes for
+ * compatibility with local and older deployments, but production release
+ * jobs own this schema so request functions never issue DDL.
+ */
+export const OAUTH_TOKEN_MIGRATIONS = [
+    {
+        version: 1,
+        name: "oauth-tokens-table",
+        sql: `
+      CREATE TABLE IF NOT EXISTS oauth_tokens (
+        provider TEXT NOT NULL,
+        account_id TEXT NOT NULL,
+        tokens TEXT NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (provider, account_id)
+      )
+    `,
+    },
+    {
+        version: 2,
+        name: "oauth-tokens-owner-column",
+        sql: "ALTER TABLE oauth_tokens ADD COLUMN IF NOT EXISTS owner TEXT",
+    },
+    {
+        version: 3,
+        name: "oauth-tokens-display-name-column",
+        sql: "ALTER TABLE oauth_tokens ADD COLUMN IF NOT EXISTS display_name TEXT",
+    },
+    {
+        version: 4,
+        name: "oauth-tokens-owner-backfill",
+        sql: "UPDATE oauth_tokens SET owner = account_id WHERE owner IS NULL",
+    },
+];

package/dist/org/workspace-url.d.ts

@@ -22,6 +22,14 @@ export type ParsedWorkspaceUrl = {
  * app they arrive at.
  */
 export declare function parseWorkspaceUrl(raw: string): ParsedWorkspaceUrl;
+/**
+ * Whether a URL points at a browser-local development origin.
+ *
+ * Local development may use a loopback hostname or a subdomain of the
+ * reserved `.localhost` domain. Hosted previews must remain eligible for
+ * workspace guidance.
+ */
+export declare function isLocalDevelopmentOrigin(currentUrl: string): boolean;
 /**
  * Whether a member currently on `currentUrl` should be pointed at the org's
  * workspace. False when the org has no workspace, when the stored value is

package/dist/org/workspace-url.js

@@ -28,7 +28,8 @@ export function parseWorkspaceUrl(raw) {
     try {
         parsed = new URL(withScheme);
     }
-    catch {
+    catch (error) {
+        void error;
         return { ok: false, reason: "Not a valid URL" };
     }
     if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
@@ -39,6 +40,28 @@ export function parseWorkspaceUrl(raw) {
     }
     return { ok: true, url: parsed.origin };
 }
+/**
+ * Whether a URL points at a browser-local development origin.
+ *
+ * Local development may use a loopback hostname or a subdomain of the
+ * reserved `.localhost` domain. Hosted previews must remain eligible for
+ * workspace guidance.
+ */
+export function isLocalDevelopmentOrigin(currentUrl) {
+    let hostname;
+    try {
+        hostname = new URL(currentUrl).hostname.toLowerCase();
+    }
+    catch (error) {
+        void error;
+        return false;
+    }
+    return (hostname === "localhost" ||
+        hostname.endsWith(".localhost") ||
+        hostname === "127.0.0.1" ||
+        hostname === "::1" ||
+        hostname === "[::1]");
+}
 /**
  * Whether a member currently on `currentUrl` should be pointed at the org's
  * workspace. False when the org has no workspace, when the stored value is
@@ -55,7 +78,8 @@ export function shouldOfferWorkspace(currentUrl, workspaceUrl) {
     try {
         currentOrigin = new URL(currentUrl).origin;
     }
-    catch {
+    catch (error) {
+        void error;
         return false;
     }
     return currentOrigin !== parsed.url;

package/dist/secrets/routes.d.ts

@@ -34,16 +34,16 @@ export declare function createListSecretsHandler(): import("h3").EventHandlerWit
 /** POST /_agent-native/secrets/:key — write a secret. */
 export declare function createWriteSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    ok?: undefined;
     status?: undefined;
+    ok?: undefined;
 } | {
     ok: boolean;
     status: string;
     error?: undefined;
 } | {
-    ok?: undefined;
     error: string;
     removed?: undefined;
+    ok?: undefined;
 } | {
     ok: boolean;
     removed: boolean;
@@ -54,9 +54,9 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
  * or the current stored value without changing anything.
  */
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
     note?: undefined;
+    ok?: undefined;
 } | {
     ok: boolean;
     note?: undefined;