@getsupervisor/agents-studio-sdk 1.41.0-patch.4 → 1.41.1-beta.162

package/dist/index.cjs

@@ -43,12 +43,17 @@ __export(index_exports, {
   createAgentVersionsApi: () => createAgentVersionsApi,
   createAgentsApi: () => createAgentsApi,
   createApiKeysApi: () => createApiKeysApi,
+  createBillingApi: () => createBillingApi,
+  createCallsApi: () => createCallsApi,
   createCampaignsApi: () => createCampaignsApi,
   createCatalogTemplatesApi: () => createCatalogTemplatesApi,
   createCatalogsApi: () => createCatalogsApi,
   createClient: () => createClient,
+  createDocumentsApi: () => createDocumentsApi,
   createHttp: () => createHttp,
+  createSipTrunksApi: () => createSipTrunksApi,
   createToolsApi: () => createToolsApi,
+  createUsageApi: () => createUsageApi,
   createVoicesApi: () => createVoicesApi,
   createWebhooksApi: () => createWebhooksApi,
   createWorkspacesApi: () => createWorkspacesApi,
@@ -238,7 +243,8 @@ function createHttp(cfg) {
         }
         return res;
       } catch (e) {
-        if (e.name === "AbortError") throw new TimeoutError(timeout, targetUrl);
+        if (e?.name === "AbortError")
+          throw new TimeoutError(timeout, targetUrl);
         if (e instanceof HttpError) throw e;
         throw new NetworkError(e, targetUrl);
       }
@@ -259,6 +265,11 @@ function createHttp(cfg) {
 }
 
 // src/utils/query.ts
+function buildSearchParams(entries) {
+  const searchParams = new URLSearchParams();
+  entries.forEach(([key, value]) => appendParam(searchParams, key, value));
+  return searchParams;
+}
 function serializeListOptions(options = {}, extra = {}) {
   const params = new URLSearchParams();
   appendParam(params, "page", options.page);
@@ -944,6 +955,117 @@ function createAgentVersionsApi(cfg) {
   };
 }
 
+// src/utils/sse-stream.ts
+function extractField(line, prefix) {
+  if (!line.startsWith(prefix)) {
+    return null;
+  }
+  return line.slice(prefix.length);
+}
+function parseSseMessage(raw) {
+  let type = "";
+  let data = "";
+  for (const line of raw.split("\n")) {
+    type = extractField(line, "event: ") ?? type;
+    data = extractField(line, "data: ") ?? data;
+  }
+  if (!type || !data) {
+    return null;
+  }
+  return { type, data };
+}
+function dispatchSseEvent(event, handlers) {
+  const handler = handlers[event.type];
+  if (!handler) {
+    return;
+  }
+  try {
+    const parsed = JSON.parse(event.data);
+    handler(parsed);
+    return parsed;
+  } catch {
+    return;
+  }
+}
+function processRawPart(raw, handlers, resolveEvent) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return;
+  }
+  const event = parseSseMessage(trimmed);
+  if (!event) {
+    return;
+  }
+  const result = dispatchSseEvent(event, handlers);
+  if (event.type !== resolveEvent) {
+    return;
+  }
+  return result;
+}
+function flushRemainingBuffer(buffer) {
+  if (!buffer.trim()) {
+    return "";
+  }
+  return buffer + "\n\n";
+}
+function consumeSseStream(response, handlers, resolveEvent, options = {}) {
+  if (!response.body) {
+    throw new Error("No response body for SSE stream");
+  }
+  return new Promise((resolve, reject) => {
+    let resolved;
+    let settled = false;
+    let buffer = "";
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    const processBuffer = () => {
+      const parts = buffer.split("\n\n");
+      buffer = parts.pop() ?? "";
+      for (const part of parts) {
+        const result = processRawPart(part, handlers, resolveEvent);
+        if (result) {
+          resolved = result;
+        }
+      }
+    };
+    const tryResolveImmediately = () => {
+      if (!options.resolveImmediately || resolved === void 0 || settled) {
+        return false;
+      }
+      settled = true;
+      resolve(resolved);
+      reader.cancel().catch(() => void 0);
+      return true;
+    };
+    const finalize = () => {
+      if (settled) return;
+      buffer = flushRemainingBuffer(buffer);
+      processBuffer();
+      if (resolved) {
+        resolve(resolved);
+        return;
+      }
+      reject(new Error(`SSE stream ended without '${resolveEvent}' event`));
+    };
+    const read = () => {
+      if (settled) return;
+      reader.read().then(({ done, value }) => {
+        if (done) {
+          finalize();
+          return;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        processBuffer();
+        if (tryResolveImmediately()) {
+          return;
+        }
+        read();
+      }).catch(reject);
+    };
+    read();
+  });
+}
+
 // src/entities/agent.ts
 var bindAgentStageTriggers = (api, agentId, blueprintId, stageId) => ({
   list(opts) {
@@ -1130,7 +1252,8 @@ var createAgentEntity = (dto, options) => {
     stageTriggersApi,
     reload,
     updateAgent,
-    deleteAgent
+    deleteAgent,
+    cloneAgent
   } = options;
   const schedulesHelper = bindAgentSchedules(
     scheduleApi,
@@ -1149,6 +1272,9 @@ var createAgentEntity = (dto, options) => {
     async save(patch) {
       return updateAgent(dto.agentId, patch);
     },
+    async clone(payload) {
+      return cloneAgent(dto.agentId, payload);
+    },
     async delete() {
       await deleteAgent(dto.agentId);
     },
@@ -1160,8 +1286,38 @@ var createAgentEntity = (dto, options) => {
 };
 
 // src/api/agents.ts
+function normalizeCloneSelection(selection) {
+  if (!selection) {
+    return [];
+  }
+  if (Array.isArray(selection)) {
+    return selection;
+  }
+  return Object.entries(selection).filter(([, enabled]) => enabled).map(([component]) => component);
+}
+function buildCloneRequest(payload) {
+  const { clone, ...rest } = payload;
+  return { ...rest, clone: normalizeCloneSelection(clone) };
+}
+function buildSseHandlers(callbacks) {
+  const onAgent = (data) => callbacks.onAgentCreated?.(data);
+  return {
+    "agent-created": onAgent,
+    agent: onAgent,
+    "runtime-progress": (data) => callbacks.onProgress?.(data),
+    "runtime-complete": (data) => callbacks.onComplete?.(data),
+    "runtime-error": (data) => callbacks.onError?.(data)
+  };
+}
+function resolveAgentId(agent) {
+  if (typeof agent === "string") {
+    return agent;
+  }
+  return agent.agentId;
+}
 function createAgentsApi(cfg, relatedApis) {
-  const { base, doFetch, resolveWorkspaceId, resolveApiKey } = createHttp(cfg);
+  const { base, doFetch, buildHeaders, resolveWorkspaceId, resolveApiKey } = createHttp(cfg);
+  const jsonHeaders = { "content-type": "application/json" };
   const requireWorkspace = () => {
     const workspaceId = resolveWorkspaceId();
     if (typeof workspaceId === "string" && workspaceId.trim().length > 0) {
@@ -1173,132 +1329,186 @@ function createAgentsApi(cfg, relatedApis) {
     }
     throw new WorkspaceNotSelectedError();
   };
-  const jsonHeaders = { "content-type": "application/json" };
-  const fetchAgentsPage = async (options = {}) => {
+  const postJson = async (url, payload) => {
     requireWorkspace();
-    const sanitizedOptions = {
-      page: options.page,
-      limit: options.limit,
-      filter: options.filter
-    };
-    const query = serializeListOptions(sanitizedOptions);
-    const res = await doFetch(`${base}/agents`, {
-      method: "GET",
-      query
-    });
-    return res.json();
-  };
-  const listAgents = async (options = {}) => {
-    const normalizedOptions = { ...options ?? {} };
-    const response = await fetchAgentsPage(normalizedOptions);
-    return attachPaginator(response, fetchAgentsPage, normalizedOptions);
-  };
-  const getAgentDetail = async (agentId) => {
-    requireWorkspace();
-    const res = await doFetch(`${base}/agents/${agentId}`, {
-      method: "GET"
-    });
-    return res.json();
-  };
-  const createAgent = async (payload) => {
-    requireWorkspace();
-    const res = await doFetch(`${base}/agents`, {
+    const res = await doFetch(url, {
       method: "POST",
       body: JSON.stringify(payload),
       headers: jsonHeaders
     });
     return res.json();
   };
-  const forkAgentFromTemplate = async (payload) => {
+  const postWithSse = async (url, payload, callbacks) => {
     requireWorkspace();
-    const res = await doFetch(`${base}/agents/from-template`, {
+    const headers = buildHeaders({ "content-type": "application/json" });
+    const fx = cfg.fetchImpl ?? fetch;
+    const res = await fx(url, {
       method: "POST",
       body: JSON.stringify(payload),
-      headers: jsonHeaders
+      headers
     });
-    return res.json();
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`POST ${url} failed with status ${res.status}: ${body}`);
+    }
+    const contentType = res.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      const agent = await res.json();
+      callbacks.onAgentCreated?.(agent);
+      return agent;
+    }
+    return consumeSseStream(
+      res,
+      buildSseHandlers(callbacks),
+      "agent-created"
+    );
   };
-  const updateAgent = async (agentId, payload) => {
+  const getWithSse = async (url, callbacks) => {
     requireWorkspace();
-    const res = await doFetch(`${base}/agents/${agentId}`, {
-      method: "PATCH",
-      body: JSON.stringify(payload),
-      headers: jsonHeaders
-    });
-    return res.json();
-  };
-  const resolveAgentId = (agent) => {
-    return typeof agent === "string" ? agent : agent.agentId;
+    const headers = buildHeaders({});
+    const fx = cfg.fetchImpl ?? fetch;
+    const res = await fx(url, { method: "GET", headers });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`GET ${url} failed with status ${res.status}: ${body}`);
+    }
+    const contentType = res.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      const agent = await res.json();
+      callbacks.onAgentCreated?.(agent);
+      return agent;
+    }
+    return consumeSseStream(
+      res,
+      buildSseHandlers(callbacks),
+      "agent"
+    );
   };
-  const deleteAgent = async (agent) => {
+  const fetchPage = async (options = {}) => {
     requireWorkspace();
-    const agentId = resolveAgentId(agent);
-    await doFetch(`${base}/agents/${agentId}`, {
-      method: "DELETE"
+    const query = serializeListOptions({
+      page: options.page,
+      limit: options.limit,
+      filter: options.filter
     });
+    const res = await doFetch(`${base}/agents`, { method: "GET", query });
+    return res.json();
   };
   const baseApi = {
-    list: listAgents,
-    get: getAgentDetail,
-    create: createAgent,
-    forkFromTemplate: forkAgentFromTemplate,
-    update: updateAgent,
-    delete: deleteAgent
+    async list(options = {}) {
+      const opts = { ...options ?? {} };
+      const response = await fetchPage(opts);
+      return attachPaginator(response, fetchPage, opts);
+    },
+    async get(agentId, callbacks) {
+      if (callbacks) {
+        return getWithSse(`${base}/agents/${agentId}`, callbacks);
+      }
+      requireWorkspace();
+      const res = await doFetch(`${base}/agents/${agentId}`, { method: "GET" });
+      const contentType = res.headers.get("content-type") ?? "";
+      if (contentType.includes("text/event-stream")) {
+        return consumeSseStream(
+          res,
+          buildSseHandlers({}),
+          "agent",
+          {
+            resolveImmediately: true
+          }
+        );
+      }
+      return res.json();
+    },
+    async create(payload, callbacks) {
+      if (callbacks) {
+        return postWithSse(`${base}/agents`, payload, callbacks);
+      }
+      return postJson(`${base}/agents`, payload);
+    },
+    async clone(agentId, payload) {
+      return postJson(
+        `${base}/agents/${agentId}/clone`,
+        buildCloneRequest(payload)
+      );
+    },
+    async forkFromTemplate(payload, callbacks) {
+      if (callbacks) {
+        return postWithSse(`${base}/agents/from-template`, payload, callbacks);
+      }
+      return postJson(`${base}/agents/from-template`, payload);
+    },
+    async rebuild(agentId, callbacks) {
+      if (callbacks) {
+        return postWithSse(`${base}/agents/${agentId}/rebuild`, {}, callbacks);
+      }
+      return postJson(`${base}/agents/${agentId}/rebuild`, {});
+    },
+    async update(agentId, payload) {
+      requireWorkspace();
+      const res = await doFetch(`${base}/agents/${agentId}`, {
+        method: "PATCH",
+        body: JSON.stringify(payload),
+        headers: jsonHeaders
+      });
+      return res.json();
+    },
+    async delete(agent) {
+      requireWorkspace();
+      await doFetch(`${base}/agents/${resolveAgentId(agent)}`, {
+        method: "DELETE"
+      });
+    }
   };
   if (!relatedApis) {
     return baseApi;
   }
+  return withEntityWrapping(baseApi, fetchPage, relatedApis);
+}
+function withEntityWrapping(api, fetchPage, deps) {
   const wrapAgent = (detail) => createAgentEntity(detail, {
-    tagsApi: relatedApis.tagsApi,
-    phonesApi: relatedApis.phonesApi,
-    scheduleApi: relatedApis.scheduleApi,
-    scheduleExceptionsApi: relatedApis.scheduleExceptionsApi,
-    versionsApi: relatedApis.versionsApi,
-    blueprintsApi: relatedApis.blueprintsApi,
-    stagesApi: relatedApis.stagesApi,
-    stageTriggersApi: relatedApis.stageTriggersApi,
+    ...deps,
     reload: async (agentId) => {
-      const latest = await getAgentDetail(agentId);
+      const latest = await api.get(agentId);
       return wrapAgent(latest);
     },
     updateAgent: async (agentId, payload) => {
-      const updated = await updateAgent(agentId, payload);
+      const updated = await api.update(agentId, payload);
       return wrapAgent(updated);
     },
     deleteAgent: async (agentId) => {
-      await deleteAgent(agentId);
+      await api.delete(agentId);
+    },
+    cloneAgent: async (agentId, payload) => {
+      const cloned = await api.clone(agentId, payload);
+      return wrapAgent(cloned);
     }
   });
+  const wrapList = async (opts) => {
+    const result = await fetchPage(opts);
+    const items = Array.isArray(result.data) ? result.data : [];
+    return { ...result, data: items.map(wrapAgent) };
+  };
   return {
-    ...baseApi,
+    ...api,
     async list(options = {}) {
-      const normalizedOptions = { ...options ?? {} };
-      const applyWrap = async (opts) => {
-        const result = await fetchAgentsPage(opts);
-        const items = Array.isArray(result.data) ? result.data : [];
-        return {
-          ...result,
-          data: items.map((summary) => wrapAgent(summary))
-        };
-      };
-      const initial = await applyWrap(normalizedOptions);
-      return attachPaginator(initial, applyWrap, normalizedOptions);
+      const opts = { ...options ?? {} };
+      const initial = await wrapList(opts);
+      return attachPaginator(initial, wrapList, opts);
     },
-    async get(agentId) {
-      const detail = await getAgentDetail(agentId);
-      return wrapAgent(detail);
+    async get(agentId, callbacks) {
+      return wrapAgent(await api.get(agentId, callbacks));
     },
-    async create(payload) {
-      const detail = await createAgent(payload);
-      return wrapAgent(detail);
+    async create(payload, callbacks) {
+      return wrapAgent(await api.create(payload, callbacks));
+    },
+    async clone(agentId, payload) {
+      return wrapAgent(await api.clone(agentId, payload));
     },
-    async forkFromTemplate(payload) {
-      const detail = await forkAgentFromTemplate(payload);
-      return wrapAgent(detail);
+    async forkFromTemplate(payload, callbacks) {
+      return wrapAgent(await api.forkFromTemplate(payload, callbacks));
     },
     async update(agentId, payload) {
-      const detail = await updateAgent(agentId, payload);
-      return wrapAgent(detail);
+      return wrapAgent(await api.update(agentId, payload));
     }
   };
 }
@@ -1334,6 +1544,82 @@ function createApiKeysApi(cfg) {
   };
 }
 
+// src/api/billing.ts
+function createBillingApi(cfg) {
+  const { base, doFetch } = createHttp(cfg);
+  return {
+    async getBalance() {
+      const res = await doFetch(`${base}/billing/balance`, {
+        method: "GET"
+      });
+      return res.json();
+    }
+  };
+}
+
+// src/api/calls.ts
+function createCallsApi(cfg) {
+  const { base, doFetch } = createHttp(cfg);
+  const fetchCallsPage = async (options = {}) => {
+    const {
+      agentBatchId,
+      agentId,
+      executionId,
+      recordedAfter,
+      recordedBefore,
+      durationBucket,
+      goalStatus,
+      query: searchQuery,
+      ...listOptions
+    } = options ?? {};
+    const query = serializeListOptions(listOptions, {
+      agentBatchId,
+      agentId,
+      executionId,
+      recordedAfter,
+      recordedBefore,
+      durationBucket,
+      goalStatus,
+      query: searchQuery
+    });
+    const res = await doFetch(`${base}/calls`, {
+      method: "GET",
+      query
+    });
+    return res.json();
+  };
+  return {
+    async list(options = {}) {
+      const normalizedOptions = { ...options ?? {} };
+      const response = await fetchCallsPage(normalizedOptions);
+      return attachPaginator(response, fetchCallsPage, normalizedOptions);
+    },
+    async stream(options) {
+      const query = buildSearchParams([
+        ["after", options.after],
+        ["limit", options.limit],
+        ["agentBatchId", options.agentBatchId],
+        ["agentId", options.agentId],
+        ["executionId", options.executionId],
+        ["durationBucket", options.durationBucket],
+        ["goalStatus", options.goalStatus],
+        ["query", options.query]
+      ]);
+      const res = await doFetch(`${base}/calls/stream`, {
+        method: "GET",
+        query
+      });
+      return res.json();
+    },
+    async get(callId) {
+      const res = await doFetch(`${base}/calls/${callId}`, {
+        method: "GET"
+      });
+      return res.json();
+    }
+  };
+}
+
 // src/api/campaigns.ts
 function createCampaignsApi(cfg) {
   const { base, doFetch } = createHttp(cfg);
@@ -1349,10 +1635,7 @@ function createCampaignsApi(cfg) {
     return res.json();
   };
   const fetchExecutionsPage = async (campaignId, options = {}) => {
-    const query = serializeListOptions({
-      page: options.page,
-      limit: options.limit
-    });
+    const query = serializeListOptions(options ?? {});
     const res = await doFetch(`${base}/campaigns/${campaignId}/executions`, {
       method: "GET",
       query
@@ -1406,6 +1689,51 @@ function createCampaignsApi(cfg) {
       const response = await fetchExecutionsPage(campaignId, normalizedOptions);
       const fetchPage = (opts) => fetchExecutionsPage(campaignId, opts);
       return attachPaginator(response, fetchPage, normalizedOptions);
+    },
+    /**
+     * Pausa una campaña en curso. Los reintentos ya programados se
+     * reagendan al ejecutarse (sin consumir intentos) hasta `resume()`.
+     */
+    async pause(campaignId) {
+      const res = await doFetch(`${base}/campaigns/${campaignId}/pause`, {
+        method: "POST"
+      });
+      return res.json();
+    },
+    /**
+     * Reanuda una campaña pausada. Re-encola los reintentos pendientes
+     * según su `nextRetryAt`.
+     */
+    async resume(campaignId) {
+      const res = await doFetch(`${base}/campaigns/${campaignId}/resume`, {
+        method: "POST"
+      });
+      return res.json();
+    },
+    /**
+     * Cancela definitivamente una campaña no terminal. Los reintentos
+     * pendientes se descartan — operación destructiva.
+     */
+    async cancel(campaignId) {
+      const res = await doFetch(`${base}/campaigns/${campaignId}/cancel`, {
+        method: "POST"
+      });
+      return res.json();
+    },
+    /**
+     * Descarga el CSV con todas las ejecuciones de la campaña. Devuelve un
+     * `Blob` con `text/csv; charset=utf-8` (BOM UTF-8 incluido). Para
+     * campañas > 20,000 filas la API responde 413.
+     */
+    async exportExecutions(campaignId) {
+      const res = await doFetch(
+        `${base}/campaigns/${campaignId}/executions/export`,
+        {
+          method: "GET",
+          headers: { Accept: "text/csv" }
+        }
+      );
+      return res.blob();
     }
   };
 }
@@ -1486,6 +1814,70 @@ function createCatalogsApi(cfg) {
   };
 }
 
+// src/api/documents.ts
+function createDocumentsApi(cfg) {
+  const { base, doFetch, resolveWorkspaceId, resolveApiKey } = createHttp(cfg);
+  const jsonHeaders = { "content-type": "application/json" };
+  const requireWorkspace = () => {
+    const workspaceId = resolveWorkspaceId();
+    if (typeof workspaceId === "string" && workspaceId.trim().length > 0) {
+      return;
+    }
+    const apiKey = resolveApiKey();
+    if (typeof apiKey === "string" && apiKey.trim().length > 0) {
+      return;
+    }
+    throw new WorkspaceNotSelectedError();
+  };
+  return {
+    async create(files) {
+      requireWorkspace();
+      const res = await doFetch(`${base}/documents`, {
+        method: "POST",
+        body: JSON.stringify({ files }),
+        headers: jsonHeaders
+      });
+      return res.json();
+    }
+  };
+}
+
+// src/api/sip-trunks.ts
+function createSipTrunksApi(cfg) {
+  const { base, doFetch } = createHttp(cfg);
+  return {
+    async list() {
+      const res = await doFetch(`${base}/sip/trunks`, { method: "GET" });
+      return res.json();
+    },
+    async get(trunkId) {
+      const res = await doFetch(`${base}/sip/trunks/${trunkId}`, {
+        method: "GET"
+      });
+      return res.json();
+    },
+    async create(body) {
+      const res = await doFetch(`${base}/sip/trunks`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      return res.json();
+    },
+    async update(trunkId, body) {
+      const res = await doFetch(`${base}/sip/trunks/${trunkId}`, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      return res.json();
+    },
+    async delete(trunkId) {
+      await doFetch(`${base}/sip/trunks/${trunkId}`, { method: "DELETE" });
+    }
+  };
+}
+
 // src/api/tools.ts
 var IDEMPOTENCY_HEADER = "Idempotency-Key";
 var generateIdempotencyKey = (explicit) => {
@@ -1675,6 +2067,74 @@ function createToolsApi(cfg) {
   };
 }
 
+// src/api/usage.ts
+var import_api_query_builder = require("@getsupervisor/api-query-builder");
+function createUsageApi(cfg) {
+  const { base, doFetch } = createHttp(cfg);
+  const fetchUsageAgentsPage = async (options = {}) => {
+    const { resource, from, to, ...listOptions } = options;
+    const query = serializeListOptions({
+      ...listOptions,
+      filter: resolveFilter(
+        buildUsageFilter(resource, from, to),
+        listOptions.filter
+      )
+    });
+    const res = await doFetch(`${base}/usage/agents`, {
+      method: "GET",
+      query
+    });
+    return res.json();
+  };
+  return {
+    async agents(options = {}) {
+      const normalizedOptions = {
+        ...options
+      };
+      const response = await fetchUsageAgentsPage(normalizedOptions);
+      return attachPaginator(response, fetchUsageAgentsPage, normalizedOptions);
+    }
+  };
+}
+function resolveFilter(usageFilter, fallback) {
+  if (usageFilter) {
+    return usageFilter;
+  }
+  return fallback;
+}
+function appendCondition(query, factory) {
+  if (query) {
+    query.and(factory);
+    return query;
+  }
+  return new import_api_query_builder.Query(factory);
+}
+var DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+function toISOString(value) {
+  const input = DATE_ONLY.test(value) ? `${value}T00:00:00` : value;
+  const date = new Date(input);
+  if (Number.isNaN(date.getTime())) {
+    return value;
+  }
+  return date.toISOString();
+}
+function buildUsageFilter(resource, from, to) {
+  let query;
+  if (resource) {
+    query = appendCondition(query, (qb) => qb.eq("resource", resource));
+  }
+  if (from) {
+    query = appendCondition(
+      query,
+      (qb) => qb.mte("createdAt", toISOString(from))
+    );
+  }
+  if (to) {
+    query = appendCondition(query, (qb) => qb.lt("createdAt", toISOString(to)));
+  }
+  return query;
+}
+
 // src/utils/catalog-voices.ts
 var FALLBACK_LOCALE = "und";
 var FALLBACK_PROVIDER = "catalog";
@@ -1733,9 +2193,9 @@ function pickGender(value) {
 }
 
 // src/utils/catalog-filter.ts
-var import_api_query_builder = require("@getsupervisor/api-query-builder");
+var import_api_query_builder2 = require("@getsupervisor/api-query-builder");
 function createCatalogTypeQuery(type) {
-  return new import_api_query_builder.Query((qb) => qb.eq("type", type));
+  return new import_api_query_builder2.Query((qb) => qb.eq("type", type));
 }
 function ensureCatalogTypeFilter(filter, type) {
   const requiredQuery = createCatalogTypeQuery(type);
@@ -1971,6 +2431,35 @@ function createWebhooksApi(cfg) {
         `${base}/webhooks/${webhookId}/subscriptions/${subscriptionId}`,
         { method: "DELETE" }
       );
+    },
+    // Deliveries
+    async listDeliveries(webhookId, options = {}) {
+      const fetchPage = async (opts) => {
+        const query = serializeListOptions({
+          page: opts.page,
+          limit: opts.limit,
+          sort: opts.sort,
+          fields: opts.fields,
+          include: opts.include,
+          search: opts.search,
+          filter: opts.filter
+        });
+        const res = await doFetch(`${base}/webhooks/${webhookId}/deliveries`, {
+          method: "GET",
+          query
+        });
+        return res.json();
+      };
+      const normalized = { ...options ?? {} };
+      const response = await fetchPage(normalized);
+      return attachPaginator(response, fetchPage, normalized);
+    },
+    async getDelivery(webhookId, deliveryId) {
+      const res = await doFetch(
+        `${base}/webhooks/${webhookId}/deliveries/${deliveryId}`,
+        { method: "GET" }
+      );
+      return res.json();
     }
   };
 }
@@ -2034,8 +2523,8 @@ function createWorkspacesApi(cfg) {
       const fetchPage = (options) => fetchPhonesPage(workspaceId, options);
       return attachPaginator(response, fetchPage, normalizedOptions);
     },
-    async enable(workspaceId, payload) {
-      const res = await doFetch(`${base}/workspaces/${workspaceId}/enable`, {
+    async enable(payload) {
+      const res = await doFetch(`${base}/workspaces/enable`, {
         method: "POST",
         headers: jsonHeaders,
         body: JSON.stringify(payload)
@@ -2081,6 +2570,7 @@ function createClient(initialCfg) {
   const stagesApi = createAgentStagesApi(runtimeCfg);
   const voicesApi = createVoicesApi(runtimeCfg);
   const apiKeysApi = createApiKeysApi(runtimeCfg);
+  const callsApi = createCallsApi(runtimeCfg);
   const catalogsApi = createCatalogsApi(runtimeCfg);
   const catalogTemplatesApi = createCatalogTemplatesApi(runtimeCfg);
   const webhooksApi = createWebhooksApi(runtimeCfg);
@@ -2149,9 +2639,14 @@ function createClient(initialCfg) {
       ...catalogsApi,
       templates: catalogTemplatesApi
     },
+    documents: createDocumentsApi(runtimeCfg),
     campaigns: createCampaignsApi(runtimeCfg),
     voices: voicesApi,
     apiKeys: apiKeysApi,
+    billing: createBillingApi(runtimeCfg),
+    calls: callsApi,
+    usage: createUsageApi(runtimeCfg),
+    sip: createSipTrunksApi(runtimeCfg),
     webhooks: webhooksApi
   };
   return {
@@ -2235,12 +2730,17 @@ function createClient(initialCfg) {
   createAgentVersionsApi,
   createAgentsApi,
   createApiKeysApi,
+  createBillingApi,
+  createCallsApi,
   createCampaignsApi,
   createCatalogTemplatesApi,
   createCatalogsApi,
   createClient,
+  createDocumentsApi,
   createHttp,
+  createSipTrunksApi,
   createToolsApi,
+  createUsageApi,
   createVoicesApi,
   createWebhooksApi,
   createWorkspacesApi,