@agent-native/core 0.220.0-nightly-20261024033422 → 0.220.0

package/dist/agent/tool-approval-store.js

@@ -87,6 +87,70 @@ export class AgentToolApprovalNotFoundError extends Error {
         this.name = "AgentToolApprovalNotFoundError";
     }
 }
+export async function hasPendingAgentToolApproval(tx, input) {
+    const result = await tx.execute({
+        sql: `SELECT 1 FROM agent_tool_approvals
+      WHERE owner_email = ?
+        AND ((org_id IS NULL AND CAST(? AS TEXT) IS NULL) OR org_id = CAST(? AS TEXT))
+        AND thread_id = ?
+        AND status = 'pending'
+        AND expires_at > ?
+      LIMIT 1`,
+        args: [
+            input.ownerEmail,
+            input.orgId ?? null,
+            input.orgId ?? null,
+            input.threadId,
+            Date.now(),
+        ],
+    });
+    return result.rows.length > 0;
+}
+/** Denial is a durable resolution so queued turns can resume after a pause. */
+export async function denyAgentToolApproval(input) {
+    await ensureAgentToolApprovalTable();
+    const now = Date.now();
+    const updated = await withFencedExecutionWrite((tx) => tx.execute({
+        sql: `UPDATE agent_tool_approvals
+          SET status = 'denied', updated_at = ?
+          WHERE id = ?
+            AND owner_email = ?
+            AND ((org_id IS NULL AND CAST(? AS TEXT) IS NULL) OR org_id = CAST(? AS TEXT))
+            AND thread_id = ?
+            AND status = 'pending'`,
+        args: [
+            now,
+            input.approvalId,
+            input.ownerEmail,
+            input.orgId ?? null,
+            input.orgId ?? null,
+            input.threadId,
+        ],
+    }), { threadId: input.threadId });
+    if (updated.rowsAffected === 1)
+        return "denied";
+    const existing = await getDbExec().execute({
+        sql: `SELECT status FROM agent_tool_approvals
+      WHERE id = ?
+        AND owner_email = ?
+        AND ((org_id IS NULL AND CAST(? AS TEXT) IS NULL) OR org_id = CAST(? AS TEXT))
+        AND thread_id = ?
+      LIMIT 1`,
+        args: [
+            input.approvalId,
+            input.ownerEmail,
+            input.orgId ?? null,
+            input.orgId ?? null,
+            input.threadId,
+        ],
+    });
+    const status = existing.rows[0]?.status;
+    if (status === "denied")
+        return "denied";
+    if (status && status !== "pending")
+        return "already_resolved";
+    return "not_applied";
+}
 /**
  * Saves "always allow" for one tool name. With `approvalId`, the grant takes
  * the revision of that approval row, the card the user clicked, so it never

package/dist/automation/index.d.ts

@@ -139,8 +139,8 @@ export declare function createAutomationCallbackHandler(runtime: AutomationRunti
     duplicate?: undefined;
     eventId?: undefined;
 } | {
+    error?: undefined;
     accepted: boolean;
     duplicate: boolean;
     eventId: string;
-    error?: undefined;
 }>;

package/dist/client/background-agent-session.d.ts

@@ -42,3 +42,7 @@ export declare function cancelBackgroundAgentSession(options: {
     turnId: string;
     reason?: string;
 }): Promise<void>;
+export type AgentRunThreadProjectionRetryState = "already_projected" | "projected" | "deferred";
+export declare function retryAgentRunThreadProjection(runId: string): Promise<{
+    state: AgentRunThreadProjectionRetryState;
+}>;

package/dist/client/background-agent-session.js

@@ -23,13 +23,16 @@ class BackgroundAgentSessionHttpError extends Error {
     }
 }
 async function responseError(response) {
+    return responseErrorFor(response, "Background agent session");
+}
+async function responseErrorFor(response, requestName) {
     const body = await response
         .json()
         .catch(() => null);
     const detail = body && typeof body.error === "string" && body.error.trim()
         ? `: ${body.error.trim()}`
         : "";
-    return new BackgroundAgentSessionHttpError(response.status, `Background agent session was rejected (HTTP ${response.status})${detail}`);
+    return new BackgroundAgentSessionHttpError(response.status, `${requestName} was rejected (HTTP ${response.status})${detail}`);
 }
 async function drainResponse(response) {
     const reader = response.body?.getReader();
@@ -241,3 +244,16 @@ export async function cancelBackgroundAgentSession(options) {
         throw await responseError(turnResponse);
     }
 }
+export async function retryAgentRunThreadProjection(runId) {
+    const response = await fetch(agentNativePath(`/_agent-native/agent-chat/runs/${encodeURIComponent(runId)}/retry-projection`), { method: "POST", credentials: "same-origin" });
+    if (!response.ok) {
+        throw await responseErrorFor(response, "Run projection retry");
+    }
+    const body = (await response.json());
+    if (body.state !== "already_projected" &&
+        body.state !== "projected" &&
+        body.state !== "deferred") {
+        throw new Error("Run projection retry returned an invalid response");
+    }
+    return { state: body.state };
+}

package/dist/client/chat/runtime.js

@@ -3474,12 +3474,44 @@ export function createAgentNativeChatRuntime(options = {}, telemetry = {}) {
                 });
             }
             if (!approval.approved) {
-                messageStates.delete(messageStateKey);
-                return terminalRuntimeTurn({
-                    sessionId: session.id,
-                    turnId: continuation.turnId,
-                    reason: "complete",
-                });
+                return (async () => {
+                    const threadId = session.threadId ?? options.threadId ?? session.id;
+                    const headers = await resolveHeaders(options.headers, {
+                        sessionId: session.id,
+                        turnId: continuation.turnId,
+                    });
+                    if (!headers.has("Content-Type")) {
+                        headers.set("Content-Type", "application/json");
+                    }
+                    const response = await fetchImpl(`${apiUrl.replace(/\/+$/, "")}/threads/${encodeURIComponent(threadId)}/approval-resolution`, {
+                        method: "POST",
+                        headers,
+                        credentials: "same-origin",
+                        body: JSON.stringify({
+                            approvalId: approval.id,
+                            decision: "deny",
+                        }),
+                    });
+                    let denialResolved = response.ok;
+                    if (!denialResolved && response.status === 409) {
+                        try {
+                            const body = asRecord(await response.clone().json());
+                            denialResolved = body?.code === "approval_not_pending";
+                        }
+                        catch {
+                            // coercion-ok: Preserve the original HTTP failure when conflict details are unreadable.
+                        }
+                    }
+                    if (!denialResolved) {
+                        throw new Error(await readErrorText(response));
+                    }
+                    messageStates.delete(messageStateKey);
+                    return terminalRuntimeTurn({
+                        sessionId: session.id,
+                        turnId: continuation.turnId,
+                        reason: "complete",
+                    });
+                })();
             }
             const messageState = messageStates.get(messageStateKey);
             const approvalParts = [

package/dist/collab/routes.d.ts

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

package/dist/db/schema-snapshot.generated.js

@@ -1,6 +1,7 @@
 export const SCHEMA_SNAPSHOT = {
     statements: [
         'CREATE SEQUENCE IF NOT EXISTS "agent_chat_submission_inbox_queue_order_seq";',
+        'CREATE SEQUENCE IF NOT EXISTS "agent_run_projection_retry_order_seq";',
         'CREATE SEQUENCE IF NOT EXISTS "app_resource_change_seq";',
         'CREATE SEQUENCE IF NOT EXISTS "automation_trigger_event_queue_sequence_id_seq";',
         'CREATE TABLE "_better_auth_migrations" (\n  "version" bigint NOT NULL\n);',
@@ -50,7 +51,7 @@ export const SCHEMA_SNAPSHOT = {
         'CREATE TABLE "agent_review_thread_preferences" (\n  "thread_id" text NOT NULL,\n  "user_email" text NOT NULL,\n  "muted" integer DEFAULT 0 NOT NULL,\n  "unread" integer DEFAULT 0 NOT NULL,\n  "updated_at" text NOT NULL\n);',
         'CREATE TABLE "agent_run_events" (\n  "run_id" text NOT NULL,\n  "seq" bigint NOT NULL,\n  "event_at" bigint,\n  "event_data" text NOT NULL\n);',
         'CREATE TABLE "agent_run_outcome_daily" (\n  "day" text NOT NULL,\n  "status" text NOT NULL,\n  "terminal_reason" text DEFAULT \'\'::text NOT NULL,\n  "run_count" bigint DEFAULT 0 NOT NULL\n);',
-        'CREATE TABLE "agent_runs" (\n  "id" text NOT NULL,\n  "thread_id" text NOT NULL,\n  "status" text DEFAULT \'running\'::text NOT NULL,\n  "abort_reason" text,\n  "started_at" bigint NOT NULL,\n  "completed_at" bigint,\n  "heartbeat_at" bigint,\n  "last_progress_at" bigint,\n  "turn_id" text,\n  "error_code" text,\n  "error_detail" text,\n  "terminal_reason" text,\n  "dispatch_mode" text,\n  "diag_stage" text,\n  "dispatch_payload" text,\n  "peak_rss_mb" bigint,\n  "continuation_order" bigint,\n  "thread_projection_pending" boolean DEFAULT false NOT NULL,\n  "worker_stage" text,\n  "in_flight_since" bigint,\n  "auto_continue_of" text,\n  "worker_generation" bigint\n);',
+        'CREATE TABLE "agent_runs" (\n  "id" text NOT NULL,\n  "thread_id" text NOT NULL,\n  "status" text DEFAULT \'running\'::text NOT NULL,\n  "abort_reason" text,\n  "started_at" bigint NOT NULL,\n  "completed_at" bigint,\n  "heartbeat_at" bigint,\n  "last_progress_at" bigint,\n  "turn_id" text,\n  "error_code" text,\n  "error_detail" text,\n  "terminal_reason" text,\n  "dispatch_mode" text,\n  "diag_stage" text,\n  "dispatch_payload" text,\n  "peak_rss_mb" bigint,\n  "continuation_order" bigint,\n  "thread_projection_pending" boolean DEFAULT false NOT NULL,\n  "thread_projection_retry_order" bigint,\n  "thread_projection_error_code" text,\n  "worker_stage" text,\n  "in_flight_since" bigint,\n  "auto_continue_of" text,\n  "worker_generation" bigint\n);',
         'CREATE TABLE "agent_satisfaction_scores" (\n  "id" text NOT NULL,\n  "thread_id" text NOT NULL,\n  "user_id" text,\n  "frustration_score" real DEFAULT 0 NOT NULL,\n  "rephrasing_score" real DEFAULT 0 NOT NULL,\n  "abandonment_score" real DEFAULT 0 NOT NULL,\n  "sentiment_score" real DEFAULT 0 NOT NULL,\n  "length_trend_score" real DEFAULT 0 NOT NULL,\n  "computed_at" bigint NOT NULL\n);',
         'CREATE TABLE "agent_team_run_queue" (\n  "task_id" text NOT NULL,\n  "thread_id" text NOT NULL,\n  "run_id" text NOT NULL,\n  "status" text DEFAULT \'queued\'::text NOT NULL,\n  "owner_email" text,\n  "org_id" text,\n  "payload" text NOT NULL,\n  "continuation_count" bigint DEFAULT 0 NOT NULL,\n  "attempts" bigint DEFAULT 0 NOT NULL,\n  "created_at" bigint NOT NULL,\n  "updated_at" bigint NOT NULL,\n  "reconciliation_attempted_at" bigint\n);',
         'CREATE TABLE "agent_tool_approval_policies" (\n  "id" text NOT NULL,\n  "owner_email" text NOT NULL,\n  "org_id" text,\n  "tool_name" text NOT NULL,\n  "enabled" boolean NOT NULL,\n  "created_at" bigint NOT NULL,\n  "updated_at" bigint NOT NULL,\n  "tool_revision" text\n);',
@@ -432,6 +433,7 @@ export const SCHEMA_SNAPSHOT = {
         "CREATE INDEX idx_review_suggestion_proposal_members ON public.agent_review_suggestions USING btree (proposal_id, created_at);",
         "CREATE INDEX idx_review_suggestions_resource ON public.agent_review_suggestions USING btree (resource_type, resource_id, created_at);",
         "CREATE INDEX agent_runs_thread_projection_pending_idx ON public.agent_runs USING btree (completed_at, id) WHERE (thread_projection_pending IS TRUE);",
+        "CREATE INDEX agent_runs_thread_projection_retry_order_idx ON public.agent_runs USING btree (thread_projection_retry_order NULLS FIRST, completed_at, id) WHERE (thread_projection_pending IS TRUE);",
         "CREATE INDEX idx_satisfaction_thread ON public.agent_satisfaction_scores USING btree (thread_id);",
         "CREATE INDEX idx_satisfaction_user ON public.agent_satisfaction_scores USING btree (user_id, computed_at);",
         "CREATE INDEX idx_agent_team_run_queue_reconciliation ON public.agent_team_run_queue USING btree (status, reconciliation_attempted_at, updated_at) WHERE (status = ANY (ARRAY['queued'::text, 'running'::text]));",
@@ -833,12 +835,23 @@ export const SCHEMA_SNAPSHOT = {
             "agent-run-liveness-and-diagnostics-columns",
             "2a9d24ed6ffbea78",
         ],
+        [
+            "agent_runs",
+            "agent-run-thread-projection-quarantine",
+            "8eb065e2325e20ea",
+        ],
         ["agent_runs", "agent-run-thread-projection-retry", "d564128e21e3b424"],
+        [
+            "agent_runs",
+            "agent-run-thread-projection-retry-fairness",
+            "36150eae08f95f3d",
+        ],
         ["agent_runs", "agent-tool-ledger-arguments-hash", "495946626eda9dc4"],
         ["agent_runs", "agent-tool-ledger-chat-ui-result", "288137f1126005f6"],
         ["agent_runs", "agent-tool-ledger-result-type", "d4fe90219a833db8"],
         ["agent_runs", "agent-turn-execution-leases-and-steps", "bc8cfdc3fc695e2a"],
         ["agent_runs", "baseline", null],
+        ["agent_runs", "thread-projection-retry-quarantine-runtime-schema", null],
         ["agent_runs", "widen-bigint", null],
         ["agent_team_run_queue", "baseline", null],
         [

package/dist/file-upload/actions/upload-image.d.ts

@@ -42,8 +42,8 @@ declare const _default: import("../../action.js").ActionDefinition<{
     url: string;
     id: string;
     provider: string;
-    configured?: undefined;
     error?: undefined;
+    configured?: undefined;
 } | {
     url?: undefined;
     id?: undefined;

package/dist/jobs/automation-recovery.d.ts

@@ -16,6 +16,10 @@ export declare class AutomationRecoveryStorageError extends Error {
     readonly errorCode = "automation_recovery_storage_unavailable";
     constructor(cause: unknown);
 }
+export declare class AutomationRecoveryProjectionDeferredError extends Error {
+    readonly errorCode = "automation_recovery_projection_deferred";
+    constructor(runId: string);
+}
 export declare function withAutomationRecoveryStorage<T>(operation: () => Promise<T>): Promise<T>;
 export declare function readAutomationRecoveryEvents(threadId: string, turnId: string): Promise<CurrentTurnRunEvent[]>;
 export declare function readAutomationRunDeliveryNote(runId: string): Promise<string>;

package/dist/jobs/automation-recovery.js

@@ -16,6 +16,13 @@ export class AutomationRecoveryStorageError extends Error {
         this.name = "AutomationRecoveryStorageError";
     }
 }
+export class AutomationRecoveryProjectionDeferredError extends Error {
+    errorCode = "automation_recovery_projection_deferred";
+    constructor(runId) {
+        super(`Automation recovery is waiting for run ${runId} to project its thread`);
+        this.name = "AutomationRecoveryProjectionDeferredError";
+    }
+}
 export async function withAutomationRecoveryStorage(operation) {
     try {
         return await operation();

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

@@ -8,7 +8,7 @@ import { actionsToEngineTools, filterInitialEngineTools, resolveOwnerEngineApiKe
 import { foldReapedRunIntoThread } from "../agent/reaped-run-thread.js";
 import { AgentLoopAbortedError, runAgentLoopDirectWithSoftTimeout, } from "../agent/run-loop-with-resume.js";
 import { abortRun, resolveBackgroundAutomationSoftTimeoutMs, resolveBackgroundRunHardTimeoutMs, startRun, } from "../agent/run-manager.js";
-import { claimBackgroundRun, beginAgentExecutionStep, completeAgentExecutionStep, markAgentExecutionStepDispatched, insertRun, tryClaimRunSlot, releaseBackgroundRunBeforeStart, } from "../agent/run-store.js";
+import { claimBackgroundRun, beginAgentExecutionStep, completeAgentExecutionStep, markAgentExecutionStepDispatched, insertRun, tryClaimRunSlot, retryRunThreadProjection, releaseBackgroundRunBeforeStart, } from "../agent/run-store.js";
 import { buildAssistantMessageFromRunJournal } from "../agent/run-thread-projector.js";
 import { buildCurrentTimeUserContext, buildRuntimeContextPrompt, } from "../agent/runtime-context.js";
 import { buildAssistantMessage, buildUserMessage, extractThreadMeta, foldAssistantTurn, upsertUserMessage, threadDataToEngineMessages, threadMessageTextForEngine, } from "../agent/thread-data-builder.js";
@@ -28,7 +28,7 @@ import { runWithRequestContext, } from "../server/request-context.js";
 import { normalizeReasoningEffortForRequest } from "../shared/reasoning-effort.js";
 import automationNoOpAction, { AUTOMATION_NO_OP_TOOL, automationNoOpSchema, } from "./actions/automation-no-op.js";
 import { applyAutomationFailure, automationOwnerKind, classifyAutomationFailure, CONFIG_INVALID_ERROR_CODE, CONNECTION_REQUIRED_ERROR_CODE, MISSING_TOOLS_ERROR_CODE, OWNER_MISSING_ERROR_CODE, pausedMessage, withDeliveryNote, } from "./automation-outcome.js";
-import { AutomationRecoveryStorageError, deliveryNoteForEvents, readAutomationRecoveryEvents, readAutomationRunDeliveryNote, withAutomationRecoveryStorage, } from "./automation-recovery.js";
+import { AutomationRecoveryProjectionDeferredError, AutomationRecoveryStorageError, deliveryNoteForEvents, readAutomationRecoveryEvents, readAutomationRunDeliveryNote, withAutomationRecoveryStorage, } from "./automation-recovery.js";
 import { automationRunTerminalError, } from "./automation-terminal-error.js";
 import { inspectAutomationWork } from "./automation-work-evidence.js";
 import { effectiveTimezone } from "./cron.js";
@@ -338,6 +338,7 @@ export async function runBackgroundAutomation(options, deps) {
     catch (err) {
         if (err instanceof StaleExecutionFenceError ||
             err instanceof AutomationSchedulerLeaseLostError ||
+            err instanceof AutomationRecoveryProjectionDeferredError ||
             err instanceof AutomationRecoveryStorageError ||
             (err instanceof BackgroundAutomationRunError &&
                 (err.errorCode === "background_automation_claim_lost" ||
@@ -460,6 +461,8 @@ export async function runJobRunner(options) {
     }
     catch (err) {
         if (err instanceof AutomationSchedulerLeaseLostError ||
+            err instanceof AutomationRecoveryProjectionDeferredError ||
+            err instanceof AutomationRecoveryStorageError ||
             (err instanceof BackgroundAutomationRunError &&
                 err.errorCode === "background_automation_history_write_failed"))
             throw err;
@@ -859,6 +862,20 @@ async function executeBackgroundAutomation(options, deps, historyId, runIdRef) {
         const systemPrompt = `${baseSystemPrompt}${workspaceAppContext ? `\n\n${workspaceAppContext}` : ""}\n\n${messages.noOpInstruction}`;
         assertHardDeadline(options.hardDeadlineAt);
         const resume = options.resume;
+        if (resume) {
+            const projection = await withAutomationRecoveryStorage(() => retryRunThreadProjection(resume.previousRunId));
+            switch (projection.state) {
+                case "deferred":
+                    throw new AutomationRecoveryProjectionDeferredError(resume.previousRunId);
+                case "untracked":
+                    // Inspection found this run before retention pruned its cleared
+                    // projection marker; a pending marker prevents that pruning.
+                    break;
+                case "projected":
+                case "already_projected":
+                    break;
+            }
+        }
         const thread = resume
             ? await withAutomationRecoveryStorage(() => getThread(resume.threadId))
             : await createThread(ownerEmail, {

package/dist/jobs/scheduler.js

@@ -4,7 +4,7 @@ import { withDbExec } from "../db/client.js";
 import { ensureTable as ensureResourcesTable, resourceGetByPath, resourceListAllOwners, resourcePutIfCurrent, resourcePutIfCurrentInTransaction, } from "../resources/store.js";
 import { countAutomationCredentialState, trackAutomationPaused, trackAutomationResumed, } from "./automation-events.js";
 import { applyAutomationFailure, classifyAutomationFailure, CLEAR_FAILURE_STATE, CONFIG_INVALID_ERROR_CODE, hasStalePause, isMissingCredentialCode, isPausedByFramework, isReservedIdentityBlocked, isTransientPauseProbeDue, OWNER_MISSING_ERROR_CODE, OWNER_RESERVED_ERROR_CODE, pauseNow, RESUME_AUTOMATION_PATCH, reservedIdentityMessage, runtimeFailureNextRun, TRANSIENT_PROBE_RESUME_PATCH, withDeliveryNote, } from "./automation-outcome.js";
-import { AutomationRecoveryStorageError, deliveryNoteForEvents, inspectAutomationRecovery, } from "./automation-recovery.js";
+import { AutomationRecoveryProjectionDeferredError, AutomationRecoveryStorageError, deliveryNoteForEvents, inspectAutomationRecovery, } from "./automation-recovery.js";
 import { backgroundRunCutOffReason, checkBackgroundAutomationCredentials, isBackgroundAutomationRunActive, resolveBackgroundAutomationIdentity, runBackgroundAutomation, runJobRunner, startBackgroundAutomationHistory, } from "./background-automation-runner.js";
 import { nextOccurrence, isValidCron, describeCron, effectiveTimezone, } from "./cron.js";
 import { buildJobResourceContent, isRecoveredFactoryJob, jobBelongsToApp, parseJobResource, patchJobFrontmatterFields, recoveredFactoryOwnerOrgId, } from "./frontmatter.js";
@@ -993,6 +993,8 @@ async function executeJob(resource, meta, body, deps, now, options = {}) {
         const failure = classifyAutomationFailure(err);
         if (err instanceof AutomationSchedulerLeaseLostError)
             throw err;
+        if (err instanceof AutomationRecoveryProjectionDeferredError)
+            throw err;
         if (err instanceof AutomationRecoveryStorageError)
             throw err;
         if (failure.code === "background_automation_history_write_failed")

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

@@ -21,17 +21,18 @@
  *
  * ## Resolution + safety model
  *
- *   - The directory origin is read from env: `AGENT_NATIVE_ORG_DIRECTORY_URL`
- *     (dedicated) or `AGENT_NATIVE_IDENTITY_HUB_URL` (Dispatch is also the
- *     identity hub). When *neither* is set the feature is simply inactive —
- *     `fetchOrgApps()` returns `[]` and nothing changes anywhere (asserted by
- *     a test). This makes the whole feature opt-in and back-compat.
+ *   - A selected org's bound workspace URL wins for org-scoped requests; the
+ *     deployment's `AGENT_NATIVE_ORG_DIRECTORY_URL` or
+ *     `AGENT_NATIVE_IDENTITY_HUB_URL` is the fallback when no binding exists.
+ *     When neither is set the feature is inactive — `fetchOrgApps()` returns
+ *     `[]` and nothing changes anywhere (asserted by a test).
  *   - `fetchOrgAppsResult()` preserves directory availability for callers
  *     that cannot mistake a failed lookup for an empty directory.
  *     `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.
- *   - Credentialed requests require HTTPS and use manual redirects. A short
+ *   - Mounted `/dispatch` requests retry at the host root only after a 404.
+ *     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.
  *     Successful responses are cached for 60s; transient unavailable results
@@ -51,7 +52,7 @@ export interface OrgApp {
     whenToUse?: string[];
     aliases?: string[];
 }
-export type OrgDirectoryUnavailableReason = "not-configured" | "authentication" | "unauthorized" | "authorization" | "invalid-origin" | "missing-route" | "timeout" | "network" | "invalid-response" | "ssrf-blocked" | "server-error" | "http-error";
+export type OrgDirectoryUnavailableReason = "not-configured" | "authentication" | "unauthorized" | "authorization" | "invalid-origin" | "missing-route" | "timeout" | "network" | "invalid-response" | "ssrf-blocked" | "workspace-url-unavailable" | "server-error" | "http-error";
 export type OrgDirectoryFetchResult = {
     status: "available";
     apps: OrgApp[];

package/dist/mcp/org-directory.js

@@ -127,11 +127,92 @@ function serviceScopedCacheKey(origin, orgId, includeDirectoryApp = false, stric
     ].join("|");
 }
 async function fetchOrgAppsResultInternal(opts, strictValidation = true) {
+    const env = opts?.env ?? process.env;
+    const directoryBase = await resolveDirectoryBaseUrl(opts, env);
+    if (!directoryBase.ok)
+        return directoryBase.result;
+    const result = await fetchOrgAppsAtBaseUrl({ ...opts, directoryBaseUrl: directoryBase.url }, strictValidation);
+    if (result.status !== "unavailable" || result.reason !== "missing-route") {
+        return result;
+    }
+    const rootUrl = new URL(directoryBase.url).origin;
+    if (rootUrl === directoryBase.url.replace(/\/+$/, ""))
+        return result;
+    return fetchOrgAppsAtBaseUrl({ ...opts, directoryBaseUrl: rootUrl }, strictValidation);
+}
+async function resolveDirectoryBaseUrl(opts, env) {
+    if (opts?.directoryBaseUrl !== undefined) {
+        const url = normalizeDirectoryBaseUrl(opts.directoryBaseUrl);
+        return url
+            ? { ok: true, url }
+            : {
+                ok: false,
+                result: { status: "unavailable", reason: "invalid-origin" },
+            };
+    }
+    const serviceOrgId = opts?.serviceOrgId?.trim();
+    let orgId = serviceOrgId || undefined;
+    try {
+        if (!orgId) {
+            const { getRequestOrgId } = await import("../server/request-context.js");
+            orgId = getRequestOrgId();
+        }
+        if (orgId) {
+            const { getOrgWorkspaceUrl } = await import("../org/context.js");
+            const workspaceUrl = await getOrgWorkspaceUrl(orgId);
+            if (workspaceUrl) {
+                const url = normalizeOrgWorkspaceDirectoryBaseUrl(workspaceUrl);
+                return url
+                    ? { ok: true, url }
+                    : {
+                        ok: false,
+                        result: { status: "unavailable", reason: "invalid-origin" },
+                    };
+            }
+        }
+    }
+    catch {
+        return {
+            ok: false,
+            result: { status: "unavailable", reason: "workspace-url-unavailable" },
+        };
+    }
+    const configuredUrl = configuredOrgDirectoryUrl(env);
+    const url = resolveOrgDirectoryOrigin(env);
+    if (url)
+        return { ok: true, url };
+    return {
+        ok: false,
+        result: {
+            status: "unavailable",
+            reason: configuredUrl ? "invalid-origin" : "not-configured",
+        },
+    };
+}
+function normalizeOrgWorkspaceDirectoryBaseUrl(value) {
+    try {
+        const url = new URL(value);
+        if (url.protocol !== "https:" ||
+            url.username ||
+            url.password ||
+            url.search ||
+            url.hash ||
+            (url.pathname !== "/" && url.pathname !== "")) {
+            return null;
+        }
+        return `${url.origin}/dispatch`;
+    }
+    catch {
+        // coercion-ok: Invalid bindings become typed invalid-origin failures above.
+        return null;
+    }
+}
+async function fetchOrgAppsAtBaseUrl(opts, strictValidation) {
     const env = opts?.env ?? process.env;
     const hasExplicitBaseUrl = opts?.directoryBaseUrl !== undefined;
     const hasConfiguredEnvUrl = configuredOrgDirectoryUrl(env) !== null;
     const origin = hasExplicitBaseUrl
-        ? normalizeDirectoryBaseUrl(opts?.directoryBaseUrl ?? "")
+        ? normalizeDirectoryBaseUrl(opts.directoryBaseUrl ?? "")
         : resolveOrgDirectoryOrigin(env);
     if (!origin) {
         return {

package/dist/notifications/routes.d.ts

@@ -16,6 +16,6 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
 } | {
     count?: undefined;
     updated?: undefined;
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;

package/dist/observability/routes.d.ts

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

package/dist/progress/routes.d.ts

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

package/dist/resources/handlers.d.ts

@@ -42,8 +42,8 @@ export declare function handleDeleteResource(event: any): Promise<{
     error: string;
     ok?: undefined;
 } | {
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>;
 export declare function handleUploadResource(event: any): Promise<import("./store.js").Resource | {
     error: string;
@@ -63,10 +63,10 @@ export declare function handleUploadResource(event: any): Promise<import("./stor
     runId: string | null;
     expiresAt: number | null;
     metadata: string | null;
+    error?: undefined;
     url: string;
     provider: string;
     storageSetupRequired?: undefined;
-    error?: undefined;
 } | {
     error: string;
     storageSetupRequired: boolean;

package/dist/secrets/routes.d.ts

@@ -57,39 +57,39 @@ 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;
 } | {
+    error?: undefined;
     errorCode?: undefined;
     ok: boolean;
     status: string;
-    error?: undefined;
 } | {
+    ok?: undefined;
     error: string;
     removed?: undefined;
-    ok?: 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;
-    ok?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note?: undefined;
-    error?: undefined;
 } | {
+    error?: undefined;
     ok: boolean;
     note: string;
-    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -117,11 +117,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;
 }>>;