@agent-native/core 0.212.0-nightly-20261021093329 → 0.212.0

package/dist/integrations/adapters/slack.js

@@ -281,10 +281,25 @@ export function slackAdapter(options = {}) {
             const channelId = context.platformContext.channelId;
             const threadTs = context.platformContext.threadTs;
             const blocks = message.platformContext?.blocks;
+            const responseImages = getSlackResponseImages(message.platformContext?.imageUrls);
+            const { images, linkedImages } = await resolveOwnedSlackResponseImages(responseImages.images);
+            const deliveryText = [
+                message.text,
+                ...responseImages.linkedImages.map((image) => `Image: ${image.url}`),
+                ...linkedImages.map((image) => `Image: ${image.url}`),
+            ]
+                .filter(Boolean)
+                .join("\n");
             const placeholderRef = opts?.placeholderRef;
-            const chunks = splitNonEmptyMessage(message.text, SLACK_MAX_LENGTH);
             const hasProvidedBlocks = Array.isArray(blocks) && blocks.length > 0;
-            const firstChunk = chunks[0] ?? (hasProvidedBlocks ? "Response" : "");
+            const hasImages = images.length > 0;
+            const chunks = splitNonEmptyMessage(deliveryText, SLACK_MAX_LENGTH);
+            const firstChunk = chunks[0] ??
+                (hasProvidedBlocks
+                    ? "Response"
+                    : hasImages
+                        ? images[0].alt || "Image"
+                        : "");
             if (!firstChunk) {
                 if (threadTs) {
                     setSlackAssistantStatus(token, channelId, threadTs, "");
@@ -300,11 +315,26 @@ export function slackAdapter(options = {}) {
             const reconciledRefs = opts?.idempotencyKey && freshChunkIndexes.length > 0
                 ? await reconcileSlackDeliveryChunks(token, channelId, threadTs, opts.idempotencyKey, freshChunkIndexes, opts.reconcileAfter, opts.signal)
                 : new Map();
-            const finalBlocks = blocks ??
-                buildResponseBlocks(firstChunk, {
-                    threadDeepLinkUrl: message.platformContext
-                        ?.threadDeepLinkUrl,
-                });
+            const imageBlocks = images.map(({ url, alt }) => ({
+                type: "image",
+                image_url: url,
+                alt_text: alt || "Image",
+            }));
+            const finalBlocks = hasProvidedBlocks && restChunks.length === 0
+                ? [...blocks, ...imageBlocks].slice(0, 50)
+                : hasProvidedBlocks
+                    ? [
+                        ...buildResponseBlocks(firstChunk, {
+                            threadDeepLinkUrl: message.platformContext
+                                ?.threadDeepLinkUrl,
+                        }, imageBlocks).filter((block) => block?.type === "section"),
+                        ...blocks.filter((block) => block?.type !== "section"),
+                        ...imageBlocks,
+                    ].slice(0, 50)
+                    : buildResponseBlocks(restChunks.length > 0 ? firstChunk : deliveryText, {
+                        threadDeepLinkUrl: message.platformContext
+                            ?.threadDeepLinkUrl,
+                    }, imageBlocks);
             const baseBody = {
                 channel: channelId,
                 text: firstChunk,
@@ -487,11 +517,23 @@ export function slackAdapter(options = {}) {
             }
         },
         formatAgentResponse(text, opts) {
+            const imageUrls = [];
+            const textWithImageLinks = text.replace(/!\[([^\]]*)\]\((https:\/\/[^\s)]+)\)/g, (_markdownImage, alt, url) => {
+                const image = parseSlackResponseImage(url, alt);
+                if (image) {
+                    imageUrls.push(image);
+                    return "";
+                }
+                return slackImageLinkText(url, alt);
+            });
             return {
-                text: markdownToSlackMrkdwn(text),
-                platformContext: opts?.threadDeepLinkUrl
-                    ? { threadDeepLinkUrl: opts.threadDeepLinkUrl }
-                    : {},
+                text: markdownToSlackMrkdwn(textWithImageLinks),
+                platformContext: {
+                    ...(opts?.threadDeepLinkUrl
+                        ? { threadDeepLinkUrl: opts.threadDeepLinkUrl }
+                        : {}),
+                    ...(imageUrls.length > 0 ? { imageUrls } : {}),
+                },
             };
         },
         async getStatus(_baseUrl) {
@@ -875,12 +917,15 @@ function setSlackAssistantStatus(token, channelId, threadTs, status) {
         }),
     }).catch(() => { });
 }
-function buildResponseBlocks(text, opts) {
-    const sectionChunks = splitMessage(text || "_(no response)_", SLACK_SECTION_TEXT_MAX_LENGTH);
+function buildResponseBlocks(text, opts, imageBlocks = []) {
+    const sectionChunks = text.trim()
+        ? splitMessage(text, SLACK_SECTION_TEXT_MAX_LENGTH)
+        : [];
     const blocks = sectionChunks.map((chunk) => ({
         type: "section",
         text: { type: "mrkdwn", text: chunk },
     }));
+    blocks.push(...imageBlocks);
     if (opts.threadDeepLinkUrl) {
         blocks.push({
             type: "actions",
@@ -894,7 +939,90 @@ function buildResponseBlocks(text, opts) {
             ],
         });
     }
-    return blocks;
+    return blocks.slice(0, 50);
+}
+function getSlackResponseImages(value) {
+    if (!Array.isArray(value))
+        return { images: [], linkedImages: [] };
+    const images = [];
+    const linkedImages = [];
+    for (const image of value) {
+        if (!image || typeof image !== "object")
+            continue;
+        const { url, alt } = image;
+        if (typeof url !== "string")
+            continue;
+        const normalizedUrl = normalizeSlackImageLinkUrl(url);
+        if (!normalizedUrl)
+            continue;
+        const item = {
+            url: normalizedUrl,
+            alt: typeof alt === "string" ? alt.trim().slice(0, 2_000) : "",
+        };
+        if (parseSlackResponseImage(normalizedUrl, item.alt)) {
+            images.push(item);
+        }
+        else {
+            linkedImages.push(item);
+        }
+    }
+    return { images, linkedImages };
+}
+function parseSlackResponseImage(value, alt) {
+    if (value.length > 3_000 || !URL.canParse(value))
+        return null;
+    const url = new URL(value);
+    if (url.protocol !== "https:" || url.username || url.password)
+        return null;
+    return { url: url.toString(), alt: alt.trim().slice(0, 2_000) };
+}
+function normalizeSlackImageLinkUrl(value) {
+    if (!URL.canParse(value))
+        return null;
+    const url = new URL(value);
+    url.username = "";
+    url.password = "";
+    return url.toString();
+}
+function slackImageLinkText(value, alt) {
+    const url = normalizeSlackImageLinkUrl(value);
+    return url ? `[${alt.trim().slice(0, 2_000) || "Image"}](${url})` : alt;
+}
+async function resolveOwnedSlackResponseImages(images) {
+    if (images.length === 0)
+        return { images: [], linkedImages: [] };
+    try {
+        const { findFileUploadProviderOwningUrl } = await import("../../file-upload/registry.js");
+        const checks = await Promise.all(images.map(async (image) => {
+            try {
+                return {
+                    image,
+                    owned: Boolean(await findFileUploadProviderOwningUrl(image.url)),
+                };
+            }
+            catch (error) {
+                return {
+                    image,
+                    owned: false,
+                    unverifiable: error instanceof Error ? error.name : "unknown",
+                };
+            }
+        }));
+        const unverifiableTypes = checks.flatMap((check) => "unverifiable" in check ? [check.unverifiable] : []);
+        if (unverifiableTypes.length > 0) {
+            console.warn("[slack] Could not verify ownership of response image URLs; keeping links instead.", { count: unverifiableTypes.length, errorTypes: unverifiableTypes });
+        }
+        return {
+            images: checks.filter((check) => check.owned).map((check) => check.image),
+            linkedImages: checks
+                .filter((check) => !check.owned)
+                .map((check) => check.image),
+        };
+    }
+    catch (error) {
+        console.warn("[slack] File upload ownership checks are unavailable; keeping response image links.", { errorType: error instanceof Error ? error.name : "unknown" });
+        return { images: [], linkedImages: images };
+    }
 }
 async function postFresh(token, channelId, threadTs, body, signal) {
     const hasBlocks = Array.isArray(body.blocks) && body.blocks.length > 0;

package/dist/integrations/webhook-handler.js

@@ -4,7 +4,8 @@ import { isInBackgroundFunctionRuntime } from "../agent/durable-background.js";
 import { formatLlmCredentialErrorMessage, isLlmCredentialError, } from "../agent/engine/credential-errors.js";
 import { getConfiguredEngineNameForRequest, getStoredModelForEngine, normalizeModelForEngine, resolveEngine, } from "../agent/engine/index.js";
 import { resolveMainChatMaxOutputTokens } from "../agent/engine/output-tokens.js";
-import { actionsToEngineTools, filterInitialEngineTools, resolveOwnerEngineApiKey, } from "../agent/production-agent.js";
+import { buildWorkspaceAppRequestContext } from "../agent/jev-tool-prefetch.js";
+import { actionsToEngineTools, filterInitialEngineTools, getJevContextCredentials, resolveOwnerEngineApiKey, } from "../agent/production-agent.js";
 import { appendDurableContinuationContext, runAgentLoopDirectWithSoftTimeout, } from "../agent/run-loop-with-resume.js";
 import { startRun, } from "../agent/run-manager.js";
 import { buildCurrentTimeUserContext, buildRuntimeContextPrompt, } from "../agent/runtime-context.js";
@@ -13,6 +14,7 @@ import { attachToolSearch } from "../agent/tool-search.js";
 import { createThread, getThread, grantThreadUserShare, setThreadSourceIfMissing, } from "../chat-threads/store.js";
 import { updateThreadData } from "../chat-threads/store.js";
 import { getOrgA2ASecret } from "../org/context.js";
+import { preloadJevContextWithStatus } from "../server/agent-chat/prompt-resources.js";
 import { withConfiguredAppBasePath } from "../server/app-base-path.js";
 import { getAppProductionUrl } from "../server/app-url.js";
 import { runWithRequestContext } from "../server/request-context.js";
@@ -403,6 +405,45 @@ async function processIncomingMessage(incoming, options, opts = {}) {
         }
     }
     effectiveSystemPrompt += await loadIntegrationMemoryPrompt(incoming.integrationScopeId).catch(() => "");
+    const workspaceAppHistory = (incoming.contextMessages ?? [])
+        .filter((message) => {
+        const isCurrent = message.text.trim() === incoming.text.trim() &&
+            (!incoming.senderId || message.senderId === incoming.senderId);
+        return !isCurrent;
+    })
+        .map((message) => ({
+        role: message.senderId && message.senderId === incoming.senderId
+            ? "user"
+            : "assistant",
+        content: message.text,
+    }));
+    const appRequest = buildWorkspaceAppRequestContext({
+        request: incoming.text,
+        history: workspaceAppHistory,
+        selectedObjectContext: buildProviderConversationContext(incoming),
+    });
+    const appPreload = await runWithRequestContext({
+        userEmail: ownerEmail,
+        ...requestContext,
+        isIntegrationCaller: true,
+    }, async () => {
+        const jevCredentials = await getJevContextCredentials(ownerEmail);
+        return preloadJevContextWithStatus({
+            request: appRequest,
+            appRequest,
+            owner: ownerEmail,
+            orgId,
+            apiKey: jevCredentials.apiKey,
+            personalApiKey: jevCredentials.personalApiKey,
+            builderAuth: jevCredentials.builderAuth,
+            selfAppId: options.appId,
+            workspaceAppsEnabled: Boolean(actions["call-agent"]),
+            appDiscoveryOnly: true,
+        });
+    });
+    if (appPreload.relevantAppsContext) {
+        effectiveSystemPrompt += `\n\n${appPreload.relevantAppsContext}`;
+    }
     const budgetReservations = await reserveApplicableIntegrationBudgets({
         incoming,
         ownerEmail,

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

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

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

@@ -24,6 +24,13 @@ export interface BackgroundAutomationContext {
 export interface BackgroundAutomationDeps {
     getActions: (automation?: BackgroundAutomationContext) => Record<string, ActionEntry> | Promise<Record<string, ActionEntry>>;
     getSystemPrompt: (owner: string) => Promise<string>;
+    getWorkspaceAppContext?: (input: {
+        request: string;
+        ownerEmail: string;
+        orgId?: string;
+        appId?: string;
+        workspaceAppsEnabled: boolean;
+    }) => Promise<string>;
     getInitialToolNames?: (automation?: BackgroundAutomationContext) => string[] | undefined;
     engine?: AgentEngine;
     apiKey?: string;

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

@@ -844,7 +844,19 @@ async function executeBackgroundAutomation(options, deps, historyId, runIdRef) {
         assertHardDeadline(options.hardDeadlineAt);
         const model = await resolveBackgroundAutomationModel(engine, automation.meta.model, deps);
         assertHardDeadline(options.hardDeadlineAt);
-        const systemPrompt = `${await deps.getSystemPrompt(ownerEmail)}\n\n${messages.noOpInstruction}`;
+        const [baseSystemPrompt, workspaceAppContext] = await Promise.all([
+            deps.getSystemPrompt(ownerEmail),
+            baseActions["call-agent"] && deps.getWorkspaceAppContext
+                ? deps.getWorkspaceAppContext({
+                    request: prompt,
+                    ownerEmail,
+                    orgId,
+                    appId: deps.appId,
+                    workspaceAppsEnabled: true,
+                })
+                : Promise.resolve(""),
+        ]);
+        const systemPrompt = `${baseSystemPrompt}${workspaceAppContext ? `\n\n${workspaceAppContext}` : ""}\n\n${messages.noOpInstruction}`;
         assertHardDeadline(options.hardDeadlineAt);
         const resume = options.resume;
         const thread = resume

package/dist/mcp/org-directory.d.ts

@@ -31,10 +31,11 @@
  *     `fetchOrgApps()` remains the best-effort compatibility wrapper: on ANY
  *     error it returns `[]` and NEVER throws, so cross-app verbs still degrade
  *     silently to their exact current local-only behavior.
- *   - A short in-memory TTL cache (default 60s) keyed by directory origin and
+ *   - Credentialed requests require HTTPS and use manual redirects. A short
+ *     in-memory TTL cache (default 60s) is keyed by directory origin and
  *     caller identity/org scope so sibling app lists never cross tenants.
- *     Only successful authenticated responses are cached; unavailable results
- *     remain immediately retryable.
+ *     Successful responses are cached for 60s; transient unavailable results
+ *     are cached for 30s to avoid repeating failing directory requests.
  *   - No secrets are ever logged.
  *
  * Bundled alongside `mountMCP` (no Node-only top-level imports). The A2A
@@ -46,8 +47,11 @@ export interface OrgApp {
     url: string;
     a2aUrl: string;
     capabilities?: string[];
+    description?: string;
+    whenToUse?: string[];
+    aliases?: string[];
 }
-export type OrgDirectoryUnavailableReason = "not-configured" | "authentication" | "authorization" | "timeout" | "network" | "invalid-response" | "server-error" | "http-error";
+export type OrgDirectoryUnavailableReason = "not-configured" | "authentication" | "unauthorized" | "authorization" | "invalid-origin" | "missing-route" | "timeout" | "network" | "invalid-response" | "ssrf-blocked" | "server-error" | "http-error";
 export type OrgDirectoryFetchResult = {
     status: "available";
     apps: OrgApp[];
@@ -59,6 +63,7 @@ export declare function resolveOrgDirectoryOrigin(env?: NodeJS.ProcessEnv): stri
 export interface FetchOrgAppsOptions {
     selfId?: string;
     selfOrigin?: string;
+    directoryBaseUrl?: string;
     includeDirectoryApp?: boolean;
     serviceOrgId?: string;
     env?: NodeJS.ProcessEnv;

package/dist/mcp/org-directory.js

@@ -1,23 +1,37 @@
 import { canonicalA2AAudience } from "../a2a/audience.js";
+import { parseAgentProfileMetadataFields } from "../shared/agent-profile.js";
 const SUCCESS_TTL_MS = 60_000;
+const UNAVAILABLE_TTL_MS = 30_000;
 const cache = new Map();
 export function resolveOrgDirectoryOrigin(env = process.env) {
-    const raw = env.AGENT_NATIVE_ORG_DIRECTORY_URL || env.AGENT_NATIVE_IDENTITY_HUB_URL;
-    if (!raw || typeof raw !== "string")
+    const raw = configuredOrgDirectoryUrl(env);
+    if (!raw)
         return null;
     const trimmed = raw.trim().replace(/\/+$/, "");
     if (!trimmed)
         return null;
     try {
         const u = new URL(trimmed);
-        if (u.protocol !== "http:" && u.protocol !== "https:")
+        if (u.protocol !== "https:")
             return null;
         return trimmed;
     }
     catch {
+        // coercion-ok: The caller converts malformed configured URLs to invalid-origin.
         return null;
     }
 }
+function configuredOrgDirectoryUrl(env) {
+    for (const key of [
+        "AGENT_NATIVE_ORG_DIRECTORY_URL",
+        "AGENT_NATIVE_IDENTITY_HUB_URL",
+    ]) {
+        const value = env[key]?.trim();
+        if (value)
+            return value;
+    }
+    return null;
+}
 function isAbsoluteHttpUrl(value) {
     try {
         const url = new URL(value);
@@ -32,10 +46,20 @@ function normalizeApp(raw, strict = false) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw))
         return null;
     const r = raw;
+    const profile = parseAgentProfileMetadataFields({
+        ...(r.description !== undefined ? { description: r.description } : {}),
+        ...(r.whenToUse !== undefined ? { whenToUse: r.whenToUse } : {}),
+        ...(r.aliases !== undefined ? { aliases: r.aliases } : {}),
+    });
     const id = typeof r.id === "string" ? r.id.trim().toLowerCase() : "";
     const url = typeof r.url === "string" ? r.url.trim() : "";
     if (!id || !url || !isAbsoluteHttpUrl(url))
         return null;
+    if (strict && profile.invalidFields.length > 0) {
+        console.warn("[org-directory] dropped invalid peer profile fields", {
+            fields: profile.invalidFields,
+        });
+    }
     if (strict &&
         ((r.name !== undefined && typeof r.name !== "string") ||
             (r.a2aUrl !== undefined && typeof r.a2aUrl !== "string") ||
@@ -58,19 +82,25 @@ function normalizeApp(raw, strict = false) {
         : Array.isArray(r.capabilities)
             ? r.capabilities.filter((c) => typeof c === "string")
             : undefined;
+    const { description, whenToUse, aliases } = profile.metadata;
     return {
         id,
         name,
         url: url.replace(/\/+$/, ""),
         a2aUrl: a2aUrl.replace(/\/+$/, ""),
         ...(capabilities && capabilities.length ? { capabilities } : {}),
+        ...(description ? { description } : {}),
+        ...(whenToUse?.length ? { whenToUse } : {}),
+        ...(aliases?.length ? { aliases } : {}),
     };
 }
-function sameOrigin(a, b) {
+function sameAppBaseUrl(a, b) {
     try {
         const ua = new URL(a);
         const ub = new URL(b);
-        return ua.host === ub.host && ua.protocol === ub.protocol;
+        const normalizePath = (pathname) => pathname.replace(/\/+$/, "") || "/";
+        return (ua.origin === ub.origin &&
+            normalizePath(ua.pathname) === normalizePath(ub.pathname));
     }
     catch {
         return a.replace(/\/+$/, "") === b.replace(/\/+$/, "");
@@ -98,15 +128,25 @@ function serviceScopedCacheKey(origin, orgId, includeDirectoryApp = false, stric
 }
 async function fetchOrgAppsResultInternal(opts, strictValidation = true) {
     const env = opts?.env ?? process.env;
-    const origin = resolveOrgDirectoryOrigin(env);
-    if (!origin)
-        return { status: "unavailable", reason: "not-configured" };
+    const hasExplicitBaseUrl = opts?.directoryBaseUrl !== undefined;
+    const hasConfiguredEnvUrl = configuredOrgDirectoryUrl(env) !== null;
+    const origin = hasExplicitBaseUrl
+        ? normalizeDirectoryBaseUrl(opts?.directoryBaseUrl ?? "")
+        : resolveOrgDirectoryOrigin(env);
+    if (!origin) {
+        return {
+            status: "unavailable",
+            reason: hasExplicitBaseUrl || hasConfiguredEnvUrl
+                ? "invalid-origin"
+                : "not-configured",
+        };
+    }
     const selfId = (opts?.selfId ?? "").trim().toLowerCase();
     const selfOrigin = (opts?.selfOrigin ?? "").trim();
     const stripSelf = (apps) => apps.filter((a) => {
         if (selfId && a.id === selfId)
             return false;
-        if (selfOrigin && sameOrigin(a.url, selfOrigin))
+        if (selfOrigin && sameAppBaseUrl(a.url, selfOrigin))
             return false;
         return true;
     });
@@ -116,13 +156,15 @@ async function fetchOrgAppsResultInternal(opts, strictValidation = true) {
         const serviceCacheKey = serviceScopedCacheKey(origin, serviceOrgId, opts?.includeDirectoryApp, strictValidation);
         const cached = cache.get(serviceCacheKey);
         if (cached && cached.expiresAt > Date.now()) {
-            return { status: "available", apps: stripSelf(cached.apps) };
+            return cached.result.status === "available"
+                ? { status: "available", apps: stripSelf(cached.result.apps) }
+                : cached.result;
         }
         cacheKey = serviceCacheKey;
     }
     try {
         const directoryUrl = `${origin}/_agent-native/org/apps`;
-        const audience = canonicalA2AAudience(origin);
+        const audience = canonicalA2AAudience(directoryUrl);
         const auth = serviceOrgId
             ? await resolveOrgDirectoryServiceAuth(serviceOrgId, audience)
             : await resolveOrgDirectoryCallerAuth(audience);
@@ -135,13 +177,18 @@ async function fetchOrgAppsResultInternal(opts, strictValidation = true) {
             cacheKey = scopedCacheKey(origin, auth, opts?.includeDirectoryApp, strictValidation);
             const cached = cache.get(cacheKey);
             if (cached && cached.expiresAt > now) {
-                return { status: "available", apps: stripSelf(cached.apps) };
+                return cached.result.status === "available"
+                    ? { status: "available", apps: stripSelf(cached.result.apps) }
+                    : cached.result;
             }
         }
-        const { resolveVercelDeploymentProtectionHeaders } = await import("../server/credential-provider.js");
+        const [{ resolveVercelDeploymentProtectionHeaders }, { ssrfSafeFetch }] = await Promise.all([
+            import("../server/credential-provider.js"),
+            import("../extensions/url-safety.js"),
+        ]);
         const protectionHeaders = resolveVercelDeploymentProtectionHeaders(directoryUrl);
         for (let i = 0; i < attempts.length; i++) {
-            const res = await fetch(directoryUrl, {
+            const res = await ssrfSafeFetch(directoryUrl, {
                 method: "GET",
                 headers: {
                     Authorization: `Bearer ${attempts[i]}`,
@@ -151,11 +198,11 @@ async function fetchOrgAppsResultInternal(opts, strictValidation = true) {
                         ? { "X-Agent-Native-Include-Directory-App": "1" }
                         : {}),
                 },
-                ...(protectionHeaders["x-vercel-protection-bypass"]
-                    ? { redirect: "manual" }
-                    : {}),
                 signal: AbortSignal.timeout(4000),
-            });
+            }, { maxRedirects: 0, followRedirects: false, httpsOnly: true });
+            if (res.status >= 300 && res.status < 400) {
+                return { status: "unavailable", reason: "http-error" };
+            }
             if (res.ok) {
                 const json = (await res.json());
                 if (!Array.isArray(json?.apps))
@@ -167,7 +214,7 @@ async function fetchOrgAppsResultInternal(opts, strictValidation = true) {
                 const apps = normalizedApps.filter((a) => a !== null);
                 if (cacheKey) {
                     cache.set(cacheKey, {
-                        apps,
+                        result: { status: "available", apps },
                         expiresAt: Date.now() + SUCCESS_TTL_MS,
                     });
                 }
@@ -175,29 +222,70 @@ async function fetchOrgAppsResultInternal(opts, strictValidation = true) {
             }
             if (res.status === 401 && i < attempts.length - 1)
                 continue;
-            return {
+            const unavailable = {
                 status: "unavailable",
-                reason: res.status === 401 || res.status === 403
-                    ? "authorization"
-                    : res.status === 429 || res.status >= 500
-                        ? "server-error"
-                        : "http-error",
+                reason: res.status === 404
+                    ? "missing-route"
+                    : res.status === 401
+                        ? "unauthorized"
+                        : res.status === 403
+                            ? "authorization"
+                            : res.status === 429 || res.status >= 500
+                                ? "server-error"
+                                : "http-error",
             };
+            if (cacheKey && unavailable.reason === "server-error") {
+                cache.set(cacheKey, {
+                    result: unavailable,
+                    expiresAt: Date.now() + UNAVAILABLE_TTL_MS,
+                });
+            }
+            return unavailable;
         }
     }
     catch (error) {
-        return {
+        const unavailable = {
             status: "unavailable",
             reason: error instanceof Error &&
                 (error.name === "TimeoutError" || error.name === "AbortError")
                 ? "timeout"
-                : error instanceof SyntaxError
-                    ? "invalid-response"
-                    : "network",
+                : error instanceof Error && error.message.startsWith("SSRF blocked:")
+                    ? "ssrf-blocked"
+                    : error instanceof SyntaxError
+                        ? "invalid-response"
+                        : "network",
         };
+        if (cacheKey &&
+            (unavailable.reason === "timeout" || unavailable.reason === "network")) {
+            cache.set(cacheKey, {
+                result: unavailable,
+                expiresAt: Date.now() + UNAVAILABLE_TTL_MS,
+            });
+        }
+        return unavailable;
     }
     return { status: "unavailable", reason: "authorization" };
 }
+function normalizeDirectoryBaseUrl(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const url = new URL(trimmed);
+        if (url.protocol !== "https:" ||
+            url.username ||
+            url.password ||
+            url.search ||
+            url.hash) {
+            return null;
+        }
+        return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+    }
+    catch {
+        // coercion-ok: The caller returns this as invalid-origin, not as an empty directory.
+        return null;
+    }
+}
 export async function fetchOrgAppsResult(opts) {
     return fetchOrgAppsResultInternal(opts, true);
 }

package/dist/notifications/routes.d.ts

@@ -1,21 +1,21 @@
 export declare function createNotificationsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<"" | import("./types.js").Notification[] | {
-    count: number;
-    updated?: undefined;
     error?: undefined;
+    count: number;
     ok?: undefined;
+    updated?: undefined;
 } | {
+    error?: undefined;
     count?: undefined;
     updated: number;
-    error?: undefined;
     ok?: undefined;
 } | {
     count?: undefined;
-    updated?: undefined;
     error: string;
     ok?: undefined;
-} | {
-    count?: undefined;
     updated?: undefined;
+} | {
     error?: undefined;
+    count?: undefined;
     ok: boolean;
+    updated?: undefined;
 }>>;

package/dist/org/context.d.ts

@@ -54,6 +54,7 @@ export declare function createOrganization(name: string, email: string, role?: O
 }>;
 export declare function bootstrapAdminOrganization(rawEmail: string, event?: H3Event): Promise<boolean>;
 export declare function getOrgDomain(orgId: string): Promise<string | null>;
+export declare function getOrgWorkspaceUrl(orgId: string): Promise<string | null>;
 export declare function getOrgA2ASecret(orgId: string): Promise<string | null>;
 export declare function getA2ASecretByDomain(domain: string): Promise<string | null>;
 export type OrgDomainLookup = {

package/dist/org/context.js

@@ -741,6 +741,17 @@ export async function getOrgDomain(orgId) {
     const domain = String(rows[0].allowed_domain || "");
     return domain || null;
 }
+export async function getOrgWorkspaceUrl(orgId) {
+    const exec = getDbExec();
+    const { rows } = await exec.execute({
+        sql: `SELECT workspace_url FROM organizations WHERE id = ? LIMIT 1`,
+        args: [orgId],
+    });
+    if (!rows[0])
+        return null;
+    const workspaceUrl = String(rows[0].workspace_url ?? "").trim();
+    return workspaceUrl || null;
+}
 export async function getOrgA2ASecret(orgId) {
     const exec = getDbExec();
     const { rows } = await exec.execute({