@agent-native/dispatch 0.13.8 → 0.13.10

package/src/routes/pages/$appId.tsx

@@ -14,15 +14,15 @@ import {
   type LoaderFunctionArgs,
 } from "react-router";
 
-import { DispatchShell } from "@/components/dispatch-shell";
-import { Badge } from "@/components/ui/badge";
-import { Button } from "@/components/ui/button";
-import { Spinner } from "@/components/ui/spinner";
-import { resolveServerCatchAllTarget } from "@/lib/catch-all-target";
+import { DispatchShell } from "../../components/dispatch-shell";
+import { Badge } from "../../components/ui/badge";
+import { Button } from "../../components/ui/button";
+import { Spinner } from "../../components/ui/spinner";
+import { resolveServerCatchAllTarget } from "../../lib/catch-all-target";
 import {
   workspaceAppHref,
   type WorkspaceAppSummary,
-} from "@/lib/workspace-apps";
+} from "../../lib/workspace-apps";
 
 export function meta() {
   return [{ title: "Workspace app - Dispatch" }];

package/src/server/lib/dispatch-integrations.spec.ts

@@ -15,9 +15,13 @@ vi.mock("@agent-native/core/org", () => ({
   resolveOrgIdForEmail: mocks.resolveOrgIdForEmail,
 }));
 
-import type { IncomingMessage } from "@agent-native/core/server";
+import type {
+  IncomingMessage,
+  PlatformAdapter,
+} from "@agent-native/core/server";
 
 import {
+  beforeDispatchProcess,
   identityKeyForIncoming,
   resolveDispatchOwner,
 } from "./dispatch-integrations.js";
@@ -54,6 +58,38 @@ function emailIncoming(
   };
 }
 
+function telegramIncoming(
+  overrides: Partial<IncomingMessage> = {},
+): IncomingMessage {
+  return {
+    platform: "telegram",
+    externalThreadId: "12345",
+    text: "ask analytics about traffic",
+    senderId: "777",
+    senderName: "Steve",
+    platformContext: { chatId: 12345, fromId: 777, rawText: "hello" },
+    timestamp: 1,
+    ...overrides,
+  };
+}
+
+const noopAdapter: PlatformAdapter = {
+  platform: "telegram",
+  label: "Telegram",
+  getRequiredEnvKeys: () => [],
+  handleVerification: async () => ({ handled: false }),
+  verifyWebhook: async () => true,
+  parseIncomingMessage: async () => null,
+  sendResponse: async () => {},
+  formatAgentResponse: (text: string) => ({ text, platformContext: {} }),
+  getStatus: async () => ({
+    platform: "telegram",
+    label: "Telegram",
+    enabled: true,
+    configured: true,
+  }),
+};
+
 beforeEach(() => {
   mocks.resolveLinkedOwner.mockResolvedValue(null);
   mocks.consumeLinkToken.mockResolvedValue("owner@example.test");
@@ -75,6 +111,10 @@ describe("identityKeyForIncoming", () => {
   it("scopes Slack identities by team", () => {
     expect(identityKeyForIncoming(slackIncoming())).toBe("T123:U123");
   });
+
+  it("uses Telegram sender ids as link identities", () => {
+    expect(identityKeyForIncoming(telegramIncoming())).toBe("777");
+  });
 });
 
 describe("resolveDispatchOwner", () => {
@@ -184,3 +224,54 @@ describe("resolveDispatchOwner", () => {
     ).resolves.toBe("victim@member.test");
   });
 });
+
+describe("beforeDispatchProcess", () => {
+  it("asks unlinked Telegram users to link before using org context", async () => {
+    vi.stubEnv("APP_URL", "https://dispatch.agent-native.test");
+
+    const result = await beforeDispatchProcess(telegramIncoming(), noopAdapter);
+
+    expect(result).toEqual({
+      handled: true,
+      responseText:
+        "Telegram is connected, but this Telegram account is not linked to an Agent-Native user yet. Tap https://dispatch.agent-native.test/identities, create a Telegram link token, then send `/link <token>` here. After that I can use your Builder.io org and connected apps.",
+    });
+    expect(mocks.resolveLinkedOwner).toHaveBeenCalledWith("telegram", "777", {
+      allowAnyOrgFallback: true,
+    });
+  });
+
+  it("lets linked Telegram users proceed to normal agent processing", async () => {
+    mocks.resolveLinkedOwner.mockResolvedValueOnce("steve@builder.io");
+
+    await expect(
+      beforeDispatchProcess(telegramIncoming(), noopAdapter),
+    ).resolves.toEqual({ handled: false });
+  });
+
+  it("still consumes Telegram link commands before enforcing the link gate", async () => {
+    const result = await beforeDispatchProcess(
+      telegramIncoming({
+        text: "token-123",
+        platformContext: {
+          chatId: 12345,
+          fromId: 777,
+          rawText: "/link token-123",
+        },
+      }),
+      noopAdapter,
+    );
+
+    expect(result).toEqual({
+      handled: true,
+      responseText:
+        "Linked successfully. Future telegram messages will use owner@example.test's personal dispatch context.",
+    });
+    expect(mocks.consumeLinkToken).toHaveBeenCalledWith({
+      platform: "telegram",
+      token: "token-123",
+      externalUserId: "777",
+      externalUserName: "Steve",
+    });
+  });
+});

package/src/server/lib/dispatch-integrations.ts

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
 
 import { resolveOrgIdForEmail } from "@agent-native/core/org";
+import { withConfiguredAppBasePath } from "@agent-native/core/server";
 import type {
   IncomingMessage,
   PlatformAdapter,
@@ -77,6 +78,40 @@ function configuredDefaultOwnerForIncoming(
   return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email) ? email : null;
 }
 
+function platformRequiresExplicitLink(incoming: IncomingMessage): boolean {
+  // Telegram does not provide a verified email address. Require an explicit
+  // identity link before it can act as a Builder/Agent-Native user.
+  return incoming.platform === "telegram";
+}
+
+function configuredDispatchIdentitiesUrl(): string | null {
+  const raw =
+    process.env.WORKSPACE_GATEWAY_URL ||
+    process.env.APP_URL ||
+    process.env.URL ||
+    process.env.DEPLOY_URL ||
+    process.env.BETTER_AUTH_URL ||
+    "";
+  if (!raw.trim()) return null;
+  const base = /^https?:\/\//i.test(raw) ? raw : `https://${raw}`;
+  try {
+    return new URL(
+      "identities",
+      `${withConfiguredAppBasePath(base).replace(/\/+$/, "")}/`,
+    ).toString();
+  } catch {
+    return null;
+  }
+}
+
+function formatTelegramLinkRequiredMessage(): string {
+  const identitiesUrl = configuredDispatchIdentitiesUrl();
+  const linkStep = identitiesUrl
+    ? `Tap ${identitiesUrl}, create a Telegram link token, then send \`/link <token>\` here.`
+    : "Open Dispatch while signed in, create a Telegram link token, then send `/link <token>` here.";
+  return `Telegram is connected, but this Telegram account is not linked to an Agent-Native user yet. ${linkStep} After that I can use your Builder.io org and connected apps.`;
+}
+
 async function resolveSlackSenderProfile(
   incoming: IncomingMessage,
 ): Promise<SlackSenderProfile> {
@@ -228,6 +263,19 @@ export async function beforeDispatchProcess(
     contextString(incoming.platformContext.rawText) || trimmed;
   const match = commandText.match(/^\/link(?:@\w+)?\s+([a-zA-Z0-9_-]+)$/);
   if (!match) {
+    if (platformRequiresExplicitLink(incoming)) {
+      const owner = await resolveLinkedOwner(
+        incoming.platform,
+        identityKeyForIncoming(incoming),
+        { allowAnyOrgFallback: true },
+      );
+      if (!owner) {
+        return {
+          handled: true,
+          responseText: formatTelegramLinkRequiredMessage(),
+        };
+      }
+    }
     return handleRemoteCodeCommand(incoming, adapter, {
       resolveOwner: () => resolveDispatchOwner(incoming),
     });

package/src/server/plugins/integrations.ts

@@ -7,6 +7,17 @@ import {
   resolveDispatchOwner,
 } from "../lib/dispatch-integrations.js";
 
+const dispatchIntegrationActions = {
+  ...dispatchActions,
+  // Messaging integrations should use the core call-agent tool for cross-app
+  // delegation because it queues A2A continuations when serverless budgets are
+  // tight. The MCP-facing ask_app action is still available outside this path.
+  ask_app: {
+    ...dispatchActions.ask_app,
+    agentTool: false,
+  },
+};
+
 const DISPATCH_INTEGRATION_SYSTEM_PROMPT = `You are the central dispatch for this workspace, responding via a messaging platform integration (Slack, Telegram, email, etc.).
 
 Default posture:
@@ -21,6 +32,7 @@ Default posture:
 
 When a user asks for something:
 - If it belongs to analytics, content, slides, clips, assets, etc., delegate via call-agent — do not re-implement the domain logic in dispatch.
+- In messaging integrations, use call-agent for cross-app delegation; do not use ask_app.
 - After call-agent returns an answer, RELAY IT DIRECTLY to the user with at most a one-line preface — do not rephrase, summarize, or add commentary. The downstream agent already crafted the answer; your job is delivery, not editing. This minimizes round-trips and keeps the user-visible reply fast.
 - Exception: if the downstream agent reports a missing model/provider credential, do not name exact env vars, Vault keys, tokens, or secrets. Say the target app needs an LLM connection and recommend connecting Builder/managed LLM for that app; keep bring-your-own provider keys as a secondary option only if the user asks.
 - If the user asks to create, build, make, scaffold, or generate an "agent" from Dispatch chat or by tagging @agent-native in Slack, email, or Telegram, first classify the ask. If it is a simple Dispatch-native behavior like a reminder, digest, monitor, routing rule, saved instruction, or recurring workflow, create or update the recurring job/resource/destination in Dispatch. If it is a robust unique product or teammate that needs its own UI, data model, actions, integrations, or domain workflow, treat it as a new workspace app and call start-workspace-app-creation.
@@ -49,7 +61,7 @@ const dispatchIntegrationsPlugin = async (nitroApp: any) => {
 
   const plugin = createIntegrationsPlugin({
     appId: "dispatch",
-    actions: dispatchActions,
+    actions: dispatchIntegrationActions,
     resolveOwner: resolveDispatchOwner,
     beforeProcess: beforeDispatchProcess,
     systemPrompt,