@agent-native/core 0.154.5 → 0.157.0

package/dist/coding-tools/sandbox/executions-store.js

@@ -79,6 +79,7 @@ async function _doEnsureTable() {
       timed_out ${intType()} NOT NULL DEFAULT 0,
       error TEXT,
       bridge_tools_used TEXT,
+      allowed_action_names TEXT,
       created_at ${intType()} NOT NULL,
       started_at ${intType()},
       finished_at ${intType()},
@@ -94,7 +95,10 @@ async function _doEnsureTable() {
         await ensureTableExists(TABLE, createSql);
         // Additive-column guard: keeps older deployments (created before a column
         // was added) self-healing without destructive migrations.
-        const pgColumns = [["bridge_tools_used", "TEXT"]];
+        const pgColumns = [
+            ["bridge_tools_used", "TEXT"],
+            ["allowed_action_names", "TEXT"],
+        ];
         for (const [col, def] of pgColumns) {
             await ensureColumnExists(TABLE, col, `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS ${col} ${def}`);
         }
@@ -103,6 +107,15 @@ async function _doEnsureTable() {
     }
     else {
         await retryOnDdlRace(() => client.execute(createSql));
+        try {
+            await retryOnDdlRace(() => client.execute(`ALTER TABLE ${TABLE} ADD COLUMN allowed_action_names TEXT`));
+        }
+        catch (error) {
+            const message = String(error?.message ?? error);
+            if (!/duplicate column name|column .* already exists/i.test(message)) {
+                throw error;
+            }
+        }
         await retryOnDdlRace(() => client.execute(ownerIdxSql));
         await retryOnDdlRace(() => client.execute(dueIdxSql));
     }
@@ -136,6 +149,27 @@ function rowFromDb(raw) {
             bridgeToolsUsed = [];
         }
     }
+    let allowedActionNames;
+    if (raw.allowed_action_names !== null &&
+        raw.allowed_action_names !== undefined) {
+        if (typeof raw.allowed_action_names !== "string") {
+            allowedActionNames = [];
+        }
+        else {
+            try {
+                const parsed = JSON.parse(raw.allowed_action_names);
+                allowedActionNames =
+                    Array.isArray(parsed) &&
+                        parsed.every((item) => typeof item === "string")
+                        ? [...new Set(parsed)]
+                        : [];
+            }
+            catch {
+                // A malformed persisted surface must never restore the full registry.
+                allowedActionNames = [];
+            }
+        }
+    }
     return {
         id: String(raw.id),
         owner: String(raw.owner),
@@ -165,6 +199,7 @@ function rowFromDb(raw) {
         timedOut: toBool(raw.timed_out),
         error: raw.error === null || raw.error === undefined ? null : String(raw.error),
         bridgeToolsUsed,
+        allowedActionNames,
         createdAt: toNumberOrNull(raw.created_at) ?? 0,
         startedAt: toNumberOrNull(raw.started_at),
         finishedAt: toNumberOrNull(raw.finished_at),
@@ -180,8 +215,8 @@ export async function createSandboxExecution(input) {
     const maxAttempts = Math.max(1, Math.min(input.maxAttempts ?? SANDBOX_EXECUTION_DEFAULT_MAX_ATTEMPTS, 5));
     await client.execute({
         sql: `INSERT INTO ${TABLE}
-      (id, owner, org_id, thread_id, runtime, code, status, timeout_ms, max_output_chars, attempt_count, max_attempts, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, 'queued', ?, ?, 0, ?, ?, ?)`,
+      (id, owner, org_id, thread_id, runtime, code, status, timeout_ms, max_output_chars, attempt_count, max_attempts, allowed_action_names, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, 'queued', ?, ?, 0, ?, ?, ?, ?)`,
         args: [
             id,
             input.owner,
@@ -192,6 +227,9 @@ export async function createSandboxExecution(input) {
             input.timeoutMs,
             input.maxOutputChars,
             maxAttempts,
+            input.allowedActionNames === undefined
+                ? null
+                : JSON.stringify([...new Set(input.allowedActionNames)]),
             now,
             now,
         ],

package/dist/collab/awareness.d.ts

@@ -62,11 +62,11 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
-    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
+    error?: undefined;
 }>>;
 /**
  * GET /_agent-native/collab/:docId/users
@@ -77,9 +77,9 @@ export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("
     error: string;
     users?: undefined;
 } | {
-    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
+    error?: undefined;
 }>>;

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/feature-flags/index.d.ts

@@ -1,4 +1,4 @@
 export { defineFeatureFlag, defineFeatureFlags, getFeatureFlagDefinition, listFeatureFlags, registerFeatureFlags, type FeatureFlagDefinition, } from "./registry.js";
-export { defaultFeatureFlagRules, evaluateFeatureFlag, evaluateFeatureFlagRules, isFeatureFlagEnabled, getFeatureFlagRules, normalizeFeatureFlagRules, type FeatureFlagMode, type FeatureFlagRules, type FeatureFlagScope, } from "./store.js";
+export { defaultFeatureFlagRules, evaluateFeatureFlag, evaluateFeatureFlagRules, hasActiveFeatureFlagRollout, isFeatureFlagEnabled, getFeatureFlagRules, normalizeFeatureFlagRules, type FeatureFlagMode, type FeatureFlagRules, type FeatureFlagScope, } from "./store.js";
 export { createFeatureFlagsPlugin } from "./plugin.js";
 export { createFeatureFlagA2AActionRouteAuth } from "./a2a-action-route.js";

package/dist/feature-flags/index.js

@@ -1,4 +1,4 @@
 export { defineFeatureFlag, defineFeatureFlags, getFeatureFlagDefinition, listFeatureFlags, registerFeatureFlags, } from "./registry.js";
-export { defaultFeatureFlagRules, evaluateFeatureFlag, evaluateFeatureFlagRules, isFeatureFlagEnabled, getFeatureFlagRules, normalizeFeatureFlagRules, } from "./store.js";
+export { defaultFeatureFlagRules, evaluateFeatureFlag, evaluateFeatureFlagRules, hasActiveFeatureFlagRollout, isFeatureFlagEnabled, getFeatureFlagRules, normalizeFeatureFlagRules, } from "./store.js";
 export { createFeatureFlagsPlugin } from "./plugin.js";
 export { createFeatureFlagA2AActionRouteAuth } from "./a2a-action-route.js";

package/dist/feature-flags/store.d.ts

@@ -19,6 +19,16 @@ export declare const FEATURE_FLAG_SETTINGS_PREFIX = "feature-flag:";
 export declare function defaultFeatureFlagRules(): FeatureFlagRules;
 export declare function normalizeFeatureFlagRules(value: unknown): FeatureFlagRules;
 export declare function getFeatureFlagRules(key: string, scope: Pick<FeatureFlagScope, "orgId">): Promise<FeatureFlagRules>;
+/**
+ * Anonymous discovery hint for a rollout that may be scoped to an org.
+ *
+ * This deliberately answers only whether some active rollout exists. It does
+ * not reveal the target email or organization, and callers must still run
+ * `evaluateFeatureFlag` with the authenticated scope before granting access.
+ * Without this separate hint, an org-only rollout is invisible to Desktop
+ * before the user has authenticated and the org can be resolved.
+ */
+export declare function hasActiveFeatureFlagRollout(key: string): Promise<boolean>;
 /**
  * Atomically derive one flag's scoped rules. An org's first override starts
  * from the global fallback, then becomes independently CAS-protected.

package/dist/feature-flags/store.js

@@ -1,10 +1,73 @@
+import { getDbExec, isPostgres } from "../db/client.js";
 import { getOrgSetting, mutateOrgSetting } from "../settings/org-settings.js";
 import { getSetting, mutateSetting } from "../settings/store.js";
 import { getFeatureFlagDefinition, } from "./registry.js";
 export const FEATURE_FLAG_SETTINGS_PREFIX = "feature-flag:";
+const FEATURE_FLAG_ROLLOUT_INDEX_PREFIX = "feature-flag-rollout-index:";
 function settingKey(key) {
     return `${FEATURE_FLAG_SETTINGS_PREFIX}${key}`;
 }
+function rolloutIndexKey(key) {
+    return `${FEATURE_FLAG_ROLLOUT_INDEX_PREFIX}${key}`;
+}
+function parseStoredRules(value) {
+    if (typeof value === "string")
+        return normalizeFeatureFlagRules(JSON.parse(value));
+    return normalizeFeatureFlagRules(value);
+}
+function hasActiveRollout(rules) {
+    return (rules.mode === "on" ||
+        (rules.mode === "rules" &&
+            (rules.emails.length > 0 ||
+                rules.orgIds.length > 0 ||
+                rules.percentage > 0)));
+}
+function normalizeFeatureFlagRolloutIndex(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const raw = value;
+    const orgIds = Array.isArray(raw.orgIds)
+        ? [
+            ...new Set(raw.orgIds.filter((item) => typeof item === "string")),
+        ]
+            .map((orgId) => orgId.trim())
+            .filter(Boolean)
+            .sort()
+        : [];
+    return {
+        version: 1,
+        global: raw.global === true,
+        orgIds,
+    };
+}
+function activeFeatureFlagRolloutIndex(index) {
+    return index.global || index.orgIds.length > 0;
+}
+async function syncFeatureFlagRolloutIndex(key, scope, rules) {
+    const indexKey = rolloutIndexKey(key);
+    await mutateSetting(indexKey, async (current) => {
+        const next = normalizeFeatureFlagRolloutIndex(current) ?? {
+            version: 1,
+            global: false,
+            orgIds: [],
+        };
+        if (scope.orgId?.trim()) {
+            const orgId = scope.orgId.trim();
+            const active = hasActiveRollout(rules);
+            const orgIds = active
+                ? [...new Set([...next.orgIds, orgId])].sort()
+                : next.orgIds.filter((value) => value !== orgId);
+            return {
+                ...next,
+                orgIds,
+            };
+        }
+        return {
+            ...next,
+            global: hasActiveRollout(rules),
+        };
+    });
+}
 export function defaultFeatureFlagRules() {
     return {
         version: 1,
@@ -66,6 +129,52 @@ export async function getFeatureFlagRules(key, scope) {
     ]);
     return normalizeFeatureFlagRules(orgStored ?? globalStored);
 }
+/**
+ * Anonymous discovery hint for a rollout that may be scoped to an org.
+ *
+ * This deliberately answers only whether some active rollout exists. It does
+ * not reveal the target email or organization, and callers must still run
+ * `evaluateFeatureFlag` with the authenticated scope before granting access.
+ * Without this separate hint, an org-only rollout is invisible to Desktop
+ * before the user has authenticated and the org can be resolved.
+ */
+export async function hasActiveFeatureFlagRollout(key) {
+    if (!getFeatureFlagDefinition(key))
+        return false;
+    const indexKey = rolloutIndexKey(key);
+    const storedIndex = normalizeFeatureFlagRolloutIndex(await getSetting(indexKey));
+    if (storedIndex)
+        return activeFeatureFlagRolloutIndex(storedIndex);
+    const globalStored = await getSetting(settingKey(key));
+    const globalActive = hasActiveRollout(parseStoredRules(globalStored));
+    if (globalActive) {
+        await mutateSetting(indexKey, async () => ({
+            version: 1,
+            global: true,
+            orgIds: [],
+        }));
+        return true;
+    }
+    const table = isPostgres() ? "public.settings" : "settings";
+    const { rows } = await getDbExec().execute({
+        sql: `SELECT key, value FROM ${table} WHERE key LIKE ?`,
+        args: [`o:%:${settingKey(key)}`],
+    });
+    const orgIds = rows
+        .filter((row) => hasActiveRollout(parseStoredRules(row.value)))
+        .map((row) => {
+        const match = /^o:([^:]+):/.exec(row.key ?? "");
+        return match?.[1] ?? null;
+    })
+        .filter((orgId) => Boolean(orgId))
+        .sort();
+    await mutateSetting(indexKey, async () => ({
+        version: 1,
+        global: false,
+        orgIds,
+    }));
+    return orgIds.length > 0;
+}
 /**
  * Atomically derive one flag's scoped rules. An org's first override starts
  * from the global fallback, then becomes independently CAS-protected.
@@ -85,7 +194,9 @@ export async function mutateFeatureFlagRules(key, scope, updater) {
     const persisted = scope.orgId?.trim()
         ? await mutateOrgSetting(scope.orgId, settingKey(key), mutate)
         : await mutateSetting(settingKey(key), mutate);
-    return normalizeFeatureFlagRules(persisted);
+    const normalized = normalizeFeatureFlagRules(persisted);
+    await syncFeatureFlagRolloutIndex(key, scope, normalized);
+    return normalized;
 }
 function rolloutBucket(input) {
     // FNV-1a is deliberately tiny, deterministic, and independent of runtime.

package/dist/guards/no-env-credentials.js

@@ -55,6 +55,10 @@ const ALLOWLIST_EXACT = new Set([
     "AWS_LAMBDA_FUNCTION_NAME",
     "BETTER_AUTH_SECRET",
     "BETTER_AUTH_URL",
+    // Public deployment identity/configuration. These select the app origin and
+    // explicitly registered SSO clients; they are not user credentials.
+    "APP_URL",
+    "IDENTITY_SSO_APP_REGISTRY_JSON",
     "NOTION_CLIENT_ID",
     "NOTION_CLIENT_SECRET",
     "NOTION_STATE_SECRET",

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./config.js";
-export { createProductionAgentHandler, type ActionEntry, type ScriptEntry, type ProductionAgentOptions, type ActionTool, type ScriptTool, type AgentMessage, type AgentChatRequest, type AgentChatEvent, type AgentChatAttachment, DEFAULT_MODEL, TripWire, type Processor, type ProcessorState, type ProcessorAbort, } from "./agent/index.js";
+export { createProductionAgentHandler, type ActionEntry, type ScriptEntry, type ProductionAgentOptions, type AgentActionSurface, type AgentActionSurfaceDetails, type ActionTool, type ScriptTool, type AgentMessage, type AgentChatRequest, type AgentChatEvent, type AgentChatAttachment, DEFAULT_MODEL, TripWire, type Processor, type ProcessorState, type ProcessorAbort, } from "./agent/index.js";
 export { defineAction, ActionContractError, isActionContractError, type ActionContractErrorOptions, AgentActionStopError, isAgentActionStopError, type ActionDefinition, type ActionHttpConfig, type AgentActionStopOptions, type PublicAgentActionConfig, type ActionDeepLink, type ActionLinkBuilder, MCP_APP_EXTENSION_ID, MCP_APP_MIME_TYPE, MCP_APP_RESOURCE_URI_META_KEY, type ActionMcpAppConfig, type ActionMcpAppCsp, type ActionMcpAppCspBuilder, type ActionMcpAppHtmlBuilder, type ActionMcpAppPermissions, type ActionMcpAppResourceConfig, type ActionMcpAppResourceMeta, } from "./action.js";
 export * from "./user-profile/index.js";
 export { embedApp, MCP_APP_REQUEST_ORIGIN_CSP_SOURCE, type EmbedAppOptions, } from "./mcp/embed-app.js";
@@ -11,7 +11,7 @@ export { createAgentChatPlugin, defaultAgentChatPlugin, type AgentChatPluginOpti
 export { createAgentNativeEmbeddedPlugin, mountAgentNativeEmbedded, type AgentNativeEmbeddedPluginOptions, } from "./server/embedded.js";
 export { BUILT_IN_INTEGRATION_CATALOG, INTEGRATION_CATEGORIES, getIntegrationCatalogEntry, listBuiltInChannelIntegrations, listIntegrationCatalog, type AutomationCapabilities, type BuiltInChannelId, type ChannelCapabilities, type IntegrationAvailability, type IntegrationCatalogEntry, type IntegrationCategory, type IntegrationCredentialRequirement, type IntegrationIconKey, type IntegrationSupportMaturity, } from "./integrations/catalog.js";
 export { AutomationConnectorError, createAutomationCallbackHandler, createAutomationRuntime, createInvokeAutomationWorkflowAction, type AutomationCallbackAuthentication, type AutomationCallbackInput, type AutomationCallbackResult, type AutomationInboundDefinition, type AutomationInvocation, type AutomationInvocationResult, type AutomationInvocationStatus, type AutomationOutboundDefinition, type AutomationResponseMode, type AutomationRetryPolicy, type AutomationRuntime, type AutomationRuntimeOptions, type AutomationWorkflowCapabilities, type AutomationWorkflowDefinition, type JsonSchema, } from "./automation/index.js";
-export { createFeatureFlagsPlugin, defineFeatureFlag, defineFeatureFlags, evaluateFeatureFlag, getFeatureFlagDefinition, getFeatureFlagRules, isFeatureFlagEnabled, listFeatureFlags, registerFeatureFlags, type FeatureFlagDefinition, type FeatureFlagMode, type FeatureFlagRules, type FeatureFlagScope, } from "./feature-flags/index.js";
+export { createFeatureFlagsPlugin, defineFeatureFlag, defineFeatureFlags, evaluateFeatureFlag, getFeatureFlagDefinition, getFeatureFlagRules, hasActiveFeatureFlagRollout, isFeatureFlagEnabled, listFeatureFlags, registerFeatureFlags, type FeatureFlagDefinition, type FeatureFlagMode, type FeatureFlagRules, type FeatureFlagScope, } from "./feature-flags/index.js";
 export { createServer, createSSEHandler, defineNitroPlugin, autoMountAuth, getSession, type CreateServerOptions, type SSEHandlerOptions, type AuthSession, type AuthOptions, } from "./server/index.js";
 export { agentChat, type AgentChatCallOptions, type AgentChatResponse, } from "./shared/index.js";
 export { EMBED_MODE_QUERY_PARAM, EMBED_SESSION_COOKIE, EMBED_START_PATH, EMBED_TOKEN_QUERY_PARAM, } from "./shared/embed-auth.js";

package/dist/index.js

@@ -16,7 +16,7 @@ export { createAgentChatPlugin, defaultAgentChatPlugin, } from "./server/agent-c
 export { createAgentNativeEmbeddedPlugin, mountAgentNativeEmbedded, } from "./server/embedded.js";
 export { BUILT_IN_INTEGRATION_CATALOG, INTEGRATION_CATEGORIES, getIntegrationCatalogEntry, listBuiltInChannelIntegrations, listIntegrationCatalog, } from "./integrations/catalog.js";
 export { AutomationConnectorError, createAutomationCallbackHandler, createAutomationRuntime, createInvokeAutomationWorkflowAction, } from "./automation/index.js";
-export { createFeatureFlagsPlugin, defineFeatureFlag, defineFeatureFlags, evaluateFeatureFlag, getFeatureFlagDefinition, getFeatureFlagRules, isFeatureFlagEnabled, listFeatureFlags, registerFeatureFlags, } from "./feature-flags/index.js";
+export { createFeatureFlagsPlugin, defineFeatureFlag, defineFeatureFlags, evaluateFeatureFlag, getFeatureFlagDefinition, getFeatureFlagRules, hasActiveFeatureFlagRollout, isFeatureFlagEnabled, listFeatureFlags, registerFeatureFlags, } from "./feature-flags/index.js";
 // Server
 export { createServer, createSSEHandler, defineNitroPlugin, autoMountAuth, getSession, } from "./server/index.js";
 // Client

package/dist/integrations/adapters/slack.js

@@ -858,7 +858,11 @@ function markdownToSlackMrkdwn(text) {
         // pathological "**" sequence that exhibits super-linear backtracking.
         // Newlines are allowed because `[^*]` excludes only the asterisk
         // itself, so multi-line bold spans still match.
-        .replace(/\*\*([^*]{1,5000})\*\*/g, "*$1*"));
+        .replace(/\*\*([^*]{1,5000})\*\*/g, "*$1*")
+        // Agent output sometimes uses Markdown-style bare Slack user IDs.
+        // Leave native `<@...>` mentions untouched while converting the bare
+        // user/member forms Slack expects in mrkdwn.
+        .replace(/(?<![<\w])@([UW][A-Z0-9]+)(?![A-Z0-9])/g, "<@$1>"));
 }
 /**
  * Optionally set Slack's native Agent status indicator (the small "is

package/dist/localization/core-messages/ar-SA.d.ts

@@ -0,0 +1,3 @@
+import type { AgentChatTranslation } from "../core-messages.js";
+declare const messages: AgentChatTranslation;
+export default messages;