@agent-native/core 0.202.0-nightly-20261006153106 → 0.202.0

package/dist/mcp/build-server.js

@@ -194,6 +194,9 @@ export function validateMcpDirectoryProfile(config, sourceActions = config.produ
             typeof annotations.openWorldHint !== "boolean") {
             throw new McpDirectoryProfileValidationError(`[agent-native] MCP directory catalog action "${name}" must declare boolean readOnlyHint, destructiveHint, and openWorldHint values.`);
         }
+        if (annotations.readOnlyHint !== (entry.readOnly === true)) {
+            throw new McpDirectoryProfileValidationError(`[agent-native] MCP directory catalog action "${name}" readOnlyHint must match its readOnly action setting.`);
+        }
     }
     for (const map of [
         config.directoryProfile?.toolDescriptions,
@@ -602,11 +605,18 @@ function mcpAppEmbedOpenLinkMeta(result, resource, meta) {
             : {}),
     };
 }
-async function withServerMintedMcpAppEmbedStart(result, meta, directoryLinkUrl) {
+async function withServerMintedMcpAppEmbedStart(result, meta, directoryLinkUrl, suppressDirectoryReadOnlyEmbed = false) {
     if (!result || typeof result !== "object" || Array.isArray(result)) {
         return result;
     }
     const out = result;
+    if (suppressDirectoryReadOnlyEmbed) {
+        const resultWithoutEmbedSession = { ...out };
+        delete resultWithoutEmbedSession.embedStartUrl;
+        delete resultWithoutEmbedSession.embedTargetPath;
+        delete resultWithoutEmbedSession.embedExpiresAt;
+        return resultWithoutEmbedSession;
+    }
     if (out.embed === false || (out.embed !== true && !directoryLinkUrl)) {
         return result;
     }
@@ -759,16 +769,17 @@ function safeUiSegment(value, fallback) {
     return normalized || fallback;
 }
 const MCP_APP_RESOURCE_SHELL_VERSION = "shell-v65";
+const MCP_DIRECTORY_APP_RESOURCE_SHELL_VERSION = "shell-v66";
 function legacyDefaultMcpAppUri(config, actionName) {
     const app = safeUiSegment(config.appId ?? config.name, "agent-native");
     const action = safeUiSegment(actionName, "tool");
     return `ui://${app}/${action}`;
 }
-function versionMcpAppResourceUri(rawUri) {
+function versionMcpAppResourceUri(rawUri, shellVersion = MCP_APP_RESOURCE_SHELL_VERSION) {
     const uri = rawUri.trim();
     if (!uri.startsWith("ui://"))
         return null;
-    const versionSuffix = `/${MCP_APP_RESOURCE_SHELL_VERSION}`;
+    const versionSuffix = "/" + shellVersion;
     let versionedUri;
     try {
         const parsed = new URL(uri);
@@ -826,7 +837,26 @@ function getMcpAppResourceUri(config, actionName, entry) {
     if (!resource)
         return null;
     const baseUri = resource.uri?.trim() || legacyDefaultMcpAppUri(config, actionName);
-    return versionMcpAppResourceUri(baseUri);
+    const actionResource = versionMcpAppResourceUri(baseUri);
+    if (!actionResource ||
+        config.catalogMode !== "directory" ||
+        !mcpAppWidgetsEnabled(config)) {
+        return actionResource;
+    }
+    const app = safeUiSegment(config.appId ?? config.name, "agent-native");
+    const sharedResource = versionMcpAppResourceUri("ui://" + app + "/" + MCP_DIRECTORY_APP_RESOURCE_SHELL_VERSION, MCP_DIRECTORY_APP_RESOURCE_SHELL_VERSION);
+    if (!sharedResource)
+        return actionResource;
+    return {
+        ...sharedResource,
+        legacyUris: [
+            ...new Set([
+                ...(sharedResource.legacyUris ?? []),
+                actionResource.uri,
+                ...(actionResource.legacyUris ?? []),
+            ]),
+        ],
+    };
 }
 function expandRequestOriginSources(sources, requestMeta) {
     if (!sources)
@@ -851,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) {
+function mcpAppUiMeta(resource, resolvedCsp, requestMeta, description, widgetDomain, directoryMode = false, widgetDiagnostic) {
     const base = resource._meta && typeof resource._meta === "object"
         ? { ...resource._meta }
         : {};
@@ -860,23 +890,32 @@ 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),
-            frameDomains: expandRequestOriginSources(resolvedCsp.frameDomains, requestMeta),
+            ...(!omitFrameDomains
+                ? {
+                    frameDomains: expandRequestOriginSources(resolvedCsp.frameDomains, requestMeta),
+                }
+                : {}),
             ...(!directoryMode
                 ? {
                     baseUriDomains: expandRequestOriginSources(resolvedCsp.baseUriDomains, requestMeta),
@@ -888,15 +927,21 @@ function mcpAppUiMeta(resource, resolvedCsp, requestMeta, description, widgetDom
         ui.permissions = resource.permissions;
     const hostSpecificDomain = hostSpecificDomainString(resource.domain) ??
         hostSpecificDomainString(existingUi.domain);
-    if (widgetDomain)
+    if (omitFrameDomains) {
+        delete ui.domain;
+        delete base["openai/widgetDomain"];
+    }
+    else if (widgetDomain)
         ui.domain = widgetDomain;
     else if (hostSpecificDomain)
         ui.domain = hostSpecificDomain;
-    const openAiWidgetDomain = originString(widgetDomain) ??
-        originString(resource.domain) ??
-        originString(ui.domain) ??
-        originString(existingUi.domain) ??
-        originString(requestMeta?.origin);
+    const openAiWidgetDomain = omitFrameDomains
+        ? undefined
+        : (originString(widgetDomain) ??
+            originString(resource.domain) ??
+            originString(ui.domain) ??
+            originString(existingUi.domain) ??
+            originString(requestMeta?.origin));
     if (typeof resource.prefersBorder === "boolean") {
         ui.prefersBorder = resource.prefersBorder;
     }
@@ -910,10 +955,30 @@ function mcpAppUiMeta(resource, resolvedCsp, requestMeta, description, widgetDom
         base["openai/widgetPrefersBorder"] = resource.prefersBorder;
     }
     const openAiCsp = openAiWidgetCsp(resolvedCsp, requestMeta);
-    if (openAiCsp && base["openai/widgetCSP"] == null) {
+    if (directoryMode) {
+        const directoryCsp = { ...(openAiCsp ?? {}) };
+        if (omitFrameDomains)
+            delete directoryCsp.frame_domains;
+        const redirectDomain = originString(widgetDomain);
+        if (redirectDomain)
+            directoryCsp.redirect_domains = [redirectDomain];
+        if (Object.keys(directoryCsp).length > 0) {
+            base["openai/widgetCSP"] = directoryCsp;
+        }
+        else {
+            delete base["openai/widgetCSP"];
+        }
+        const openAiUi = metadataObject(base["openai/ui"]);
+        base["openai/ui"] = {
+            ...openAiUi,
+            availableDisplayModes: ["inline", "fullscreen"],
+        };
+    }
+    else if (openAiCsp && base["openai/widgetCSP"] == null) {
         base["openai/widgetCSP"] = openAiCsp;
     }
-    if (openAiWidgetDomain &&
+    if (!omitFrameDomains &&
+        openAiWidgetDomain &&
         (widgetDomain || base["openai/widgetDomain"] == null)) {
         base["openai/widgetDomain"] = openAiWidgetDomain;
     }
@@ -940,7 +1005,9 @@ 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");
+    const resourceMeta = mcpAppUiMeta(resource, resolvedCsp, requestMeta, description, config.catalogMode === "directory" ? config.widgetDomain : undefined, config.catalogMode === "directory", config.catalogMode === "directory"
+        ? config.directoryProfile?.widgetDiagnostic
+        : undefined);
     return {
         uri: resolvedUri.uri,
         ...(resolvedUri.legacyUris ? { legacyUris: resolvedUri.legacyUris } : {}),
@@ -966,12 +1033,14 @@ function mcpAppWidgetsEnabled(config) {
         config.directoryProfile?.widgets === false);
 }
 function stripDirectoryWidgetMeta(config, metadata) {
-    if (mcpAppWidgetsEnabled(config))
+    if (config.catalogMode !== "directory")
         return;
     delete metadata.ui;
     delete metadata[MCP_APP_RESOURCE_URI_META_KEY];
     delete metadata["openai/ui"];
     delete metadata["openai/outputTemplate"];
+    delete metadata["openai/toolInvocation/invoking"];
+    delete metadata["openai/toolInvocation/invoked"];
     for (const key of Object.keys(metadata)) {
         if (key.startsWith("openai/widget"))
             delete metadata[key];
@@ -980,10 +1049,52 @@ function stripDirectoryWidgetMeta(config, metadata) {
 async function getMcpAppResources(config, actions, requestMeta) {
     if (!requestMeta?.inlineMcpApps || !mcpAppWidgetsEnabled(config))
         return [];
-    const resources = await Promise.all(Object.entries(actions).map(([name, entry]) => resolveMcpAppResourceSafely(config, name, entry, requestMeta)));
-    return resources.filter((resource) => Boolean(resource));
+    const actionEntries = Object.entries(actions);
+    const orderedActionEntries = config.catalogMode === "directory"
+        ? actionEntries.sort(([a], [b]) => compareMcpCatalogValues(a, b))
+        : actionEntries;
+    const resources = await Promise.all(orderedActionEntries.map(([name, entry]) => resolveMcpAppResourceSafely(config, name, entry, requestMeta)));
+    const resolved = resources.filter((resource) => Boolean(resource));
+    if (config.catalogMode !== "directory")
+        return resolved;
+    const seenUris = new Set();
+    return resolved.filter((resource) => {
+        if (seenUris.has(resource.uri))
+            return false;
+        seenUris.add(resource.uri);
+        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,
@@ -994,37 +1105,43 @@ function renderMcpAppHtml(resource, actionName, config, requestMeta) {
     }
     return resource.html;
 }
-function openAiToolDescriptorMeta(resource, entrypoints) {
+function openAiToolDescriptorMeta(resource, entrypoints, directoryMode = false) {
     const label = resource.title ?? resource.name;
     const widgetCsp = metadataObject(resource._meta?.["openai/widgetCSP"]);
     return {
         "openai/outputTemplate": resource.uri,
         "openai/toolInvocation/invoking": `Opening ${label}`,
         "openai/toolInvocation/invoked": `${label} ready`,
-        "openai/widgetAccessible": true,
-        ...(entrypoints?.length ? { "openai/ui": { entrypoints } } : {}),
-        ...(Object.keys(widgetCsp).length > 0
+        ...(!directoryMode ? { "openai/widgetAccessible": true } : {}),
+        ...(!directoryMode && entrypoints?.length
+            ? { "openai/ui": { entrypoints } }
+            : {}),
+        ...(!directoryMode && Object.keys(widgetCsp).length > 0
             ? { "openai/widgetCSP": widgetCsp }
             : {}),
     };
 }
-function openAiToolResultMeta(resource) {
+function openAiToolResultMeta(resource, directoryMode = false) {
     const label = resource.title ?? resource.name;
     const widgetCsp = metadataObject(resource._meta?.["openai/widgetCSP"]);
     return {
         "openai/outputTemplate": resource.uri,
         "openai/toolInvocation/invoking": `Opening ${label}`,
         "openai/toolInvocation/invoked": `${label} ready`,
-        "openai/widgetAccessible": true,
-        ...(Object.keys(widgetCsp).length > 0
+        ...(!directoryMode ? { "openai/widgetAccessible": true } : {}),
+        ...(!directoryMode && Object.keys(widgetCsp).length > 0
             ? { "openai/widgetCSP": widgetCsp }
             : {}),
     };
 }
-function mcpAppToolUiMeta(resource, visibility) {
+function mcpAppToolUiMeta(resource, visibility, directoryMode = false) {
     return {
         resourceUri: resource.uri,
-        visibility: Array.isArray(visibility) ? visibility : ["model", "app"],
+        ...(!directoryMode
+            ? {
+                visibility: Array.isArray(visibility) ? visibility : ["model", "app"],
+            }
+            : {}),
     };
 }
 function primitiveValue(value) {
@@ -1461,10 +1578,12 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                         ? {
                             ...openAiToolDescriptorMeta(mcpAppResource, hasOpenAppEntrypoint
                                 ? [{ type: "global" }, { type: "thread" }]
-                                : undefined),
-                            [MCP_APP_RESOURCE_URI_META_KEY]: mcpAppResource.uri,
+                                : undefined, directoryCatalog),
+                            ...(!directoryCatalog
+                                ? { [MCP_APP_RESOURCE_URI_META_KEY]: mcpAppResource.uri }
+                                : {}),
                             ui: mcpAppToolUiMeta(mcpAppResource, entry.mcpApp?.visibility ??
-                                metadataObject(rawToolMeta.ui).visibility),
+                                metadataObject(rawToolMeta.ui).visibility, directoryCatalog),
                         }
                         : {}),
                 };
@@ -1483,14 +1602,26 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                             entry.needsApproval !== undefined,
                         openWorldHint: false,
                     };
-                if (hasLink)
+                if (directoryCatalog) {
+                    delete annotations["agent-native/producesOpenLink"];
+                }
+                else if (hasLink) {
                     annotations["agent-native/producesOpenLink"] = true;
+                }
                 return {
                     name,
                     description: hasLink
                         ? `${baseDescription} After calling, surface the returned "Open in … →" link to the user.`
                         : baseDescription,
                     inputSchema,
+                    ...(directoryCatalog && mcpAppResource
+                        ? {
+                            outputSchema: {
+                                type: "object",
+                                additionalProperties: true,
+                            },
+                        }
+                        : {}),
                     ...(Object.keys(toolMeta).length > 0 ? { _meta: toolMeta } : {}),
                     annotations,
                 };
@@ -1674,9 +1805,8 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                     });
                     directoryLinkUrl = linked?.url ?? undefined;
                 }
-                const rawResultForClient = mcpAppResourceCandidate &&
-                    !(directoryCatalog && entry.readOnly === true)
-                    ? await withServerMintedMcpAppEmbedStart(projectedRawResult, requestMeta, directoryLinkUrl)
+                const rawResultForClient = mcpAppResourceCandidate
+                    ? await withServerMintedMcpAppEmbedStart(projectedRawResult, requestMeta, directoryLinkUrl, directoryCatalog && entry.readOnly === true)
                     : projectedRawResult;
                 const { value: actionResultForClient, images: resultImages, notes: resultImageNotes, } = extractAgentImagesFromActionResult(rawResultForClient);
                 const textResultForClient = mcpResult
@@ -1694,7 +1824,9 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                     ...(mcpAppResource
                         ? mcpAppEmbedOpenLinkMeta(actionResultForClient, mcpAppResource, requestMeta)
                         : {}),
-                    ...(mcpAppResource ? openAiToolResultMeta(mcpAppResource) : {}),
+                    ...(mcpAppResource
+                        ? openAiToolResultMeta(mcpAppResource, directoryCatalog)
+                        : {}),
                 };
                 const toolUiMeta = metadataObject(entry.tool._meta?.ui);
                 const toolVisibility = toolUiMeta.visibility;
@@ -1838,6 +1970,9 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
             return result;
         });
         server.setRequestHandler("resources/templates/list", async () => {
+            if (config.catalogMode === "directory") {
+                return withCallerContext(async () => ({ resourceTemplates: [] }));
+            }
             return withCallerContext(async () => {
                 const mcpAppResources = await getMcpAppResources(config, advertisedActions, requestMeta);
                 return {
@@ -1877,7 +2012,10 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                     const resourceActions = mcpAppWidgetsEnabled(config)
                         ? Object.entries(advertisedActions)
                         : [];
-                    for (const [name, entry] of resourceActions) {
+                    const orderedResourceActions = config.catalogMode === "directory"
+                        ? resourceActions.sort(([a], [b]) => compareMcpCatalogValues(a, b))
+                        : resourceActions;
+                    for (const [name, entry] of orderedResourceActions) {
                         const resourceUri = getMcpAppResourceUri(config, name, entry);
                         if (!resourceUri || !matchesMcpAppResourceUri(resourceUri, uri)) {
                             continue;

package/dist/mcp/embed-app.js

@@ -1239,7 +1239,7 @@ export function embedApp(options = {}) {
       const frame = document.createElement("iframe");
       frame.title = body.dataset.iframeTitle || "Agent-Native app";
       frame.src = src;
-      frame.allow = "clipboard-read; clipboard-write";
+      ${ctx.catalogMode === "directory" ? "" : 'frame.allow = "clipboard-read; clipboard-write";'}
       appFrame = frame;
       appFrameReady = false;
       lastFrameSrc = src;

package/dist/mcp/server.js

@@ -225,7 +225,9 @@ async function handleMcpRequestInternal(event, config, routePath = MCP_PUBLIC_RO
             connectorCatalog: directoryProfile.connectorCatalog,
             instructions: directoryProfile.instructions,
             keyToolNames: directoryProfile.keyToolNames,
-            widgetDomain: requestMeta.origin,
+            widgetDomain: directoryProfile.widgetDomain ??
+                config.widgetDomain ??
+                requestMeta.origin,
         }
         : config;
     let authResult;

package/dist/observability/routes.d.ts

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

package/dist/org/handlers.d.ts

@@ -71,9 +71,9 @@ export declare const setWorkspaceAppDefaultVisibilityHandler: import("h3").Event
     visibility: WorkspaceAppDefaultVisibility;
 }>>;
 export declare const createOrgHandler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    name?: undefined;
     success: boolean;
     id?: undefined;
-    name?: undefined;
     role?: undefined;
 } | {
     success?: undefined;

package/dist/org/index.d.ts

@@ -177,10 +177,10 @@ export declare const getMyOrgHandler: import("h3").EventHandlerWithFetch<import(
     soloDeploymentAdmin: boolean | undefined;
 }>>;
 export declare const createOrgHandler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    role?: undefined;
     name?: undefined;
     success: boolean;
     id?: undefined;
+    role?: undefined;
 } | {
     success?: undefined;
     id: string;

package/dist/resources/handlers.d.ts

@@ -39,8 +39,8 @@ export declare function handleUpdateResource(event: any): Promise<import("./stor
     error: string;
 }>;
 export declare function handleDeleteResource(event: any): Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/secrets/routes.d.ts

@@ -73,32 +73,32 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
     ok?: undefined;
     status?: undefined;
 } | {
+    error?: undefined;
     errorCode?: undefined;
     retryable?: undefined;
     ok: boolean;
     status: string;
-    error?: undefined;
 } | {
     ok?: undefined;
     error: string;
     removed?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     removed: boolean;
-    error?: undefined;
 }>>;
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     ok?: undefined;
     error: string;
     note?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note?: undefined;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note: string;
-    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -126,11 +126,11 @@ export declare function createAdHocSecretHandler(): import("h3").EventHandlerWit
 } | {
     error: string;
 } | {
+    error?: undefined;
     ok: boolean;
     key: string;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     removed: boolean;
-    error?: undefined;
 }>>;

package/dist/server/agent-engine-api-key-route.d.ts

@@ -66,12 +66,12 @@ export declare function createAgentEngineApiKeyHandler(): import("h3").EventHand
     code: any;
 } | {
     errorCode?: undefined;
-    error?: undefined;
     code?: undefined;
     ok: boolean;
     key: string;
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
     defaultModel?: import("./agent-engine-default-model-route.js").SavedKeyDefaultModelOutcome;
+    error?: undefined;
 }>>;
 export {};

package/dist/server/agent-engine-ollama-models-route.d.ts

@@ -1,9 +1,9 @@
 export declare function createAgentEngineOllamaModelsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    models?: undefined;
     ok?: undefined;
+    models?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     models: string[];
-    error?: undefined;
 }>>;

package/dist/shared/analytics-events.d.ts

@@ -125,3 +125,17 @@ export declare const AGENT_SIGNALS_VERSION = 1;
  * another tab opened.
  */
 export declare const PAGE_LOAD_PAGEVIEW_PROPERTY = "page_load_id";
+/**
+ * Action telemetry reports every `action.response` at least this slow
+ * unsampled, and marks each one someone waited for on the session replay with
+ * its own timing.
+ */
+export declare const SLOW_ACTION_RESPONSE_MS = 1000;
+/**
+ * Whether an `action.response`'s duration is what a person waited for.
+ * Background tabs throttle timers and cancelled requests never finish.
+ */
+export declare function isWaitedActionResponse(properties: {
+    page_hidden?: unknown;
+    outcome?: unknown;
+}): boolean;

package/dist/shared/analytics-events.js

@@ -342,3 +342,16 @@ export const AGENT_SIGNALS_VERSION = 1;
  * another tab opened.
  */
 export const PAGE_LOAD_PAGEVIEW_PROPERTY = "page_load_id";
+/**
+ * Action telemetry reports every `action.response` at least this slow
+ * unsampled, and marks each one someone waited for on the session replay with
+ * its own timing.
+ */
+export const SLOW_ACTION_RESPONSE_MS = 1_000;
+/**
+ * Whether an `action.response`'s duration is what a person waited for.
+ * Background tabs throttle timers and cancelled requests never finish.
+ */
+export function isWaitedActionResponse(properties) {
+    return properties.page_hidden !== true && properties.outcome !== "cancelled";
+}