@agent-native/core 0.198.3 → 0.198.5

package/dist/org/plugin.js

@@ -7,7 +7,31 @@ import { listSSOProvidersHandler, createSSOProviderHandler, verifySSOProviderHan
 import { CROSS_APP_ORG_FEDERATION_FLAG } from "./feature-flags.js";
 import { getMyOrgHandler, createOrgHandler, updateOrgHandler, deleteOrgHandler, switchOrgHandler, listMembersHandler, removeMemberHandler, retryPendingFederatedRemovalHandler, changeMemberRoleHandler, listInvitationsHandler, createInvitationHandler, acceptInvitationHandler, joinByDomainHandler, setDomainHandler, setWorkspaceUrlHandler, setRequiredAuthProviderHandler, revealA2ASecretHandler, setA2ASecretHandler, syncA2ASecretHandler, receiveA2ASecretHandler, setWorkspaceAppDefaultVisibilityHandler, setOrgVisualIdentityHandler, } from "./handlers.js";
 import { ORG_MIGRATIONS } from "./migrations.js";
+import { readWorkspacePrivateIconHandler, uploadWorkspacePrivateIconHandler, } from "./private-icon-handlers.js";
 const ORG_PREFIX = `${FRAMEWORK_PREFIX}/org`;
+async function workspaceIconUploadResponse(event) {
+    try {
+        return await uploadWorkspacePrivateIconHandler(event);
+    }
+    catch (error) {
+        const statusCode = error &&
+            typeof error === "object" &&
+            "statusCode" in error &&
+            typeof error.statusCode === "number"
+            ? error.statusCode
+            : 500;
+        setResponseStatus(event, statusCode);
+        return {
+            message: statusCode < 500 &&
+                error &&
+                typeof error === "object" &&
+                "message" in error &&
+                typeof error.message === "string"
+                ? error.message
+                : "Workspace icon upload failed.",
+        };
+    }
+}
 /**
  * Mounts the org REST routes under `/_agent-native/org/*` and runs the org
  * module's migrations.
@@ -47,6 +71,24 @@ export function createOrgPlugin() {
         await awaitBootstrap(nitroApp);
         await migrate(nitroApp);
         const app = getH3App(nitroApp);
+        app.use(`${ORG_PREFIX}/private-icons`, defineEventHandler(async (event) => {
+            const tail = getRequestURL(event).pathname || "/";
+            const method = getMethod(event);
+            if (tail === "/" ||
+                tail === "" ||
+                tail === `${ORG_PREFIX}/private-icons` ||
+                tail === `${ORG_PREFIX}/private-icons/`) {
+                if (method === "POST")
+                    return workspaceIconUploadResponse(event);
+                setResponseStatus(event, 405);
+                return { error: "Method not allowed" };
+            }
+            if (method === "GET")
+                return readWorkspacePrivateIconHandler(event);
+            setResponseStatus(event, 405);
+            return { error: "Method not allowed" };
+        }));
+        // GET /me
         app.use(`${ORG_PREFIX}/me`, defineEventHandler(async (event) => {
             if (getMethod(event) !== "GET") {
                 setResponseStatus(event, 405);

package/dist/org/private-icon-handlers.d.ts

@@ -0,0 +1,6 @@
+export declare const uploadWorkspacePrivateIconHandler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    id: string;
+}>>;
+export declare const readWorkspacePrivateIconHandler: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<Buffer<ArrayBuffer>>>;
+export declare function assertOwnedLocalWorkspaceIcon(assetId: string, email: string, orgId: string): Promise<void>;
+export declare function requirePrivateWorkspaceIconId(assetId: string): void;

package/dist/org/private-icon-handlers.js

@@ -0,0 +1,212 @@
+import { createError, defineEventHandler, getRequestURL, setResponseHeader, setResponseStatus, } from "h3";
+import { getDbExec } from "../db/client.js";
+import { getIconAsset, IconUploadBodyError, putIconAsset, readIconUploadFormData, readIconAssetForAuthorizedReference, } from "../icon-assets/index.js";
+import { readFederatedWorkspaceIcon, uploadFederatedWorkspaceIcon, verifyFederatedWorkspaceIconOwner, } from "../icon-assets/workspace-transport.js";
+import { getSession } from "../server/auth.js";
+import { runWithRequestContext } from "../server/request-context.js";
+import { getOrgContext } from "./context.js";
+import { validateFederatedOrganizationMembership } from "./federation.js";
+import { parseOrganizationIconJson } from "./visual-identity.js";
+const ASSET_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const ORG_ID = /^[A-Za-z0-9_-]{1,128}$/;
+const MAX_ICON_BYTES = 5 * 1024 * 1024;
+const IMAGE_TYPES = new Set([
+    "image/png",
+    "image/jpeg",
+    "image/webp",
+    "image/svg+xml",
+]);
+async function readOrg(orgId) {
+    const result = await getDbExec().execute({
+        sql: `SELECT identity_authority, identity_id, allowed_domain, icon_json
+          FROM organizations WHERE id = ? LIMIT 1`,
+        args: [orgId],
+    });
+    const row = result.rows[0];
+    if (!row)
+        return null;
+    return {
+        identityAuthority: typeof row.identity_authority === "string"
+            ? row.identity_authority
+            : null,
+        identityId: typeof row.identity_id === "string" ? row.identity_id : null,
+        allowedDomain: typeof row.allowed_domain === "string" ? row.allowed_domain : null,
+        iconJson: row.icon_json,
+    };
+}
+function isFederated(org) {
+    if (Boolean(org.identityAuthority) !== Boolean(org.identityId)) {
+        throw new Error("Workspace identity mapping is incomplete.");
+    }
+    return Boolean(org.identityAuthority);
+}
+export const uploadWorkspacePrivateIconHandler = defineEventHandler(async (event) => {
+    const ctx = await getOrgContext(event);
+    if (!ctx.orgId || !ctx.email)
+        throw createError({
+            statusCode: 401,
+            message: "Organization access required",
+        });
+    if (ctx.role !== "owner" && ctx.role !== "admin") {
+        throw createError({
+            statusCode: 403,
+            message: "Only owners and admins can upload workspace icons",
+        });
+    }
+    const org = await readOrg(ctx.orgId);
+    if (!org)
+        throw createError({ statusCode: 404, message: "Organization not found" });
+    const form = await readIconUploadFormData(event.req).catch((error) => {
+        if (error instanceof IconUploadBodyError) {
+            throw createError({
+                statusCode: error.statusCode,
+                cause: error,
+                message: error.statusCode === 413
+                    ? "Workspace icon is too large"
+                    : error.message,
+            });
+        }
+        throw error;
+    });
+    const file = form.get("file");
+    if (!file || typeof file === "string" || !file.size)
+        throw createError({ statusCode: 400, message: "Image file required" });
+    if (file.size > MAX_ICON_BYTES)
+        throw createError({
+            statusCode: 413,
+            message: "Workspace icon is too large",
+        });
+    const mimeType = file.type?.toLowerCase();
+    if (!mimeType || !IMAGE_TYPES.has(mimeType)) {
+        throw createError({
+            statusCode: 415,
+            message: "Unsupported workspace icon image type",
+        });
+    }
+    const data = new Uint8Array(await file.arrayBuffer());
+    const id = await runWithRequestContext({ userEmail: ctx.email, orgId: ctx.orgId }, async () => isFederated(org)
+        ? uploadFederatedWorkspaceIcon(event, org, ctx.email, {
+            data,
+            mimeType,
+            filename: file.name || "workspace-icon",
+        })
+        : (await putIconAsset({
+            data,
+            mimeType,
+            filename: file.name || undefined,
+            ownerEmail: ctx.email,
+            orgId: ctx.orgId,
+        })).id);
+    if (!ASSET_ID.test(id))
+        throw new Error("Workspace icon storage returned an invalid asset ID.");
+    setResponseStatus(event, 201);
+    return { id };
+});
+export const readWorkspacePrivateIconHandler = defineEventHandler(async (event) => {
+    const session = await getSession(event);
+    if (!session?.email)
+        throw createError({
+            statusCode: 401,
+            message: "Authentication required",
+        });
+    const path = getRequestURL(event).pathname;
+    const match = path.match(/^(?:\/_agent-native\/org\/private-icons)?\/(library\/)?([A-Za-z0-9_-]{1,128})\/([0-9a-f-]{36})\/?$/i);
+    if (!match || !ORG_ID.test(match[2]) || !ASSET_ID.test(match[3])) {
+        throw createError({
+            statusCode: 404,
+            message: "Workspace icon not found",
+        });
+    }
+    const [, library, orgId, assetId] = match;
+    const membership = await getDbExec().execute({
+        sql: `SELECT role FROM org_members
+          WHERE org_id = ? AND LOWER(email) = ?
+            AND federation_removal_pending_at IS NULL LIMIT 1`,
+        args: [orgId, session.email.toLowerCase()],
+    });
+    if (!membership.rows.length)
+        throw createError({
+            statusCode: 404,
+            message: "Workspace icon not found",
+        });
+    if (library &&
+        membership.rows[0]?.role !== "owner" &&
+        membership.rows[0]?.role !== "admin") {
+        throw createError({
+            statusCode: 404,
+            message: "Workspace icon not found",
+        });
+    }
+    const org = await readOrg(orgId);
+    if (!org)
+        throw createError({
+            statusCode: 404,
+            message: "Workspace icon not found",
+        });
+    if (library) {
+        const owned = isFederated(org)
+            ? await verifyFederatedWorkspaceIconOwner(event, org, session.email, assetId)
+            : Boolean(await getIconAsset(assetId, { ownerEmail: session.email, orgId }));
+        if (!owned)
+            throw createError({
+                statusCode: 404,
+                message: "Workspace icon not found",
+            });
+    }
+    else {
+        const icon = parseOrganizationIconJson(org.iconJson);
+        if (icon?.kind !== "image" ||
+            icon.authority !== "private-icon" ||
+            icon.assetId !== assetId) {
+            throw createError({
+                statusCode: 404,
+                message: "Workspace icon not found",
+            });
+        }
+    }
+    if (isFederated(org)) {
+        const verified = await validateFederatedOrganizationMembership(event, {
+            orgId,
+            email: session.email,
+        });
+        if (!verified.active)
+            throw createError({
+                statusCode: 404,
+                message: "Workspace icon not found",
+            });
+    }
+    const bytes = isFederated(org)
+        ? await readFederatedWorkspaceIcon(event, org, session.email, assetId)
+        : await readIconAssetForAuthorizedReference(assetId, { orgId });
+    if (!bytes || !IMAGE_TYPES.has(bytes.mimeType)) {
+        throw createError({
+            statusCode: 404,
+            message: "Workspace icon not found",
+        });
+    }
+    setResponseHeader(event, "Content-Type", bytes.mimeType);
+    setResponseHeader(event, "Content-Length", String(bytes.data.length));
+    setResponseHeader(event, "Cache-Control", "private, no-store");
+    setResponseHeader(event, "X-Content-Type-Options", "nosniff");
+    if (bytes.mimeType === "image/svg+xml") {
+        setResponseHeader(event, "Content-Security-Policy", "sandbox; default-src 'none'; style-src 'unsafe-inline'; img-src data:");
+    }
+    return Buffer.from(bytes.data);
+});
+export async function assertOwnedLocalWorkspaceIcon(assetId, email, orgId) {
+    if (!ASSET_ID.test(assetId) ||
+        !(await getIconAsset(assetId, { ownerEmail: email, orgId }))) {
+        throw createError({
+            statusCode: 403,
+            message: "Workspace icon asset is not owned by this organization administrator",
+        });
+    }
+}
+export function requirePrivateWorkspaceIconId(assetId) {
+    if (!ASSET_ID.test(assetId)) {
+        throw createError({
+            statusCode: 400,
+            message: "Invalid workspace icon asset ID",
+        });
+    }
+}

package/dist/progress/routes.d.ts

@@ -2,6 +2,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;

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

@@ -75,10 +75,11 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
-    id?: undefined;
     message?: undefined;
-    found?: undefined;
     deleted?: undefined;
+    id?: undefined;
+    provider?: undefined;
+    found?: undefined;
     providers: {
         id: string;
         label: string;
@@ -89,13 +90,12 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         updatedAt: number;
     }[];
     count: number;
-    provider?: undefined;
     registered?: undefined;
     label?: undefined;
 } | {
-    id?: undefined;
     message?: undefined;
     deleted?: undefined;
+    id?: undefined;
     providers?: undefined;
     count?: undefined;
     found: boolean;
@@ -105,29 +105,29 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
 } | {
     message?: undefined;
     deleted?: undefined;
+    provider?: undefined;
     providers?: undefined;
     count?: undefined;
-    provider?: undefined;
     found: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
 } | {
     message?: undefined;
+    provider?: undefined;
     found?: undefined;
     providers?: undefined;
     count?: undefined;
-    provider?: undefined;
     deleted: boolean;
     id: string;
     registered?: undefined;
     label?: undefined;
 } | {
-    found?: undefined;
     deleted?: undefined;
+    provider?: undefined;
+    found?: undefined;
     providers?: undefined;
     count?: undefined;
-    provider?: undefined;
     registered: boolean;
     id: string;
     label: string;

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

@@ -311,10 +311,10 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         notes?: string | undefined;
         scope?: "org" | "user" | undefined;
     }, {
-        id?: undefined;
         provider?: undefined;
-        deleted?: undefined;
+        id?: undefined;
         message?: undefined;
+        deleted?: undefined;
         found?: undefined;
         providers: {
             id: string;
@@ -330,9 +330,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         label?: undefined;
     } | {
         id?: undefined;
-        deleted?: undefined;
         count?: undefined;
         message?: undefined;
+        deleted?: undefined;
         providers?: undefined;
         found: boolean;
         provider: import("../custom-registry.js").CustomProviderConfig;
@@ -340,9 +340,9 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         label?: undefined;
     } | {
         provider?: undefined;
-        deleted?: undefined;
         count?: undefined;
         message?: undefined;
+        deleted?: undefined;
         providers?: undefined;
         found: boolean;
         id: string;
@@ -360,8 +360,8 @@ export declare function createProviderApiActions(runtime: Pick<ProviderApiRuntim
         label?: undefined;
     } | {
         provider?: undefined;
-        deleted?: undefined;
         count?: undefined;
+        deleted?: undefined;
         found?: undefined;
         providers?: undefined;
         registered: boolean;

package/dist/provider-api/corpus-jobs.d.ts

@@ -73,6 +73,7 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
     offset?: unknown;
     limit?: unknown;
 }, {
+    deleted?: undefined;
     jobs: {
         id: string;
         name: string;
@@ -83,7 +84,6 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
         updatedAt: string;
     }[];
     total: number;
-    deleted?: undefined;
     jobId?: undefined;
 } | {
     jobs?: undefined;
@@ -91,9 +91,9 @@ export declare function createProviderCorpusJobAction(options: CreateProviderCor
     deleted: boolean;
     jobId: string;
 } | {
+    deleted?: undefined;
     jobs?: undefined;
     total?: undefined;
-    deleted?: undefined;
     jobId?: undefined;
     hits: Record<string, unknown>[];
     offset: number;

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

@@ -1,4 +1,4 @@
-import type { WorkspaceConnectionTemplateUse } from "../connections/catalog.js";
+import { type WorkspaceConnectionTemplateUse } from "../connections/catalog.js";
 import { type CredentialContext } from "../credentials/index.js";
 import { type WebContentSearchOptions, type WebExtractMode, type WebResponseMode } from "../extensions/web-content.js";
 import type { CustomProviderConfig } from "./custom-registry.js";

package/dist/provider-api/index.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { AgentConnectionRequiredError } from "../action.js";
+import { getWorkspaceConnectionProvider, } from "../connections/catalog.js";
 import { assertCredentialCanReachEndpoint, describeCredentialScopeGap, resolveCredentialDetailed, } from "../credentials/index.js";
 import { createSsrfSafeDispatcher, isBlockedExtensionUrlWithDns, } from "../extensions/url-safety.js";
 import { processWebContent, } from "../extensions/web-content.js";
@@ -1452,6 +1453,7 @@ export async function resolveProviderApiOAuthAccessToken(args, runtime) {
         })
         : await resolveOAuthBearerToken({
             auth: oauthAuth,
+            runtime,
             ctx,
             accountId: args.accountId,
         });
@@ -2756,8 +2758,10 @@ async function resolveAuth(config, runtime, ctx, args) {
             })
             : await resolveOAuthBearerToken({
                 auth: { ...auth, oauthProvider },
+                runtime,
                 ctx,
                 accountId: args.accountId,
+                connectionId: args.connectionId,
             });
         return {
             headers: { Authorization: `Bearer ${credential.value}` },
@@ -3009,9 +3013,7 @@ async function resolveAnyCredential(options) {
             return credential;
     }
     const scopeGap = await describeCredentialScopeGap(options.keys, options.ctx).catch(() => null);
-    if (options.workspaceProvider &&
-        !options.runtime.resolveCredential &&
-        !scopeGap) {
+    if (options.workspaceProvider && !scopeGap) {
         return throwWorkspaceConnectionRequired({
             runtime: options.runtime,
             provider: options.workspaceProvider,
@@ -3029,9 +3031,7 @@ async function resolveRequiredCredential(options) {
         // coercion-ok: only enriches an error we throw either way — losing the scope
         // hint still surfaces the real "not configured" failure, never a success.
         .catch(() => null);
-    if (options.workspaceProvider &&
-        !options.runtime.resolveCredential &&
-        !scopeGap) {
+    if (options.workspaceProvider && !scopeGap) {
         return throwWorkspaceConnectionRequired({
             runtime: options.runtime,
             provider: options.workspaceProvider,
@@ -3152,6 +3152,14 @@ async function resolveOAuthBearerToken(options) {
     const ownerEmail = options.ownerEmail?.trim() || options.ctx.userEmail;
     const accounts = await listOAuthAccountsByOwner(options.auth.oauthProvider, ownerEmail);
     if (accounts.length === 0) {
+        if (options.auth.workspaceProvider) {
+            return throwWorkspaceConnectionRequired({
+                runtime: options.runtime,
+                provider: options.auth.workspaceProvider,
+                connectionId: options.connectionId,
+                message: `${options.auth.tokenLabel} requires an available workspace connection.`,
+            });
+        }
         throw new Error(`${options.auth.tokenLabel} is not connected for ${ownerEmail}.`);
     }
     const accountId = options.accountId?.trim();
@@ -3205,10 +3213,20 @@ async function throwWorkspaceConnectionRequired(options) {
         resolved.connection.status !== "connected") {
         reason = "reauthorize";
     }
+    const connectionProvider = getWorkspaceConnectionProvider(options.provider);
     throw new AgentConnectionRequiredError(options.message, {
         provider: options.provider,
         reason,
         appId: options.runtime.appId,
+        ...(connectionProvider
+            ? {
+                source: {
+                    id: options.provider,
+                    kind: "workspace_connection",
+                    label: connectionProvider.label,
+                },
+            }
+            : {}),
     });
 }
 async function resolveOptionalConnectionBoundOAuthBearerToken(options) {
@@ -3252,9 +3270,11 @@ async function resolveOptionalConnectionBoundOAuthBearerToken(options) {
     }
     const credential = await resolveOAuthBearerToken({
         auth: options.auth,
+        runtime: options.runtime,
         ctx: options.ctx,
         accountId: connectionAccountId,
         ownerEmail: resolved.connection.ownerEmail,
+        connectionId: requestedConnectionId,
         salesforceLoginUrl: options.auth.oauthProvider === "salesforce" &&
             typeof resolved.connection.config?.salesforceLoginUrl === "string"
             ? resolved.connection.config.salesforceLoginUrl

package/dist/secrets/routes.d.ts

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

package/dist/server/action-discovery.js

@@ -437,6 +437,10 @@ export async function mergeCoreSharingActions(registry) {
             "list-workspace-app-access",
             () => import("../org/actions/list-workspace-app-access.js"),
         ],
+        [
+            "list-workspace-icons",
+            () => import("../org/actions/list-workspace-icons.js"),
+        ],
         [
             "set-workspace-app-access",
             () => import("../org/actions/set-workspace-app-access.js"),
@@ -545,6 +549,7 @@ export async function mergeCoreSharingActions(registry) {
             () => import("../feature-flags/actions/set-feature-flag.js"),
         ],
         ["get-labs", () => import("../labs/actions/get-labs.js")],
+        ["get-lab-states", () => import("../labs/actions/get-lab-states.js")],
         ["set-lab", () => import("../labs/actions/set-lab.js")],
         [
             "get-chatgpt-subscription-status",

package/dist/server/agent-chat-plugin.js

@@ -2126,6 +2126,20 @@ export function createAgentChatPlugin(options) {
                             ...(connectionRequest.detail
                                 ? { detail: connectionRequest.detail }
                                 : {}),
+                            ...(connectionRequest.source?.kind === "workspace_connection" &&
+                                connectionRequest.source.id === connectionRequest.provider
+                                ? {
+                                    source: {
+                                        id: connectionRequest.provider,
+                                        kind: "workspace_connection",
+                                        ...(connectionRequest.source.label
+                                            ? {
+                                                label: connectionRequest.source.label.slice(0, 120),
+                                            }
+                                            : {}),
+                                    },
+                                }
+                                : {}),
                         };
                         yield {
                             role: "agent",

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

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

package/dist/server/agent-engine-default-model-route.d.ts

@@ -8,8 +8,8 @@ export declare const AGENT_ENGINE_API_KEY_ACTION_NAME = "agent-engine-api-key";
  * resolveEngine's credential detection.
  */
 export declare function createAgentEngineDisconnectHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
     scope?: undefined;
 } | {
     ok: boolean;

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

@@ -3,7 +3,7 @@ export declare function createAgentEngineOllamaModelsHandler(): import("h3").Eve
     ok?: undefined;
     models?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     models: string[];
+    error?: undefined;
 }>>;

package/dist/server/core-routes-plugin.d.ts

@@ -616,7 +616,7 @@ export declare function resolveOAuthCustodyBuilderKeyStatus(dependencies?: {
         lookupFailed: boolean;
     }>;
 }): Promise<OAuthCustodyBuilderKeyStatus>;
-export declare function createOAuthPopupWaitingHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, "<!doctype html><html><head><meta charset=\"utf-8\"><meta name=\"color-scheme\" content=\"light dark\"><title></title></head><body></body></html>" | {
+export declare function createOAuthPopupWaitingHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, string | {
     error: string;
 }>;
 export declare function mountApplicationStateRoutes(nitroApp: any, routePrefix?: string, app?: H3AppShim, options?: {