@getsupervisor/agents-studio-sdk 1.2.0 → 1.4.0

package/dist/index.cjs

@@ -25,59 +25,114 @@ __export(index_exports, {
   bindAgentInstructions: () => bindAgentInstructions,
   bindAgentKnowledge: () => bindAgentKnowledge,
   bindAgentPhones: () => bindAgentPhones,
+  bindAgentSchedule: () => bindAgentSchedule,
+  bindAgentVersions: () => bindAgentVersions,
   createAgentEntity: () => createAgentEntity,
   createAgentInstructionsApi: () => createAgentInstructionsApi,
   createAgentKnowledgeApi: () => createAgentKnowledgeApi,
   createAgentPhonesApi: () => createAgentPhonesApi,
+  createAgentScheduleApi: () => createAgentScheduleApi,
+  createAgentVersionsApi: () => createAgentVersionsApi,
   createAgentsApi: () => createAgentsApi,
   createClient: () => createClient,
   createHttp: () => createHttp,
   createToolsApi: () => createToolsApi,
+  createVoicesApi: () => createVoicesApi,
   createWorkspacesApi: () => createWorkspacesApi
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/entities/agent.ts
-var bindAgentInstructions = (api, agentId) => ({
-  list(opts) {
-    return api.list(agentId, opts);
-  },
-  create(payload) {
-    return api.create(agentId, payload);
+// src/utils/pagination.ts
+var toNumber = (value) => {
+  return typeof value === "number" ? value : void 0;
+};
+var toBoolean = (value) => {
+  return typeof value === "boolean" ? value : void 0;
+};
+function cloneOptions(options, overrides) {
+  return {
+    ...options ?? {},
+    ...overrides ?? {}
+  };
+}
+function normalizeMeta(meta) {
+  if (!meta) {
+    return void 0;
   }
-});
-var bindAgentKnowledge = (api, agentId) => ({
-  upload(payload) {
-    return api.upload(agentId, payload);
-  },
-  listBases() {
-    return api.listBases(agentId);
-  },
-  listUploads() {
-    return api.listUploads(agentId);
+  const metaRecord = meta;
+  return {
+    ...metaRecord,
+    page: toNumber(metaRecord.page),
+    limit: toNumber(metaRecord.limit) ?? toNumber(metaRecord.pageSize),
+    total: toNumber(metaRecord.total) ?? toNumber(metaRecord.totalItems),
+    hasNext: toBoolean(metaRecord.hasNext),
+    hasPrevious: toBoolean(metaRecord.hasPrevious),
+    totalPages: toNumber(metaRecord.totalPages)
+  };
+}
+function resolveHasNext(meta, limit) {
+  if (typeof meta?.hasNext === "boolean") {
+    return meta.hasNext;
   }
-});
-var bindAgentPhones = (api, agentId) => ({
-  connect(payload) {
-    return api.connect(agentId, payload);
-  },
-  disconnect(phoneId) {
-    return api.disconnect(agentId, phoneId);
+  if (typeof meta?.total === "number" && typeof meta?.page === "number" && typeof limit === "number") {
+    return meta.page * limit < meta.total;
   }
-});
-var createAgentEntity = (dto, options) => {
-  const { instructionsApi, knowledgeApi, phonesApi, reload } = options;
-  const entity = {
-    ...dto,
-    instructions: bindAgentInstructions(instructionsApi, dto.agentId),
-    knowledge: bindAgentKnowledge(knowledgeApi, dto.agentId),
-    phones: bindAgentPhones(phonesApi, dto.agentId),
-    async refresh() {
-      return reload(dto.agentId);
-    }
+  if (typeof meta?.totalPages === "number" && typeof meta?.page === "number") {
+    return meta.page < meta.totalPages;
+  }
+  return false;
+}
+function resolveHasPrevious(meta) {
+  if (typeof meta?.hasPrevious === "boolean") {
+    return meta.hasPrevious;
+  }
+  if (typeof meta?.page === "number") {
+    return meta.page > 1;
+  }
+  return false;
+}
+function attachPaginator(response, fetchPage, options) {
+  const baseOptions = options ?? {};
+  const meta = normalizeMeta(response.meta);
+  const currentPage = typeof meta?.page === "number" ? meta.page : typeof baseOptions.page === "number" ? baseOptions.page : 1;
+  const currentLimit = typeof meta?.limit === "number" ? meta.limit : typeof baseOptions.limit === "number" ? baseOptions.limit : void 0;
+  const getNextResponse = async (page, overrides) => {
+    const nextOptions = cloneOptions(baseOptions, {
+      ...overrides,
+      page
+    });
+    const nextResponse = await fetchPage(nextOptions);
+    return attachPaginator(nextResponse, fetchPage, nextOptions);
   };
-  return Object.freeze(entity);
-};
+  return Object.assign(response, {
+    async next() {
+      if (!resolveHasNext(meta, currentLimit)) {
+        return null;
+      }
+      return getNextResponse(currentPage + 1);
+    },
+    async prev() {
+      if (!resolveHasPrevious(meta)) {
+        return null;
+      }
+      return getNextResponse(Math.max(1, currentPage - 1));
+    },
+    async page(pageNumber) {
+      if (typeof pageNumber !== "number" || Number.isNaN(pageNumber)) {
+        throw new TypeError("page(pageNumber) requires a numeric value.");
+      }
+      if (pageNumber < 1) {
+        throw new RangeError(
+          "Page numbers must be greater than or equal to 1."
+        );
+      }
+      return getNextResponse(pageNumber);
+    },
+    async reload() {
+      return getNextResponse(currentPage);
+    }
+  });
+}
 
 // src/errors.ts
 var HttpError = class extends Error {
@@ -108,6 +163,36 @@ var NetworkError = class extends Error {
 };
 
 // src/http.ts
+function toQueryString(query) {
+  if (!query) return void 0;
+  if (typeof query === "string") {
+    const normalized = query.trim().replace(/^\?/, "");
+    return normalized.length > 0 ? normalized : void 0;
+  }
+  if (query instanceof URLSearchParams) {
+    const result2 = query.toString();
+    return result2.length > 0 ? result2 : void 0;
+  }
+  const params = new URLSearchParams();
+  Object.entries(query).forEach(([key, value]) => {
+    if (value === null || value === void 0) return;
+    const values = Array.isArray(value) ? value : [value];
+    values.forEach((item) => {
+      params.append(key, String(item));
+    });
+  });
+  const result = params.toString();
+  return result.length > 0 ? result : void 0;
+}
+function appendQuery(url, query) {
+  const qs = toQueryString(query);
+  if (!qs) return url;
+  const [base, hash] = url.split("#");
+  const hasQuery = base.includes("?");
+  const needsSeparator = hasQuery ? base.endsWith("?") || base.endsWith("&") ? "" : "&" : "?";
+  const built = `${base}${needsSeparator}${qs}`;
+  return hash ? `${built}#${hash}` : built;
+}
 function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
@@ -182,25 +267,31 @@ function createHttp(cfg) {
     };
   };
   async function doFetch(url, init = {}) {
+    const { query, ...requestInit } = init;
+    const targetUrl = appendQuery(url, query);
     const ab = new AbortController();
     const req = async () => {
       try {
-        const finalHeaders = buildHeaders(init.headers);
+        const finalHeaders = buildHeaders(requestInit.headers);
         const res = await withTimeout(
-          fx(url, { ...init, headers: finalHeaders, signal: ab.signal }),
+          fx(targetUrl, {
+            ...requestInit,
+            headers: finalHeaders,
+            signal: ab.signal
+          }),
           timeout,
           ab,
-          url
+          targetUrl
         );
         if (!res.ok) {
           const body = await res.clone().json().catch(() => void 0);
-          throw new HttpError(res.status, res.statusText, body, url);
+          throw new HttpError(res.status, res.statusText, body, targetUrl);
         }
         return res;
       } catch (e) {
-        if (e.name === "AbortError") throw new TimeoutError(timeout, url);
+        if (e.name === "AbortError") throw new TimeoutError(timeout, targetUrl);
         if (e instanceof HttpError) throw e;
-        throw new NetworkError(e, url);
+        throw new NetworkError(e, targetUrl);
       }
     };
     return withRetry(req, retry);
@@ -216,16 +307,421 @@ function createHttp(cfg) {
   };
 }
 
+// src/utils/query.ts
+function serializeListOptions(options = {}, extra = {}) {
+  const params = new URLSearchParams();
+  appendParam(params, "page", options.page);
+  appendParam(params, "limit", options.limit);
+  appendParam(params, "sort", options.sort);
+  appendParam(params, "fields", options.fields);
+  appendParam(params, "include", options.include);
+  appendParam(params, "q", options.search);
+  appendParam(params, "filter", mapQueryValue(options.filter));
+  appendParam(params, "or", mapQueryValue(options.or));
+  Object.entries(extra).forEach(([key, value]) => {
+    appendParam(params, key, value);
+  });
+  return params.toString();
+}
+function mapQueryValue(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (isQueryBuilderSerializable(value)) {
+    return getQueryBuilderString(value);
+  }
+  return value;
+}
+function appendParam(params, key, value) {
+  if (value === void 0 || value === null) {
+    return;
+  }
+  if (value instanceof Date) {
+    params.set(key, value.toISOString());
+    return;
+  }
+  if (isQueryBuilderSerializable(value)) {
+    params.set(key, getQueryBuilderString(value));
+    return;
+  }
+  if (typeof value === "string") {
+    params.set(key, value);
+    return;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    params.set(key, String(value));
+    return;
+  }
+  if (typeof value === "bigint") {
+    params.set(key, value.toString());
+    return;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return;
+    }
+    if (value.every(isPrimitive)) {
+      params.set(key, value.map((item) => String(item)).join(","));
+      return;
+    }
+    value.forEach((item, idx) => {
+      appendParam(params, `${key}[${idx}]`, item);
+    });
+    return;
+  }
+  if (isPlainObject(value)) {
+    Object.entries(value).forEach(([childKey, childValue]) => {
+      appendParam(params, `${key}[${childKey}]`, childValue);
+    });
+    return;
+  }
+  params.set(key, String(value));
+}
+function isPrimitive(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint";
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function isQueryBuilderSerializable(value) {
+  return !!value && typeof value === "object" && typeof value.build === "function";
+}
+function getQueryBuilderString(value) {
+  const build = value.build;
+  if (typeof build !== "function") {
+    throw new TypeError(
+      "Query builder values must expose a build() method returning a string."
+    );
+  }
+  if (build.length > 0) {
+    const stringValue = value.toString?.();
+    if (stringValue && stringValue !== "[object Object]") {
+      return stringValue;
+    }
+    throw new TypeError(
+      "Query builder instances passed to the SDK must expose a zero-argument build() method. Did you pass QueryBuilder instead of Query?"
+    );
+  }
+  const result = build.call(value);
+  if (typeof result === "string") {
+    return result;
+  }
+  if (result === void 0 || result === null) {
+    throw new TypeError(
+      "Query builder build() must return a string representation of the query."
+    );
+  }
+  return String(result);
+}
+
+// src/api/agent-instructions.ts
+function createAgentInstructionsApi(cfg) {
+  const { base, doFetch } = createHttp(cfg);
+  const jsonHeaders = { "content-type": "application/json" };
+  const fetchInstructionPage = async (agentId, opts = {}) => {
+    const { versionId, ...queryOptions } = opts ?? {};
+    const query = serializeListOptions(queryOptions, { versionId });
+    const res = await doFetch(`${base}/v1/agents/${agentId}/instructions`, {
+      method: "GET",
+      query
+    });
+    return res.json();
+  };
+  return {
+    async list(agentId, opts = {}) {
+      const normalizedOptions = {
+        ...opts ?? {}
+      };
+      const fetchPage = (options) => fetchInstructionPage(agentId, options);
+      const response = await fetchPage(normalizedOptions);
+      return attachPaginator(response, fetchPage, normalizedOptions);
+    },
+    async create(agentId, payload) {
+      const res = await doFetch(`${base}/v1/agents/${agentId}/instructions`, {
+        method: "POST",
+        headers: jsonHeaders,
+        body: JSON.stringify(payload)
+      });
+      return res.json();
+    },
+    async update(agentId, instructionId, payload) {
+      const res = await doFetch(
+        `${base}/v1/agents/${agentId}/instructions/${instructionId}`,
+        {
+          method: "PATCH",
+          headers: jsonHeaders,
+          body: JSON.stringify(payload)
+        }
+      );
+      return res.json();
+    },
+    async delete(agentId, instructionId) {
+      await doFetch(
+        `${base}/v1/agents/${agentId}/instructions/${instructionId}`,
+        {
+          method: "DELETE"
+        }
+      );
+    }
+  };
+}
+
+// src/api/agent-knowledge.ts
+function createAgentKnowledgeApi(cfg) {
+  const { base, doFetch } = createHttp(cfg);
+  const jsonHeaders = { "content-type": "application/json" };
+  const fetchBasesPage = async (agentId, opts = {}) => {
+    const query = serializeListOptions(opts);
+    const res = await doFetch(`${base}/v1/agents/${agentId}/knowledge/bases`, {
+      method: "GET",
+      query
+    });
+    return res.json();
+  };
+  const fetchUploadsPage = async (agentId, opts = {}) => {
+    const query = serializeListOptions(opts);
+    const res = await doFetch(
+      `${base}/v1/agents/${agentId}/knowledge/uploads`,
+      {
+        method: "GET",
+        query
+      }
+    );
+    return res.json();
+  };
+  return {
+    async upload(agentId, payload) {
+      const res = await doFetch(
+        `${base}/v1/agents/${agentId}/knowledge/upload`,
+        {
+          method: "POST",
+          headers: jsonHeaders,
+          body: JSON.stringify(payload)
+        }
+      );
+      return res.json();
+    },
+    async listBases(agentId, opts = {}) {
+      const normalizedOptions = {
+        ...opts ?? {}
+      };
+      const fetchPage = (options) => fetchBasesPage(agentId, options);
+      const response = await fetchPage(normalizedOptions);
+      return attachPaginator(response, fetchPage, normalizedOptions);
+    },
+    async listUploads(agentId, opts = {}) {
+      const normalizedOptions = {
+        ...opts ?? {}
+      };
+      const fetchPage = (options) => fetchUploadsPage(agentId, options);
+      const response = await fetchPage(normalizedOptions);
+      return attachPaginator(response, fetchPage, normalizedOptions);
+    }
+  };
+}
+
+// src/api/agent-phones.ts
+function createAgentPhonesApi(cfg) {
+  const { base, doFetch } = createHttp(cfg);
+  const jsonHeaders = { "content-type": "application/json" };
+  return {
+    async connect(agentId, payload) {
+      const res = await doFetch(`${base}/v1/agents/${agentId}/phones`, {
+        method: "POST",
+        headers: jsonHeaders,
+        body: JSON.stringify(payload)
+      });
+      return res.json();
+    },
+    async disconnect(agentId, phoneId) {
+      await doFetch(`${base}/v1/agents/${agentId}/phones/${phoneId}`, {
+        method: "DELETE"
+      });
+    }
+  };
+}
+
+// src/api/agent-schedule.ts
+function createAgentScheduleApi(cfg) {
+  const { base, doFetch } = createHttp(cfg);
+  const jsonHeaders = { "content-type": "application/json" };
+  return {
+    async get(agentId) {
+      const res = await doFetch(`${base}/v1/agents/${agentId}/schedule`, {
+        method: "GET"
+      });
+      return res.json();
+    },
+    async update(agentId, payload) {
+      const res = await doFetch(`${base}/v1/agents/${agentId}/schedule`, {
+        method: "PUT",
+        headers: jsonHeaders,
+        body: JSON.stringify(payload)
+      });
+      return res.json();
+    }
+  };
+}
+
+// src/api/agent-versions.ts
+function createAgentVersionsApi(cfg) {
+  const { base, doFetch } = createHttp(cfg);
+  const jsonHeaders = { "content-type": "application/json" };
+  const fetchVersionsPage = async (agentId, opts = {}) => {
+    const { status, ...queryOptions } = opts ?? {};
+    const query = serializeListOptions(queryOptions, { status });
+    const res = await doFetch(`${base}/v1/agents/${agentId}/versions`, {
+      method: "GET",
+      query
+    });
+    return res.json();
+  };
+  return {
+    async list(agentId, opts = {}) {
+      const normalizedOptions = { ...opts ?? {} };
+      const fetchPage = (options) => fetchVersionsPage(agentId, options);
+      const response = await fetchPage(normalizedOptions);
+      return attachPaginator(response, fetchPage, normalizedOptions);
+    },
+    async get(agentId, versionId) {
+      const res = await doFetch(
+        `${base}/v1/agents/${agentId}/versions/${versionId}`,
+        {
+          method: "GET"
+        }
+      );
+      return res.json();
+    },
+    async create(agentId, payload) {
+      const res = await doFetch(`${base}/v1/agents/${agentId}/versions`, {
+        method: "POST",
+        headers: jsonHeaders,
+        body: JSON.stringify(payload)
+      });
+      return res.json();
+    },
+    async update(agentId, versionId, payload) {
+      const res = await doFetch(
+        `${base}/v1/agents/${agentId}/versions/${versionId}`,
+        {
+          method: "PATCH",
+          headers: jsonHeaders,
+          body: JSON.stringify(payload)
+        }
+      );
+      return res.json();
+    }
+  };
+}
+
+// src/entities/agent.ts
+var bindAgentInstructions = (api, agentId) => ({
+  list(opts) {
+    return api.list(agentId, opts);
+  },
+  create(payload) {
+    return api.create(agentId, payload);
+  },
+  update(instructionId, payload) {
+    return api.update(agentId, instructionId, payload);
+  },
+  delete(instructionId) {
+    return api.delete(agentId, instructionId);
+  }
+});
+var bindAgentKnowledge = (api, agentId) => ({
+  upload(payload) {
+    return api.upload(agentId, payload);
+  },
+  listBases(opts) {
+    return api.listBases(agentId, opts);
+  },
+  listUploads(opts) {
+    return api.listUploads(agentId, opts);
+  }
+});
+var bindAgentPhones = (api, agentId) => ({
+  connect(payload) {
+    return api.connect(agentId, payload);
+  },
+  disconnect(phoneId) {
+    return api.disconnect(agentId, phoneId);
+  }
+});
+var bindAgentSchedule = (api, agentId) => ({
+  get() {
+    return api.get(agentId);
+  },
+  update(payload) {
+    return api.update(agentId, payload);
+  }
+});
+var bindAgentVersions = (api, agentId) => ({
+  list(opts) {
+    return api.list(agentId, opts);
+  },
+  get(versionId) {
+    return api.get(agentId, versionId);
+  },
+  create(payload) {
+    return api.create(agentId, payload);
+  },
+  update(versionId, payload) {
+    return api.update(agentId, versionId, payload);
+  }
+});
+var createAgentEntity = (dto, options) => {
+  const {
+    instructionsApi,
+    knowledgeApi,
+    phonesApi,
+    scheduleApi,
+    versionsApi,
+    reload,
+    updateAgent,
+    deleteAgent
+  } = options;
+  const entity = {
+    ...dto,
+    instructions: bindAgentInstructions(instructionsApi, dto.agentId),
+    knowledge: bindAgentKnowledge(knowledgeApi, dto.agentId),
+    phones: bindAgentPhones(phonesApi, dto.agentId),
+    schedule: bindAgentSchedule(scheduleApi, dto.agentId),
+    versions: bindAgentVersions(versionsApi, dto.agentId),
+    async save(patch) {
+      return updateAgent(dto.agentId, patch);
+    },
+    async delete() {
+      await deleteAgent(dto.agentId);
+    },
+    async refresh() {
+      return reload(dto.agentId);
+    }
+  };
+  return Object.freeze(entity);
+};
+
 // src/api/agents.ts
 function createAgentsApi(cfg, relatedApis) {
   const { base, doFetch } = createHttp(cfg);
   const jsonHeaders = { "content-type": "application/json" };
-  const listAgents = async () => {
+  const fetchAgentsPage = async (options = {}) => {
+    const query = serializeListOptions(options);
     const res = await doFetch(`${base}/v1/agents`, {
-      method: "GET"
+      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) => {
     const res = await doFetch(`${base}/v1/agents/${agentId}`, {
       method: "GET"
@@ -248,7 +744,11 @@ function createAgentsApi(cfg, relatedApis) {
     });
     return res.json();
   };
-  const deleteAgent = async (agentId) => {
+  const resolveAgentId = (agent) => {
+    return typeof agent === "string" ? agent : agent.agentId;
+  };
+  const deleteAgent = async (agent) => {
+    const agentId = resolveAgentId(agent);
     await doFetch(`${base}/v1/agents/${agentId}`, {
       method: "DELETE"
     });
@@ -267,13 +767,35 @@ function createAgentsApi(cfg, relatedApis) {
     instructionsApi: relatedApis.instructionsApi,
     knowledgeApi: relatedApis.knowledgeApi,
     phonesApi: relatedApis.phonesApi,
+    scheduleApi: relatedApis.scheduleApi,
+    versionsApi: relatedApis.versionsApi,
     reload: async (agentId) => {
       const latest = await getAgentDetail(agentId);
       return wrapAgent(latest);
+    },
+    updateAgent: async (agentId, payload) => {
+      const updated = await updateAgent(agentId, payload);
+      return wrapAgent(updated);
+    },
+    deleteAgent: async (agentId) => {
+      await deleteAgent(agentId);
     }
   });
   return {
     ...baseApi,
+    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);
+    },
     async get(agentId) {
       const detail = await getAgentDetail(agentId);
       return wrapAgent(detail);
@@ -289,60 +811,26 @@ function createAgentsApi(cfg, relatedApis) {
   };
 }
 
-// src/api/agent-knowledge.ts
-function createAgentKnowledgeApi(cfg) {
+// src/api/tools.ts
+function createToolsApi(cfg) {
   const { base, doFetch } = createHttp(cfg);
   const jsonHeaders = { "content-type": "application/json" };
-  return {
-    async upload(agentId, payload) {
-      const res = await doFetch(
-        `${base}/v1/agents/${agentId}/knowledge/upload`,
-        {
-          method: "POST",
-          headers: jsonHeaders,
-          body: JSON.stringify(payload)
-        }
-      );
-      return res.json();
-    },
-    async listBases(agentId) {
-      const res = await doFetch(
-        `${base}/v1/agents/${agentId}/knowledge/bases`,
-        {
-          method: "GET"
-        }
-      );
-      return res.json();
-    },
-    async listUploads(agentId) {
-      const res = await doFetch(
-        `${base}/v1/agents/${agentId}/knowledge/uploads`,
-        {
-          method: "GET"
-        }
-      );
-      return res.json();
-    }
+  const fetchToolsPage = async (options = {}) => {
+    const query = serializeListOptions(options);
+    const res = await doFetch(`${base}/v1/tools`, {
+      method: "GET",
+      query
+    });
+    return res.json();
   };
-}
-
-// src/api/agent-instructions.ts
-function createAgentInstructionsApi(cfg) {
-  const { base, doFetch } = createHttp(cfg);
-  const jsonHeaders = { "content-type": "application/json" };
   return {
-    async list(agentId, opts) {
-      const search = opts?.versionId ? `?versionId=${encodeURIComponent(opts.versionId)}` : "";
-      const res = await doFetch(
-        `${base}/v1/agents/${agentId}/instructions${search}`,
-        {
-          method: "GET"
-        }
-      );
-      return res.json();
+    async list(options = {}) {
+      const normalizedOptions = { ...options ?? {} };
+      const response = await fetchToolsPage(normalizedOptions);
+      return attachPaginator(response, fetchToolsPage, normalizedOptions);
     },
-    async create(agentId, payload) {
-      const res = await doFetch(`${base}/v1/agents/${agentId}/instructions`, {
+    async execute(toolId, payload) {
+      const res = await doFetch(`${base}/v1/tools/${toolId}/execute`, {
         method: "POST",
         headers: jsonHeaders,
         body: JSON.stringify(payload)
@@ -352,23 +840,40 @@ function createAgentInstructionsApi(cfg) {
   };
 }
 
-// src/api/agent-phones.ts
-function createAgentPhonesApi(cfg) {
+// src/api/voices.ts
+function createVoicesApi(cfg) {
   const { base, doFetch } = createHttp(cfg);
-  const jsonHeaders = { "content-type": "application/json" };
+  const fetchVoicesPage = async (options = {}) => {
+    const { agentId, agentVersionId, gender, locale } = options;
+    const query = serializeListOptions(
+      {
+        page: options.page,
+        limit: options.limit ?? options.pageSize,
+        sort: options.sort,
+        fields: options.fields,
+        include: options.include,
+        search: options.search,
+        filter: options.filter,
+        or: options.or
+      },
+      {
+        agentId,
+        agentVersionId,
+        gender,
+        locale
+      }
+    );
+    const res = await doFetch(`${base}/v1/voices`, {
+      method: "GET",
+      query
+    });
+    return res.json();
+  };
   return {
-    async connect(agentId, payload) {
-      const res = await doFetch(`${base}/v1/agents/${agentId}/phones`, {
-        method: "POST",
-        headers: jsonHeaders,
-        body: JSON.stringify(payload)
-      });
-      return res.json();
-    },
-    async disconnect(agentId, phoneId) {
-      await doFetch(`${base}/v1/agents/${agentId}/phones/${phoneId}`, {
-        method: "DELETE"
-      });
+    async list(options = {}) {
+      const normalizedOptions = { ...options ?? {} };
+      const response = await fetchVoicesPage(normalizedOptions);
+      return attachPaginator(response, fetchVoicesPage, normalizedOptions);
     }
   };
 }
@@ -377,16 +882,35 @@ function createAgentPhonesApi(cfg) {
 function createWorkspacesApi(cfg) {
   const { base, doFetch } = createHttp(cfg);
   const jsonHeaders = { "content-type": "application/json" };
+  const fetchPhonesPage = async (workspaceId, opts = {}) => {
+    const { channel } = 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,
+        or: opts.or
+      },
+      { channel }
+    );
+    const res = await doFetch(`${base}/v1/workspaces/${workspaceId}/phones`, {
+      method: "GET",
+      query
+    });
+    return res.json();
+  };
   return {
-    async listPhones(workspaceId, opts) {
-      const search = opts?.channel ? `?channel=${opts.channel}` : "";
-      const res = await doFetch(
-        `${base}/v1/workspaces/${workspaceId}/phones${search}`,
-        {
-          method: "GET"
-        }
-      );
-      return res.json();
+    async listPhones(workspaceId, opts = {}) {
+      const normalizedOptions = {
+        ...opts ?? {}
+      };
+      const response = await fetchPhonesPage(workspaceId, normalizedOptions);
+      const fetchPage = (options) => fetchPhonesPage(workspaceId, options);
+      return attachPaginator(response, fetchPage, normalizedOptions);
     },
     async enable(workspaceId, payload) {
       const res = await doFetch(`${base}/v1/workspaces/${workspaceId}/enable`, {
@@ -399,28 +923,6 @@ function createWorkspacesApi(cfg) {
   };
 }
 
-// src/api/tools.ts
-function createToolsApi(cfg) {
-  const { base, doFetch } = createHttp(cfg);
-  const jsonHeaders = { "content-type": "application/json" };
-  return {
-    async list() {
-      const res = await doFetch(`${base}/v1/tools`, {
-        method: "GET"
-      });
-      return res.json();
-    },
-    async execute(toolId, payload) {
-      const res = await doFetch(`${base}/v1/tools/${toolId}/execute`, {
-        method: "POST",
-        headers: jsonHeaders,
-        body: JSON.stringify(payload)
-      });
-      return res.json();
-    }
-  };
-}
-
 // src/client.ts
 function createClient(initialCfg) {
   const runtimeCfg = {
@@ -436,20 +938,28 @@ function createClient(initialCfg) {
   const instructionsApi = createAgentInstructionsApi(runtimeCfg);
   const knowledgeApi = createAgentKnowledgeApi(runtimeCfg);
   const phonesApi = createAgentPhonesApi(runtimeCfg);
+  const scheduleApi = createAgentScheduleApi(runtimeCfg);
+  const versionsApi = createAgentVersionsApi(runtimeCfg);
+  const voicesApi = createVoicesApi(runtimeCfg);
   const agentsApi = createAgentsApi(runtimeCfg, {
     instructionsApi,
     knowledgeApi,
-    phonesApi
+    phonesApi,
+    scheduleApi,
+    versionsApi
   });
   const apis = {
     agents: {
       ...agentsApi,
       knowledge: knowledgeApi,
       instructions: instructionsApi,
-      phones: phonesApi
+      phones: phonesApi,
+      schedule: scheduleApi,
+      versions: versionsApi
     },
     workspaces: createWorkspacesApi(runtimeCfg),
-    tools: createToolsApi(runtimeCfg)
+    tools: createToolsApi(runtimeCfg),
+    voices: voicesApi
   };
   return {
     ...apis,
@@ -484,14 +994,19 @@ function createClient(initialCfg) {
   bindAgentInstructions,
   bindAgentKnowledge,
   bindAgentPhones,
+  bindAgentSchedule,
+  bindAgentVersions,
   createAgentEntity,
   createAgentInstructionsApi,
   createAgentKnowledgeApi,
   createAgentPhonesApi,
+  createAgentScheduleApi,
+  createAgentVersionsApi,
   createAgentsApi,
   createClient,
   createHttp,
   createToolsApi,
+  createVoicesApi,
   createWorkspacesApi
 });
 //# sourceMappingURL=index.cjs.map