@agent-native/core 0.147.0 → 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/awareness.d.ts

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

package/dist/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.js

@@ -1,7 +1,7 @@
 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 { acquireAutomationSchedulerLease, recordAutomationSchedulerHealth, releaseAutomationSchedulerLease, renewAutomationSchedulerLease, AUTOMATION_SCHEDULER_LEASE_RENEWAL_MS, } from "./scheduler-health.js";
 // ─── Frontmatter parsing ────────────────────────────────────────────────────
@@ -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.
@@ -429,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/observability/routes.d.ts

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

package/dist/onboarding/app-profile.js

@@ -3,7 +3,7 @@ const LLM_CAPABILITY = {
     label: "AI model",
     required: true,
     builderIncluded: true,
-    keySummary: "One model key: Anthropic, OpenAI, Gemini, Groq, Mistral, or Cohere",
+    keySummary: "One model key or local connection: Anthropic, OpenAI, OpenRouter, Gemini, Groq, Mistral, Cohere, or Ollama",
     why: "The agent uses a language model to understand requests and produce answers.",
 };
 const DESIGN_SYSTEM_INTELLIGENCE_CAPABILITY = {

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/provider-api/actions/custom-provider-registration.d.ts

@@ -75,8 +75,9 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
-    deleted?: undefined;
     id?: undefined;
+    provider?: undefined;
+    deleted?: undefined;
     providers: {
         id: string;
         label: string;
@@ -87,15 +88,14 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         updatedAt: number;
     }[];
     count: number;
-    provider?: undefined;
     found?: undefined;
     registered?: undefined;
     label?: undefined;
     message?: undefined;
 } | {
-    deleted?: undefined;
     count?: undefined;
     id?: undefined;
+    deleted?: undefined;
     providers?: undefined;
     found: boolean;
     provider: import("../custom-registry.js").CustomProviderConfig;
@@ -103,10 +103,10 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     label?: undefined;
     message?: undefined;
 } | {
-    deleted?: undefined;
     count?: undefined;
-    providers?: undefined;
     provider?: undefined;
+    deleted?: undefined;
+    providers?: undefined;
     found: boolean;
     id: string;
     registered?: undefined;
@@ -114,8 +114,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     message?: undefined;
 } | {
     count?: undefined;
-    providers?: undefined;
     provider?: undefined;
+    providers?: undefined;
     found?: undefined;
     deleted: boolean;
     id: string;
@@ -123,10 +123,10 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     label?: undefined;
     message?: undefined;
 } | {
-    deleted?: undefined;
     count?: undefined;
-    providers?: undefined;
     provider?: undefined;
+    deleted?: undefined;
+    providers?: undefined;
     found?: undefined;
     registered: boolean;
     id: string;

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

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

package/dist/resources/handlers.d.ts

@@ -48,8 +48,8 @@ export declare function handleUpdateResource(event: any): Promise<import("./stor
 }>;
 /** DELETE /_agent-native/resources/:id — delete a resource */
 export declare function handleDeleteResource(event: any): Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/scripts/agent-engines/test-agent-engine.js

@@ -2,7 +2,8 @@
  * test-agent-engine — sends a trivial prompt to verify the engine is working.
  */
 import { getAgentEngineEntry, registerBuiltinEngines, } from "../../agent/engine/index.js";
-import { normalizeOpenAiBaseUrl, OPENAI_BASE_URL_ENV_VAR, } from "../../agent/engine/openai-compatible-endpoint.js";
+import { OLLAMA_BASE_URL_ENV_VAR, OPENAI_BASE_URL_ENV_VAR, } from "../../agent/engine/openai-compatible-endpoint.js";
+import { validateProviderBaseUrl } from "../../agent/engine/provider-endpoint-validation.js";
 import { canUseDeployCredentialFallbackForRequest, readDeployCredentialEnv, resolveSecret, } from "../../server/credential-provider.js";
 export const tool = {
     description: "Test an agent engine by sending a trivial prompt and measuring latency. Useful for verifying API keys and connectivity before switching engines.",
@@ -31,13 +32,30 @@ async function resolveAgentEngineSecret(key) {
         if (value)
             return value;
     }
-    catch {
-        // Fall through to deploy env when this request is allowed to use it.
+    catch (error) {
+        if (!canUseDeployCredentialFallbackForRequest(key))
+            throw error;
+        console.warn("[test-agent-engine] Saved provider secret unavailable; using deploy configuration.", { key, error });
     }
     return canUseDeployCredentialFallbackForRequest(key)
         ? readDeployCredentialEnv(key)
         : undefined;
 }
+async function resolveAgentEngineEndpoint(key) {
+    const value = await resolveSecret(key);
+    if (value) {
+        return validateProviderBaseUrl(value, {
+            allowLocalOllama: key === OLLAMA_BASE_URL_ENV_VAR &&
+                process.env.NODE_ENV === "development",
+        });
+    }
+    if (!canUseDeployCredentialFallbackForRequest(key))
+        return undefined;
+    const deployValue = readDeployCredentialEnv(key);
+    return deployValue
+        ? validateProviderBaseUrl(deployValue, { allowPrivate: true })
+        : undefined;
+}
 function canUseDeployEnvForEntry(entry) {
     if (entry.requiredEnvVars.length === 0)
         return true;
@@ -50,13 +68,19 @@ async function createEngineConfig(entry, args) {
             : undefined,
         allowEnvFallback: canUseDeployEnvForEntry(entry),
     };
-    if (entry.name === "ai-sdk:openai") {
-        const rawBaseUrl = args.baseUrl?.trim()
-            ? args.baseUrl
-            : await resolveAgentEngineSecret(OPENAI_BASE_URL_ENV_VAR);
-        if (rawBaseUrl) {
-            config.baseUrl = normalizeOpenAiBaseUrl(rawBaseUrl);
-        }
+    if (entry.name === "ai-sdk:openai" || entry.name === "ai-sdk:ollama") {
+        const endpointKey = entry.name === "ai-sdk:ollama"
+            ? OLLAMA_BASE_URL_ENV_VAR
+            : OPENAI_BASE_URL_ENV_VAR;
+        const explicitBaseUrl = args.baseUrl?.trim();
+        const baseUrl = explicitBaseUrl
+            ? await validateProviderBaseUrl(explicitBaseUrl, {
+                allowLocalOllama: entry.name === "ai-sdk:ollama" &&
+                    process.env.NODE_ENV === "development",
+            })
+            : await resolveAgentEngineEndpoint(endpointKey);
+        if (baseUrl)
+            config.baseUrl = baseUrl;
     }
     return config;
 }

package/dist/secrets/routes.d.ts

@@ -34,37 +34,37 @@ export declare function createListSecretsHandler(): import("h3").EventHandlerWit
 /** POST /_agent-native/secrets/:key — write a secret. */
 export declare function createWriteSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    status?: undefined;
     ok?: undefined;
+    status?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     status: string;
-    error?: undefined;
 } | {
+    ok?: undefined;
     error: string;
     removed?: undefined;
-    ok?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     removed: boolean;
-    error?: undefined;
 }>>;
 /**
  * POST /_agent-native/secrets/:key/test — validate an optional candidate value
  * or the current stored value without changing anything.
  */
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    ok?: undefined;
     error: string;
     note?: undefined;
-    ok?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note?: undefined;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note: string;
-    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -95,11 +95,11 @@ export interface AdHocSecretPayload {
 export declare function createAdHocSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<AdHocSecretPayload[] | {
     error: string;
 } | {
+    error?: undefined;
     ok: boolean;
     key: string;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     removed: boolean;
-    error?: undefined;
 }>>;

package/dist/server/agent-chat/run-code-tools.d.ts

@@ -1,7 +1,7 @@
 import type { ActionEntry } from "../../agent/production-agent.js";
 /**
  * Load the sandboxed code-execution tool entries for one action registry:
- * `run-code` plus its `get-code-execution` poll companion. The poll tool is
+ * `run-code`, bounded `tool-orchestration`, plus its `get-code-execution` poll companion. The poll tool is
  * registered ALONGSIDE run-code everywhere run-code appears, so the durable
  * background-execution guidance run-code emits ("check it with
  * get-code-execution") always points at a callable tool. Returns an empty

package/dist/server/agent-chat/run-code-tools.js

@@ -1,6 +1,6 @@
 /**
  * Load the sandboxed code-execution tool entries for one action registry:
- * `run-code` plus its `get-code-execution` poll companion. The poll tool is
+ * `run-code`, bounded `tool-orchestration`, plus its `get-code-execution` poll companion. The poll tool is
  * registered ALONGSIDE run-code everywhere run-code appears, so the durable
  * background-execution guidance run-code emits ("check it with
  * get-code-execution") always points at a callable tool. Returns an empty
@@ -13,8 +13,10 @@
 export async function loadRunCodeToolEntries(supplier, runCodeOptions) {
     try {
         const { createRunCodeEntry, createGetCodeExecutionEntry } = await import("../../coding-tools/run-code.js");
+        const { createToolOrchestrationEntry } = await import("../../coding-tools/tool-orchestration.js");
         const entries = {
             "run-code": createRunCodeEntry(supplier, runCodeOptions),
+            "tool-orchestration": createToolOrchestrationEntry(supplier),
             "get-code-execution": createGetCodeExecutionEntry(),
         };
         // Data programs: stored JS scripts executed through this same run-code