@agent-native/core 0.202.0 → 0.202.1-nightly-20261007011022

package/dist/client/chat-model-groups.d.ts

@@ -3,6 +3,7 @@ export interface EngineModelGroup {
     label: string;
     models: string[];
     modelDisplayNames?: Readonly<Record<string, string>>;
+    preserveCustomModels?: boolean;
     configured: boolean;
     isSubscription?: boolean;
 }

package/dist/client/chat-model-groups.js

@@ -168,6 +168,7 @@ export function buildChatModelGroups({ engines, configuredKeys, builderConnected
             ...(engine.modelDisplayNames
                 ? { modelDisplayNames: engine.modelDisplayNames }
                 : {}),
+            ...(engine.preserveCustomModels ? { preserveCustomModels: true } : {}),
             configured: engine.configured ??
                 (requiredEnvVars.length === 0 ||
                     requiredEnvVars.some((key) => configured.has(key))),

package/dist/client/use-chat-models.js

@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useRef, useState } from "react";
 import { DEFAULT_MODEL } from "../agent/default-model.js";
+import { upgradeModelToLatestSupportedVersion } from "../agent/model-version.js";
 export { DEFAULT_MODEL };
 import { DEFAULT_REASONING_EFFORT, getReasoningEffortOptionsForModel, resolveReasoningEffortSelection, } from "../shared/reasoning-effort.js";
 import { fetchOllamaModels } from "./agent-engine-key.js";
@@ -274,21 +275,61 @@ export function useChatModels({ storageKey = DEFAULT_STORAGE_KEY, enabled = true
                     finish();
                     return;
                 }
-                const selectableGroups = unavailableSelectionPolicy === "require-explicit"
+                const selectableGroups = unavailableSelectionPolicy === "require-explicit" ||
+                    !selection.selectedEngine
                     ? configuredGroups
                     : groups;
-                const selectedGroup = selectableGroups.find((group) => group.models.includes(selection.selectedModel) &&
+                const exactSelectedGroups = selectableGroups.filter((group) => (group.models.includes(selection.selectedModel) ||
+                    (selection.selectedEngine === group.engine &&
+                        group.preserveCustomModels)) &&
                     (!selection.selectedEngine ||
                         group.engine === selection.selectedEngine));
+                const exactSelectedGroup = selection.selectedEngine
+                    ? exactSelectedGroups[0]
+                    : new Set(exactSelectedGroups.map((group) => group.engine)).size ===
+                        1
+                        ? exactSelectedGroups[0]
+                        : undefined;
+                const upgradeCandidates = exactSelectedGroup
+                    ? []
+                    : selectableGroups.flatMap((group) => {
+                        if (selection.selectedEngine &&
+                            group.engine !== selection.selectedEngine) {
+                            return [];
+                        }
+                        const model = group.preserveCustomModels &&
+                            selection.selectedEngine === group.engine
+                            ? selection.selectedModel
+                            : upgradeModelToLatestSupportedVersion(selection.selectedModel, group.models);
+                        return model ? [{ group, model }] : [];
+                    });
+                const upgradeCandidateKeys = new Set(upgradeCandidates.map(({ group, model }) => JSON.stringify([group.engine, model])));
+                const upgradedSelection = upgradeCandidateKeys.size === 1 ? upgradeCandidates[0] : undefined;
+                const selectedGroup = exactSelectedGroup ?? upgradedSelection?.group;
                 if (selectedGroup) {
+                    const selectedModel = upgradeModelToLatestSupportedVersion(selection.selectedModel, selectedGroup.models) ?? selection.selectedModel;
+                    const nextSelection = {
+                        ...selection,
+                        selectedModel,
+                        selectedEngine: selectedGroup.engine,
+                    };
                     unavailableSelectionRef.current = null;
                     setUnavailableSelection(null);
-                    if (selection.selectedEngine !== selectedGroup.engine) {
+                    if (selectionRef.current.selectedEngine !== selectedGroup.engine) {
                         setSelectedEngine(selectedGroup.engine);
                     }
-                    if (selectionRef.current.selectedModel !== selection.selectedModel) {
-                        setSelectedModel(selection.selectedModel);
-                        setSelectedEffort(selection.selectedEffort);
+                    if (selectionRef.current.selectedModel !== selectedModel) {
+                        setSelectedModel(selectedModel);
+                        setSelectedEffort(resolveReasoningEffortSelection(selectedModel, selection.selectedEffort));
+                    }
+                    if (selection.selectedModel !== selectedModel ||
+                        selection.selectedEngine !== selectedGroup.engine) {
+                        selectionRef.current = nextSelection;
+                        writePersisted(storageKey, {
+                            model: selectedModel,
+                            engine: selectedGroup.engine,
+                            effort: resolveReasoningEffortSelection(selectedModel, selection.selectedEffort),
+                        });
                     }
                     finish();
                     return;

package/dist/deploy/build.js

@@ -1414,9 +1414,9 @@ function getRealtimeClientConfigScript() {
 function getAppOriginClientConfigScript() {
   // MUST stay consistent with resolvePublicAppOriginConfig in
   // server/app-origin-config.ts, and with the alias order declared on
-  // app.url / workspace.* in app-config (worker bundles a string copy; it
-  // can't import them). Impersonal values only — this ships into the
-  // CDN-cached shell.
+  // app.id / app.workspaceId / app.url / workspace.* in app-config (worker
+  // bundles a string copy; it can't import them). Impersonal values only —
+  // this ships into the CDN-cached shell.
   const env = globalThis.process?.env || {};
   const appUrl = firstNonEmpty(
     env.APP_URL,
@@ -1479,23 +1479,37 @@ function getAppOriginClientConfigScript() {
       return;
     }
   })();
-  const appHomePath = resolveAgentNativeAppHomePath(
-    getAgentNativeAppConfig().app,
-    getAgentNativeAppConfig().workspace,
-  );
+  const appConfig = getAgentNativeAppConfig();
   const config = {
-    appHomePath,
+    ...(appConfig.app.id ? { appId: appConfig.app.id } : {}),
+    ...(appConfig.app.workspaceId
+      ? { workspaceAppId: appConfig.app.workspaceId }
+      : {}),
+    appHomePath: resolveAgentNativeAppHomePath(
+      appConfig.app,
+      appConfig.workspace,
+    ),
     ...(appUrl ? { appUrl } : {}),
     ...(workspaceGatewayUrl ? { workspaceGatewayUrl } : {}),
     ...(workspaceOAuthOrigin ? { workspaceOAuthOrigin } : {}),
     ...(workspaceRuntime ? { workspaceRuntime: true } : {}),
     ...(workspaceAppMountPaths ? { workspaceAppMountPaths } : {}),
   };
+  const toUnicodeEscape = (character) =>
+    String.fromCharCode(92) +
+    "u" +
+    character.charCodeAt(0).toString(16).padStart(4, "0");
+  let serializedConfig = JSON.stringify(config).replace(/[<>&]/g, toUnicodeEscape);
+  for (const character of [String.fromCharCode(0x2028), String.fromCharCode(0x2029)]) {
+    serializedConfig = serializedConfig
+      .split(character)
+      .join(toUnicodeEscape(character));
+  }
   if (Object.keys(config).length === 0) return null;
   return (
     '<script data-agent-native-app-origin-config>' +
     'window.__AGENT_NATIVE_CONFIG__=Object.assign({},window.__AGENT_NATIVE_CONFIG__,' +
-    JSON.stringify(config) +
+    serializedConfig +
     ");</script>"
   );
 }

package/dist/email-catalog/redact-body.js

@@ -1,5 +1,5 @@
 const URL_PATTERN = /https?:\/\/[^\s"'<>)]+|(?<=["'\s]|^)\/\/[^\s"'<>)]+/gi;
-const SENSITIVE_URL_PATH_PATTERN = /\/(?:reset-password|password-reset|magic-link|magic_link|verify-email|email-verification|verification|confirm-email|auth\/callback|sso\/callback|unlock-account)(?:[/?]|$)/i;
+const SENSITIVE_URL_PATH_PATTERN = /\/(?:reset-password|password-reset|magic-link|magic_link|email-link|verify-email|email-verification|verification|confirm-email|auth\/callback|sso\/callback|unlock-account)(?:[/?]|$)/i;
 const SENSITIVE_QUERY_PARAM_PATTERN = /(?:\?|#|&(?:amp;)?)(?:token|code|otp|otp_code|otpcode|verification_code|verificationcode|verify_token|verifytoken|reset_token|resettoken|magic|auth|auth_token|authtoken|session|sid|sig|signature|secret|key|nonce|access_token|accesstoken|id_token|idtoken|oobcode)=/i;
 const JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\b/g;
 const OTP_KEYWORD_PATTERN = /\b(?:otp|one[- ]time\s+(?:password|code|pin)|verification\s+code|security\s+code|access\s+code|passcode|pin\s+code|login\s+code)\b/i;

package/dist/jobs/actions/manage-recurring-job.d.ts

@@ -11,9 +11,9 @@ declare const _default: import("../../action.js").ActionDefinition<{
     enabled?: undefined;
     nextRun?: undefined;
 } | {
+    deleted?: undefined;
     name: string;
     enabled: boolean;
     nextRun: string;
-    deleted?: undefined;
 }>;
 export default _default;

package/dist/jobs/background-automation-runner.d.ts

@@ -111,8 +111,10 @@ export declare function runBackgroundAutomation(options: BackgroundAutomationRun
 export declare function checkBackgroundAutomationCredentials(identity: {
     ownerEmail: string;
     orgId?: string;
-}, deps: BackgroundAutomationDeps): Promise<{
+}, deps: BackgroundAutomationDeps, automationModel?: string): Promise<{
     ok: true;
+    engine: AgentEngine;
+    model: string;
 } | {
     ok: false;
     failure: AutomationFailure;

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

@@ -481,15 +481,26 @@ async function resolveUsableBackgroundEngine(identity, deps, assertDeadline) {
     await assertLlmCredentialsUsable({ engine, apiKey, ownerEmail, orgId });
     return engine;
 }
+async function resolveBackgroundAutomationModel(engine, automationModel, deps) {
+    const modelCandidate = automationModel ??
+        deps.model ??
+        (await getStoredModelForEngine(engine, { appId: deps.appId })) ??
+        engine.defaultModel;
+    return normalizeModelForEngine(engine, modelCandidate);
+}
 /**
  * Whether the automation's run identity has a usable LLM credential right now,
  * without starting a run. The scheduler asks this to resume an automation it
  * paused for `missing_credentials` as soon as the credential exists.
  */
-export async function checkBackgroundAutomationCredentials(identity, deps) {
+export async function checkBackgroundAutomationCredentials(identity, deps, automationModel) {
     try {
-        await runWithRequestContext({ userEmail: identity.ownerEmail, orgId: identity.orgId }, () => resolveUsableBackgroundEngine(identity, deps, () => undefined));
-        return { ok: true };
+        const { engine, model } = await runWithRequestContext({ userEmail: identity.ownerEmail, orgId: identity.orgId }, async () => {
+            const engine = await resolveUsableBackgroundEngine(identity, deps, () => undefined);
+            const model = await resolveBackgroundAutomationModel(engine, automationModel, deps);
+            return { engine, model };
+        });
+        return { ok: true, engine, model };
     }
     catch (error) {
         return { ok: false, failure: classifyAutomationFailure(error) };
@@ -522,11 +533,7 @@ async function executeBackgroundAutomation(options, deps, historyId, runIdRef) {
         await assertDeliveryTargetSupported(automation);
         const engine = await resolveUsableBackgroundEngine({ ownerEmail, orgId }, deps, () => assertHardDeadline(options.hardDeadlineAt));
         assertHardDeadline(options.hardDeadlineAt);
-        const modelCandidate = automation.meta.model ??
-            deps.model ??
-            (await getStoredModelForEngine(engine, { appId: deps.appId })) ??
-            engine.defaultModel;
-        const model = normalizeModelForEngine(engine, modelCandidate);
+        const model = await resolveBackgroundAutomationModel(engine, automation.meta.model, deps);
         assertHardDeadline(options.hardDeadlineAt);
         const systemPrompt = await deps.getSystemPrompt(ownerEmail);
         assertHardDeadline(options.hardDeadlineAt);

package/dist/jobs/scheduler.js

@@ -470,7 +470,7 @@ async function resumeRecoveredPauses(paused, deps, now) {
                 (await checkBackgroundAutomationCredentials({
                     ownerEmail: identity.identity.userEmail,
                     orgId: identity.identity.orgId,
-                }, deps)).ok;
+                }, deps, meta.model)).ok;
             if (!recovered) {
                 await updateResource(resource, { ...meta, lastCheck: now.toISOString() }, body);
                 continue;

package/dist/mcp/build-server.d.ts

@@ -50,7 +50,6 @@ export interface MCPConfig {
         instructions?: string;
         widgets?: boolean;
         widgetDomain?: string;
-        widgetDiagnostic?: "tiny-html" | "no-frame-domains";
         keyToolNames?: readonly string[];
         toolDescriptions?: Record<string, string>;
         toolParameterDescriptions?: Record<string, Record<string, string>>;

package/dist/mcp/build-server.js

@@ -881,7 +881,7 @@ function openAiWidgetCsp(cspConfig, requestMeta) {
         csp.frame_domains = frameDomains;
     return Object.keys(csp).length > 0 ? csp : undefined;
 }
-function mcpAppUiMeta(resource, resolvedCsp, requestMeta, description, widgetDomain, directoryMode = false, widgetDiagnostic) {
+function mcpAppUiMeta(resource, resolvedCsp, requestMeta, description, widgetDomain, directoryMode = false) {
     const base = resource._meta && typeof resource._meta === "object"
         ? { ...resource._meta }
         : {};
@@ -890,32 +890,23 @@ function mcpAppUiMeta(resource, resolvedCsp, requestMeta, description, widgetDom
         : {};
     const ui = { ...existingUi };
     delete ui.domain;
-    const omitFrameDomains = directoryMode && widgetDiagnostic === "no-frame-domains";
     if (directoryMode &&
         ui.csp &&
         typeof ui.csp === "object" &&
         !Array.isArray(ui.csp)) {
         const csp = { ...ui.csp };
         delete csp.baseUriDomains;
-        if (omitFrameDomains)
-            delete csp.frameDomains;
         ui.csp = csp;
     }
     if (resolvedCsp) {
         const csp = { ...resolvedCsp };
         if (directoryMode)
             delete csp.baseUriDomains;
-        if (omitFrameDomains)
-            delete csp.frameDomains;
         ui.csp = {
             ...csp,
             connectDomains: expandRequestOriginSources(resolvedCsp.connectDomains, requestMeta),
             resourceDomains: expandRequestOriginSources(resolvedCsp.resourceDomains, requestMeta),
-            ...(!omitFrameDomains
-                ? {
-                    frameDomains: expandRequestOriginSources(resolvedCsp.frameDomains, requestMeta),
-                }
-                : {}),
+            frameDomains: expandRequestOriginSources(resolvedCsp.frameDomains, requestMeta),
             ...(!directoryMode
                 ? {
                     baseUriDomains: expandRequestOriginSources(resolvedCsp.baseUriDomains, requestMeta),
@@ -927,21 +918,15 @@ function mcpAppUiMeta(resource, resolvedCsp, requestMeta, description, widgetDom
         ui.permissions = resource.permissions;
     const hostSpecificDomain = hostSpecificDomainString(resource.domain) ??
         hostSpecificDomainString(existingUi.domain);
-    if (omitFrameDomains) {
-        delete ui.domain;
-        delete base["openai/widgetDomain"];
-    }
-    else if (widgetDomain)
+    if (widgetDomain)
         ui.domain = widgetDomain;
     else if (hostSpecificDomain)
         ui.domain = hostSpecificDomain;
-    const openAiWidgetDomain = omitFrameDomains
-        ? undefined
-        : (originString(widgetDomain) ??
-            originString(resource.domain) ??
-            originString(ui.domain) ??
-            originString(existingUi.domain) ??
-            originString(requestMeta?.origin));
+    const openAiWidgetDomain = originString(widgetDomain) ??
+        originString(resource.domain) ??
+        originString(ui.domain) ??
+        originString(existingUi.domain) ??
+        originString(requestMeta?.origin);
     if (typeof resource.prefersBorder === "boolean") {
         ui.prefersBorder = resource.prefersBorder;
     }
@@ -957,8 +942,6 @@ function mcpAppUiMeta(resource, resolvedCsp, requestMeta, description, widgetDom
     const openAiCsp = openAiWidgetCsp(resolvedCsp, requestMeta);
     if (directoryMode) {
         const directoryCsp = { ...(openAiCsp ?? {}) };
-        if (omitFrameDomains)
-            delete directoryCsp.frame_domains;
         const redirectDomain = originString(widgetDomain);
         if (redirectDomain)
             directoryCsp.redirect_domains = [redirectDomain];
@@ -977,8 +960,7 @@ function mcpAppUiMeta(resource, resolvedCsp, requestMeta, description, widgetDom
     else if (openAiCsp && base["openai/widgetCSP"] == null) {
         base["openai/widgetCSP"] = openAiCsp;
     }
-    if (!omitFrameDomains &&
-        openAiWidgetDomain &&
+    if (openAiWidgetDomain &&
         (widgetDomain || base["openai/widgetDomain"] == null)) {
         base["openai/widgetDomain"] = openAiWidgetDomain;
     }
@@ -1005,9 +987,7 @@ async function resolveMcpAppResource(config, actionName, entry, requestMeta) {
         requestOrigin: requestMeta?.origin,
         catalogMode: config.catalogMode,
     });
-    const resourceMeta = mcpAppUiMeta(resource, resolvedCsp, requestMeta, description, config.catalogMode === "directory" ? config.widgetDomain : undefined, config.catalogMode === "directory", config.catalogMode === "directory"
-        ? config.directoryProfile?.widgetDiagnostic
-        : undefined);
+    const resourceMeta = mcpAppUiMeta(resource, resolvedCsp, requestMeta, description, config.catalogMode === "directory" ? config.widgetDomain : undefined, config.catalogMode === "directory");
     return {
         uri: resolvedUri.uri,
         ...(resolvedUri.legacyUris ? { legacyUris: resolvedUri.legacyUris } : {}),
@@ -1065,36 +1045,7 @@ async function getMcpAppResources(config, actions, requestMeta) {
         return true;
     });
 }
-const DIRECTORY_TINY_WIDGET_HTML = [
-    "<!doctype html>",
-    '<html lang="en">',
-    "<head>",
-    '  <meta charset="utf-8">',
-    '  <meta name="viewport" content="width=device-width, initial-scale=1">',
-    "  <title>Widget resource size diagnostic</title>",
-    "  <style>",
-    "    :root { color-scheme: light dark; font-family: system-ui, sans-serif; }",
-    "    body { margin: 0; min-height: 100vh; display: grid; place-items: center; background: Canvas; color: CanvasText; }",
-    "    main { width: min(42rem, calc(100% - 3rem)); padding: 2rem; border: 1px solid color-mix(in srgb, CanvasText 20%, Canvas); border-radius: 1rem; }",
-    "    h1 { margin: 0 0 1rem; font-size: 1.4rem; }",
-    "    p { line-height: 1.6; }",
-    "  </style>",
-    "</head>",
-    "<body>",
-    '  <main role="status">',
-    "    <h1>Widget resource size diagnostic</h1>",
-    "    <p>This temporary resource replaces the full Agent-Native Slides widget shell while the ChatGPT plugin scan is being diagnosed.</p>",
-    "    <p>The Slides app and its MCP tools remain available. This page measures whether the review scan completes when the linked HTML resource is small.</p>",
-    "    <p>After the scan experiment, remove this diagnostic lane and restore the production widget resource.</p>",
-    "  </main>",
-    "</body>",
-    "</html>",
-].join("\n");
 function renderMcpAppHtml(resource, actionName, config, requestMeta) {
-    if (config.catalogMode === "directory" &&
-        config.directoryProfile?.widgetDiagnostic === "tiny-html") {
-        return DIRECTORY_TINY_WIDGET_HTML;
-    }
     if (typeof resource.html === "function") {
         return resource.html({
             actionName,

package/dist/observability/routes.d.ts

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

package/dist/onboarding/app-profile-data.d.ts

@@ -0,0 +1,10 @@
+import type { OnboardingAppProfile } from "./types.js";
+export declare function normalizeOnboardingAppId(value: string | undefined): string;
+/**
+ * The app's setup profile: the shared workspace services first (see
+ * `WORKSPACE_SERVICES`), each tagged with its `service` id, then the app's
+ * own capabilities. A profile that declares a
+ * service's capability tailors its copy and can raise it to required or
+ * recommended, never lower it.
+ */
+export declare function getOnboardingAppProfileForId(appId?: string): OnboardingAppProfile;