@meistrari/tela-sdk-js 0.0.3 → 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1303 @@
+'use strict';
+
+const changeCase = require('change-case');
+const micromatch = require('micromatch');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return n;
+}
+
+const changeCase__namespace = /*#__PURE__*/_interopNamespaceCompat(changeCase);
+const micromatch__default = /*#__PURE__*/_interopDefaultCompat(micromatch);
+
+const version = "1.0.0";
+
+var __defProp$5 = Object.defineProperty;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$5 = (obj, key, value) => {
+  __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class TelaError extends Error {
+}
+class ConflictApiKeyAndJWTError extends TelaError {
+  constructor() {
+    super("You must provide either an API key or a JWT, but not both");
+  }
+}
+class MissingApiKeyOrJWTError extends TelaError {
+  constructor() {
+    super("You must provide an API key or a JWT");
+  }
+}
+class EmptyFileError extends TelaError {
+  constructor() {
+    super("File cannot be empty");
+  }
+}
+class InvalidFileURL extends TelaError {
+  constructor(url) {
+    super(`Invalid file URL: ${url}`);
+  }
+}
+class FileUploadError extends TelaError {
+  constructor(message) {
+    super(`Failed to upload file: ${message}`);
+  }
+}
+class APIError extends TelaError {
+  constructor(statusCode, error, _message) {
+    const message = error?.message ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : error ? JSON.stringify(error) : _message;
+    super(message);
+    __publicField$5(this, "statusCode");
+    __publicField$5(this, "error");
+    this.statusCode = statusCode;
+    this.error = error;
+  }
+  static from(statusCode, responseError, message) {
+    if (!statusCode) {
+      return new ConnectionError({
+        message,
+        cause: toError(responseError)
+      });
+    }
+    const error = responseError;
+    if (error.status === 400) {
+      return new BadRequestError(statusCode, error, message);
+    }
+    if (error.status === 401) {
+      return new AuthenticationError(statusCode, error, message);
+    }
+    if (error.status === 403) {
+      return new AuthorizationError(statusCode, error, message);
+    }
+    if (error.status === 404) {
+      return new NotFoundError(statusCode, error, message);
+    }
+    if (error.status === 409) {
+      return new ConflictError(statusCode, error, message);
+    }
+    if (error.status === 422) {
+      return new UnprocessableEntityError(statusCode, error, message);
+    }
+    if (error.status === 429) {
+      return new RateLimitError(statusCode, error, message);
+    }
+    if (error.status >= 500) {
+      return new InternalServerError(statusCode, error, message);
+    }
+    return new APIError(statusCode, error, message);
+  }
+}
+class UserAbortError extends APIError {
+  constructor({ message } = {}) {
+    super(void 0, void 0, message || "User aborted.");
+    __publicField$5(this, "statusCode");
+  }
+}
+class ConnectionError extends APIError {
+  constructor({
+    message,
+    cause
+  }) {
+    super(void 0, void 0, message || "Connection error.");
+    __publicField$5(this, "statusCode");
+    if (cause)
+      this.cause = cause;
+  }
+}
+class ConnectionTimeout extends APIError {
+  constructor({
+    message
+  } = {}) {
+    super(void 0, void 0, message || "Request timed out.");
+    __publicField$5(this, "statusCode");
+  }
+}
+class BadRequestError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField$5(this, "statusCode", 400);
+  }
+  // todo: handle validation errors from zod/typebox
+}
+class AuthenticationError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField$5(this, "statusCode", 401);
+  }
+}
+class AuthorizationError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField$5(this, "statusCode", 403);
+  }
+}
+class NotFoundError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField$5(this, "statusCode", 404);
+  }
+}
+class ConflictError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField$5(this, "statusCode", 409);
+  }
+}
+class UnprocessableEntityError extends APIError {
+  constructor() {
+    super(...arguments);
+    // todo: check if tela returns 400 or 422 for zod errors
+    __publicField$5(this, "statusCode", 422);
+  }
+}
+class RateLimitError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField$5(this, "statusCode", 429);
+  }
+}
+class InternalServerError extends APIError {
+  constructor() {
+    super(...arguments);
+    __publicField$5(this, "statusCode", 500);
+  }
+}
+function toError(err) {
+  if (err instanceof Error)
+    return err;
+  if (typeof err === "object" && err !== null) {
+    try {
+      return new Error(JSON.stringify(err));
+    } catch {
+    }
+  }
+  return new Error(err);
+}
+
+const DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS = [
+  // Inputs
+  "variables.*(!(*fileUrl))",
+  "override.structuredOutput.schema.properties.*",
+  "override.functions.*.parameters.properties.*",
+  // Outputs
+  "choices.*.message.content.*",
+  "choices.*.message.function_call.arguments.*",
+  "choices.*.message.tool_calls.*.function.arguments.*",
+  "message.content.*",
+  "message.function_call.arguments.*",
+  "message.tool_calls.*.function.arguments.*",
+  "message.structured_content.*",
+  "input_content.variables.*",
+  "input_content.variables.*(!(*file_url))",
+  "input_content.messages.*.function_call.arguments.*",
+  "output_content.tool_calls.*.arguments.*",
+  "output_content.content.*",
+  "raw_input.override.structured_output.schema.properties.*",
+  "raw_input.override.functions.*.parameters.properties.*"
+];
+
+function isExcluded(path, exclusions) {
+  return exclusions.some((pattern) => {
+    const isMatch = micromatch__default.isMatch(path, pattern);
+    return isMatch;
+  });
+}
+function transformObjectFromCamelCaseToSnakeCase(obj, exclusions = []) {
+  const result = Array.isArray(obj) ? [] : {};
+  const stack = [
+    { source: obj, target: result, path: "" }
+  ];
+  while (stack.length > 0) {
+    const { source, target, path } = stack.pop();
+    if (Array.isArray(source)) {
+      source.forEach((item, index) => {
+        const newPath = path ? `${path}.*` : "*";
+        if (Array.isArray(item) || typeof item === "object" && item !== null) {
+          target[index] = Array.isArray(item) ? [] : {};
+          stack.push({ source: item, target: target[index], path: newPath });
+        } else {
+          target[index] = item;
+        }
+      });
+    } else if (typeof source === "object" && source !== null) {
+      for (const [key, value] of Object.entries(source)) {
+        const newPath = path ? `${path}.${key}` : key;
+        const snakeKey = isExcluded(newPath, exclusions) ? key : changeCase__namespace.snakeCase(key);
+        if (Array.isArray(value) || typeof value === "object" && value !== null) {
+          target[snakeKey] = Array.isArray(value) ? [] : {};
+          stack.push({ source: value, target: target[snakeKey], path: newPath });
+        } else {
+          target[snakeKey] = value;
+        }
+      }
+    }
+  }
+  return result;
+}
+function transformObjectFromSnakeCaseToCamelCase(obj, exclusions = []) {
+  const result = Array.isArray(obj) ? [] : {};
+  const stack = [
+    { source: obj, target: result, path: "" }
+  ];
+  while (stack.length > 0) {
+    const { source, target, path } = stack.pop();
+    if (Array.isArray(source)) {
+      source.forEach((item, index) => {
+        const newPath = path ? `${path}.*` : "*";
+        if (Array.isArray(item) || typeof item === "object" && item !== null) {
+          target[index] = Array.isArray(item) ? [] : {};
+          stack.push({ source: item, target: target[index], path: newPath });
+        } else {
+          target[index] = item;
+        }
+      });
+    } else if (typeof source === "object" && source !== null) {
+      for (const [key, value] of Object.entries(source)) {
+        const newPath = path ? `${path}.${key}` : key;
+        const camelKey = isExcluded(newPath, exclusions) ? key : changeCase__namespace.camelCase(key);
+        if (Array.isArray(value) || typeof value === "object" && value !== null) {
+          target[camelKey] = Array.isArray(value) ? [] : {};
+          stack.push({ source: value, target: target[camelKey], path: newPath });
+        } else {
+          target[camelKey] = value;
+        }
+      }
+    }
+  }
+  return result;
+}
+
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => {
+  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Stream {
+  /**
+   * Creates a new Stream instance.
+   *
+   * @param iterator - A function that returns an AsyncIterator<Item>.
+   * @param controller - The AbortController for this stream.
+   */
+  constructor(iterator, controller) {
+    this.iterator = iterator;
+    /**
+     * The AbortController associated with this stream.
+     */
+    __publicField$4(this, "controller");
+    this.controller = controller;
+  }
+  /**
+   * Creates a Stream from a server-sent events (SSE) Response.
+   *
+   * @param response - The Response object containing the SSE data.
+   * @param controller - The AbortController for this stream.
+   * @returns A new Stream instance.
+   * @throws {Error} If the stream is consumed more than once.
+   * @throws {APIError} If the SSE data contains an error.
+   */
+  static fromSSEResponse(response, controller) {
+    let consumed = false;
+    async function* iterator() {
+      if (consumed) {
+        throw new Error("Cannot iterate over a consumed stream, use `.tee()` to split the stream.");
+      }
+      consumed = true;
+      let done = false;
+      try {
+        for await (const sse of _iterSSEMessages(response, controller)) {
+          if (done)
+            continue;
+          if (sse.data.startsWith("[DONE]")) {
+            done = true;
+            continue;
+          }
+          if (sse.event === null) {
+            let data;
+            try {
+              data = JSON.parse(sse.data);
+              data = transformObjectFromSnakeCaseToCamelCase(data, DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS);
+            } catch (e) {
+              console.error(`Could not parse message into JSON:`, sse.data);
+              console.error(`From chunk:`, sse.raw);
+              throw e;
+            }
+            if (data && data.error) {
+              throw new APIError(void 0, data.error, void 0);
+            }
+            yield data;
+          } else {
+            let data;
+            try {
+              data = JSON.parse(sse.data);
+            } catch (e) {
+              console.error(`Could not parse message into JSON:`, sse.data);
+              console.error(`From chunk:`, sse.raw);
+              throw e;
+            }
+            if (sse.event === "error") {
+              throw new APIError(void 0, data.error, data.message);
+            }
+            yield { event: sse.event, data };
+          }
+        }
+        done = true;
+      } catch (e) {
+        if (e instanceof Error && e.name === "AbortError")
+          return;
+        throw e;
+      } finally {
+        if (!done)
+          controller.abort();
+      }
+    }
+    return new Stream(iterator, controller);
+  }
+  /**
+   * Creates a Stream from a newline-separated ReadableStream where each item is a JSON value.
+   *
+   * @param readableStream - The ReadableStream containing newline-separated JSON data.
+   * @param controller - The AbortController for this stream.
+   * @returns A new Stream instance.
+   * @throws {Error} If the stream is consumed more than once.
+   */
+  static fromReadableStream(readableStream, controller) {
+    let consumed = false;
+    async function* iterLines() {
+      const lineDecoder = new LineDecoder();
+      const iter = readableStreamAsyncIterable(readableStream);
+      for await (const chunk of iter) {
+        for (const line of lineDecoder.decode(chunk)) {
+          yield line;
+        }
+      }
+      for (const line of lineDecoder.flush()) {
+        yield line;
+      }
+    }
+    async function* iterator() {
+      if (consumed) {
+        throw new Error("Cannot iterate over a consumed stream, use `.tee()` to split the stream.");
+      }
+      consumed = true;
+      let done = false;
+      try {
+        for await (const line of iterLines()) {
+          if (done)
+            continue;
+          if (line)
+            yield JSON.parse(line);
+        }
+        done = true;
+      } catch (e) {
+        if (e instanceof Error && e.name === "AbortError")
+          return;
+        throw e;
+      } finally {
+        if (!done)
+          controller.abort();
+      }
+    }
+    return new Stream(iterator, controller);
+  }
+  /**
+   * Implements the AsyncIterable interface, allowing the Stream to be used in a for-await-of loop.
+   *
+   * @returns An AsyncIterator for the stream items.
+   */
+  [Symbol.asyncIterator]() {
+    return this.iterator();
+  }
+  /**
+   * Splits the stream into two streams which can be independently read from at different speeds.
+   *
+   * @returns A tuple containing two new Stream instances.
+   */
+  tee() {
+    const left = [];
+    const right = [];
+    const iterator = this.iterator();
+    const teeIterator = (queue) => {
+      return {
+        next: () => {
+          if (queue.length === 0) {
+            const result = iterator.next();
+            left.push(result);
+            right.push(result);
+          }
+          return queue.shift();
+        }
+      };
+    };
+    return [
+      new Stream(() => teeIterator(left), this.controller),
+      new Stream(() => teeIterator(right), this.controller)
+    ];
+  }
+  /**
+   * Converts this stream to a newline-separated ReadableStream of JSON stringified values.
+   * The resulting stream can be converted back to a Stream using `Stream.fromReadableStream()`.
+   *
+   * @returns A ReadableStream containing newline-separated JSON data.
+   */
+  toReadableStream() {
+    const self = this;
+    let iter;
+    const encoder = new TextEncoder();
+    return new ReadableStream({
+      async start() {
+        iter = self[Symbol.asyncIterator]();
+      },
+      async pull(ctrl) {
+        try {
+          const { value, done } = await iter.next();
+          if (done)
+            return ctrl.close();
+          const bytes = encoder.encode(`${JSON.stringify(value)}
+`);
+          ctrl.enqueue(bytes);
+        } catch (err) {
+          ctrl.error(err);
+        }
+      },
+      async cancel() {
+        await iter.return?.();
+      }
+    });
+  }
+}
+async function* _iterSSEMessages(response, controller) {
+  if (!response.body) {
+    controller.abort();
+    throw new TelaError(`Attempted to iterate over a response with no body`);
+  }
+  const sseDecoder = new SSEDecoder();
+  const lineDecoder = new LineDecoder();
+  const iter = readableStreamAsyncIterable(response.body);
+  for await (const sseChunk of iterSSEChunks(iter)) {
+    for (const line of lineDecoder.decode(sseChunk)) {
+      const sse = sseDecoder.decode(line);
+      if (sse)
+        yield sse;
+    }
+  }
+  for (const line of lineDecoder.flush()) {
+    const sse = sseDecoder.decode(line);
+    if (sse)
+      yield sse;
+  }
+}
+async function* iterSSEChunks(iterator) {
+  let data = new Uint8Array();
+  for await (const chunk of iterator) {
+    if (chunk == null) {
+      continue;
+    }
+    const binaryChunk = chunk instanceof ArrayBuffer ? new Uint8Array(chunk) : typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk;
+    const newData = new Uint8Array(data.length + binaryChunk.length);
+    newData.set(data);
+    newData.set(binaryChunk, data.length);
+    data = newData;
+    let patternIndex = findDoubleNewlineIndex(data);
+    while (patternIndex !== -1) {
+      yield data.slice(0, patternIndex);
+      data = data.slice(patternIndex);
+      patternIndex = findDoubleNewlineIndex(data);
+    }
+  }
+  if (data.length > 0) {
+    yield data;
+  }
+}
+function findDoubleNewlineIndex(buffer) {
+  const newline = 10;
+  const carriage = 13;
+  for (let i = 0; i < buffer.length - 2; i++) {
+    if (buffer[i] === newline && buffer[i + 1] === newline) {
+      return i + 2;
+    }
+    if (buffer[i] === carriage && buffer[i + 1] === carriage) {
+      return i + 2;
+    }
+    if (buffer[i] === carriage && buffer[i + 1] === newline && i + 3 < buffer.length && buffer[i + 2] === carriage && buffer[i + 3] === newline) {
+      return i + 4;
+    }
+  }
+  return -1;
+}
+class SSEDecoder {
+  constructor() {
+    __publicField$4(this, "data");
+    __publicField$4(this, "event");
+    __publicField$4(this, "chunks");
+    this.event = null;
+    this.data = [];
+    this.chunks = [];
+  }
+  decode(line) {
+    if (line.endsWith("\r")) {
+      line = line.substring(0, line.length - 1);
+    }
+    if (!line) {
+      if (!this.event && !this.data.length)
+        return null;
+      const sse = {
+        event: this.event,
+        data: this.data.join("\n"),
+        raw: this.chunks
+      };
+      this.event = null;
+      this.data = [];
+      this.chunks = [];
+      return sse;
+    }
+    this.chunks.push(line);
+    if (line.startsWith(":")) {
+      return null;
+    }
+    let [fieldname, _, value] = partition(line, ":");
+    if (value.startsWith(" ")) {
+      value = value.substring(1);
+    }
+    if (fieldname === "event") {
+      this.event = value;
+    } else if (fieldname === "data") {
+      this.data.push(value);
+    }
+    return null;
+  }
+}
+const _LineDecoder = class _LineDecoder {
+  // TextDecoder found in browsers; not typed to avoid pulling in either "dom" or "node" types.
+  constructor() {
+    __publicField$4(this, "buffer");
+    __publicField$4(this, "trailingCR");
+    __publicField$4(this, "textDecoder");
+    this.buffer = [];
+    this.trailingCR = false;
+  }
+  decode(chunk) {
+    let text = this.decodeText(chunk);
+    if (this.trailingCR) {
+      text = `\r${text}`;
+      this.trailingCR = false;
+    }
+    if (text.endsWith("\r")) {
+      this.trailingCR = true;
+      text = text.slice(0, -1);
+    }
+    if (!text) {
+      return [];
+    }
+    const trailingNewline = _LineDecoder.NEWLINE_CHARS.has(text[text.length - 1] || "");
+    let lines = text.split(_LineDecoder.NEWLINE_REGEXP);
+    if (trailingNewline) {
+      lines.pop();
+    }
+    if (lines.length === 1 && !trailingNewline) {
+      this.buffer.push(lines[0]);
+      return [];
+    }
+    if (this.buffer.length > 0) {
+      lines = [this.buffer.join("") + lines[0], ...lines.slice(1)];
+      this.buffer = [];
+    }
+    if (!trailingNewline) {
+      this.buffer = [lines.pop() || ""];
+    }
+    return lines;
+  }
+  decodeText(bytes) {
+    if (bytes == null)
+      return "";
+    if (typeof bytes === "string")
+      return bytes;
+    if (typeof Buffer !== "undefined") {
+      if (bytes instanceof Buffer) {
+        return bytes.toString();
+      }
+      if (bytes instanceof Uint8Array) {
+        return Buffer.from(bytes).toString();
+      }
+      throw new TelaError(
+        `Unexpected: received non-Uint8Array (${bytes.constructor.name}) stream chunk in an environment with a global "Buffer" defined, which this library assumes to be Node. Please report this error.`
+      );
+    }
+    if (typeof TextDecoder !== "undefined") {
+      if (bytes instanceof Uint8Array || bytes instanceof ArrayBuffer) {
+        this.textDecoder ?? (this.textDecoder = new TextDecoder("utf8"));
+        return this.textDecoder.decode(bytes);
+      }
+      throw new TelaError(
+        `Unexpected: received non-Uint8Array/ArrayBuffer (${bytes.constructor.name}) in a web platform. Please report this error.`
+      );
+    }
+    throw new TelaError(
+      `Unexpected: neither Buffer nor TextDecoder are available as globals. Please report this error.`
+    );
+  }
+  flush() {
+    if (!this.buffer.length && !this.trailingCR) {
+      return [];
+    }
+    const lines = [this.buffer.join("")];
+    this.buffer = [];
+    this.trailingCR = false;
+    return lines;
+  }
+};
+// prettier-ignore
+__publicField$4(_LineDecoder, "NEWLINE_CHARS", /* @__PURE__ */ new Set(["\n", "\r"]));
+__publicField$4(_LineDecoder, "NEWLINE_REGEXP", /\r\n|[\n\r]/g);
+let LineDecoder = _LineDecoder;
+function partition(str, delimiter) {
+  const index = str.indexOf(delimiter);
+  if (index !== -1) {
+    return [str.substring(0, index), delimiter, str.substring(index + delimiter.length)];
+  }
+  return [str, "", ""];
+}
+function readableStreamAsyncIterable(stream) {
+  if (stream[Symbol.asyncIterator])
+    return stream;
+  const reader = stream.getReader();
+  return {
+    async next() {
+      try {
+        const result = await reader.read();
+        if (result?.done)
+          reader.releaseLock();
+        return result;
+      } catch (e) {
+        reader.releaseLock();
+        throw e;
+      }
+    },
+    async return() {
+      const cancelPromise = reader.cancel();
+      reader.releaseLock();
+      await cancelPromise;
+      return { done: true, value: void 0 };
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => {
+  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+async function defaultParseResponse(props) {
+  const { response } = props;
+  if (props.options.stream) {
+    debug("response", response.status, response.url, response.headers, response.body);
+    return Stream.fromSSEResponse(response, props.controller);
+  }
+  if (response.status === 204) {
+    return null;
+  }
+  const contentType = response.headers.get("content-type");
+  const isJSON = contentType?.includes("application/json") || contentType?.includes("application/vnd.api+json");
+  if (isJSON) {
+    const json = await response.json();
+    debug("response", response.status, response.url, response.headers, json);
+    return transformObjectFromSnakeCaseToCamelCase(json, DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS);
+  }
+  const text = await response.text();
+  debug("response", response.status, response.url, response.headers, text);
+  return text;
+}
+class BaseClient {
+  constructor({ baseURL, maxRetries = 5, timeout = 0 }) {
+    __publicField$3(this, "baseURL");
+    __publicField$3(this, "maxRetries");
+    __publicField$3(this, "timeout");
+    __publicField$3(this, "fetch");
+    this.baseURL = baseURL;
+    this.maxRetries = validateMaxRetries(maxRetries);
+    this.timeout = validateTimeout(timeout);
+    this.fetch = fetch;
+  }
+  createHeaders(opts) {
+    const headers = new Headers();
+    headers.set("Accept", "application/json");
+    headers.set("Content-Type", "application/json");
+    headers.set("User-Agent", this.getUserAgent());
+    for (const [key, value] of Object.entries(this.getAuthHeaders())) {
+      headers.set(key, value);
+    }
+    for (const [key, value] of Object.entries(opts ?? {})) {
+      headers.set(key, value);
+    }
+    return headers;
+  }
+  getUserAgent() {
+    return `tela-sdk-node/${version}`;
+  }
+  getAuthHeaders() {
+    return {};
+  }
+  get(path, opts) {
+    return this.methodRequest("GET", path, opts);
+  }
+  post(path, opts) {
+    return this.methodRequest("POST", path, opts);
+  }
+  put(path, opts) {
+    return this.methodRequest("PUT", path, opts);
+  }
+  patch(path, opts) {
+    return this.methodRequest("PATCH", path, opts);
+  }
+  delete(path, opts) {
+    return this.methodRequest("DELETE", path, opts);
+  }
+  async methodRequest(method, path, opts) {
+    const headers = this.createHeaders();
+    debug("methodRequest", method, path, opts);
+    const transformedQuery = opts?.query ? transformObjectFromCamelCaseToSnakeCase(opts.query, DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS) : void 0;
+    const transformedBody = opts?.body ? transformObjectFromCamelCaseToSnakeCase(opts.body, DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS) : void 0;
+    const { response, options, controller } = await this.request({
+      method,
+      path,
+      headers,
+      ...opts,
+      query: transformedQuery,
+      body: transformedBody
+    });
+    return defaultParseResponse({ response, options, controller });
+  }
+  async request(options, remainingRetries = null) {
+    return this.makeRequest(options, remainingRetries);
+  }
+  async makeRequest(options, remainingRetries = null) {
+    if (remainingRetries === null) {
+      remainingRetries = options.maxRetries ?? this.maxRetries;
+    }
+    const { req, url, timeout } = this.buildRequest(options);
+    if (options.signal?.aborted) {
+      throw new UserAbortError();
+    }
+    const controller = new AbortController();
+    const response = await this.fetchWithTimeout(
+      url,
+      req,
+      timeout,
+      controller
+    ).catch(toError);
+    if (response instanceof Error) {
+      debug("fetchWithTimeout error", response);
+      if (options.signal?.aborted) {
+        throw new UserAbortError();
+      }
+      if (remainingRetries) {
+        return this.retryRequest(options, remainingRetries);
+      }
+      if (response.name === "AbortError") {
+        throw new ConnectionTimeout();
+      }
+      throw new ConnectionError({ cause: response });
+    }
+    const responseHeaders = createResponseHeaders(response.headers);
+    if (!response.ok) {
+      if (remainingRetries && this.shouldRetry(response)) {
+        debug("shouldRetry", `Retrying ${remainingRetries} more times`);
+        return this.retryRequest(
+          options,
+          remainingRetries,
+          responseHeaders
+        );
+      }
+      const errorText = await response.text().catch((e) => toError(e).message);
+      const errorJSON = safeJSONParse(errorText);
+      const errorMessage = errorJSON ? void 0 : errorText;
+      const error = APIError.from(response.status, errorJSON, errorMessage);
+      debug("APIError", error);
+      throw error;
+    }
+    return { response, options, controller };
+  }
+  shouldRetry(response) {
+    const shouldRetryHeader = response.headers.get("x-should-retry");
+    if (shouldRetryHeader === "true")
+      return true;
+    if (shouldRetryHeader === "false")
+      return false;
+    if (response.status === 408)
+      return true;
+    if (response.status === 409)
+      return true;
+    if (response.status === 429)
+      return true;
+    if (response.status >= 500)
+      return true;
+    return false;
+  }
+  async retryRequest(options, retriesRemaining, responseHeaders) {
+    let timeoutMillis;
+    const retryAfterMillisHeader = responseHeaders?.get("retry-after-ms");
+    if (retryAfterMillisHeader) {
+      const timeoutMs = Number.parseFloat(retryAfterMillisHeader);
+      if (!Number.isNaN(timeoutMs)) {
+        timeoutMillis = timeoutMs;
+      }
+    }
+    const retryAfterHeader = responseHeaders?.get("retry-after");
+    if (retryAfterHeader && !timeoutMillis) {
+      const timeoutSeconds = Number.parseFloat(retryAfterHeader);
+      if (!Number.isNaN(timeoutSeconds)) {
+        timeoutMillis = timeoutSeconds * 1e3;
+      } else {
+        timeoutMillis = Date.parse(retryAfterHeader) - Date.now();
+      }
+    }
+    if (!(timeoutMillis && timeoutMillis >= 0 && timeoutMillis < 60 * 1e3)) {
+      const maxRetries = options.maxRetries ?? this.maxRetries;
+      timeoutMillis = this.calculateDefaultRetryTimeoutMillis(
+        retriesRemaining,
+        maxRetries
+      );
+    }
+    await sleep(timeoutMillis);
+    return this.makeRequest(options, retriesRemaining - 1);
+  }
+  calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) {
+    const initialRetryDelay = 0.5;
+    const maxRetryDelay = 25;
+    const numRetries = maxRetries - retriesRemaining;
+    const sleepSeconds = Math.min(
+      initialRetryDelay * 2 ** numRetries,
+      maxRetryDelay
+    );
+    const jitter = 1 - Math.random() * 0.25;
+    return sleepSeconds * jitter * 1e3;
+  }
+  async fetchWithTimeout(url, _options, timeout, controller) {
+    const { signal, ...options } = _options || {};
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        controller.abort();
+      });
+    }
+    let timeoutId;
+    if (timeout > 0) {
+      timeoutId = setTimeout(() => {
+        debug("fetchWithTimeout timeout");
+        controller.abort();
+      }, timeout);
+    }
+    debug("fetchWithTimeout", { url, options });
+    return this.fetch.call(void 0, url, {
+      signal: controller.signal,
+      ...options,
+      ...options.body ? { body: JSON.stringify(options.body) } : {}
+    }).finally(() => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    });
+  }
+  buildRequest(options) {
+    const { method, path, query, headers = {}, body } = options;
+    if ("timeout" in options && options.timeout !== void 0) {
+      validateTimeout(options.timeout);
+    }
+    const url = this.buildURL(path, query);
+    const req = {
+      method,
+      ...body && { body },
+      headers,
+      signal: options.signal ?? null
+    };
+    return {
+      req,
+      url,
+      timeout: options.timeout ?? this.timeout
+    };
+  }
+  buildURL(path, query) {
+    const startsWithSchemeRegexp = /^(?:[a-z]+:)?\/\//i;
+    const isAbsoluteURL = (url2) => {
+      return startsWithSchemeRegexp.test(url2);
+    };
+    const url = isAbsoluteURL(path) ? new URL(path) : new URL(
+      this.baseURL + (this.baseURL.endsWith("/") && path.startsWith("/") ? path.slice(1) : path)
+    );
+    if (typeof query === "object" && query && !Array.isArray(query)) {
+      url.search = this.stringifyQuery(query);
+    }
+    return url.toString();
+  }
+  stringifyQuery(query) {
+    return Object.entries(query).filter(([_, value]) => typeof value !== "undefined").map(([key, value]) => {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+      }
+      if (value === null) {
+        return `${encodeURIComponent(key)}=`;
+      }
+      throw new TelaError(
+        `Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`
+      );
+    }).join("&");
+  }
+}
+function createResponseHeaders(headers) {
+  const headersFromResponse = new Headers();
+  for (const [key, value] of Object.entries(headers)) {
+    headersFromResponse.set(key, value);
+  }
+  return headersFromResponse;
+}
+function validateMaxRetries(maxRetries) {
+  if (maxRetries < 0) {
+    throw new TelaError("Max retries must be a non-negative integer");
+  }
+  return maxRetries;
+}
+function validateTimeout(timeout) {
+  if (timeout < 0) {
+    throw new TelaError("Timeout must be a non-negative integer");
+  }
+  return timeout;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function safeJSONParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function debug(action, ...args) {
+  if (typeof process !== "undefined" && process?.env?.DEBUG === "true") {
+    console.log(`TelaSDK:DEBUG:${action}`, ...args);
+  }
+}
+
+async function getStreamSize(stream) {
+  let size = 0;
+  const reader = stream.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    size += value.length;
+  }
+  return size;
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => {
+  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class TelaFile {
+  /**
+   * Creates an instance of `TelaFile`.
+   *
+   * @param file - The source of the file. Can be a URL string, Uint8Array, ReadableStream, ReadStream, Blob, or File.
+   * @param options - Optional configuration options such as byte range.
+   * @throws {InvalidFileURL} If the provided URL is not valid.
+   * @throws {EmptyFileError} If the provided file is empty.
+   */
+  constructor(file, options) {
+    __publicField$2(this, "_file");
+    __publicField$2(this, "_options");
+    __publicField$2(this, "_size", null);
+    this._file = file;
+    this._options = options;
+    this.validateFile();
+  }
+  /**
+   * Retrieves the options provided during instantiation.
+   *
+   * @returns The `TelaFileOptions` or an empty object if none were provided.
+   */
+  get options() {
+    return this._options || {};
+  }
+  /**
+   * Determines whether the file source is a valid URL.
+   *
+   * @returns `true` if the file source is a valid URL string, otherwise `false`.
+   */
+  get isURL() {
+    return typeof this._file === "string" && this.isValidURL(this._file);
+  }
+  /**
+   * Gets the size of the file in bytes.
+   *
+   * @returns The size of the file if available, otherwise `null`.
+   */
+  get size() {
+    return this._size;
+  }
+  /**
+   * Retrieves the content of the file in a format suitable for uploading.
+   *
+   * - If the file is a URL, it returns the URL string.
+   * - If the file is a `Uint8Array`, it converts it to a `File` object.
+   * - If the file is a `ReadStream` or `ReadableStream`, it calculates the size and returns a stream.
+   *
+   * @returns A promise that resolves to the uploadable content.
+   */
+  async getUploadableContent() {
+    if (this.isURL && typeof this._file === "string") {
+      return this._file;
+    }
+    if (this._file instanceof Uint8Array) {
+      return new File([this._file], "file", {
+        type: "application/octet-stream"
+      });
+    }
+    if (this._file instanceof ReadableStream) {
+      const [sizeStream, contentStream] = this._file.tee();
+      this._size = await getStreamSize(sizeStream);
+      return contentStream;
+    }
+    return this._file;
+  }
+  /**
+   * Validates the provided file based on its type.
+   *
+   * @throws {InvalidFileURL} If the file is a string but not a valid URL.
+   * @throws {EmptyFileError} If the file is empty.
+   */
+  validateFile() {
+    if (typeof this._file === "string") {
+      if (!this.isValidURL(this._file)) {
+        throw new InvalidFileURL(this._file);
+      }
+    }
+    if (this._file instanceof Uint8Array) {
+      if (this._file.length === 0) {
+        throw new EmptyFileError();
+      }
+    }
+    if (this._file instanceof Blob || this._file instanceof File) {
+      if (this._file.size === 0) {
+        throw new EmptyFileError();
+      }
+    }
+  }
+  /**
+   * Checks if the provided string is a valid URL.
+   *
+   * @param url - The URL string to validate.
+   * @returns `true` if the URL is valid, otherwise `false`.
+   */
+  isValidURL(url) {
+    try {
+      new URL(url);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function createTelaFile(file, options) {
+  return new TelaFile(file, options);
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Resource {
+  constructor(client) {
+    __publicField$1(this, "_client");
+    this._client = client;
+  }
+}
+
+class ChatCompletions extends Resource {
+  async create(body, opts) {
+    const processedBody = { ...body };
+    if (body.variables) {
+      const processedVariables = {};
+      for await (const [key, value] of Object.entries(body.variables)) {
+        if (value instanceof TelaFile) {
+          const fileWithUrl = await this.uploadFile(value);
+          processedVariables[key] = fileWithUrl;
+        } else {
+          processedVariables[key] = value;
+        }
+      }
+      processedBody.variables = processedVariables;
+    }
+    return this._client.post("/v2/chat/completions", {
+      body: processedBody,
+      ...opts,
+      stream: body.stream ?? false
+    });
+  }
+  /**
+   * Uploads a file and returns its URL and options.
+   *
+   * This is used internally to handle file uploads associated with chat completions.
+   *
+   * @param file - The TelaFile to be uploaded.
+   * @returns A Promise that resolves to an object containing the file URL and options.
+   * @throws {FileUploadError} If the file upload fails.
+   *
+   * @example
+   * ```typescript
+   * const file = new TelaFile({ /* file options *\/ });
+   * const uploadedFile = await this.uploadFile(file);
+   * console.log(uploadedFile.file_url);
+   * ```
+   */
+  async uploadFile(file) {
+    const content = await file.getUploadableContent();
+    if (file.isURL && typeof content === "string") {
+      return { fileUrl: content, options: file.options };
+    }
+    const response = await this._client.post(
+      "/v2/file"
+    );
+    const { uploadUrl, downloadUrl } = response;
+    let contentType = "application/octet-stream";
+    if (content instanceof File || content instanceof Blob) {
+      contentType = content.type;
+    }
+    const uploadResponse = await fetch(uploadUrl, {
+      method: "PUT",
+      body: content,
+      headers: {
+        "Content-Type": contentType,
+        ...file.size ? { "Content-Length": file.size.toString() } : {}
+      },
+      // @ts-expect-error: duplex is not supported
+      duplex: "half"
+    });
+    if (!uploadResponse.ok) {
+      throw new FileUploadError(await uploadResponse.text());
+    }
+    return { fileUrl: downloadUrl, options: file.options };
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const baseUrl = "https://api.tela.com";
+const _TelaSDK = class _TelaSDK extends BaseClient {
+  /**
+   * Creates a new instance of the TelaSDK.
+   */
+  constructor({ baseURL = baseUrl, apiKey, jwt, ...rest }) {
+    super({ baseURL, ...rest });
+    __publicField(this, "opts");
+    __publicField(this, "apiKey");
+    __publicField(this, "jwt");
+    /**
+     * The ChatCompletions resource for interacting with Tela's chat completion API.
+     *
+     * Use this to generate chat completions based on provided messages.
+     *
+     * @example
+     * ```typescript
+     * const completion = await tela.completions.create({
+     *   canvasId: "your-canvas-id",
+     *   messages: [{ role: "user", content: "Hello!" }],
+     * });
+     * ```
+     */
+    __publicField(this, "completions", new ChatCompletions(this));
+    /**
+     * Creates a new `TelaFile` instance from the provided file input.
+     *
+     * @param file - The file input to create a `TelaFile` instance from.
+     * @returns A new `TelaFile` instance.
+     */
+    __publicField(this, "createFile", createTelaFile.bind(this));
+    this.opts = { baseURL, ...rest };
+    this.apiKey = apiKey;
+    this.jwt = jwt;
+    this.validateAuth();
+  }
+  validateAuth() {
+    if (!this.apiKey && !this.jwt) {
+      throw new MissingApiKeyOrJWTError();
+    }
+    if (this.apiKey && this.jwt) {
+      throw new ConflictApiKeyAndJWTError();
+    }
+  }
+  getAuthHeaders() {
+    return {
+      Authorization: `Bearer ${this.apiKey || this.jwt}`
+    };
+  }
+};
+__publicField(_TelaSDK, "TelaSDK", _TelaSDK);
+__publicField(_TelaSDK, "DEFAULT_TIMEOUT", 0);
+// Error classes
+/** Thrown when an API request fails. */
+__publicField(_TelaSDK, "APIError", APIError);
+/** Thrown when a request is aborted by the user. */
+__publicField(_TelaSDK, "UserAbortError", UserAbortError);
+/** Thrown when there's a network connection error. */
+__publicField(_TelaSDK, "ConnectionError", ConnectionError);
+/** Thrown when a request times out. */
+__publicField(_TelaSDK, "ConnectionTimeout", ConnectionTimeout);
+/** Thrown when the API returns a 400 Bad Request error. */
+__publicField(_TelaSDK, "BadRequestError", BadRequestError);
+/** Thrown when authentication fails (e.g., invalid API key). */
+__publicField(_TelaSDK, "AuthenticationError", AuthenticationError);
+/** Thrown when the authenticated user doesn't have permission for the requested operation. */
+__publicField(_TelaSDK, "AuthorizationError", AuthorizationError);
+/** Thrown when the requested resource is not found. */
+__publicField(_TelaSDK, "NotFoundError", NotFoundError);
+/** Thrown when there's a conflict with the current state of the resource. */
+__publicField(_TelaSDK, "ConflictError", ConflictError);
+/** Thrown when the request is well-formed but unable to be processed due to semantic errors. */
+__publicField(_TelaSDK, "UnprocessableEntityError", UnprocessableEntityError);
+/** Thrown when the API rate limit is exceeded. */
+__publicField(_TelaSDK, "RateLimitError", RateLimitError);
+/** Thrown when an unexpected server error occurs. */
+__publicField(_TelaSDK, "InternalServerError", InternalServerError);
+/** Thrown when attempting to upload an empty file. */
+__publicField(_TelaSDK, "EmptyFileError", EmptyFileError);
+/** Thrown when an invalid file URL is provided. */
+__publicField(_TelaSDK, "InvalidFileURL", InvalidFileURL);
+/** Thrown when there's an error during file upload. */
+__publicField(_TelaSDK, "FileUploadError", FileUploadError);
+/** Thrown when neither an API key nor a JWT is provided. */
+__publicField(_TelaSDK, "MissingApiKeyOrJWTError", MissingApiKeyOrJWTError);
+/** Thrown when both an API key and a JWT are provided. */
+__publicField(_TelaSDK, "ConflictApiKeyAndJWTError", ConflictApiKeyAndJWTError);
+let TelaSDK = _TelaSDK;
+function createTelaClient(opts) {
+  return new TelaSDK(opts);
+}
+
+exports.TelaFile = TelaFile;
+exports.TelaSDK = TelaSDK;
+exports.createTelaClient = createTelaClient;