@meistrari/tela-sdk-js 2.5.0 → 2.6.1

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.5.0";
+const version = "2.6.1";
 
-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);
+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$8(this, "statusCode");
+    __publicField$a(this, "statusCode");
     this.statusCode = statusCode;
   }
 }
@@ -74,14 +73,21 @@ class InvalidExecutionModeError extends TelaError {
 class ExecutionFailedError extends TelaError {
   constructor(rawOutput) {
     super(`Execution failed: ${JSON.stringify(rawOutput)}`);
-    __publicField$8(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$8(this, "rawResponse");
+    __publicField$a(this, "rawResponse");
     this.rawResponse = rawResponse;
   }
 }
@@ -89,8 +95,8 @@ 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$8(this, "statusCode");
-    __publicField$8(this, "error");
+    __publicField$a(this, "statusCode");
+    __publicField$a(this, "error");
     this.statusCode = statusCode;
     this.error = error;
   }
@@ -132,7 +138,7 @@ class APIError extends TelaError {
 class UserAbortError extends APIError {
   constructor({ message } = {}) {
     super(void 0, void 0, message || "User aborted.");
-    __publicField$8(this, "statusCode");
+    __publicField$a(this, "statusCode");
   }
 }
 class ConnectionError extends APIError {
@@ -141,7 +147,7 @@ class ConnectionError extends APIError {
     cause
   }) {
     super(void 0, void 0, message || "Connection error.");
-    __publicField$8(this, "statusCode");
+    __publicField$a(this, "statusCode");
     if (cause)
       this.cause = cause;
   }
@@ -151,57 +157,57 @@ class ConnectionTimeout extends APIError {
     message
   } = {}) {
     super(void 0, void 0, message || "Request timed out.");
-    __publicField$8(this, "statusCode");
+    __publicField$a(this, "statusCode");
   }
 }
 class BadRequestError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$8(this, "statusCode", 400);
+    __publicField$a(this, "statusCode", 400);
   }
   // todo: handle validation errors from zod/typebox
 }
 class AuthenticationError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$8(this, "statusCode", 401);
+    __publicField$a(this, "statusCode", 401);
   }
 }
 class AuthorizationError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$8(this, "statusCode", 403);
+    __publicField$a(this, "statusCode", 403);
   }
 }
 class NotFoundError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$8(this, "statusCode", 404);
+    __publicField$a(this, "statusCode", 404);
   }
 }
 class ConflictError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$8(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$8(this, "statusCode", 422);
+    __publicField$a(this, "statusCode", 422);
   }
 }
 class RateLimitError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$8(this, "statusCode", 429);
+    __publicField$a(this, "statusCode", 429);
   }
 }
 class InternalServerError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$8(this, "statusCode", 500);
+    __publicField$a(this, "statusCode", 500);
   }
 }
 function toError(err) {
@@ -340,10 +346,10 @@ function transformDurationToMs(durationStr) {
   return Number.parseInt(amount) * multiplier;
 }
 
-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$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 {
@@ -607,9 +613,9 @@ function findDoubleNewlineIndex(buffer) {
 }
 class SSEDecoder {
   constructor() {
-    __publicField$7(this, "data");
-    __publicField$7(this, "event");
-    __publicField$7(this, "chunks");
+    __publicField$9(this, "data");
+    __publicField$9(this, "event");
+    __publicField$9(this, "chunks");
     this.event = null;
     this.data = [];
     this.chunks = [];
@@ -650,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$7(this, "buffer");
-    __publicField$7(this, "trailingCR");
-    __publicField$7(this, "textDecoder");
+    __publicField$9(this, "buffer");
+    __publicField$9(this, "trailingCR");
+    __publicField$9(this, "textDecoder");
     this.buffer = [];
     this.trailingCR = false;
   }
@@ -727,8 +733,8 @@ const _LineDecoder = class _LineDecoder {
   }
 };
 // prettier-ignore
-__publicField$7(_LineDecoder, "NEWLINE_CHARS", /* @__PURE__ */ new Set(["\n", "\r"]));
-__publicField$7(_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);
@@ -765,10 +771,10 @@ function readableStreamAsyncIterable(stream) {
   };
 }
 
-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$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) {
@@ -824,31 +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 transformCase ? transformObjectFromSnakeCaseToCamelCase(finalJson, DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS) : finalJson;
+    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 transformBody(body, transformCase) {
-  if (!body) {
-    return void 0;
+function transformObjectCase(obj, transformCase) {
+  if (!obj) {
+    return obj;
   }
   if (transformCase) {
-    return transformObjectFromCamelCaseToSnakeCase(body, DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS);
+    return transformObjectFromCamelCaseToSnakeCase(obj, DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS);
   }
-  return body;
+  return obj;
 }
 class BaseClient {
   constructor({ baseURL, maxRetries = 5, timeout = 0 }) {
-    __publicField$6(this, "baseURL");
-    __publicField$6(this, "maxRetries");
-    __publicField$6(this, "timeout");
-    __publicField$6(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);
@@ -890,8 +895,8 @@ class BaseClient {
     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 = transformBody(opts?.body, transformCase);
+    const transformedQuery = transformObjectCase(opts?.query, transformCase);
+    const transformedBody = transformObjectCase(opts?.body, transformCase);
     const { response, options, controller } = await this.request({
       method,
       path,
@@ -1072,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.`
       );
@@ -1125,10 +1133,10 @@ async function getStreamSize(stream) {
   return size;
 }
 
-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$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() {
@@ -1136,11 +1144,11 @@ function TelaFileSchema() {
 }
 class TelaFile {
   constructor(file, options = {}) {
-    __publicField$5(this, "_file");
-    __publicField$5(this, "_options");
-    __publicField$5(this, "_size", null);
-    __publicField$5(this, "_mimeType");
-    __publicField$5(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;
@@ -1286,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) {
@@ -1443,87 +1461,54 @@ function validateInputSchema(clientSchema, serverVariables) {
 function validateOutputSchema(clientSchema, serverSchema) {
   return compareSchemas(clientSchema, serverSchema);
 }
-
-var __defProp$4 = Object.defineProperty;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$4 = (obj, key, value) => {
-  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-function timeout(ms, signal) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(resolve, ms);
-    if (signal) {
-      signal.addEventListener("abort", () => {
-        clearTimeout(timer);
-        reject(signal.reason);
-      }, { once: true });
-    }
-  });
-}
-class Poller {
-  constructor({ interval, timeout: timeout2, abortSignal }) {
-    __publicField$4(this, "_interval");
-    __publicField$4(this, "_timeout");
-    __publicField$4(this, "_abortSignal");
-    __publicField$4(this, "_internalAbortController");
-    if (interval <= 0) {
-      throw new TelaError("Interval must be greater than 0");
-    }
-    if (timeout2 <= 0) {
-      throw new TelaError("Timeout must be greater than 0");
+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
+      );
     }
-    this._interval = interval;
-    this._timeout = timeout2;
-    this._abortSignal = abortSignal ?? new AbortController().signal;
-    this._internalAbortController = new AbortController();
-  }
-  async startTimeout() {
-    await timeout(this._timeout, this._internalAbortController.signal);
-    throw new ConnectionTimeout({
-      message: `Reached timeout of ${this._timeout}ms when polling`
-    });
   }
-  /**
-   * Starts the polling operation, repeatedly calling the callback until completion.
-   * The callback is invoked at the configured interval and must return a PollerResult
-   * indicating whether polling should continue or if the final value is ready.
-   *
-   * @param callback - Function called on each polling iteration.
-   * @returns A promise resolving to the final result value.
-   * @throws {Error} If the polling operation times out.
-   * @throws {Error} If the operation is aborted via the AbortSignal.
-   * @throws Any error thrown by the callback function.
-   *
-   * @example
-   * ```typescript
-   * const result = await poller.start(async (signal) => {
-   *   const response = await fetch('/api/status', { signal });
-   *   const data = await response.json();
-   *
-   *   if (data.status === 'completed') {
-   *     return { done: true, value: data.result };
-   *   }
-   *   return { done: false };
-   * });
-   * ```
-   */
-  start(callback) {
-    const resultPromise = async () => {
-      try {
-        while (!this._abortSignal.aborted) {
-          const result = await callback();
-          if (result.done) {
-            return result.value;
-          }
-          await timeout(this._interval, this._abortSignal);
-        }
-        throw new UserAbortError({ message: "Polling aborted" });
-      } finally {
-        this._internalAbortController.abort();
+  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;
       }
-    };
-    return Promise.race([this.startTimeout(), resultPromise()]);
+      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
+      );
+    }
   }
 }
 
@@ -1615,6 +1600,10 @@ async function uploadFile(file, client) {
   }
   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}`);
@@ -1634,18 +1623,95 @@ async function streamFile(vaultReference, client) {
   });
 }
 
-var __defProp$3 = Object.defineProperty;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$3 = (obj, key, value) => {
-  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$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 isTelaFile(obj) {
-  return obj instanceof TelaFile;
+function timeout(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        clearTimeout(timer);
+        reject(signal.reason);
+      }, { once: true });
+    }
+  });
 }
-function isTelaFileArray(obj) {
-  return Array.isArray(obj) && obj.length > 0 && obj.every(isTelaFile);
+class Poller {
+  constructor({ interval, timeout: timeout2, abortSignal }) {
+    __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");
+    }
+    if (timeout2 <= 0) {
+      throw new TelaError("Timeout must be greater than 0");
+    }
+    this._interval = interval;
+    this._timeout = timeout2;
+    this._abortSignal = abortSignal ?? new AbortController().signal;
+    this._internalAbortController = new AbortController();
+  }
+  async startTimeout() {
+    await timeout(this._timeout, this._internalAbortController.signal);
+    throw new ConnectionTimeout({
+      message: `Reached timeout of ${this._timeout}ms when polling`
+    });
+  }
+  /**
+   * Starts the polling operation, repeatedly calling the callback until completion.
+   * The callback is invoked at the configured interval and must return a PollerResult
+   * indicating whether polling should continue or if the final value is ready.
+   *
+   * @param callback - Function called on each polling iteration.
+   * @returns A promise resolving to the final result value.
+   * @throws {Error} If the polling operation times out.
+   * @throws {Error} If the operation is aborted via the AbortSignal.
+   * @throws Any error thrown by the callback function.
+   *
+   * @example
+   * ```typescript
+   * const result = await poller.start(async (signal) => {
+   *   const response = await fetch('/api/status', { signal });
+   *   const data = await response.json();
+   *
+   *   if (data.status === 'completed') {
+   *     return { done: true, value: data.result };
+   *   }
+   *   return { done: false };
+   * });
+   * ```
+   */
+  start(callback) {
+    const resultPromise = async () => {
+      try {
+        while (!this._abortSignal.aborted) {
+          const result = await callback();
+          if (result.done) {
+            return result.value;
+          }
+          await timeout(this._interval, this._abortSignal);
+        }
+        throw new UserAbortError({ message: "Polling aborted" });
+      } finally {
+        this._internalAbortController.abort();
+      }
+    };
+    return Promise.race([this.startTimeout(), resultPromise()]);
+  }
 }
+
+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 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);
@@ -1677,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.
@@ -1688,20 +1765,20 @@ class CanvasExecution extends Emittery__default {
    */
   constructor(variables, params = { async: false }, outputSchema, client, isTask = false) {
     super();
-    __publicField$3(this, "_id");
-    __publicField$3(this, "_status");
-    __publicField$3(this, "_variables");
-    __publicField$3(this, "_params");
-    __publicField$3(this, "_client");
-    __publicField$3(this, "_outputSchema");
-    __publicField$3(this, "_skipResultValidation");
-    __publicField$3(this, "_abortController");
-    __publicField$3(this, "_isTask");
-    __publicField$3(this, "_resultPromise");
-    __publicField$3(this, "_stream");
-    __publicField$3(this, "_rawResultValue");
-    __publicField$3(this, "_requestId");
-    __publicField$3(this, "_task");
+    __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;
@@ -2207,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
@@ -2258,15 +2335,15 @@ class CanvasExecution extends Emittery__default {
           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
@@ -2275,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) => {
@@ -2284,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) {
@@ -2330,10 +2407,10 @@ class CanvasExecution extends Emittery__default {
   }
 }
 
-var __defProp$2 = Object.defineProperty;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$2 = (obj, key, value) => {
-  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+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 BatchResultItem = z__default.looseObject({
@@ -2428,8 +2505,8 @@ class BatchExecutionResult {
    * @internal
    */
   constructor(client, response) {
-    __publicField$2(this, "_client");
-    __publicField$2(this, "_response");
+    __publicField$4(this, "_client");
+    __publicField$4(this, "_response");
     this._client = client;
     this._response = response;
   }
@@ -2715,13 +2792,13 @@ class BatchExecution extends Emittery__default {
    */
   constructor(id, client, params = {}, creationResponse) {
     super();
-    __publicField$2(this, "_client");
-    __publicField$2(this, "_id");
-    __publicField$2(this, "_params");
-    __publicField$2(this, "_abortController");
-    __publicField$2(this, "_creationResponse");
-    __publicField$2(this, "_status", "created");
-    __publicField$2(this, "_resultPromise");
+    __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;
@@ -2934,10 +3011,10 @@ class Batch {
    * @internal
    */
   constructor(client, canvasIdentifier, params = {}) {
-    __publicField$2(this, "_client");
-    __publicField$2(this, "_canvasIdentifier");
-    __publicField$2(this, "_items", []);
-    __publicField$2(this, "_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;
@@ -3073,16 +3150,12 @@ class Batch {
   }
 }
 
-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$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;
 };
-const zod = {
-  ...z__namespace,
-  file: TelaFileSchema
-};
 function fetchById(id, client) {
   return client.get(`/prompt/${id}/promoted-version`);
 }
@@ -3104,56 +3177,6 @@ function fetchByAny({ id, versionId, applicationId, 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) {
-    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}`);
-      }
-    } catch (error) {
-      console.warn(
-        `[Tela SDK - Canvas Input Validation] Failed to validate input schema for canvas "${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 - 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;
-      }
-      const mismatches = validateOutputSchema(outputSchema, serverOutput.schema);
-      if (mismatches.length === 0) {
-        return;
-      }
-      console.warn(
-        `[Tela SDK - Canvas Output Validation] Output schema mismatches for canvas "${canvasIdentifier}":`
-      );
-      for (const mismatch of mismatches) {
-        console.warn(`  - ${mismatch.path}: ${mismatch.issue}`);
-      }
-    } catch (error) {
-      console.warn(
-        `[Tela SDK - Canvas Output Validation] Failed to validate output schema for canvas "${canvasIdentifier}":`,
-        error
-      );
-    }
-  }
-}
 class Canvas {
   /**
    * Creates a new instance of the Canvas class. Usage of this constructor is not recommended.
@@ -3162,15 +3185,15 @@ class Canvas {
    * @private
    */
   constructor({ id, applicationId, name, versionId, input, output, client, variables, isWorkflow }) {
-    __publicField$1(this, "_id");
-    __publicField$1(this, "_versionId");
-    __publicField$1(this, "_applicationId");
-    __publicField$1(this, "_name");
-    __publicField$1(this, "_input");
-    __publicField$1(this, "_output");
-    __publicField$1(this, "_client");
-    __publicField$1(this, "_variables");
-    __publicField$1(this, "_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;
@@ -3199,7 +3222,7 @@ class Canvas {
     const inputSchema = input && input(zod);
     const outputSchema = output && output(zod);
     if (!skipSchemaValidation) {
-      validateSchemas(inputSchema, outputSchema, promptVersion);
+      validateSchemas("Canvas", inputSchema, outputSchema, promptVersion);
     }
     return new Canvas({
       id: promptVersion.promptId,
@@ -3389,6 +3412,663 @@ class Canvas {
   }
 }
 
+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
+        };
+      }
+      if (!["completed", "validating"].includes(response.status)) {
+        return {
+          done: false,
+          value: void 0
+        };
+      }
+      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) {
+      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;
+    }
+  }
+}
+
+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 Workstation instance.
+   *
+   * Use {@link Workstation.get} instead.
+   * @internal
+   */
+  constructor({ client, applicationId, promptVersion, input, output }) {
+    __publicField$1(this, "_id");
+    __publicField$1(this, "_promptVersion");
+    __publicField$1(this, "_client");
+    __publicField$1(this, "_input");
+    __publicField$1(this, "_output");
+    this._id = applicationId;
+    this._promptVersion = promptVersion;
+    this._client = client;
+    this._input = input && input(zod);
+    this._output = output && output(zod);
+  }
+  /**
+   * 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.
+   *
+   * 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 { 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("Workstation", inputSchema, outputSchema, promptVersion);
+    }
+    return new Workstation({
+      client,
+      applicationId: id,
+      promptVersion,
+      input,
+      output
+    });
+  }
+  /**
+   * Creates a new task for this workstation and returns a promise-like object.
+   *
+   * The returned object can be awaited directly to get the Task instance, or you can
+   * access `.result` to get the final task output directly.
+   *
+   * @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
+   *
+   * @example
+   * ```typescript
+   * // Get the task instance
+   * const task = await workstation.createTask({ query: 'test' })
+   *
+   * // Or get the result directly
+   * const result = await workstation.createTask({ query: 'test' }).result
+   * ```
+   */
+  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);
+      }
+    };
+  }
+  /**
+   * Retrieves an existing task by its ID.
+   *
+   * This is useful for resuming monitoring of a task that was created earlier.
+   *
+   * @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()
+   * ```
+   */
+  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 workstation 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 {
+      if (this._input instanceof z__default.ZodType) {
+        return this._input.parse(variables);
+      }
+      return variables;
+    } catch (error) {
+      if (!(error instanceof z.ZodError)) {
+        throw error;
+      }
+      throw new Error(z__default.prettifyError(error));
+    }
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Lists tasks for this workstation with optional filtering and pagination.
+   *
+   * Returns a page of tasks matching the specified filters, along with metadata
+   * for pagination.
+   *
+   * @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
+   * // Get first 10 completed tasks
+   * const { tasks, meta } = await workstation.listTasks({
+   *   filters: { status: ['completed'] },
+   *   options: { limit: 10, offset: 0 },
+   * })
+   *
+   * // Sort by creation date
+   * const { tasks, meta } = await workstation.listTasks({
+   *   options: {
+   *     order: { by: 'createdAt', direction: 'desc' },
+   *     limit: 20,
+   *   },
+   * })
+   * ```
+   */
+  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,
+      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;
+      }
+    }
+  }
+}
+
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => {
@@ -3450,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;
@@ -3509,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);
@@ -3534,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;
@@ -3541,4 +4237,6 @@ exports.TelaSDK = TelaSDK;
 exports.UnprocessableEntityError = UnprocessableEntityError;
 exports.UserAbortError = UserAbortError;
 exports.createTelaClient = createTelaClient;
+exports.isTelaFile = isTelaFile;
+exports.isTelaFileArray = isTelaFileArray;
 exports.toError = toError;