@agent-native/core 0.176.1 → 0.176.2-nightly-20260831185956

package/dist/agent/engine/builder-engine.js

@@ -18,7 +18,7 @@
 import { BUILDER_OAUTH_SCOPE, hasBuilderOAuthSession, markBuilderOAuthReconnectRequired, resolveBuilderOAuthRequestAccess, } from "../../server/builder-oauth.js";
 import { captureError } from "../../server/capture-error.js";
 import { clearBuilderGatewayAuthFailure, isBuilderGatewayDeployConfigured, resolveBuilderGatewayCredentialsDetailed, getBuilderGatewayBaseUrl, recordBuilderGatewayAuthFailure, } from "../../server/credential-provider.js";
-import { getRequestUserEmail } from "../../server/request-context.js";
+import { getRequestOrgId, getRequestUserEmail, } from "../../server/request-context.js";
 import { applyBuilderUtmTrackingParams } from "../../shared/builder-link-tracking.js";
 import { allowsSamplingParams, isGPTReasoningModel, normalizeReasoningEffortForModel, } from "../../shared/reasoning-effort.js";
 import { isInBackgroundFunctionRuntime } from "../durable-background.js";
@@ -27,6 +27,7 @@ import { getBuilderGatewayRequestHeaders } from "./builder-gateway-headers.js";
 import { gatewayVisitorFacingError, LLM_MISSING_CREDENTIALS_ERROR_CODE, LLM_MISSING_CREDENTIALS_MESSAGE, } from "./credential-errors.js";
 import { classifyTerminalErrorCode, canonicalizeBuilderGatewayErrorCode, describeErrorWithCauses, isBuilderGatewayInternalErrorMessage, isContextOverflowCode, isContextOverflowMessage, isProviderConnectionErrorMessage, } from "./error-detail.js";
 import { FIRST_STREAM_EVENT_TIMEOUT_MS } from "./first-event-timeout.js";
+import { limitProviderTools } from "./limit-provider-tools.js";
 import { resolveMaxOutputTokensForEngine } from "./output-tokens.js";
 import { splitSystemPromptForCache, stablePrefixCacheControl, } from "./prompt-cache.js";
 import { createProviderToolNameMap, toEngineToolName, } from "./tool-name.js";
@@ -133,15 +134,17 @@ class BuilderEngine {
         const creds = this.configuredCredentials ??
             (await resolveBuilderGatewayCredentialsDetailed());
         const ownerEmail = getRequestUserEmail();
+        const orgId = getRequestOrgId() ?? null;
         let oauthAccess = null;
         let hasStoredOAuth = false;
         if (ownerEmail) {
-            hasStoredOAuth = await hasBuilderOAuthSession(ownerEmail);
+            hasStoredOAuth = await hasBuilderOAuthSession(ownerEmail, orgId);
             if (hasStoredOAuth) {
                 try {
                     oauthAccess = await resolveBuilderOAuthRequestAccess({
                         ownerEmail,
                         requiredScope: BUILDER_OAUTH_SCOPE,
+                        orgId,
                     });
                 }
                 catch {
@@ -175,8 +178,9 @@ class BuilderEngine {
             ? BUILDER_DEFAULT_MODEL
             : requestedModel;
         const toolNameMap = createProviderToolNameMap(opts.tools, opts.messages);
+        const providerTools = limitProviderTools(opts.tools);
         const messages = engineMessagesToBuilderGatewayAnthropic(opts.messages, toolNameMap);
-        const tools = engineToolsToAnthropic(opts.tools, toolNameMap);
+        const tools = engineToolsToAnthropic(providerTools, toolNameMap);
         const thinkingBudget = opts.providerOptions?.anthropic?.thinking?.budgetTokens;
         const reasoningEffort = normalizeReasoningEffortForModel(model, opts.reasoningEffort ??
             (typeof thinkingBudget === "number"
@@ -337,6 +341,7 @@ class BuilderEngine {
                     creditsLane,
                     requestShape,
                     recordLegacyCredentialFailure: !oauthAccess,
+                    oauthScope: oauthAccess?.scope,
                 });
                 return;
             }
@@ -395,6 +400,7 @@ class BuilderEngine {
                 requestStartedAt: tStart,
                 requestShape,
                 recordLegacyCredentialFailure: !oauthAccess,
+                oauthScope: oauthAccess?.scope,
             });
         }
         finally {
@@ -462,8 +468,17 @@ async function recordAuthFailureForCurrentLane(opts) {
         return;
     }
     const ownerEmail = getRequestUserEmail();
-    if (ownerEmail)
-        await markBuilderOAuthReconnectRequired(ownerEmail);
+    if (ownerEmail) {
+        if (opts.oauthScope === "org") {
+            await markBuilderOAuthReconnectRequired(ownerEmail, "org", getRequestOrgId());
+        }
+        else if (opts.oauthScope === "user") {
+            await markBuilderOAuthReconnectRequired(ownerEmail, "user");
+        }
+        else {
+            await markBuilderOAuthReconnectRequired(ownerEmail);
+        }
+    }
 }
 async function* emitHttpError(response, opts) {
     const status = response.status;
@@ -502,6 +517,7 @@ async function* emitHttpError(response, opts) {
     if (status === 401 || code === "unauthorized") {
         await recordAuthFailureForCurrentLane({
             recordLegacyCredentialFailure: opts.recordLegacyCredentialFailure,
+            oauthScope: opts.oauthScope,
             status,
             code,
             message,
@@ -515,6 +531,7 @@ async function* emitHttpError(response, opts) {
     if (status === 403 && isBuilderCredentialAuthError(message)) {
         await recordAuthFailureForCurrentLane({
             recordLegacyCredentialFailure: opts.recordLegacyCredentialFailure,
+            oauthScope: opts.oauthScope,
             status,
             code,
             message,
@@ -793,6 +810,7 @@ async function* parseJsonlStream(reader, model, captureContext = {}) {
                         if (isCredentialAuthError) {
                             await recordAuthFailureForCurrentLane({
                                 recordLegacyCredentialFailure: captureContext.recordLegacyCredentialFailure,
+                                oauthScope: captureContext.oauthScope,
                                 code: typeof gatewayErrCode === "string" ? gatewayErrCode : errCode,
                                 message: String(errMsg),
                             });

package/dist/agent/engine/limit-provider-tools.d.ts

@@ -0,0 +1,3 @@
+import type { EngineTool } from "./types.js";
+export declare const MAX_PROVIDER_TOOLS = 128;
+export declare function limitProviderTools(tools: readonly EngineTool[], preserveNames?: readonly string[]): EngineTool[];

package/dist/agent/engine/limit-provider-tools.js

@@ -0,0 +1,23 @@
+export const MAX_PROVIDER_TOOLS = 128;
+const DEFAULT_PRESERVED_TOOL_NAMES = ["tool-search"];
+export function limitProviderTools(tools, preserveNames = DEFAULT_PRESERVED_TOOL_NAMES) {
+    if (tools.length <= MAX_PROVIDER_TOOLS)
+        return tools;
+    const preservedNames = new Set(preserveNames);
+    const seen = new Set();
+    const limited = [];
+    for (const tool of tools) {
+        if (!preservedNames.has(tool.name) || seen.has(tool.name))
+            continue;
+        limited.push(tool);
+        seen.add(tool.name);
+    }
+    for (const tool of tools) {
+        if (seen.has(tool.name))
+            continue;
+        limited.push(tool);
+        if (limited.length === MAX_PROVIDER_TOOLS)
+            return limited;
+    }
+    return limited.slice(0, MAX_PROVIDER_TOOLS);
+}

package/dist/agent/engine/openai-compatible-endpoint.d.ts

@@ -1,4 +1,6 @@
 export declare const OPENAI_BASE_URL_ENV_VAR = "OPENAI_BASE_URL";
+export declare const OPENAI_DEFAULT_BASE_URL = "https://api.openai.com/v1";
 export declare const OLLAMA_BASE_URL_ENV_VAR = "OLLAMA_BASE_URL";
+export declare function isCustomOpenAiBaseUrl(value: string | undefined): boolean;
 export declare function normalizeProviderBaseUrl(value: string): string;
 export declare function normalizeOpenAiBaseUrl(value: string): string;

package/dist/agent/engine/openai-compatible-endpoint.js

@@ -1,5 +1,9 @@
 export const OPENAI_BASE_URL_ENV_VAR = "OPENAI_BASE_URL";
+export const OPENAI_DEFAULT_BASE_URL = "https://api.openai.com/v1";
 export const OLLAMA_BASE_URL_ENV_VAR = "OLLAMA_BASE_URL";
+export function isCustomOpenAiBaseUrl(value) {
+    return Boolean(value && value.replace(/\/+$/, "") !== OPENAI_DEFAULT_BASE_URL);
+}
 export function normalizeProviderBaseUrl(value) {
     const trimmed = value.trim();
     if (!trimmed) {

package/dist/agent/engine/output-tokens.d.ts

@@ -1,24 +1,30 @@
 export declare const DEFAULT_OPENROUTER_MAX_OUTPUT_TOKENS = 8192;
-export declare const DEFAULT_AI_SDK_MAX_OUTPUT_TOKENS = 4096;
+export declare const DEFAULT_AI_SDK_MAX_OUTPUT_TOKENS = 8192;
 export declare const DEFAULT_ANTHROPIC_MAX_OUTPUT_TOKENS = 8192;
 export declare const DEFAULT_BUILDER_MAX_OUTPUT_TOKENS = 8192;
 /** Cap for the first attempt of an interactive chat turn. */
-export declare const MAIN_CHAT_MAX_OUTPUT_TOKENS_CAP = 32000;
+export declare const MAIN_CHAT_MAX_OUTPUT_TOKENS_CAP = 64000;
 /**
  * Cap used only when retrying a turn that came back with an empty final
  * response (see production-agent.ts's empty-final-response retry). Higher
  * than the first-attempt cap so the retry meaningfully raises the ceiling.
  */
-export declare const EMPTY_RESPONSE_RETRY_MAX_OUTPUT_TOKENS_CAP = 64000;
+export declare const EMPTY_RESPONSE_RETRY_MAX_OUTPUT_TOKENS_CAP = 128000;
 /**
  * Resolve the max_output_tokens floor for the first attempt of an
- * interactive chat turn: min(model ceiling, 32K). Always at or above the
- * flat per-engine defaults above, regardless of whether the model is known.
+ * interactive chat turn: min(model ceiling, configured chat cap). Always at
+ * or above the flat per-engine defaults above, regardless of whether the
+ * model is known.
  */
 export declare function resolveMainChatMaxOutputTokens(modelId?: string): number;
 /**
  * Resolve the max_output_tokens to use when retrying a turn after an empty
- * final response: min(model ceiling, 64K).
+ * final response: min(model ceiling, configured retry cap).
+ *
+ * The retry cap is floored at the first-attempt cap. The two fields are
+ * configured independently, so a deployment can set a retry cap BELOW the
+ * chat cap — which would make the retry a downgrade, quietly weakening the
+ * exact path that exists to recover a truncated answer.
  */
 export declare function resolveEmptyResponseRetryMaxOutputTokens(modelId?: string): number;
 /** Anthropic's documented minimum extended-thinking budget. */

package/dist/agent/engine/output-tokens.js

@@ -1,3 +1,4 @@
+import { getAppConfig } from "../../app-config/index.js";
 import { getMaxOutputTokensForModel } from "../model-config.js";
 const MIN_MAX_OUTPUT_TOKENS = 256;
 // The output-token ceiling is model-aware (see MODEL_MAX_OUTPUT_TOKENS in
@@ -6,14 +7,19 @@ const MIN_MAX_OUTPUT_TOKENS = 256;
 // higher (Claude Fable 5 / Opus 4.8 / Sonnet 5, GPT-5.x). When no model id is
 // available the conservative 64K ceiling applies.
 // OpenRouter default raised from 1024 (truncation-prone) to 8192.
+// These are ceilings, not budgets: an unused ceiling costs nothing, while one
+// below what the turn needs truncates the answer. They are the floor for a
+// caller that passes nothing AND configures nothing — every path that runs a
+// real turn now passes one (see resolveMainChatMaxOutputTokens below), and a
+// deployment raises the rest at once through `agent.maxOutputTokens`.
 export const DEFAULT_OPENROUTER_MAX_OUTPUT_TOKENS = 8192;
-export const DEFAULT_AI_SDK_MAX_OUTPUT_TOKENS = 4096;
+export const DEFAULT_AI_SDK_MAX_OUTPUT_TOKENS = 8192;
 export const DEFAULT_ANTHROPIC_MAX_OUTPUT_TOKENS = 8192;
 export const DEFAULT_BUILDER_MAX_OUTPUT_TOKENS = 8192;
 // ---------------------------------------------------------------------------
 // Main interactive chat path
 //
-// The per-engine defaults above (4096-8192) exist for internal/eval/
+// The per-engine defaults above (8192) exist for internal/eval/
 // observational-memory callers that intentionally want a small explicit cap.
 // The main interactive chat turn (the one the end user is staring at) needs
 // real headroom: on long-context or reasoning-heavy turns, a tiny completion
@@ -22,28 +28,39 @@ export const DEFAULT_BUILDER_MAX_OUTPUT_TOKENS = 8192;
 // These helpers give the chat path a much higher floor while staying at or
 // under each model's documented ceiling — they never lower the ceiling.
 // ---------------------------------------------------------------------------
+// These two constants are the values declared as defaults on
+// `agent.mainChatMaxOutputTokens` and `agent.emptyResponseRetryMaxOutputTokens`
+// in app-config/agent.ts. They exist here so the reasoning above sits next to
+// the number; output-tokens.spec.ts fails if the pair diverges.
 /** Cap for the first attempt of an interactive chat turn. */
-export const MAIN_CHAT_MAX_OUTPUT_TOKENS_CAP = 32_000;
+export const MAIN_CHAT_MAX_OUTPUT_TOKENS_CAP = 64_000;
 /**
  * Cap used only when retrying a turn that came back with an empty final
  * response (see production-agent.ts's empty-final-response retry). Higher
  * than the first-attempt cap so the retry meaningfully raises the ceiling.
  */
-export const EMPTY_RESPONSE_RETRY_MAX_OUTPUT_TOKENS_CAP = 64_000;
+export const EMPTY_RESPONSE_RETRY_MAX_OUTPUT_TOKENS_CAP = 128_000;
 /**
  * Resolve the max_output_tokens floor for the first attempt of an
- * interactive chat turn: min(model ceiling, 32K). Always at or above the
- * flat per-engine defaults above, regardless of whether the model is known.
+ * interactive chat turn: min(model ceiling, configured chat cap). Always at
+ * or above the flat per-engine defaults above, regardless of whether the
+ * model is known.
  */
 export function resolveMainChatMaxOutputTokens(modelId) {
-    return Math.min(getMaxOutputTokensForModel(modelId), MAIN_CHAT_MAX_OUTPUT_TOKENS_CAP);
+    return Math.min(getMaxOutputTokensForModel(modelId), getAppConfig().agent.mainChatMaxOutputTokens);
 }
 /**
  * Resolve the max_output_tokens to use when retrying a turn after an empty
- * final response: min(model ceiling, 64K).
+ * final response: min(model ceiling, configured retry cap).
+ *
+ * The retry cap is floored at the first-attempt cap. The two fields are
+ * configured independently, so a deployment can set a retry cap BELOW the
+ * chat cap — which would make the retry a downgrade, quietly weakening the
+ * exact path that exists to recover a truncated answer.
  */
 export function resolveEmptyResponseRetryMaxOutputTokens(modelId) {
-    return Math.min(getMaxOutputTokensForModel(modelId), EMPTY_RESPONSE_RETRY_MAX_OUTPUT_TOKENS_CAP);
+    const { mainChatMaxOutputTokens, emptyResponseRetryMaxOutputTokens } = getAppConfig().agent;
+    return Math.min(getMaxOutputTokensForModel(modelId), Math.max(emptyResponseRetryMaxOutputTokens, mainChatMaxOutputTokens));
 }
 // ---------------------------------------------------------------------------
 // Extended-thinking budget headroom
@@ -100,22 +117,31 @@ export function normalizeMaxOutputTokens(value, modelId) {
         return null;
     return Math.min(getMaxOutputTokensForModel(modelId), Math.max(MIN_MAX_OUTPUT_TOKENS, parsed));
 }
-function envOverrideForEngine(engineName, modelId) {
+/**
+ * Per-provider override, e.g. `AGENT_OPENROUTER_MAX_OUTPUT_TOKENS`.
+ *
+ * This one key namespace stays a direct environment read: the provider half of
+ * the name is derived from the engine at call time, so there is no leaf field a
+ * `.meta({ env })` alias could hang off. The global key it used to sit above is
+ * now the declared `agent.maxOutputTokens` field, read below.
+ */
+function providerEnvOverride(engineName, modelId) {
     const provider = engineName.startsWith("ai-sdk:")
         ? engineName.slice("ai-sdk:".length)
         : engineName;
     const providerEnvKey = `AGENT_${provider
         .replace(/[^a-z0-9]+/gi, "_")
         .toUpperCase()}_MAX_OUTPUT_TOKENS`;
-    return (
     // guard:allow-env-credential — output-token cap config, not a credential
-    normalizeMaxOutputTokens(process.env[providerEnvKey], modelId) ??
-        normalizeMaxOutputTokens(process.env.AGENT_MAX_OUTPUT_TOKENS, modelId));
+    return normalizeMaxOutputTokens(process.env[providerEnvKey], modelId);
 }
 export function defaultMaxOutputTokensForEngine(engineName, modelId) {
-    const override = envOverrideForEngine(engineName, modelId);
-    if (override != null)
-        return override;
+    const providerOverride = providerEnvOverride(engineName, modelId);
+    if (providerOverride != null)
+        return providerOverride;
+    const configured = normalizeMaxOutputTokens(getAppConfig().agent.maxOutputTokens, modelId);
+    if (configured != null)
+        return configured;
     if (engineName === "builder")
         return DEFAULT_BUILDER_MAX_OUTPUT_TOKENS;
     if (engineName === "anthropic" || engineName === "ai-sdk:anthropic") {

package/dist/agent/engine/registry.d.ts

@@ -69,7 +69,7 @@ export interface NormalizeModelOptions {
      * The settings actions call `normalizeModelForEngine` with a static registry
      * ENTRY, which never carries the runtime `preserveCustomModels` flag — that
      * is only set on the engine INSTANCE created with an OpenAI-compatible
-     * `baseUrl`. They resolve the capability with
+     * `baseUrl` or the OpenRouter provider. They resolve the capability with
      * {@link resolveEnginePreservesCustomModels} and pass it here so a gateway
      * model (e.g. an Ollama `gemma4`) is not rewritten to the OpenAI default on
      * save/read. First-party OpenAI (no gateway) leaves this unset, so an unknown

package/dist/agent/engine/registry.js

@@ -11,14 +11,15 @@ import { createRequire } from "node:module";
 import { getAppConfig } from "../../app-config/index.js";
 import { BUILDER_OAUTH_SCOPE, hasBuilderOAuthSession, resolveBuilderOAuthRequestAccess, } from "../../server/builder-oauth.js";
 import { assertCredentialStoreReadable, canUseDeployCredentialFallbackForRequest, getBuilderCredentialAuthFailure, getProviderCredentialAuthFailure, readDeployCredentialEnv, resolveBuilderCredentialsDetailed, resolveBuilderGatewayCredentialsDetailed, resolveSecret, } from "../../server/credential-provider.js";
-import { getRequestUserEmail } from "../../server/request-context.js";
+import { getRequestOrgId, getRequestContext, getRequestUserEmail, } from "../../server/request-context.js";
 import { getSetting } from "../../settings/store.js";
 import { getAgentAppModelDefaultForCurrentRequest } from "../app-model-defaults.js";
-import { OLLAMA_BASE_URL_ENV_VAR, OPENAI_BASE_URL_ENV_VAR, } from "./openai-compatible-endpoint.js";
+import { OLLAMA_BASE_URL_ENV_VAR, OPENAI_BASE_URL_ENV_VAR, isCustomOpenAiBaseUrl, } from "./openai-compatible-endpoint.js";
 import { validateProviderBaseUrl } from "./provider-endpoint-validation.js";
 const require = createRequire(import.meta.url);
 const _registry = new Map();
 const _packageAvailabilityCache = new Map();
+const AGENT_NATIVE_BUILD_ENGINE_PACKAGES_ENV_VAR = "AGENT_NATIVE_BUILD_ENGINE_PACKAGES";
 /**
  * Register a custom agent engine. Called at server startup (e.g., from a
  * server plugin or builtin.ts). Throws if name is already registered.
@@ -77,9 +78,11 @@ function packageNameFromInstallSpecifier(specifier) {
  * bundle and are therefore NOT resolvable via `require.resolve` — even though
  * the dynamic `import()` the engine uses to load them still works.
  *
- * Deliberately narrow. The Nitro Vercel/Netlify presets (which agent-native's
- * own `deploy` command emits) inline optional peers and always set these env
- * markers, so they are a reliable signal. Other serverless runtimes — a
+ * Deliberately narrow. Deploy builds provide package-specific evidence because
+ * these runtime markers may be absent once a Function executes. When that
+ * marker is absent, the Nitro Vercel/Netlify presets (which agent-native's own
+ * `deploy` command emits) inline optional peers and these env markers remain a
+ * fallback signal. Other serverless runtimes — a
  * container on Cloud Run / Google Cloud Functions (`K_SERVICE` /
  * `FUNCTION_TARGET`), or a plain AWS Lambda — commonly ship a real
  * `node_modules` where `require.resolve` is authoritative; there a resolve miss
@@ -89,10 +92,16 @@ function packageNameFromInstallSpecifier(specifier) {
  */
 function isBundledServerlessRuntime() {
     const env = process.env;
+    if (isLocalNetlifyRuntime())
+        return false;
     // Nitro's Vercel/Netlify presets inline optional peers into the function
     // bundle; these platforms always set these markers.
-    if (env.VERCEL || env.NETLIFY)
+    if (env.VERCEL || env.NETLIFY || env.NETLIFY_FUNCTION_NAME)
         return true;
+    // Netlify documents SITE_ID as a runtime marker, while NETLIFY is primarily
+    // a build-time variable and may be absent once the Function executes.
+    if (env.SITE_ID)
+        return true; // guard:allow-env-credential - Netlify runtime host marker, not a credential.
     // Otherwise require direct evidence that this module is running from inside a
     // bundle output directory (Vercel's `/var/task`, Nitro's `.output/server`,
     // inlined `_libs`). This is the real signal that `require.resolve` cannot be
@@ -106,6 +115,28 @@ function isBundledServerlessRuntime() {
         return false;
     }
 }
+function isLocalNetlifyRuntime() {
+    const env = process.env;
+    return (/^(1|true)$/i.test(env.NETLIFY_LOCAL ?? "") ||
+        /^(1|true)$/i.test(env.NETLIFY_DEV ?? ""));
+}
+function resolveBuildBundledEnginePackages() {
+    const marker = getAppConfig().agent.buildEnginePackages;
+    if (marker === undefined)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(marker);
+    }
+    catch {
+        throw new Error(`[agent-engine] ${AGENT_NATIVE_BUILD_ENGINE_PACKAGES_ENV_VAR} is not valid JSON.`);
+    }
+    if (!Array.isArray(parsed) ||
+        parsed.some((packageName) => typeof packageName !== "string")) {
+        throw new Error(`[agent-engine] ${AGENT_NATIVE_BUILD_ENGINE_PACKAGES_ENV_VAR} must be a JSON array of package names.`);
+    }
+    return new Set(parsed);
+}
 function canResolvePackage(packageName) {
     const cached = _packageAvailabilityCache.get(packageName);
     if (cached !== undefined)
@@ -119,12 +150,22 @@ function canResolvePackage(packageName) {
         // Bundled serverless runtimes (e.g. Nitro on Vercel/Netlify) inline optional
         // provider packages into the function bundle, so require.resolve cannot find
         // them even though the dynamic `import()` the engine actually uses to load
-        // them works. Treat them as available there and let the engine's own import
-        // be the real gate — it already fails with a clear "pnpm add …" message when
-        // the package is genuinely missing. Without this, every engine-usability
-        // gate rejects the AI-SDK engines at runtime and the agent silently falls
-        // back to the native Anthropic engine.
-        available = isBundledServerlessRuntime();
+        // them works. New deploys use the build marker below as package-specific
+        // evidence; older deploys retain the narrow platform/path fallback. Without
+        // either signal, every engine-usability gate rejects the AI-SDK engines at
+        // runtime and the agent silently falls back to the native Anthropic engine.
+        const bundledPackages = isLocalNetlifyRuntime()
+            ? undefined
+            : resolveBuildBundledEnginePackages();
+        if (bundledPackages) {
+            // New deploys provide package-specific build evidence. Older deploys do
+            // not have the marker, so retain their platform/path fallback until they
+            // are naturally replaced by a build carrying it.
+            available = bundledPackages.has(packageName);
+        }
+        else if (isBundledServerlessRuntime()) {
+            available = true;
+        }
     }
     _packageAvailabilityCache.set(packageName, available);
     return available;
@@ -262,12 +303,13 @@ export function resolveDelegatedRunModel(engine, options) {
  * still normalizes to a supported one.
  */
 export async function resolveEnginePreservesCustomModels(entry) {
-    if (entry.name === "ai-sdk:ollama")
+    if (entry.name === "ai-sdk:ollama" || entry.name === "ai-sdk:openrouter") {
         return true;
+    }
     if (entry.name !== "ai-sdk:openai")
         return false;
     try {
-        return Boolean(await resolveProviderBaseUrl(OPENAI_BASE_URL_ENV_VAR));
+        return isCustomOpenAiBaseUrl(await resolveProviderBaseUrl(OPENAI_BASE_URL_ENV_VAR));
     }
     catch {
         return false;
@@ -571,12 +613,15 @@ async function resolveProviderBaseUrl(envVar) {
  */
 async function builderOAuthLaneUsable(identity) {
     const ownerEmail = identity?.userEmail?.trim().toLowerCase() || getRequestUserEmail();
-    if (!ownerEmail || !(await hasBuilderOAuthSession(ownerEmail)))
+    const orgId = identity?.orgId !== undefined ? identity.orgId : getRequestOrgId();
+    const requestOrgId = orgId ?? null;
+    if (!ownerEmail || !(await hasBuilderOAuthSession(ownerEmail, requestOrgId)))
         return null;
     try {
         return Boolean(await resolveBuilderOAuthRequestAccess({
             ownerEmail,
             requiredScope: BUILDER_OAUTH_SCOPE,
+            orgId: requestOrgId,
         }));
     }
     catch {
@@ -928,7 +973,15 @@ export async function resolveEngine(config) {
         const entry = _registry.get(envEngine);
         if (entry) {
             assertAgentEnginePackageInstalled(entry);
-            return entry.create(await engineCreateConfigForEntry(entry, apiKey, undefined, "automatic", apiKeyEnvVar, credentialIdentity));
+            // Synthetic checks cannot use deploy-wide credentials, but may validate
+            // the dedicated user-scoped credential they install for the request.
+            const canUseConfiguredEngine = getRequestContext()?.isSyntheticTraffic !== true ||
+                (await isStoredEngineUsableForRequest({ engine: entry.name }, entry, {
+                    credentialIdentity,
+                }));
+            if (canUseConfiguredEngine) {
+                return entry.create(await engineCreateConfigForEntry(entry, apiKey, undefined, "automatic", apiKeyEnvVar, credentialIdentity));
+            }
         }
     }
     const appDefault = await getAgentAppModelDefaultForCurrentRequest(appId);