@meistrari/tela-sdk-js 2.4.3 → 2.6.0

package/dist/index.cjs

@@ -21,15 +21,14 @@ function _interopNamespaceCompat(e) {
 
 const changeCase__namespace = /*#__PURE__*/_interopNamespaceCompat(changeCase);
 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.6.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$a = Object.defineProperty;
+var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$a = (obj, key, value) => {
+  __defNormalProp$a(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 class TelaError extends Error {
@@ -57,7 +56,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$a(this, "statusCode");
     this.statusCode = statusCode;
   }
 }
@@ -74,16 +73,30 @@ class InvalidExecutionModeError extends TelaError {
 class ExecutionFailedError extends TelaError {
   constructor(rawOutput) {
     super(`Execution failed: ${JSON.stringify(rawOutput)}`);
-    __publicField$7(this, "rawOutput");
+    __publicField$a(this, "rawOutput");
     this.rawOutput = rawOutput;
   }
 }
+class TaskFailedError extends TelaError {
+  constructor(rawTask, message, cause) {
+    super(`Task failed: ${JSON.stringify(rawTask)}`, { cause });
+    __publicField$a(this, "rawTask");
+    this.rawTask = rawTask;
+  }
+}
+class BatchExecutionFailedError extends TelaError {
+  constructor(rawResponse) {
+    super(`Batch execution failed: ${JSON.stringify(rawResponse)}`);
+    __publicField$a(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$a(this, "statusCode");
+    __publicField$a(this, "error");
     this.statusCode = statusCode;
     this.error = error;
   }
@@ -125,7 +138,7 @@ class APIError extends TelaError {
 class UserAbortError extends APIError {
   constructor({ message } = {}) {
     super(void 0, void 0, message || "User aborted.");
-    __publicField$7(this, "statusCode");
+    __publicField$a(this, "statusCode");
   }
 }
 class ConnectionError extends APIError {
@@ -134,7 +147,7 @@ class ConnectionError extends APIError {
     cause
   }) {
     super(void 0, void 0, message || "Connection error.");
-    __publicField$7(this, "statusCode");
+    __publicField$a(this, "statusCode");
     if (cause)
       this.cause = cause;
   }
@@ -144,57 +157,57 @@ class ConnectionTimeout extends APIError {
     message
   } = {}) {
     super(void 0, void 0, message || "Request timed out.");
-    __publicField$7(this, "statusCode");
+    __publicField$a(this, "statusCode");
   }
 }
 class BadRequestError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$7(this, "statusCode", 400);
+    __publicField$a(this, "statusCode", 400);
   }
   // todo: handle validation errors from zod/typebox
 }
 class AuthenticationError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$7(this, "statusCode", 401);
+    __publicField$a(this, "statusCode", 401);
   }
 }
 class AuthorizationError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$7(this, "statusCode", 403);
+    __publicField$a(this, "statusCode", 403);
   }
 }
 class NotFoundError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$7(this, "statusCode", 404);
+    __publicField$a(this, "statusCode", 404);
   }
 }
 class ConflictError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$7(this, "statusCode", 409);
+    __publicField$a(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$a(this, "statusCode", 422);
   }
 }
 class RateLimitError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$7(this, "statusCode", 429);
+    __publicField$a(this, "statusCode", 429);
   }
 }
 class InternalServerError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$7(this, "statusCode", 500);
+    __publicField$a(this, "statusCode", 500);
   }
 }
 function toError(err) {
@@ -305,11 +318,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$9 = Object.defineProperty;
+var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$9 = (obj, key, value) => {
+  __defNormalProp$9(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 class Stream {
@@ -573,9 +613,9 @@ function findDoubleNewlineIndex(buffer) {
 }
 class SSEDecoder {
   constructor() {
-    __publicField$6(this, "data");
-    __publicField$6(this, "event");
-    __publicField$6(this, "chunks");
+    __publicField$9(this, "data");
+    __publicField$9(this, "event");
+    __publicField$9(this, "chunks");
     this.event = null;
     this.data = [];
     this.chunks = [];
@@ -616,9 +656,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$9(this, "buffer");
+    __publicField$9(this, "trailingCR");
+    __publicField$9(this, "textDecoder");
     this.buffer = [];
     this.trailingCR = false;
   }
@@ -693,8 +733,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$9(_LineDecoder, "NEWLINE_CHARS", /* @__PURE__ */ new Set(["\n", "\r"]));
+__publicField$9(_LineDecoder, "NEWLINE_REGEXP", /\r\n|[\n\r]/g);
 let LineDecoder = _LineDecoder;
 function partition(str, delimiter) {
   const index = str.indexOf(delimiter);
@@ -731,10 +771,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$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;
 };
 function getRequestIdFromResponse(response) {
@@ -776,6 +816,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);
@@ -789,22 +830,30 @@ async function defaultParseResponse(props) {
     const json = await response.json();
     debug("response", response.status, response.url, response.headers, json);
     const requestId = getRequestIdFromResponse(response);
-    const finalJson = { ...json };
     if (requestId) {
-      finalJson.requestId = requestId;
+      json.requestId = requestId;
     }
-    return transformObjectFromSnakeCaseToCamelCase(finalJson, DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS);
+    return transformCase ? transformObjectFromSnakeCaseToCamelCase(json, DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS) : json;
   }
   const text = await response.text();
   debug("response", response.status, response.url, response.headers, text);
   return text;
 }
+function transformObjectCase(obj, transformCase) {
+  if (!obj) {
+    return obj;
+  }
+  if (transformCase) {
+    return transformObjectFromCamelCaseToSnakeCase(obj, DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS);
+  }
+  return obj;
+}
 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$8(this, "baseURL");
+    __publicField$8(this, "maxRetries");
+    __publicField$8(this, "timeout");
+    __publicField$8(this, "fetch");
     this.baseURL = baseURL;
     this.maxRetries = validateMaxRetries(maxRetries);
     this.timeout = validateTimeout(timeout);
@@ -843,10 +892,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 transformedQuery = transformObjectCase(opts?.query, transformCase);
+    const transformedBody = transformObjectCase(opts?.body, transformCase);
     const { response, options, controller } = await this.request({
       method,
       path,
@@ -1027,6 +1077,9 @@ class BaseClient {
       if (value === null) {
         return `${encodeURIComponent(key)}=`;
       }
+      if (Array.isArray(value)) {
+        return value.map((item) => `${encodeURIComponent(key)}[]=${encodeURIComponent(item)}`).join("&");
+      }
       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.`
       );
@@ -1080,10 +1133,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$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;
 };
 function TelaFileSchema() {
@@ -1091,11 +1144,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$7(this, "_file");
+    __publicField$7(this, "_options");
+    __publicField$7(this, "_size", null);
+    __publicField$7(this, "_mimeType");
+    __publicField$7(this, "_name");
     this._file = file;
     if (file instanceof File || file instanceof Blob) {
       this._size = file.size;
@@ -1241,7 +1294,17 @@ class TelaFile {
     return url.startsWith("vault://");
   }
 }
+function isTelaFile(obj) {
+  return obj instanceof TelaFile;
+}
+function isTelaFileArray(obj) {
+  return Array.isArray(obj) && obj.length > 0 && obj.every(isTelaFile);
+}
 
+const zod = {
+  ...z.z,
+  file: TelaFileSchema
+};
 function compareSchemas(clientSchema, serverSchema, path = "$") {
   const mismatches = [];
   if (clientSchema.type !== serverSchema.type) {
@@ -1398,11 +1461,172 @@ function validateInputSchema(clientSchema, serverVariables) {
 function validateOutputSchema(clientSchema, serverSchema) {
   return compareSchemas(clientSchema, serverSchema);
 }
+function validateSchemas(resource, input, output, promptVersion) {
+  const canvasIdentifier = `${promptVersion.title} (${promptVersion.promptId})`;
+  if (input instanceof z.z.ZodType) {
+    try {
+      const inputSchema = z.z.toJSONSchema(input, { unrepresentable: "any" });
+      const mismatches = validateInputSchema(inputSchema, promptVersion.variables);
+      if (mismatches.length === 0) {
+        return;
+      }
+      console.warn(
+        `[Tela SDK - ${resource} Input Validation] Input schema mismatches for ${resource} "${canvasIdentifier}":`
+      );
+      for (const mismatch of mismatches) {
+        console.warn(`  - ${mismatch.path}: ${mismatch.issue}`);
+      }
+    } catch (error) {
+      console.warn(
+        `[Tela SDK - ${resource} Input Validation] Failed to validate input schema for ${resource} "${canvasIdentifier}":`,
+        error
+      );
+    }
+  }
+  if (output instanceof z.z.ZodType) {
+    try {
+      const outputSchema = z.z.toJSONSchema(output);
+      const serverOutput = promptVersion.configuration.structuredOutput;
+      if (!serverOutput.enabled) {
+        console.warn(
+          `[Tela SDK - ${resource} Output Validation] Output schema provided for ${resource} "${canvasIdentifier}", but structured output is not enabled on the server. The schema may not be enforced.`
+        );
+        return;
+      }
+      const mismatches = validateOutputSchema(outputSchema, serverOutput.schema);
+      if (mismatches.length === 0) {
+        return;
+      }
+      console.warn(
+        `[Tela SDK - ${resource} Output Validation] Output schema mismatches for ${resource} "${canvasIdentifier}":`
+      );
+      for (const mismatch of mismatches) {
+        console.warn(`  - ${mismatch.path}: ${mismatch.issue}`);
+      }
+    } catch (error) {
+      console.warn(
+        `[Tela SDK - ${resource} Output Validation] Failed to validate output schema for ${resource} "${canvasIdentifier}":`,
+        error
+      );
+    }
+  }
+}
 
-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);
+async function calculateSha256sum(content) {
+  const stream = content instanceof File || content instanceof Blob ? content.stream() : content;
+  const reader = stream.getReader();
+  try {
+    const { createHash } = await import('node:crypto');
+    const hash = createHash("sha256");
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      hash.update(value);
+    }
+    return hash.digest("hex");
+  } catch {
+    const chunks = [];
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      chunks.push(value);
+    }
+    const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+    const buffer = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      buffer.set(chunk, offset);
+      offset += chunk.length;
+    }
+    const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+    return hashHex;
+  }
+}
+
+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 uploadFiles(files, client) {
+  const uploadPromises = files.map((file) => uploadFile(file, client));
+  return Promise.all(uploadPromises);
+}
+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$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 timeout(ms, signal) {
@@ -1418,10 +1642,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$6(this, "_interval");
+    __publicField$6(this, "_timeout");
+    __publicField$6(this, "_abortSignal");
+    __publicField$6(this, "_internalAbortController");
     if (interval <= 0) {
       throw new TelaError("Interval must be greater than 0");
     }
@@ -1467,7 +1691,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;
           }
@@ -1482,53 +1706,12 @@ class Poller {
   }
 }
 
-async function calculateSha256sum(content) {
-  const stream = content instanceof File || content instanceof Blob ? content.stream() : content;
-  const reader = stream.getReader();
-  try {
-    const { createHash } = await import('node:crypto');
-    const hash = createHash("sha256");
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      hash.update(value);
-    }
-    return hash.digest("hex");
-  } catch {
-    const chunks = [];
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      chunks.push(value);
-    }
-    const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
-    const buffer = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-      buffer.set(chunk, offset);
-      offset += chunk.length;
-    }
-    const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
-    const hashArray = Array.from(new Uint8Array(hashBuffer));
-    const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-    return hashHex;
-  }
-}
-
-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);
+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 isTelaFile(obj) {
-  return obj instanceof TelaFile;
-}
-function isTelaFileArray(obj) {
-  return Array.isArray(obj) && obj.length > 0 && obj.every(isTelaFile);
-}
 function isUUID(str) {
   const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
   return uuidRegex.test(str);
@@ -1560,6 +1743,17 @@ function getResultFromPollingResponse(response) {
   }
   throw new Error("Invalid response type");
 }
+function normalizeExecutionStatus(status) {
+  switch (status) {
+    case "completed":
+    case "validating":
+      return "succeeded";
+    case "cancelled":
+      return "failed";
+    default:
+      return status;
+  }
+}
 class CanvasExecution extends Emittery__default {
   /**
    * Creates a new canvas execution instance.
@@ -1571,20 +1765,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$5(this, "_id");
+    __publicField$5(this, "_status");
+    __publicField$5(this, "_variables");
+    __publicField$5(this, "_params");
+    __publicField$5(this, "_client");
+    __publicField$5(this, "_outputSchema");
+    __publicField$5(this, "_skipResultValidation");
+    __publicField$5(this, "_abortController");
+    __publicField$5(this, "_isTask");
+    __publicField$5(this, "_resultPromise");
+    __publicField$5(this, "_stream");
+    __publicField$5(this, "_rawResultValue");
+    __publicField$5(this, "_requestId");
+    __publicField$5(this, "_task");
     this._variables = variables;
     this._params = params;
     this._outputSchema = outputSchema;
@@ -2090,13 +2284,13 @@ class CanvasExecution extends Emittery__default {
     const resolvedVariables = await this.resolveVariables();
     return await this.create(resolvedVariables, { async: true }).then((response) => {
       this._id = "completionRunId" in response ? response.completionRunId : response.id;
-      this.status = response.status;
+      this.status = normalizeExecutionStatus(response.status);
       if (this._isTask) {
         this._task = response;
       }
       this.emit("poll", {
         id: response.id,
-        status: response.status,
+        status: normalizeExecutionStatus(response.status),
         outputContent: response.outputContent,
         rawOutput: "rawOutput" in response ? response.rawOutput : void 0,
         requestId: response.requestId
@@ -2129,27 +2323,27 @@ 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;
+      this.status = normalizeExecutionStatus(response.status);
       this.emit("poll", response);
-      if (response.status === "failed") {
+      if (this.status === "failed") {
         const error = new ExecutionFailedError(response.rawOutput);
         this.cancel();
         this.emit("error", error);
         throw error;
       }
-      if (response.status !== "succeeded") {
+      if (this.status !== "succeeded") {
         return {
           done: false,
           value: void 0
@@ -2158,7 +2352,7 @@ class CanvasExecution extends Emittery__default {
       this._rawResultValue = response;
       this.emit("success", { ...getResultFromPollingResponse(response), requestId: response?.requestId });
       return {
-        done: response.status === "succeeded",
+        done: this.status === "succeeded",
         value: getResultFromPollingResponse(response)
       };
     }).then((value) => {
@@ -2167,7 +2361,7 @@ class CanvasExecution extends Emittery__default {
       }
       return this._outputSchema.parse(value);
     }).catch((error) => {
-      if (this._status !== "failed") {
+      if (this.status !== "failed") {
         this.status = "failed";
       }
       if (this.listenerCount("error") > 0) {
@@ -2196,56 +2390,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,213 +2407,1516 @@ class CanvasExecution extends Emittery__default {
   }
 }
 
-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);
+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;
 };
-const zod = {
-  ...z__namespace,
-  file: TelaFileSchema
-};
-function fetchById(id, client) {
-  return client.get(`/prompt/${id}/promoted-version`);
-}
-function fetchByVersionId(versionId, client) {
-  return client.get(`/prompt-version/${versionId}`);
-}
-function fetchByApplicationId(applicationId, client) {
-  return client.get(`/prompt-application/${applicationId}/targetPromptVersion`);
-}
-function fetchByAny({ id, versionId, applicationId, client }) {
-  if (applicationId) {
-    return fetchByApplicationId(applicationId, client);
+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$4(this, "_client");
+    __publicField$4(this, "_response");
+    this._client = client;
+    this._response = response;
   }
-  if (versionId) {
-    return fetchByVersionId(versionId, client);
+  get requestId() {
+    return this._response.requestId;
   }
-  if (id) {
-    return fetchById(id, client);
+  /**
+   * 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$4(this, "_client");
+    __publicField$4(this, "_id");
+    __publicField$4(this, "_params");
+    __publicField$4(this, "_abortController");
+    __publicField$4(this, "_creationResponse");
+    __publicField$4(this, "_status", "created");
+    __publicField$4(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$4(this, "_client");
+    __publicField$4(this, "_canvasIdentifier");
+    __publicField$4(this, "_items", []);
+    __publicField$4(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$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 fetchById(id, client) {
+  return client.get(`/prompt/${id}/promoted-version`);
+}
+function fetchByVersionId(versionId, client) {
+  return client.get(`/prompt-version/${versionId}`);
+}
+function fetchByApplicationId(applicationId, client) {
+  return client.get(`/prompt-application/${applicationId}/targetPromptVersion`);
+}
+function fetchByAny({ id, versionId, applicationId, client }) {
+  if (applicationId) {
+    return fetchByApplicationId(applicationId, client);
+  }
+  if (versionId) {
+    return fetchByVersionId(versionId, client);
+  }
+  if (id) {
+    return fetchById(id, client);
   }
   throw new Error("Either id, versionId, or applicationId must be provided");
 }
-function validateSchemas(input, output, promptVersion) {
-  const canvasIdentifier = `${promptVersion.title} (${promptVersion.promptId})`;
-  if (input instanceof z.z.ZodType) {
+class Canvas {
+  /**
+   * Creates a new instance of the Canvas class. Usage of this constructor is not recommended.
+   * Use the `tela.getCanvas` method instead.
+   *
+   * @private
+   */
+  constructor({ id, applicationId, name, versionId, input, output, client, variables, isWorkflow }) {
+    __publicField$3(this, "_id");
+    __publicField$3(this, "_versionId");
+    __publicField$3(this, "_applicationId");
+    __publicField$3(this, "_name");
+    __publicField$3(this, "_input");
+    __publicField$3(this, "_output");
+    __publicField$3(this, "_client");
+    __publicField$3(this, "_variables");
+    __publicField$3(this, "_isWorkflow");
+    this._id = id;
+    this._applicationId = applicationId;
+    this._name = name;
+    this._versionId = versionId;
+    this._input = input && input(zod);
+    this._output = output && output(zod);
+    this._client = client;
+    this._variables = variables;
+    this._isWorkflow = isWorkflow;
+  }
+  /**
+   * Gets a canvas by its ID.
+   *
+   * @param options - The options to use to get the canvas.
+   * @param options.id - The ID of the canvas to get.
+   * @param options.versionId - The version ID of the canvas to get.
+   * @param options.applicationId - The application ID of the canvas to get.
+   * @param options.client - The client to use to make the request.
+   * @param options.input - The input schema of the canvas to get.
+   * @param options.output - The output schema of the canvas to get.
+   * @returns The canvas.
+   */
+  static async get(options) {
+    const { id, versionId, applicationId, client, input, output, skipSchemaValidation = false } = options;
+    const promptVersion = await fetchByAny({ id, versionId, applicationId, client });
+    const inputSchema = input && input(zod);
+    const outputSchema = output && output(zod);
+    if (!skipSchemaValidation) {
+      validateSchemas("Canvas", inputSchema, outputSchema, promptVersion);
+    }
+    return new Canvas({
+      id: promptVersion.promptId,
+      versionId: promptVersion.id,
+      applicationId: applicationId ?? void 0,
+      name: promptVersion.title,
+      input,
+      output,
+      client,
+      variables: promptVersion.variables,
+      isWorkflow: promptVersion.isWorkflow
+    });
+  }
+  /**
+   * Gets the unique identifier of this canvas.
+   *
+   * @returns The canvas ID.
+   */
+  get id() {
+    if (!this._id) {
+      throw new Error("Canvas ID is not set");
+    }
+    return this._id;
+  }
+  /**
+   * Gets the name of this canvas, if provided.
+   *
+   * @returns The canvas name or undefined.
+   */
+  get name() {
+    if (!this._name) {
+      throw new Error("Canvas name is not set");
+    }
+    return this._name;
+  }
+  /**
+   * Gets the version identifier of this canvas, if specified.
+   * When undefined, the latest promoted version is used.
+   *
+   * @returns The version ID or undefined.
+   */
+  get versionId() {
+    if (!this._versionId) {
+      throw new Error("Canvas version ID is not set");
+    }
+    return this._versionId;
+  }
+  get applicationId() {
+    if (!this._applicationId) {
+      throw new Error("Canvas application ID is not set");
+    }
+    return this._applicationId;
+  }
+  /**
+   * Gets the variables of this canvas.
+   *
+   * @returns The variables of the canvas.
+   */
+  get variables() {
+    return this._variables;
+  }
+  /**
+   * Gets whether this canvas is a workflow.
+   *
+   * @returns True if the canvas is a workflow.
+   */
+  get isWorkflow() {
+    return this._isWorkflow;
+  }
+  /**
+   * Gets whether this canvas is a workstation.
+   * This is true if an application ID is provided.
+   *
+   * @returns True if the canvas is a workstation.
+   */
+  get isWorkstation() {
+    return Boolean(this._applicationId);
+  }
+  /**
+   * Validates and parses input variables using the canvas input schema.
+   *
+   * @param variables - Raw input variables to validate.
+   * @returns Parsed and validated variables.
+   * @throws {ZodError} If validation fails when a Zod schema is configured.
+   */
+  parseVariables(variables) {
     try {
-      const inputSchema = z.z.toJSONSchema(input, { unrepresentable: "any" });
-      const mismatches = validateInputSchema(inputSchema, promptVersion.variables);
-      if (mismatches.length === 0) {
-        return;
-      }
-      console.warn(
-        `[Tela SDK - Canvas Input Validation] Input schema mismatches for canvas "${canvasIdentifier}":`
-      );
-      for (const mismatch of mismatches) {
-        console.warn(`  - ${mismatch.path}: ${mismatch.issue}`);
+      if (this._input instanceof z.z.ZodType) {
+        return this._input.parse(variables);
       }
+      return variables;
     } catch (error) {
-      console.warn(
-        `[Tela SDK - Canvas Input Validation] Failed to validate input schema for canvas "${canvasIdentifier}":`,
-        error
-      );
+      if (!(error instanceof z.ZodError)) {
+        throw error;
+      }
+      throw new Error(z.z.prettifyError(error));
     }
   }
-  if (output instanceof z.z.ZodType) {
-    try {
-      const outputSchema = z.z.toJSONSchema(output);
-      const serverOutput = promptVersion.configuration.structuredOutput;
-      if (!serverOutput.enabled) {
-        console.warn(
-          `[Tela SDK - Canvas Output Validation] Output schema provided for canvas "${canvasIdentifier}", but structured output is not enabled on the server. The schema may not be enforced.`
-        );
-        return;
+  execute(variables, params) {
+    const parsedInput = this.parseVariables(variables);
+    const idObject = this._applicationId ? { applicationId: this._applicationId } : { versionId: this._versionId, canvasId: this._id };
+    const fullParams = {
+      ...params ?? { async: false },
+      ...idObject
+    };
+    const execution = new CanvasExecution(parsedInput, fullParams, this._output, this._client, this.isWorkstation);
+    return {
+      then(onfulfilled, onrejected) {
+        return Promise.resolve(execution.start()).then(() => onfulfilled?.(execution) ?? execution).catch(onrejected);
+      },
+      get result() {
+        return Promise.resolve(execution.start()).then(() => execution.result);
+      }
+    };
+  }
+  /**
+   * Fetches an existing async execution by its ID.
+   *
+   * This method retrieves the current state of an async execution that was previously
+   * started on this canvas. Only async executions can be fetched, as they are the only
+   * ones with persistent UUIDs on the server.
+   *
+   * @param id - The UUID of the async execution to fetch.
+   * @param options - Optional configuration for polling behavior.
+   * @param options.pollingInterval - Time in milliseconds between polling attempts (default: 1000).
+   * @param options.pollingTimeout - Maximum time in milliseconds to wait for completion (default: 60000).
+   * @throws {InvalidExecutionModeError} If the provided ID is not a valid UUID.
+   * @returns A promise resolving to a CanvasExecution instance with the fetched state.
+   *
+   * @example
+   * ```typescript
+   * // Start an async execution
+   * const execution = await canvas.execute({ query: 'test' }, { async: true })
+   * const executionId = execution.id
+   *
+   * // Later, fetch the execution by ID
+   * const fetched = await canvas.getExecution(executionId)
+   * console.log(fetched.status) // 'running', 'succeeded', or 'failed'
+   *
+   * // Use poll() for event-driven progress tracking
+   * fetched.on('statusChange', (status) => console.log('Status:', status))
+   * fetched.poll()
+   * ```
+   */
+  async getExecution(id, options) {
+    return CanvasExecution.fetch(
+      id,
+      this._output,
+      this._client,
+      {
+        ...options,
+        isTask: this.isWorkstation
+      }
+    );
+  }
+  /**
+   * 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);
+  }
+}
+
+const TaskStatus = z.z.enum(["created", "failed", "running", "validating", "completed", "cancelled"]);
+const OutputContent = z.z.object({
+  role: z.z.literal("assistant"),
+  content: z.z.unknown(),
+  toolCalls: z.z.array(z.z.any()),
+  functionCall: z.z.any()
+});
+const RawInput = z.z.object({
+  async: z.z.boolean(),
+  stream: z.z.boolean(),
+  variables: z.z.record(z.z.string(), z.z.unknown()),
+  applicationId: z.z.string()
+});
+z.z.object({
+  id: z.z.string(),
+  reference: z.z.number(),
+  name: z.z.string(),
+  status: TaskStatus,
+  rawInput: RawInput,
+  inputContent: z.z.any(),
+  outputContent: OutputContent,
+  originalOutputContent: OutputContent,
+  createdBy: z.z.string(),
+  approvedBy: z.z.any(),
+  approvedAt: z.z.any(),
+  completionRunId: z.z.string(),
+  workflowRunId: z.z.any(),
+  promptVersionId: z.z.string(),
+  promptApplicationId: z.z.string(),
+  workspaceId: z.z.string(),
+  metadata: z.z.any(),
+  tags: z.z.array(z.z.string()),
+  createdAt: z.z.string(),
+  updatedAt: z.z.string(),
+  deletedAt: z.z.any(),
+  requestId: z.z.string()
+});
+
+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 Task extends Emittery__default {
+  constructor(client, variables, task, requestId, outputSchema, skipResultValidation = false) {
+    super();
+    __publicField$2(this, "_variables");
+    __publicField$2(this, "_task");
+    __publicField$2(this, "_abortController", new AbortController());
+    __publicField$2(this, "_client");
+    __publicField$2(this, "_outputSchema");
+    __publicField$2(this, "_skipResultValidation");
+    __publicField$2(this, "_resultPromise");
+    __publicField$2(this, "_status");
+    __publicField$2(this, "_requestId");
+    this._variables = variables;
+    this._task = task;
+    this._client = client;
+    this._outputSchema = outputSchema;
+    this._skipResultValidation = skipResultValidation;
+    this._status = task.status;
+    this._requestId = requestId;
+  }
+  /**
+   * Gets the unique task ID assigned by the server.
+   *
+   * @returns The task ID.
+   */
+  get id() {
+    if (!this._task.id) {
+      throw new Error("Task ID is not available");
+    }
+    return this._task.id;
+  }
+  /**
+   * Gets the request ID from the `x-request-id` header of the task creation request.
+   *
+   * This is the request ID from the initial POST /task request that created the task.
+   * Each API request has its own unique request ID.
+   *
+   * For polling operations, different request IDs are available:
+   * - `task.requestId` - ID from the task creation request
+   * - `pollResult.requestId` - ID from each polling request (in poll events)
+   * - `result.requestId` - ID from the final successful polling request (in success events)
+   *
+   * @returns A promise that resolves to the request ID from the task creation request.
+   *
+   * @example
+   * ```typescript
+   * const task = await workstation.createTask({ query: 'test' })
+   * const requestId = await task.requestId
+   * console.log('Request ID:', requestId)
+   * ```
+   */
+  get requestId() {
+    return this._requestId;
+  }
+  /**
+   * Gets the latest known status of the task.
+   *
+   * Status values and transitions:
+   * - `created` → `running` → `completed` or `failed`
+   *
+   * **Important:** Status is set to `completed` only after successful validation.
+   * If validation fails, status will be `failed` even if the API request succeeded.
+   *
+   * Use the `statusChange` event to track status transitions in real-time.
+   *
+   * @returns The current status of the task.
+   *
+   * @example
+   * ```typescript
+   * const task = await workstation.createTask({ query: 'test' })
+   * console.log(task.status) // 'created'
+   *
+   * await task.result
+   * console.log(task.status) // 'completed' or 'failed'
+   * ```
+   */
+  get status() {
+    return this._status;
+  }
+  /**
+   * Sets the status of the task and emits statusChange event.
+   *
+   * @param status - The new status of the task.
+   * @private
+   */
+  set status(status) {
+    const changed = this._status !== status;
+    this._status = status;
+    if (changed) {
+      this.emit("statusChange", status);
+    }
+  }
+  /**
+   * Gets the input variables provided to this task.
+   *
+   * @returns The variables object.
+   */
+  get variables() {
+    return this._variables;
+  }
+  /**
+   * Gets the task label (alias for name).
+   *
+   * @returns The task name.
+   */
+  get label() {
+    return this.name;
+  }
+  /**
+   * Gets the task name.
+   *
+   * @returns The task name.
+   */
+  get name() {
+    return this._task.name;
+  }
+  /**
+   * Gets the task tags.
+   *
+   * @returns The task tags.
+   */
+  get tags() {
+    return this._task.tags;
+  }
+  /**
+   * Gets the raw task definition from the server.
+   *
+   * @returns The raw task definition.
+   */
+  get rawTask() {
+    return this._task;
+  }
+  /**
+   * Starts polling for the task result without waiting for the promise to resolve.
+   * This allows users to track task progress via events rather than awaiting a promise.
+   *
+   * The following events will be emitted during polling:
+   * - `statusChange`: Emitted when the task status changes (e.g., 'created' → 'running' → 'completed')
+   * - `poll`: Emitted on each polling attempt with the server response
+   * - `success`: Emitted when the task completes successfully with the final result
+   * - `error`: Emitted if the task fails
+   *
+   * **Important:** Events are only emitted while polling is active. You must call `poll()` or
+   * await `task.result` to start polling. Simply setting up event listeners without starting
+   * polling will not trigger any events.
+   *
+   * @example
+   * ```typescript
+   * const task = await workstation.createTask({ query: 'test' })
+   *
+   * // Set up event listeners
+   * task.on('statusChange', (status) => {
+   *   console.log('Status:', status)
+   * })
+   *
+   * task.on('success', (result) => {
+   *   console.log('Completed:', result)
+   * })
+   *
+   * task.on('error', (error) => {
+   *   console.error('Failed:', error)
+   * })
+   *
+   * // Start polling without waiting
+   * task.poll()
+   * ```
+   */
+  poll() {
+    if (this._resultPromise) {
+      return;
+    }
+    this._resultPromise = this.startPolling();
+    this._resultPromise.catch(() => {
+    });
+  }
+  /**
+   * Gets the task result. Automatically starts polling if not already started.
+   *
+   * @returns A promise that resolves to the validated task output.
+   *
+   * @example
+   * ```typescript
+   * const task = await workstation.createTask({ query: 'test' })
+   * const result = await task.result
+   * console.log(result)
+   * ```
+   */
+  get result() {
+    if (this._resultPromise) {
+      return this._resultPromise;
+    }
+    this._resultPromise = this.startPolling();
+    return this._resultPromise;
+  }
+  /**
+   * Starts the polling process to retrieve task results.
+   * Emits events during the polling lifecycle and validates output before resolving.
+   *
+   * @returns A promise that resolves to the validated task output.
+   * @private
+   */
+  async startPolling() {
+    const result = await new Poller({
+      interval: 1e3,
+      timeout: 6e4,
+      abortSignal: this._abortController.signal
+    }).start(async () => {
+      const response = await this._client.get(`/task/${this.id}`, {
+        signal: this._abortController.signal
+      });
+      const newStatus = response.status;
+      this.status = newStatus;
+      this.emit("poll", response);
+      if (response.status === "failed") {
+        const error = new TaskFailedError(response, "Task failure reported by the server");
+        this.status = "failed";
+        this.emit("error", error);
+        if (this.listenerCount("error") === 0) {
+          throw error;
+        }
+        return {
+          done: true,
+          value: void 0
+        };
       }
-      const mismatches = validateOutputSchema(outputSchema, serverOutput.schema);
-      if (mismatches.length === 0) {
-        return;
+      if (!["completed", "validating"].includes(response.status)) {
+        return {
+          done: false,
+          value: void 0
+        };
       }
-      console.warn(
-        `[Tela SDK - Canvas Output Validation] Output schema mismatches for canvas "${canvasIdentifier}":`
-      );
-      for (const mismatch of mismatches) {
-        console.warn(`  - ${mismatch.path}: ${mismatch.issue}`);
+      return {
+        done: true,
+        value: response
+      };
+    });
+    try {
+      const value = result;
+      if (value === void 0) {
+        return void 0;
       }
+      const content = value.outputContent.content;
+      const validatedContent = this._skipResultValidation || !(this._outputSchema instanceof z__default.ZodType) ? content : this._outputSchema.parse(content);
+      this.status = value.status;
+      this.emit("success", validatedContent);
+      return validatedContent;
     } catch (error) {
-      console.warn(
-        `[Tela SDK - Canvas Output Validation] Failed to validate output schema for canvas "${canvasIdentifier}":`,
-        error
-      );
+      this.status = "failed";
+      const castError = error instanceof Error ? error : new Error(String(error));
+      const message = castError instanceof z.ZodError ? z__default.prettifyError(castError) : castError.message;
+      this.emit("error", new TaskFailedError(result, message, castError));
+      if (this.listenerCount("error") === 0) {
+        throw error;
+      }
+      return void 0;
     }
   }
 }
-class Canvas {
+
+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;
+};
+const DateRange = z__default.object({
+  since: z__default.union([z__default.date().transform((date) => date.toISOString()), z__default.iso.datetime()]),
+  until: z__default.union([z__default.date().transform((date) => date.toISOString()), z__default.iso.datetime()])
+});
+const TaskListFilters = z__default.looseObject({
+  id: z__default.uuid().array().optional(),
+  name: z__default.string().optional(),
+  status: z__default.array(TaskStatus).optional(),
+  approvedAt: DateRange.partial().optional(),
+  createdAt: DateRange.partial().optional(),
+  updatedAt: DateRange.partial().optional(),
+  approvedBy: z__default.string().optional(),
+  createdBy: z__default.string().optional(),
+  completionRunId: z__default.uuid().optional(),
+  promptVersionId: z__default.uuid().optional()
+}).transform(({ name, approvedAt, createdAt, updatedAt, ...rest }) => ({
+  taskName: name,
+  ...approvedAt ? { approvedAtSince: approvedAt.since, approvedAtUntil: approvedAt.until } : {},
+  ...createdAt ? { createdAtSince: createdAt.since, createdAtUntil: createdAt.until } : {},
+  ...updatedAt ? { updatedAtSince: updatedAt.since, updatedAtUntil: updatedAt.until } : {},
+  ...rest
+}));
+const TaskListOptions = z__default.looseObject({
+  limit: z__default.number().optional(),
+  offset: z__default.number().optional(),
+  order: z__default.object({
+    by: z__default.enum(["createdAt", "updatedAt", "approvedAt", "status", "reference", "name"]),
+    direction: z__default.enum(["asc", "desc"])
+  }).optional()
+}).transform(({ order, ...rest }) => ({
+  orderBy: order?.by,
+  orderDirection: order?.direction,
+  ...rest
+}));
+class Workstation {
   /**
-   * Creates a new instance of the Canvas class. Usage of this constructor is not recommended.
-   * Use the `tela.getCanvas` method instead.
+   * Creates a new Workstation instance.
    *
-   * @private
+   * Use {@link Workstation.get} instead.
+   * @internal
    */
-  constructor({ id, applicationId, name, versionId, input, output, client, variables, isWorkflow }) {
+  constructor({ client, applicationId, promptVersion, input, output }) {
     __publicField$1(this, "_id");
-    __publicField$1(this, "_versionId");
-    __publicField$1(this, "_applicationId");
-    __publicField$1(this, "_name");
+    __publicField$1(this, "_promptVersion");
+    __publicField$1(this, "_client");
     __publicField$1(this, "_input");
     __publicField$1(this, "_output");
-    __publicField$1(this, "_client");
-    __publicField$1(this, "_variables");
-    __publicField$1(this, "_isWorkflow");
-    this._id = id;
-    this._applicationId = applicationId;
-    this._name = name;
-    this._versionId = versionId;
+    this._id = applicationId;
+    this._promptVersion = promptVersion;
+    this._client = client;
     this._input = input && input(zod);
     this._output = output && output(zod);
-    this._client = client;
-    this._variables = variables;
-    this._isWorkflow = isWorkflow;
   }
   /**
-   * Gets a canvas by its ID.
+   * The unique identifier for this workstation (application ID).
+   */
+  get id() {
+    return this._id;
+  }
+  /**
+   * The prompt version configuration for this workstation.
+   */
+  get promptVersion() {
+    return this._promptVersion;
+  }
+  /**
+   * Retrieves a workstation by application ID and optionally validates schemas.
    *
-   * @param options - The options to use to get the canvas.
-   * @param options.id - The ID of the canvas to get.
-   * @param options.versionId - The version ID of the canvas to get.
-   * @param options.applicationId - The application ID of the canvas to get.
-   * @param options.client - The client to use to make the request.
-   * @param options.input - The input schema of the canvas to get.
-   * @param options.output - The output schema of the canvas to get.
-   * @returns The canvas.
+   * This is the recommended way to create a Workstation instance.
+   *
+   * @param options - Configuration options
+   * @param options.client - The BaseClient instance for API communication
+   * @param options.applicationId - The unique ID of the workstation
+   * @param options.input - Optional input schema function
+   * @param options.output - Optional output schema function
+   * @param options.skipSchemaValidation - Whether to skip schema validation (defaults to false)
+   * @returns A promise that resolves to a Workstation instance
+   *
+   * @throws {Error} If schema validation fails (when schemas are provided and skipSchemaValidation is false)
+   *
+   * @example
+   * ```typescript
+   * const workstation = await Workstation.get({
+   *   client,
+   *   applicationId: 'app-123',
+   *   input: schema => schema.object({
+   *     query: schema.string(),
+   *   }),
+   *   output: schema => schema.object({
+   *     answer: schema.string(),
+   *   }),
+   * })
+   * ```
    */
   static async get(options) {
-    const { id, versionId, applicationId, client, input, output, skipSchemaValidation = false } = options;
-    const promptVersion = await fetchByAny({ id, versionId, applicationId, client });
+    const { client, applicationId, input, output, skipSchemaValidation = false } = options;
+    const id = z__default.uuid({ error: (error) => `Invalid application ID: '${error.input}'. Must be a valid UUID.` }).parse(applicationId);
+    const promptVersion = await client.get(`/prompt-application/${id}/targetPromptVersion`);
     const inputSchema = input && input(zod);
     const outputSchema = output && output(zod);
     if (!skipSchemaValidation) {
-      validateSchemas(inputSchema, outputSchema, promptVersion);
+      validateSchemas("Workstation", inputSchema, outputSchema, promptVersion);
     }
-    return new Canvas({
-      id: promptVersion.promptId,
-      versionId: promptVersion.id,
-      applicationId: applicationId ?? void 0,
-      name: promptVersion.title,
-      input,
-      output,
+    return new Workstation({
       client,
-      variables: promptVersion.variables,
-      isWorkflow: promptVersion.isWorkflow
+      applicationId: id,
+      promptVersion,
+      input,
+      output
     });
   }
   /**
-   * Gets the unique identifier of this canvas.
+   * Creates a new task for this workstation and returns a promise-like object.
    *
-   * @returns The canvas ID.
-   */
-  get id() {
-    if (!this._id) {
-      throw new Error("Canvas ID is not set");
-    }
-    return this._id;
-  }
-  /**
-   * Gets the name of this canvas, if provided.
+   * The returned object can be awaited directly to get the Task instance, or you can
+   * access `.result` to get the final task output directly.
    *
-   * @returns The canvas name or undefined.
-   */
-  get name() {
-    if (!this._name) {
-      throw new Error("Canvas name is not set");
-    }
-    return this._name;
-  }
-  /**
-   * Gets the version identifier of this canvas, if specified.
-   * When undefined, the latest promoted version is used.
+   * @param variables - Input variables for the task (must match the input schema)
+   * @param params - Optional task parameters (label, tags, skipResultValidation)
+   * @returns A promise-like object that resolves to the Task instance
    *
-   * @returns The version ID or undefined.
-   */
-  get versionId() {
-    if (!this._versionId) {
-      throw new Error("Canvas version ID is not set");
-    }
-    return this._versionId;
-  }
-  get applicationId() {
-    if (!this._applicationId) {
-      throw new Error("Canvas application ID is not set");
-    }
-    return this._applicationId;
-  }
-  /**
-   * Gets the variables of this canvas.
+   * @example
+   * ```typescript
+   * // Get the task instance
+   * const task = await workstation.createTask({ query: 'test' })
    *
-   * @returns The variables of the canvas.
+   * // Or get the result directly
+   * const result = await workstation.createTask({ query: 'test' }).result
+   * ```
    */
-  get variables() {
-    return this._variables;
+  createTask(variables, params = {}) {
+    const validatedVariables = this.parseVariables(variables);
+    const taskDefinitionPromise = this.resolveVariables(validatedVariables).then((resolvedVariables) => this._client.post(`/task`, {
+      body: {
+        name: params.label ?? "Task from SDK",
+        tags: params.tags ?? void 0,
+        promptApplicationId: this._id,
+        rawInput: {
+          variables: resolvedVariables
+        }
+      },
+      transformCase: false
+    })).then((response) => {
+      return new Task(
+        this._client,
+        variables,
+        response[0],
+        response.requestId,
+        this._output,
+        params.skipResultValidation ?? false
+      );
+    });
+    return {
+      then(onfulfilled, onrejected) {
+        return Promise.resolve(taskDefinitionPromise).then((task) => onfulfilled?.(task) ?? task).catch(onrejected);
+      },
+      get result() {
+        return Promise.resolve(taskDefinitionPromise).then((task) => task.result);
+      }
+    };
   }
   /**
-   * Gets whether this canvas is a workflow.
+   * Retrieves an existing task by its ID.
    *
-   * @returns True if the canvas is a workflow.
-   */
-  get isWorkflow() {
-    return this._isWorkflow;
-  }
-  /**
-   * Gets whether this canvas is a workstation.
-   * This is true if an application ID is provided.
+   * This is useful for resuming monitoring of a task that was created earlier.
    *
-   * @returns True if the canvas is a workstation.
+   * @param id - The task ID to retrieve
+   * @param options - Optional configuration
+   * @param options.skipResultValidation - Whether to skip output validation
+   * @returns A promise that resolves to the Task instance
+   *
+   * @example
+   * ```typescript
+   * const task = await workstation.getTask('task-id')
+   *
+   * // Set up event listeners
+   * task.on('statusChange', (status) => console.log('Status:', status))
+   * task.on('success', (result) => console.log('Result:', result))
+   *
+   * // Start polling
+   * task.poll()
+   * ```
    */
-  get isWorkstation() {
-    return Boolean(this._applicationId);
+  async getTask(id, options = {}) {
+    const taskResponse = await this._client.get(`/task/${id}`);
+    return new Task(
+      this._client,
+      taskResponse.rawInput.variables,
+      taskResponse,
+      taskResponse.requestId,
+      this._output,
+      options.skipResultValidation ?? false
+    );
   }
   /**
-   * Validates and parses input variables using the canvas input schema.
+   * Validates and parses input variables using the workstation input schema.
    *
    * @param variables - Raw input variables to validate.
    * @returns Parsed and validated variables.
@@ -2476,7 +3924,7 @@ class Canvas {
    */
   parseVariables(variables) {
     try {
-      if (this._input instanceof z.z.ZodType) {
+      if (this._input instanceof z__default.ZodType) {
         return this._input.parse(variables);
       }
       return variables;
@@ -2484,65 +3932,140 @@ class Canvas {
       if (!(error instanceof z.ZodError)) {
         throw error;
       }
-      throw new Error(z.z.prettifyError(error));
+      throw new Error(z__default.prettifyError(error));
     }
   }
-  execute(variables, params) {
-    const parsedInput = this.parseVariables(variables);
-    const idObject = this._applicationId ? { applicationId: this._applicationId } : { versionId: this._versionId, canvasId: this._id };
-    const fullParams = {
-      ...params ?? { async: false },
-      ...idObject
-    };
-    const execution = new CanvasExecution(parsedInput, fullParams, this._output, this._client, this.isWorkstation);
-    return {
-      then(onfulfilled, onrejected) {
-        return Promise.resolve(execution.start()).then(() => onfulfilled?.(execution) ?? execution).catch(onrejected);
-      },
-      get result() {
-        return Promise.resolve(execution.start()).then(() => execution.result);
+  /**
+   * Processes variables and uploads any TelaFile instances to the server.
+   * Replaces TelaFile objects with their uploaded URLs while preserving other values.
+   *
+   * @returns A promise resolving to the processed variables object.
+   */
+  async resolveVariables(inputVariables) {
+    const variables = {};
+    for (const [key, value] of Object.entries(inputVariables)) {
+      if (isTelaFileArray(value)) {
+        variables[key] = { files: await uploadFiles(value, this._client) };
+        continue;
       }
-    };
+      if (isTelaFile(value)) {
+        variables[key] = await uploadFile(value, this._client);
+        continue;
+      }
+      variables[key] = value;
+    }
+    return variables;
   }
   /**
-   * Fetches an existing async execution by its ID.
+   * Lists tasks for this workstation with optional filtering and pagination.
    *
-   * This method retrieves the current state of an async execution that was previously
-   * started on this canvas. Only async executions can be fetched, as they are the only
-   * ones with persistent UUIDs on the server.
+   * Returns a page of tasks matching the specified filters, along with metadata
+   * for pagination.
    *
-   * @param id - The UUID of the async execution to fetch.
-   * @param options - Optional configuration for polling behavior.
-   * @param options.pollingInterval - Time in milliseconds between polling attempts (default: 1000).
-   * @param options.pollingTimeout - Maximum time in milliseconds to wait for completion (default: 60000).
-   * @throws {InvalidExecutionModeError} If the provided ID is not a valid UUID.
-   * @returns A promise resolving to a CanvasExecution instance with the fetched state.
+   * @param params - Query parameters
+   * @param params.filters - Optional filters to apply (ID, name, status, dates, etc.)
+   * @param params.options - Optional pagination and sorting options
+   * @param params.rawQuery - Raw query object (internal use, overrides filters/options)
+   * @returns A promise that resolves to an object containing tasks and pagination metadata
    *
    * @example
    * ```typescript
-   * // Start an async execution
-   * const execution = await canvas.execute({ query: 'test' }, { async: true })
-   * const executionId = execution.id
-   *
-   * // Later, fetch the execution by ID
-   * const fetched = await canvas.getExecution(executionId)
-   * console.log(fetched.status) // 'running', 'succeeded', or 'failed'
+   * // Get first 10 completed tasks
+   * const { tasks, meta } = await workstation.listTasks({
+   *   filters: { status: ['completed'] },
+   *   options: { limit: 10, offset: 0 },
+   * })
    *
-   * // Use poll() for event-driven progress tracking
-   * fetched.on('statusChange', (status) => console.log('Status:', status))
-   * fetched.poll()
+   * // Sort by creation date
+   * const { tasks, meta } = await workstation.listTasks({
+   *   options: {
+   *     order: { by: 'createdAt', direction: 'desc' },
+   *     limit: 20,
+   *   },
+   * })
    * ```
    */
-  async getExecution(id, options) {
-    return CanvasExecution.fetch(
-      id,
-      this._output,
+  async listTasks({ filters, options, rawQuery }) {
+    function getQuery(id) {
+      if (rawQuery) {
+        return rawQuery;
+      }
+      const validatedFilters = TaskListFilters.optional().parse(filters);
+      const validatedOptions = TaskListOptions.optional().parse(options);
+      return {
+        promptApplicationId: id,
+        objectLinks: true,
+        ...validatedFilters,
+        ...validatedOptions
+      };
+    }
+    const query = getQuery(this._id);
+    const response = await this._client.get(`/task`, {
+      query,
+      transformCase: false
+    });
+    const tasks = response.data.map((task) => new Task(
       this._client,
-      {
-        ...options,
-        isTask: this.isWorkstation
+      task.rawInput?.variables,
+      task,
+      task.requestId,
+      this._output
+    ));
+    return {
+      tasks,
+      meta: response.meta
+    };
+  }
+  /**
+   * Asynchronously iterates through all tasks matching the specified filters.
+   *
+   * This generator automatically handles pagination, fetching additional pages
+   * as needed. Each iteration yields a task and the current page metadata.
+   *
+   * @param params - Query parameters
+   * @param params.filters - Optional filters to apply (ID, name, status, dates, etc.)
+   * @param params.options - Optional initial pagination and sorting options
+   * @yields A tuple of [task, metadata] for each task
+   *
+   * @example
+   * ```typescript
+   * // Iterate through all pending tasks
+   * for await (const [task, meta] of workstation.iterateTasks({
+   *   filters: { status: ['pending'] },
+   * })) {
+   *   console.log(`Task ${task.id}: ${task.status}`)
+   *   console.log(`Page ${meta.currentPage} of ${meta.totalPages}`)
+   * }
+   *
+   * // Process tasks in batches
+   * for await (const [task, meta] of workstation.iterateTasks({
+   *   options: { limit: 50 },
+   * })) {
+   *   await processTask(task)
+   * }
+   * ```
+   */
+  async *iterateTasks({ filters, options }) {
+    let rawQuery;
+    let hasMore = true;
+    while (hasMore) {
+      const { tasks, meta } = await this.listTasks({
+        filters,
+        options,
+        rawQuery
+      });
+      for (const task of tasks) {
+        yield [task, meta];
       }
-    );
+      if (meta.links.next !== null) {
+        rawQuery = {
+          ...meta.links.next,
+          objectLinks: true
+        };
+      } else {
+        hasMore = false;
+      }
+    }
   }
 }
 
@@ -2607,6 +4130,17 @@ const _TelaSDK = class _TelaSDK extends BaseClient {
         });
       }
     });
+    __publicField(this, "workstation", {
+      get: async (options) => {
+        return Workstation.get({
+          applicationId: options.applicationId,
+          input: options.input,
+          output: options.output,
+          skipSchemaValidation: options.skipSchemaValidation,
+          client: this
+        });
+      }
+    });
     this.opts = { baseURL, ...rest };
     this.apiKey = apiKey;
     this.jwt = jwt;
@@ -2666,6 +4200,10 @@ __publicField(_TelaSDK, "FileUploadError", FileUploadError);
 __publicField(_TelaSDK, "MissingApiKeyOrJWTError", MissingApiKeyOrJWTError);
 /** Thrown when both an API key and a JWT are provided. */
 __publicField(_TelaSDK, "ConflictApiKeyAndJWTError", ConflictApiKeyAndJWTError);
+/** Thrown when a canvas execution fails on the server. */
+__publicField(_TelaSDK, "ExecutionFailedError", ExecutionFailedError);
+/** Thrown when a workstation task fails on the server. */
+__publicField(_TelaSDK, "TaskFailedError", TaskFailedError);
 let TelaSDK = _TelaSDK;
 function createTelaClient(opts) {
   return new TelaSDK(opts);
@@ -2676,6 +4214,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;
@@ -2690,6 +4229,7 @@ exports.InvalidFileURL = InvalidFileURL;
 exports.MissingApiKeyOrJWTError = MissingApiKeyOrJWTError;
 exports.NotFoundError = NotFoundError;
 exports.RateLimitError = RateLimitError;
+exports.TaskFailedError = TaskFailedError;
 exports.TelaError = TelaError;
 exports.TelaFile = TelaFile;
 exports.TelaFileSchema = TelaFileSchema;
@@ -2697,4 +4237,6 @@ exports.TelaSDK = TelaSDK;
 exports.UnprocessableEntityError = UnprocessableEntityError;
 exports.UserAbortError = UserAbortError;
 exports.createTelaClient = createTelaClient;
+exports.isTelaFile = isTelaFile;
+exports.isTelaFileArray = isTelaFileArray;
 exports.toError = toError;