@meistrari/tela-sdk-js 2.4.3 → 2.5.0

package/dist/index.cjs

@@ -24,12 +24,12 @@ const z__default = /*#__PURE__*/_interopDefaultCompat(z);
 const z__namespace = /*#__PURE__*/_interopNamespaceCompat(z);
 const Emittery__default = /*#__PURE__*/_interopDefaultCompat(Emittery);
 
-const version = "2.4.3";
+const version = "2.5.0";
 
-var __defProp$7 = Object.defineProperty;
-var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$7 = (obj, key, value) => {
-  __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$8 = Object.defineProperty;
+var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$8 = (obj, key, value) => {
+  __defNormalProp$8(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 class TelaError extends Error {
@@ -57,7 +57,7 @@ class InvalidFileURL extends TelaError {
 class FileUploadError extends TelaError {
   constructor(message, statusCode) {
     super(`Failed to upload file: ${message} (Status code: ${statusCode})`);
-    __publicField$7(this, "statusCode");
+    __publicField$8(this, "statusCode");
     this.statusCode = statusCode;
   }
 }
@@ -74,16 +74,23 @@ class InvalidExecutionModeError extends TelaError {
 class ExecutionFailedError extends TelaError {
   constructor(rawOutput) {
     super(`Execution failed: ${JSON.stringify(rawOutput)}`);
-    __publicField$7(this, "rawOutput");
+    __publicField$8(this, "rawOutput");
     this.rawOutput = rawOutput;
   }
 }
+class BatchExecutionFailedError extends TelaError {
+  constructor(rawResponse) {
+    super(`Batch execution failed: ${JSON.stringify(rawResponse)}`);
+    __publicField$8(this, "rawResponse");
+    this.rawResponse = rawResponse;
+  }
+}
 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$7(this, "statusCode");
-    __publicField$7(this, "error");
+    __publicField$8(this, "statusCode");
+    __publicField$8(this, "error");
     this.statusCode = statusCode;
     this.error = error;
   }
@@ -125,7 +132,7 @@ class APIError extends TelaError {
 class UserAbortError extends APIError {
   constructor({ message } = {}) {
     super(void 0, void 0, message || "User aborted.");
-    __publicField$7(this, "statusCode");
+    __publicField$8(this, "statusCode");
   }
 }
 class ConnectionError extends APIError {
@@ -134,7 +141,7 @@ class ConnectionError extends APIError {
     cause
   }) {
     super(void 0, void 0, message || "Connection error.");
-    __publicField$7(this, "statusCode");
+    __publicField$8(this, "statusCode");
     if (cause)
       this.cause = cause;
   }
@@ -144,57 +151,57 @@ class ConnectionTimeout extends APIError {
     message
   } = {}) {
     super(void 0, void 0, message || "Request timed out.");
-    __publicField$7(this, "statusCode");
+    __publicField$8(this, "statusCode");
   }
 }
 class BadRequestError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$7(this, "statusCode", 400);
+    __publicField$8(this, "statusCode", 400);
   }
   // todo: handle validation errors from zod/typebox
 }
 class AuthenticationError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$7(this, "statusCode", 401);
+    __publicField$8(this, "statusCode", 401);
   }
 }
 class AuthorizationError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$7(this, "statusCode", 403);
+    __publicField$8(this, "statusCode", 403);
   }
 }
 class NotFoundError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$7(this, "statusCode", 404);
+    __publicField$8(this, "statusCode", 404);
   }
 }
 class ConflictError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$7(this, "statusCode", 409);
+    __publicField$8(this, "statusCode", 409);
   }
 }
 class UnprocessableEntityError extends APIError {
   constructor() {
     super(...arguments);
     // todo: check if tela returns 400 or 422 for zod errors
-    __publicField$7(this, "statusCode", 422);
+    __publicField$8(this, "statusCode", 422);
   }
 }
 class RateLimitError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$7(this, "statusCode", 429);
+    __publicField$8(this, "statusCode", 429);
   }
 }
 class InternalServerError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$7(this, "statusCode", 500);
+    __publicField$8(this, "statusCode", 500);
   }
 }
 function toError(err) {
@@ -305,11 +312,38 @@ function transformObjectFromSnakeCaseToCamelCase(obj, exclusions = []) {
   }
   return result;
 }
+const DURATION_REGEX = /(?<amount>\d+)(?<unit>[smhd])/;
+const DURATION_UNITS = {
+  s: 1e3,
+  // 1 second in milliseconds
+  m: 6e4,
+  // 1 minute in milliseconds
+  h: 36e5,
+  // 1 hour in milliseconds
+  d: 864e5
+  // 1 day in milliseconds
+};
+function transformDurationToMs(durationStr) {
+  if (!durationStr) {
+    return void 0;
+  }
+  if (typeof durationStr === "number") {
+    return durationStr;
+  }
+  const match = durationStr.match(DURATION_REGEX);
+  const amount = match?.groups?.amount;
+  const unit = match?.groups?.unit;
+  const multiplier = DURATION_UNITS[unit];
+  if (!amount || Number.isNaN(Number.parseInt(amount)) || !multiplier) {
+    return void 0;
+  }
+  return Number.parseInt(amount) * multiplier;
+}
 
-var __defProp$6 = Object.defineProperty;
-var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$6 = (obj, key, value) => {
-  __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$7 = Object.defineProperty;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$7 = (obj, key, value) => {
+  __defNormalProp$7(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 class Stream {
@@ -573,9 +607,9 @@ function findDoubleNewlineIndex(buffer) {
 }
 class SSEDecoder {
   constructor() {
-    __publicField$6(this, "data");
-    __publicField$6(this, "event");
-    __publicField$6(this, "chunks");
+    __publicField$7(this, "data");
+    __publicField$7(this, "event");
+    __publicField$7(this, "chunks");
     this.event = null;
     this.data = [];
     this.chunks = [];
@@ -616,9 +650,9 @@ class SSEDecoder {
 const _LineDecoder = class _LineDecoder {
   // TextDecoder found in browsers; not typed to avoid pulling in either "dom" or "node" types.
   constructor() {
-    __publicField$6(this, "buffer");
-    __publicField$6(this, "trailingCR");
-    __publicField$6(this, "textDecoder");
+    __publicField$7(this, "buffer");
+    __publicField$7(this, "trailingCR");
+    __publicField$7(this, "textDecoder");
     this.buffer = [];
     this.trailingCR = false;
   }
@@ -693,8 +727,8 @@ const _LineDecoder = class _LineDecoder {
   }
 };
 // prettier-ignore
-__publicField$6(_LineDecoder, "NEWLINE_CHARS", /* @__PURE__ */ new Set(["\n", "\r"]));
-__publicField$6(_LineDecoder, "NEWLINE_REGEXP", /\r\n|[\n\r]/g);
+__publicField$7(_LineDecoder, "NEWLINE_CHARS", /* @__PURE__ */ new Set(["\n", "\r"]));
+__publicField$7(_LineDecoder, "NEWLINE_REGEXP", /\r\n|[\n\r]/g);
 let LineDecoder = _LineDecoder;
 function partition(str, delimiter) {
   const index = str.indexOf(delimiter);
@@ -731,10 +765,10 @@ function readableStreamAsyncIterable(stream) {
   };
 }
 
-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);
+var __defProp$6 = Object.defineProperty;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$6 = (obj, key, value) => {
+  __defNormalProp$6(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 function getRequestIdFromResponse(response) {
@@ -776,6 +810,7 @@ function getRequestIdFromResponse(response) {
 }
 async function defaultParseResponse(props) {
   const { response } = props;
+  const { transformCase = true } = props.options;
   if (props.options.stream) {
     debug("response", response.status, response.url, response.headers, response.body);
     return Stream.fromSSEResponse(response, props.controller);
@@ -793,18 +828,27 @@ async function defaultParseResponse(props) {
     if (requestId) {
       finalJson.requestId = requestId;
     }
-    return transformObjectFromSnakeCaseToCamelCase(finalJson, DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS);
+    return transformCase ? transformObjectFromSnakeCaseToCamelCase(finalJson, DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS) : finalJson;
   }
   const text = await response.text();
   debug("response", response.status, response.url, response.headers, text);
   return text;
 }
+function transformBody(body, transformCase) {
+  if (!body) {
+    return void 0;
+  }
+  if (transformCase) {
+    return transformObjectFromCamelCaseToSnakeCase(body, DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS);
+  }
+  return body;
+}
 class BaseClient {
   constructor({ baseURL, maxRetries = 5, timeout = 0 }) {
-    __publicField$5(this, "baseURL");
-    __publicField$5(this, "maxRetries");
-    __publicField$5(this, "timeout");
-    __publicField$5(this, "fetch");
+    __publicField$6(this, "baseURL");
+    __publicField$6(this, "maxRetries");
+    __publicField$6(this, "timeout");
+    __publicField$6(this, "fetch");
     this.baseURL = baseURL;
     this.maxRetries = validateMaxRetries(maxRetries);
     this.timeout = validateTimeout(timeout);
@@ -843,10 +887,11 @@ class BaseClient {
     return this.methodRequest("DELETE", path, opts);
   }
   async methodRequest(method, path, opts) {
+    const { transformCase = true } = 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 transformedBody = transformBody(opts?.body, transformCase);
     const { response, options, controller } = await this.request({
       method,
       path,
@@ -1080,10 +1125,10 @@ async function getStreamSize(stream) {
   return size;
 }
 
-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);
+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;
 };
 function TelaFileSchema() {
@@ -1091,11 +1136,11 @@ function TelaFileSchema() {
 }
 class TelaFile {
   constructor(file, options = {}) {
-    __publicField$4(this, "_file");
-    __publicField$4(this, "_options");
-    __publicField$4(this, "_size", null);
-    __publicField$4(this, "_mimeType");
-    __publicField$4(this, "_name");
+    __publicField$5(this, "_file");
+    __publicField$5(this, "_options");
+    __publicField$5(this, "_size", null);
+    __publicField$5(this, "_mimeType");
+    __publicField$5(this, "_name");
     this._file = file;
     if (file instanceof File || file instanceof Blob) {
       this._size = file.size;
@@ -1399,10 +1444,10 @@ function validateOutputSchema(clientSchema, serverSchema) {
   return compareSchemas(clientSchema, serverSchema);
 }
 
-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);
+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;
 };
 function timeout(ms, signal) {
@@ -1418,10 +1463,10 @@ function timeout(ms, signal) {
 }
 class Poller {
   constructor({ interval, timeout: timeout2, abortSignal }) {
-    __publicField$3(this, "_interval");
-    __publicField$3(this, "_timeout");
-    __publicField$3(this, "_abortSignal");
-    __publicField$3(this, "_internalAbortController");
+    __publicField$4(this, "_interval");
+    __publicField$4(this, "_timeout");
+    __publicField$4(this, "_abortSignal");
+    __publicField$4(this, "_internalAbortController");
     if (interval <= 0) {
       throw new TelaError("Interval must be greater than 0");
     }
@@ -1467,7 +1512,7 @@ class Poller {
     const resultPromise = async () => {
       try {
         while (!this._abortSignal.aborted) {
-          const result = await callback(this._abortSignal);
+          const result = await callback();
           if (result.done) {
             return result.value;
           }
@@ -1517,10 +1562,82 @@ async function calculateSha256sum(content) {
   }
 }
 
-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);
+async function uploadFile(file, client) {
+  let content = await file.getUploadableContent();
+  let sha256sumStream;
+  if (typeof content === "string") {
+    return { fileUrl: content, options: file.options };
+  }
+  const filename = file.name ?? void 0;
+  const fileType = file.type ?? void 0;
+  const contentLength = file.size ?? void 0;
+  if (content instanceof ReadableStream) {
+    const [hashStream, contentStream] = content.tee();
+    content = contentStream;
+    sha256sumStream = hashStream;
+  }
+  const sha256sum = await calculateSha256sum(sha256sumStream ?? content);
+  const { id, uploadUrl } = await client.post("/_services/vault/files", {
+    body: {
+      fileName: filename,
+      mimeType: fileType,
+      size: contentLength ?? void 0,
+      sha256sum
+    },
+    transformCase: false
+  });
+  if (content instanceof ReadableStream && typeof Bun !== "undefined") {
+    console.warn(
+      "[Tela SDK - WARNING] Buffering file upload due to Bun fetch implementation. Large files may cause memory issues. Consider using Node.js for streaming uploads.",
+      { fileName: filename, fileSize: contentLength }
+    );
+    const chunks = [];
+    const reader = content.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      chunks.push(value);
+    }
+    content = new Blob(chunks, { type: fileType ?? "application/octet-stream" });
+  }
+  const request = new Request(uploadUrl, {
+    method: "PUT",
+    body: content,
+    headers: {
+      "Content-Type": fileType ?? "application/octet-stream",
+      ...file.size ? { "Content-Length": file.size.toString() } : {}
+    }
+  });
+  const uploadResponse = await fetch(request);
+  if (!uploadResponse.ok) {
+    throw new FileUploadError(await uploadResponse.text(), uploadResponse.status);
+  }
+  return { fileUrl: `vault://${id}`, options: file.options };
+}
+async function downloadFile(vaultReference, client) {
+  const vaultId = vaultReference.replace("vault://", "");
+  const response = await client.get(`/_services/vault/files/${vaultId}`);
+  return fetch(response.url).then((res) => res.blob());
+}
+async function streamFile(vaultReference, client) {
+  const vaultId = vaultReference.replace("vault://", "");
+  const response = await client.get(`/_services/vault/files/${vaultId}`);
+  return fetch(response.url).then((res) => {
+    if (!res.ok) {
+      throw new Error("Failed to stream file", { cause: res.statusText });
+    }
+    if (!res.body) {
+      throw new Error("Failed to stream file", { cause: "No body" });
+    }
+    return res.body;
+  });
+}
+
+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;
 };
 function isTelaFile(obj) {
@@ -1571,20 +1688,20 @@ class CanvasExecution extends Emittery__default {
    */
   constructor(variables, params = { async: false }, outputSchema, client, isTask = false) {
     super();
-    __publicField$2(this, "_id");
-    __publicField$2(this, "_status");
-    __publicField$2(this, "_variables");
-    __publicField$2(this, "_params");
-    __publicField$2(this, "_client");
-    __publicField$2(this, "_outputSchema");
-    __publicField$2(this, "_skipResultValidation");
-    __publicField$2(this, "_abortController");
-    __publicField$2(this, "_isTask");
-    __publicField$2(this, "_resultPromise");
-    __publicField$2(this, "_stream");
-    __publicField$2(this, "_rawResultValue");
-    __publicField$2(this, "_requestId");
-    __publicField$2(this, "_task");
+    __publicField$3(this, "_id");
+    __publicField$3(this, "_status");
+    __publicField$3(this, "_variables");
+    __publicField$3(this, "_params");
+    __publicField$3(this, "_client");
+    __publicField$3(this, "_outputSchema");
+    __publicField$3(this, "_skipResultValidation");
+    __publicField$3(this, "_abortController");
+    __publicField$3(this, "_isTask");
+    __publicField$3(this, "_resultPromise");
+    __publicField$3(this, "_stream");
+    __publicField$3(this, "_rawResultValue");
+    __publicField$3(this, "_requestId");
+    __publicField$3(this, "_task");
     this._variables = variables;
     this._params = params;
     this._outputSchema = outputSchema;
@@ -2129,16 +2246,16 @@ class CanvasExecution extends Emittery__default {
       throw new InvalidExecutionModeError("Polling is only supported for async executions");
     }
     return new Poller({
-      interval: this._params.pollingInterval ?? 1e3,
+      interval: transformDurationToMs(this._params.pollingInterval) ?? 1e3,
       // 1 second
-      timeout: this._params.pollingTimeout ?? 6e4,
+      timeout: transformDurationToMs(this._params.pollingTimeout) ?? 6e4,
       // 1 minute
       abortSignal: this._abortController.signal
-    }).start(async (signal) => {
+    }).start(async () => {
       const response = await this._client.get(
         `/v2/chat/completions/${this.id}`,
         {
-          signal
+          signal: this._abortController.signal
         }
       );
       this.status = response.status;
@@ -2196,56 +2313,7 @@ class CanvasExecution extends Emittery__default {
    * ```
    */
   async uploadFile(file) {
-    let content = await file.getUploadableContent();
-    let sha256sumStream;
-    if (typeof content === "string") {
-      return { fileUrl: content, options: file.options };
-    }
-    const filename = file.name ?? void 0;
-    const fileType = file.type ?? void 0;
-    const contentLength = file.size ?? void 0;
-    if (content instanceof ReadableStream) {
-      const [hashStream, contentStream] = content.tee();
-      content = contentStream;
-      sha256sumStream = hashStream;
-    }
-    const sha256sum = await calculateSha256sum(sha256sumStream ?? content);
-    const { id, uploadUrl } = await this._client.post("/_services/vault/files", {
-      body: {
-        fileName: filename,
-        mimeType: fileType,
-        size: contentLength ?? void 0,
-        sha256sum
-      }
-    });
-    if (content instanceof ReadableStream && typeof Bun !== "undefined") {
-      console.warn(
-        "[Tela SDK - WARNING] Buffering file upload due to Bun fetch implementation. Large files may cause memory issues. Consider using Node.js for streaming uploads.",
-        { fileName: filename, fileSize: contentLength }
-      );
-      const chunks = [];
-      const reader = content.getReader();
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        chunks.push(value);
-      }
-      content = new Blob(chunks, { type: fileType ?? "application/octet-stream" });
-    }
-    const request = new Request(uploadUrl, {
-      method: "PUT",
-      body: content,
-      headers: {
-        "Content-Type": fileType ?? "application/octet-stream",
-        ...file.size ? { "Content-Length": file.size.toString() } : {}
-      }
-    });
-    const uploadResponse = await fetch(request);
-    if (!uploadResponse.ok) {
-      throw new FileUploadError(await uploadResponse.text(), uploadResponse.status);
-    }
-    return { fileUrl: `vault://${id}`, options: file.options };
+    return uploadFile(file, this._client);
   }
   /**
    * Uploads multiple files and returns their URLs and options.
@@ -2262,6 +2330,749 @@ class CanvasExecution extends Emittery__default {
   }
 }
 
+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;
+};
+const BatchResultItem = z__default.looseObject({
+  reference_id: z__default.string(),
+  status: z__default.string(),
+  execution_id: z__default.string(),
+  result: z__default.object({
+    id: z__default.string(),
+    tags: z__default.array(z__default.string()),
+    status: z__default.string(),
+    metadata: z__default.object({
+      promptVersion: z__default.object({
+        modelConfigurations: z__default.object({
+          type: z__default.string(),
+          model: z__default.string(),
+          temperature: z__default.number(),
+          structuredOutput: z__default.object({
+            schema: z__default.looseObject({}).optional(),
+            enabled: z__default.boolean()
+          })
+        }),
+        variablesDefinitions: z__default.array(
+          z__default.object({
+            name: z__default.string(),
+            type: z__default.string(),
+            required: z__default.boolean(),
+            processingOptions: z__default.object({ allowMultimodal: z__default.boolean() })
+          })
+        )
+      })
+    }),
+    promptId: z__default.string(),
+    rawInput: z__default.object({
+      tags: z__default.array(z__default.string()),
+      async: z__default.boolean(),
+      canvas_id: z__default.string(),
+      variables: z__default.looseObject({})
+    }),
+    createdAt: z__default.string(),
+    deletedAt: z__default.null(),
+    rawOutput: z__default.object({
+      id: z__default.string(),
+      usage: z__default.object({
+        cost: z__default.object({
+          total_cost: z__default.number(),
+          prompt_cost: z__default.number(),
+          completion_cost: z__default.number()
+        }),
+        total_tokens: z__default.number(),
+        prompt_tokens: z__default.number(),
+        completion_tokens: z__default.number()
+      }),
+      object: z__default.string(),
+      choices: z__default.array(
+        z__default.object({
+          message: z__default.object({
+            role: z__default.string(),
+            content: z__default.looseObject({}),
+            tool_calls: z__default.array(z__default.object({ type: z__default.string(), function: z__default.object({ name: z__default.string(), arguments: z__default.looseObject({}) }) })),
+            function_call: z__default.null()
+          })
+        })
+      ),
+      created: z__default.number()
+    }),
+    updatedAt: z__default.string(),
+    creditsUsed: z__default.number(),
+    workspaceId: z__default.string(),
+    inputContent: z__default.object({
+      files: z__default.array(z__default.object({ file_url: z__default.string() })),
+      messages: z__default.array(z__default.object({ role: z__default.string(), content: z__default.looseObject({}) })),
+      variables: z__default.looseObject({})
+    }),
+    outputContent: z__default.object({
+      role: z__default.string(),
+      content: z__default.looseObject({}),
+      tool_calls: z__default.array(z__default.looseObject({})),
+      function_call: z__default.string().nullable()
+    }),
+    promptVersionId: z__default.string(),
+    compatibilityDate: z__default.string(),
+    promptApplicationId: z__default.string().nullable()
+  }),
+  error: z__default.null()
+});
+class BatchExecutionResult {
+  /**
+   * Creates a new batch execution result wrapper.
+   *
+   * @param client - HTTP client for making API requests.
+   * @param response - Raw batch execution response from the server.
+   * @internal
+   */
+  constructor(client, response) {
+    __publicField$2(this, "_client");
+    __publicField$2(this, "_response");
+    this._client = client;
+    this._response = response;
+  }
+  get requestId() {
+    return this._response.requestId;
+  }
+  /**
+   * Gets the unique identifier for this batch execution.
+   *
+   * @returns The batch execution ID.
+   */
+  get id() {
+    return this._response.id;
+  }
+  /**
+   * Gets the current status of the batch execution.
+   *
+   * @returns The batch status.
+   */
+  get status() {
+    return this._response.status;
+  }
+  /**
+   * Gets the progress statistics for this batch.
+   *
+   * @returns Object containing completed, failed, and total execution counts, or null if not available.
+   */
+  get state() {
+    return this._response.state;
+  }
+  /**
+   * Gets the vault URL of the output JSONL file containing all results.
+   *
+   * @returns The output file URL, or null if batch is not completed.
+   */
+  get outputFile() {
+    return this._response.outputFile;
+  }
+  /**
+   * Gets the raw API response without any processing.
+   *
+   * @returns The complete batch response object.
+   */
+  get rawResponse() {
+    return this._response;
+  }
+  /**
+   * Gets the timestamp when this batch was created.
+   *
+   * @returns Creation date.
+   */
+  get createdAt() {
+    return new Date(this._response.createdAt);
+  }
+  /**
+   * Gets the timestamp when this batch was last updated.
+   *
+   * @returns Last update date.
+   */
+  get updatedAt() {
+    return new Date(this._response.updatedAt);
+  }
+  /**
+   * Gets the timestamp when this batch completed successfully.
+   *
+   * @returns Completion date, or null if not completed.
+   */
+  get completedAt() {
+    return this._response.completedAt ? new Date(this._response.completedAt) : null;
+  }
+  /**
+   * Gets the timestamp when this batch was canceled.
+   *
+   * @returns Cancellation date, or null if not canceled.
+   */
+  get canceledAt() {
+    return this._response.canceledAt ? new Date(this._response.canceledAt) : null;
+  }
+  /**
+   * Gets the timestamp when this batch failed.
+   *
+   * @returns Failure date, or null if not failed.
+   */
+  get failedAt() {
+    return this._response.failedAt ? new Date(this._response.failedAt) : null;
+  }
+  /**
+   * Downloads the complete output file as a Blob.
+   *
+   * The output file is a JSONL (JSON Lines) file where each line contains
+   * one execution result with its reference ID, status, and output.
+   *
+   * @throws {Error} If batch is not completed or output file is unavailable.
+   * @returns A promise resolving to the output file as a Blob.
+   *
+   * @example
+   * ```typescript
+   * const file = await result.downloadOutputFile()
+   * const text = await file.text()
+   * console.log(text) // JSONL content
+   * ```
+   */
+  downloadOutputFile() {
+    this.validateOutputFile();
+    return downloadFile(this._response.outputFile, this._client);
+  }
+  /**
+   * Streams the output file as a ReadableStream for memory-efficient processing.
+   *
+   * Useful for large batches where loading the entire file into memory is not practical.
+   *
+   * @throws {Error} If batch is not completed or output file is unavailable.
+   * @returns A promise resolving to a ReadableStream of the output file.
+   *
+   * @example
+   * ```typescript
+   * const stream = await result.streamOutputFile()
+   * // Process stream with custom logic
+   * ```
+   */
+  async streamOutputFile() {
+    this.validateOutputFile();
+    return streamFile(this._response.outputFile, this._client);
+  }
+  /**
+   * Downloads and parses all results into an array.
+   *
+   * Loads the entire output file into memory, parses each line, and extracts
+   * the output content. For large batches, consider using `iterateResults()` instead.
+   *
+   * @throws {Error} If batch is not completed, output file is unavailable, or parsing fails.
+   * @returns A promise resolving to an array of all execution outputs.
+   *
+   * @example
+   * ```typescript
+   * const results = await result.getResults()
+   * console.log(`Got ${results.length} results`)
+   * results.forEach((output, i) => console.log(`Result ${i}:`, output))
+   * ```
+   */
+  async getResults() {
+    const resultFile = await this.downloadOutputFile();
+    const results = await resultFile.text();
+    return results.split("\n").filter((line) => line.trim().length > 0).map((result) => JSON.parse(result)).map((result) => {
+      const parsedResult = BatchResultItem.safeParse(result);
+      if (!parsedResult.success) {
+        throw new Error("Invalid result from the batch API", { cause: parsedResult.error });
+      }
+      return parsedResult.data.result.outputContent.content;
+    });
+  }
+  /**
+   * Asynchronously iterates over raw result items from the output file.
+   *
+   * Streams and parses the output file line-by-line, yielding raw JSON objects.
+   * Each yielded object contains the full result structure including metadata.
+   *
+   * @param params - Iteration options.
+   * @param params.abortController - Optional AbortController to cancel iteration.
+   * @throws {Error} If batch is not completed or output file is unavailable.
+   * @yields Raw result objects from the JSONL file.
+   *
+   * @example
+   * ```typescript
+   * for await (const rawResult of result.iterateRawResults()) {
+   *   console.log('Reference ID:', rawResult.reference_id)
+   *   console.log('Status:', rawResult.status)
+   *   console.log('Output:', rawResult.result.outputContent.content)
+   * }
+   * ```
+   */
+  async *iterateRawResults(params = {}) {
+    const { abortController = new AbortController() } = params;
+    const stream = await this.streamOutputFile();
+    for await (const result of Stream.fromReadableStream(stream, abortController)) {
+      yield result;
+    }
+  }
+  /**
+   * Asynchronously iterates over parsed output content from the batch results.
+   *
+   * Streams and parses the output file line-by-line, yielding only the output content
+   * (not the full result metadata). Memory-efficient for large batches.
+   *
+   * @param params - Iteration options.
+   * @param params.abortController - Optional AbortController to cancel iteration.
+   * @throws {Error} If batch is not completed, output file is unavailable, or parsing fails.
+   * @yields Parsed output content from each execution.
+   *
+   * @example
+   * ```typescript
+   * const controller = new AbortController()
+   *
+   * for await (const output of result.iterateResults({ abortController: controller })) {
+   *   console.log(output)
+   *   if (someCondition) {
+   *     controller.abort() // Stop iteration early
+   *   }
+   * }
+   * ```
+   */
+  async *iterateResults(params = {}) {
+    for await (const result of this.iterateRawResults(params)) {
+      const parsedResult = BatchResultItem.safeParse(result);
+      if (!parsedResult.success) {
+        throw new Error("Invalid result from the batch API", { cause: parsedResult.error });
+      }
+      yield parsedResult.data.result.outputContent.content;
+    }
+  }
+  /**
+   * Fetches the raw result metadata for a specific execution by its reference ID.
+   *
+   * Queries the API for the execution result using the reference ID tag.
+   * Returns the complete execution metadata including input, output, and usage statistics.
+   *
+   * @param referenceId - The reference ID of the execution to retrieve.
+   * @throws {Error} If no result found with the given reference ID.
+   * @returns A promise resolving to the raw execution result object.
+   *
+   * @example
+   * ```typescript
+   * const rawResult = await result.getRawResult('my-ref-id')
+   * console.log('Credits used:', rawResult.creditsUsed)
+   * console.log('Execution status:', rawResult.status)
+   * ```
+   */
+  async getRawResult(referenceId) {
+    const response = await this._client.get("/v1/completion-run/", {
+      query: {
+        tags: `reference_id:${referenceId}`
+      }
+    });
+    const result = response.data[0];
+    if (!result) {
+      throw new Error("Result not found");
+    }
+    return result;
+  }
+  /**
+   * Fetches the output content for a specific execution by its reference ID.
+   *
+   * Convenience method that retrieves the raw result and extracts just the output content.
+   *
+   * @param referenceId - The reference ID of the execution to retrieve.
+   * @throws {Error} If no result found with the given reference ID.
+   * @returns A promise resolving to the execution output content.
+   *
+   * @example
+   * ```typescript
+   * const output = await result.getResult('my-ref-id')
+   * console.log('Output:', output)
+   * ```
+   */
+  async getResult(referenceId) {
+    const result = await this.getRawResult(referenceId);
+    return result.outputContent.content;
+  }
+  /**
+   * Validates that the output file is available for access.
+   *
+   * @throws {Error} If batch is not completed or output file is missing.
+   * @private
+   */
+  validateOutputFile() {
+    if (this._response.status !== "completed") {
+      throw new Error("Batch execution is not completed");
+    }
+    if (!this._response.outputFile) {
+      throw new Error("Output file not found");
+    }
+  }
+}
+class BatchExecution extends Emittery__default {
+  /**
+   * Creates a new batch execution instance.
+   *
+   * @param id - Unique identifier for this batch execution.
+   * @param client - HTTP client for making API requests.
+   * @param params - Batch execution parameters.
+   * @param creationResponse - Initial response from batch creation.
+   * @internal
+   */
+  constructor(id, client, params = {}, creationResponse) {
+    super();
+    __publicField$2(this, "_client");
+    __publicField$2(this, "_id");
+    __publicField$2(this, "_params");
+    __publicField$2(this, "_abortController");
+    __publicField$2(this, "_creationResponse");
+    __publicField$2(this, "_status", "created");
+    __publicField$2(this, "_resultPromise");
+    this._id = id;
+    this._client = client;
+    this._params = params;
+    this._abortController = new AbortController();
+    this._creationResponse = creationResponse;
+  }
+  /**
+   * Gets the latest known status of the batch execution.
+   *
+   * Status values and transitions:
+   * - `created` → `validating` → `running` → `completed` or `failed`
+   * - Can transition to `canceled` from any non-terminal state
+   *
+   * Use the `statusChange` event to track status transitions in real-time.
+   *
+   * @returns The current status of the batch execution.
+   *
+   * @example
+   * ```typescript
+   * const execution = await batch.execute()
+   * console.log(execution.status) // 'created'
+   *
+   * execution.on('statusChange', ([status]) => {
+   *   console.log('New status:', status)
+   * })
+   *
+   * await execution.result
+   * console.log(execution.status) // 'completed' or 'failed'
+   * ```
+   */
+  get status() {
+    return this._status;
+  }
+  /**
+   * Gets the unique identifier for this batch execution.
+   *
+   * @returns The batch execution ID.
+   */
+  get id() {
+    return this._id;
+  }
+  /**
+   * Gets the batch execution parameters.
+   *
+   * @returns The batch parameters.
+   */
+  get params() {
+    return this._params;
+  }
+  /**
+   * Cancels the batch execution.
+   *
+   * Sends a cancellation request to the server and aborts any ongoing polling.
+   * The batch will stop processing, but already-completed executions remain available.
+   *
+   * @returns A promise that resolves when the cancellation request completes.
+   *
+   * @example
+   * ```typescript
+   * const execution = await batch.execute()
+   * execution.poll()
+   *
+   * // Cancel after some condition
+   * if (shouldCancel) {
+   *   await execution.cancel()
+   *   console.log(execution.status) // 'canceled'
+   * }
+   * ```
+   */
+  async cancel() {
+    await this._client.put(`/_services/batch/batches/${this._id}/cancel`);
+    this._status = "canceled";
+    this._abortController.abort();
+  }
+  /**
+   * Starts polling for the batch result without waiting for the promise to resolve.
+   * This allows users to track batch progress via events rather than awaiting a promise.
+   *
+   * The following events will be emitted during polling:
+   * - `statusChange`: Emitted when the batch status changes (e.g., 'created' → 'running' → 'completed')
+   * - `poll`: Emitted on each polling attempt with the server response
+   * - `success`: Emitted when the batch completes successfully with the final result
+   * - `error`: Emitted if the batch fails
+   *
+   * **Important:** Events are only emitted while polling is active. You must call `poll()` or
+   * await `execution.result` to start polling. Simply setting up event listeners without starting
+   * polling will not trigger any events.
+   *
+   * @example
+   * ```typescript
+   * const execution = await batch.execute()
+   *
+   * // Set up event listeners
+   * execution.on('statusChange', ([status, response]) => {
+   *   console.log(`Status: ${status}`)
+   *   if (response.state) {
+   *     const { completed, total } = response.state
+   *     console.log(`Progress: ${completed}/${total}`)
+   *   }
+   * })
+   *
+   * execution.on('success', (result) => {
+   *   console.log('Batch completed!')
+   *   console.log('Request ID:', result.requestId)
+   * })
+   *
+   * execution.on('error', (error) => {
+   *   console.error('Batch failed:', error)
+   * })
+   *
+   * // Start polling without waiting
+   * execution.poll()
+   * ```
+   */
+  poll() {
+    if (this._resultPromise) {
+      return;
+    }
+    this._resultPromise = this.startPolling();
+    this._resultPromise.catch(() => {
+    });
+  }
+  /**
+   * Sets the batch status and emits statusChange event if changed.
+   *
+   * @param status - The new status.
+   * @param response - The response containing the status.
+   * @private
+   */
+  setStatus(status, response) {
+    const changed = this._status !== status;
+    this._status = status;
+    if (changed) {
+      this.emit("statusChange", [status, response]);
+    }
+  }
+  /**
+   * Starts polling the server for batch completion.
+   * Continues polling until the batch completes, fails, or times out.
+   *
+   * @throws {BatchExecutionFailedError} If the batch fails on the server.
+   * @throws {Error} If the polling operation times out.
+   * @returns A promise resolving to the final batch result.
+   * @private
+   */
+  async startPolling() {
+    this.emit("statusChange", [this._status, this._creationResponse]);
+    return new Poller({
+      interval: transformDurationToMs(this._params.pollingInterval) ?? 1e3,
+      // 1 second
+      timeout: transformDurationToMs(this._params.pollingTimeout) ?? 6e4,
+      // 1 minute
+      abortSignal: this._abortController.signal
+    }).start(async () => {
+      const response = await this._client.get(
+        `/_services/batch/batches/${this._id}`,
+        { signal: this._abortController.signal }
+      );
+      this.emit("poll", response);
+      this.setStatus(response.status, response);
+      if (response.status === "failed") {
+        const error = new BatchExecutionFailedError(response);
+        this._abortController.abort();
+        this.emit("error", error);
+        throw error;
+      }
+      if (response.status !== "completed") {
+        return {
+          done: false,
+          value: void 0
+        };
+      }
+      const result = new BatchExecutionResult(this._client, response);
+      this.emit("success", result);
+      return {
+        done: true,
+        value: result
+      };
+    });
+  }
+  /**
+   * Gets the batch execution result. Automatically starts polling if not already started.
+   *
+   * @returns A promise resolving to the batch execution result.
+   *
+   * @example
+   * ```typescript
+   * const execution = await batch.execute()
+   * const result = await execution.result
+   *
+   * // Access results
+   * const outputs = await result.getResults()
+   * console.log(`Got ${outputs.length} results`)
+   * ```
+   */
+  get result() {
+    if (!this._resultPromise) {
+      this._resultPromise = this.startPolling();
+    }
+    return this._resultPromise;
+  }
+}
+class Batch {
+  /**
+   * Creates a new batch builder.
+   *
+   * @param client - HTTP client for making API requests.
+   * @param canvasIdentifier - Canvas identification (ID + version or application ID).
+   * @param params - Optional batch execution parameters.
+   * @internal
+   */
+  constructor(client, canvasIdentifier, params = {}) {
+    __publicField$2(this, "_client");
+    __publicField$2(this, "_canvasIdentifier");
+    __publicField$2(this, "_items", []);
+    __publicField$2(this, "_params");
+    this._client = client;
+    this._canvasIdentifier = canvasIdentifier;
+    this._params = params;
+  }
+  /**
+   * Gets the current list of items in this batch.
+   *
+   * @returns Array of batch items.
+   */
+  get items() {
+    return this._items;
+  }
+  /**
+   * Gets the batch execution parameters.
+   *
+   * @returns The batch parameters.
+   */
+  get params() {
+    return this._params;
+  }
+  /**
+   * Gets the canvas identifier in the format expected by the API.
+   *
+   * @returns Canvas identifier object.
+   * @private
+   */
+  get canvasIdentifier() {
+    return "applicationId" in this._canvasIdentifier ? { applicationId: this._canvasIdentifier.applicationId } : { versionId: this._canvasIdentifier.versionId, canvasID: this._canvasIdentifier.id };
+  }
+  /**
+   * Adds one or more items to the batch.
+   *
+   * Items without a reference ID will have UUIDs generated automatically.
+   * This method can be called multiple times to build up the batch incrementally.
+   *
+   * @param item - Single item or array of items to add to the batch.
+   *
+   * @example
+   * ```typescript
+   * // Add single item
+   * batch.add({
+   *   referenceId: 'my-custom-id',
+   *   variables: { query: 'Hello' }
+   * })
+   *
+   * // Add multiple items
+   * batch.add([
+   *   { variables: { query: 'First' } },
+   *   { variables: { query: 'Second' } },
+   *   { variables: { query: 'Third' } }
+   * ])
+   *
+   * console.log(`Batch has ${batch.items.length} items`)
+   * ```
+   */
+  add(item) {
+    const items = Array.isArray(item) ? item : [item];
+    for (const item2 of items) {
+      this._items.push({
+        ...item2,
+        referenceId: item2.referenceId ?? crypto.randomUUID()
+      });
+    }
+  }
+  /**
+   * Executes the batch by uploading the input file and creating a batch execution on the server.
+   *
+   * Returns a promise-like object that allows flexible usage patterns:
+   * - Await for execution object: `const exec = await batch.execute()`
+   * - Direct result access: `const result = await batch.execute().result`
+   *
+   * The batch items are serialized to JSONL format, uploaded to vault storage,
+   * and submitted to the batch API for processing.
+   *
+   * @returns A promise-like object with a `result` property for direct result access.
+   *
+   * @example
+   * ```typescript
+   * // Direct result access (recommended for simple cases)
+   * const result = await batch.execute().result
+   * const outputs = await result.getResults()
+   *
+   * // Get execution object for event monitoring
+   * const execution = await batch.execute()
+   *
+   * execution.on('statusChange', ([status, response]) => {
+   *   console.log(`Status: ${status}`)
+   *   if (response.state) {
+   *     console.log(`Progress: ${response.state.completed}/${response.state.total}`)
+   *   }
+   * })
+   *
+   * execution.on('success', (result) => {
+   *   console.log('Batch completed!', result.requestId)
+   * })
+   *
+   * const result = await execution.result
+   *
+   * // Iterate through results
+   * for await (const output of result.iterateResults()) {
+   *   console.log(output)
+   * }
+   * ```
+   */
+  execute() {
+    const jsonLines = this._items.map((item) => ({
+      ...this.canvasIdentifier,
+      ...item
+    })).map((item) => transformObjectFromCamelCaseToSnakeCase(item)).map((item) => JSON.stringify(item));
+    const fileContent = new Blob([jsonLines.join("\n")], { type: "application/jsonl" });
+    const file = TelaFile.create(fileContent);
+    const client = this._client;
+    const params = this._params;
+    async function execute() {
+      const { fileUrl } = await uploadFile(file, client);
+      const body = {
+        task: "async-completion",
+        inputFile: fileUrl,
+        webhookUrl: params.webhookUrl
+      };
+      return client.post("/_services/batch/batches", {
+        body
+      }).then((response) => new BatchExecution(response.id, client, params, response));
+    }
+    return {
+      then(onfulfilled, onrejected) {
+        return Promise.resolve(execute()).then((execution) => onfulfilled?.(execution) ?? execution).catch(onrejected);
+      },
+      get result() {
+        return Promise.resolve(execute()).then((execution) => execution.result);
+      }
+    };
+  }
+}
+
 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) => {
@@ -2544,6 +3355,38 @@ class Canvas {
       }
     );
   }
+  /**
+   * Prepares to execute this canvas in batch.
+   *
+   * @param params - The parameters for the batch.
+   * @param params.pollingInterval - The interval between polling attempts.
+   * @param params.pollingTimeout - The timeout for the batch.
+   * @param params.webhookUrl - The webhook URL for the batch.
+   *
+   * @example
+   * ```typescript
+   * const batch = canvas.createBatch({
+   *   pollingInterval: '1s',
+   *   pollingTimeout: '1m',
+   *   webhookUrl: 'https://example.com/webhook',
+   * })
+   *
+   * batch.add({
+   *   referenceId: crypto.randomUUID(), // Optional
+   *   variables: { query: 'Hello' },
+   * })
+   *
+   * const execution = await batch.execute()
+   * const result = await execution.result
+   * const resultFile = await execution.downloadOutputFile()
+   * ```
+   *
+   * @returns The batch instance that can be used to manage the batch.
+   */
+  createBatch(params = {}) {
+    const canvasIdentifier = this._applicationId ? { applicationId: this._applicationId } : { versionId: this._versionId, id: this._id };
+    return new Batch(this._client, canvasIdentifier, params);
+  }
 }
 
 var __defProp = Object.defineProperty;
@@ -2676,6 +3519,7 @@ exports.AuthenticationError = AuthenticationError;
 exports.AuthorizationError = AuthorizationError;
 exports.BadRequestError = BadRequestError;
 exports.BaseClient = BaseClient;
+exports.BatchExecutionFailedError = BatchExecutionFailedError;
 exports.ConflictApiKeyAndJWTError = ConflictApiKeyAndJWTError;
 exports.ConflictError = ConflictError;
 exports.ConnectionError = ConnectionError;