@adzenai/ai 1.1.0 → 1.2.0

package/dist/copilotkit/index.js

@@ -1,4 +1,9 @@
 // src/copilotkit/middleware.ts
+function generateIdempotencyKey() {
+  const globalCrypto = globalThis.crypto;
+  if (globalCrypto?.randomUUID) return globalCrypto.randomUUID();
+  return `adzen-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
 function isFinalOutputEvent(event) {
   const type = String(event.type ?? "");
   if (type === "RUN_FINISHED" || type === "RunFinished") return false;
@@ -28,13 +33,15 @@ var AdzenAsyncMiddleware = class {
   fetchedIds = /* @__PURE__ */ new Set();
   pendingFetches = [];
   fallbackCounter = 0;
+  conversationId;
   constructor(config) {
     this.config = {
       ...config,
-      endpointUrl: config.endpointUrl ?? "https://api.adzen.ai/v1/ai",
+      endpointUrl: config.endpointUrl ?? "https://api.adzen.ai/v1",
       timeoutMs: config.timeoutMs ?? 3e3,
       adUnitPosition: config.adUnitPosition ?? "chin"
     };
+    this.conversationId = config.conversationId;
   }
   /**
    * Process a single AG-UI event. Returns an array of events to emit
@@ -44,6 +51,12 @@ var AdzenAsyncMiddleware = class {
   async processEvent(event) {
     const type = String(event.type ?? "");
     switch (type) {
+      case "RUN_STARTED":
+      case "RunStarted": {
+        const threadId = String(event.threadId ?? "");
+        if (threadId) this.conversationId = threadId;
+        return [event];
+      }
       case "TEXT_MESSAGE_START":
       case "TextMessageStart": {
         const messageId = this.resolveMessageId(event);
@@ -131,31 +144,58 @@ var AdzenAsyncMiddleware = class {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs);
     try {
+      const body = {
+        content,
+        message_id: messageId
+      };
+      if (this.config.location) body.location = this.config.location;
+      if (this.conversationId) body.conversation_id = this.conversationId;
+      const headers = {
+        "Content-Type": "application/json",
+        "X-API-Key": this.config.apiKey,
+        // AI-API requires an Idempotency-Key on /process (400 otherwise).
+        // One per ad fetch — each completed message is a distinct request.
+        "Idempotency-Key": generateIdempotencyKey()
+      };
+      if (this.config.profileId) headers["X-Profile-Id"] = this.config.profileId;
       const res = await fetch(`${this.config.endpointUrl}/process`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-API-Key": this.config.apiKey
-        },
-        body: JSON.stringify({
-          content,
-          message_id: messageId
-        }),
+        headers,
+        body: JSON.stringify(body),
         signal: controller.signal
       });
       if (!res.ok) return null;
       const data = await res.json();
-      if (data.decision === "serve" && data.ad) return data.ad;
-      return null;
+      const first = data.ads?.[0];
+      if (!first) return null;
+      return this.mapResponseToPlacement(first);
     } catch {
       return null;
     } finally {
       clearTimeout(timeout);
     }
   }
+  mapResponseToPlacement(ad) {
+    return {
+      ad_id: String(ad.ad_id),
+      advertiser_name: ad.advertiser_name,
+      advertiser_image_url: ad.sponsor_logo_url || void 0,
+      headline: ad.title,
+      description: ad.description,
+      cta_text: ad.cta,
+      destination_url: ad.click_through_url,
+      creative_url: ad.creative_url ?? void 0,
+      adUnitPosition: ad.placement ?? this.config.adUnitPosition,
+      render_impression_url: ad.render_impression_url,
+      view_impression_url: ad.view_impression_url
+    };
+  }
   makePlacementEvent(placement, messageId) {
     return {
-      type: "CUSTOM_EVENT",
+      // AG-UI's event schema only accepts "CUSTOM"; @ag-ui/client zod-validates
+      // every SSE frame and aborts the run on an unknown type. "CUSTOM_EVENT"
+      // was rejected downstream.
+      type: "CUSTOM",
       name: "adzen_placement",
       messageId,
       value: {
@@ -166,71 +206,464 @@ var AdzenAsyncMiddleware = class {
   }
 };
 
-// src/copilotkit/impressionHandler.ts
-var REQUIRED_FIELDS = [
-  "type",
-  "ad_id",
-  "message_id",
-  "ad_unit_position",
-  "timestamp"
-];
-function createImpressionHandler(config) {
-  const endpointUrl = config.endpointUrl ?? "https://api.adzen.ai/v1/ai";
-  return async (request) => {
-    if (request.method !== "POST") {
-      return new Response(JSON.stringify({ error: "Method not allowed" }), {
-        status: 405,
-        headers: { "Content-Type": "application/json" }
-      });
+// src/copilotkit/AdzenStreamClient.ts
+import { uuidv4 } from "@adzenai/core";
+
+// src/copilotkit/parseSSE.ts
+async function* parseSSE(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let currentEvent;
+  let dataLines = [];
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop();
+      for (const raw of lines) {
+        const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+        if (line === "") {
+          if (dataLines.length > 0) {
+            yield { event: currentEvent, data: dataLines.join("\n") };
+            dataLines = [];
+            currentEvent = void 0;
+          }
+          continue;
+        }
+        if (line.startsWith(":")) continue;
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1) continue;
+        const field = line.slice(0, colonIdx);
+        const value2 = line.slice(colonIdx + 1).replace(/^ /, "");
+        switch (field) {
+          case "data":
+            dataLines.push(value2);
+            break;
+          case "event":
+            currentEvent = value2;
+            break;
+        }
+      }
     }
-    let body;
-    try {
-      body = await request.json();
-    } catch {
-      return new Response(JSON.stringify({ error: "Invalid JSON" }), {
-        status: 400,
-        headers: { "Content-Type": "application/json" }
-      });
+    if (dataLines.length > 0) {
+      yield { event: currentEvent, data: dataLines.join("\n") };
     }
-    for (const field of REQUIRED_FIELDS) {
-      if (!body[field]) {
-        return new Response(
-          JSON.stringify({ error: `Missing required field: ${field}` }),
-          { status: 400, headers: { "Content-Type": "application/json" } }
-        );
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/copilotkit/AdzenStreamClient.ts
+var DEFAULT_ENDPOINT = "https://api.adzen.ai/v1";
+var DEFAULT_TIMEOUT_MS = 3e3;
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
+var SUPPORTS_REQUEST_STREAMS = (() => {
+  try {
+    let duplexAccessed = false;
+    const hasContentType = new Request("http://localhost", {
+      method: "POST",
+      body: new ReadableStream(),
+      get duplex() {
+        duplexAccessed = true;
+        return "half";
       }
+    }).headers.has("Content-Type");
+    return duplexAccessed && !hasContentType;
+  } catch {
+    return false;
+  }
+})();
+var AdzenStreamClient = class {
+  endpointUrl;
+  apiKey;
+  timeoutMs;
+  location;
+  profileId;
+  placementPollIntervalMs;
+  prefetchEnabled;
+  sidecarEnabled;
+  conversationId;
+  abortController = null;
+  placementEndpoint = null;
+  pollTimer = null;
+  streamEnded = false;
+  inlineAdQueue = [];
+  streamPromise = null;
+  prefetchPromise = null;
+  onInlineAd;
+  onPlacement;
+  onError;
+  onStreamStart;
+  onStreamEnd;
+  constructor(config) {
+    this.endpointUrl = config.endpointUrl ?? DEFAULT_ENDPOINT;
+    this.apiKey = config.apiKey;
+    this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.location = config.location;
+    this.profileId = config.profileId;
+    this.placementPollIntervalMs = config.placementPollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    this.prefetchEnabled = config.prefetch ?? false;
+    this.sidecarEnabled = config.sidecar ?? true;
+    this.conversationId = config.conversationId ?? uuidv4();
+    this.onInlineAd = config.onInlineAd;
+    this.onPlacement = config.onPlacement;
+    this.onError = config.onError;
+    this.onStreamStart = config.onStreamStart;
+    this.onStreamEnd = config.onStreamEnd;
+  }
+  getConversationId() {
+    return this.conversationId;
+  }
+  setConversationId(id) {
+    this.conversationId = id;
+  }
+  /**
+   * Dispatches the prefetch without waiting for it.
+   *
+   * The request leaves before `connect()` opens `/stream`, which is all the
+   * 2-step chained flow needs — the two calls are correlated server-side by
+   * `conversation_id`. Awaiting the response here would stall the assistant
+   * message behind a full ad-matching round trip while the LLM keeps
+   * streaming, so the buffered tokens would then arrive in one burst.
+   */
+  startPrefetch(prompt) {
+    if (!this.prefetchEnabled) return;
+    this.prefetchPromise = this.prefetchProcess(prompt);
+  }
+  /**
+   * 2-step chained flow: POST /process with the user prompt and
+   * conversationId. Awaits the response (or timeout) but discards the
+   * result. If it fails, logs and continues — the stream will proceed
+   * in degraded mode.
+   */
+  async prefetchProcess(prompt) {
+    if (!this.prefetchEnabled) return;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const body = {
+        content: prompt,
+        message_id: uuidv4(),
+        conversation_id: this.conversationId
+      };
+      if (this.location) body.location = this.location;
+      const headers = {
+        "Content-Type": "application/json",
+        "X-API-Key": this.apiKey,
+        "Idempotency-Key": uuidv4()
+      };
+      if (this.profileId) headers["X-Profile-Id"] = this.profileId;
+      await fetch(`${this.endpointUrl}/process`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+    } catch {
+    } finally {
+      clearTimeout(timeout);
     }
-    if (body.type !== "render" && body.type !== "view") {
-      return new Response(
-        JSON.stringify({ error: 'Invalid type: must be "render" or "view"' }),
-        { status: 400, headers: { "Content-Type": "application/json" } }
-      );
+  }
+  /**
+   * Opens a streaming POST to /stream, piping the upstream LLM response
+   * body directly. The API reads the raw LLM stream in real time and
+   * sends SSE ad events back on the response side.
+   *
+   * @param messageId  Unique ID for this assistant message
+   * @param body       The upstream LLM response body (one branch of a tee)
+   */
+  connect(messageId, body) {
+    this.streamEnded = false;
+    this.inlineAdQueue = [];
+    this.placementEndpoint = null;
+    this.streamPromise = null;
+    this.abortController = new AbortController();
+    if (!SUPPORTS_REQUEST_STREAMS) {
+      this.streamEnded = true;
+      this.onError?.({
+        type: "adzen_error",
+        code: "request_streams_unsupported",
+        message: "This runtime cannot send a ReadableStream as a request body, so the LLM stream cannot be proxied. Run AdzenStreamMiddleware server-side (Node 18+) \u2014 browsers other than Chromium do not support fetch upload streams."
+      });
+      void body.cancel().catch(() => {
+      });
+      return;
     }
-    const upstreamPath = body.type === "render" ? "/impressions/render" : "/impressions/view";
-    const { type: _type, ...forwardBody } = body;
+    const headers = {
+      "Content-Type": "application/octet-stream",
+      "X-API-Key": this.apiKey,
+      "Idempotency-Key": uuidv4(),
+      "X-Message-Id": messageId,
+      "X-Conversation-Id": this.conversationId
+    };
+    if (this.profileId) headers["X-Profile-Id"] = this.profileId;
+    if (this.location) headers["X-Location"] = this.location;
+    this.streamPromise = this.executeStreamFetch(body, headers);
+  }
+  /**
+   * Waits for the SSE response stream from the API to finish, along with any
+   * prefetch still in flight. Neither can reject — both swallow their errors.
+   */
+  async finalize() {
+    await Promise.all([this.prefetchPromise, this.streamPromise]);
+  }
+  async executeStreamFetch(body, headers) {
+    const timeout = setTimeout(
+      () => this.abortController?.abort(),
+      this.timeoutMs
+    );
     try {
-      const upstream = await fetch(`${endpointUrl}${upstreamPath}`, {
+      const res = await fetch(`${this.endpointUrl}/stream`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-API-Key": config.apiKey
-        },
-        body: JSON.stringify(forwardBody)
+        headers,
+        body,
+        signal: this.abortController?.signal,
+        // @ts-expect-error -- required for streaming request bodies (Node/undici)
+        duplex: "half"
       });
-      return new Response(upstream.body, {
-        status: upstream.status,
-        headers: { "Content-Type": "application/json" }
+      clearTimeout(timeout);
+      if (!res.ok || !res.body) return;
+      await this.readStream(res.body);
+    } catch {
+      clearTimeout(timeout);
+    }
+  }
+  /** Drains and returns any queued inline ad events. */
+  drainInlineAds() {
+    const ads = this.inlineAdQueue.splice(0);
+    return ads;
+  }
+  /** Cancels pending requests and cleans up state. */
+  abort() {
+    this.abortController?.abort();
+    this.stopPolling();
+    this.streamEnded = true;
+  }
+  /** Polls the placement endpoint once. Called on an interval internally. */
+  async pollPlacements() {
+    if (!this.sidecarEnabled || !this.placementEndpoint) return;
+    try {
+      const res = await fetch(this.placementEndpoint, {
+        method: "GET",
+        headers: { "X-API-Key": this.apiKey }
       });
+      if (!res.ok) return;
+      const data = await res.json();
+      for (const placement of data.placements) {
+        this.onPlacement?.(placement);
+      }
     } catch {
-      return new Response(
-        JSON.stringify({ error: "Upstream request failed" }),
-        { status: 502, headers: { "Content-Type": "application/json" } }
-      );
     }
-  };
-}
+  }
+  async readStream(body) {
+    try {
+      for await (const frame of parseSSE(body)) {
+        if (this.abortController?.signal.aborted) break;
+        this.handleFrame(frame.event, frame.data);
+      }
+    } catch {
+    } finally {
+      this.streamEnded = true;
+      this.stopPolling();
+    }
+  }
+  handleFrame(event, data) {
+    switch (event) {
+      case "adzen_stream_start": {
+        try {
+          const parsed = JSON.parse(data);
+          const evt = { type: "adzen_stream_start", ...parsed };
+          this.placementEndpoint = parsed.placement_endpoint;
+          this.onStreamStart?.(evt);
+          this.startPolling();
+        } catch {
+        }
+        break;
+      }
+      case "adzen_inline": {
+        try {
+          const ad = JSON.parse(data);
+          this.inlineAdQueue.push(ad);
+          this.onInlineAd?.(ad);
+        } catch {
+        }
+        break;
+      }
+      case "adzen_error": {
+        try {
+          const parsed = JSON.parse(data);
+          this.onError?.({ type: "adzen_error", ...parsed });
+        } catch {
+        }
+        break;
+      }
+      case "adzen_stream_end": {
+        try {
+          const parsed = JSON.parse(data);
+          const evt = { type: "adzen_stream_end", ...parsed };
+          this.onStreamEnd?.(evt);
+        } catch {
+        }
+        this.streamEnded = true;
+        this.stopPolling();
+        break;
+      }
+      default: {
+        if (event?.startsWith("adzen_debug_")) break;
+        break;
+      }
+    }
+  }
+  startPolling() {
+    if (!this.sidecarEnabled) return;
+    if (this.pollTimer || !this.placementEndpoint) return;
+    this.pollTimer = setInterval(
+      () => this.pollPlacements(),
+      this.placementPollIntervalMs
+    );
+  }
+  stopPolling() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+};
+
+// src/copilotkit/streamMiddleware.ts
+var AdzenStreamMiddleware = class {
+  config;
+  adUnitPosition;
+  constructor(config) {
+    this.config = config;
+    this.adUnitPosition = config.adUnitPosition ?? "chin";
+  }
+  async *processStream(events, options) {
+    const sidecarPlacements = [];
+    let client = null;
+    let currentMessageId = "";
+    let contentOffset = 0;
+    const onPlacement = (record) => {
+      sidecarPlacements.push(this.mapPlacementRecord(record, currentMessageId));
+    };
+    const onError = (error) => {
+      console.warn(`[adzen-stream] ${error.code}: ${error.message}`);
+    };
+    for await (const event of events) {
+      const type = String(event.type ?? "");
+      switch (type) {
+        case "RUN_STARTED":
+        case "RunStarted": {
+          const threadId = String(event.threadId ?? "");
+          client = new AdzenStreamClient({
+            ...this.config,
+            conversationId: threadId || this.config.conversationId,
+            onPlacement,
+            onError
+          });
+          if (this.config.prefetch && options?.prompt) {
+            client.startPrefetch(options.prompt);
+          }
+          yield event;
+          break;
+        }
+        case "TEXT_MESSAGE_START":
+        case "TextMessageStart": {
+          currentMessageId = String(event.messageId ?? "");
+          contentOffset = 0;
+          if (client && options?.upstreamBody) {
+            client.connect(currentMessageId, options.upstreamBody);
+          }
+          yield event;
+          break;
+        }
+        case "TEXT_MESSAGE_CONTENT":
+        case "TextMessageContent": {
+          yield event;
+          contentOffset += String(event.delta ?? "").length;
+          if (client) {
+            for (const ad of client.drainInlineAds()) {
+              yield this.makeInlineAdEvent(ad, currentMessageId, contentOffset);
+            }
+          }
+          break;
+        }
+        case "TEXT_MESSAGE_END":
+        case "TextMessageEnd": {
+          if (client) {
+            await client.finalize();
+            for (const ad of client.drainInlineAds()) {
+              yield this.makeInlineAdEvent(ad, currentMessageId, contentOffset);
+            }
+          }
+          yield event;
+          break;
+        }
+        case "RUN_FINISHED":
+        case "RunFinished": {
+          if (client) {
+            await client.pollPlacements();
+            client.abort();
+          }
+          for (const placement of sidecarPlacements) {
+            yield this.makePlacementEvent(placement, placement.ad_id);
+          }
+          yield event;
+          break;
+        }
+        default:
+          yield event;
+      }
+    }
+  }
+  /**
+   * Wraps an inline ad as an AG-UI custom event anchored to `contentOffset`,
+   * the number of message characters emitted before the ad arrived. Clients
+   * use it to render the ad directly after that content instead of at the
+   * end of the message.
+   */
+  makeInlineAdEvent(ad, messageId, contentOffset) {
+    const value = {
+      ...ad,
+      message_id: messageId,
+      content_offset: contentOffset
+    };
+    return {
+      type: "CUSTOM_EVENT",
+      name: "adzen_inline_ad",
+      messageId,
+      value
+    };
+  }
+  makePlacementEvent(placement, adId) {
+    return {
+      type: "CUSTOM_EVENT",
+      name: "adzen_placement",
+      messageId: adId,
+      value: {
+        ...placement,
+        message_id: placement.ad_id
+      }
+    };
+  }
+  mapPlacementRecord(record, messageId) {
+    return {
+      ad_id: String(record.ad_id),
+      advertiser_name: "",
+      headline: record.headline,
+      cta_text: record.cta_text,
+      destination_url: record.destination_url,
+      adUnitPosition: record.placement || this.adUnitPosition,
+      render_impression_url: record.tracking.impression_url,
+      view_impression_url: record.tracking.impression_url
+    };
+  }
+};
 export {
   AdzenAsyncMiddleware,
-  createImpressionHandler
+  AdzenStreamMiddleware
 };
 //# sourceMappingURL=index.js.map