@agent-native/core 0.164.3 → 0.164.11

package/dist/integrations/identity-links-store.js

@@ -32,7 +32,7 @@ const INDEXES = [
       ON ${TABLE}(org_id, user_email)`,
     ],
 ];
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/integrations/installations-store.d.ts

@@ -83,6 +83,7 @@ export interface IntegrationInstallationUpdate {
     lastHealthyAt?: number | null;
     tokenExpiresAt?: number | null;
 }
+export declare function ensureTable(): Promise<void>;
 /**
  * Create or refresh a managed install. Re-installs may rotate tokens inside
  * the same owner/org scope, but cannot silently move an existing provider

package/dist/integrations/installations-store.js

@@ -61,7 +61,7 @@ const INDEXES = [
         `CREATE INDEX IF NOT EXISTS idx_integration_installations_org ON ${TABLE}(org_id, updated_at)`,
     ],
 ];
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/integrations/remote-commands-store.d.ts

@@ -1,4 +1,5 @@
 import type { ComputerCommandEnvelope, ComputerOperationClass, RemoteCommand, RemoteCommandKind } from "./remote-types.js";
+export declare function ensureTable(): Promise<void>;
 export declare function isRemoteCommandKind(value: unknown): value is RemoteCommandKind;
 export declare function enqueueRemoteCommand(input: {
     deviceId: string;

package/dist/integrations/remote-commands-store.js

@@ -16,7 +16,7 @@ const REMOTE_COMMAND_KINDS = [
     "status",
 ];
 const TERMINAL_STATUSES = new Set(["completed", "failed"]);
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/integrations/remote-devices-store.d.ts

@@ -1,4 +1,5 @@
 import type { PublicRemoteDevice, RemoteComputerCapabilities, RemoteDevice, RemoteDeviceMetadata, RemoteExecutionCapabilities } from "./remote-types.js";
+export declare function ensureTable(): Promise<void>;
 export declare function toPublicRemoteDevice(device: RemoteDevice): PublicRemoteDevice;
 export declare function getRemoteComputerCapabilities(device: Pick<RemoteDevice, "metadata">): RemoteComputerCapabilities | null;
 export declare function getRemoteExecutionCapabilities(device: Pick<RemoteDevice, "metadata">): RemoteExecutionCapabilities | null;

package/dist/integrations/remote-devices-store.js

@@ -1,7 +1,7 @@
 import { getDbExec, intType, isPostgres, retryOnDdlRace, } from "../db/client.js";
 import { ensureColumnExists, ensureIndexExists, 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/remote-push-store.d.ts

@@ -1,4 +1,5 @@
 import type { PublicRemotePushRegistration, RemotePushNotification, RemotePushRegistration } from "./remote-types.js";
+export declare function ensureTables(): Promise<void>;
 export declare function toPublicRemotePushRegistration(registration: RemotePushRegistration): PublicRemotePushRegistration;
 export declare function upsertRemotePushRegistration(input: {
     ownerEmail: string;

package/dist/integrations/remote-push-store.js

@@ -43,7 +43,7 @@ function buildCreateNotificationsSql() {
   )
 `;
 }
-async function ensureTables() {
+export async function ensureTables() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/integrations/remote-run-events-store.d.ts

@@ -1,4 +1,5 @@
 import type { RemoteLiveViewEvent, RemoteRunEvent } from "./remote-types.js";
+export declare function ensureTable(): Promise<void>;
 export declare function insertRemoteRunEvents(input: {
     deviceId: string;
     remoteRunId: string;

package/dist/integrations/remote-run-events-store.js

@@ -18,7 +18,7 @@ function buildCreateSql() {
   )
 `;
 }
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/integrations/scope-store.d.ts

@@ -42,6 +42,7 @@ export interface SaveIntegrationScopeInput extends IntegrationScopeKey {
     defaultModel?: string | null;
     policy?: Partial<IntegrationScopePolicy>;
 }
+export declare function ensureTable(): Promise<void>;
 /** A stable, non-secret subject key suitable for a scope budget. */
 export declare function integrationScopeSubjectKey(key: IntegrationScopeKey): string;
 export declare function getIntegrationScope(keyInput: IntegrationScopeKey, accessInput: IntegrationScopeAccess): Promise<IntegrationScope | null>;

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/routes.d.ts

@@ -13,13 +13,13 @@
 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;
+    error?: undefined;
 } | {
     count?: undefined;
     updated?: undefined;
@@ -28,6 +28,6 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
 } | {
     count?: undefined;
     updated?: undefined;
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;

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

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.