@m8tes/sdk 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,672 @@
+import { createNormalizer, createSseDecoder, initialConversationState, accumulate, RunFailedError, APIError, parseRetryAfter, parseErrorEnvelope, errorClassForStatus } from './chunk-UFQQNUFE.js';
+export { APIError, AuthenticationError, BillingError, ConflictError, M8tesApiError, NotFoundError, PROTOCOL_VERSION, PermissionDeniedError, RateLimitError, RunFailedError, RunNotStreamingError, TERMINAL_EVENT_TYPES, ValidationError, accumulate, createAccumulator, createNormalizer, createSseDecoder, errorClassForStatus, errorFromResponse, initialConversationState, isTerminalEvent, parseErrorEnvelope, parseRetryAfter, parseSse, splitConcatenatedJson } from './chunk-UFQQNUFE.js';
+import { createHmac, timingSafeEqual } from 'crypto';
+
+// src/http.ts
+var DEFAULT_BASE_URL = "https://api.m8tes.ai/api/v2";
+var MAX_ATTEMPTS = 3;
+var INITIAL_BACKOFF_MS = 500;
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
+function backoff(ms, signal) {
+  if (signal?.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    const timer = setTimeout(done, ms);
+    function done() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", done);
+      resolve();
+    }
+    signal?.addEventListener("abort", done, { once: true });
+  });
+}
+function looksLikeHtml(res, text) {
+  if ((res.headers.get("content-type") ?? "").includes("text/html")) return true;
+  const head = text.trimStart().slice(0, 9).toLowerCase();
+  return head.startsWith("<!doctype") || head.startsWith("<html");
+}
+function diagnose(res, text, body, url) {
+  if (looksLikeHtml(res, text)) {
+    return `Received an HTML page instead of an API response (HTTP ${res.status}) from ${url}. This usually means the host does not serve the m8tes API; check your baseUrl (the hosted API is ${DEFAULT_BASE_URL}).`;
+  }
+  const isBareNotFound = res.status === 404 && body !== null && typeof body === "object" && !("error" in body) && body.detail === "Not Found";
+  if (isBareNotFound) {
+    return `HTTP 404 from ${url} with no API error envelope \u2014 the path matched no route. Check your baseUrl includes the /api/v2 prefix (the hosted API is ${DEFAULT_BASE_URL}).`;
+  }
+  return void 0;
+}
+function createHttp(options = {}) {
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    throw new Error(
+      "@m8tes/sdk is server-only: it holds your secret m8_ API key, which anyone could read out of a browser bundle. To render an agent in the browser use @m8tes/react, which talks to a server proxy that keeps the key on your server. See https://www.m8tes.ai/docs/embed-a-ui"
+    );
+  }
+  const apiKey = options.apiKey ?? globalThis.process?.env?.["M8TES_API_KEY"];
+  if (!apiKey) {
+    throw new Error(
+      "@m8tes/sdk: no API key. Pass `new M8tes({ apiKey })` or set M8TES_API_KEY. Create a key at https://m8tes.ai/developer."
+    );
+  }
+  const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const timeout = options.timeout ?? 3e5;
+  const maybeFetch = options.fetch ?? globalThis.fetch;
+  if (!maybeFetch) {
+    throw new Error(
+      "@m8tes/sdk: no global fetch. Use Node 18+ or pass `fetch` in the client options."
+    );
+  }
+  const fetchImpl = maybeFetch;
+  async function toError(res, url, errOpts) {
+    const text = await res.text().catch(() => "");
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      body = void 0;
+    }
+    const parsed = parseErrorEnvelope(res.status, body, res.headers);
+    const message = diagnose(res, text, body, url) ?? (body ? parsed.message : text || parsed.message);
+    return new (errorClassForStatus(res.status, errOpts))(message, parsed.fields);
+  }
+  async function attempt(method, url, opts) {
+    const headers = {
+      authorization: `Bearer ${apiKey}`,
+      ...options.headers,
+      ...opts.headers
+    };
+    const init = { method, headers };
+    if (opts.body !== void 0) {
+      headers["content-type"] = "application/json";
+      init.body = JSON.stringify(opts.body);
+    }
+    const timer = AbortSignal.timeout(timeout);
+    init.signal = opts.signal ? AbortSignal.any([opts.signal, timer]) : timer;
+    return fetchImpl(url, init);
+  }
+  async function send(method, path, opts, errOpts = {}) {
+    const url = `${baseUrl}${path}${opts.query ?? ""}`;
+    const idempotent = IDEMPOTENT_METHODS.has(method.toUpperCase());
+    let lastNetworkError;
+    for (let i = 0; i < MAX_ATTEMPTS; i++) {
+      const isLast = i === MAX_ATTEMPTS - 1;
+      let res;
+      try {
+        res = await attempt(method, url, opts);
+      } catch (e) {
+        if (opts.signal?.aborted) throw e;
+        lastNetworkError = e;
+        if (!idempotent || isLast) {
+          throw new APIError(e instanceof Error ? e.message : String(e), {
+            type: "api_error",
+            code: 0,
+            status: 0
+          });
+        }
+        await backoff(INITIAL_BACKOFF_MS * 2 ** i, opts.signal);
+        if (opts.signal?.aborted) throw e;
+        continue;
+      }
+      if (res.ok) return res;
+      if (!RETRYABLE_STATUS.has(res.status) || !idempotent || isLast) {
+        throw await toError(res, url, errOpts);
+      }
+      const retryAfter = res.status === 429 ? parseRetryAfter(res.headers.get("retry-after")) : void 0;
+      await res.text().catch(() => "");
+      await backoff(retryAfter !== void 0 ? retryAfter * 1e3 : INITIAL_BACKOFF_MS * 2 ** i, opts.signal);
+      if (opts.signal?.aborted) throw await toError(res, url, errOpts);
+    }
+    throw new APIError(
+      lastNetworkError instanceof Error ? lastNetworkError.message : "Max retries exceeded",
+      { type: "api_error", code: 0, status: 0 }
+    );
+  }
+  return {
+    baseUrl,
+    async request(method, path, opts = {}) {
+      const res = await send(method, path, opts);
+      if (res.status === 204) return void 0;
+      const text = await res.text();
+      return text ? JSON.parse(text) : void 0;
+    },
+    raw(method, path, opts = {}) {
+      return send(method, path, opts);
+    },
+    async *stream(method, path, opts = {}) {
+      const res = await send(method, path, opts, { conflictIsNotStreaming: true });
+      if (!res.body) return;
+      const normalizer = opts.normalizer ?? createNormalizer();
+      const decoder = createSseDecoder({ onMalformed: options.onMalformed });
+      const reader = res.body.getReader();
+      const td = new TextDecoder();
+      try {
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          for (const frame of decoder.push(td.decode(value, { stream: true }))) {
+            yield* normalizer.push(frame);
+          }
+        }
+        for (const frame of decoder.flush()) yield* normalizer.push(frame);
+      } finally {
+        try {
+          await reader.cancel();
+        } catch {
+          try {
+            reader.releaseLock();
+          } catch {
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/pagination.ts
+var Page = class {
+  data;
+  hasMore;
+  /** Fetches the next page given a cursor. Absent on a terminal page. */
+  fetchNext;
+  constructor(data, hasMore, fetchNext) {
+    this.data = data;
+    this.hasMore = hasMore;
+    this.fetchNext = fetchNext;
+  }
+  /**
+   * Auto-paging: yields every item across every page.
+   *
+   * Stops if the cursor ever fails to advance. A server that returns the same
+   * page again with `has_more: true` — a caching layer, a replica lagging, a bug
+   * — would otherwise spin forever, re-yielding the same rows and never
+   * returning. Terminating is the only safe response: the caller gets the items
+   * it did see rather than a hung process.
+   */
+  async *[Symbol.asyncIterator]() {
+    let page = this;
+    const seen = /* @__PURE__ */ new Set();
+    for (; ; ) {
+      yield* page.data;
+      const last = page.data.at(-1);
+      if (!page.hasMore || !last || !page.fetchNext) return;
+      const cursor = typeof last.id === "number" || typeof last.id === "string" ? last.id : typeof last.name === "string" ? last.name : void 0;
+      if (cursor === void 0 || seen.has(cursor)) return;
+      seen.add(cursor);
+      page = await page.fetchNext(cursor);
+    }
+  }
+  /** Every item across every page, collected. Prefer iteration for large sets. */
+  async all() {
+    const out = [];
+    for await (const item of this) out.push(item);
+    return out;
+  }
+};
+
+// src/params.ts
+function toBody(params) {
+  const out = {};
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+function toQuery(params) {
+  const q = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v === void 0 || v === null) continue;
+    q.set(k, String(v));
+  }
+  const s = q.toString();
+  return s ? `?${s}` : "";
+}
+function resolveAgentId(teammateId, agentId) {
+  if (agentId !== void 0 && teammateId !== void 0 && agentId !== teammateId) {
+    throw new Error("Pass agent_id or teammate_id, not both");
+  }
+  return teammateId ?? agentId;
+}
+
+// src/resources/agents.ts
+function createAgentsResource(http) {
+  return {
+    create(params = {}) {
+      return http.request("POST", "/agents/", { body: toBody({ ...params }) });
+    },
+    async list(params = {}) {
+      const fetchPage = async (p) => {
+        const res = await http.request("GET", "/agents/", {
+          query: toQuery(p)
+        });
+        return new Page(
+          res?.data ?? [],
+          res?.has_more ?? false,
+          (starting_after) => fetchPage({ ...p, starting_after })
+        );
+      };
+      return fetchPage({ ...params });
+    },
+    get(agentId, params = {}) {
+      return http.request("GET", `/agents/${agentId}`, { query: toQuery(params) });
+    },
+    update(agentId, params) {
+      const { user_id, ...patch } = params;
+      return http.request("PATCH", `/agents/${agentId}`, {
+        body: toBody(patch),
+        query: toQuery({ user_id })
+      });
+    },
+    async delete(agentId, params = {}) {
+      await http.request("DELETE", `/agents/${agentId}`, { query: toQuery(params) });
+    },
+    enableWebhook(agentId) {
+      return http.request("POST", `/agents/${agentId}/webhook`, { body: {} });
+    },
+    async disableWebhook(agentId) {
+      await http.request("DELETE", `/agents/${agentId}/webhook`);
+    },
+    enableEmailInbox(agentId) {
+      return http.request("POST", `/agents/${agentId}/email-inbox`, { body: {} });
+    },
+    async disableEmailInbox(agentId) {
+      await http.request("DELETE", `/agents/${agentId}/email-inbox`);
+    }
+  };
+}
+
+// src/resources/apps.ts
+function createAppsResource(http) {
+  const slug = (name) => encodeURIComponent(name);
+  return {
+    async list(params = {}) {
+      const res = await http.request("GET", "/apps/", {
+        query: toQuery({ user_id: params.user_id })
+      });
+      return new Page(res?.data ?? [], res?.has_more ?? false);
+    },
+    async isConnected(appName, params = {}) {
+      const { data } = await this.list(params);
+      return data.find((a) => a.name === appName)?.connected ?? false;
+    },
+    connectOauth(appName, params) {
+      return http.request("POST", `/apps/${slug(appName)}/connect`, {
+        body: toBody({ ...params })
+      });
+    },
+    connectApiKey(appName, params) {
+      return http.request("POST", `/apps/${slug(appName)}/connect/api-key`, {
+        body: toBody({ ...params })
+      });
+    },
+    connectComplete(appName, params) {
+      return http.request("POST", `/apps/${slug(appName)}/connect/complete`, {
+        body: toBody({ ...params })
+      });
+    },
+    async disconnect(appName, params = {}) {
+      await http.request("DELETE", `/apps/${slug(appName)}/connections`, { query: toQuery(params) });
+    }
+  };
+}
+
+// src/streaming.ts
+var RunStream = class {
+  source;
+  raiseOnError;
+  state = initialConversationState;
+  textChunks = [];
+  errorMessages = [];
+  runIdValue = null;
+  consumed = false;
+  constructor(source, options = {}) {
+    this.source = source;
+    this.raiseOnError = options.raiseOnError ?? false;
+  }
+  async *[Symbol.asyncIterator]() {
+    if (this.consumed) {
+      throw new Error(
+        "RunStream has already been consumed. A stream is single-pass \u2014 iterate once, then read .text / .state / .errors, or call runs.get(runId) to re-read the result."
+      );
+    }
+    this.consumed = true;
+    try {
+      for await (const event of this.source) {
+        this.state = accumulate(this.state, event);
+        if (event.type === "text-delta") this.textChunks.push(event.delta);
+        if (event.type === "run-start" && event.runId !== null) this.runIdValue = event.runId;
+        if (event.type === "run-error") this.errorMessages.push(event.message || event.error);
+        yield event;
+      }
+    } finally {
+      await this.source.return(void 0).catch(() => void 0);
+    }
+    if (this.raiseOnError && this.errorMessages.length > 0) {
+      throw new RunFailedError(`Run failed: ${this.errorMessages.join("; ")}`, {
+        type: "run_failed",
+        code: 0,
+        status: 0,
+        details: { errors: this.errorMessages }
+      });
+    }
+  }
+  /** Yield only the assistant's text, in order. The 90% case for a server. */
+  async *iterText() {
+    for await (const event of this) {
+      if (event.type === "text-delta") yield event.delta;
+    }
+  }
+  /** Drain the stream and return the full assistant text. */
+  async text() {
+    for await (const _ of this) {
+    }
+    return this.textChunks.join("");
+  }
+  /** Accumulated text so far (complete once iteration finishes). */
+  get output() {
+    return this.textChunks.join("");
+  }
+  /** Run id, available as soon as the first `run-start` event arrives. */
+  get runId() {
+    return this.runIdValue;
+  }
+  /** Error messages the run emitted. Check this, or pass `raiseOnError`. */
+  get errors() {
+    return [...this.errorMessages];
+  }
+  get hasErrors() {
+    return this.errorMessages.length > 0;
+  }
+  /** Full normalized conversation: messages, tool calls, notices, status. */
+  get conversation() {
+    return this.state;
+  }
+  /** Close the underlying response without draining it. */
+  async close() {
+    await this.source.return(void 0).catch(() => void 0);
+  }
+};
+
+// src/resources/runs.ts
+function items(payload) {
+  return Array.isArray(payload) ? payload : payload?.data ?? [];
+}
+function createRunsResource(http) {
+  const createBody = (p, stream) => {
+    const { agent_id, teammate_id, ...rest } = p;
+    return toBody({ ...rest, teammate_id: resolveAgentId(teammate_id, agent_id), stream });
+  };
+  return {
+    create(params, options) {
+      return new RunStream(http.stream("POST", "/runs", { body: createBody(params, true) }), options);
+    },
+    createAsync(params) {
+      return http.request("POST", "/runs", { body: createBody(params, false) });
+    },
+    stream(runId, options) {
+      return new RunStream(http.stream("GET", `/runs/${runId}/stream`), options);
+    },
+    reply(runId, message, options) {
+      return new RunStream(http.stream("POST", `/runs/${runId}/reply`, { body: { message } }), options);
+    },
+    get(runId) {
+      return http.request("GET", `/runs/${runId}`);
+    },
+    async list(params = {}) {
+      const { agent_id, teammate_id, ...rest } = params;
+      const q = toBody({ ...rest, teammate_id: resolveAgentId(teammate_id, agent_id) });
+      const fetchPage = async (p) => {
+        const res = await http.request("GET", "/runs", {
+          query: toQuery(p)
+        });
+        return new Page(
+          res?.data ?? [],
+          res?.has_more ?? false,
+          (starting_after) => fetchPage({ ...p, starting_after })
+        );
+      };
+      return fetchPage(q);
+    },
+    cancel(runId) {
+      return http.request("POST", `/runs/${runId}/cancel`, { body: {} });
+    },
+    approve(runId, params) {
+      return http.request("POST", `/runs/${runId}/approve`, {
+        body: { remember: false, ...params }
+      });
+    },
+    answer(runId, params) {
+      return http.request("POST", `/runs/${runId}/answer`, {
+        body: { answers: params.answers }
+      });
+    },
+    async permissions(runId) {
+      return items(await http.request("GET", `/runs/${runId}/permissions`));
+    },
+    outcome(runId) {
+      return http.request("GET", `/runs/${runId}/outcome`);
+    },
+    async files(runId) {
+      return items(await http.request("GET", `/runs/${runId}/files`));
+    },
+    async downloadFile(runId, filename) {
+      const res = await http.raw("GET", `/runs/${runId}/files/${encodeURIComponent(filename)}/download`, {
+        headers: { accept: "application/octet-stream" }
+      });
+      return res.arrayBuffer();
+    }
+  };
+}
+
+// src/resources/settings.ts
+function createSettingsResource(http) {
+  return {
+    get() {
+      return http.request("GET", "/settings/");
+    },
+    // `null` must survive (it CLEARS a cap); only `undefined` is dropped.
+    update(params) {
+      return http.request("PATCH", "/settings/", { body: toBody({ ...params }) });
+    }
+  };
+}
+
+// src/resources/tasks.ts
+function createTasksResource(http) {
+  const triggers = {
+    create(taskId, params) {
+      return http.request("POST", `/tasks/${taskId}/triggers/`, {
+        body: toBody({ timezone: "UTC", ...params })
+      });
+    },
+    async list(taskId) {
+      const res = await http.request(
+        "GET",
+        `/tasks/${taskId}/triggers/`
+      );
+      return Array.isArray(res) ? res : res?.data ?? [];
+    },
+    update(taskId, triggerId, params) {
+      return http.request("PATCH", `/tasks/${taskId}/triggers/${triggerId}`, {
+        body: toBody({ ...params })
+      });
+    },
+    async delete(taskId, triggerId) {
+      await http.request("DELETE", `/tasks/${taskId}/triggers/${triggerId}`);
+    }
+  };
+  return {
+    triggers,
+    create(params) {
+      const { agent_id, teammate_id, ...rest } = params;
+      return http.request("POST", "/tasks/", {
+        body: toBody({ ...rest, teammate_id: resolveAgentId(teammate_id, agent_id) })
+      });
+    },
+    async list(params = {}) {
+      const { agent_id, teammate_id, ...rest } = params;
+      const q = toBody({ ...rest, teammate_id: resolveAgentId(teammate_id, agent_id) });
+      const fetchPage = async (p) => {
+        const res = await http.request("GET", "/tasks/", {
+          query: toQuery(p)
+        });
+        return new Page(
+          res?.data ?? [],
+          res?.has_more ?? false,
+          (starting_after) => fetchPage({ ...p, starting_after })
+        );
+      };
+      return fetchPage(q);
+    },
+    get(taskId, params = {}) {
+      return http.request("GET", `/tasks/${taskId}`, { query: toQuery(params) });
+    },
+    update(taskId, params) {
+      const { user_id, ...patch } = params;
+      return http.request("PATCH", `/tasks/${taskId}`, {
+        body: toBody(patch),
+        query: toQuery({ user_id })
+      });
+    },
+    async delete(taskId, params = {}) {
+      await http.request("DELETE", `/tasks/${taskId}`, { query: toQuery(params) });
+    },
+    run(taskId, params = {}, options) {
+      return new RunStream(
+        http.stream("POST", `/tasks/${taskId}/runs`, { body: toBody({ ...params, stream: true }) }),
+        options
+      );
+    },
+    runAsync(taskId, params = {}) {
+      return http.request("POST", `/tasks/${taskId}/runs`, {
+        body: toBody({ ...params, stream: false })
+      });
+    },
+    enableWebhook(taskId) {
+      return http.request("POST", `/tasks/${taskId}/webhook`, { body: {} });
+    },
+    async disableWebhook(taskId) {
+      await http.request("DELETE", `/tasks/${taskId}/webhook`);
+    }
+  };
+}
+
+// src/resources/users.ts
+function pager(http, path) {
+  const fetchPage = async (p) => {
+    const res = await http.request("GET", path, {
+      query: toQuery(p)
+    });
+    return new Page(
+      res?.data ?? [],
+      res?.has_more ?? false,
+      (starting_after) => fetchPage({ ...p, starting_after })
+    );
+  };
+  return fetchPage;
+}
+function createUsersResource(http) {
+  return {
+    create(params) {
+      return http.request("POST", "/users/", { body: toBody({ ...params }) });
+    },
+    list(params = {}) {
+      return pager(http, "/users/")({ ...params });
+    },
+    get(userId) {
+      return http.request("GET", `/users/${encodeURIComponent(userId)}`);
+    },
+    update(userId, params) {
+      return http.request("PATCH", `/users/${encodeURIComponent(userId)}`, {
+        body: toBody({ ...params })
+      });
+    },
+    async delete(userId) {
+      await http.request("DELETE", `/users/${encodeURIComponent(userId)}`);
+    },
+    usage(params = {}) {
+      return pager(http, "/usage/end-users")({ ...params });
+    }
+  };
+}
+function verifySignature(body, headers, secret, options = {}) {
+  const get = (name) => {
+    if (typeof headers.get === "function") {
+      return headers.get(name) ?? void 0;
+    }
+    const lower = Object.fromEntries(
+      Object.entries(headers).map(([k, v]) => [
+        k.toLowerCase(),
+        Array.isArray(v) ? v[0] : v
+      ])
+    );
+    return lower[name];
+  };
+  const webhookId = get("webhook-id");
+  const timestamp = get("webhook-timestamp");
+  const signature = get("webhook-signature");
+  if (!webhookId || !timestamp || !signature) return false;
+  if (options.toleranceSeconds !== void 0) {
+    const ts = Number.parseInt(timestamp, 10);
+    if (!Number.isFinite(ts)) return false;
+    const now = options.now ? options.now() : Math.floor(Date.now() / 1e3);
+    if (Math.abs(now - ts) > options.toleranceSeconds) return false;
+  }
+  const raw = typeof body === "string" ? body : new TextDecoder().decode(body);
+  const expected = `v1=${createHmac("sha256", secret).update(`${webhookId}.${timestamp}.${raw}`).digest("hex")}`;
+  const a = Buffer.from(expected);
+  const b = Buffer.from(signature);
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+function createWebhooksResource(http) {
+  return {
+    verifySignature,
+    create(params) {
+      return http.request("POST", "/webhooks/", { body: toBody({ ...params }) });
+    },
+    list(params = {}) {
+      return pager(http, "/webhooks/")({ ...params });
+    },
+    get(webhookId) {
+      return http.request("GET", `/webhooks/${webhookId}`);
+    },
+    update(webhookId, params) {
+      return http.request("PATCH", `/webhooks/${webhookId}`, { body: toBody({ ...params }) });
+    },
+    async delete(webhookId) {
+      await http.request("DELETE", `/webhooks/${webhookId}`);
+    },
+    listDeliveries(webhookId, params = {}) {
+      return pager(http, `/webhooks/${webhookId}/deliveries`)({ ...params });
+    }
+  };
+}
+
+// src/index.ts
+var M8TES_SDK_VERSION = "0.1.0-alpha.1";
+var M8tes = class {
+  runs;
+  agents;
+  /** Permanent alias for `agents` — the DB model and older docs say "teammate". */
+  teammates;
+  tasks;
+  users;
+  apps;
+  webhooks;
+  settings;
+  /** The underlying transport. Use it to call an endpoint this version does not wrap yet. */
+  http;
+  constructor(options = {}) {
+    this.http = createHttp(options);
+    this.runs = createRunsResource(this.http);
+    this.agents = createAgentsResource(this.http);
+    this.teammates = this.agents;
+    this.tasks = createTasksResource(this.http);
+    this.users = createUsersResource(this.http);
+    this.apps = createAppsResource(this.http);
+    this.webhooks = createWebhooksResource(this.http);
+    this.settings = createSettingsResource(this.http);
+  }
+};
+
+export { DEFAULT_BASE_URL, M8TES_SDK_VERSION, M8tes, Page, RunStream, createHttp, verifySignature };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map