@getsupervisor/agents-studio-sdk 1.2.0 → 1.3.0

package/dist/index.js

@@ -1,45 +1,3 @@
-// src/entities/agent.ts
-var bindAgentInstructions = (api, agentId) => ({
-  list(opts) {
-    return api.list(agentId, opts);
-  },
-  create(payload) {
-    return api.create(agentId, payload);
-  }
-});
-var bindAgentKnowledge = (api, agentId) => ({
-  upload(payload) {
-    return api.upload(agentId, payload);
-  },
-  listBases() {
-    return api.listBases(agentId);
-  },
-  listUploads() {
-    return api.listUploads(agentId);
-  }
-});
-var bindAgentPhones = (api, agentId) => ({
-  connect(payload) {
-    return api.connect(agentId, payload);
-  },
-  disconnect(phoneId) {
-    return api.disconnect(agentId, phoneId);
-  }
-});
-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);
-    }
-  };
-  return Object.freeze(entity);
-};
-
 // src/errors.ts
 var HttpError = class extends Error {
   constructor(status, statusText, body, url) {
@@ -69,6 +27,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));
 }
@@ -143,25 +131,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);
@@ -177,13 +171,378 @@ 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" };
+  return {
+    async list(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();
+    },
+    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" };
+  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 query = serializeListOptions(opts);
+      const res = await doFetch(
+        `${base}/v1/agents/${agentId}/knowledge/bases`,
+        {
+          method: "GET",
+          query
+        }
+      );
+      return res.json();
+    },
+    async listUploads(agentId, opts = {}) {
+      const query = serializeListOptions(opts);
+      const res = await doFetch(
+        `${base}/v1/agents/${agentId}/knowledge/uploads`,
+        {
+          method: "GET",
+          query
+        }
+      );
+      return res.json();
+    }
+  };
+}
+
+// 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" };
+  return {
+    async list(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();
+    },
+    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
+  } = 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 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 listAgents = async (options = {}) => {
+    const query = serializeListOptions(options);
     const res = await doFetch(`${base}/v1/agents`, {
-      method: "GET"
+      method: "GET",
+      query
     });
     return res.json();
   };
@@ -228,6 +587,8 @@ 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);
@@ -235,6 +596,14 @@ function createAgentsApi(cfg, relatedApis) {
   });
   return {
     ...baseApi,
+    async list(options = {}) {
+      const response = await listAgents(options);
+      const items = Array.isArray(response.data) ? response.data : [];
+      return {
+        ...response,
+        data: items.map((summary) => wrapAgent(summary))
+      };
+    },
     async get(agentId) {
       const detail = await getAgentDetail(agentId);
       return wrapAgent(detail);
@@ -250,60 +619,21 @@ function createAgentsApi(cfg, relatedApis) {
   };
 }
 
-// src/api/agent-knowledge.ts
-function createAgentKnowledgeApi(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();
-    }
-  };
-}
-
-// src/api/agent-instructions.ts
-function createAgentInstructionsApi(cfg) {
+// src/api/tools.ts
+function createToolsApi(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"
-        }
-      );
+    async list(options = {}) {
+      const query = serializeListOptions(options);
+      const res = await doFetch(`${base}/v1/tools`, {
+        method: "GET",
+        query
+      });
       return res.json();
     },
-    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)
@@ -313,23 +643,35 @@ 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" };
   return {
-    async connect(agentId, payload) {
-      const res = await doFetch(`${base}/v1/agents/${agentId}/phones`, {
-        method: "POST",
-        headers: jsonHeaders,
-        body: JSON.stringify(payload)
+    async list(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();
-    },
-    async disconnect(agentId, phoneId) {
-      await doFetch(`${base}/v1/agents/${agentId}/phones/${phoneId}`, {
-        method: "DELETE"
-      });
     }
   };
 }
@@ -339,14 +681,25 @@ function createWorkspacesApi(cfg) {
   const { base, doFetch } = createHttp(cfg);
   const jsonHeaders = { "content-type": "application/json" };
   return {
-    async listPhones(workspaceId, opts) {
-      const search = opts?.channel ? `?channel=${opts.channel}` : "";
-      const res = await doFetch(
-        `${base}/v1/workspaces/${workspaceId}/phones${search}`,
+    async listPhones(workspaceId, opts = {}) {
+      const { channel } = opts;
+      const query = serializeListOptions(
         {
-          method: "GET"
-        }
+          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();
     },
     async enable(workspaceId, payload) {
@@ -360,28 +713,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 = {
@@ -397,20 +728,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,
@@ -444,14 +783,19 @@ export {
   bindAgentInstructions,
   bindAgentKnowledge,
   bindAgentPhones,
+  bindAgentSchedule,
+  bindAgentVersions,
   createAgentEntity,
   createAgentInstructionsApi,
   createAgentKnowledgeApi,
   createAgentPhonesApi,
+  createAgentScheduleApi,
+  createAgentVersionsApi,
   createAgentsApi,
   createClient,
   createHttp,
   createToolsApi,
+  createVoicesApi,
   createWorkspacesApi
 };
 //# sourceMappingURL=index.js.map