@dialgem/sdk 0.1.0-beta.0

package/dist/index.cjs

@@ -0,0 +1,712 @@
+'use strict';
+
+// src/core/errors.ts
+var DialgemError = class extends Error {
+  name = "DialgemError";
+};
+var APIError = class extends DialgemError {
+  name = "APIError";
+  /** HTTP status code. */
+  status;
+  /** The service's `err_code`, e.g. `flow_invalid` or `HTTP_404`. Undefined if the body was not the envelope. */
+  errCode;
+  /** The service's `request_id`. Quote it when contacting support. */
+  requestId;
+  /** Field/graph diagnostics, present on validation failures. */
+  issues;
+  /** Parsed JSON body, or the raw text if the body was not JSON. */
+  body;
+  headers;
+  constructor(status, body, message, headers) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.headers = headers;
+    const envelope = isErrorBody(body) ? body : void 0;
+    this.errCode = envelope?.err_code;
+    this.requestId = envelope?.request_id ?? headers.get("x-request-id") ?? void 0;
+    this.issues = envelope?.issues ?? [];
+  }
+  /** Build the subclass matching `status`. */
+  static from(status, body, statusText, headers) {
+    const envelope = isErrorBody(body) ? body : void 0;
+    const detail = envelope?.err_msg || (typeof body === "string" && body.trim() ? body.trim().slice(0, 500) : "");
+    const message = detail ? `${status} ${detail}` : `${status} ${statusText || "status code (no body)"}`;
+    const Ctor = errorClassFor(status);
+    return new Ctor(status, body, message, headers);
+  }
+};
+var BadRequestError = class extends APIError {
+  name = "BadRequestError";
+};
+var AuthenticationError = class extends APIError {
+  name = "AuthenticationError";
+};
+var PermissionDeniedError = class extends APIError {
+  name = "PermissionDeniedError";
+};
+var NotFoundError = class extends APIError {
+  name = "NotFoundError";
+};
+var ConflictError = class extends APIError {
+  name = "ConflictError";
+};
+var UnprocessableEntityError = class extends APIError {
+  name = "UnprocessableEntityError";
+};
+var RateLimitError = class extends APIError {
+  name = "RateLimitError";
+};
+var InternalServerError = class extends APIError {
+  name = "InternalServerError";
+};
+var APIConnectionError = class extends DialgemError {
+  name = "APIConnectionError";
+  constructor(message = "Connection error.", options) {
+    super(message, options);
+  }
+};
+var APIUserAbortError = class extends DialgemError {
+  name = "APIUserAbortError";
+  constructor(message = "Request was aborted.") {
+    super(message);
+  }
+};
+var APIConnectionTimeoutError = class extends APIConnectionError {
+  name = "APIConnectionTimeoutError";
+  constructor(message = "Request timed out.") {
+    super(message);
+  }
+};
+var WebhookVerificationError = class extends DialgemError {
+  name = "WebhookVerificationError";
+};
+function errorClassFor(status) {
+  switch (status) {
+    case 400:
+      return BadRequestError;
+    case 401:
+      return AuthenticationError;
+    case 403:
+      return PermissionDeniedError;
+    case 404:
+      return NotFoundError;
+    case 409:
+      return ConflictError;
+    case 422:
+      return UnprocessableEntityError;
+    case 429:
+      return RateLimitError;
+    default:
+      return status >= 500 ? InternalServerError : APIError;
+  }
+}
+function isErrorBody(body) {
+  return typeof body === "object" && body !== null && typeof body.err_code === "string";
+}
+
+// src/version.ts
+var VERSION = "0.1.0-beta.0";
+
+// src/core/http.ts
+var RETRYABLE_METHODS = /* @__PURE__ */ new Set(["GET", "PATCH", "DELETE"]);
+var MAX_RETRY_DELAY_MS = 6e4;
+var HttpClient = class {
+  baseURL;
+  #apiKey;
+  #timeout;
+  #maxRetries;
+  #fetch;
+  #defaultHeaders;
+  constructor(options) {
+    this.baseURL = options.baseURL.replace(/\/+$/, "");
+    this.#apiKey = options.apiKey;
+    this.#timeout = options.timeout;
+    this.#maxRetries = options.maxRetries;
+    this.#fetch = options.fetch;
+    this.#defaultHeaders = options.defaultHeaders;
+  }
+  get(path2, query, options) {
+    return this.request("GET", path2, { query, options });
+  }
+  post(path2, body, options) {
+    return this.request("POST", path2, { body, options });
+  }
+  patch(path2, body, options) {
+    return this.request("PATCH", path2, { body, options });
+  }
+  delete(path2, options) {
+    return this.request("DELETE", path2, { options });
+  }
+  async request(method, path2, { query, body, options = {} }) {
+    const url = this.buildURL(path2, query);
+    const headers = this.buildHeaders(body !== void 0, options.headers);
+    const payload = body === void 0 ? void 0 : JSON.stringify(body);
+    const timeout = options.timeout ?? this.#timeout;
+    const maxRetries = options.maxRetries ?? (RETRYABLE_METHODS.has(method) ? this.#maxRetries : 0);
+    assertTimeout(timeout);
+    assertMaxRetries(maxRetries);
+    for (let attempt = 0; ; attempt++) {
+      const retriesLeft = maxRetries - attempt;
+      if (options.signal?.aborted) throw new APIUserAbortError();
+      const outcome = await this.#attempt(url, method, headers, payload, timeout, options.signal);
+      if (outcome.kind === "response") {
+        const { status, statusText, headers: responseHeaders, text } = outcome;
+        if (status >= 200 && status < 300) return parseSuccess(text, status);
+        if (retriesLeft > 0 && isRetryableStatus(status)) {
+          await sleep(retryAfterMs(responseHeaders) ?? backoffMs(attempt), options.signal);
+          continue;
+        }
+        throw APIError.from(status, parseErrorBody(text), statusText, responseHeaders);
+      }
+      if (options.signal?.aborted) throw new APIUserAbortError();
+      if (retriesLeft > 0) {
+        await sleep(backoffMs(attempt), options.signal);
+        continue;
+      }
+      throw outcome.error;
+    }
+  }
+  /** One HTTP attempt, with its own timeout. Never throws; timers and listeners are released before it returns. */
+  async #attempt(url, method, headers, payload, timeout, signal) {
+    const controller = new AbortController();
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeout);
+    const onUserAbort = () => controller.abort();
+    signal?.addEventListener("abort", onUserAbort, { once: true });
+    try {
+      const init = { method, headers, signal: controller.signal, redirect: "manual" };
+      if (payload !== void 0) init.body = payload;
+      const response = await this.#fetch(url, init);
+      const text = await response.text();
+      return { kind: "response", status: response.status, statusText: response.statusText, headers: response.headers, text };
+    } catch (err) {
+      const error = timedOut ? new APIConnectionTimeoutError(`Request timed out after ${timeout}ms.`) : new APIConnectionError(`Connection error: ${describe(err)}`, { cause: err });
+      return { kind: "failure", error };
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onUserAbort);
+    }
+  }
+  buildURL(path2, query) {
+    const url = `${this.baseURL}${path2.startsWith("/") ? path2 : `/${path2}`}`;
+    if (!query) return url;
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+      if (value === void 0 || value === null) continue;
+      params.append(key, String(value));
+    }
+    const qs = params.toString();
+    return qs ? `${url}?${qs}` : url;
+  }
+  buildHeaders(hasBody, extra) {
+    const merged = /* @__PURE__ */ new Map();
+    const layer = (headers) => {
+      for (const [name, value] of Object.entries(headers ?? {})) merged.set(name.toLowerCase(), [name, value]);
+    };
+    layer({
+      Accept: "application/json",
+      // `X-API-Key`, not `Authorization: Bearer`: the API only tries a
+      // Bearer value as a session JWT, so an org key sent that way is a 401.
+      "X-API-Key": this.#apiKey,
+      "User-Agent": userAgent()
+    });
+    layer(this.#defaultHeaders);
+    layer(extra);
+    if (hasBody) layer({ "Content-Type": "application/json" });
+    return Object.fromEntries(merged.values());
+  }
+};
+function assertTimeout(value) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new DialgemError(`\`timeout\` must be a positive integer of milliseconds, got ${String(value)}.`);
+  }
+}
+function assertMaxRetries(value) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new DialgemError(`\`maxRetries\` must be a non-negative integer, got ${String(value)}.`);
+  }
+}
+function parseSuccess(text, status) {
+  if (status === 204 || text.trim() === "") return void 0;
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    throw new DialgemError(`Expected a JSON response (status ${status}) but could not parse it: ${describe(err)}`);
+  }
+}
+function parseErrorBody(text) {
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function isRetryableStatus(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+function backoffMs(attempt) {
+  const base = Math.min(500 * 2 ** attempt, 8e3);
+  return base * (1 - Math.random() * 0.25);
+}
+function retryAfterMs(headers) {
+  const ms = Number(headers.get("retry-after-ms"));
+  if (Number.isFinite(ms) && ms > 0) return Math.min(ms, MAX_RETRY_DELAY_MS);
+  const raw = headers.get("retry-after");
+  if (!raw) return void 0;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds) && seconds >= 0) return Math.min(seconds * 1e3, MAX_RETRY_DELAY_MS);
+  const date = Date.parse(raw);
+  if (Number.isFinite(date)) return Math.min(Math.max(date - Date.now(), 0), MAX_RETRY_DELAY_MS);
+  return void 0;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(new APIUserAbortError());
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new APIUserAbortError());
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function userAgent() {
+  const proc = globalThis.process;
+  return proc?.version ? `dialgem-sdk-node/${VERSION} node/${proc.version}` : `dialgem-sdk-node/${VERSION}`;
+}
+function describe(err) {
+  if (err instanceof Error) {
+    const cause = err.cause;
+    return cause instanceof Error ? `${err.message} (${cause.message})` : err.message;
+  }
+  return String(err);
+}
+
+// src/resources/resource.ts
+var APIResource = class {
+  _client;
+  constructor(client) {
+    this._client = client;
+  }
+};
+function path(strings, ...ids) {
+  let out = strings[0] ?? "";
+  ids.forEach((id, i) => {
+    if (typeof id !== "string" || id.trim() === "") {
+      throw new DialgemError(`Expected a non-empty id in ${strings.join("{id}")}, got ${JSON.stringify(id)}.`);
+    }
+    out += encodeURIComponent(id) + (strings[i + 1] ?? "");
+  });
+  return out;
+}
+
+// src/resources/agents.ts
+var Agents = class extends APIResource {
+  /** Tools (HTTP functions and built-ins like `end_call`) the agent can call. */
+  functions;
+  /** Text documents the agent retrieves from during the call. */
+  knowledge;
+  /** Remote MCP servers whose tools are exposed to the agent. */
+  mcpServers;
+  constructor(client) {
+    super(client);
+    this.functions = new AgentFunctions(client);
+    this.knowledge = new AgentKnowledge(client);
+    this.mcpServers = new AgentMCPServers(client);
+  }
+  /** Create an agent. Only `name` is required; everything else has a server default. */
+  create(body, options) {
+    return this._client.post("/v1/agents", body, options);
+  }
+  retrieve(agentId, options) {
+    return this._client.get(path`/v1/agents/${agentId}`, void 0, options);
+  }
+  /** Every agent in the organization. `webhook_signing_secret` is `null` in this list. */
+  list(options) {
+    return this._client.get("/v1/agents", void 0, options);
+  }
+  /** Partial update: only the fields you send change. */
+  update(agentId, body, options) {
+    return this._client.patch(path`/v1/agents/${agentId}`, body, options);
+  }
+  delete(agentId, options) {
+    return this._client.delete(path`/v1/agents/${agentId}`, options);
+  }
+};
+var AgentFunctions = class extends APIResource {
+  list(agentId, options) {
+    return this._client.get(path`/v1/agents/${agentId}/functions`, void 0, options);
+  }
+  create(agentId, body, options) {
+    return this._client.post(path`/v1/agents/${agentId}/functions`, body, options);
+  }
+  update(agentId, functionId, body, options) {
+    return this._client.patch(path`/v1/agents/${agentId}/functions/${functionId}`, body, options);
+  }
+  delete(agentId, functionId, options) {
+    return this._client.delete(path`/v1/agents/${agentId}/functions/${functionId}`, options);
+  }
+  /** Set the order functions are offered to the LLM. `order` is function ids, first to last. */
+  reorder(agentId, body, options) {
+    return this._client.post(path`/v1/agents/${agentId}/functions/reorder`, body, options);
+  }
+};
+var AgentKnowledge = class extends APIResource {
+  list(agentId, options) {
+    return this._client.get(path`/v1/agents/${agentId}/knowledge`, void 0, options);
+  }
+  /** Add a plain-text document (up to 500,000 characters). It is chunked and embedded server-side. */
+  create(agentId, body, options) {
+    return this._client.post(path`/v1/agents/${agentId}/knowledge`, body, options);
+  }
+  delete(agentId, sourceId, options) {
+    return this._client.delete(path`/v1/agents/${agentId}/knowledge/${sourceId}`, options);
+  }
+};
+var AgentMCPServers = class extends APIResource {
+  list(agentId, options) {
+    return this._client.get(path`/v1/agents/${agentId}/mcp-servers`, void 0, options);
+  }
+  create(agentId, body, options) {
+    return this._client.post(path`/v1/agents/${agentId}/mcp-servers`, body, options);
+  }
+  update(agentId, serverId, body, options) {
+    return this._client.patch(path`/v1/agents/${agentId}/mcp-servers/${serverId}`, body, options);
+  }
+  delete(agentId, serverId, options) {
+    return this._client.delete(path`/v1/agents/${agentId}/mcp-servers/${serverId}`, options);
+  }
+  /** Connect to the server now, list its tools, and store the result as `last_status`. */
+  test(agentId, serverId, options) {
+    return this._client.post(path`/v1/agents/${agentId}/mcp-servers/${serverId}/test`, void 0, options);
+  }
+};
+
+// src/core/pagination.ts
+var Page = class _Page {
+  data;
+  total;
+  page;
+  page_size;
+  #fetchPage;
+  constructor(data, fetchPage) {
+    this.data = data.data;
+    this.total = data.total;
+    this.page = data.page;
+    this.page_size = data.page_size;
+    this.#fetchPage = fetchPage;
+  }
+  hasNextPage() {
+    return this.data.length > 0 && this.page * this.page_size < this.total;
+  }
+  async getNextPage() {
+    if (!this.hasNextPage()) throw new DialgemError("No next page; check hasNextPage() first.");
+    return new _Page(await this.#fetchPage(this.page + 1), this.#fetchPage);
+  }
+};
+var PagePromise = class {
+  #fetchPage;
+  #startPage;
+  #first;
+  constructor(fetchPage, startPage) {
+    this.#fetchPage = fetchPage;
+    this.#startPage = startPage;
+  }
+  #firstPage() {
+    this.#first ??= this.#fetchPage(this.#startPage).then((data) => new Page(data, this.#fetchPage));
+    return this.#first;
+  }
+  then(onfulfilled, onrejected) {
+    return this.#firstPage().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.#firstPage().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.#firstPage().finally(onfinally);
+  }
+  async *[Symbol.asyncIterator]() {
+    let page = await this.#firstPage();
+    for (; ; ) {
+      yield* page.data;
+      if (!page.hasNextPage()) return;
+      page = await page.getNextPage();
+    }
+  }
+};
+
+// src/resources/calls.ts
+var Calls = class extends APIResource {
+  /**
+   * Calls, newest first. Await for one page, or iterate for every call:
+   *
+   *   const page = await dialgem.calls.list({ page_size: 50 })
+   *   for await (const call of dialgem.calls.list({ status: "completed" })) {
+   *     if (call.started_at < cutoff) break // newest first: everything after is older
+   *   }
+   */
+  list(params = {}, options) {
+    const fetchPage = async (page) => {
+      const res = await this._client.get("/v1/calls", { ...params, page }, options);
+      return { data: res.calls, total: res.total, page: res.page, page_size: res.page_size };
+    };
+    return new PagePromise(fetchPage, params.page ?? 1);
+  }
+  /** One call, including its transcript, analysis and recording URL. */
+  retrieve(callId, options) {
+    return this._client.get(path`/v1/calls/${callId}`, void 0, options);
+  }
+  /**
+   * Dial `to` from one of your organization's numbers, with `agent_id` (or the
+   * number's outbound agent) on the line.
+   *
+   * Not retried by default: a retry after an ambiguous failure can place a
+   * second call. Follow progress through webhooks or `retrieve(call_id)`.
+   */
+  createPhoneCall(body, options) {
+    return this._client.post("/v1/calls/outbound", body, options);
+  }
+  /**
+   * Bring-your-own-Twilio: call this from your Twilio voice webhook, then answer
+   * Twilio with `<Response><Connect><Stream url="{stream_url}"/></Connect></Response>`.
+   * No Twilio credentials are shared with Dialgem.
+   */
+  register(body, options) {
+    return this._client.post("/v1/calls/register", body, options);
+  }
+};
+
+// src/resources/catalog.ts
+var Voices = class extends APIResource {
+  /** Voices available to agents, by name. Put a voice's `provider_voice_id` in an agent's `voice_id`. */
+  list(params = {}, options) {
+    return this._client.get("/v1/voices", params, options);
+  }
+};
+var FlowTemplates = class extends APIResource {
+  /** Built-in conversation-flow templates (summaries, without `flow_config`). */
+  list(params = {}, options) {
+    return this._client.get("/v1/flow-templates", params, options);
+  }
+  retrieve(templateId, options) {
+    return this._client.get(path`/v1/flow-templates/${templateId}`, void 0, options);
+  }
+};
+var PromptTemplates = class extends APIResource {
+  /** Built-in prompt templates (summaries, without the prompt text). */
+  list(params = {}, options) {
+    return this._client.get("/v1/prompt-templates", params, options);
+  }
+  retrieve(templateId, options) {
+    return this._client.get(path`/v1/prompt-templates/${templateId}`, void 0, options);
+  }
+};
+
+// src/resources/phone-numbers.ts
+var PhoneNumbers = class extends APIResource {
+  /** Register a number you own (`phone_number` in E.164) with Dialgem. */
+  create(body, options) {
+    return this._client.post("/v1/phone-numbers", body, options);
+  }
+  /** Every active (not released) number in the organization, newest first. */
+  list(options) {
+    return this._client.get("/v1/phone-numbers", void 0, options);
+  }
+  /**
+   * Partial update.
+   *
+   * `inbound_agent_id` is **ignored unless `set_inbound_agent: true`** is sent with
+   * it, both to set an agent and to clear one (`null`). Same for the outbound pair.
+   * `inbound_agents` / `outbound_agents` (weighted routing), when sent, take
+   * precedence over the single-agent fields.
+   */
+  update(phoneNumberId, body, options) {
+    return this._client.patch(path`/v1/phone-numbers/${phoneNumberId}`, body, options);
+  }
+  /** Set the number's **inbound** agent, or pass `agent_id: null` to clear it. For outbound, use `update`. */
+  assign(phoneNumberId, body, options) {
+    return this._client.patch(path`/v1/phone-numbers/${phoneNumberId}/assign`, body, options);
+  }
+  /** Release the number from Dialgem. It stops routing calls and disappears from `list()`; your carrier account is untouched. */
+  delete(phoneNumberId, options) {
+    return this._client.delete(path`/v1/phone-numbers/${phoneNumberId}`, options);
+  }
+};
+
+// src/webhooks.ts
+var WEBHOOK_SIGNATURE_HEADER = "x-dialgem-signature";
+var WEBHOOK_EVENT_HEADER = "x-dialgem-event";
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var Webhooks = class {
+  /**
+   * Returns whether `signature` is the HMAC-SHA256 of `payload` under `secret`.
+   * Constant-time. Returns `false` for a missing or malformed signature; throws only
+   * if `secret` is empty, which is a configuration error rather than a bad request.
+   */
+  async verify(payload, signature, secret) {
+    if (!secret) {
+      throw new DialgemError(
+        "Webhook secret is empty. Set the agent's `webhook_signing_secret` and pass the same value here."
+      );
+    }
+    const received = firstHeader(signature)?.trim().toLowerCase();
+    if (!received || !/^[0-9a-f]{64}$/.test(received)) return false;
+    const expected = await hmacSha256Hex(secret, toBytes(payload));
+    return timingSafeEqual(expected, received);
+  }
+  /**
+   * Verifies the signature, then parses the body.
+   *
+   * @throws WebhookVerificationError if the signature is missing or does not match.
+   */
+  async constructEvent(payload, signature, secret) {
+    if (!firstHeader(signature)) {
+      throw new WebhookVerificationError(
+        `Missing ${WEBHOOK_SIGNATURE_HEADER} header. Is a webhook_signing_secret set on the agent?`
+      );
+    }
+    if (!await this.verify(payload, signature, secret)) {
+      throw new WebhookVerificationError(
+        "Webhook signature does not match the body. Check the secret, and that the body was not re-serialized before verification."
+      );
+    }
+    const text = typeof payload === "string" ? payload : decoder.decode(toBytes(payload));
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      throw new WebhookVerificationError("Webhook body is signed but is not valid JSON.");
+    }
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.event !== "string") {
+      throw new WebhookVerificationError("Webhook body has no `event` field.");
+    }
+    return parsed;
+  }
+};
+var webhooks = new Webhooks();
+function firstHeader(value) {
+  const v = Array.isArray(value) ? value[0] : value;
+  return v ?? void 0;
+}
+function toBytes(payload) {
+  if (typeof payload === "string") return encoder.encode(payload);
+  if (payload instanceof Uint8Array) return payload;
+  return new Uint8Array(payload);
+}
+async function hmacSha256Hex(secret, data) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) {
+    throw new DialgemError("Web Crypto (globalThis.crypto.subtle) is unavailable. Node 20 or newer is required.");
+  }
+  const key = await subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  const signature = await subtle.sign("HMAC", key, new Uint8Array(data));
+  return Array.from(new Uint8Array(signature), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.dialgem.com";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var DEFAULT_MAX_RETRIES = 2;
+var Dialgem = class {
+  static DEFAULT_BASE_URL = DEFAULT_BASE_URL;
+  /** Webhook verification without a client instance: `Dialgem.webhooks.constructEvent(...)`. */
+  static webhooks = webhooks;
+  agents;
+  calls;
+  phoneNumbers;
+  voices;
+  flowTemplates;
+  promptTemplates;
+  webhooks = webhooks;
+  baseURL;
+  constructor(options = {}) {
+    if (isBrowser() && !options.dangerouslyAllowBrowser) {
+      throw new DialgemError(
+        "The Dialgem SDK is for server-side use: running it in a browser exposes your API key to every visitor. Call Dialgem from your backend instead, or pass `dangerouslyAllowBrowser: true` if you understand the risk."
+      );
+    }
+    const apiKey = options.apiKey ?? readEnv("DIALGEM_API_KEY");
+    if (!apiKey) {
+      throw new DialgemError(
+        "Missing API key. Pass `apiKey` to `new Dialgem({ apiKey })` or set the DIALGEM_API_KEY environment variable."
+      );
+    }
+    const timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+    const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    assertTimeout(timeout);
+    assertMaxRetries(maxRetries);
+    const fetchImpl = options.fetch ?? defaultFetch();
+    this.baseURL = (options.baseURL ?? readEnv("DIALGEM_BASE_URL") ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    const http = new HttpClient({
+      apiKey,
+      baseURL: this.baseURL,
+      timeout,
+      maxRetries,
+      fetch: fetchImpl,
+      defaultHeaders: options.defaultHeaders ?? {}
+    });
+    this.agents = new Agents(http);
+    this.calls = new Calls(http);
+    this.phoneNumbers = new PhoneNumbers(http);
+    this.voices = new Voices(http);
+    this.flowTemplates = new FlowTemplates(http);
+    this.promptTemplates = new PromptTemplates(http);
+  }
+};
+function readEnv(name) {
+  const proc = globalThis.process;
+  const value = proc?.env?.[name]?.trim();
+  return value ? value : void 0;
+}
+function isBrowser() {
+  const g = globalThis;
+  return typeof g.window !== "undefined" && typeof g.document !== "undefined";
+}
+function defaultFetch() {
+  const f = globalThis.fetch;
+  if (typeof f !== "function") {
+    throw new DialgemError("No global `fetch` found. Use Node 20 or newer, or pass `fetch` in the client options.");
+  }
+  return (url, init) => f.call(globalThis, url, init);
+}
+
+exports.APIConnectionError = APIConnectionError;
+exports.APIConnectionTimeoutError = APIConnectionTimeoutError;
+exports.APIError = APIError;
+exports.APIUserAbortError = APIUserAbortError;
+exports.AuthenticationError = AuthenticationError;
+exports.BadRequestError = BadRequestError;
+exports.ConflictError = ConflictError;
+exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
+exports.Dialgem = Dialgem;
+exports.DialgemError = DialgemError;
+exports.InternalServerError = InternalServerError;
+exports.NotFoundError = NotFoundError;
+exports.Page = Page;
+exports.PagePromise = PagePromise;
+exports.PermissionDeniedError = PermissionDeniedError;
+exports.RateLimitError = RateLimitError;
+exports.UnprocessableEntityError = UnprocessableEntityError;
+exports.VERSION = VERSION;
+exports.WEBHOOK_EVENT_HEADER = WEBHOOK_EVENT_HEADER;
+exports.WEBHOOK_SIGNATURE_HEADER = WEBHOOK_SIGNATURE_HEADER;
+exports.WebhookVerificationError = WebhookVerificationError;
+exports.Webhooks = Webhooks;
+exports.webhooks = webhooks;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map