@agent-native/dispatch 0.14.7 → 0.14.9

package/src/components/workspace-app-card.spec.tsx

@@ -51,9 +51,13 @@ describe("WorkspaceAppCard", () => {
       );
     });
 
-    expect(
-      container.querySelector('a[aria-label="Open Analytics"]')?.className,
-    ).toContain("focus-visible:ring-2");
+    const appLink = container.querySelector<HTMLAnchorElement>(
+      'a[aria-label="Open Analytics"]',
+    );
+    expect(appLink?.getAttribute("href")).toBe("/analytics");
+    expect(appLink?.getAttribute("target")).toBeNull();
+    expect(appLink?.getAttribute("rel")).toBeNull();
+    expect(appLink?.className).toContain("focus-visible:ring-2");
 
     const actions = [
       container.querySelector<HTMLButtonElement>(
@@ -77,4 +81,31 @@ describe("WorkspaceAppCard", () => {
       expect(action?.className).not.toContain("opacity-0");
     }
   });
+
+  it("opens pending Builder apps in a new tab", async () => {
+    await act(async () => {
+      root.render(
+        <TooltipProvider>
+          <WorkspaceAppCard
+            app={{
+              id: "new-app",
+              name: "New app",
+              path: "/new-app",
+              builderUrl: "https://builder.example.com/projects/new-app",
+              status: "pending",
+            }}
+          />
+        </TooltipProvider>,
+      );
+    });
+
+    const appLink = container.querySelector<HTMLAnchorElement>(
+      'a[aria-label="Open New app"]',
+    );
+    expect(appLink?.getAttribute("href")).toBe(
+      "https://builder.example.com/projects/new-app",
+    );
+    expect(appLink?.getAttribute("target")).toBe("_blank");
+    expect(appLink?.getAttribute("rel")).toBe("noreferrer");
+  });
 });

package/src/routes/pages/agents.tsx

@@ -1,5 +1,4 @@
 import {
-  agentNativePath,
   useActionMutation,
   useActionQuery,
   useT,
@@ -39,7 +38,7 @@ interface McpAccessState {
 }
 
 function dispatchMcpUrl(): string {
-  const path = agentNativePath("/_agent-native/mcp");
+  const path = "/mcp";
   if (typeof window === "undefined") return path;
   return new URL(path, window.location.origin).href;
 }

package/src/server/lib/mcp-access-store.spec.ts

@@ -33,10 +33,10 @@ beforeEach(() => {
 });
 
 describe("normalizeMcpAppAccessSettings", () => {
-  it("defaults to Dispatch only", () => {
+  it("defaults to all apps when no access setting exists", () => {
     expect(normalizeMcpAppAccessSettings(null)).toEqual({
-      mode: "selected-apps",
-      selectedAppIds: ["dispatch"],
+      mode: "all-apps",
+      selectedAppIds: [],
       updatedAt: undefined,
       updatedBy: undefined,
     });

package/src/server/lib/mcp-access-store.ts

@@ -56,11 +56,10 @@ export function normalizeMcpAppAccessSettings(
     raw && typeof raw === "object" && !Array.isArray(raw)
       ? (raw as Record<string, unknown>)
       : {};
-  const mode = record.mode === "all-apps" ? "all-apps" : "selected-apps";
+  const mode = record.mode === "selected-apps" ? "selected-apps" : "all-apps";
   return {
     mode,
-    selectedAppIds:
-      raw == null ? ["dispatch"] : uniqueAppIds(record.selectedAppIds),
+    selectedAppIds: uniqueAppIds(record.selectedAppIds),
     updatedAt:
       typeof record.updatedAt === "string" ? record.updatedAt : undefined,
     updatedBy:

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

@@ -12,7 +12,9 @@ const mocks = vi.hoisted(() => ({
   managerStop: vi.fn(),
   managerCallTool: vi.fn(),
   managerConstructor: vi.fn(),
-  callAgent: vi.fn(),
+  a2aConstructor: vi.fn(),
+  a2aSend: vi.fn(),
+  a2aGetTask: vi.fn(),
   signA2AToken: vi.fn(),
   getOrgA2ASecret: vi.fn(),
   getOrgDomain: vi.fn(),
@@ -40,7 +42,19 @@ vi.mock("@agent-native/core/server", async (importOriginal) => {
 });
 
 vi.mock("@agent-native/core/a2a", () => ({
-  callAgent: mocks.callAgent,
+  A2AClient: class MockA2AClient {
+    constructor(...args: unknown[]) {
+      mocks.a2aConstructor(...args);
+    }
+
+    send(...args: unknown[]) {
+      return mocks.a2aSend(...args);
+    }
+
+    getTask(...args: unknown[]) {
+      return mocks.a2aGetTask(...args);
+    }
+  },
   signA2AToken: mocks.signA2AToken,
 }));
 
@@ -76,6 +90,7 @@ import { runWithRequestContext } from "@agent-native/core/server";
 import {
   createGrantedDispatchMcpEmbedSession,
   askGrantedDispatchMcpApp,
+  getGrantedDispatchMcpAppTask,
   listGrantedDispatchMcpApps,
   listGrantedDispatchMcpAppOrigins,
   openGrantedDispatchMcpApp,
@@ -91,6 +106,10 @@ const analyticsAgent = {
 };
 
 beforeEach(() => {
+  mocks.a2aConstructor.mockReset();
+  mocks.a2aSend.mockReset();
+  mocks.a2aGetTask.mockReset();
+  mocks.signA2AToken.mockReset();
   mocks.discoverAgents.mockResolvedValue([analyticsAgent]);
   mocks.getUserSetting.mockResolvedValue({ mode: "all-apps" });
   mocks.getOrgSetting.mockResolvedValue({ mode: "all-apps" });
@@ -106,19 +125,29 @@ beforeEach(() => {
       startUrl: "http://localhost:8086/_agent-native/embed/start?ticket=remote",
     },
   });
-  mocks.callAgent.mockResolvedValue("Created the requested dashboard.");
+  mocks.a2aSend.mockResolvedValue({
+    id: "task-1",
+    status: {
+      state: "completed",
+      message: {
+        role: "agent",
+        parts: [{ type: "text", text: "Created the requested dashboard." }],
+      },
+    },
+  });
   mocks.signA2AToken.mockResolvedValue("signed-token");
   mocks.getOrgA2ASecret.mockResolvedValue(null);
   mocks.getOrgDomain.mockResolvedValue(null);
 });
 
 afterEach(() => {
+  vi.useRealTimers();
   vi.unstubAllEnvs();
   vi.clearAllMocks();
 });
 
 describe("Dispatch MCP gateway app discovery", () => {
-  it("defaults to exposing Dispatch only until an owner or admin grants more apps", async () => {
+  it("defaults to exposing every discovered app", async () => {
     mocks.getUserSetting.mockResolvedValue(null);
     const apps = await runWithRequestContext(
       {
@@ -128,7 +157,7 @@ describe("Dispatch MCP gateway app discovery", () => {
       () => listGrantedDispatchMcpApps(),
     );
 
-    expect(apps.map((app) => app.id)).toEqual(["dispatch"]);
+    expect(apps.map((app) => app.id)).toEqual(["dispatch", "analytics"]);
   });
 
   it("includes Dispatch itself so agents can target extension routes", async () => {
@@ -275,20 +304,258 @@ describe("askGrantedDispatchMcpApp", () => {
         ),
     );
 
-    expect(mocks.callAgent).toHaveBeenCalledWith(
+    expect(mocks.a2aConstructor).toHaveBeenCalledWith(
       "http://localhost:8086",
-      "Build a weekly active users dashboard.",
+      "signed-token",
+      { requestTimeoutMs: 10_000 },
+    );
+    expect(mocks.a2aSend).toHaveBeenCalledWith(
+      {
+        role: "user",
+        parts: [
+          { type: "text", text: "Build a weekly active users dashboard." },
+        ],
+      },
+      {
+        async: true,
+        metadata: {
+          userEmail: "owner@example.test",
+          orgDomain: "builder.io",
+          requestOrigin: "http://localhost:8092",
+        },
+      },
+    );
+    expect(result).toMatchObject({
+      app: "analytics",
+      routedVia: "a2a",
+      response: "Created the requested dashboard.",
+      taskId: "task-1",
+      status: "completed",
+    });
+  });
+
+  it("returns a durable polling handle when the downstream task is still working", async () => {
+    mocks.a2aSend.mockResolvedValueOnce({
+      id: "task-working",
+      status: { state: "working" },
+    });
+
+    const result = await runWithRequestContext(
       {
         userEmail: "owner@example.test",
-        orgDomain: "builder.io",
-        orgSecret: "org-specific-secret",
-        timeoutMs: 5 * 60_000,
+        requestOrigin: "http://localhost:8092",
       },
+      () =>
+        askGrantedDispatchMcpApp("analytics", "Build the report.", {
+          async: true,
+        }),
     );
+
     expect(result).toEqual({
       app: "analytics",
       routedVia: "a2a",
-      response: "Created the requested dashboard.",
+      taskId: "task-working",
+      status: "working",
+      pollAfterMs: 1_500,
+      poll: {
+        tool: "ask_app_status",
+        arguments: { app: "analytics", taskId: "task-working" },
+      },
+      message:
+        'ask_app is still working. Call ask_app_status with taskId "task-working" to retrieve the final response.',
+    });
+  });
+
+  it("counts submission and every poll against one inline deadline", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    mocks.a2aSend.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          setTimeout(
+            () =>
+              resolve({
+                id: "task-deadline",
+                status: { state: "working" },
+              }),
+            3_000,
+          );
+        }),
+    );
+    mocks.a2aGetTask.mockImplementationOnce(() => new Promise(() => undefined));
+
+    const resultPromise = runWithRequestContext(
+      {
+        userEmail: "owner@example.test",
+        requestOrigin: "http://localhost:8092",
+      },
+      () =>
+        askGrantedDispatchMcpApp("analytics", "Build the report.", {
+          maxWaitMs: 5_000,
+        }),
+    );
+
+    await vi.advanceTimersByTimeAsync(5_000);
+
+    await expect(resultPromise).resolves.toMatchObject({
+      taskId: "task-deadline",
+      status: "working",
+      pollAfterMs: 1_500,
+    });
+    expect(Date.now()).toBe(5_000);
+    expect(mocks.a2aConstructor).toHaveBeenCalledWith(
+      "http://localhost:8086",
+      undefined,
+      { requestTimeoutMs: 5_000 },
+    );
+    expect(mocks.a2aGetTask).toHaveBeenCalledTimes(1);
+  });
+
+  it.each([401, 403, 404])(
+    "surfaces permanent %s status errors without waiting until the deadline",
+    async (statusCode) => {
+      vi.useFakeTimers();
+      vi.setSystemTime(0);
+      mocks.a2aSend.mockResolvedValueOnce({
+        id: "task-missing",
+        status: { state: "working" },
+      });
+      mocks.a2aGetTask.mockRejectedValueOnce(
+        new Error(`A2A request failed (${statusCode}): Task not found`),
+      );
+
+      const resultPromise = runWithRequestContext(
+        {
+          userEmail: "owner@example.test",
+          requestOrigin: "http://localhost:8092",
+        },
+        () =>
+          askGrantedDispatchMcpApp("analytics", "Build the report.", {
+            maxWaitMs: 20_000,
+          }),
+      );
+      const rejection = resultPromise.catch((err) => err);
+
+      await vi.advanceTimersByTimeAsync(0);
+      await vi.advanceTimersByTimeAsync(1_500);
+
+      await expect(rejection).resolves.toEqual(
+        expect.objectContaining({
+          message: expect.stringMatching(
+            new RegExp(`${statusCode}.*not found`, "i"),
+          ),
+        }),
+      );
+      expect(Date.now()).toBe(1_500);
+      expect(mocks.a2aGetTask).toHaveBeenCalledTimes(1);
+    },
+  );
+
+  it("retries transient status failures within the same deadline", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+    mocks.a2aSend.mockResolvedValueOnce({
+      id: "task-transient",
+      status: { state: "working" },
+    });
+    mocks.a2aGetTask
+      .mockRejectedValueOnce(new Error("A2A request failed (503): retry"))
+      .mockResolvedValueOnce({
+        id: "task-transient",
+        status: {
+          state: "completed",
+          message: {
+            role: "agent",
+            parts: [{ type: "text", text: "The report is ready." }],
+          },
+        },
+      });
+
+    const resultPromise = runWithRequestContext(
+      {
+        userEmail: "owner@example.test",
+        requestOrigin: "http://localhost:8092",
+      },
+      () =>
+        askGrantedDispatchMcpApp("analytics", "Build the report.", {
+          maxWaitMs: 20_000,
+        }),
+    );
+
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(3_000);
+
+    await expect(resultPromise).resolves.toMatchObject({
+      taskId: "task-transient",
+      status: "completed",
+      response: "The report is ready.",
+    });
+    expect(mocks.a2aGetTask).toHaveBeenCalledTimes(2);
+  });
+
+  it("returns input-required as a terminal handoff instead of a poll loop", async () => {
+    mocks.a2aSend.mockResolvedValueOnce({
+      id: "task-input",
+      status: {
+        state: "input-required",
+        message: {
+          role: "agent",
+          parts: [{ type: "text", text: "Which date range should I use?" }],
+        },
+      },
+    });
+
+    const result = await runWithRequestContext(
+      {
+        userEmail: "owner@example.test",
+        requestOrigin: "http://localhost:8092",
+      },
+      () => askGrantedDispatchMcpApp("analytics", "Build the report."),
+    );
+
+    expect(result).toEqual({
+      app: "analytics",
+      routedVia: "a2a",
+      taskId: "task-input",
+      status: "input-required",
+      response: "Which date range should I use?",
+      inputRequired: "Which date range should I use?",
+      message: "Which date range should I use?",
+    });
+    expect(mocks.a2aGetTask).not.toHaveBeenCalled();
+  });
+
+  it("polls a granted app task through the same authenticated A2A route", async () => {
+    mocks.a2aGetTask.mockResolvedValueOnce({
+      id: "task-working",
+      status: {
+        state: "completed",
+        message: {
+          role: "agent",
+          parts: [{ type: "text", text: "The report is ready." }],
+        },
+      },
+    });
+    mocks.getUserSetting.mockResolvedValue({
+      mode: "selected-apps",
+      selectedAppIds: ["analytics"],
+    });
+
+    const result = await runWithRequestContext(
+      {
+        userEmail: "owner@example.test",
+        requestOrigin: "http://localhost:8092",
+      },
+      () => getGrantedDispatchMcpAppTask("analytics", "task-working"),
+    );
+
+    expect(mocks.a2aGetTask).toHaveBeenCalledWith("task-working");
+    expect(result).toEqual({
+      app: "analytics",
+      routedVia: "a2a",
+      taskId: "task-working",
+      status: "completed",
+      response: "The report is ready.",
     });
   });
 
@@ -307,7 +574,25 @@ describe("askGrantedDispatchMcpApp", () => {
         () => askGrantedDispatchMcpApp("analytics", "Show signups."),
       ),
     ).rejects.toThrow(/not granted/);
-    expect(mocks.callAgent).not.toHaveBeenCalled();
+    expect(mocks.a2aSend).not.toHaveBeenCalled();
+  });
+
+  it("rejects polling a task for an app outside the grant", async () => {
+    mocks.getUserSetting.mockResolvedValue({
+      mode: "selected-apps",
+      selectedAppIds: ["dispatch"],
+    });
+
+    await expect(
+      runWithRequestContext(
+        {
+          userEmail: "owner@example.test",
+          requestOrigin: "http://localhost:8092",
+        },
+        () => getGrantedDispatchMcpAppTask("analytics", "task-working"),
+      ),
+    ).rejects.toThrow(/not granted/);
+    expect(mocks.a2aGetTask).not.toHaveBeenCalled();
   });
 });
 
@@ -547,7 +832,7 @@ describe("createGrantedDispatchMcpEmbedSession", () => {
     expect(mocks.managerConstructor).toHaveBeenCalledWith({
       servers: {
         target: expect.objectContaining({
-          url: "http://localhost:8092/analytics/_agent-native/mcp",
+          url: "http://localhost:8092/analytics/mcp",
         }),
       },
     });
@@ -596,7 +881,7 @@ describe("createGrantedDispatchMcpEmbedSession", () => {
     expect(mocks.managerConstructor).toHaveBeenCalledWith({
       servers: {
         target: expect.objectContaining({
-          url: "https://mail.agent-native.com/_agent-native/mcp",
+          url: "https://mail.agent-native.com/mcp",
         }),
       },
     });