@agent-native/core 0.92.12 → 0.93.0

package/corpus/core/src/deploy/workspace-deploy.ts

@@ -18,7 +18,13 @@ import { execFileSync } from "child_process";
 import fs from "fs";
 import path from "path";
 
-import { AGENT_CHAT_PROCESS_RUN_PATH } from "../agent/durable-background.js";
+import {
+  AGENT_BACKGROUND_PROCESSOR_A2A,
+  AGENT_BACKGROUND_PROCESSOR_FIELD,
+  AGENT_BACKGROUND_PROCESSOR_ROUTE,
+  AGENT_BACKGROUND_PROCESSOR_ROUTE_FIELD,
+  AGENT_CHAT_PROCESS_RUN_PATH,
+} from "../agent/durable-background.js";
 import { findWorkspaceRoot } from "../scripts/utils.js";
 import {
   DEFAULT_WORKSPACE_APP_AUDIENCE,
@@ -746,6 +752,7 @@ function emitNetlifyBackgroundFunction(
   // The function is reached at its default url, so the entry rewrites the
   // incoming pathname to `/<app>/_agent-native/agent-chat/_process-run`.
   const processRunPath = `${basePath}${AGENT_CHAT_PROCESS_RUN_PATH}`;
+  const a2aProcessTaskPath = `${basePath}/_agent-native/a2a/_process-task`;
   const server = `// Mark this isolate as the durable background runtime BEFORE the handler bundle
 // is imported, so isInBackgroundFunctionRuntime() reliably returns true in this
 // function (the deployed Lambda name is not guaranteed to end in -background). A
@@ -756,6 +763,34 @@ globalThis.__AGENT_NATIVE_BACKGROUND_RUNTIME__ = true;
 const basePath = ${JSON.stringify(basePath)};
 // The base-path-prefixed framework route the Nitro router dispatches to.
 const PROCESS_RUN_PATH = ${JSON.stringify(processRunPath)};
+const A2A_PROCESS_TASK_PATH = ${JSON.stringify(a2aProcessTaskPath)};
+const BACKGROUND_PROCESSOR_FIELD = ${JSON.stringify(AGENT_BACKGROUND_PROCESSOR_FIELD)};
+const BACKGROUND_PROCESSOR_A2A = ${JSON.stringify(AGENT_BACKGROUND_PROCESSOR_A2A)};
+const BACKGROUND_PROCESSOR_ROUTE = ${JSON.stringify(AGENT_BACKGROUND_PROCESSOR_ROUTE)};
+const BACKGROUND_PROCESSOR_ROUTE_FIELD = ${JSON.stringify(AGENT_BACKGROUND_PROCESSOR_ROUTE_FIELD)};
+
+function processorPathFromBody(body) {
+  if (!body) return null;
+  try {
+    const parsed = JSON.parse(body);
+    if (parsed?.[BACKGROUND_PROCESSOR_FIELD] === BACKGROUND_PROCESSOR_A2A) {
+      return A2A_PROCESS_TASK_PATH;
+    }
+    const route = parsed?.[BACKGROUND_PROCESSOR_ROUTE_FIELD];
+    if (
+      parsed?.[BACKGROUND_PROCESSOR_FIELD] === BACKGROUND_PROCESSOR_ROUTE &&
+      typeof route === "string" &&
+      route.startsWith(basePath + "/api/_agent-native-background/") &&
+      !route.includes("?") &&
+      !route.includes("#")
+    ) {
+      return route;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 
 function setBasePathEnv() {
   const processRef = globalThis.process ??= { env: {} };
@@ -790,10 +825,10 @@ export default async function handler(request) {
   setBasePathEnv();
   cachedHandler ??= (await import("./main.mjs")).default;
   const url = new URL(request.url);
-  url.pathname = PROCESS_RUN_PATH;
   const method = request.method || "POST";
   const hasBody = method !== "GET" && method !== "HEAD";
   const body = hasBody ? await request.text() : undefined;
+  url.pathname = processorPathFromBody(body) || PROCESS_RUN_PATH;
   const rewritten = new Request(url.toString(), {
     method,
     headers: request.headers,

package/corpus/core/src/file-upload/types.ts

@@ -83,5 +83,7 @@ export interface FileUploadProvider {
       filename: string,
       options?: { stableUrl?: boolean; recordAsset?: boolean },
     ): Promise<string>;
+    /** Best-effort provider cleanup for a session the caller will not resume. */
+    abortSession?(session: ResumableUploadSession): Promise<void>;
   };
 }

package/corpus/core/src/index.ts

@@ -105,6 +105,43 @@ export {
   mountAgentNativeEmbedded,
   type AgentNativeEmbeddedPluginOptions,
 } from "./server/embedded.js";
+export {
+  BUILT_IN_INTEGRATION_CATALOG,
+  INTEGRATION_CATEGORIES,
+  getIntegrationCatalogEntry,
+  listBuiltInChannelIntegrations,
+  listIntegrationCatalog,
+  type AutomationCapabilities,
+  type BuiltInChannelId,
+  type ChannelCapabilities,
+  type IntegrationAvailability,
+  type IntegrationCatalogEntry,
+  type IntegrationCategory,
+  type IntegrationCredentialRequirement,
+  type IntegrationIconKey,
+  type IntegrationSupportMaturity,
+} from "./integrations/catalog.js";
+export {
+  AutomationConnectorError,
+  createAutomationCallbackHandler,
+  createAutomationRuntime,
+  createInvokeAutomationWorkflowAction,
+  type AutomationCallbackAuthentication,
+  type AutomationCallbackInput,
+  type AutomationCallbackResult,
+  type AutomationInboundDefinition,
+  type AutomationInvocation,
+  type AutomationInvocationResult,
+  type AutomationInvocationStatus,
+  type AutomationOutboundDefinition,
+  type AutomationResponseMode,
+  type AutomationRetryPolicy,
+  type AutomationRuntime,
+  type AutomationRuntimeOptions,
+  type AutomationWorkflowCapabilities,
+  type AutomationWorkflowDefinition,
+  type JsonSchema,
+} from "./automation/index.js";
 
 // Server
 export {

package/corpus/core/src/integrations/a2a-continuations-store.ts

@@ -461,9 +461,10 @@ export async function completeA2AContinuation(id: string): Promise<void> {
   const now = Date.now();
   await client.execute({
     sql: `UPDATE integration_a2a_continuations
-          SET status = ?, updated_at = ?, completed_at = ?
+          SET status = ?, updated_at = ?, completed_at = ?,
+              incoming_payload = ?, a2a_auth_token = NULL
           WHERE id = ? AND status IN ('processing', 'delivering', 'completed')`,
-    args: ["completed", now, now, id],
+    args: ["completed", now, now, "{}", id],
   });
 }
 
@@ -476,8 +477,9 @@ export async function failA2AContinuation(
   const now = Date.now();
   await client.execute({
     sql: `UPDATE integration_a2a_continuations
-          SET status = ?, updated_at = ?, error_message = ?
+          SET status = ?, updated_at = ?, error_message = ?,
+              incoming_payload = ?, a2a_auth_token = NULL
           WHERE id = ? AND status <> 'completed'`,
-    args: ["failed", now, errorMessage.slice(0, 2000), id],
+    args: ["failed", now, errorMessage.slice(0, 2000), "{}", id],
   });
 }

package/corpus/core/src/integrations/adapters/discord.ts

@@ -0,0 +1,362 @@
+import type { H3Event } from "h3";
+import { getHeader, readRawBody } from "h3";
+import nacl from "tweetnacl";
+
+import type { EnvKeyConfig } from "../../server/create-server.js";
+import { resolveSecret } from "../../server/credential-provider.js";
+import type {
+  IncomingMessage,
+  IntegrationStatus,
+  OutgoingMessage,
+  PlatformAdapter,
+} from "../types.js";
+
+const DISCORD_MAX_CONTENT_LENGTH = 2_000;
+const DISCORD_PING = 1;
+const DISCORD_APPLICATION_COMMAND = 2;
+const DISCORD_CHAT_INPUT_COMMAND = 1;
+const DISCORD_PONG = 1;
+const DISCORD_DEFERRED_CHANNEL_MESSAGE = 5;
+const DISCORD_SIGNATURE_MAX_SKEW_MS = 5 * 60 * 1000;
+
+type DiscordInteraction = {
+  id?: unknown;
+  application_id?: unknown;
+  type?: unknown;
+  token?: unknown;
+  guild_id?: unknown;
+  channel_id?: unknown;
+  member?: {
+    nick?: unknown;
+    user?: DiscordUser;
+  };
+  user?: DiscordUser;
+  data?: {
+    type?: unknown;
+    name?: unknown;
+    options?: unknown;
+  };
+  authorizing_integration_owners?: Record<string, unknown>;
+};
+
+type DiscordUser = {
+  id?: unknown;
+  username?: unknown;
+  global_name?: unknown;
+  bot?: unknown;
+};
+
+export function discordAdapter(): PlatformAdapter {
+  return {
+    platform: "discord",
+    label: "Discord",
+    capabilities: {
+      replyText: true,
+      proactiveMessages: false,
+      nativeThreads: false,
+      contextualReplies: false,
+      deferredWebhookResponse: true,
+      interactionOnly: true,
+    },
+
+    getRequiredEnvKeys(): EnvKeyConfig[] {
+      return [
+        {
+          key: "DISCORD_APPLICATION_ID",
+          label: "Discord Application ID",
+          required: true,
+          helpText:
+            "General Information → Application ID in the Discord Developer Portal.",
+        },
+        {
+          key: "DISCORD_PUBLIC_KEY",
+          label: "Discord Public Key",
+          required: true,
+          helpText:
+            "General Information → Public Key. Used to verify every interaction webhook.",
+        },
+      ];
+    },
+
+    async handleVerification(event: H3Event) {
+      const raw = await readRawBodyCached(event);
+      const interaction = parseInteraction(raw);
+      if (interaction?.type === DISCORD_PING) {
+        return { handled: true, response: { type: DISCORD_PONG } };
+      }
+      return { handled: false };
+    },
+
+    async verifyWebhook(event: H3Event): Promise<boolean> {
+      const publicKey = await resolveSecret("DISCORD_PUBLIC_KEY");
+      const applicationId = await resolveSecret("DISCORD_APPLICATION_ID");
+      const signature = getHeader(event, "x-signature-ed25519");
+      const timestamp = getHeader(event, "x-signature-timestamp");
+      if (
+        !publicKey ||
+        !applicationId ||
+        !signature ||
+        !timestamp ||
+        !/^\d+$/.test(timestamp) ||
+        !/^[0-9a-f]{64}$/i.test(publicKey) ||
+        !/^[0-9a-f]{128}$/i.test(signature)
+      ) {
+        return false;
+      }
+      const signedAtMs = Number(timestamp) * 1000;
+      if (
+        !Number.isSafeInteger(signedAtMs) ||
+        Math.abs(Date.now() - signedAtMs) > DISCORD_SIGNATURE_MAX_SKEW_MS
+      ) {
+        return false;
+      }
+
+      const raw = await readRawBodyCached(event);
+      const interaction = parseInteraction(raw);
+      if (
+        !interaction ||
+        readString(interaction.application_id) !== applicationId
+      ) {
+        return false;
+      }
+
+      try {
+        return nacl.sign.detached.verify(
+          new TextEncoder().encode(timestamp + raw),
+          hexToBytes(signature),
+          hexToBytes(publicKey),
+        );
+      } catch {
+        return false;
+      }
+    },
+
+    async parseIncomingMessage(
+      event: H3Event,
+    ): Promise<IncomingMessage | null> {
+      const interaction = parseInteraction(await readRawBodyCached(event));
+      if (
+        !interaction ||
+        interaction.type !== DISCORD_APPLICATION_COMMAND ||
+        interaction.data?.type !== DISCORD_CHAT_INPUT_COMMAND
+      ) {
+        return null;
+      }
+
+      const interactionId = readString(interaction.id);
+      const applicationId = readString(interaction.application_id);
+      const interactionToken = readString(interaction.token);
+      const channelId = readString(interaction.channel_id);
+      const guildId = readString(interaction.guild_id);
+      const user = interaction.member?.user ?? interaction.user;
+      const userId = readString(user?.id);
+      const commandName = readString(interaction.data.name);
+      const text = extractCommandText(interaction.data.options);
+      if (
+        !interactionId ||
+        !applicationId ||
+        !interactionToken ||
+        !channelId ||
+        !userId ||
+        !commandName ||
+        !text ||
+        user?.bot === true
+      ) {
+        return null;
+      }
+
+      const installationOwner =
+        readString(interaction.authorizing_integration_owners?.["0"]) ??
+        readString(interaction.authorizing_integration_owners?.["1"]);
+      const conversationScope = guildId
+        ? `guild:${guildId}:channel:${channelId}`
+        : `dm:${channelId}:user:${userId}`;
+
+      return {
+        platform: "discord",
+        externalThreadId: `app:${applicationId}:${conversationScope}`,
+        text,
+        senderName:
+          readString(interaction.member?.nick) ??
+          readString(user?.global_name) ??
+          readString(user?.username),
+        senderId: userId,
+        platformContext: {
+          applicationId,
+          interactionId,
+          commandName,
+          channelId,
+          guildId,
+          installationOwner,
+          interactionSurface: "outgoing-webhook",
+        },
+        responseContext: { interactionToken },
+        timestamp: Date.now(),
+      };
+    },
+
+    getImmediateWebhookResponse(incoming: IncomingMessage) {
+      if (!readString(incoming.responseContext?.interactionToken)) return null;
+      return {
+        status: 200,
+        body: {
+          type: DISCORD_DEFERRED_CHANNEL_MESSAGE,
+          data: { allowed_mentions: { parse: [] } },
+        },
+      };
+    },
+
+    async sendResponse(
+      message: OutgoingMessage,
+      context: IncomingMessage,
+    ): Promise<void> {
+      const applicationId = readString(context.platformContext.applicationId);
+      const interactionToken = readString(
+        context.responseContext?.interactionToken,
+      );
+      if (!applicationId || !interactionToken) {
+        throw new Error(
+          "Discord interaction response is unavailable or has expired",
+        );
+      }
+
+      const chunks = splitMessage(message.text, DISCORD_MAX_CONTENT_LENGTH);
+      if (chunks.length === 0) return;
+
+      await discordWebhookFetch(
+        `https://discord.com/api/v10/webhooks/${encodeURIComponent(applicationId)}/${encodeURIComponent(interactionToken)}/messages/@original`,
+        "PATCH",
+        chunks[0],
+      );
+
+      for (const chunk of chunks.slice(1)) {
+        await discordWebhookFetch(
+          `https://discord.com/api/v10/webhooks/${encodeURIComponent(applicationId)}/${encodeURIComponent(interactionToken)}`,
+          "POST",
+          chunk,
+        );
+      }
+    },
+
+    formatAgentResponse(text: string): OutgoingMessage {
+      return {
+        text,
+        platformContext: { allowedMentions: { parse: [] } },
+      };
+    },
+
+    async getStatus(): Promise<IntegrationStatus> {
+      const hasApplicationId = !!(await resolveSecret(
+        "DISCORD_APPLICATION_ID",
+      ));
+      const hasPublicKey = !!(await resolveSecret("DISCORD_PUBLIC_KEY"));
+      const configured = hasApplicationId && hasPublicKey;
+      return {
+        platform: "discord",
+        label: "Discord",
+        enabled: false,
+        configured,
+        details: {
+          hasApplicationId,
+          hasPublicKey,
+          surface: "interactions",
+          ordinaryMessageIngestion: false,
+        },
+        error: !configured
+          ? "Save DISCORD_APPLICATION_ID and DISCORD_PUBLIC_KEY in settings"
+          : undefined,
+      };
+    },
+  };
+}
+
+async function readRawBodyCached(event: H3Event): Promise<string> {
+  const cached = event.context.__rawBody;
+  if (typeof cached === "string") return cached;
+  const raw = (await readRawBody(event)) ?? "";
+  event.context.__rawBody = raw;
+  return raw;
+}
+
+function parseInteraction(raw: string): DiscordInteraction | null {
+  try {
+    const value = JSON.parse(raw);
+    return value && typeof value === "object"
+      ? (value as DiscordInteraction)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function extractCommandText(options: unknown): string | null {
+  if (!Array.isArray(options)) return null;
+  const values: string[] = [];
+  const visit = (items: unknown[]) => {
+    for (const item of items) {
+      if (!item || typeof item !== "object") continue;
+      const option = item as {
+        name?: unknown;
+        value?: unknown;
+        options?: unknown;
+      };
+      if (Array.isArray(option.options)) visit(option.options);
+      if (
+        typeof option.value === "string" ||
+        typeof option.value === "number" ||
+        typeof option.value === "boolean"
+      ) {
+        values.push(String(option.value));
+      }
+    }
+  };
+  visit(options);
+  return values.join(" ").trim() || null;
+}
+
+async function discordWebhookFetch(
+  url: string,
+  method: "PATCH" | "POST",
+  content: string,
+): Promise<void> {
+  const response = await fetch(url, {
+    method,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      content,
+      allowed_mentions: { parse: [] },
+    }),
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Discord interaction response failed (HTTP ${response.status})`,
+    );
+  }
+}
+
+function hexToBytes(value: string): Uint8Array {
+  return Uint8Array.from(value.match(/.{2}/g) ?? [], (byte) =>
+    Number.parseInt(byte, 16),
+  );
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function splitMessage(text: string, limit: number): string[] {
+  const chunks: string[] = [];
+  let remaining = text.trim();
+  while (remaining) {
+    if (remaining.length <= limit) {
+      chunks.push(remaining);
+      break;
+    }
+    let splitAt = remaining.lastIndexOf("\n", limit);
+    if (splitAt <= 0) splitAt = remaining.lastIndexOf(" ", limit);
+    if (splitAt <= 0) splitAt = limit;
+    chunks.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt).trimStart();
+  }
+  return chunks;
+}

package/corpus/core/src/integrations/adapters/index.ts

@@ -0,0 +1,29 @@
+import type { PlatformAdapter } from "../types.js";
+import { discordAdapter } from "./discord.js";
+import { emailAdapter } from "./email.js";
+import { microsoftTeamsAdapter } from "./microsoft-teams.js";
+import { slackAdapter } from "./slack.js";
+import { telegramAdapter } from "./telegram.js";
+import { whatsappAdapter } from "./whatsapp.js";
+
+/** Create the built-in adapter for proactive delivery outside a webhook run. */
+export function getDefaultAdapter(
+  platform: string,
+): PlatformAdapter | undefined {
+  switch (platform) {
+    case "slack":
+      return slackAdapter();
+    case "telegram":
+      return telegramAdapter();
+    case "whatsapp":
+      return whatsappAdapter();
+    case "discord":
+      return discordAdapter();
+    case "microsoft-teams":
+      return microsoftTeamsAdapter();
+    case "email":
+      return emailAdapter();
+    default:
+      return undefined;
+  }
+}