@agent-native/core 0.146.8 → 0.148.0

package/dist/coding-tools/tool-orchestration.js

@@ -0,0 +1,107 @@
+import { executeSandboxCode, } from "./run-code.js";
+const DEFAULT_TIMEOUT_MS = 60_000;
+const MAX_TIMEOUT_MS = 120_000;
+const DEFAULT_MAX_OUTPUT_CHARS = 50_000;
+const MAX_OUTPUT_CHARS = 100_000;
+const DEFAULT_MAX_TOOL_CALLS = 32;
+const MAX_TOOL_CALLS = 128;
+/**
+ * Create the bounded read-only orchestration tool.
+ *
+ * This deliberately has a separate registry entry from run-code. The latter
+ * retains its existing workspace staging and background-execution contract;
+ * this entry is for short fan-out, reduction, and aggregation over tools that
+ * the host can prove are read-only for the supplied arguments.
+ */
+export function createToolOrchestrationEntry(getActions) {
+    return {
+        readOnly: true,
+        allowInPlanMode: false,
+        timeoutMs: MAX_TIMEOUT_MS,
+        maxResultChars: MAX_OUTPUT_CHARS,
+        tool: {
+            description: [
+                "Run a bounded JavaScript orchestration script in the existing sandbox.",
+                "Use toolSearch(query) to discover read-only or conditionally read-only tools, then toolCall(name, args) to fan out, join, filter, and aggregate their results without putting every intermediate payload into chat. The host rechecks conditional policies against each argument object.",
+                "The host rechecks every child call: mutating actions, hidden actions, provider writes, non-GET/HEAD web requests, staging, file saves, and workspace writes are rejected. Call mutations directly as native tools.",
+                "The orchestration sandbox has no background mode, a strict child-tool-call budget, and a 20-page cap on each provider fetchAllPages call. It is a bounded orchestration path, not a general-purpose replacement for run-code.",
+                "Available globals: toolSearch(query?, options?), toolCall(name, args?), providerFetch(provider, path, init?), providerFetchAll(...), providerSearchAll(...), webFetch(url, init?), webRead(url, init?), workspaceRead(path, opts?), workspaceReadMeta(path, opts?), workspaceList(prefix?), and appAction(name, args?) for eligible read-only actions.",
+                "Print only the compact result needed by the conversation with console.log().",
+            ].join(" "),
+            parameters: {
+                type: "object",
+                properties: {
+                    code: {
+                        type: "string",
+                        description: "JavaScript source to execute. ESM syntax and top-level await are supported.",
+                    },
+                    timeoutMs: {
+                        type: "number",
+                        description: `Execution timeout in milliseconds. Default: ${DEFAULT_TIMEOUT_MS}; max: ${MAX_TIMEOUT_MS}.`,
+                    },
+                    maxOutputChars: {
+                        type: "number",
+                        description: `Maximum combined stdout+stderr characters. Default: ${DEFAULT_MAX_OUTPUT_CHARS}; max: ${MAX_OUTPUT_CHARS}.`,
+                    },
+                    maxToolCalls: {
+                        type: "number",
+                        description: `Maximum bridged child-tool calls. Default: ${DEFAULT_MAX_TOOL_CALLS}; max: ${MAX_TOOL_CALLS}.`,
+                    },
+                },
+                required: ["code"],
+            },
+        },
+        run: async (args, context) => {
+            if (args.background || args.executionId) {
+                return "Error: tool-orchestration is foreground-only and does not support background or polling arguments. Use run-code for durable long-running execution.";
+            }
+            const code = typeof args.code === "string" ? args.code : "";
+            if (!code.trim())
+                return "Error: code is required.";
+            const requestedTimeout = Number(args.timeoutMs);
+            const timeoutMs = Number.isFinite(requestedTimeout) && requestedTimeout > 0
+                ? Math.min(requestedTimeout, MAX_TIMEOUT_MS)
+                : DEFAULT_TIMEOUT_MS;
+            const requestedOutput = Number(args.maxOutputChars);
+            const maxOutputChars = Number.isFinite(requestedOutput) && requestedOutput > 0
+                ? Math.min(requestedOutput, MAX_OUTPUT_CHARS)
+                : DEFAULT_MAX_OUTPUT_CHARS;
+            const requestedCalls = Number(args.maxToolCalls);
+            const maxToolCalls = Number.isFinite(requestedCalls) && requestedCalls > 0
+                ? Math.min(Math.floor(requestedCalls), MAX_TOOL_CALLS)
+                : DEFAULT_MAX_TOOL_CALLS;
+            const result = await executeSandboxCode({
+                code,
+                timeoutMs,
+                getActions,
+                mode: "tool-orchestration",
+                maxToolCalls,
+                context,
+            });
+            return formatResult(result, timeoutMs, maxOutputChars);
+        },
+    };
+}
+function formatResult(result, timeoutMs, maxOutputChars) {
+    const combined = [
+        result.stdout ? `stdout:\n${result.stdout}` : "",
+        result.stderr ? `stderr:\n${result.stderr}` : "",
+    ]
+        .filter(Boolean)
+        .join("\n\n") || "(no output)";
+    const lines = [];
+    if (result.timedOut)
+        lines.push(`timedOut: true (${timeoutMs}ms)`);
+    if (result.exitCode !== 0 && result.exitCode !== null) {
+        lines.push(`exitCode: ${result.exitCode}`);
+    }
+    if (result.bridgeToolsUsed.length) {
+        lines.push(`bridgeToolsUsed: ${result.bridgeToolsUsed.join(", ")}`);
+    }
+    lines.push(combined);
+    const full = lines.join("\n\n");
+    if (full.length <= maxOutputChars)
+        return full;
+    const truncated = full.slice(0, maxOutputChars);
+    return `${truncated}\n\n...[truncated ${(full.length - maxOutputChars).toLocaleString()} chars]`;
+}

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<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

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

@@ -1,4 +1,5 @@
 import { collectFinalResponseTextFromAgentEvents } from "../a2a/response-text.js";
+import { createBuilderEngine } from "../agent/engine/builder-engine.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";
@@ -9,6 +10,7 @@ import { resolveAutomationExecutionIdentity, } from "../automations/service.js";
 import { createThread } from "../chat-threads/store.js";
 import { queryOrgMembers } from "../org/context.js";
 import { organizationIdFromResourceOwner, organizationResourceOwner, } from "../resources/store.js";
+import { resolveBuilderCredentialsDetailed } from "../server/credential-provider.js";
 import { runWithRequestContext, } from "../server/request-context.js";
 import { attachAutomationRunThread, finishAutomationRun, startAutomationRun, } from "./run-history.js";
 const BACKGROUND_RUN_STUCK_MS = 10 * 60_000;
@@ -236,18 +238,33 @@ async function executeBackgroundAutomation(options, deps, historyId) {
         const availableTools = actionsToEngineTools(actions);
         const tools = filterInitialEngineTools(availableTools, initialToolNames);
         const userApiKey = await getOwnerActiveApiKey(ownerEmail);
-        const engine = deps.engine ??
+        const resolvedEngine = deps.engine ??
             (await resolveEngine({
                 apiKey: userApiKey ?? deps.apiKey,
                 appId: deps.appId,
             }));
+        // The run manager invokes its detached callback after the scheduler's
+        // setup stack has yielded. Capture the verified Builder pair while the
+        // owner/org identity is explicit, then keep it on the engine so a
+        // concurrent serverless run cannot make this call look unauthenticated.
+        const engine = !deps.engine && resolvedEngine.name === "builder"
+            ? createBuilderEngine({
+                credentials: await resolveBuilderCredentialsDetailed({
+                    userEmail: ownerEmail,
+                    orgId,
+                }),
+            })
+            : resolvedEngine;
         const modelCandidate = automation.meta.model ??
             deps.model ??
             (await getStoredModelForEngine(engine, { appId: deps.appId })) ??
             engine.defaultModel;
         const model = normalizeModelForEngine(engine, modelCandidate);
         const systemPrompt = await deps.getSystemPrompt(ownerEmail);
-        const thread = await createThread(ownerEmail, { title: threadTitle });
+        const thread = await createThread(ownerEmail, {
+            title: threadTitle,
+            orgId: orgId ?? null,
+        });
         const runId = createRunId(options.runIdPrefix);
         await recordRunThread(historyId, thread.id, runId);
         // Scheduled work is background work: it has no synchronous serverless

package/dist/jobs/frontmatter.d.ts

@@ -54,6 +54,15 @@ export interface JobFrontmatter {
      */
     delegatedPolicyId?: string;
 }
+/**
+ * Return whether a scheduler or trigger dispatcher may claim this resource.
+ *
+ * Personal legacy jobs have no app owner and remain compatible with the
+ * shared scheduler. An organization-owned resource without an explicit app
+ * owner is ambiguous, though: letting every installed app claim it can run
+ * the same job multiple times and with the wrong deployment credentials.
+ */
+export declare function jobBelongsToApp(meta: Pick<JobFrontmatter, "appId" | "orgId">, appId: string | null | undefined): boolean;
 export interface JobResourceClassification {
     kind: "job" | "automation";
     hasExplicitTriggerType: boolean;

package/dist/jobs/frontmatter.js

@@ -1,3 +1,19 @@
+/**
+ * Return whether a scheduler or trigger dispatcher may claim this resource.
+ *
+ * Personal legacy jobs have no app owner and remain compatible with the
+ * shared scheduler. An organization-owned resource without an explicit app
+ * owner is ambiguous, though: letting every installed app claim it can run
+ * the same job multiple times and with the wrong deployment credentials.
+ */
+export function jobBelongsToApp(meta, appId) {
+    const ownerAppId = meta.appId?.trim();
+    if (ownerAppId) {
+        const schedulerAppId = appId?.trim();
+        return Boolean(schedulerAppId && ownerAppId === schedulerAppId);
+    }
+    return !meta.orgId?.trim();
+}
 const MAX_JOB_MCP_TOOLS = 64;
 const JOB_MCP_TOOL_NAME_RE = /^mcp__[^\s]+__[^\s]+$/;
 const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n)?([\s\S]*)$/;

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

@@ -1,4 +1,6 @@
 import { type MigrationEntry } from "../db/migrations.js";
+export declare const AUTOMATION_SCHEDULER_LEASE_MS: number;
+export declare const AUTOMATION_SCHEDULER_LEASE_RENEWAL_MS = 60000;
 /** Authoritative release-time schema for recurring scheduler health. */
 export declare const AUTOMATION_SCHEDULER_HEALTH_MIGRATIONS: MigrationEntry[];
 export declare function runAutomationSchedulerHealthMigrations(nitroApp: unknown): Promise<void>;
@@ -11,6 +13,24 @@ export interface AutomationSchedulerHealth {
     runtime: string | null;
     updatedAt: number | null;
 }
+/** Claim one recurring scheduler across all deployments of an app. */
+export declare function acquireAutomationSchedulerLease(input?: {
+    appId?: string;
+    now?: number;
+    leaseMs?: number;
+}): Promise<string | null>;
+/** Renew a lease while a slow sweep is still executing. */
+export declare function renewAutomationSchedulerLease(input: {
+    appId?: string;
+    owner: string;
+    now?: number;
+    leaseMs?: number;
+}): Promise<boolean>;
+/** Release only the lease owned by this invocation. */
+export declare function releaseAutomationSchedulerLease(input: {
+    appId?: string;
+    owner: string;
+}): Promise<void>;
 /** Record the last scheduler tick without making health bookkeeping fatal. */
 export declare function recordAutomationSchedulerHealth(input: {
     appId?: string;

package/dist/jobs/scheduler-health.js

@@ -1,9 +1,12 @@
+import { randomUUID } from "node:crypto";
 import { getDbExec, intType, isPostgres } from "../db/client.js";
 import { ensureColumnExists, ensureIndexExists, ensureTableExists, } from "../db/ddl-guard.js";
 import { runMigrations } from "../db/migrations.js";
 const TABLE = "automation_scheduler_health";
 const DEFAULT_APP_ID = "default";
 const MAX_ERROR_LENGTH = 500;
+export const AUTOMATION_SCHEDULER_LEASE_MS = 10 * 60_000;
+export const AUTOMATION_SCHEDULER_LEASE_RENEWAL_MS = 60_000;
 /** Authoritative release-time schema for recurring scheduler health. */
 export const AUTOMATION_SCHEDULER_HEALTH_MIGRATIONS = [
     {
@@ -30,6 +33,14 @@ export const AUTOMATION_SCHEDULER_HEALTH_MIGRATIONS = [
       CREATE INDEX IF NOT EXISTS idx_${TABLE}_updated ON ${TABLE} (updated_at)
     `,
     },
+    {
+        version: 2,
+        name: "automation-scheduler-health-lease",
+        sql: `
+      ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS lease_owner TEXT;
+      ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS lease_expires_at INTEGER;
+    `,
+    },
 ];
 export async function runAutomationSchedulerHealthMigrations(nitroApp) {
     await runMigrations(AUTOMATION_SCHEDULER_HEALTH_MIGRATIONS, {
@@ -56,7 +67,9 @@ async function ensureHealthTable() {
           last_dispatched_at ${intType()},
           last_error TEXT,
           runtime TEXT,
-          updated_at ${intType()} NOT NULL
+          updated_at ${intType()} NOT NULL,
+          lease_owner TEXT,
+          lease_expires_at ${intType()}
         )
       `;
             const indexSql = `CREATE INDEX IF NOT EXISTS idx_${TABLE}_updated ON ${TABLE} (updated_at)`;
@@ -69,6 +82,8 @@ async function ensureHealthTable() {
                 await ensureColumnExists(TABLE, "last_error", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS last_error TEXT`);
                 await ensureColumnExists(TABLE, "runtime", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS runtime TEXT`);
                 await ensureColumnExists(TABLE, "updated_at", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS updated_at ${intType()}`);
+                await ensureColumnExists(TABLE, "lease_owner", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS lease_owner TEXT`);
+                await ensureColumnExists(TABLE, "lease_expires_at", `ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS lease_expires_at ${intType()}`);
                 await ensureIndexExists(`idx_${TABLE}_updated`, indexSql);
                 return;
             }
@@ -84,6 +99,8 @@ async function ensureHealthTable() {
                 ["last_error", "TEXT"],
                 ["runtime", "TEXT"],
                 ["updated_at", `${intType()} NOT NULL DEFAULT 0`],
+                ["lease_owner", "TEXT"],
+                ["lease_expires_at", `${intType()}`],
             ]) {
                 if (columns.has(name))
                     continue;
@@ -106,6 +123,74 @@ async function ensureHealthTable() {
     }
     return initPromise;
 }
+function isUniqueViolation(error) {
+    const candidate = error;
+    return (candidate?.code === "23505" ||
+        /unique|duplicate|already exists/i.test(String(candidate?.message ?? error)));
+}
+function leaseRowId(appId) {
+    return rowIdForScope(appId, null);
+}
+/** Claim one recurring scheduler across all deployments of an app. */
+export async function acquireAutomationSchedulerLease(input = {}) {
+    await ensureHealthTable();
+    const appId = normalizeAppId(input.appId);
+    const id = leaseRowId(appId);
+    const now = input.now ?? Date.now();
+    const leaseMs = Math.max(input.leaseMs ?? AUTOMATION_SCHEDULER_LEASE_MS, AUTOMATION_SCHEDULER_LEASE_RENEWAL_MS * 2);
+    const owner = randomUUID();
+    const expiresAt = now + leaseMs;
+    const client = getDbExec();
+    try {
+        await client.execute({
+            sql: `INSERT INTO ${TABLE}
+        (id, app_id, org_id, last_checked_at, last_dispatched_at, last_error, runtime, updated_at, lease_owner, lease_expires_at)
+        VALUES (?, ?, NULL, NULL, NULL, NULL, 'recurring-jobs', ?, ?, ?)`,
+            args: [id, appId, now, owner, expiresAt],
+        });
+        return owner;
+    }
+    catch (error) {
+        if (!isUniqueViolation(error))
+            throw error;
+    }
+    const result = await client.execute({
+        sql: `UPDATE ${TABLE}
+          SET lease_owner = ?, lease_expires_at = ?, updated_at = ?
+          WHERE id = ?
+            AND (lease_owner IS NULL OR lease_expires_at IS NULL OR lease_expires_at <= ?)`,
+        args: [owner, expiresAt, now, id, now],
+    });
+    return Number(result.rowsAffected ?? 0) > 0 ? owner : null;
+}
+/** Renew a lease while a slow sweep is still executing. */
+export async function renewAutomationSchedulerLease(input) {
+    await ensureHealthTable();
+    const now = input.now ?? Date.now();
+    const expiresAt = now + Math.max(input.leaseMs ?? AUTOMATION_SCHEDULER_LEASE_MS, 0);
+    const result = await getDbExec().execute({
+        sql: `UPDATE ${TABLE}
+          SET lease_expires_at = ?, updated_at = ?
+          WHERE id = ? AND lease_owner = ?`,
+        args: [
+            expiresAt,
+            now,
+            leaseRowId(normalizeAppId(input.appId)),
+            input.owner,
+        ],
+    });
+    return Number(result.rowsAffected ?? 0) > 0;
+}
+/** Release only the lease owned by this invocation. */
+export async function releaseAutomationSchedulerLease(input) {
+    await ensureHealthTable();
+    await getDbExec().execute({
+        sql: `UPDATE ${TABLE}
+          SET lease_owner = NULL, lease_expires_at = NULL, updated_at = ?
+          WHERE id = ? AND lease_owner = ?`,
+        args: [Date.now(), leaseRowId(normalizeAppId(input.appId)), input.owner],
+    });
+}
 function fromRow(row) {
     return {
         appId: String(row.app_id ?? DEFAULT_APP_ID),

package/dist/jobs/scheduler.js

@@ -1,9 +1,9 @@
 import { resourceGetByPath, resourceListAllOwners, resourcePutIfCurrent, } from "../resources/store.js";
 import { backgroundRunCutOffReason, isBackgroundAutomationRunActive, resolveBackgroundAutomationIdentity, runBackgroundAutomation, } from "./background-automation-runner.js";
 import { nextOccurrence, isValidCron, describeCron, effectiveTimezone, } from "./cron.js";
-import { buildJobResourceContent, parseJobResource, } from "./frontmatter.js";
+import { buildJobResourceContent, jobBelongsToApp, parseJobResource, } from "./frontmatter.js";
 import { claimAutomationRun, finishAutomationRun, getAutomationRun, listAutomationRuns, } from "./run-history.js";
-import { recordAutomationSchedulerHealth } from "./scheduler-health.js";
+import { acquireAutomationSchedulerLease, recordAutomationSchedulerHealth, releaseAutomationSchedulerLease, renewAutomationSchedulerLease, AUTOMATION_SCHEDULER_LEASE_RENEWAL_MS, } from "./scheduler-health.js";
 // ─── Frontmatter parsing ────────────────────────────────────────────────────
 export { classifyJobFrontmatter, classifyJobResource, normalizeJobMcpTools, parseJobResource, } from "./frontmatter.js";
 export function parseJobFrontmatter(content) {
@@ -18,13 +18,6 @@ const MAX_IDENTITY_PREFLIGHTS_PER_TICK = MAX_CONCURRENT_SCHEDULED_JOBS * 4;
 const IDENTITY_FAILURE_RETRY_MS = 5 * 60_000;
 const _activeScheduledJobs = new Set();
 const _preflightingScheduledJobs = new Set();
-function jobBelongsToApp(meta, appId) {
-    const ownerAppId = meta.appId?.trim();
-    if (!ownerAppId)
-        return true;
-    const schedulerAppId = appId?.trim();
-    return Boolean(schedulerAppId && ownerAppId === schedulerAppId);
-}
 // Skip the DB query on every tick if we recently confirmed no jobs exist.
 // `_hasJobsCache` is invalidated whenever a `jobs/*` resource is written or
 // deleted (subscribed below), and refreshed at most every 5 minutes.
@@ -74,6 +67,43 @@ function subscribeToJobsResourceEvents() {
  * one job cannot run twice while leaving other due jobs waiting behind it.
  */
 export async function processRecurringJobs(deps) {
+    const leaseOwner = await acquireAutomationSchedulerLease({
+        appId: deps.appId,
+    });
+    if (!leaseOwner)
+        return;
+    const leaseRenewal = setInterval(() => {
+        void renewAutomationSchedulerLease({
+            appId: deps.appId,
+            owner: leaseOwner,
+        }).catch((error) => {
+            console.warn("[recurring-jobs] Scheduler lease renewal failed:", error instanceof Error ? error.message : error);
+        });
+    }, AUTOMATION_SCHEDULER_LEASE_RENEWAL_MS);
+    let primaryFailed = false;
+    try {
+        await processRecurringJobsWithLease(deps);
+    }
+    catch (error) {
+        primaryFailed = true;
+        throw error;
+    }
+    finally {
+        clearInterval(leaseRenewal);
+        try {
+            await releaseAutomationSchedulerLease({
+                appId: deps.appId,
+                owner: leaseOwner,
+            });
+        }
+        catch (releaseError) {
+            console.warn("[recurring-jobs] Scheduler lease release failed:", releaseError instanceof Error ? releaseError.message : releaseError);
+            if (!primaryFailed)
+                throw releaseError;
+        }
+    }
+}
+async function processRecurringJobsWithLease(deps) {
     subscribeToJobsResourceEvents();
     // Skip if we recently confirmed there are no job resources to run.
     const nowMs = Date.now();
@@ -392,6 +422,13 @@ async function executeJob(resource, meta, body, deps, now, options = {}) {
             requestContext,
             ...(options.historyId ? { historyId: options.historyId } : {}),
             actionCaller: "automation",
+            actionAutomation: {
+                triggerId: resource.id,
+                triggerName: jobName,
+                ...(meta.delegatedPolicyId
+                    ? { policyId: meta.delegatedPolicyId }
+                    : {}),
+            },
         }, deps);
         await recordExecutionOutcome(resource, {
             lastRun: meta.lastRun,

package/dist/jobs/tools.d.ts

@@ -1,6 +1,6 @@
 import type { ActionEntry } from "../agent/production-agent.js";
 import { type JobFrontmatter } from "./scheduler.js";
-export declare function jobBelongsToApp(meta: JobFrontmatter, appId?: string): boolean;
+export { jobBelongsToApp } from "./frontmatter.js";
 /**
  * Authorise a mutation (update / delete) against a job resource. When the
  * job is in the SHARED scope the caller must either be the original

package/dist/jobs/tools.js

@@ -3,8 +3,9 @@ import { resolveUserSchedulingTimezone } from "../localization/user-timezone.js"
 import { resourcePut, resourceGetByPath, resourceList, resourceDelete, organizationIdFromResourceOwner, sharedResourceOwner, SHARED_OWNER, } from "../resources/store.js";
 import { getRequestUserEmail, getRequestOrgId, getIntegrationRequestContext, } from "../server/request-context.js";
 import { isValidCron, nextOccurrence, describeCron, effectiveTimezone, isValidTimezone, } from "./cron.js";
-import { classifyJobResource } from "./frontmatter.js";
+import { classifyJobResource, jobBelongsToApp } from "./frontmatter.js";
 import { parseJobFrontmatter, buildJobContent, normalizeJobMcpTools, } from "./scheduler.js";
+export { jobBelongsToApp } from "./frontmatter.js";
 function getOwner() {
     const email = getRequestUserEmail();
     if (!email)
@@ -14,12 +15,6 @@ function getOwner() {
 function getSharedOwner() {
     return sharedResourceOwner(getRequestOrgId());
 }
-export function jobBelongsToApp(meta, appId) {
-    const ownerAppId = meta.appId?.trim();
-    if (!ownerAppId)
-        return true;
-    return ownerAppId === appId?.trim();
-}
 /**
  * Determine if the current request's user is an org owner/admin in the
  * given org. Used to allow privileged users to update or delete shared

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

@@ -455,6 +455,26 @@ declare const messages: {
         builderModelCredits: string;
         addOwnKeys: string;
         configureProviderKeys: string;
+        chooseProvider: string;
+        searchProviders: string;
+        noProvidersFound: string;
+        availableProviders: string;
+        configured: string;
+        apiKey: string;
+        localRuntime: string;
+        enterApiKey: string;
+        providerSetupFailed: string;
+        noApiKeyNeeded: string;
+        modelId: string;
+        endpointUrl: string;
+        optional: string;
+        ollamaEndpointHint: string;
+        compatibleEndpointHint: string;
+        savingProvider: string;
+        providerSaved: string;
+        useProvider: string;
+        saveAndUseProvider: string;
+        getApiKey: string;
         checkingAiConnection: string;
         delegatedAgent: {
             asking: string;

package/dist/localization/default-messages.js

@@ -389,7 +389,7 @@ const messages = {
             threadDebugRefreshFailures: "Refresh failed runs",
             threadDebugNoFailures: "No failed runs found.",
             threadDebugCurrentDatabase: "Current Dispatch DB",
-            threadDebugSearchPlaceholder: "Search title, preview, messages, tools",
+            threadDebugSearchPlaceholder: "Search threads or email",
             threadDebugSearch: "Search",
             threadDebugLookupPlaceholder: "Paste thread or request/run ID",
             threadDebugInspect: "Inspect",
@@ -455,12 +455,32 @@ const messages = {
         askAgentTitle: "Ask the agent",
         askAgentPlaceholder: "Tell the agent what you want to do…",
         connectAi: "Connect AI",
-        builderOrOwnKeys: "Use Builder.io free credits, or add your own provider keys.",
+        builderOrOwnKeys: "Choose Builder.io or custom keys.",
         connectBuilderIo: "Connect Builder.io",
         connectingBuilder: "Connecting Builder.io…",
         builderModelCredits: "Free credits for Claude, OpenAI & Gemini",
-        addOwnKeys: "Add your own keys",
-        configureProviderKeys: "Configure Anthropic, OpenAI, or another provider",
+        addOwnKeys: "Custom keys",
+        configureProviderKeys: "Choose a provider.",
+        chooseProvider: "Choose a provider",
+        searchProviders: "Search providers...",
+        noProvidersFound: "No providers found.",
+        availableProviders: "Available providers",
+        configured: "Configured",
+        apiKey: "API key",
+        localRuntime: "Local",
+        enterApiKey: "Enter your {{provider}} API key.",
+        providerSetupFailed: "Could not configure this provider.",
+        noApiKeyNeeded: "No API key required.",
+        modelId: "Model ID",
+        endpointUrl: "Endpoint URL",
+        optional: "Optional",
+        ollamaEndpointHint: "Defaults to Ollama at http://localhost:11434.",
+        compatibleEndpointHint: "Use this for LiteLLM or another OpenAI-compatible gateway.",
+        savingProvider: "Saving...",
+        providerSaved: "Connected",
+        useProvider: "Use {{provider}}",
+        saveAndUseProvider: "Save and use {{provider}}",
+        getApiKey: "Get an API key",
         checkingAiConnection: "Checking AI connection...",
         delegatedAgent: {
             asking: "Asking {{name}}...",
@@ -475,7 +495,7 @@ const messages = {
             setupTitle: "Set up voice mode",
             setupDescription: "Connect Builder.io to use managed voice with free credits, or add your own keys.",
             connectBuilder: "Connect Builder.io",
-            useOpenAiKey: "Add your own keys",
+            useOpenAiKey: "Custom keys",
             startWithOpenAiKey: "Start with OpenAI key",
             start: "Real-time voice",
             keepDictating: "Dictate",

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

@@ -6,6 +6,9 @@
  * hot-reload the configured server set.
  *
  *   GET    /_agent-native/mcp/servers           list user + org servers
+ *   GET    /_agent-native/mcp/servers/runtime-config
+ *                                                reserved; returns 410 until a
+ *                                                desktop capability broker exists
  *   POST   /_agent-native/mcp/servers           add a server
  *   DELETE /_agent-native/mcp/servers/:id       remove a server (scope via ?scope=)
  *   POST   /_agent-native/mcp/servers/:id/test  dry-run connect (no persist)

package/dist/mcp-client/routes.js

@@ -6,6 +6,9 @@
  * hot-reload the configured server set.
  *
  *   GET    /_agent-native/mcp/servers           list user + org servers
+ *   GET    /_agent-native/mcp/servers/runtime-config
+ *                                                reserved; returns 410 until a
+ *                                                desktop capability broker exists
  *   POST   /_agent-native/mcp/servers           add a server
  *   DELETE /_agent-native/mcp/servers/:id       remove a server (scope via ?scope=)
  *   POST   /_agent-native/mcp/servers/:id/test  dry-run connect (no persist)
@@ -344,6 +347,11 @@ export function mountMcpServersRoutes(nitroApp, manager, options = {}) {
                 .replace(/\/+$/, "");
             const parts = pathname ? pathname.split("/") : [];
             setResponseHeader(event, "Content-Type", "application/json");
+            if (method === "GET" &&
+                parts.length === 1 &&
+                parts[0] === "runtime-config") {
+                return handleRuntimeConfig(event);
+            }
             // POST /servers/test — dry-run a URL+headers before persisting
             if (method === "POST" && parts.length === 1 && parts[0] === "test") {
                 return handleTestUrl(event);
@@ -700,6 +708,12 @@ async function handleList(event, manager) {
         role,
     };
 }
+function handleRuntimeConfig(event) {
+    setResponseStatus(event, 410);
+    return {
+        error: "Cleartext MCP runtime config requires a desktop capability broker and is not available over session-authenticated HTTP.",
+    };
+}
 async function handleAdd(event, manager) {
     const body = (await readBody(event).catch(() => ({})));
     const scope = body.scope === "org" ? "org" : body.scope === "user" ? "user" : null;

package/dist/notifications/routes.d.ts

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

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;
     ok: boolean;
-    error?: undefined;
 }>>;