@getsupervisor/agents-studio-sdk 1.41.2-patch.15 → 1.41.2-patch.17

package/dist/index.js

@@ -890,102 +890,6 @@ 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 void 0;
-  }
-  try {
-    const parsed = JSON.parse(event.data);
-    handler(parsed);
-    return parsed;
-  } catch {
-    return void 0;
-  }
-}
-function processRawPart(raw, handlers, resolveEvent) {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return void 0;
-  }
-  const event = parseSseMessage(trimmed);
-  if (!event) {
-    return void 0;
-  }
-  const result = dispatchSseEvent(event, handlers);
-  if (event.type !== resolveEvent) {
-    return void 0;
-  }
-  return result;
-}
-function flushRemainingBuffer(buffer) {
-  if (!buffer.trim()) {
-    return "";
-  }
-  return buffer + "\n\n";
-}
-function consumeSseStream(response, handlers, resolveEvent) {
-  if (!response.body) {
-    throw new Error("No response body for SSE stream");
-  }
-  return new Promise((resolve, reject) => {
-    let resolved;
-    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 finalize = () => {
-      buffer = flushRemainingBuffer(buffer);
-      processBuffer();
-      if (resolved) {
-        resolve(resolved);
-        return;
-      }
-      reject(new Error(`SSE stream ended without '${resolveEvent}' event`));
-    };
-    const read = () => {
-      reader.read().then(({ done, value }) => {
-        if (done) {
-          finalize();
-          return;
-        }
-        buffer += decoder.decode(value, { stream: true });
-        processBuffer();
-        read();
-      }).catch(reject);
-    };
-    read();
-  });
-}
-
 // src/entities/agent.ts
 var bindAgentStageTriggers = (api, agentId, blueprintId, stageId) => ({
   list(opts) {
@@ -1206,36 +1110,8 @@ 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) {
-  return {
-    "agent-created": (data) => callbacks.onAgentCreated?.(data),
-    "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, buildHeaders, resolveWorkspaceId, resolveApiKey } = createHttp(cfg);
-  const jsonHeaders = { "content-type": "application/json" };
+  const { base, doFetch, resolveWorkspaceId, resolveApiKey } = createHttp(cfg);
   const requireWorkspace = () => {
     const workspaceId = resolveWorkspaceId();
     if (typeof workspaceId === "string" && workspaceId.trim().length > 0) {
@@ -1247,144 +1123,167 @@ function createAgentsApi(cfg, relatedApis) {
     }
     throw new WorkspaceNotSelectedError();
   };
-  const postJson = async (url, payload) => {
+  const jsonHeaders = { "content-type": "application/json" };
+  const normalizeCloneSelection = (selection) => {
+    if (!selection) {
+      return [];
+    }
+    if (Array.isArray(selection)) {
+      return selection;
+    }
+    return Object.entries(selection).filter(([, enabled]) => enabled).map(([component]) => component);
+  };
+  const buildCloneAgentRequest = (payload) => {
+    const { clone, ...rest } = payload;
+    return {
+      ...rest,
+      clone: normalizeCloneSelection(clone)
+    };
+  };
+  const fetchAgentsPage = async (options = {}) => {
     requireWorkspace();
-    const res = await doFetch(url, {
+    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`, {
       method: "POST",
       body: JSON.stringify(payload),
       headers: jsonHeaders
     });
     return res.json();
   };
-  const postWithSse = async (url, payload, callbacks) => {
+  const forkAgentFromTemplate = async (payload) => {
     requireWorkspace();
-    const headers = buildHeaders({ "content-type": "application/json" });
-    const fx = cfg.fetchImpl ?? fetch;
-    const res = await fx(url, {
+    const res = await doFetch(`${base}/agents/from-template`, {
       method: "POST",
       body: JSON.stringify(payload),
-      headers
+      headers: jsonHeaders
     });
-    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"
-    );
+    return res.json();
   };
-  const fetchPage = async (options = {}) => {
+  const cloneAgent = async (agentId, payload) => {
     requireWorkspace();
-    const query = serializeListOptions({
-      page: options.page,
-      limit: options.limit,
-      filter: options.filter
+    const requestPayload = buildCloneAgentRequest(payload);
+    const res = await doFetch(`${base}/agents/${agentId}/clone`, {
+      method: "POST",
+      body: JSON.stringify(requestPayload),
+      headers: jsonHeaders
     });
-    const res = await doFetch(`${base}/agents`, { method: "GET", query });
     return res.json();
   };
+  const updateAgent = async (agentId, payload) => {
+    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 deleteAgent = async (agent) => {
+    requireWorkspace();
+    const agentId = resolveAgentId(agent);
+    await doFetch(`${base}/agents/${agentId}`, {
+      method: "DELETE"
+    });
+  };
   const baseApi = {
-    async list(options = {}) {
-      const opts = { ...options ?? {} };
-      const response = await fetchPage(opts);
-      return attachPaginator(response, fetchPage, opts);
-    },
-    async get(agentId) {
-      requireWorkspace();
-      const res = await doFetch(`${base}/agents/${agentId}`, { method: "GET" });
-      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 update(agentId, payload) {
-      requireWorkspace();
-      const res = await doFetch(`${base}/agents/${agentId}`, {
-        method: "PATCH",
-        body: JSON.stringify(payload),
-        headers: jsonHeaders
-      });
-      return res.json();
-    },
-    async presignDocuments(files) {
-      return postJson(`${base}/documents`, { files });
-    },
-    async delete(agent) {
-      requireWorkspace();
-      await doFetch(`${base}/agents/${resolveAgentId(agent)}`, {
-        method: "DELETE"
-      });
-    }
+    list: listAgents,
+    get: getAgentDetail,
+    create: createAgent,
+    clone: cloneAgent,
+    forkFromTemplate: forkAgentFromTemplate,
+    update: updateAgent,
+    delete: deleteAgent
   };
   if (!relatedApis) {
     return baseApi;
   }
-  return withEntityWrapping(baseApi, fetchPage, relatedApis);
-}
-function withEntityWrapping(api, fetchPage, deps) {
   const wrapAgent = (detail) => createAgentEntity(detail, {
-    ...deps,
+    tagsApi: relatedApis.tagsApi,
+    phonesApi: relatedApis.phonesApi,
+    scheduleApi: relatedApis.scheduleApi,
+    scheduleExceptionsApi: relatedApis.scheduleExceptionsApi,
+    versionsApi: relatedApis.versionsApi,
+    blueprintsApi: relatedApis.blueprintsApi,
+    stagesApi: relatedApis.stagesApi,
+    stageTriggersApi: relatedApis.stageTriggersApi,
     reload: async (agentId) => {
-      const latest = await api.get(agentId);
+      const latest = await getAgentDetail(agentId);
       return wrapAgent(latest);
     },
     updateAgent: async (agentId, payload) => {
-      const updated = await api.update(agentId, payload);
+      const updated = await updateAgent(agentId, payload);
       return wrapAgent(updated);
     },
     deleteAgent: async (agentId) => {
-      await api.delete(agentId);
+      await deleteAgent(agentId);
     },
     cloneAgent: async (agentId, payload) => {
-      const cloned = await api.clone(agentId, payload);
+      const cloned = await cloneAgent(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 {
-    ...api,
+    ...baseApi,
     async list(options = {}) {
-      const opts = { ...options ?? {} };
-      const initial = await wrapList(opts);
-      return attachPaginator(initial, wrapList, opts);
+      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) {
-      return wrapAgent(await api.get(agentId));
+      const detail = await getAgentDetail(agentId);
+      return wrapAgent(detail);
     },
-    async create(payload, callbacks) {
-      return wrapAgent(await api.create(payload, callbacks));
+    async create(payload) {
+      const detail = await createAgent(payload);
+      return wrapAgent(detail);
     },
     async clone(agentId, payload) {
-      return wrapAgent(await api.clone(agentId, payload));
+      const detail = await cloneAgent(agentId, payload);
+      return wrapAgent(detail);
     },
-    async forkFromTemplate(payload, callbacks) {
-      return wrapAgent(await api.forkFromTemplate(payload, callbacks));
+    async forkFromTemplate(payload) {
+      const detail = await forkAgentFromTemplate(payload);
+      return wrapAgent(detail);
     },
     async update(agentId, payload) {
-      return wrapAgent(await api.update(agentId, payload));
+      const detail = await updateAgent(agentId, payload);
+      return wrapAgent(detail);
     }
   };
 }
@@ -1511,10 +1410,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
@@ -1568,6 +1464,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();
     }
   };
 }