@agent-native/core 0.209.1-nightly-20261015153252 → 0.209.1

package/dist/client/chat/agentkit-agent-native.js

@@ -1,12 +1,12 @@
 import { AgentKitRunSlotBusyError } from "@agent-native/agentkit/client";
-import { agentEventSequenceEnd, isAgentKitProtocolVersion, parseAgentQueuedMessage, parseAgentRunOptions, parseAgentThreadSnapshot, persistableFilePart, } from "@agent-native/agentkit/protocol";
+import { AGENT_NATIVE_SUBMISSION_DEADLINES_CAPABILITY_ID, createCapabilityUnavailableError, createCapabilityUnsupportedError, agentEventSequenceEnd, isAgentKitProtocolVersion, negotiateAgentKitProtocolVersion, parseAgentQueuedMessage, parseAgentRunOptions, parseAgentThreadSnapshot, persistableFilePart, } from "@agent-native/agentkit/protocol";
 import { failedRunIdsWithError, isRenderedRunNotStartedNotice, projectRootAssistantMessages, } from "../../agent/thread-message-projection.js";
 import { RUN_NOT_STARTED_METADATA_KEY, retryContextFromRequest, } from "../../shared/agent-chat-run-not-started.js";
 import { assertNoInlineImageBytes, stripInlineBytes, } from "../../shared/inline-bytes.js";
 import { toolInputFingerprint } from "../../shared/tool-inputs.js";
 import { agentEngineStatusUrlForChatApi, requireAgentEngineConfiguredForDispatch, } from "../agent-engine-readiness.js";
 import { agentNativePath } from "../api-path.js";
-import { CHAT_REQUEST_TOO_LARGE_MESSAGE } from "../error-format.js";
+import { CHAT_CAPABILITY_UNAVAILABLE_MESSAGE, CHAT_CAPABILITY_UNSUPPORTED_MESSAGE, CHAT_REQUEST_TOO_LARGE_MESSAGE, } from "../error-format.js";
 import { dispatchAgentChatRunning } from "../use-agent-chat-running-threads.js";
 import { appendChatThreadScopeParams, } from "../use-chat-threads.js";
 import { AGENT_NATIVE_PROTOCOL_METADATA_KEY, createAgentKitProtocolAdapter, } from "./agentkit-protocol.js";
@@ -2801,7 +2801,7 @@ export function createAgentNativeAgentKitTransport(options = {}) {
                     await waitForSnapshotRetry(attempt, signal);
                 };
                 throwIfRequestAborted(signal);
-                let response;
+                let response = undefined;
                 try {
                     response = await fetcher(threadUrl, {
                         method: "PUT",
@@ -2894,6 +2894,7 @@ export function createAgentNativeAgentKitTransport(options = {}) {
             queuedMessages: storedQueue(value.queuedMessages, threadId, now()),
             ...(message ? { message } : {}),
             ...(claimedMessage ? { claimedMessage } : {}),
+            ...(value.submissionExpired === true ? { submissionExpired: true } : {}),
         };
     }
     // A server that predates `active` meaning "in flight" reports a run inside
@@ -3040,6 +3041,9 @@ export function createAgentNativeAgentKitTransport(options = {}) {
                     type: "append",
                     message,
                 });
+                if (result.submissionExpired) {
+                    throw Object.assign(new Error("The prompt expired before it could be queued."), { code: "submission_expired", retryable: false });
+                }
                 if (!result.message) {
                     throw new TypeError("Agent chat queue mutation omitted its message.");
                 }
@@ -3093,6 +3097,10 @@ export function createAgentNativeAgentKitTransport(options = {}) {
                     throw error;
                 }
                 try {
+                    if (claim.submissionExpired) {
+                        clearPromotionClaimId(threadId, messageId);
+                        return { alreadyRemoved: true };
+                    }
                     if (!claim.claimedMessage) {
                         throw new TypeError("Agent chat queue claim response is invalid.");
                     }
@@ -3151,6 +3159,19 @@ export function createAgentNativeAgentKitTransport(options = {}) {
                     return run;
                 }
                 catch (error) {
+                    if (asRecord(error)?.code === "submission_expired") {
+                        try {
+                            await persistQueueMutation(threadId, {
+                                type: "remove",
+                                messageId,
+                            });
+                        }
+                        catch (removeError) {
+                            throw new AggregateError([error, removeError], "An expired queued prompt could not be removed.");
+                        }
+                        clearPromotionClaimId(threadId, messageId);
+                        return { alreadyRemoved: true };
+                    }
                     try {
                         await persistQueueMutation(threadId, {
                             type: "release",
@@ -3349,10 +3370,112 @@ export function createAgentNativeAgentKitTransport(options = {}) {
         }
     };
     const subscribeToRun = protocolTransport.subscribeToRun.bind(protocolTransport);
+    const discoverCapabilities = protocolTransport.discoverCapabilities?.bind(protocolTransport);
+    const serverBackedCapabilities = isAgentNativeChatRuntime(runtime);
+    const capabilitiesUrl = apiUrl.endsWith("/")
+        ? `${apiUrl}capabilities`
+        : `${apiUrl}/capabilities`;
     transport = {
         ...protocolTransport,
         assertAiSetupReady,
         startRun: (input, context) => startRunTrackingRunningState(input, context),
+        async discoverCapabilities(input, context) {
+            const capability = AGENT_NATIVE_SUBMISSION_DEADLINES_CAPABILITY_ID;
+            const discovery = discoverCapabilities
+                ? await discoverCapabilities(input, context)
+                : (() => {
+                    const legacy = protocolTransport.capabilities ?? {};
+                    return {
+                        protocol: negotiateAgentKitProtocolVersion(input.protocol, {
+                            correlationId: context?.correlationId,
+                        }),
+                        capabilities: Object.entries(legacy).reduce((descriptors, [id, state]) => {
+                            if (typeof state !== "boolean")
+                                return descriptors;
+                            const capabilityId = id;
+                            descriptors.push(state
+                                ? { id: capabilityId, state: "available" }
+                                : {
+                                    id: capabilityId,
+                                    state: "unsupported",
+                                    error: createCapabilityUnsupportedError(capabilityId),
+                                });
+                            return descriptors;
+                        }, []),
+                        discoveredAt: new Date().toISOString(),
+                        legacy,
+                    };
+                })();
+            let supported = false;
+            let unavailableError;
+            if (serverBackedCapabilities) {
+                const createUnavailableError = () => createCapabilityUnavailableError(capability, {
+                    message: CHAT_CAPABILITY_UNAVAILABLE_MESSAGE,
+                });
+                let response = undefined;
+                try {
+                    response = await fetcher(capabilitiesUrl, {
+                        method: "GET",
+                        headers: { Accept: "application/json" },
+                        credentials: "same-origin",
+                        cache: "no-store",
+                        ...(context?.signal ? { signal: context.signal } : {}),
+                    });
+                }
+                catch (error) {
+                    if (context?.signal?.aborted)
+                        throw error;
+                    unavailableError = createUnavailableError();
+                }
+                if (!unavailableError &&
+                    response &&
+                    !response.ok &&
+                    response.status !== 404 &&
+                    response.status !== 405) {
+                    unavailableError = createUnavailableError();
+                }
+                if (!unavailableError && response?.ok) {
+                    try {
+                        const serverCapabilities = asRecord(await response.json());
+                        if (!serverCapabilities) {
+                            throw new TypeError("Capability response must be an object.");
+                        }
+                        supported = serverCapabilities?.[capability] === true;
+                    }
+                    catch (error) {
+                        if (context?.signal?.aborted)
+                            throw error;
+                        unavailableError = createUnavailableError();
+                    }
+                }
+            }
+            const descriptor = supported
+                ? { id: capability, state: "available" }
+                : unavailableError
+                    ? { id: capability, state: "unavailable", error: unavailableError }
+                    : {
+                        id: capability,
+                        state: "unsupported",
+                        error: createCapabilityUnsupportedError(capability, {
+                            message: CHAT_CAPABILITY_UNSUPPORTED_MESSAGE,
+                        }),
+                    };
+            const legacy = { ...discovery.legacy };
+            if (unavailableError) {
+                delete legacy[capability];
+            }
+            else {
+                legacy[capability] = supported;
+            }
+            return {
+                ...discovery,
+                capabilities: [
+                    ...discovery.capabilities.filter((candidate) => candidate.id !== capability),
+                    descriptor,
+                ],
+                legacy,
+            };
+        },
         async *subscribeToRun(input) {
             dispatchAgentChatRunning({
                 isRunning: true,

package/dist/client/error-format.d.ts

@@ -17,6 +17,8 @@ export declare const NEW_CHAT_ACTION_HREF = "agent-native:new-chat";
 export declare const PROVIDER_CREDENTIAL_REJECTED_MESSAGE = "The provider rejected the credential used for this request; it is skipped on the next attempt. Retry, or update your provider key if it keeps failing.";
 export declare const SERVER_AUTHORED_CREDENTIAL_CODES: ReadonlySet<string>;
 export declare const CHAT_REQUEST_TOO_LARGE_MESSAGE = "This request exceeded the server's size limit (HTTP 413). Start a new chat or remove large attachments or references, then retry.";
+export declare const CHAT_CAPABILITY_UNAVAILABLE_MESSAGE = "We couldn't send your message right now. Please try again shortly.";
+export declare const CHAT_CAPABILITY_UNSUPPORTED_MESSAGE = "This app can't safely retry your saved prompt yet. Update the app, then try again.";
 export declare function formatChatErrorText(errorMessage: string, upgradeUrl?: string, errorCode?: string): string;
 export interface NormalizedChatError {
     message: string;

package/dist/client/error-format.js

@@ -54,6 +54,8 @@ const INVALID_ATTACHMENT_MESSAGE = "The model provider rejected this attachment'
 const MALFORMED_REQUEST_ATTACHMENT_MESSAGE = "The model rejected an attached file, so this message was never sent. Remove the attachment and retry — a PDF, a plain-text file, or a JPEG, PNG, GIF, or WebP image is read directly; other formats have to be uploaded and linked instead.";
 const MALFORMED_REQUEST_MESSAGE = "The model provider rejected this request as malformed, so it was not retried. Retry, or start a new chat if it keeps happening.";
 export const CHAT_REQUEST_TOO_LARGE_MESSAGE = "This request exceeded the server's size limit (HTTP 413). Start a new chat or remove large attachments or references, then retry.";
+export const CHAT_CAPABILITY_UNAVAILABLE_MESSAGE = "We couldn't send your message right now. Please try again shortly.";
+export const CHAT_CAPABILITY_UNSUPPORTED_MESSAGE = "This app can't safely retry your saved prompt yet. Update the app, then try again.";
 const MALFORMED_REQUEST_CODES = new Set([
     "invalid_request",
     "invalid_request_error",
@@ -108,6 +110,14 @@ const KNOWN_CHAT_ERROR_KEYS = new Map([
     ],
     [INVALID_ATTACHMENT_MESSAGE, "agentChat.errorMessages.invalidAttachment"],
     [CHAT_REQUEST_TOO_LARGE_MESSAGE, "agentChat.errorMessages.requestTooLarge"],
+    [
+        CHAT_CAPABILITY_UNAVAILABLE_MESSAGE,
+        "agentChat.errorMessages.capabilityUnavailable",
+    ],
+    [
+        CHAT_CAPABILITY_UNSUPPORTED_MESSAGE,
+        "agentChat.errorMessages.capabilityUnsupported",
+    ],
     [
         "No LLM provider is connected. Open this app's Manage agent > LLM, then use Builder.io or add a provider key.",
         "agentChat.errorMessages.noProviderConnected",

package/dist/collab/routes.d.ts

@@ -13,8 +13,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
     };
 }>>;
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/mcp/screen-memory-stdio.d.ts

@@ -140,13 +140,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
             includeMicrophone?: undefined;
             includeSystemAudio?: undefined;
             requestId?: undefined;
+            count?: undefined;
         };
         required?: undefined;
     };
@@ -171,13 +171,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
             includeMicrophone?: undefined;
             includeSystemAudio?: undefined;
             requestId?: undefined;
+            count?: undefined;
         };
         required?: undefined;
     };
@@ -196,13 +196,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
             includeMicrophone?: undefined;
             includeSystemAudio?: undefined;
             requestId?: undefined;
+            count?: undefined;
         };
         required?: undefined;
     };
@@ -231,13 +231,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             };
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
             includeMicrophone?: undefined;
             includeSystemAudio?: undefined;
             requestId?: undefined;
+            count?: undefined;
         };
     };
 } | {
@@ -260,12 +260,12 @@ export declare function screenMemoryMcpToolDefinitions(): ({
                 description: string;
             };
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             includeMicrophone?: undefined;
             includeSystemAudio?: undefined;
             requestId?: undefined;
+            count?: undefined;
         };
     };
 } | {
@@ -317,7 +317,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt: {
                 type: string;
                 description: string;
@@ -337,6 +336,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
                 type: string;
             };
             requestId?: undefined;
+            count?: undefined;
         };
     };
 } | {
@@ -352,7 +352,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -361,6 +360,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             requestId: {
                 type: string;
             };
+            count?: undefined;
         };
     };
 })[];

package/dist/org/index.d.ts

@@ -22,7 +22,7 @@ export { offboardMember } from "../identity/offboard.js";
 export type { OffboardMemberOptions, OffboardMemberResult, } from "../identity/offboard.js";
 export { registerIdentityColumns } from "../identity/rekey.js";
 export type { AppIdentityColumn, IdentityEmailChange, IdentityOffboard, IdentityOrgScope, } from "../identity/rekey.js";
-export { claimWorkspaceAppForOrganization, isStandaloneDispatchRuntime, isWorkspaceAppAccessAllowed, } from "./workspace-app-access.js";
+export { checkWorkspaceAppAccess, claimWorkspaceAppForOrganization, isStandaloneDispatchRuntime, isWorkspaceAppAccessAllowed, isWorkspaceAppAccessUnavailable, type WorkspaceAppAccessCheck, type WorkspaceAppAccessOutcome, type WorkspaceAppAccessUnavailable, } from "./workspace-app-access.js";
 export { defineAppRoles, getRegisteredAppRoles, listRegisteredAppRoles, listAppMemberRoles, resolveAppRole, setAppMemberRole, setAppMemberRoles, applyInvitationAppRoles, getAppPermissionOverrides, setAppPermissionRoles, resolveAppAuthorizationContext, } from "./app-roles.js";
 export type { AppRoles, AppRolesDescriptor, AppRoleCaller, AppPermissionPolicy, AppRoleLookup, AppMemberRoleRow, AppAuthorizationContext, } from "./app-roles.js";
 export { ORG_MIGRATIONS } from "./migrations.js";

package/dist/org/index.js

@@ -32,7 +32,7 @@ export { invalidateMemberOrgCaches } from "./request-org-cache.js";
 export { isMissingOrganizationTableError } from "./membership.js";
 export { offboardMember } from "../identity/offboard.js";
 export { registerIdentityColumns } from "../identity/rekey.js";
-export { claimWorkspaceAppForOrganization, isStandaloneDispatchRuntime, isWorkspaceAppAccessAllowed, } from "./workspace-app-access.js";
+export { checkWorkspaceAppAccess, claimWorkspaceAppForOrganization, isStandaloneDispatchRuntime, isWorkspaceAppAccessAllowed, isWorkspaceAppAccessUnavailable, } from "./workspace-app-access.js";
 export { defineAppRoles, getRegisteredAppRoles, listRegisteredAppRoles, listAppMemberRoles, resolveAppRole, setAppMemberRole, setAppMemberRoles, applyInvitationAppRoles, getAppPermissionOverrides, setAppPermissionRoles, resolveAppAuthorizationContext, } from "./app-roles.js";
 export { ORG_MIGRATIONS } from "./migrations.js";
 export { CROSS_APP_ORG_FEDERATION_FLAG, CROSS_APP_ORG_FEDERATION_SCOPE, } from "./feature-flags.js";

package/dist/org/workspace-app-access-outcome.d.ts

@@ -0,0 +1,45 @@
+export declare const WORKSPACE_APP_ACCESS_UNAVAILABLE: "unavailable";
+export declare const WORKSPACE_APP_ACCESS_UNAVAILABLE_MESSAGE = "Workspace app access is temporarily unavailable.";
+export type WorkspaceAppAccessUnavailableReason = "directory-url-invalid" | "org-domain-lookup-failed" | "org-domain-missing" | "a2a-secret-missing" | "token-signing-failed" | "registry-timeout" | "registry-fetch-failed" | "registry-http-error" | "registry-malformed-response" | "claim-http-error" | "claim-malformed-response";
+/**
+ * The access check could not reach a verdict. Distinct from `false`: the
+ * caller is not refused, the answer is unknown, and `reason` says which step
+ * failed so a 503 can be traced without server logs.
+ */
+export interface WorkspaceAppAccessUnavailable {
+    status: typeof WORKSPACE_APP_ACCESS_UNAVAILABLE;
+    reason: WorkspaceAppAccessUnavailableReason;
+    /** HTTP status of the Dispatch registry reply, when one arrived. */
+    upstreamStatus?: number;
+    /** Audience the caller signed for: origin and path only, never userinfo. */
+    audience?: string;
+    /** Short text from the upstream reply or error class. Untrusted. */
+    detail?: string;
+}
+/** What `isWorkspaceAppAccessAllowed` has always returned. */
+export type WorkspaceAppAccessOutcome = boolean | typeof WORKSPACE_APP_ACCESS_UNAVAILABLE;
+/** A verdict, or the cause when none could be reached. */
+export type WorkspaceAppAccessCheck = boolean | WorkspaceAppAccessUnavailable;
+export declare function isWorkspaceAppAccessUnavailable(outcome: unknown): outcome is WorkspaceAppAccessUnavailable;
+export declare function workspaceAppAccessUnavailable(reason: WorkspaceAppAccessUnavailableReason, extra?: Pick<WorkspaceAppAccessUnavailable, "upstreamStatus" | "audience" | "detail">): WorkspaceAppAccessUnavailable;
+export declare function workspaceAppAccessUnavailableBody(outcome: WorkspaceAppAccessUnavailable): {
+    error: string;
+    code: WorkspaceAppAccessUnavailableReason;
+    upstreamStatus?: number;
+    audience?: string;
+    detail?: string;
+};
+/**
+ * Names a thrown error without echoing its message: driver and upstream
+ * messages can carry hostnames or connection strings.
+ */
+export declare function describeFetchFailure(error: unknown): {
+    timedOut: boolean;
+    detail: string;
+};
+/**
+ * Reads the human-readable refusal out of a registry error reply, if it sent
+ * JSON. A non-JSON or unreadable body yields no detail; the HTTP status on the
+ * outcome already says the call failed.
+ */
+export declare function registryErrorDetail(body: unknown): string | undefined;

package/dist/org/workspace-app-access-outcome.js

@@ -0,0 +1,80 @@
+export const WORKSPACE_APP_ACCESS_UNAVAILABLE = "unavailable";
+export const WORKSPACE_APP_ACCESS_UNAVAILABLE_MESSAGE = "Workspace app access is temporarily unavailable.";
+const MAX_DETAIL_LENGTH = 160;
+export function isWorkspaceAppAccessUnavailable(outcome) {
+    return (typeof outcome === "object" &&
+        outcome !== null &&
+        outcome.status ===
+            WORKSPACE_APP_ACCESS_UNAVAILABLE);
+}
+export function workspaceAppAccessUnavailable(reason, extra = {}) {
+    const detail = boundedDetail(extra.detail);
+    return {
+        status: WORKSPACE_APP_ACCESS_UNAVAILABLE,
+        reason,
+        ...(extra.upstreamStatus === undefined
+            ? {}
+            : { upstreamStatus: extra.upstreamStatus }),
+        ...(extra.audience ? { audience: extra.audience } : {}),
+        ...(detail ? { detail } : {}),
+    };
+}
+export function workspaceAppAccessUnavailableBody(outcome) {
+    return {
+        error: WORKSPACE_APP_ACCESS_UNAVAILABLE_MESSAGE,
+        code: outcome.reason,
+        ...(outcome.upstreamStatus === undefined
+            ? {}
+            : { upstreamStatus: outcome.upstreamStatus }),
+        ...(outcome.audience ? { audience: outcome.audience } : {}),
+        ...(outcome.detail ? { detail: outcome.detail } : {}),
+    };
+}
+/**
+ * Names a thrown error without echoing its message: driver and upstream
+ * messages can carry hostnames or connection strings.
+ */
+export function describeFetchFailure(error) {
+    const name = error instanceof Error ? error.name : "UnknownError";
+    const cause = error instanceof Error ? error.cause : undefined;
+    const code = cause && typeof cause.code === "string"
+        ? cause.code
+        : "";
+    return {
+        timedOut: name === "AbortError" || name === "TimeoutError",
+        detail: code ? `${name}:${code}` : name,
+    };
+}
+/**
+ * Reads the human-readable refusal out of a registry error reply, if it sent
+ * JSON. A non-JSON or unreadable body yields no detail; the HTTP status on the
+ * outcome already says the call failed.
+ */
+export function registryErrorDetail(body) {
+    if (!body || typeof body !== "object")
+        return undefined;
+    const record = body;
+    for (const candidate of [
+        record.error,
+        record.statusMessage,
+        record.message,
+    ]) {
+        if (typeof candidate === "string" && candidate.trim())
+            return candidate;
+    }
+    return undefined;
+}
+function boundedDetail(value) {
+    if (!value)
+        return undefined;
+    const collapsed = value
+        // eslint-disable-next-line no-control-regex
+        .replace(/[\u0000-\u001f\u007f]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!collapsed)
+        return undefined;
+    return collapsed.length > MAX_DETAIL_LENGTH
+        ? `${collapsed.slice(0, MAX_DETAIL_LENGTH)}…`
+        : collapsed;
+}

package/dist/org/workspace-app-access-request.d.ts

@@ -1,8 +1,8 @@
-import { type WorkspaceAppAccessOutcome } from "./workspace-app-access.js";
+import { type WorkspaceAppAccessCheck } from "./workspace-app-access.js";
 export type WorkspaceAppAccessRequest = {
     path: string;
     method: string;
     email: string;
     orgId?: string | null;
 };
-export declare function checkWorkspaceAppAccessForRequest(request: WorkspaceAppAccessRequest): Promise<WorkspaceAppAccessOutcome | null>;
+export declare function checkWorkspaceAppAccessForRequest(request: WorkspaceAppAccessRequest): Promise<WorkspaceAppAccessCheck | null>;

package/dist/org/workspace-app-access-request.js

@@ -1,4 +1,4 @@
-import { isWorkspaceAppAccessAllowed, } from "./workspace-app-access.js";
+import { checkWorkspaceAppAccess, } from "./workspace-app-access.js";
 import { resolveWorkspaceAccessAppId } from "./workspace-app-identity.js";
 function isWorkspaceAccessRecoveryPath(path, method) {
     return (path === "/_agent-native/org/me" ||
@@ -13,7 +13,7 @@ export async function checkWorkspaceAppAccessForRequest(request) {
     if (!appId || isWorkspaceAccessRecoveryPath(request.path, request.method)) {
         return null;
     }
-    return isWorkspaceAppAccessAllowed(appId, {
+    return checkWorkspaceAppAccess(appId, {
         email: request.email,
         orgId: request.orgId,
     });

package/dist/org/workspace-app-access.d.ts

@@ -1,10 +1,15 @@
-export declare const WORKSPACE_APP_ACCESS_UNAVAILABLE: "unavailable";
-export declare const WORKSPACE_APP_ACCESS_UNAVAILABLE_MESSAGE = "Workspace app access is temporarily unavailable.";
-export type WorkspaceAppAccessOutcome = boolean | typeof WORKSPACE_APP_ACCESS_UNAVAILABLE;
+import { type WorkspaceAppAccessCheck, type WorkspaceAppAccessOutcome } from "./workspace-app-access-outcome.js";
+export { WORKSPACE_APP_ACCESS_UNAVAILABLE, WORKSPACE_APP_ACCESS_UNAVAILABLE_MESSAGE, isWorkspaceAppAccessUnavailable, workspaceAppAccessUnavailableBody, type WorkspaceAppAccessCheck, type WorkspaceAppAccessOutcome, type WorkspaceAppAccessUnavailable, type WorkspaceAppAccessUnavailableReason, } from "./workspace-app-access-outcome.js";
 export interface WorkspaceAppAccessContext {
     email: string;
     orgId?: string | null;
 }
 export declare function isStandaloneDispatchRuntime(): boolean;
 export declare function claimWorkspaceAppForOrganization(appId: string, context: WorkspaceAppAccessContext): Promise<boolean>;
+/**
+ * Keeps the contract this function has always had: `true`, `false`, or the
+ * `"unavailable"` sentinel. Use `checkWorkspaceAppAccess` to learn why a verdict
+ * could not be reached.
+ */
 export declare function isWorkspaceAppAccessAllowed(appId: string, context: WorkspaceAppAccessContext): Promise<WorkspaceAppAccessOutcome>;
+export declare function checkWorkspaceAppAccess(appId: string, context: WorkspaceAppAccessContext): Promise<WorkspaceAppAccessCheck>;