@agent-native/core 0.200.0-nightly-20261002124406 → 0.200.0

package/dist/mcp-client/app-api.d.ts

@@ -10,10 +10,20 @@ export interface AppMcpTool {
 }
 export interface ListVisibleMcpToolsOptions {
     serverId?: string;
+    /**
+     * Keep only tools served from this provider's MCP endpoint, matched on the
+     * server URL. A server id is a name the user chose, so it cannot prove which
+     * provider answers the call.
+     */
+    providerId?: string;
+}
+export interface CallMcpToolOptions {
+    /** Refuse the call unless the server's URL belongs to this provider. */
+    providerId?: string;
 }
 export declare class McpAppApiError extends Error {
     readonly statusCode: 401 | 403 | 503;
     constructor(message: string, statusCode: 401 | 403 | 503);
 }
 export declare function listVisibleMcpTools(options?: ListVisibleMcpToolsOptions): Promise<AppMcpTool[]>;
-export declare function callMcpTool(serverId: string, originalToolName: string, args?: Record<string, unknown>): Promise<unknown>;
+export declare function callMcpTool(serverId: string, originalToolName: string, args?: Record<string, unknown>, options?: CallMcpToolOptions): Promise<unknown>;

package/dist/mcp-client/app-api.js

@@ -1,6 +1,7 @@
 import { isToolVisibilityModelOnly } from "@modelcontextprotocol/ext-apps/app-bridge";
 import { getMcpManagerForPrincipal } from "../server/agent-chat/mcp-glue.js";
 import { getRequestContext } from "../server/request-context.js";
+import { hasMcpProviderMatchRules, mcpServerUrlMatchesProvider, } from "../shared/mcp-provider-hosts.js";
 import { buildMcpToolName, } from "./manager.js";
 import { normalizeMcpPrincipal } from "./principal.js";
 import { parseMergedKey } from "./remote-store.js";
@@ -20,16 +21,19 @@ export async function listVisibleMcpTools(options = {}) {
         ? manager.getToolsForServer(options.serverId)
         : manager.getTools();
     return tools
-        .filter((tool) => isToolVisibleToApp(tool, context))
+        .filter((tool) => isToolVisibleToApp(tool, context) &&
+        isServerForProvider(manager, tool.source, options.providerId))
         .map(toAppMcpTool);
 }
-export async function callMcpTool(serverId, originalToolName, args = {}) {
+export async function callMcpTool(serverId, originalToolName, args = {}, options = {}) {
     const context = requireAuthenticatedRequest();
     const manager = await requireMcpManager(context);
     const tool = manager
         .getToolsForServer(serverId)
         .find((candidate) => candidate.originalName === originalToolName);
-    if (!tool || !isToolVisibleToApp(tool, context)) {
+    if (!tool ||
+        !isToolVisibleToApp(tool, context) ||
+        !isServerForProvider(manager, serverId, options.providerId)) {
         throw new McpAppApiError("MCP tool is not available in this request scope.", 403);
     }
     return manager.callTool(buildMcpToolName(serverId, originalToolName), args);
@@ -81,6 +85,16 @@ function isToolVisibleToApp(tool, context) {
         return false;
     }
 }
+function isServerForProvider(manager, serverId, providerId) {
+    if (providerId === undefined)
+        return true;
+    if (!hasMcpProviderMatchRules(providerId)) {
+        throw new Error(`No MCP provider match rules for "${providerId}". Add it to MCP_PROVIDER_ENDPOINTS or MCP_LINK_HOSTS before filtering by it.`);
+    }
+    const config = manager.getServerConfig(serverId);
+    return (config?.type === "http" &&
+        mcpServerUrlMatchesProvider(providerId, config.url) === true);
+}
 function toAppMcpTool(tool) {
     return {
         serverId: tool.source,

package/dist/mcp-client/index.d.ts

@@ -10,7 +10,7 @@ export { mountMcpServersRoutes, buildMergedConfig, builtinMergedConfigKey, McpCo
 export { mountMcpHubRoutes, listHubServers, getHubStatus, isHubServeEnabled, isHubConsumeEnabled, type HubServerRecord, type HubServersResponse, } from "./hub-routes.js";
 export { fetchHubServers } from "./hub-client.js";
 export { isMcpToolAllowedForRequest } from "./visibility.js";
-export { callMcpTool, listVisibleMcpTools, McpAppApiError, type AppMcpTool, type ListVisibleMcpToolsOptions, } from "./app-api.js";
+export { callMcpTool, listVisibleMcpTools, McpAppApiError, type AppMcpTool, type CallMcpToolOptions, type ListVisibleMcpToolsOptions, } from "./app-api.js";
 export { classifyMcpToolCall, evaluateMcpToolCallPolicy, type McpToolCallClassification, type McpToolEffect, type McpToolFamily, type McpToolInvocationPolicy, type McpToolPolicyDecision, } from "./tool-policy.js";
 export { configureScreenMemory, queryScreenMemoryForAgent, queryScreenMemoryContext, readScreenMemoryStatus, type ScreenMemoryConfig, type ScreenMemoryAgentQueryResult, type ScreenMemoryContextItem, type ScreenMemoryCoverageGap, type ScreenMemoryEvidenceItem, type ScreenMemoryEvidenceSourceType, type ScreenMemoryQueryResult, type ScreenMemoryRetrievalCoverage, type ScreenMemorySegmentReference, type ScreenMemoryStatus, type ScreenMemoryTimeRange, type ScreenMemoryTruncation, } from "./screen-memory-local.js";
 export { MCP_ACTION_RESULT_MARKER, isMcpActionResult, type AgentMcpAppPayload, type AgentMcpAppResourceContent, type McpActionResult, } from "./app-result.js";

package/dist/mcp-client/manager.d.ts

@@ -1,4 +1,4 @@
-import type { McpConfig } from "./config.js";
+import type { McpConfig, McpServerConfig } from "./config.js";
 export declare const MCP_TOOL_PREFIX = "mcp__";
 export interface McpTool {
     source: string;
@@ -66,6 +66,8 @@ export declare class McpClientManager {
     getTools(): McpTool[];
     getTool(prefixedName: string): McpTool | null;
     getToolsForServer(serverId: string): McpTool[];
+    /** The config the server's current tools were loaded from. */
+    getServerConfig(serverId: string): McpServerConfig | null;
     hasServer(serverId: string): boolean;
     callTool(prefixedName: string, args: unknown): Promise<unknown>;
     readResource(serverId: string, uri: string): Promise<unknown>;

package/dist/mcp-client/manager.js

@@ -526,6 +526,10 @@ export class McpClientManager {
     getToolsForServer(serverId) {
         return [...(this.servers.get(serverId)?.tools ?? [])];
     }
+    /** The config the server's current tools were loaded from. */
+    getServerConfig(serverId) {
+        return this.servers.get(serverId)?.config ?? null;
+    }
     hasServer(serverId) {
         const entry = this.servers.get(serverId);
         return !!entry?.client && !entry.error;

package/dist/notifications/routes.d.ts

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

package/dist/observability/metrics.js

@@ -64,8 +64,11 @@ export function recordHttpServerRequest(request) {
 function flushErrorType(error) {
     return error instanceof Error && error.name ? error.name : "unknown";
 }
-function recordFlushFailure(errorType) {
-    instruments()?.flushFailures.add(1, { "error.type": errorType });
+function recordFlushFailure(signal, errorType) {
+    instruments()?.flushFailures.add(1, {
+        "agent_native.telemetry.signal": signal,
+        "error.type": errorType,
+    });
 }
 /**
  * Export buffered telemetry before a serverless function can freeze. Never
@@ -85,17 +88,21 @@ export async function flushObservability() {
     try {
         // One provider failing must not end the wait for the other: the response
         // hook returning early lets the runtime freeze mid-export.
-        const failures = await Promise.all([provider.meterProvider, provider.tracerProvider].map((signal) => Promise.race([
+        const flushes = [
+            ["metrics", provider.meterProvider],
+            ["traces", provider.tracerProvider],
+        ];
+        const failures = await Promise.all(flushes.map(([, signalProvider]) => Promise.race([
             (async () => {
-                await signal?.forceFlush?.();
+                await signalProvider?.forceFlush?.();
                 return undefined;
             })().catch(flushErrorType),
             timeout,
         ])));
-        for (const failure of failures) {
+        failures.forEach((failure, index) => {
             if (failure)
-                recordFlushFailure(failure);
-        }
+                recordFlushFailure(flushes[index][0], failure);
+        });
     }
     finally {
         clearTimeout(timer);

package/dist/provider-api/actions/custom-provider-registration.d.ts

@@ -75,10 +75,11 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
+    provider?: undefined;
     id?: undefined;
     deleted?: undefined;
-    provider?: undefined;
     message?: undefined;
+    found?: undefined;
     providers: {
         id: string;
         label: string;
@@ -89,7 +90,6 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         updatedAt: number;
     }[];
     count: number;
-    found?: undefined;
     registered?: undefined;
     label?: undefined;
 } | {
@@ -103,8 +103,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     registered?: undefined;
     label?: undefined;
 } | {
-    deleted?: undefined;
     provider?: undefined;
+    deleted?: undefined;
     message?: undefined;
     providers?: undefined;
     count?: undefined;
@@ -115,19 +115,19 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
 } | {
     provider?: undefined;
     message?: undefined;
+    found?: undefined;
     providers?: undefined;
     count?: undefined;
-    found?: undefined;
     deleted: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
 } | {
-    deleted?: undefined;
     provider?: undefined;
+    deleted?: undefined;
+    found?: undefined;
     providers?: undefined;
     count?: undefined;
-    found?: undefined;
     registered: boolean;
     id: string;
     label: string;

package/dist/provider-api/actions/provider-api.d.ts

@@ -311,10 +311,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         notes?: string | undefined;
         scope?: "org" | "user" | undefined;
     }, {
-        message?: undefined;
-        provider?: undefined;
         id?: undefined;
-        deleted?: undefined;
+        message?: undefined;
+        found?: undefined;
         providers: {
             id: string;
             label: string;
@@ -325,45 +324,46 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
             updatedAt: number;
         }[];
         count: number;
-        found?: undefined;
+        provider?: undefined;
+        deleted?: undefined;
         registered?: undefined;
         label?: undefined;
     } | {
-        message?: undefined;
         id?: undefined;
         count?: undefined;
-        deleted?: undefined;
+        message?: undefined;
         providers?: undefined;
         found: boolean;
         provider: import("../custom-registry.js").CustomProviderConfig;
+        deleted?: undefined;
         registered?: undefined;
         label?: undefined;
     } | {
-        message?: undefined;
-        provider?: undefined;
         count?: undefined;
-        deleted?: undefined;
+        message?: undefined;
         providers?: undefined;
+        provider?: undefined;
         found: boolean;
         id: string;
+        deleted?: undefined;
         registered?: undefined;
         label?: undefined;
     } | {
-        message?: undefined;
-        provider?: undefined;
         count?: undefined;
-        providers?: undefined;
+        message?: undefined;
         found?: undefined;
+        providers?: undefined;
+        provider?: undefined;
         deleted: boolean;
         id: string;
         registered?: undefined;
         label?: undefined;
     } | {
-        provider?: undefined;
         count?: undefined;
-        deleted?: undefined;
-        providers?: undefined;
         found?: undefined;
+        providers?: undefined;
+        provider?: undefined;
+        deleted?: undefined;
         registered: boolean;
         id: string;
         label: string;

package/dist/resource-changes/store.d.ts

@@ -0,0 +1,166 @@
+/**
+ * The app resource change feed: a durable note that one of an app's
+ * resources changed, kept once for every consumer that asked to hear about
+ * that resource type.
+ *
+ * Producers call one SQL function, `agent_native_app_resource_changed`, in the
+ * writer's own transaction, so nothing is recorded unless the write commits.
+ * Today the producers are row triggers that core generates for a registered
+ * table. They catch every writer: actions, sync jobs, raw SQL, and deletes.
+ * If core later gains a data layer that every write goes through, it calls the
+ * same function and the triggers retire; consumers don't change.
+ *
+ * Each (consumer, resource) pair is one row. Repeated changes update that row
+ * rather than adding rows, so autosave doesn't grow the feed. Every change
+ * takes a new value from one sequence, taken after the row lock, so for any
+ * one resource a larger `seq` always means a later committed change. Consumers
+ * use it to reject stale work and to delete only what they processed.
+ *
+ * A change that fails is retried with backoff, and after its last allowed
+ * attempt it is marked failed but still retried every few minutes. It stays
+ * pending the whole time, so a consumer that reports freshness never treats
+ * it as done.
+ *
+ * Consumers never poll. They process changes only where the database is
+ * already awake: before a read that needs fresh data, right after a write, or
+ * inside the framework's recurring sweep. See docs/search-architecture.md.
+ */
+import { type DbExec } from "../db/client.js";
+export declare const RESOURCE_CHANGES_TABLE = "app_resource_changes";
+export declare const RESOURCE_CHANGE_CONSUMERS_TABLE = "app_resource_change_consumers";
+export declare const RESOURCE_CHANGE_SEQUENCE = "app_resource_change_seq";
+export declare const RESOURCE_CHANGED_FUNCTION = "agent_native_app_resource_changed";
+/** After this many attempts a change is marked failed. */
+export declare const RESOURCE_CHANGE_MAX_ATTEMPTS = 5;
+/**
+ * Creates the feed's tables, sequence, and producer function. Listed in
+ * `server/release-schema.ts`; trigger installation calls it too, so the
+ * function a trigger calls always exists before the trigger does.
+ */
+export declare function ensureResourceChangeTables(injectedClient?: DbExec): Promise<void>;
+/** Where a registered resource lives, for generating its triggers. */
+export interface ResourceChangeSource {
+    app: string;
+    resourceType: string;
+    table: string;
+    idColumn: string;
+}
+export declare function assertResourceKey(value: string, label: string): string;
+/**
+ * Names of the function and triggers generated for one source. Functions are
+ * schema-wide and the readable part is shortened to fit Postgres's 63
+ * characters, so a hash of the app, table, and type keeps every source's
+ * names distinct. Installing a source replaces whatever has its names, so
+ * the hash is wide enough that two sources never share them.
+ */
+export declare function resourceChangeTriggerNames(source: ResourceChangeSource): {
+    function: string;
+    insertDeleteTrigger: string;
+    updateTrigger: string;
+    truncateTrigger: string;
+};
+/**
+ * SQL that makes every committed insert, update, delete, and truncate on the
+ * source table call the producer function. An update that changes nothing is
+ * skipped. An update that changes the id reports both ids. A truncate
+ * reports every row it removes as deleted.
+ *
+ * "Changes nothing" compares the rows' stored bytes (`*<>`), not their
+ * values: a `json` or `point` column has no equality operator, and comparing
+ * such rows by value would make every update on the table fail.
+ *
+ * Triggers are replaced in place, never dropped and recreated: a write
+ * committed between a drop and a create would never be recorded.
+ */
+export declare function resourceChangeTriggerSql(source: ResourceChangeSource): string[];
+/**
+ * Installs change capture for a source and subscribes a consumer to it.
+ * Apps call this from a named migration, so the triggers ship with the app's
+ * schema rather than being created on a request path.
+ *
+ * Creating a trigger waits for every open transaction on the table, and
+ * queues the table's writes behind it while it waits, so each waits at most
+ * a few seconds. Returns false when one gave up; the caller retries later.
+ */
+export declare function installResourceChangeCapture(exec: DbExec, source: ResourceChangeSource, consumer: string): Promise<boolean>;
+export declare function subscribeResourceChangeConsumer(exec: DbExec, source: Pick<ResourceChangeSource, "app" | "resourceType">, consumer: string): Promise<void>;
+/**
+ * True when every generated trigger exists on the source table and fires.
+ * A disabled trigger (`ALTER TABLE ... DISABLE TRIGGER`) records nothing, so
+ * it counts as missing.
+ */
+export declare function resourceChangeCaptureInstalled(exec: DbExec, source: ResourceChangeSource): Promise<boolean>;
+export interface ResourceChangeFeed {
+    consumer: string;
+    app: string;
+    resourceType: string;
+}
+export interface ClaimedResourceChange {
+    resourceId: string;
+    seq: string;
+    attempts: number;
+}
+/**
+ * A condition a consumer attaches to its claim, complete, and fail
+ * statements. It is checked inside each statement, so once it stops holding,
+ * those statements change nothing. Search uses it so a process running an
+ * older index version can't consume changes queued for a newer one.
+ */
+export interface ResourceChangeFence {
+    sql: string;
+    args: unknown[];
+}
+/**
+ * Leases up to `limit` ready changes, oldest first. Rows another claimant is
+ * locking right now are skipped, and the lease expires on its own if this
+ * process dies, so there is nothing to clean up.
+ */
+export declare function claimResourceChanges(exec: DbExec, feed: ResourceChangeFeed, limit: number, fence?: ResourceChangeFence): Promise<ClaimedResourceChange[]>;
+export declare function compareSeq(a: string, b: string): number;
+/**
+ * Deletes processed changes, but only rows whose seq is still the one that
+ * was claimed. A change recorded meanwhile stays for the next pass.
+ */
+export declare function completeResourceChanges(exec: DbExec, feed: ResourceChangeFeed, changes: readonly ClaimedResourceChange[], fence?: ResourceChangeFence): Promise<void>;
+/**
+ * Backs off failed changes, doubling the wait up to five minutes. After the
+ * last allowed attempt a change is also marked failed, which a consumer can
+ * report, but it keeps being retried: a failure that was only temporary
+ * clears itself, and a later write to the resource starts it fresh.
+ */
+export declare function failResourceChanges(exec: DbExec, feed: ResourceChangeFeed, changes: readonly ClaimedResourceChange[], fence?: ResourceChangeFence): Promise<void>;
+/**
+ * Two boolean columns for a caller's own SELECT, so checking the feed costs
+ * no extra round trip: `pending` while any change is waiting, leased, or
+ * backing off, and `failing` while any has used up its attempts.
+ */
+export declare function resourceChangeBacklogColumns(feed: ResourceChangeFeed): {
+    sql: string;
+    args: unknown[];
+};
+/** True while any change at or below `seq` is still pending for this feed. */
+export declare function hasPendingResourceChanges(exec: DbExec, feed: ResourceChangeFeed, options?: {
+    atOrBelowSeq?: string;
+}): Promise<boolean>;
+/**
+ * Records a change for every row of the source table, for this consumer
+ * only, and returns a seq at or above every one it assigned. Consumers use
+ * it to rebuild from scratch.
+ *
+ * A change already queued is replaced by a fresh one, even if another
+ * process has it leased or it has failed: that work was done for the old
+ * consumer state, so it must not complete what the rebuild queued.
+ */
+export declare function enqueueAllResourceChanges(exec: DbExec, source: ResourceChangeSource, consumer: string, reason: string): Promise<string>;
+type DrainHook = () => Promise<unknown>;
+/**
+ * Registers work to run right after a request that changed data, while the
+ * database is known to be awake. Returns an unregister function.
+ */
+export declare function registerAfterWriteDrain(id: string, drain: DrainHook): () => void;
+/**
+ * Runs registered after-write drains without delaying the caller. On
+ * serverless the request's `waitUntil` keeps the function alive for them.
+ */
+export declare function runAfterWriteDrains(waitUntil?: (promise: Promise<unknown>) => void): void;
+export {};