@agent-native/dispatch 0.27.2 → 0.27.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/dispatch",
-  "version": "0.27.2",
+  "version": "0.27.4",
   "description": "Dispatch — workspace control plane for agent-native apps. Vault, integrations, destinations, scheduled jobs, and cross-app delegation, shipped as a single drop-in package.",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -87,7 +87,7 @@
     "tailwind-merge": "^3.5.0",
     "vaul": "^1.1.2",
     "zod": "^4.3.6",
-    "@agent-native/toolkit": "0.16.2"
+    "@agent-native/toolkit": "0.16.3"
   },
   "devDependencies": {
     "@react-router/dev": "^8.1.0",
@@ -101,7 +101,7 @@
     "typescript-7": "npm:typescript@^7.0.2",
     "vite": "8.1.0",
     "vitest": "^4.1.5",
-    "@agent-native/core": "0.157.9"
+    "@agent-native/core": "0.157.15"
   },
   "peerDependencies": {
     "@agent-native/core": ">=0.8.0",

package/src/server/lib/app-creation-store.spec.ts

@@ -259,6 +259,63 @@ describe("listWorkspaceApps", () => {
     ]);
   });
 
+  it("falls back to the authenticated workspace action for hosted gateways", async () => {
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(new Response("not found", { status: 404 }))
+      .mockResolvedValueOnce(
+        new Response(
+          JSON.stringify([
+            {
+              id: "atlas",
+              name: "Atlas",
+              path: "/atlas",
+              url: "https://agent-workspace.builder.io/atlas",
+            },
+          ]),
+          { headers: { "content-type": "application/json" } },
+        ),
+      );
+    vi.stubGlobal("fetch", fetchMock);
+    vi.stubEnv("A2A_SECRET", "test-a2a-secret");
+    vi.stubEnv("WORKSPACE_GATEWAY_URL", "https://agent-workspace.builder.io");
+
+    const apps = await runWithRequestContext(
+      { userEmail: "dev@example.test" },
+      () => listWorkspaceApps({ includeAgentCards: false }),
+    );
+
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    expect(String(fetchMock.mock.calls[1]?.[0])).toBe(
+      "https://agent-workspace.builder.io/_agent-native/actions/list-workspace-apps?includeAgentCards=false&audience=all",
+    );
+    expect(fetchMock.mock.calls[1]?.[1]).toEqual(
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          accept: "application/json",
+          Authorization: expect.stringMatching(/^Bearer /),
+        }),
+      }),
+    );
+    expect(apps.map((app) => app.id)).toEqual(["atlas"]);
+    expect(apps[0]?.url).toBe("https://agent-workspace.builder.io/atlas");
+  });
+
+  it("falls back to local discovery when the gateway URL is malformed", async () => {
+    stubManifest();
+    vi.stubEnv("WORKSPACE_GATEWAY_URL", "not-a-url");
+    const fetchMock = vi.fn();
+    vi.stubGlobal("fetch", fetchMock);
+
+    const apps = await runWithRequestContext(
+      { userEmail: "dev@example.test" },
+      () => listWorkspaceApps({ includeAgentCards: false }),
+    );
+
+    expect(fetchMock).not.toHaveBeenCalled();
+    expect(apps.map((app) => app.id)).toEqual(["dispatch"]);
+  });
+
   it("filters workspace apps by audience", async () => {
     stubNoPendingContext();
     vi.stubEnv(

package/src/server/lib/app-creation-store.ts

@@ -3,7 +3,9 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { signA2AToken } from "@agent-native/core/a2a";
 import { getDbExec } from "@agent-native/core/db";
+import { getOrgA2ASecret, getOrgDomain } from "@agent-native/core/org";
 import {
   ensureBuilderProject,
   getBuilderBranchProjectId,
@@ -23,6 +25,7 @@ import {
   resolveLinkedOwner,
 } from "./dispatch-store.js";
 import { createRequest, listSecretOptions } from "./vault-store.js";
+import { WORKSPACE_APPS_ACTION_PATH } from "./workspace-app-action-auth.js";
 import {
   grantWorkspaceResourcesToApp,
   listWorkspaceResourceOptions,
@@ -42,7 +45,7 @@ const WORKSPACE_APP_METADATA_SETTINGS_KEY = "workspace-app-metadata";
 const WORKSPACE_APPS_ENV_KEY = "AGENT_NATIVE_WORKSPACE_APPS_JSON";
 const WORKSPACE_APPS_MANIFEST_FILE = "workspace-apps.json";
 const WORKSPACE_APPS_GATEWAY_PATH = "/_workspace/apps";
-const WORKSPACE_APPS_GATEWAY_TIMEOUT_MS = 1_000;
+const WORKSPACE_APPS_GATEWAY_TIMEOUT_MS = 2_500;
 const MAX_PENDING_APPS = 50;
 const PENDING_WORKSPACE_APP_TTL_MS = 7 * 24 * 60 * 60 * 1_000;
 const AGENT_CARD_PATH = "/.well-known/agent-card.json";
@@ -1075,22 +1078,102 @@ async function readWorkspaceAppsFromGateway(): Promise<
   const base = process.env.WORKSPACE_GATEWAY_URL;
   if (!base) return null;
 
+  let baseUrl: URL;
+  try {
+    baseUrl = new URL(base);
+  } catch {
+    // coercion-ok: malformed gateway configuration is an unavailable registry
+    // and falls back to local sources.
+    return null;
+  }
+  if (baseUrl.protocol !== "http:" && baseUrl.protocol !== "https:") {
+    return null;
+  }
+
   const controller = new AbortController();
   const timeout = setTimeout(
     () => controller.abort(),
     WORKSPACE_APPS_GATEWAY_TIMEOUT_MS,
   );
 
+  const requestContext = getRequestContext();
+  const authHeaders: Record<string, string> = {};
+  if (requestContext?.userEmail) {
+    const [orgDomain, orgSecret] = requestContext.orgId
+      ? await Promise.all([
+          // coercion-ok: an unavailable org row falls back to the deployment secret.
+          getOrgDomain(requestContext.orgId).catch(() => null),
+          // coercion-ok: an unavailable org row falls back to the deployment secret.
+          getOrgA2ASecret(requestContext.orgId).catch(() => null),
+        ])
+      : [null, null];
+    const usableOrgSecret =
+      typeof orgSecret === "string" && orgSecret.trim().length > 0;
+    const usableOrgDomain =
+      typeof orgDomain === "string" && orgDomain.trim().length > 0;
+    try {
+      const token = await signA2AToken(
+        requestContext.userEmail,
+        usableOrgDomain ? orgDomain.trim() : undefined,
+        usableOrgSecret ? orgSecret.trim() : undefined,
+        {
+          expiresIn: "1m",
+          // The workspace registry is an authenticated read. Prefer the
+          // shared deployment secret so a registry read does not depend on
+          // every app having the same org row.
+          preferGlobalSecret: true,
+        },
+      );
+      authHeaders.Authorization = `Bearer ${token}`;
+    } catch {
+      // coercion-ok: absent signing credentials keep local unauthenticated
+      // gateway discovery available and make hosted discovery fail closed.
+      // Keep the unauthenticated local-dev gateway path available. A hosted
+      // gateway will fail closed below when its action route needs identity.
+    }
+  }
+
+  const gatewayUrl = (pathname: string): URL => {
+    const url = new URL(baseUrl.toString());
+    const basePath = url.pathname.replace(/\/+$/, "");
+    url.pathname = `${basePath}${pathname}` || "/";
+    url.search = "";
+    url.hash = "";
+    return url;
+  };
+
+  const headers = {
+    accept: "application/json",
+    ...authHeaders,
+  };
+
   try {
-    const response = await fetch(
-      new URL(WORKSPACE_APPS_GATEWAY_PATH, `${base.replace(/\/$/, "")}/`),
-      {
-        headers: { accept: "application/json" },
-        signal: controller.signal,
-      },
+    const localResponse = await fetch(gatewayUrl(WORKSPACE_APPS_GATEWAY_PATH), {
+      headers,
+      signal: controller.signal,
+    });
+    if (localResponse.ok) {
+      return parseWorkspaceAppsManifest(
+        // coercion-ok: malformed gateway JSON is an unavailable registry and
+        // must fall through to the local manifest sources.
+        await localResponse.json().catch(() => null),
+      );
+    }
+
+    if (!authHeaders.Authorization) return null;
+    const actionUrl = gatewayUrl(WORKSPACE_APPS_ACTION_PATH);
+    actionUrl.searchParams.set("includeAgentCards", "false");
+    actionUrl.searchParams.set("audience", "all");
+    const actionResponse = await fetch(actionUrl, {
+      headers,
+      signal: controller.signal,
+    });
+    if (!actionResponse.ok) return null;
+    return parseWorkspaceAppsManifest(
+      // coercion-ok: malformed gateway JSON is an unavailable registry and
+      // must fall through to the local manifest sources.
+      await actionResponse.json().catch(() => null),
     );
-    if (!response.ok) return null;
-    return parseWorkspaceAppsManifest(await response.json().catch(() => null));
   } catch {
     return null;
   } finally {

package/src/server/lib/mcp-gateway.spec.ts

@@ -940,6 +940,55 @@ describe("createGrantedDispatchMcpEmbedSession", () => {
     expect(mocks.managerConstructor).toHaveBeenCalled();
   });
 
+  it("allows custom mounted workspace apps from the live workspace registry", async () => {
+    vi.stubEnv("WORKSPACE_GATEWAY_URL", "https://agent-workspace.builder.io");
+    mocks.discoverAgents.mockResolvedValue([]);
+    mocks.managerCallTool.mockResolvedValueOnce({
+      structuredContent: {
+        startUrl:
+          "https://agent-workspace.builder.io/atlas/_agent-native/embed/start?ticket=remote",
+      },
+    });
+    mocks.listWorkspaceApps.mockResolvedValue([
+      {
+        id: "atlas",
+        name: "Atlas",
+        description: "Workspace app",
+        path: "/atlas",
+        url: "https://agent-workspace.builder.io/atlas",
+        isDispatch: false,
+        audience: "internal",
+        publicPaths: [],
+        protectedPaths: [],
+      },
+    ]);
+
+    const result = await runWithRequestContext(
+      {
+        userEmail: "owner@example.test",
+        requestOrigin: "https://dispatch.agent-native.com",
+      },
+      () =>
+        createWorkspaceSsoEmbedSession({
+          app: "atlas",
+          path: "/",
+        }),
+    );
+
+    expect(result).toMatchObject({
+      app: "atlas",
+      startUrl:
+        "https://agent-workspace.builder.io/atlas/_agent-native/embed/start?ticket=remote",
+    });
+    expect(mocks.managerConstructor).toHaveBeenCalledWith({
+      servers: {
+        target: expect.objectContaining({
+          url: "https://agent-workspace.builder.io/atlas/mcp",
+        }),
+      },
+    });
+  });
+
   it("allows an exact custom registry entry and rejects an unregistered external app", async () => {
     vi.stubEnv(
       "IDENTITY_SSO_APP_REGISTRY_JSON",

package/src/server/lib/mcp-gateway.ts

@@ -621,6 +621,17 @@ function workspaceSsoOriginForApp(appId: string): string | null {
   return custom?.origin ?? null;
 }
 
+function workspaceSsoGatewayOrigin(): string | null {
+  const configured = process.env.WORKSPACE_GATEWAY_URL?.trim();
+  if (!configured) return null;
+  try {
+    return new URL(configured).origin;
+  } catch {
+    // coercion-ok: malformed deployment configuration is not a trusted origin.
+    return null;
+  }
+}
+
 function isWorkspaceSsoCanonicalApp(app: DispatchMcpAccessibleApp): boolean {
   const origin = safeAppOrigin(app);
   if (!origin) return false;
@@ -664,7 +675,8 @@ async function isEligibleWorkspaceSsoApp(
     color: DISPATCH_COLOR,
     granted: true,
   });
-  if (origin !== dispatchOrigin) return false;
+  const trustedMountedOrigin = workspaceSsoGatewayOrigin() ?? dispatchOrigin;
+  if (origin !== trustedMountedOrigin) return false;
   return mountedApps.some((mounted) => sameWorkspaceApp(candidate, mounted));
 }
 
@@ -673,15 +685,32 @@ async function listWorkspaceSsoApps(): Promise<DispatchMcpAccessibleApp[]> {
     discoverAgents("dispatch"),
     listWorkspaceApps({ includeAgentCards: false }),
   ]);
-  const candidates = agents
-    .filter((agent) => normalizeAppId(agent.id) !== DISPATCH_APP_ID)
-    .map((agent) => ({
+  const candidatesById = new Map<string, DispatchMcpAccessibleApp>();
+  for (const agent of agents) {
+    if (normalizeAppId(agent.id) === DISPATCH_APP_ID) continue;
+    candidatesById.set(agent.id, {
       ...toAccessibleApp(agent, {
         mode: "all-apps",
         selectedAppIds: [],
       }),
       granted: true,
-    }));
+    });
+  }
+  // The hosted Dispatch database is separate from the shared Workspace
+  // database. Overlay the live mounted registry so custom apps are eligible
+  // without copying a stale app list into Dispatch configuration.
+  for (const app of mountedApps) {
+    if (app.isDispatch || !app.url) continue;
+    candidatesById.set(app.id, {
+      id: app.id,
+      name: app.name,
+      description: app.description,
+      url: app.url,
+      color: DISPATCH_COLOR,
+      granted: true,
+    });
+  }
+  const candidates = [...candidatesById.values()];
   const eligible = [] as DispatchMcpAccessibleApp[];
   for (const candidate of candidates) {
     if (await isEligibleWorkspaceSsoApp(candidate, mountedApps)) {

package/src/server/lib/workspace-app-action-auth.spec.ts

@@ -0,0 +1,173 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  verifyA2AToken: vi.fn(),
+  isOrgMember: vi.fn(),
+  resolveOrgByDomain: vi.fn(),
+  resolveOrgIdForEmail: vi.fn(),
+}));
+
+vi.mock("@agent-native/core/a2a", () => ({
+  verifyA2AToken: mocks.verifyA2AToken,
+}));
+
+vi.mock("@agent-native/core/org", () => ({
+  isOrgMember: mocks.isOrgMember,
+  resolveOrgByDomain: mocks.resolveOrgByDomain,
+  resolveOrgIdForEmail: mocks.resolveOrgIdForEmail,
+}));
+
+import {
+  workspaceAppActionRouteAuth,
+  WORKSPACE_APPS_ACTION_PATH,
+} from "./workspace-app-action-auth.js";
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+function eventFor(path: string, authorization?: string) {
+  return {
+    path,
+    context: {},
+    node: {
+      req: {
+        headers: authorization ? { authorization } : {},
+      },
+    },
+  };
+}
+
+describe("workspace app action auth", () => {
+  it("only resolves the mounted workspace registry action", async () => {
+    await expect(
+      workspaceAppActionRouteAuth.resolveCaller?.(
+        eventFor(
+          "/_agent-native/actions/list-connected-agents",
+          "Bearer token",
+        ),
+      ),
+    ).resolves.toBeNull();
+    expect(mocks.verifyA2AToken).not.toHaveBeenCalled();
+  });
+
+  it("rejects an invalid registry bearer instead of falling through to cookies", async () => {
+    mocks.verifyA2AToken.mockResolvedValue({ email: null, orgDomain: null });
+
+    await expect(
+      workspaceAppActionRouteAuth.resolveCaller?.(
+        eventFor(WORKSPACE_APPS_ACTION_PATH, "Bearer invalid"),
+      ),
+    ).rejects.toThrow("Invalid workspace registry authorization");
+  });
+
+  it("returns the verified caller and local org scope", async () => {
+    mocks.verifyA2AToken.mockResolvedValue({
+      email: "steve@builder.io",
+      orgDomain: "builder.io",
+    });
+    mocks.resolveOrgByDomain.mockResolvedValue({
+      orgId: "org-builder",
+      orgName: "Builder.io",
+    });
+    mocks.isOrgMember.mockResolvedValue(true);
+
+    await expect(
+      workspaceAppActionRouteAuth.resolveCaller?.(
+        eventFor(WORKSPACE_APPS_ACTION_PATH, "Bearer verified"),
+      ),
+    ).resolves.toEqual({
+      owner: "steve@builder.io",
+      anonymous: false,
+      orgId: "org-builder",
+    });
+    expect(mocks.verifyA2AToken).toHaveBeenCalledWith(
+      "verified",
+      expect.anything(),
+    );
+    expect(mocks.resolveOrgByDomain).toHaveBeenCalledWith("builder.io");
+    expect(mocks.isOrgMember).toHaveBeenCalledWith(
+      "org-builder",
+      "steve@builder.io",
+    );
+    expect(mocks.resolveOrgIdForEmail).not.toHaveBeenCalled();
+  });
+
+  it("uses the original mounted pathname after the route prefix is stripped", async () => {
+    mocks.verifyA2AToken.mockResolvedValue({
+      email: "steve@builder.io",
+      orgDomain: "builder.io",
+    });
+    mocks.resolveOrgByDomain.mockResolvedValue({
+      orgId: "org-builder",
+      orgName: "Builder.io",
+    });
+    mocks.isOrgMember.mockResolvedValue(true);
+    const event = eventFor("/", "Bearer mounted");
+    event.context = {
+      _mountedPathname: WORKSPACE_APPS_ACTION_PATH,
+    };
+
+    await expect(
+      workspaceAppActionRouteAuth.resolveCaller?.(event),
+    ).resolves.toMatchObject({
+      owner: "steve@builder.io",
+      orgId: "org-builder",
+    });
+    expect(mocks.verifyA2AToken).toHaveBeenCalledWith(
+      "mounted",
+      expect.anything(),
+    );
+  });
+
+  it("keeps legacy email-derived scope when the token has no org domain", async () => {
+    mocks.verifyA2AToken.mockResolvedValue({
+      email: "steve@builder.io",
+      orgDomain: null,
+    });
+    mocks.resolveOrgIdForEmail.mockResolvedValue("org-by-email");
+
+    await expect(
+      workspaceAppActionRouteAuth.resolveCaller?.(
+        eventFor(WORKSPACE_APPS_ACTION_PATH, "Bearer legacy"),
+      ),
+    ).resolves.toMatchObject({ orgId: "org-by-email" });
+    expect(mocks.resolveOrgIdForEmail).toHaveBeenCalledWith("steve@builder.io");
+  });
+
+  it("rejects a verified domain that is not registered locally", async () => {
+    mocks.verifyA2AToken.mockResolvedValue({
+      email: "steve@builder.io",
+      orgDomain: "unknown.example",
+    });
+    mocks.resolveOrgByDomain.mockResolvedValue(null);
+
+    await expect(
+      workspaceAppActionRouteAuth.resolveCaller?.(
+        eventFor(WORKSPACE_APPS_ACTION_PATH, "Bearer unmapped"),
+      ),
+    ).rejects.toThrow("Invalid workspace registry authorization");
+  });
+
+  it("rejects a global-token caller who is not a member of the claimed org", async () => {
+    mocks.verifyA2AToken.mockResolvedValue({
+      email: "outsider@example.com",
+      orgDomain: "builder.io",
+    });
+    mocks.resolveOrgByDomain.mockResolvedValue({
+      orgId: "org-builder",
+      orgName: "Builder.io",
+    });
+    mocks.isOrgMember.mockResolvedValue(false);
+
+    await expect(
+      workspaceAppActionRouteAuth.resolveCaller?.(
+        eventFor(WORKSPACE_APPS_ACTION_PATH, "Bearer global-token"),
+      ),
+    ).rejects.toThrow("Invalid workspace registry authorization");
+    expect(mocks.isOrgMember).toHaveBeenCalledWith(
+      "org-builder",
+      "outsider@example.com",
+    );
+  });
+});

package/src/server/lib/workspace-app-action-auth.ts

@@ -0,0 +1,90 @@
+import { verifyA2AToken } from "@agent-native/core/a2a";
+import {
+  isOrgMember,
+  resolveOrgByDomain,
+  resolveOrgIdForEmail,
+} from "@agent-native/core/org";
+import type {
+  ActionRouteAuthAdapter,
+  ActionRouteResolvedCaller,
+} from "@agent-native/core/server";
+
+export const WORKSPACE_APPS_ACTION_PATH =
+  "/_agent-native/actions/list-workspace-apps";
+
+function isWorkspaceAppsActionPath(event: any): boolean {
+  const rawUrl =
+    (typeof event?.context?._mountedPathname === "string" &&
+      event.context._mountedPathname) ||
+    (typeof event?.path === "string" && event.path) ||
+    (typeof event?.url?.pathname === "string" && event.url.pathname) ||
+    (typeof event?.node?.req?.url === "string" && event.node.req.url) ||
+    (typeof event?.req?.url === "string" && event.req.url) ||
+    "/";
+  const requestPath =
+    String(rawUrl).split("?", 1)[0].replace(/\/+$/, "") || "/";
+  const appBasePath = process.env.APP_BASE_PATH?.trim().replace(/\/+$/, "");
+  return (
+    requestPath === WORKSPACE_APPS_ACTION_PATH ||
+    Boolean(
+      appBasePath &&
+      `${appBasePath}${WORKSPACE_APPS_ACTION_PATH}` === requestPath,
+    )
+  );
+}
+
+function readAuthorizationHeader(event: any): string | undefined {
+  const headers = event?.node?.req?.headers ?? event?.req?.headers;
+  if (typeof headers?.get === "function") {
+    return headers.get("authorization") ?? undefined;
+  }
+  const value = headers?.authorization ?? headers?.Authorization;
+  return Array.isArray(value) ? value[0] : value;
+}
+
+/**
+ * The hosted workspace registry is a read-only action that accepts a caller
+ * JWT from Dispatch. Keep this resolver path-scoped so the shared secret never
+ * becomes a bearer credential for unrelated Dispatch actions.
+ */
+export const workspaceAppActionRouteAuth: ActionRouteAuthAdapter = {
+  resolveCaller: async (event): Promise<ActionRouteResolvedCaller | null> => {
+    if (!isWorkspaceAppsActionPath(event)) return null;
+
+    const authorization = readAuthorizationHeader(event);
+    if (!authorization) return null;
+    if (!authorization.startsWith("Bearer ")) {
+      throw new Error("Invalid workspace registry authorization");
+    }
+
+    const token = authorization.slice("Bearer ".length).trim();
+    if (!token) throw new Error("Invalid workspace registry authorization");
+
+    const identity = await verifyA2AToken(token, event);
+    if (!identity.email) {
+      throw new Error("Invalid workspace registry authorization");
+    }
+
+    const orgDomain = identity.orgDomain?.trim().toLowerCase();
+    let orgId: string | null;
+    if (orgDomain) {
+      // A verified domain claim identifies the caller's intended org. Resolve
+      // it locally instead of falling back to the receiver's active-org or
+      // first-membership selection, which can be wrong for multi-org users.
+      const org = await resolveOrgByDomain(orgDomain);
+      if (!org || !(await isOrgMember(org.orgId, identity.email))) {
+        throw new Error("Invalid workspace registry authorization");
+      }
+      orgId = org.orgId;
+    } else {
+      // Preserve compatibility with legacy tokens that predate org_domain.
+      orgId = await resolveOrgIdForEmail(identity.email);
+    }
+
+    return {
+      owner: identity.email,
+      anonymous: false,
+      orgId,
+    };
+  },
+};

package/src/server/plugins/agent-chat.spec.ts

@@ -33,6 +33,10 @@ describe("Dispatch agent chat plugin", () => {
             "start-workspace-app-creation",
           ]),
         },
+        actionRoutePublicPaths: ["/_agent-native/actions/list-workspace-apps"],
+        actionRouteAuth: expect.objectContaining({
+          resolveCaller: expect.any(Function),
+        }),
       }),
     );
   });

package/src/server/plugins/agent-chat.ts

@@ -2,6 +2,10 @@ import { getOrgContext } from "@agent-native/core/org";
 import { createAgentChatPlugin } from "@agent-native/core/server";
 
 import { dispatchActions } from "../../actions/index.js";
+import {
+  workspaceAppActionRouteAuth,
+  WORKSPACE_APPS_ACTION_PATH,
+} from "../lib/workspace-app-action-auth.js";
 
 const INITIAL_TOOL_NAMES = [
   "view-screen",
@@ -53,6 +57,8 @@ export default createAgentChatPlugin({
   // a build-time-generated `.generated/actions-registry.ts` (the latter is a
   // template-only construct that the Vite plugin emits next to actions/).
   actions: dispatchActions,
+  actionRouteAuth: workspaceAppActionRouteAuth,
+  actionRoutePublicPaths: [WORKSPACE_APPS_ACTION_PATH],
   codeExecution: { production: "sandboxed" },
   systemPrompt: `You are the central dispatch for this workspace.