@agent-native/core 0.164.4 → 0.164.12

package/dist/integrations/scope-store.js

@@ -20,7 +20,7 @@ const TRUST_VALUES = new Set([
     "external_shared",
     "unknown",
 ]);
-async function ensureTable() {
+export async function ensureTable() {
     if (!initPromise) {
         initPromise = (async () => {
             const db = getDbExec();

package/dist/integrations/thread-mapping-store.d.ts

@@ -1,3 +1,4 @@
+export declare function ensureTable(): Promise<void>;
 export interface ThreadMapping {
     platform: string;
     externalThreadId: string;

package/dist/integrations/thread-mapping-store.js

@@ -1,7 +1,7 @@
 import { getDbExec, isPostgres, intType } from "../db/client.js";
 import { ensureTableExists } from "../db/ddl-guard.js";
 let _initPromise;
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/integrations/usage-budget-store.d.ts

@@ -53,6 +53,7 @@ export interface IntegrationBudgetThresholdEvent {
     observedMicros: number;
     createdAt: number;
 }
+export declare function ensureTables(): Promise<void>;
 export declare function saveIntegrationUsageBudget(input: {
     subject: IntegrationBudgetSubject;
     period: IntegrationBudgetPeriod;

package/dist/integrations/usage-budget-store.js

@@ -5,7 +5,7 @@ let initPromise;
 let transactionTail = Promise.resolve();
 /** All budget values are integer millionths of one billing currency unit. */
 export const INTEGRATION_BUDGET_COST_UNIT = "currency_micros";
-async function ensureTables() {
+export async function ensureTables() {
     if (!initPromise) {
         initPromise = (async () => {
             const db = getDbExec();

package/dist/jobs/background-automation-runner.js

@@ -2,11 +2,12 @@ import { collectFinalResponseTextFromAgentEvents } from "../a2a/response-text.js
 import { getStoredModelForEngine, normalizeModelForEngine, resolveEngine, } from "../agent/engine/index.js";
 import { actionsToEngineTools, filterInitialEngineTools, getOwnerActiveApiKey, } from "../agent/production-agent.js";
 import { runAgentLoopDirectWithSoftTimeout } from "../agent/run-loop-with-resume.js";
-import { resolveRunSoftTimeoutMs, startRun } from "../agent/run-manager.js";
+import { resolveRunSoftTimeoutMs, startRun, } from "../agent/run-manager.js";
 import { claimBackgroundRun, insertRun } from "../agent/run-store.js";
+import { buildAssistantMessage, buildUserMessage, extractThreadMeta, foldAssistantTurn, upsertUserMessage, } from "../agent/thread-data-builder.js";
 import { attachToolSearch } from "../agent/tool-search.js";
 import { resolveAutomationExecutionIdentity, } from "../automations/service.js";
-import { createThread } from "../chat-threads/store.js";
+import { createThread, getThread, updateThreadData, withThreadDataLock, } from "../chat-threads/store.js";
 import { queryOrgMembers } from "../org/context.js";
 import { organizationIdFromResourceOwner, organizationResourceOwner, } from "../resources/store.js";
 import { runWithRequestContext, } from "../server/request-context.js";
@@ -204,6 +205,80 @@ async function recordRunThread(historyId, threadId, runId) {
         console.error(`[automations] Could not attach thread ${threadId} to run ${historyId}:`, err);
     }
 }
+function backgroundAutomationPersistFailure(input) {
+    if (input.hardTimedOut) {
+        return {
+            message: `Background automation timed out after ${BACKGROUND_RUN_HARD_TIMEOUT_MS / 60_000} minutes`,
+            errorCode: "background_automation_hard_timeout",
+        };
+    }
+    const cutOffReason = backgroundRunCutOffReason(input.run);
+    if (!cutOffReason)
+        return undefined;
+    return {
+        message: `Background automation was cut off before finishing (${cutOffReason})`,
+        errorCode: "background_automation_cut_off",
+    };
+}
+/**
+ * Chat opens `/chat/:threadId` from `thread_data`, not `agent_run_events`.
+ * Persist before the cut-off/status reject so a failed run still has a
+ * visible trace. Keep the scheduler title — `extractThreadMeta` would
+ * otherwise replace `Job: …` with the prompt excerpt.
+ *
+ * Cut-off and hard-abort turns have no terminal error event of their own.
+ * `suppressInternalContinuation` also drops `auto_continue`, so persist
+ * would otherwise store a completed assistant message. Append a
+ * non-recoverable error and skip that suppress so Open thread shows the
+ * incomplete state.
+ */
+async function persistBackgroundAutomationTurn(input) {
+    await withThreadDataLock(input.threadId, async () => {
+        const row = await getThread(input.threadId);
+        if (!row) {
+            throw new Error(`Background automation thread ${input.threadId} was not found while saving run ${input.run.runId}.`);
+        }
+        let repo;
+        try {
+            repo = JSON.parse(row.threadData || "{}");
+        }
+        catch {
+            throw new Error(`Background automation thread ${input.threadId} has unreadable thread data.`);
+        }
+        if (!repo || typeof repo !== "object" || Array.isArray(repo)) {
+            throw new Error(`Background automation thread ${input.threadId} has unreadable thread data.`);
+        }
+        repo = upsertUserMessage(repo, buildUserMessage({ text: input.prompt, runId: input.run.runId }));
+        const events = [...(input.run.events ?? [])];
+        if (input.persistFailure) {
+            events.push({
+                seq: events.length,
+                event: {
+                    type: "error",
+                    error: input.persistFailure.message,
+                    errorCode: input.persistFailure.errorCode,
+                    recoverable: false,
+                },
+            });
+        }
+        const assistantMsg = buildAssistantMessage(events, input.run.runId, {
+            suppressInternalContinuation: !input.persistFailure,
+            turnId: input.run.turnId,
+            runDurationMs: Number.isFinite(input.run.startedAt)
+                ? Math.max(0, Date.now() - input.run.startedAt)
+                : undefined,
+        });
+        if (assistantMsg) {
+            repo = foldAssistantTurn(repo, assistantMsg, {
+                runId: input.run.runId,
+                turnId: input.run.turnId,
+            });
+        }
+        const meta = extractThreadMeta(repo);
+        const messages = repo.messages;
+        await updateThreadData(input.threadId, JSON.stringify(repo), input.threadTitle || row.title, meta.preview || row.preview, Array.isArray(messages) ? messages.length : 0);
+    });
+}
 async function recordRunOutcome(historyId, status, error) {
     if (!historyId)
         return;
@@ -282,6 +357,7 @@ async function executeBackgroundAutomation(options, deps, historyId) {
         const usageRef = { current: null };
         let responseText = "";
         let hardAbortTimer = null;
+        let hardTimedOut = false;
         // This runner executes in-process, synchronously — there is no HTTP
         // self-dispatch to a separate worker. Self-claim the row into
         // 'background-processing' right away, exactly like a genuine HTTP
@@ -331,9 +407,29 @@ async function executeBackgroundAutomation(options, deps, historyId) {
                     clearTimeout(hardAbortTimer);
                     hardAbortTimer = null;
                 }
-                const cutOffReason = backgroundRunCutOffReason(run);
-                if (cutOffReason) {
-                    reject(new Error(`Background automation was cut off before finishing (${cutOffReason})`));
+                const persistFailure = backgroundAutomationPersistFailure({
+                    run,
+                    hardTimedOut,
+                });
+                try {
+                    await persistBackgroundAutomationTurn({
+                        threadId: thread.id,
+                        threadTitle,
+                        prompt,
+                        run,
+                        persistFailure,
+                    });
+                }
+                catch (err) {
+                    reject(err instanceof Error ? err : new Error(String(err)));
+                    throw err;
+                }
+                // Hard timeout owns the runner reject so a serverless return
+                // waits for this persist via `activeRun.finalized`.
+                if (hardTimedOut)
+                    return;
+                if (persistFailure) {
+                    reject(new Error(persistFailure.message));
                     return;
                 }
                 if (run.status !== "completed") {
@@ -350,10 +446,16 @@ async function executeBackgroundAutomation(options, deps, historyId) {
             });
             hardAbortTimer = setTimeout(() => {
                 hardAbortTimer = null;
-                if (activeRun.status === "running") {
-                    activeRun.abort.abort("background_automation_hard_timeout");
-                    reject(new Error(`Background automation timed out after ${BACKGROUND_RUN_HARD_TIMEOUT_MS / 60_000} minutes`));
-                }
+                if (activeRun.status !== "running")
+                    return;
+                hardTimedOut = true;
+                activeRun.abort.abort("background_automation_hard_timeout");
+                const timeoutError = new Error(`Background automation timed out after ${BACKGROUND_RUN_HARD_TIMEOUT_MS / 60_000} minutes`);
+                void activeRun.finalized
+                    .catch(() => { })
+                    .then(() => {
+                    reject(timeoutError);
+                });
             }, BACKGROUND_RUN_HARD_TIMEOUT_MS);
         }).finally(() => {
             if (hardAbortTimer) {

package/dist/jobs/run-history.d.ts

@@ -36,6 +36,7 @@ export interface StartAutomationRunInput {
 /** Authoritative release-time schema for durable automation history. */
 export declare const AUTOMATION_RUN_MIGRATIONS: MigrationEntry[];
 export declare function runAutomationRunMigrations(nitroApp: unknown): Promise<void>;
+export declare function ensureTable(): Promise<void>;
 /**
  * Record an automation execution. Manual runs create the row before dispatch,
  * so `dispatchPending` distinguishes that durable handoff from a run that has

package/dist/jobs/run-history.js

@@ -83,7 +83,7 @@ export async function runAutomationRunMigrations(nitroApp) {
     })(nitroApp);
 }
 let _initPromise;
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/jobs/scheduler-health.d.ts

@@ -13,6 +13,7 @@ export interface AutomationSchedulerHealth {
     runtime: string | null;
     updatedAt: number | null;
 }
+export declare function ensureHealthTable(): Promise<void>;
 /** Claim one recurring scheduler across all deployments of an app. */
 export declare function acquireAutomationSchedulerLease(input?: {
     appId?: string;

package/dist/jobs/scheduler-health.js

@@ -55,7 +55,7 @@ function rowIdForScope(appId, orgId) {
     return `${appId}:${orgId ?? "global"}`;
 }
 let initPromise;
-async function ensureHealthTable() {
+export async function ensureHealthTable() {
     if (!initPromise) {
         initPromise = (async () => {
             const createSql = `

package/dist/mcp/approval-store.d.ts

@@ -1,3 +1,4 @@
+export declare function ensureApprovalTable(): Promise<void>;
 export interface McpApprovalGrant {
     nonce: string;
     callerKey: string;

package/dist/mcp/approval-store.js

@@ -1,7 +1,7 @@
 import { getDbExec, intType, isPostgres } from "../db/client.js";
 import { ensureTableExists } from "../db/ddl-guard.js";
 let initPromise;
-async function ensureApprovalTable() {
+export async function ensureApprovalTable() {
     if (!initPromise) {
         initPromise = (async () => {
             const createSql = `

package/dist/mcp/connect-store.d.ts

@@ -41,6 +41,7 @@ export declare const MAX_TOKEN_TTL_DAYS = 365;
  */
 export declare const DEVICE_START_MAX = 20;
 export declare const DEVICE_START_WINDOW_MS = 60000;
+export declare function ensureTable(): Promise<void>;
 export interface MintedTokenRow {
     id: string;
     jti: string;

package/dist/mcp/connect-store.js

@@ -45,7 +45,7 @@ export const MAX_TOKEN_TTL_DAYS = 365;
  */
 export const DEVICE_START_MAX = 20;
 export const DEVICE_START_WINDOW_MS = 60_000;
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/mcp/oauth-store.d.ts

@@ -19,6 +19,7 @@ export declare const MCP_OAUTH_ACCESS_TOKEN_TTL_SECONDS: number;
 export declare const MCP_OAUTH_REFRESH_TOKEN_TTL_MS: number;
 export declare const MCP_OAUTH_REGISTER_MAX = 60;
 export declare const MCP_OAUTH_REGISTER_WINDOW_MS = 60000;
+export declare function ensureTable(): Promise<void>;
 export interface OAuthClientRow {
     clientId: string;
     clientName: string | null;

package/dist/mcp/oauth-store.js

@@ -65,7 +65,7 @@ export const MCP_OAUTH_ACCESS_TOKEN_TTL_SECONDS = _accessTokenTtl.seconds;
 export const MCP_OAUTH_REFRESH_TOKEN_TTL_MS = 365 * 24 * 60 * 60_000;
 export const MCP_OAUTH_REGISTER_MAX = 60;
 export const MCP_OAUTH_REGISTER_WINDOW_MS = 60_000;
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/notifications/store.d.ts

@@ -1,4 +1,5 @@
 import type { Notification, NotificationSeverity } from "./types.js";
+export declare function ensureTable(): Promise<void>;
 export interface InsertNotificationInput {
     owner: string;
     severity: NotificationSeverity;

package/dist/notifications/store.js

@@ -11,7 +11,7 @@ function normalizeLimit(value, fallback = 50) {
         return fallback;
     return Math.min(Math.floor(value), 200);
 }
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

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

@@ -1,3 +1,4 @@
+export declare function ensureTable(): Promise<void>;
 export declare function getOAuthTokens(provider: string, accountId: string, owner?: string): Promise<Record<string, unknown> | null>;
 export interface OAuthTokenSnapshot {
     tokens: Record<string, unknown>;

package/dist/oauth-tokens/store.js

@@ -51,7 +51,7 @@ function isDuplicateColumnError(err) {
         message.includes("duplicate column") ||
         message.includes("already exists"));
 }
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/observability/routes.d.ts

@@ -41,27 +41,27 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
+    error?: undefined;
+    ok?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
+} | {
     error?: undefined;
     ok?: undefined;
-} | {
     summary?: undefined;
     spans?: undefined;
     id: string;
-    error?: undefined;
-    ok?: undefined;
 } | {
+    ok?: undefined;
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     error: any;
-    ok?: undefined;
 } | {
+    error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
-    error?: undefined;
     ok: boolean;
 }>>;

package/dist/progress/routes.d.ts

@@ -15,6 +15,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;

package/dist/progress/store.d.ts

@@ -1,5 +1,6 @@
 import type { AgentRun, ListRunsOptions, StartRunInput, UpdateProgressInput } from "./types.js";
 export declare const DEFAULT_PROGRESS_RUN_STALE_MS: number;
+export declare function ensureTable(): Promise<void>;
 export declare function insertRun(input: StartRunInput): Promise<AgentRun>;
 export declare function getRun(id: string, owner: string): Promise<AgentRun | null>;
 export declare function updateRun(id: string, owner: string, input: UpdateProgressInput): Promise<AgentRun | null>;

package/dist/progress/store.js

@@ -21,7 +21,7 @@ function resolveProgressRunStaleMs() {
     }
     return DEFAULT_PROGRESS_RUN_STALE_MS;
 }
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

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

@@ -75,7 +75,6 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
-    message?: undefined;
     id?: undefined;
     provider?: undefined;
     deleted?: undefined;
@@ -92,18 +91,18 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     found?: undefined;
     registered?: undefined;
     label?: undefined;
-} | {
     message?: undefined;
-    count?: undefined;
+} | {
     id?: undefined;
+    count?: undefined;
     deleted?: undefined;
     providers?: undefined;
     found: boolean;
     provider: import("../custom-registry.js").CustomProviderConfig;
     registered?: undefined;
     label?: undefined;
-} | {
     message?: undefined;
+} | {
     count?: undefined;
     provider?: undefined;
     deleted?: undefined;
@@ -112,8 +111,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     id: string;
     registered?: undefined;
     label?: undefined;
-} | {
     message?: undefined;
+} | {
     count?: undefined;
     provider?: undefined;
     providers?: undefined;
@@ -122,6 +121,7 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     id: string;
     registered?: undefined;
     label?: undefined;
+    message?: undefined;
 } | {
     count?: undefined;
     provider?: undefined;

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

@@ -311,6 +311,7 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         notes?: string | undefined;
         scope?: "org" | "user" | undefined;
     }, {
+        message?: undefined;
         deleted?: undefined;
         id?: undefined;
         providers: {
@@ -327,8 +328,8 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         found?: undefined;
         registered?: undefined;
         label?: undefined;
-        message?: undefined;
     } | {
+        message?: undefined;
         deleted?: undefined;
         id?: undefined;
         providers?: undefined;
@@ -337,8 +338,8 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         provider: import("../custom-registry.js").CustomProviderConfig;
         registered?: undefined;
         label?: undefined;
-        message?: undefined;
     } | {
+        message?: undefined;
         deleted?: undefined;
         providers?: undefined;
         count?: undefined;
@@ -347,8 +348,8 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         id: string;
         registered?: undefined;
         label?: undefined;
-        message?: undefined;
     } | {
+        message?: undefined;
         providers?: undefined;
         count?: undefined;
         provider?: undefined;
@@ -357,7 +358,6 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         id: string;
         registered?: undefined;
         label?: undefined;
-        message?: undefined;
     } | {
         deleted?: undefined;
         providers?: undefined;

package/dist/provider-api/corpus-jobs-store.d.ts

@@ -62,6 +62,7 @@ export interface UpdateProviderCorpusJobOptions {
     error?: string | null;
     nextResumeAt?: number | null;
 }
+export declare function ensureTables(): Promise<void>;
 export declare function createProviderCorpusJob(options: CreateProviderCorpusJobOptions): Promise<ProviderCorpusJobRecord>;
 export declare function getProviderCorpusJob(options: {
     id: string;

package/dist/provider-api/corpus-jobs-store.js

@@ -9,7 +9,7 @@
 import { getDbExec, intType, isPostgres } from "../db/client.js";
 import { ensureTableExists, ensureIndexExists } from "../db/ddl-guard.js";
 let initPromise;
-async function ensureTables() {
+export async function ensureTables() {
     if (!initPromise) {
         initPromise = (async () => {
             const db = getDbExec();

package/dist/provider-api/custom-registry.d.ts

@@ -67,6 +67,7 @@ export interface UpsertCustomProviderArgs {
      */
     orgRole: string | null;
 }
+export declare function ensureTable(): Promise<void>;
 /**
  * Validate and normalise a custom provider base URL. Throws when the URL is
  * invalid, uses a non-http(s) scheme, or resolves to a private/internal host.

package/dist/provider-api/custom-registry.js

@@ -42,7 +42,7 @@ const CREATE_SQL = `CREATE TABLE IF NOT EXISTS custom_api_providers (
   PRIMARY KEY (scope, scope_id, id)
 )`;
 let _initPromise;
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/provider-api/quota-governor.d.ts

@@ -50,3 +50,4 @@ export declare function createProviderRequestDedupeKey(input: {
 }): string | undefined;
 export declare function executeWithProviderQuota<T>(options: ExecuteWithProviderQuotaOptions<T>): Promise<T>;
 export declare function resetProviderQuotaStateForTests(): void;
+export declare function ensureCooldownTable(): Promise<void>;

package/dist/provider-api/quota-governor.js

@@ -244,7 +244,7 @@ function persistenceTemporarilyUnavailable() {
     return Boolean(state.persistenceUnavailableUntil &&
         state.persistenceUnavailableUntil > Date.now());
 }
-async function ensureCooldownTable() {
+export async function ensureCooldownTable() {
     if (!shouldPersistCooldowns())
         return;
     if (persistenceTemporarilyUnavailable())

package/dist/provider-api/staged-datasets-store.d.ts

@@ -14,6 +14,7 @@
  */
 export declare const MAX_ROWS_PER_APP = 200000;
 export declare const MAX_BYTES_PER_APP: number;
+export declare function ensureTables(): Promise<void>;
 export interface StagedDatasetMeta {
     id: string;
     appId: string;

package/dist/provider-api/staged-datasets-store.js

@@ -23,7 +23,7 @@ export const MAX_BYTES_PER_APP = 50 * 1024 * 1024; // 50 MB
 // Table initialisation
 // ---------------------------------------------------------------------------
 let _initPromise;
-async function ensureTables() {
+export async function ensureTables() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const db = getDbExec();

package/dist/resources/handlers.d.ts

@@ -48,11 +48,11 @@ export declare function handleUpdateResource(event: any): Promise<import("./stor
 }>;
 /** DELETE /_agent-native/resources/:id — delete a resource */
 export declare function handleDeleteResource(event: any): Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>;
 /** POST /_agent-native/resources/upload — upload a file as a resource */
 export declare function handleUploadResource(event: any): Promise<import("./store.js").Resource | {
@@ -73,10 +73,10 @@ export declare function handleUploadResource(event: any): Promise<import("./stor
     runId: string | null;
     expiresAt: number | null;
     metadata: string | null;
-    error?: undefined;
     url: string;
     provider: string;
     storageSetupRequired?: undefined;
+    error?: undefined;
 } | {
     error: string;
     storageSetupRequired: boolean;

package/dist/resources/store.d.ts

@@ -94,6 +94,7 @@ export interface EffectiveResourceContext {
 export declare const LOCAL_WORKSPACE_RESOURCE_METADATA_SOURCE = "local-workspace-resource";
 export declare function canWriteLocalWorkspaceResourcePath(resourcePath: string): Promise<boolean>;
 export { isLocalWorkspaceResourceId };
+export declare function ensureTable(): Promise<void>;
 /**
  * Seed personal AGENTS.md and LEARNINGS.md for a user if they don't exist.
  * Called when listing resources or from the agent chat plugin.

package/dist/resources/store.js

@@ -601,7 +601,7 @@ function scheduleExpiredAgentScratchCleanup(client) {
         console.warn("[resources] expired agent-scratch cleanup failed; will retry on a later read:", err?.message ?? err);
     });
 }
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = _doEnsureTable().catch((err) => {
             // Don't cache the rejection — let the next caller retry a fresh init.

package/dist/scripts/dev/index.js

@@ -6,6 +6,7 @@
  * registered in production.
  */
 import { createCodingToolRegistry } from "../../coding-tools/index.js";
+import { getRequestRunContext } from "../../server/request-context.js";
 import { normalizeDatabaseToolsMode, } from "../db/tool-mode.js";
 import { dbExecToolParameters } from "../db/tool-schemas.js";
 import { tool as listFilesTool, run as listFilesRun } from "./list-files.js";
@@ -67,6 +68,19 @@ function blockedDatabaseActionFromBash(command, databaseToolsMode) {
     }
     return null;
 }
+function unauthorizedActionFromBash(command, allowedActionNames) {
+    if (!allowedActionNames)
+        return null;
+    const allowed = new Set(allowedActionNames);
+    const actionCommands = command.matchAll(/\b(?:pnpm|npm|yarn|bun)(?:\s+\S+){0,4}\s+action\s+([a-z][a-z0-9-]*)\b/g);
+    for (const match of actionCommands) {
+        const actionName = match[1];
+        if (actionName && !allowed.has(actionName)) {
+            return `Error: action "${actionName}" is not available in this request's action surface.`;
+        }
+    }
+    return null;
+}
 /**
  * Creates the dev-mode script registry with shared bash/read/edit/write
  * coding tools and database tools. Call this and merge with your app's registry
@@ -200,7 +214,7 @@ export async function createDevScriptRegistry(options = {}) {
     const codingEntries = createCodingToolRegistry({
         cwd: process.cwd(),
         bashThrowsOnNonZero: true,
-        beforeBash: ({ command }) => blockedDatabaseActionFromBash(command, databaseToolsMode),
+        beforeBash: ({ command }) => unauthorizedActionFromBash(command, getRequestRunContext()?.allowedActionNames) ?? blockedDatabaseActionFromBash(command, databaseToolsMode),
     });
     const legacyEntries = options.legacyAliases
         ? {

package/dist/search/index.js

@@ -48,6 +48,9 @@ export function assertPgVectorAvailable(postgres = isPostgres()) {
     if (!postgres)
         throw new Error(PGVECTOR_REQUIRED_MESSAGE);
 }
+// guard:allow-unreleased-schema - the table name is derived at call time from
+// the search namespace and embedding dimensions (`${namespace}_vectors${suffix}`),
+// so the set of tables is not known at release time and cannot be pre-created.
 export async function ensurePgVectorIndex(db, dimensions, options) {
     const resolved = pgVectorOptions(options);
     const names = searchNamespaceIdentifiers(resolved.namespace, dimensions);