@niadra/sdk 0.1.0 → 0.7.0

package/dist/retell.cjs

@@ -0,0 +1,846 @@
+'use strict';
+
+// src/tools.ts
+var TOOL_NAMES = {
+  search: "search_customer_history",
+  timeline: "get_customer_timeline",
+  open: "open_history_item"
+};
+var AGENT_MEMORY_TOOL_NAMES = {
+  search: "search_agent_memory",
+  remember: "remember"
+};
+var TOOL_DEFINITIONS = [
+  {
+    "type": "function",
+    "function": {
+      "name": "search_customer_history",
+      "description": "Search everything that already happened with this customer: past conversations, promises, agent actions, orders and invoices. Use it when the customer refers to something earlier or asks whether a problem happened before. Do not call it when the answer is already in the context block, including its 'Do hist\xF3rico' line, which already counts recurrences. Returns short items with date, channel and outcome, plus a recurrence count. Open one with open_history_item.",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "query": {
+            "type": "string",
+            "description": "What to look for, in the customer's words."
+          },
+          "filters": {
+            "type": "object",
+            "properties": {
+              "since": {
+                "type": "string",
+                "format": "date-time"
+              },
+              "until": {
+                "type": "string",
+                "format": "date-time"
+              },
+              "when": {
+                "type": "string",
+                "description": "The period in the customer's own words, as they said it: 'last week', 'semana passada', 'en marzo'."
+              },
+              "channels": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "categories": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "item_kinds": {
+                "type": "array",
+                "items": {
+                  "enum": [
+                    "episode",
+                    "fact",
+                    "open_item",
+                    "action",
+                    "object",
+                    "trait"
+                  ]
+                }
+              },
+              "outcome": {
+                "type": "string"
+              }
+            },
+            "additionalProperties": false
+          },
+          "max_tokens": {
+            "type": "integer",
+            "minimum": 50,
+            "maximum": 4e3
+          }
+        },
+        "required": [
+          "query"
+        ],
+        "additionalProperties": false
+      }
+    }
+  },
+  {
+    "type": "function",
+    "function": {
+      "name": "get_customer_timeline",
+      "description": "List this customer's conversations and agent actions in order, newest first, one line each. Use it to leaf through the history when you do not know what to search for. Pass next_cursor to continue. Prefer search_customer_history for a specific question.",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "cursor": {
+            "type": "string"
+          },
+          "limit": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 100
+          },
+          "filters": {
+            "type": "object",
+            "properties": {
+              "since": {
+                "type": "string",
+                "format": "date-time"
+              },
+              "until": {
+                "type": "string",
+                "format": "date-time"
+              },
+              "when": {
+                "type": "string",
+                "description": "The period in the customer's own words, as they said it: 'last week', 'semana passada', 'en marzo'."
+              },
+              "channels": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "categories": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "item_kinds": {
+                "type": "array",
+                "items": {
+                  "enum": [
+                    "episode",
+                    "fact",
+                    "open_item",
+                    "action",
+                    "object",
+                    "trait"
+                  ]
+                }
+              },
+              "outcome": {
+                "type": "string"
+              }
+            },
+            "additionalProperties": false
+          }
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  {
+    "type": "function",
+    "function": {
+      "name": "open_history_item",
+      "description": "Open one conversation or business object returned by search_customer_history or get_customer_timeline: what was asked, what was promised and by whom, the outcome and what memory came from it. Use it only after a search or timeline pointed to the item.",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "The item id, e.g. `episode:...`."
+          }
+        },
+        "required": [
+          "id"
+        ],
+        "additionalProperties": false
+      }
+    }
+  }
+];
+var AGENT_MEMORY_TOOL_DEFINITIONS = [
+  {
+    "type": "function",
+    "function": {
+      "name": "search_agent_memory",
+      "description": "Search your own working notes: procedures, how the company's tools and processes behave, and known pitfalls. Use it before a task or a tool call you are unsure how to do. It holds nothing about customers; for the customer's history use search_customer_history.",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "query": {
+            "type": "string",
+            "description": "What you need to know how to do."
+          },
+          "tags": {
+            "type": "array",
+            "maxItems": 8,
+            "items": {
+              "type": "string",
+              "pattern": "^[a-z0-9][a-z0-9_.:-]{0,63}$"
+            },
+            "description": "Object types, operations or systems, e.g. `invoice`, `credit`, `erp`."
+          }
+        },
+        "required": [
+          "query"
+        ],
+        "additionalProperties": false
+      }
+    }
+  },
+  {
+    "type": "function",
+    "function": {
+      "name": "remember",
+      "description": "Save a working note for yourself and future runs: a procedure that worked, how a tool or process behaves, or a pitfall to avoid. Never write anything about a customer here: no names, phones, e-mails, documents, ids or words from the conversation. A note with personal data is refused. Write it so it helps with any customer.",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "kind": {
+            "enum": [
+              "procedure",
+              "tool_note",
+              "process_note",
+              "pitfall"
+            ]
+          },
+          "title": {
+            "type": "string",
+            "maxLength": 120
+          },
+          "body": {
+            "type": "string",
+            "maxLength": 2e3
+          },
+          "tags": {
+            "type": "array",
+            "maxItems": 8,
+            "items": {
+              "type": "string",
+              "pattern": "^[a-z0-9][a-z0-9_.:-]{0,63}$"
+            },
+            "description": "Object types, operations or systems, e.g. `invoice`, `credit`, `erp`."
+          }
+        },
+        "required": [
+          "kind",
+          "title",
+          "body"
+        ],
+        "additionalProperties": false
+      }
+    }
+  }
+];
+
+// src/context.ts
+function emptyResult(error) {
+  return { text: "", suffix: "", variables: {}, pack: null, source: "none", response: null, error, constraints: null, state: null, coordination: null };
+}
+
+// src/integrations/shared.ts
+var ATTESTED = { A: "V2", B: "V1", C: "V1" };
+function attestationProof(attestation) {
+  if (!attestation) return null;
+  const value = attestation.trim().toUpperCase();
+  if (value.includes("FAILED") || value.startsWith("NO-")) return null;
+  const letter = value.length === 1 ? value : /PASSED-([ABC])$/.exec(value)?.[1];
+  const level = letter ? ATTESTED[letter] : void 0;
+  return level ? { method: "network_attestation", level } : null;
+}
+function isConversation(session) {
+  return "customer" in session && typeof session.customer === "function";
+}
+function phoneHandle(value) {
+  const raw = value?.trim().replace(/^tel:/i, "").replace(/[\s().-]/g, "");
+  if (!raw) return null;
+  const e164 = raw.startsWith("+") ? raw : `+${raw}`;
+  return /^\+[1-9]\d{6,14}$/.test(e164) ? { type: "phone_e164", value: e164 } : null;
+}
+function errorName(error) {
+  return error instanceof Error ? error.name : typeof error;
+}
+var Bridge = class {
+  constructor(session, proof, memory = false) {
+    this.session = session;
+    this.proof = proof;
+    this.memory = memory;
+  }
+  session;
+  proof;
+  memory;
+  proving = null;
+  /** `begin()` started the first read of a call: the first `context()` waits for it with `ready()`. */
+  begun = false;
+  opened = false;
+  /**
+   * The context and, when enabled, the agent's notes, read side by side within the same budget.
+   * Never rejects.
+   */
+  async read(options = {}) {
+    const memoryParams = this.memory === false ? null : this.memory === true ? {} : withoutWrite(this.memory);
+    const [context, memory] = await Promise.all([
+      this.context(options),
+      memoryParams ? this.agentMemory(memoryParams, options) : Promise.resolve("")
+    ]);
+    return { context, memory, prefix: [memory, context.text].filter(Boolean).join("\n\n"), suffix: context.suffix };
+  }
+  get logger() {
+    return this.session.logger;
+  }
+  /**
+   * Starts the first read of a call now, in the background, after the proof when one was given (the
+   * pack depends on the level it proves): at call start, so the read runs while the call is set up.
+   * The first `context()` then waits for it within `timeouts.contextVoiceStart`. Never throws.
+   */
+  begin() {
+    const session = this.session;
+    if (!isConversation(session)) return;
+    const start = () => {
+      this.safe("start the first read", () => {
+        this.begun = session.begin();
+      });
+    };
+    if (this.proof === void 0 || this.proof === null) start();
+    else void this.verifyOnce().then(start);
+  }
+  /** Verifies once (when a proof was given), then reads the context. Never rejects. */
+  async context(options = {}) {
+    await this.verifyOnce();
+    try {
+      const session = this.session;
+      if (this.begun && !this.opened && isConversation(session)) {
+        this.opened = true;
+        await session.ready(options.timeout === void 0 ? {} : { timeout: options.timeout });
+      }
+      return await this.session.context(options);
+    } catch (error) {
+      this.logger.warn(`could not read context (${errorName(error)})`);
+      return emptyResult(null);
+    }
+  }
+  /** Records that `context` went into the prompt, unless it was empty for a reason other than the holdout. */
+  injected(context) {
+    if (!context.text && !context.suffix && context.response?.path !== "holdout") return;
+    this.safe("mark the injection", () => {
+      this.session.markInjected(context);
+    });
+  }
+  customer(text, options = {}) {
+    const session = this.session;
+    if (!text.trim() || !isConversation(session)) return;
+    this.safe("record the customer's turn", () => session.customer(text, options));
+  }
+  /** Sends the customer's turn so far, while they speak. In the background; never throws. */
+  prefetch(text) {
+    const session = this.session;
+    if (!text.trim() || !isConversation(session)) return;
+    this.safe("prefetch the turn", () => session.prefetch(text));
+  }
+  agent(text, options = {}) {
+    if (!text.trim()) return;
+    this.safe("record the agent's turn", () => this.session.agent(text, options));
+  }
+  /** Records a transfer. Tasks have no transfer; the call is ignored for them. */
+  async handoff(target, reason) {
+    const session = this.session;
+    if (!isConversation(session)) return;
+    try {
+      await session.handoff(reason ? { target, reason } : { target });
+    } catch (error) {
+      this.logger.warn(`could not record the handoff (${errorName(error)})`);
+    }
+  }
+  async end() {
+    try {
+      await this.session.end();
+    } catch (error) {
+      this.logger.warn(`could not end the session (${errorName(error)})`);
+    }
+  }
+  /** The navigation kit as plain specs (with the agent's memory tools when enabled), or none for a task about an object only. */
+  tools() {
+    let bound;
+    try {
+      const memory = this.memory;
+      bound = this.session.tools(memory === false ? {} : { agentMemory: true, writeAgentMemory: memory !== true && memory.write === true });
+    } catch (error) {
+      this.logger.warn(`could not build the tools (${errorName(error)})`);
+      return [];
+    }
+    return bound ? toolSpecs(bound) : [];
+  }
+  async agentMemory(params, options) {
+    try {
+      const result = await this.session.agentMemory(params, options.timeout === void 0 ? {} : { timeout: options.timeout });
+      return result.text;
+    } catch (error) {
+      this.logger.warn(`could not read the agent's memory (${errorName(error)})`);
+      return "";
+    }
+  }
+  async verifyOnce() {
+    if (this.proof === void 0 || this.proof === null) return;
+    this.proving ??= this.runVerify();
+    await this.proving;
+  }
+  async runVerify() {
+    try {
+      const source = this.proof;
+      const proof = typeof source === "function" ? await source() : source;
+      if (!proof) return;
+      await this.session.verify(proof);
+    } catch (error) {
+      this.logger.warn(`could not record the verification (${errorName(error)})`);
+    }
+  }
+  safe(what, run) {
+    try {
+      run();
+    } catch (error) {
+      this.logger.warn(`could not ${what} (${errorName(error)})`);
+    }
+  }
+};
+function withoutWrite(option) {
+  const { write: _, ...params } = option;
+  return params;
+}
+function toolSpecs(bound) {
+  return bound.definitions.map(({ function: definition }) => ({
+    name: definition.name,
+    description: definition.description,
+    parameters: definition.parameters,
+    execute: (args) => bound.call(definition.name, args)
+  }));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/integrations/webhook.ts
+function memoryCallStore(max = 1e4) {
+  const calls = /* @__PURE__ */ new Map();
+  return {
+    get: (id) => calls.get(id),
+    set: (id, record) => {
+      calls.delete(id);
+      calls.set(id, record);
+      if (calls.size > max) {
+        const oldest = calls.keys().next().value;
+        if (oldest !== void 0) calls.delete(oldest);
+      }
+    }
+  };
+}
+function header(headers, name) {
+  if (typeof headers.get === "function") return headers.get(name) ?? void 0;
+  const wanted = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() !== wanted) continue;
+    return Array.isArray(value) ? value[0] : value;
+  }
+  return void 0;
+}
+function subtle() {
+  const crypto = globalThis.crypto;
+  if (!crypto?.subtle) throw new Error("Web Crypto is not available on this runtime");
+  return crypto.subtle;
+}
+var encoder = new TextEncoder();
+async function hmac(hash, secret, message) {
+  const key = await subtle().importKey("raw", encoder.encode(secret), { name: "HMAC", hash }, false, ["sign"]);
+  return new Uint8Array(await subtle().sign("HMAC", key, encoder.encode(message)));
+}
+function hex(bytes) {
+  let out = "";
+  for (const byte of bytes) out += byte.toString(16).padStart(2, "0");
+  return out;
+}
+function safeEqual(a, b) {
+  const left = encoder.encode(a);
+  const right = encoder.encode(b);
+  if (left.length !== right.length) return false;
+  let diff = 0;
+  for (let i = 0; i < left.length; i++) diff |= (left[i] ?? 0) ^ (right[i] ?? 0);
+  return diff === 0;
+}
+function bodyText(body) {
+  if (typeof body === "string") return body;
+  return new TextDecoder().decode(body instanceof Uint8Array ? body : new Uint8Array(body));
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/integrations/retell.ts
+var OURS = /* @__PURE__ */ new Set([...Object.values(TOOL_NAMES), ...Object.values(AGENT_MEMORY_TOOL_NAMES)]);
+var SIGNATURE_WINDOW_MS = 5 * 60 * 1e3;
+function retell(options) {
+  const store = options.store ?? memoryCallStore();
+  const now = options.now ?? Date.now;
+  const logger = options.niadra.logger;
+  const readOptions = options.contextTimeout ? { timeout: options.contextTimeout } : {};
+  const transferred = /* @__PURE__ */ new Set();
+  const subjectOf = (call) => {
+    try {
+      if (options.subject) return options.subject(call) ?? null;
+      return phoneHandle(call.direction === "outbound" ? call.toNumber : call.fromNumber);
+    } catch {
+      return null;
+    }
+  };
+  const remember = async (id, record) => {
+    try {
+      await store.set(id, record);
+    } catch (error) {
+      logger.warn(`could not write the call store (${errorName(error)})`);
+    }
+  };
+  const recall = async (call) => {
+    try {
+      const stored = await store.get(call.id);
+      if (stored) return stored;
+    } catch (error) {
+      logger.warn(`could not read the call store (${errorName(error)})`);
+    }
+    const subject = subjectOf(call);
+    return subject ? { subject, verification: "V0" } : null;
+  };
+  const open = (id, record) => options.niadra.conversation({ subject: record.subject, channel: "voice", conversation_id: id, verification: record.verification });
+  const start = (call) => {
+    const subject = subjectOf(call);
+    if (!subject) return null;
+    const conversation = options.niadra.conversation({ subject, channel: "voice", conversation_id: call.id });
+    const bridge = new Bridge(conversation, options.verify ? () => options.verify?.(call) : void 0, options.agentMemory);
+    bridge.begin();
+    return { bridge, conversation };
+  };
+  const signed = async (text, headers) => validRetellSignature(text, header(headers, "x-retell-signature"), options.apiKey, now());
+  async function inbound(rawBody, headers) {
+    const text = bodyText(rawBody);
+    if (!await signed(text, headers)) return { status: 401, body: { error: "unauthorized" } };
+    const body = parseJson(text);
+    const data = isRecord(body) && isRecord(body.call_inbound) ? body.call_inbound : null;
+    if (!data) return { status: 400, body: { error: "invalid_body" } };
+    const call = callOf({ ...data, direction: "inbound" });
+    const variables = { niadra_context: "", niadra_turn: "" };
+    if (options.agentMemory) variables.niadra_agent_memory = "";
+    let extra = {};
+    try {
+      extra = call && options.inboundFields ? options.inboundFields(call) : {};
+    } catch (error) {
+      logger.warn(`could not build the inbound fields (${errorName(error)})`);
+    }
+    const answer = () => {
+      const own = isRecord(extra.dynamic_variables) ? extra.dynamic_variables : {};
+      return { status: 200, body: { call_inbound: { ...extra, dynamic_variables: { ...own, ...variables } } } };
+    };
+    const started = call ? start(call) : null;
+    if (!call || !started) return answer();
+    const read = await started.bridge.read(readOptions);
+    started.bridge.injected(read.context);
+    variables.niadra_context = read.context.text;
+    variables.niadra_turn = read.suffix;
+    if (options.agentMemory) variables.niadra_agent_memory = read.memory;
+    await remember(call.id, { subject: started.conversation.subject, verification: started.conversation.verification, stamp: started.conversation.contextStamp });
+    return answer();
+  }
+  async function webhook(rawBody, headers) {
+    const text = bodyText(rawBody);
+    if (!await signed(text, headers)) return { status: 401, body: { error: "unauthorized" } };
+    const body = parseJson(text);
+    const call = isRecord(body) ? callOf(body.call) : null;
+    if (!isRecord(body) || typeof body.event !== "string" || !call) return { status: 400, body: { error: "invalid_body" } };
+    switch (body.event) {
+      case "call_started":
+        return callStarted(call);
+      case "transfer_started":
+        await transfer(call);
+        return { status: 200, body: {} };
+      case "call_ended":
+        return callEnded(call);
+      default:
+        return { status: 200, body: { ignored: true } };
+    }
+  }
+  async function callStarted(call) {
+    try {
+      if (await store.get(call.id)) return { status: 200, body: {} };
+    } catch (error) {
+      logger.warn(`could not read the call store (${errorName(error)})`);
+    }
+    const started = start(call);
+    if (started) {
+      await started.bridge.context(readOptions);
+      await remember(call.id, { subject: started.conversation.subject, verification: started.conversation.verification, stamp: started.conversation.contextStamp });
+    }
+    return { status: 200, body: {} };
+  }
+  async function transfer(call) {
+    if (transferred.has(call.id)) return;
+    transferred.add(call.id);
+    if (transferred.size > 1e4) transferred.clear();
+    const record = await recall(call);
+    if (record) await new Bridge(open(call.id, record)).handoff("human", "transfer");
+  }
+  async function callEnded(call) {
+    const record = await recall(call);
+    if (!record) return { status: 200, body: { recorded: 0 } };
+    const bridge = new Bridge(open(call.id, record));
+    const started = typeof call.call.start_timestamp === "number" ? call.call.start_timestamp : null;
+    const utterances = Array.isArray(call.call.transcript_object) ? call.call.transcript_object : [];
+    let recorded = 0;
+    for (const [index, utterance] of utterances.entries()) {
+      if (recordUtterance(bridge, call.id, index, utterance, started, record)) recorded++;
+    }
+    if (call.call.disconnection_reason === "call_transfer") await transfer(call);
+    await bridge.end();
+    await options.niadra.flush();
+    return { status: 200, body: { recorded } };
+  }
+  async function tool(rawBody, headers) {
+    const text = bodyText(rawBody);
+    if (!await signed(text, headers)) return { status: 401, body: { error: "unauthorized" } };
+    const body = parseJson(text);
+    const call = isRecord(body) ? callOf(body.call) : null;
+    const name = isRecord(body) && typeof body.name === "string" ? body.name : "";
+    if (!isRecord(body) || !call || !name) return { status: 400, body: { error: "invalid_body" } };
+    const args = {};
+    if (isRecord(body.args)) Object.assign(args, body.args);
+    else for (const [key, value] of Object.entries(body)) if (key !== "name" && key !== "call") args[key] = value;
+    if (!OURS.has(name)) {
+      if (!options.otherTool) return { status: 200, body: { error: `unknown tool: ${name}` } };
+      try {
+        return { status: 200, body: await options.otherTool(name, args, call) ?? null };
+      } catch (error) {
+        logger.warn(`a tool outside Niadra failed (${errorName(error)})`);
+        return { status: 200, body: { error: "tool failed" } };
+      }
+    }
+    const record = await recall(call);
+    const spec = record ? new Bridge(open(call.id, record), void 0, options.agentMemory).tools().find((candidate) => candidate.name === name) : void 0;
+    if (!spec) return { status: 200, body: { error: "unavailable", detail: "customer history is unavailable right now" } };
+    return { status: 200, body: parseJson(await spec.execute(args)) ?? null };
+  }
+  function llm(callId, config) {
+    let bridge = null;
+    let record = null;
+    let recorded = 0;
+    const send = (event) => {
+      try {
+        config.send(event);
+      } catch (error) {
+        logger.warn(`could not send to Retell (${errorName(error)})`);
+      }
+    };
+    const ensure = async (call) => {
+      if (bridge) return bridge;
+      let stored;
+      try {
+        stored = await store.get(callId);
+      } catch (error) {
+        logger.warn(`could not read the call store (${errorName(error)})`);
+      }
+      if (stored) {
+        record = stored;
+        bridge = new Bridge(open(callId, stored), void 0, options.agentMemory);
+        bridge.begin();
+        return bridge;
+      }
+      const started = call && options.trustCallDetails ? start(call) : null;
+      if (!started) return null;
+      bridge = started.bridge;
+      await bridge.context(readOptions);
+      record = { subject: started.conversation.subject, verification: started.conversation.verification, stamp: started.conversation.contextStamp };
+      await remember(callId, record);
+      return bridge;
+    };
+    async function receive(event) {
+      try {
+        if (!isRecord(event) || typeof event.interaction_type !== "string") return null;
+        switch (event.interaction_type) {
+          case "ping_pong":
+            send({ response_type: "ping_pong", timestamp: event.timestamp });
+            return null;
+          case "call_details":
+            await ensure(callOf(event.call));
+            return null;
+          case "update_only":
+            await prefetchFor(event);
+            return null;
+          case "response_required":
+          case "reminder_required":
+            return await turnFor(event, event.interaction_type);
+          default:
+            return null;
+        }
+      } catch (error) {
+        logger.warn(`could not handle a Retell event (${errorName(error)})`);
+        return null;
+      }
+    }
+    async function prefetchFor(event) {
+      const transcript = Array.isArray(event.transcript) ? event.transcript : [];
+      const last = transcript[transcript.length - 1];
+      if (!isRecord(last) || last.role !== "user" || typeof last.content !== "string") return;
+      const current = await ensure(null);
+      current?.prefetch(last.content);
+    }
+    async function turnFor(event, interactionType) {
+      const responseId = typeof event.response_id === "number" ? event.response_id : 0;
+      const transcript = Array.isArray(event.transcript) ? event.transcript : [];
+      const current = await ensure(null);
+      let prefix = "";
+      let suffix = "";
+      let context = "";
+      if (current) {
+        for (let index = recorded; index < transcript.length; index++) {
+          recordUtterance(current, callId, index, transcript[index], null, record);
+        }
+        recorded = Math.max(recorded, transcript.length);
+        const read = await current.read(readOptions);
+        current.injected(read.context);
+        ({ prefix, suffix } = read);
+        context = read.context.text;
+      }
+      const messages = [];
+      if (config.instructions) messages.push({ role: "system", content: config.instructions });
+      if (prefix) messages.push({ role: "system", content: prefix });
+      for (const utterance of transcript) {
+        if (!isRecord(utterance) || typeof utterance.content !== "string") continue;
+        if (utterance.role === "user") messages.push({ role: "user", content: utterance.content });
+        else if (utterance.role === "agent") messages.push({ role: "assistant", content: utterance.content });
+      }
+      if (suffix) {
+        const last = messages.map((message2) => message2.role).lastIndexOf("user");
+        const message = messages[last];
+        if (message) messages[last] = { role: "user", content: `${message.content}
+
+${suffix}` };
+        else messages.push({ role: "user", content: suffix });
+      }
+      return {
+        responseId,
+        interactionType,
+        messages,
+        context,
+        suffix,
+        respond(content, respondOptions = {}) {
+          const response = {
+            response_type: "response",
+            response_id: responseId,
+            content,
+            content_complete: respondOptions.complete ?? true
+          };
+          if (respondOptions.endCall) response.end_call = true;
+          if (respondOptions.transferNumber) {
+            response.transfer_number = respondOptions.transferNumber;
+            void transferOnce();
+          }
+          send(response);
+        }
+      };
+    }
+    async function transferOnce() {
+      if (transferred.has(callId)) return;
+      transferred.add(callId);
+      await bridge?.handoff("human", "transfer");
+    }
+    return {
+      open(greeting) {
+        send({ response_type: "config", config: { auto_reconnect: true, call_details: true } });
+        if (greeting) send({ response_type: "response", response_id: 0, content: greeting, content_complete: true });
+      },
+      receive,
+      async close() {
+        try {
+          await options.niadra.flush();
+        } catch (error) {
+          logger.warn(`could not flush (${errorName(error)})`);
+        }
+      }
+    };
+  }
+  function toolConfigs(config) {
+    const memory = options.agentMemory;
+    const definitions = [
+      ...TOOL_DEFINITIONS,
+      ...memory ? AGENT_MEMORY_TOOL_DEFINITIONS.slice(0, memory !== true && memory.write ? 2 : 1) : []
+    ];
+    return definitions.map(({ function: definition }) => ({
+      type: "custom",
+      name: definition.name,
+      description: definition.description,
+      url: config.url,
+      method: "POST",
+      parameters: definition.parameters,
+      speak_during_execution: false,
+      speak_after_execution: true,
+      timeout_ms: config.timeoutMs ?? 1e4
+    }));
+  }
+  return { inbound, webhook, tool, llm, toolConfigs };
+}
+async function validRetellSignature(body, signature, apiKey, now = Date.now()) {
+  if (!signature || !apiKey) return false;
+  const match = /^v=(\d+),d=([0-9a-f]{64})$/i.exec(signature.trim());
+  if (!match) return false;
+  const [, stamp = "", digest = ""] = match;
+  if (Math.abs(now - Number(stamp)) > SIGNATURE_WINDOW_MS) return false;
+  return safeEqual(digest.toLowerCase(), hex(await hmac("SHA-256", apiKey, body + stamp)));
+}
+function recordUtterance(bridge, callId, index, utterance, started, record) {
+  if (!isRecord(utterance) || typeof utterance.content !== "string" || !utterance.content.trim()) return false;
+  const words = Array.isArray(utterance.words) ? utterance.words : [];
+  const first = isRecord(words[0]) && typeof words[0].start === "number" ? words[0].start : null;
+  const at = started !== null && first !== null ? new Date(started + first * 1e3) : void 0;
+  const base = { idempotency_key: `retell:${callId}:${String(index)}`, ...at ? { occurred_at: at } : {} };
+  if (utterance.role === "user") {
+    bridge.customer(utterance.content, base);
+    return true;
+  }
+  if (utterance.role === "agent") {
+    bridge.agent(utterance.content, record?.stamp ? { ...base, context_stamp: record.stamp } : base);
+    return true;
+  }
+  return false;
+}
+function callOf(value) {
+  if (!isRecord(value) || typeof value.call_id !== "string" || !value.call_id) return null;
+  const text = (key) => {
+    const field = value[key];
+    return typeof field === "string" && field ? field : void 0;
+  };
+  return {
+    id: value.call_id,
+    fromNumber: text("from_number"),
+    toNumber: text("to_number"),
+    direction: text("direction"),
+    agentId: text("agent_id"),
+    call: value
+  };
+}
+
+exports.attestationProof = attestationProof;
+exports.memoryCallStore = memoryCallStore;
+exports.retell = retell;
+exports.validRetellSignature = validRetellSignature;
+//# sourceMappingURL=retell.cjs.map
+//# sourceMappingURL=retell.cjs.map