@andreprado/agentkit 0.1.0-alpha.2 → 0.1.0-alpha.21

package/src/runtime/channels/generic-webhook.ts

@@ -0,0 +1,225 @@
+import { createHash, createHmac, timingSafeEqual } from "node:crypto";
+
+import type { ChannelAdapter, ChannelSendInput, RawWebhookEvent } from "../channels";
+import { AgentKitError } from "../errors";
+
+const DEFAULT_SECRET_NAME = "AGENTKIT_WEBHOOK_SECRET";
+
+export const genericWebhookChannelAdapter: ChannelAdapter = {
+  type: "webhook",
+  provider: "generic",
+  requiredSecrets: [DEFAULT_SECRET_NAME],
+  verifyWebhook(input) {
+    const expected = input.secrets[DEFAULT_SECRET_NAME];
+
+    if (!expected) {
+      return {
+        ok: false,
+        code: "channel_secret_missing",
+        message: `Secret ${DEFAULT_SECRET_NAME} is not set for this channel.`,
+      };
+    }
+
+    const signature = input.headers.get("x-agentkit-webhook-signature") ?? input.headers.get("x-agentkit-signature");
+
+    if (signature) {
+      const expectedSignature = `sha256=${createHmac("sha256", expected).update(input.rawBody).digest("hex")}`;
+
+      if (constantTimeEqual(signature.trim(), expectedSignature)) {
+        return { ok: true };
+      }
+
+      return {
+        ok: false,
+        code: "channel_signature_invalid",
+        message: "Generic webhook HMAC signature did not match.",
+      };
+    }
+
+    const bearer = readBearerToken(input.headers.get("authorization"));
+    const headerToken =
+      input.headers.get("x-agentkit-webhook-secret") ??
+      input.headers.get("x-agentkit-channel-token") ??
+      input.headers.get("x-agentkit-webhook-token");
+
+    if (constantTimeEqual(bearer, expected) || constantTimeEqual(headerToken ?? "", expected)) {
+      return { ok: true };
+    }
+
+    return {
+      ok: false,
+      code: "channel_signature_invalid",
+      message: "Generic webhook token did not match.",
+    };
+  },
+  normalizeInbound(input) {
+    const body = parseJsonObject(input);
+    const eventId = readFirstScalar(body, ["event_id", "eventId", "id"]) ?? readNestedMessageId(body);
+
+    if (!eventId) {
+      throw new AgentKitError("channel_payload_invalid", "Generic webhook payload is missing event_id.");
+    }
+
+    const text = readMessageText(body);
+    const identitySource =
+      readFirstScalar(body, [
+        "external_id",
+        "externalId",
+        "user_id",
+        "userId",
+        "contact_id",
+        "contactId",
+        "conversation_id",
+        "conversationId",
+        "client_id",
+        "clientId",
+        "visitor_id",
+        "visitorId",
+        "source_id",
+        "sourceId",
+      ]) ?? `event:${eventId}`;
+    const identityKey = `webhook:generic:identity:${sha256(identitySource).slice(0, 32)}`;
+    const base = {
+      type: "webhook" as const,
+      provider: "generic" as const,
+      providerEventId: eventId,
+      dedupeKey: `webhook:generic:${input.channelId}:${eventId}`,
+      externalIdentity: {
+        key: identityKey,
+        redactedDisplay: identityKey,
+      },
+      receivedAt: input.receivedAt,
+    };
+
+    if (!text) {
+      return [
+        {
+          ...base,
+          kind: "unsupported" as const,
+          unsupportedReason: "unsupported_message_type:missing_text",
+        },
+      ];
+    }
+
+    return [
+      {
+        ...base,
+        kind: "message" as const,
+        message: {
+          role: "user" as const,
+          contentType: "text" as const,
+          content: text,
+          providerMessageId: readNestedMessageId(body) ?? eventId,
+        },
+      },
+    ];
+  },
+  async sendMessage(input) {
+    return {
+      ok: true,
+      status: "stubbed",
+      providerRequestId: buildGenericWebhookProviderRequestId(input),
+    };
+  },
+  getStatus() {
+    return {
+      status: "connected",
+      checkedAt: new Date().toISOString(),
+      providerMetadata: {
+        outbound: "stubbed",
+      },
+    };
+  },
+};
+
+function buildGenericWebhookProviderRequestId(input: ChannelSendInput): string {
+  return `webhook:generic:${input.channelId}:${input.conversationId}`;
+}
+
+function parseJsonObject(input: RawWebhookEvent): Record<string, unknown> {
+  const contentType = input.headers.get("content-type") ?? "";
+
+  if (contentType && !contentType.toLowerCase().includes("application/json")) {
+    throw new AgentKitError("channel_payload_invalid", "Generic webhook payload must use content-type application/json.");
+  }
+
+  try {
+    const parsed = JSON.parse(input.rawBody) as unknown;
+
+    if (isRecord(parsed)) {
+      return parsed;
+    }
+  } catch (error) {
+    throw new AgentKitError("channel_payload_invalid", "Generic webhook payload must be valid JSON.", {
+      cause: error,
+    });
+  }
+
+  throw new AgentKitError("channel_payload_invalid", "Generic webhook payload must be a JSON object.");
+}
+
+function readMessageText(body: Record<string, unknown>): string | undefined {
+  const message = body.message;
+
+  if (typeof message === "string") {
+    return normalizeNonEmpty(message);
+  }
+
+  if (isRecord(message)) {
+    return readFirstScalar(message, ["text", "content", "body"]);
+  }
+
+  return readFirstScalar(body, ["text", "content", "prompt", "input"]);
+}
+
+function readNestedMessageId(body: Record<string, unknown>): string | undefined {
+  const message = body.message;
+  return isRecord(message) ? readFirstScalar(message, ["id", "message_id", "messageId"]) : undefined;
+}
+
+function readFirstScalar(value: Record<string, unknown>, keys: string[]): string | undefined {
+  for (const key of keys) {
+    const field = value[key];
+
+    if (typeof field === "string") {
+      const normalized = normalizeNonEmpty(field);
+
+      if (normalized) {
+        return normalized;
+      }
+    }
+
+    if (typeof field === "number" && Number.isFinite(field)) {
+      return String(field);
+    }
+  }
+
+  return undefined;
+}
+
+function normalizeNonEmpty(value: string): string | undefined {
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function readBearerToken(value: string | null): string {
+  if (!value?.startsWith("Bearer ")) {
+    return "";
+  }
+
+  return value.slice("Bearer ".length).trim();
+}
+
+function constantTimeEqual(left: string, right: string): boolean {
+  const leftDigest = createHash("sha256").update(left).digest();
+  const rightDigest = createHash("sha256").update(right).digest();
+  return timingSafeEqual(leftDigest, rightDigest) && left === right;
+}
+
+function sha256(value: string): string {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}