@getsupervisor/agents-studio-sdk 1.1.0 → 1.3.0

package/dist/index.cjs

@@ -22,13 +22,22 @@ __export(index_exports, {
   HttpError: () => HttpError,
   NetworkError: () => NetworkError,
   TimeoutError: () => TimeoutError,
+  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);
@@ -62,6 +71,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));
 }
@@ -136,25 +175,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);
@@ -170,20 +215,157 @@ function createHttp(cfg) {
   };
 }
 
-// src/api/agents.ts
-function createAgentsApi(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 get(agentId) {
-      const res = await doFetch(`${base}/v1/agents/${agentId}`, {
-        method: "GET"
+    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 delete(agentId) {
-      await doFetch(`${base}/v1/agents/${agentId}`, {
-        method: "DELETE"
+    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"
+        }
+      );
     }
   };
 }
@@ -204,20 +386,24 @@ function createAgentKnowledgeApi(cfg) {
       );
       return res.json();
     },
-    async listBases(agentId) {
+    async listBases(agentId, opts = {}) {
+      const query = serializeListOptions(opts);
       const res = await doFetch(
         `${base}/v1/agents/${agentId}/knowledge/bases`,
         {
-          method: "GET"
+          method: "GET",
+          query
         }
       );
       return res.json();
     },
-    async listUploads(agentId) {
+    async listUploads(agentId, opts = {}) {
+      const query = serializeListOptions(opts);
       const res = await doFetch(
         `${base}/v1/agents/${agentId}/knowledge/uploads`,
         {
-          method: "GET"
+          method: "GET",
+          query
         }
       );
       return res.json();
@@ -225,75 +411,254 @@ function createAgentKnowledgeApi(cfg) {
   };
 }
 
-// src/api/agent-instructions.ts
-function createAgentInstructionsApi(cfg) {
+// src/api/agent-phones.ts
+function createAgentPhonesApi(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 create(agentId, payload) {
-      const res = await doFetch(`${base}/v1/agents/${agentId}/instructions`, {
+    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-phones.ts
-function createAgentPhonesApi(cfg) {
+// src/api/agent-schedule.ts
+function createAgentScheduleApi(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 get(agentId) {
+      const res = await doFetch(`${base}/v1/agents/${agentId}/schedule`, {
+        method: "GET"
       });
       return res.json();
     },
-    async disconnect(agentId, phoneId) {
-      await doFetch(`${base}/v1/agents/${agentId}/phones/${phoneId}`, {
-        method: "DELETE"
+    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/workspaces.ts
-function createWorkspacesApi(cfg) {
+// src/api/agent-versions.ts
+function createAgentVersionsApi(cfg) {
   const { base, doFetch } = createHttp(cfg);
   const jsonHeaders = { "content-type": "application/json" };
   return {
-    async listPhones(workspaceId, opts) {
-      const search = opts?.channel ? `?channel=${opts.channel}` : "";
+    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/workspaces/${workspaceId}/phones${search}`,
+        `${base}/v1/agents/${agentId}/versions/${versionId}`,
         {
           method: "GET"
         }
       );
       return res.json();
     },
-    async enable(workspaceId, payload) {
-      const res = await doFetch(`${base}/v1/workspaces/${workspaceId}/enable`, {
+    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 (options = {}) => {
+    const query = serializeListOptions(options);
+    const res = await doFetch(`${base}/v1/agents`, {
+      method: "GET",
+      query
+    });
+    return res.json();
+  };
+  const getAgentDetail = async (agentId) => {
+    const res = await doFetch(`${base}/v1/agents/${agentId}`, {
+      method: "GET"
+    });
+    return res.json();
+  };
+  const createAgent = async (payload) => {
+    const res = await doFetch(`${base}/v1/agents`, {
+      method: "POST",
+      body: JSON.stringify(payload),
+      headers: jsonHeaders
+    });
+    return res.json();
+  };
+  const updateAgent = async (agentId, payload) => {
+    const res = await doFetch(`${base}/v1/agents/${agentId}`, {
+      method: "PATCH",
+      body: JSON.stringify(payload),
+      headers: jsonHeaders
+    });
+    return res.json();
+  };
+  const deleteAgent = async (agentId) => {
+    await doFetch(`${base}/v1/agents/${agentId}`, {
+      method: "DELETE"
+    });
+  };
+  const baseApi = {
+    list: listAgents,
+    get: getAgentDetail,
+    create: createAgent,
+    update: updateAgent,
+    delete: deleteAgent
+  };
+  if (!relatedApis) {
+    return baseApi;
+  }
+  const wrapAgent = (detail) => createAgentEntity(detail, {
+    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);
+    }
+  });
+  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);
+    },
+    async create(payload) {
+      const detail = await createAgent(payload);
+      return wrapAgent(detail);
+    },
+    async update(agentId, payload) {
+      const detail = await updateAgent(agentId, payload);
+      return wrapAgent(detail);
     }
   };
 }
@@ -303,9 +668,11 @@ function createToolsApi(cfg) {
   const { base, doFetch } = createHttp(cfg);
   const jsonHeaders = { "content-type": "application/json" };
   return {
-    async list() {
+    async list(options = {}) {
+      const query = serializeListOptions(options);
       const res = await doFetch(`${base}/v1/tools`, {
-        method: "GET"
+        method: "GET",
+        query
       });
       return res.json();
     },
@@ -320,6 +687,76 @@ function createToolsApi(cfg) {
   };
 }
 
+// src/api/voices.ts
+function createVoicesApi(cfg) {
+  const { base, doFetch } = createHttp(cfg);
+  return {
+    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();
+    }
+  };
+}
+
+// src/api/workspaces.ts
+function createWorkspacesApi(cfg) {
+  const { base, doFetch } = createHttp(cfg);
+  const jsonHeaders = { "content-type": "application/json" };
+  return {
+    async listPhones(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();
+    },
+    async enable(workspaceId, payload) {
+      const res = await doFetch(`${base}/v1/workspaces/${workspaceId}/enable`, {
+        method: "POST",
+        headers: jsonHeaders,
+        body: JSON.stringify(payload)
+      });
+      return res.json();
+    }
+  };
+}
+
 // src/client.ts
 function createClient(initialCfg) {
   const runtimeCfg = {
@@ -332,15 +769,31 @@ function createClient(initialCfg) {
   const setWorkspaceGetter = (getter) => {
     runtimeCfg.getWorkspaceId = getter;
   };
+  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,
+    scheduleApi,
+    versionsApi
+  });
   const apis = {
     agents: {
-      ...createAgentsApi(runtimeCfg),
-      knowledge: createAgentKnowledgeApi(runtimeCfg),
-      instructions: createAgentInstructionsApi(runtimeCfg),
-      phones: createAgentPhonesApi(runtimeCfg)
+      ...agentsApi,
+      knowledge: knowledgeApi,
+      instructions: instructionsApi,
+      phones: phonesApi,
+      schedule: scheduleApi,
+      versions: versionsApi
     },
     workspaces: createWorkspacesApi(runtimeCfg),
-    tools: createToolsApi(runtimeCfg)
+    tools: createToolsApi(runtimeCfg),
+    voices: voicesApi
   };
   return {
     ...apis,
@@ -372,13 +825,22 @@ function createClient(initialCfg) {
   HttpError,
   NetworkError,
   TimeoutError,
+  bindAgentInstructions,
+  bindAgentKnowledge,
+  bindAgentPhones,
+  bindAgentSchedule,
+  bindAgentVersions,
+  createAgentEntity,
   createAgentInstructionsApi,
   createAgentKnowledgeApi,
   createAgentPhonesApi,
+  createAgentScheduleApi,
+  createAgentVersionsApi,
   createAgentsApi,
   createClient,
   createHttp,
   createToolsApi,
+  createVoicesApi,
   createWorkspacesApi
 });
 //# sourceMappingURL=index.cjs.map