swarmlord 0.1.0

package/dist/index.cjs

@@ -0,0 +1,670 @@
+'use strict';
+
+function parseSSEStream(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  return {
+    [Symbol.asyncIterator]() {
+      return {
+        async next() {
+          while (true) {
+            const eventEnd = buffer.indexOf("\n\n");
+            if (eventEnd !== -1) {
+              const raw = buffer.slice(0, eventEnd);
+              buffer = buffer.slice(eventEnd + 2);
+              let type = "";
+              let data = "";
+              for (const line of raw.split("\n")) {
+                if (line.startsWith("event: ")) type = line.slice(7);
+                else if (line.startsWith("data: ")) data = line.slice(6);
+              }
+              if (type) return { value: { type, data }, done: false };
+              continue;
+            }
+            const { done, value } = await reader.read();
+            if (done) return { value: void 0, done: true };
+            buffer += decoder.decode(value, { stream: true });
+          }
+        }
+      };
+    }
+  };
+}
+function toAgentEvent(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw.data);
+  } catch {
+    return null;
+  }
+  switch (raw.type) {
+    case "message.part.delta": {
+      const delta = parsed.delta;
+      const field = parsed.field;
+      if (field === "text" && delta) return { type: "text-delta", delta };
+      if (field === "reasoning" && delta) return { type: "reasoning-delta", delta };
+      return null;
+    }
+    case "message.part.updated": {
+      const part = parsed.part;
+      if (!part) return null;
+      if (part.type === "tool") {
+        const toolPart = part;
+        if (toolPart.state.status === "running") return { type: "tool-start", part: toolPart };
+        if (toolPart.state.status === "completed") {
+          if (toolPart.state.attachments) {
+            for (const file of toolPart.state.attachments) {
+            }
+          }
+          return { type: "tool-complete", part: toolPart };
+        }
+        if (toolPart.state.status === "error") {
+          return { type: "tool-error", part: toolPart, error: toolPart.state.error };
+        }
+        return null;
+      }
+      if (part.type === "step-finish") {
+        const sfp = part;
+        return { type: "step-finish", tokens: sfp.tokens, cost: sfp.cost, reason: sfp.reason };
+      }
+      if (part.type === "file") {
+        return { type: "attachment", file: part };
+      }
+      return null;
+    }
+    case "message.updated": {
+      const info = parsed.info ?? parsed;
+      return { type: "message-updated", info };
+    }
+    case "session.status": {
+      const status = parsed.status;
+      return status ? { type: "status-change", status } : null;
+    }
+    case "session.idle":
+      return { type: "session-idle", sessionId: parsed.sessionID ?? "" };
+    case "session.error":
+      return { type: "error", error: parsed.error ?? "Unknown error" };
+    case "permission.asked":
+      return { type: "permission-asked", request: parsed };
+    default:
+      return null;
+  }
+}
+
+function createSessionHandle(id, opts, agentConfig) {
+  const { apiKey, baseUrl } = opts;
+  function headers() {
+    return { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" };
+  }
+  function buildMessageBody(input) {
+    if (typeof input === "string") {
+      return {
+        content: input,
+        agent: agentConfig?.name,
+        model: agentConfig?.model,
+        config: agentConfig?.config
+      };
+    }
+    return {
+      parts: input.parts,
+      agent: input.agent ?? agentConfig?.name,
+      model: input.model ?? agentConfig?.model,
+      config: input.config ?? agentConfig?.config
+    };
+  }
+  return {
+    id,
+    async send(input, callbacks) {
+      const res = await fetch(`${baseUrl}/session/${id}/message`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(buildMessageBody(input))
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        const err = new Error(`Agent error (${res.status}): ${text}`);
+        callbacks?.onError?.(err);
+        throw err;
+      }
+      if (!res.body) throw new Error("No response body");
+      callbacks?.onConnect?.();
+      const parts = [];
+      let messageId = "";
+      let fullText = "";
+      let finalTokens;
+      let finalCost;
+      let finalError;
+      for await (const raw of parseSSEStream(res.body)) {
+        const event = toAgentEvent(raw);
+        if (!event) continue;
+        switch (event.type) {
+          case "text-delta":
+            fullText += event.delta;
+            callbacks?.onText?.(event.delta);
+            break;
+          case "reasoning-delta":
+            callbacks?.onReasoning?.(event.delta);
+            break;
+          case "tool-start":
+            parts.push(event.part);
+            callbacks?.onToolStart?.(event.part);
+            break;
+          case "tool-complete": {
+            replacePart(parts, event.part);
+            callbacks?.onToolComplete?.(event.part);
+            if (event.part.state.status === "completed" && event.part.state.attachments) {
+              for (const file of event.part.state.attachments) {
+                callbacks?.onAttachment?.(file);
+              }
+            }
+            break;
+          }
+          case "tool-error": {
+            replacePart(parts, event.part);
+            callbacks?.onToolError?.(event.part, event.error);
+            break;
+          }
+          case "step-finish":
+            callbacks?.onStepFinish?.(event.tokens, event.cost);
+            break;
+          case "attachment":
+            callbacks?.onAttachment?.(event.file);
+            break;
+          case "permission-asked":
+            if (callbacks?.onPermission) {
+              const reply = await callbacks.onPermission(event.request);
+              await fetch(`${baseUrl}/session/${id}/permission/${event.request.id}`, {
+                method: "POST",
+                headers: headers(),
+                body: JSON.stringify({ reply })
+              });
+            }
+            break;
+          case "status-change":
+            callbacks?.onStatus?.(event.status);
+            break;
+          case "message-updated": {
+            const info = event.info;
+            if (info.id) messageId = info.id;
+            if (info.role === "assistant") {
+              finalTokens = info.tokens;
+              finalCost = info.cost;
+              if (info.error) finalError = info.error;
+            }
+            break;
+          }
+          case "error":
+            callbacks?.onError?.(new Error(event.error));
+            break;
+        }
+      }
+      return { messageId, text: fullText, parts, tokens: finalTokens, cost: finalCost, error: finalError };
+    },
+    async *stream(input) {
+      const res = await fetch(`${baseUrl}/session/${id}/message`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify(buildMessageBody(input))
+      });
+      if (!res.ok) throw new Error(`Agent error (${res.status}): ${await res.text()}`);
+      if (!res.body) throw new Error("No response body");
+      yield { type: "connect" };
+      for await (const raw of parseSSEStream(res.body)) {
+        const event = toAgentEvent(raw);
+        if (event) yield event;
+      }
+    },
+    async abort() {
+      const res = await fetch(`${baseUrl}/session/${id}/abort`, { method: "POST", headers: headers() });
+      if (!res.ok) throw new Error(`Failed to abort: ${res.status}`);
+    },
+    async summarize() {
+      const res = await fetch(`${baseUrl}/session/${id}/summarize`, { method: "POST", headers: headers() });
+      if (!res.ok) throw new Error(`Failed to summarize: ${res.status}`);
+    },
+    async revert(messageId) {
+      const res = await fetch(`${baseUrl}/session/${id}/revert`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify({ messageId })
+      });
+      if (!res.ok) throw new Error(`Failed to revert: ${res.status}`);
+    },
+    async shell(command, shellOpts) {
+      const res = await fetch(`${baseUrl}/session/${id}/shell`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify({ command, ...shellOpts })
+      });
+      if (!res.ok) throw new Error(`Shell error: ${res.status}`);
+      return res.json();
+    },
+    async getInfo() {
+      const res = await fetch(`${baseUrl}/session/${id}`, { headers: headers() });
+      if (!res.ok) throw new Error(`Failed to get session: ${res.status}`);
+      return res.json();
+    },
+    async getMessages() {
+      const res = await fetch(`${baseUrl}/session/${id}/message`, { headers: headers() });
+      if (!res.ok) throw new Error(`Failed to get messages: ${res.status}`);
+      return res.json();
+    },
+    async getMetrics() {
+      const res = await fetch(`${baseUrl}/session/${id}/metrics`, { headers: headers() });
+      if (!res.ok) throw new Error(`Failed to get metrics: ${res.status}`);
+      return res.json();
+    },
+    async getTodos() {
+      const res = await fetch(`${baseUrl}/session/${id}/todo`, { headers: headers() });
+      if (!res.ok) throw new Error(`Failed to get todos: ${res.status}`);
+      return res.json();
+    },
+    async getFile(path) {
+      const res = await fetch(`${baseUrl}/session/${id}/file?path=${encodeURIComponent(path)}`, {
+        headers: { Authorization: `Bearer ${apiKey}` }
+      });
+      if (!res.ok) throw new Error(`Failed to get file: ${res.status}`);
+      return res.text();
+    },
+    async getFileBuffer(path) {
+      const res = await fetch(`${baseUrl}/session/${id}/file?path=${encodeURIComponent(path)}&encoding=base64`, {
+        headers: { Authorization: `Bearer ${apiKey}` }
+      });
+      if (!res.ok) throw new Error(`Failed to get file: ${res.status}`);
+      const b64 = await res.text();
+      const bin = atob(b64);
+      const bytes = new Uint8Array(bin.length);
+      for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+      return bytes.buffer;
+    },
+    async getArtifact(key) {
+      const res = await fetch(`${baseUrl}/session/${id}/artifact/${encodeURIComponent(key)}`, {
+        headers: { Authorization: `Bearer ${apiKey}` }
+      });
+      if (!res.ok) throw new Error(`Failed to get artifact: ${res.status}`);
+      return res.text();
+    },
+    async getArtifactBuffer(key) {
+      const res = await fetch(`${baseUrl}/session/${id}/artifact/${encodeURIComponent(key)}`, {
+        headers: { Authorization: `Bearer ${apiKey}` }
+      });
+      if (!res.ok) throw new Error(`Failed to get artifact: ${res.status}`);
+      return res.arrayBuffer();
+    },
+    async update(updateOpts) {
+      const res = await fetch(`${baseUrl}/session/${id}`, {
+        method: "PATCH",
+        headers: headers(),
+        body: JSON.stringify(updateOpts)
+      });
+      if (!res.ok) throw new Error(`Failed to update session: ${res.status}`);
+    },
+    async delete() {
+      const res = await fetch(`${baseUrl}/session/${id}`, { method: "DELETE", headers: headers() });
+      if (!res.ok) throw new Error(`Failed to delete session: ${res.status}`);
+    },
+    async runCommand(name, args) {
+      const res = await fetch(`${baseUrl}/session/${id}/command`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify({ name, args })
+      });
+      if (!res.ok) throw new Error(`Failed to run command: ${res.status}`);
+      const data = await res.json();
+      return data.result ?? "";
+    },
+    async replyToPermission(requestId, reply, message) {
+      const res = await fetch(`${baseUrl}/session/${id}/permission/${requestId}`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify({ reply, message })
+      });
+      if (!res.ok) throw new Error(`Failed to reply to permission: ${res.status}`);
+    },
+    async events(lastEventId) {
+      const reqHeaders = { Authorization: `Bearer ${apiKey}` };
+      if (lastEventId !== void 0) reqHeaders["Last-Event-ID"] = String(lastEventId);
+      const res = await fetch(`${baseUrl}/session/${id}/events`, { headers: reqHeaders });
+      if (!res.ok) throw new Error(`Failed to connect to events: ${res.status}`);
+      if (!res.body) throw new Error("No response body");
+      return res.body;
+    }
+  };
+}
+function replacePart(parts, updated) {
+  const idx = parts.findIndex((p) => p.id === updated.id);
+  if (idx !== -1) parts[idx] = updated;
+  else parts.push(updated);
+}
+
+const POLL_INITIAL_MS = 1e3;
+const POLL_MAX_MS = 15e3;
+const POLL_BACKOFF = 1.5;
+function createTaskHandle(sessionId, opts) {
+  const { apiKey, baseUrl } = opts;
+  function headers() {
+    return { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" };
+  }
+  return {
+    id: sessionId,
+    async poll() {
+      const res = await fetch(`${baseUrl}/session/${sessionId}/status`, { headers: headers() });
+      if (!res.ok) throw new Error(`Failed to poll task: ${res.status}`);
+      const data = await res.json();
+      return data.status;
+    },
+    async result(resultOpts) {
+      const timeout = resultOpts?.timeoutMs ?? 6e5;
+      const deadline = Date.now() + timeout;
+      let interval = POLL_INITIAL_MS;
+      while (Date.now() < deadline) {
+        const status = await this.poll();
+        if (status === "idle" || status === "error") {
+          const msgRes = await fetch(`${baseUrl}/session/${sessionId}/message`, { headers: headers() });
+          if (!msgRes.ok) throw new Error(`Failed to get task result: ${msgRes.status}`);
+          const messages = await msgRes.json();
+          const lastAssistant = messages.findLast((m) => m.info.role === "assistant");
+          const textParts = lastAssistant?.parts.filter((p) => p.type === "text") ?? [];
+          const text = textParts.map((p) => p.text).join("\n");
+          let tokens;
+          let cost;
+          if (lastAssistant?.info.role === "assistant") {
+            const aInfo = lastAssistant.info;
+            tokens = aInfo.tokens;
+            cost = aInfo.cost;
+          }
+          return {
+            sessionId,
+            status: status === "error" ? "error" : "completed",
+            text,
+            messages,
+            tokens,
+            cost
+          };
+        }
+        await new Promise((resolve) => setTimeout(resolve, interval));
+        interval = Math.min(interval * POLL_BACKOFF, POLL_MAX_MS);
+      }
+      throw new Error(`Task timed out after ${timeout}ms`);
+    },
+    async cancel() {
+      const res = await fetch(`${baseUrl}/session/${sessionId}/abort`, {
+        method: "POST",
+        headers: headers()
+      });
+      if (!res.ok) throw new Error(`Failed to cancel task: ${res.status}`);
+    }
+  };
+}
+async function launchTask(opts, prompt, agentConfig, taskOpts) {
+  const { apiKey, baseUrl } = opts;
+  function headers() {
+    return { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" };
+  }
+  const createRes = await fetch(`${baseUrl}/session`, {
+    method: "POST",
+    headers: headers(),
+    body: JSON.stringify({
+      title: taskOpts?.title ?? `Task: ${prompt.slice(0, 50)}`,
+      config: agentConfig?.config,
+      webhook: taskOpts?.webhook
+    })
+  });
+  if (!createRes.ok) throw new Error(`Failed to create task session: ${createRes.status}`);
+  const session = await createRes.json();
+  const promptRes = await fetch(`${baseUrl}/session/${session.id}/prompt_async`, {
+    method: "POST",
+    headers: headers(),
+    body: JSON.stringify({
+      content: prompt,
+      agent: agentConfig?.name,
+      model: agentConfig?.model
+    })
+  });
+  if (!promptRes.ok) throw new Error(`Failed to start task: ${promptRes.status}`);
+  return createTaskHandle(session.id, opts);
+}
+
+function createScheduleHandle(id, opts) {
+  const { apiKey, baseUrl } = opts;
+  function headers() {
+    return { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" };
+  }
+  return {
+    id,
+    async trigger() {
+      const res = await fetch(`${baseUrl}/background/${id}/trigger`, {
+        method: "POST",
+        headers: headers()
+      });
+      if (!res.ok) throw new Error(`Failed to trigger schedule: ${res.status}`);
+      const data = await res.json();
+      return createTaskHandle(data.sessionId, opts);
+    },
+    async pause() {
+      const res = await fetch(`${baseUrl}/background/${id}`, {
+        method: "PATCH",
+        headers: headers(),
+        body: JSON.stringify({ enabled: false })
+      });
+      if (!res.ok) throw new Error(`Failed to pause schedule: ${res.status}`);
+    },
+    async resume() {
+      const res = await fetch(`${baseUrl}/background/${id}`, {
+        method: "PATCH",
+        headers: headers(),
+        body: JSON.stringify({ enabled: true })
+      });
+      if (!res.ok) throw new Error(`Failed to resume schedule: ${res.status}`);
+    },
+    async update(updateOpts) {
+      const res = await fetch(`${baseUrl}/background/${id}`, {
+        method: "PATCH",
+        headers: headers(),
+        body: JSON.stringify(updateOpts)
+      });
+      if (!res.ok) throw new Error(`Failed to update schedule: ${res.status}`);
+    },
+    async delete() {
+      const res = await fetch(`${baseUrl}/background/${id}`, {
+        method: "DELETE",
+        headers: headers()
+      });
+      if (!res.ok) throw new Error(`Failed to delete schedule: ${res.status}`);
+    }
+  };
+}
+async function createSchedule(opts, agentConfig, scheduleOpts) {
+  const { apiKey, baseUrl } = opts;
+  const res = await fetch(`${baseUrl}/background`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+    body: JSON.stringify({
+      cron: scheduleOpts.cron,
+      prompt: scheduleOpts.prompt,
+      model: scheduleOpts.model ?? agentConfig?.model ?? "anthropic/claude-sonnet-4-20250514",
+      agent: agentConfig?.name,
+      config: agentConfig?.config
+    })
+  });
+  if (!res.ok) throw new Error(`Failed to create schedule: ${res.status}`);
+  const data = await res.json();
+  return createScheduleHandle(data.id, opts);
+}
+
+function createTriggerHandle(id, webhookUrl, webhookSecret, opts) {
+  const { apiKey, baseUrl } = opts;
+  function headers() {
+    return { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" };
+  }
+  return {
+    id,
+    webhookUrl,
+    webhookSecret,
+    async pause() {
+      const res = await fetch(`${baseUrl}/trigger/${id}`, {
+        method: "PATCH",
+        headers: headers(),
+        body: JSON.stringify({ enabled: false })
+      });
+      if (!res.ok) throw new Error(`Failed to pause trigger: ${res.status}`);
+    },
+    async resume() {
+      const res = await fetch(`${baseUrl}/trigger/${id}`, {
+        method: "PATCH",
+        headers: headers(),
+        body: JSON.stringify({ enabled: true })
+      });
+      if (!res.ok) throw new Error(`Failed to resume trigger: ${res.status}`);
+    },
+    async update(updateOpts) {
+      const res = await fetch(`${baseUrl}/trigger/${id}`, {
+        method: "PATCH",
+        headers: headers(),
+        body: JSON.stringify(updateOpts)
+      });
+      if (!res.ok) throw new Error(`Failed to update trigger: ${res.status}`);
+    },
+    async delete() {
+      const res = await fetch(`${baseUrl}/trigger/${id}`, {
+        method: "DELETE",
+        headers: headers()
+      });
+      if (!res.ok) throw new Error(`Failed to delete trigger: ${res.status}`);
+    },
+    async getInfo() {
+      const res = await fetch(`${baseUrl}/trigger/${id}`, { headers: headers() });
+      if (!res.ok) throw new Error(`Failed to get trigger: ${res.status}`);
+      return res.json();
+    }
+  };
+}
+async function launchTrigger(opts, agentConfig, triggerOpts) {
+  const { apiKey, baseUrl } = opts;
+  const res = await fetch(`${baseUrl}/trigger`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+    body: JSON.stringify({
+      provider: triggerOpts.provider,
+      events: triggerOpts.events,
+      promptTemplate: triggerOpts.promptTemplate,
+      agent: agentConfig?.name,
+      model: agentConfig?.model ?? triggerOpts.model,
+      providerConfig: triggerOpts.providerConfig,
+      agentConfig: agentConfig?.config,
+      outputs: triggerOpts.outputs
+    })
+  });
+  if (!res.ok) throw new Error(`Failed to create trigger: ${res.status}`);
+  const data = await res.json();
+  return createTriggerHandle(data.id, data.webhookUrl, data.webhookSecret, opts);
+}
+
+function createAgentHandle(clientOpts, config) {
+  const { apiKey, baseUrl } = clientOpts;
+  return {
+    config,
+    async createSession(sessionOpts) {
+      const res = await fetch(`${baseUrl}/session`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+        body: JSON.stringify({
+          title: sessionOpts?.title,
+          config: config.config,
+          webhook: sessionOpts?.webhook
+        })
+      });
+      if (!res.ok) throw new Error(`Failed to create session: ${res.status}`);
+      const data = await res.json();
+      return createSessionHandle(data.id, clientOpts, config);
+    },
+    session(id) {
+      return createSessionHandle(id, clientOpts, config);
+    },
+    async forkSession(id) {
+      const res = await fetch(`${baseUrl}/session/${id}/fork`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" }
+      });
+      if (!res.ok) throw new Error(`Failed to fork session: ${res.status}`);
+      const data = await res.json();
+      return createSessionHandle(data.id, clientOpts, config);
+    },
+    async run(prompt, runOpts) {
+      return launchTask(clientOpts, prompt, config, runOpts);
+    },
+    async schedule(scheduleOpts) {
+      return createSchedule(clientOpts, config, scheduleOpts);
+    },
+    async trigger(triggerOpts) {
+      return launchTrigger(clientOpts, config, triggerOpts);
+    }
+  };
+}
+
+const DEFAULT_BASE_URL = "https://api.swarmlord.ai";
+function createClient(opts) {
+  const baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+  const normalizedOpts = { ...opts, baseUrl };
+  function headers() {
+    return { Authorization: `Bearer ${opts.apiKey}`, "Content-Type": "application/json" };
+  }
+  return {
+    agent(nameOrConfig) {
+      const config = typeof nameOrConfig === "string" ? { name: nameOrConfig } : nameOrConfig;
+      return createAgentHandle(normalizedOpts, config);
+    },
+    session(id) {
+      return createSessionHandle(id, normalizedOpts);
+    },
+    task(sessionId) {
+      return createTaskHandle(sessionId, normalizedOpts);
+    },
+    schedule(id) {
+      return createScheduleHandle(id, normalizedOpts);
+    },
+    trigger(id) {
+      return createTriggerHandle(id, "", "", normalizedOpts);
+    },
+    async listSessions(listOpts) {
+      const params = new URLSearchParams();
+      if (listOpts?.limit) params.set("limit", String(listOpts.limit));
+      if (listOpts?.archived !== void 0) params.set("archived", String(listOpts.archived));
+      const qs = params.toString();
+      const res = await fetch(`${baseUrl}/session${qs ? `?${qs}` : ""}`, { headers: headers() });
+      if (!res.ok) throw new Error(`Failed to list sessions: ${res.status}`);
+      return res.json();
+    },
+    async listSchedules() {
+      const res = await fetch(`${baseUrl}/background`, { headers: headers() });
+      if (!res.ok) throw new Error(`Failed to list schedules: ${res.status}`);
+      return res.json();
+    },
+    async listTriggers() {
+      const res = await fetch(`${baseUrl}/trigger`, { headers: headers() });
+      if (!res.ok) throw new Error(`Failed to list triggers: ${res.status}`);
+      return res.json();
+    },
+    async getConfig() {
+      const res = await fetch(`${baseUrl}/config`, { headers: headers() });
+      if (!res.ok) throw new Error(`Failed to get config: ${res.status}`);
+      return res.json();
+    },
+    async updateConfig(config) {
+      const res = await fetch(`${baseUrl}/config`, {
+        method: "PATCH",
+        headers: headers(),
+        body: JSON.stringify(config)
+      });
+      if (!res.ok) throw new Error(`Failed to update config: ${res.status}`);
+    },
+    async listModels() {
+      const res = await fetch(`${baseUrl}/provider`, { headers: headers() });
+      if (!res.ok) throw new Error(`Failed to list models: ${res.status}`);
+      return res.json();
+    }
+  };
+}
+
+exports.createClient = createClient;