@meistrari/tela-sdk-js 2.11.0 → 2.13.0

package/dist/index.cjs

@@ -4,6 +4,7 @@ const changeCase = require('change-case');
 const minimatch = require('minimatch');
 const z = require('zod');
 const Emittery = require('emittery');
+const agentSdk = require('@meistrari/agent-sdk');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
@@ -23,12 +24,12 @@ const changeCase__namespace = /*#__PURE__*/_interopNamespaceCompat(changeCase);
 const z__default = /*#__PURE__*/_interopDefaultCompat(z);
 const Emittery__default = /*#__PURE__*/_interopDefaultCompat(Emittery);
 
-const version = "2.11.0";
+const version = "2.13.0";
 
-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);
+var __defProp$c = Object.defineProperty;
+var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$c = (obj, key, value) => {
+  __defNormalProp$c(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 class TelaError extends Error {
@@ -58,7 +59,7 @@ class InvalidFileURL extends TelaError {
 class FileUploadError extends TelaError {
   constructor(message, statusCode) {
     super(`Failed to upload file: ${message} (Status code: ${statusCode})`);
-    __publicField$a(this, "statusCode");
+    __publicField$c(this, "statusCode");
     this.statusCode = statusCode;
   }
 }
@@ -75,30 +76,44 @@ class InvalidExecutionModeError extends TelaError {
 class ExecutionFailedError extends TelaError {
   constructor(rawOutput) {
     super(`Execution failed: ${JSON.stringify(rawOutput)}`);
-    __publicField$a(this, "rawOutput");
+    __publicField$c(this, "rawOutput");
     this.rawOutput = rawOutput;
   }
 }
 class TaskFailedError extends TelaError {
   constructor(rawTask, message, cause) {
     super(`Task failed: ${JSON.stringify(rawTask)}`, { cause });
-    __publicField$a(this, "rawTask");
+    __publicField$c(this, "rawTask");
     this.rawTask = rawTask;
   }
 }
 class BatchExecutionFailedError extends TelaError {
   constructor(rawResponse) {
     super(`Batch execution failed: ${JSON.stringify(rawResponse)}`);
-    __publicField$a(this, "rawResponse");
+    __publicField$c(this, "rawResponse");
     this.rawResponse = rawResponse;
   }
 }
+class AgentExecutionFailedError extends TelaError {
+  constructor(payload) {
+    super(`Agent execution failed${payload.sessionId ? ` (session ${payload.sessionId})` : ""}: ${payload.error ?? "unknown error"}`);
+    /** The session id, when known. */
+    __publicField$c(this, "sessionId");
+    /** The server-provided error message, when available. */
+    __publicField$c(this, "error");
+    /** The full raw payload that triggered the failure. */
+    __publicField$c(this, "raw");
+    this.sessionId = payload.sessionId;
+    this.error = payload.error;
+    this.raw = payload;
+  }
+}
 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$a(this, "statusCode");
-    __publicField$a(this, "error");
+    __publicField$c(this, "statusCode");
+    __publicField$c(this, "error");
     this.statusCode = statusCode;
     this.error = error;
   }
@@ -140,7 +155,7 @@ class APIError extends TelaError {
 class UserAbortError extends APIError {
   constructor({ message } = {}) {
     super(void 0, void 0, message || "User aborted.");
-    __publicField$a(this, "statusCode");
+    __publicField$c(this, "statusCode");
   }
 }
 class ConnectionError extends APIError {
@@ -149,7 +164,7 @@ class ConnectionError extends APIError {
     cause
   }) {
     super(void 0, void 0, message || "Connection error.");
-    __publicField$a(this, "statusCode");
+    __publicField$c(this, "statusCode");
     if (cause)
       this.cause = cause;
   }
@@ -159,57 +174,57 @@ class ConnectionTimeout extends APIError {
     message
   } = {}) {
     super(void 0, void 0, message || "Request timed out.");
-    __publicField$a(this, "statusCode");
+    __publicField$c(this, "statusCode");
   }
 }
 class BadRequestError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$a(this, "statusCode", 400);
+    __publicField$c(this, "statusCode", 400);
   }
   // todo: handle validation errors from zod/typebox
 }
 class AuthenticationError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$a(this, "statusCode", 401);
+    __publicField$c(this, "statusCode", 401);
   }
 }
 class AuthorizationError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$a(this, "statusCode", 403);
+    __publicField$c(this, "statusCode", 403);
   }
 }
 class NotFoundError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$a(this, "statusCode", 404);
+    __publicField$c(this, "statusCode", 404);
   }
 }
 class ConflictError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$a(this, "statusCode", 409);
+    __publicField$c(this, "statusCode", 409);
   }
 }
 class UnprocessableEntityError extends APIError {
   constructor() {
     super(...arguments);
     // todo: check if tela returns 400 or 422 for zod errors
-    __publicField$a(this, "statusCode", 422);
+    __publicField$c(this, "statusCode", 422);
   }
 }
 class RateLimitError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$a(this, "statusCode", 429);
+    __publicField$c(this, "statusCode", 429);
   }
 }
 class InternalServerError extends APIError {
   constructor() {
     super(...arguments);
-    __publicField$a(this, "statusCode", 500);
+    __publicField$c(this, "statusCode", 500);
   }
 }
 function toError(err) {
@@ -495,10 +510,10 @@ function transformDurationToMs(durationStr) {
   return Number.parseInt(amount) * multiplier;
 }
 
-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);
+var __defProp$b = Object.defineProperty;
+var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$b = (obj, key, value) => {
+  __defNormalProp$b(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 class Stream {
@@ -762,9 +777,9 @@ function findDoubleNewlineIndex(buffer) {
 }
 class SSEDecoder {
   constructor() {
-    __publicField$9(this, "data");
-    __publicField$9(this, "event");
-    __publicField$9(this, "chunks");
+    __publicField$b(this, "data");
+    __publicField$b(this, "event");
+    __publicField$b(this, "chunks");
     this.event = null;
     this.data = [];
     this.chunks = [];
@@ -805,9 +820,9 @@ class SSEDecoder {
 const _LineDecoder = class _LineDecoder {
   // TextDecoder found in browsers; not typed to avoid pulling in either "dom" or "node" types.
   constructor() {
-    __publicField$9(this, "buffer");
-    __publicField$9(this, "trailingCR");
-    __publicField$9(this, "textDecoder");
+    __publicField$b(this, "buffer");
+    __publicField$b(this, "trailingCR");
+    __publicField$b(this, "textDecoder");
     this.buffer = [];
     this.trailingCR = false;
   }
@@ -882,8 +897,8 @@ const _LineDecoder = class _LineDecoder {
   }
 };
 // prettier-ignore
-__publicField$9(_LineDecoder, "NEWLINE_CHARS", /* @__PURE__ */ new Set(["\n", "\r"]));
-__publicField$9(_LineDecoder, "NEWLINE_REGEXP", /\r\n|[\n\r]/g);
+__publicField$b(_LineDecoder, "NEWLINE_CHARS", /* @__PURE__ */ new Set(["\n", "\r"]));
+__publicField$b(_LineDecoder, "NEWLINE_REGEXP", /\r\n|[\n\r]/g);
 let LineDecoder = _LineDecoder;
 function partition(str, delimiter) {
   const index = str.indexOf(delimiter);
@@ -920,10 +935,10 @@ function readableStreamAsyncIterable(stream) {
   };
 }
 
-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;
 };
 function getRequestIdFromResponse(response) {
@@ -999,10 +1014,10 @@ function transformObjectCase(obj, transformCase) {
 }
 class BaseClient {
   constructor({ baseURL, maxRetries = 5, timeout = 0 }) {
-    __publicField$8(this, "baseURL");
-    __publicField$8(this, "maxRetries");
-    __publicField$8(this, "timeout");
-    __publicField$8(this, "fetch");
+    __publicField$a(this, "baseURL");
+    __publicField$a(this, "maxRetries");
+    __publicField$a(this, "timeout");
+    __publicField$a(this, "fetch");
     this.baseURL = baseURL;
     this.maxRetries = validateMaxRetries(maxRetries);
     this.timeout = validateTimeout(timeout);
@@ -1040,6 +1055,36 @@ class BaseClient {
   delete(path, opts) {
     return this.methodRequest("DELETE", path, opts);
   }
+  /**
+   * Performs a request and returns the raw {@link Response} together with its
+   * {@link AbortController}, bypassing JSON parsing and case transformation.
+   *
+   * Intended for consumers that parse the response body themselves — e.g.
+   * custom Server-Sent Events streams whose framing differs from the chat
+   * completion stream handled by {@link Stream.fromSSEResponse}. Reuses the
+   * client's retry, auth, timeout, and `baseURL` handling.
+   *
+   * @param method - The HTTP method to use.
+   * @param path - Request path (relative to `baseURL`/`opts.baseURL`, or absolute).
+   * @param opts - Request options (notably `baseURL`, `query`, and `signal`).
+   * @returns The live `Response` and the `AbortController` controlling it.
+   */
+  async requestRaw(method, path, opts) {
+    const { headers: customHeaders, ...restOpts } = opts ?? {};
+    const headers = this.createHeaders();
+    if (customHeaders) {
+      for (const [key, value] of customHeaders.entries()) {
+        headers.set(key, value);
+      }
+    }
+    const { response, controller } = await this.request({
+      method,
+      path,
+      headers,
+      ...restOpts
+    });
+    return { response, controller };
+  }
   async methodRequest(method, path, opts) {
     const { transformCase = true, headers: customHeaders, ...restOpts } = opts ?? {};
     const headers = this.createHeaders();
@@ -1287,10 +1332,10 @@ async function getStreamSize(stream) {
   return size;
 }
 
-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;
 };
 function TelaFileSchema() {
@@ -1298,11 +1343,11 @@ function TelaFileSchema() {
 }
 class TelaFile {
   constructor(file, options = {}) {
-    __publicField$7(this, "_file");
-    __publicField$7(this, "_options");
-    __publicField$7(this, "_size", null);
-    __publicField$7(this, "_mimeType");
-    __publicField$7(this, "_name");
+    __publicField$9(this, "_file");
+    __publicField$9(this, "_options");
+    __publicField$9(this, "_size", null);
+    __publicField$9(this, "_mimeType");
+    __publicField$9(this, "_name");
     this._file = file;
     if (file instanceof File || file instanceof Blob) {
       this._size = file.size;
@@ -1781,10 +1826,10 @@ async function streamFile(vaultReference, client) {
   });
 }
 
-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 timeout(ms, signal) {
@@ -1800,10 +1845,10 @@ function timeout(ms, signal) {
 }
 class Poller {
   constructor({ interval, timeout: timeout2, abortSignal }) {
-    __publicField$6(this, "_interval");
-    __publicField$6(this, "_timeout");
-    __publicField$6(this, "_abortSignal");
-    __publicField$6(this, "_internalAbortController");
+    __publicField$8(this, "_interval");
+    __publicField$8(this, "_timeout");
+    __publicField$8(this, "_abortSignal");
+    __publicField$8(this, "_internalAbortController");
     if (interval <= 0) {
       throw new TelaError("Interval must be greater than 0");
     }
@@ -1864,10 +1909,10 @@ class Poller {
   }
 }
 
-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 isUUID(str) {
@@ -1923,21 +1968,21 @@ class CanvasExecution extends Emittery__default {
    */
   constructor(variables, params = { async: false }, outputSchema, client, isTask = false) {
     super();
-    __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, "_headers");
-    __publicField$5(this, "_resultPromise");
-    __publicField$5(this, "_stream");
-    __publicField$5(this, "_rawResultValue");
-    __publicField$5(this, "_requestId");
-    __publicField$5(this, "_task");
+    __publicField$7(this, "_id");
+    __publicField$7(this, "_status");
+    __publicField$7(this, "_variables");
+    __publicField$7(this, "_params");
+    __publicField$7(this, "_client");
+    __publicField$7(this, "_outputSchema");
+    __publicField$7(this, "_skipResultValidation");
+    __publicField$7(this, "_abortController");
+    __publicField$7(this, "_isTask");
+    __publicField$7(this, "_headers");
+    __publicField$7(this, "_resultPromise");
+    __publicField$7(this, "_stream");
+    __publicField$7(this, "_rawResultValue");
+    __publicField$7(this, "_requestId");
+    __publicField$7(this, "_task");
     this._variables = variables;
     this._params = params;
     this._outputSchema = outputSchema;
@@ -2568,12 +2613,46 @@ class CanvasExecution extends Emittery__default {
   }
 }
 
-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$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 resolveBatchQueue(queue) {
+  if (!queue) {
+    return void 0;
+  }
+  const type = queue.type === void 0 ? "customer" : queue.type;
+  if (type !== "internal" && type !== "customer") {
+    throw new Error('Batch queue type must be either "internal" or "customer"');
+  }
+  if (typeof queue.application !== "string" || queue.application.trim().length === 0) {
+    throw new Error("Batch queue application is required when queue is provided");
+  }
+  return {
+    type,
+    application: queue.application.trim()
+  };
+}
+function createBatchRequestHeaders(params) {
+  const headers = new Headers();
+  let hasHeaders = false;
+  const queue = resolveBatchQueue(params.queue);
+  if (queue) {
+    headers.set("x-batch-source", queue.type);
+    headers.set("x-batch-source-application", queue.application);
+    hasHeaders = true;
+  }
+  if (params.webhook?.headers) {
+    for (const [key, value] of Object.entries(params.webhook.headers)) {
+      const headerKey = key.toLowerCase().startsWith("x-tela-forward-") ? key : `x-tela-forward-${key}`;
+      headers.set(headerKey, value);
+      hasHeaders = true;
+    }
+  }
+  return hasHeaders ? headers : void 0;
+}
 const BatchResultItem = z__default.looseObject({
   reference_id: z__default.string(),
   status: z__default.string(),
@@ -2689,8 +2768,8 @@ class BatchExecutionResult {
    * @internal
    */
   constructor(client, response) {
-    __publicField$4(this, "_client");
-    __publicField$4(this, "_response");
+    __publicField$6(this, "_client");
+    __publicField$6(this, "_response");
     this._client = client;
     this._response = response;
   }
@@ -2966,13 +3045,13 @@ class BatchExecution extends Emittery__default {
    */
   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");
+    __publicField$6(this, "_client");
+    __publicField$6(this, "_id");
+    __publicField$6(this, "_params");
+    __publicField$6(this, "_abortController");
+    __publicField$6(this, "_creationResponse");
+    __publicField$6(this, "_status", "created");
+    __publicField$6(this, "_resultPromise");
     this._id = id;
     this._client = client;
     this._params = params;
@@ -3185,10 +3264,10 @@ class Batch {
    * @internal
    */
   constructor(client, canvasIdentifier, params = {}) {
-    __publicField$4(this, "_client");
-    __publicField$4(this, "_canvasIdentifier");
-    __publicField$4(this, "_items", []);
-    __publicField$4(this, "_params");
+    __publicField$6(this, "_client");
+    __publicField$6(this, "_canvasIdentifier");
+    __publicField$6(this, "_items", []);
+    __publicField$6(this, "_params");
     this._client = client;
     this._canvasIdentifier = canvasIdentifier;
     this._params = params;
@@ -3304,6 +3383,7 @@ class Batch {
     const client = this._client;
     const params = this._params;
     async function execute() {
+      const headers = createBatchRequestHeaders(params);
       const { fileUrl } = await uploadFile(file, client);
       const webhookUrl = params.webhook?.url ?? params.webhookUrl;
       const body = {
@@ -3311,40 +3391,31 @@ class Batch {
         inputFile: fileUrl,
         webhookUrl
       };
-      const forwardHeaders = {};
-      if (params.webhook?.headers) {
-        for (const [key, value] of Object.entries(params.webhook.headers)) {
-          const headerKey = key.toLowerCase().startsWith("x-tela-forward-") ? key : `x-tela-forward-${key}`;
-          forwardHeaders[headerKey] = value;
-        }
-      }
-      let headers;
-      if (Object.keys(forwardHeaders).length > 0) {
-        headers = new Headers();
-        for (const [key, value] of Object.entries(forwardHeaders)) {
-          headers.set(key, value);
-        }
-      }
       return client.post("/_services/batch/batches", {
         body,
         ...headers && { headers }
       }).then((response) => new BatchExecution(response.id, client, params, response));
     }
+    let executionPromise;
+    function getExecution() {
+      executionPromise ?? (executionPromise = execute());
+      return executionPromise;
+    }
     return {
       then(onfulfilled, onrejected) {
-        return Promise.resolve(execute()).then((execution) => onfulfilled?.(execution) ?? execution).catch(onrejected);
+        return getExecution().then((execution) => onfulfilled?.(execution) ?? execution).catch(onrejected);
       },
       get result() {
-        return Promise.resolve(execute()).then((execution) => execution.result);
+        return getExecution().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);
+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 fetchById(id, client) {
@@ -3376,15 +3447,15 @@ class Canvas {
    * @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");
+    __publicField$5(this, "_id");
+    __publicField$5(this, "_versionId");
+    __publicField$5(this, "_applicationId");
+    __publicField$5(this, "_name");
+    __publicField$5(this, "_input");
+    __publicField$5(this, "_output");
+    __publicField$5(this, "_client");
+    __publicField$5(this, "_variables");
+    __publicField$5(this, "_isWorkflow");
     this._id = id;
     this._applicationId = applicationId;
     this._name = name;
@@ -3641,24 +3712,24 @@ z.z.object({
   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);
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => {
+  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 class 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");
+    __publicField$4(this, "_variables");
+    __publicField$4(this, "_task");
+    __publicField$4(this, "_abortController", new AbortController());
+    __publicField$4(this, "_client");
+    __publicField$4(this, "_outputSchema");
+    __publicField$4(this, "_skipResultValidation");
+    __publicField$4(this, "_resultPromise");
+    __publicField$4(this, "_status");
+    __publicField$4(this, "_requestId");
     this._variables = variables;
     this._task = task;
     this._client = client;
@@ -3906,10 +3977,10 @@ class Task 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$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 DateRange = z__default.object({
@@ -3955,11 +4026,11 @@ class Workstation {
    * @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");
+    __publicField$3(this, "_id");
+    __publicField$3(this, "_promptVersion");
+    __publicField$3(this, "_client");
+    __publicField$3(this, "_input");
+    __publicField$3(this, "_output");
     this._id = applicationId;
     this._promptVersion = promptVersion;
     this._client = client;
@@ -4650,6 +4721,490 @@ class Vault {
   }
 }
 
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => {
+  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const AGENT_NO_TRANSFORM$1 = { transformCase: false };
+const DEFAULT_MESSAGE = "Execute";
+const RECONNECT_DELAY_MS = 2e3;
+const MAX_STREAM_RECONNECT_ERRORS = 5;
+class AgentExecution extends Emittery__default {
+  constructor(context) {
+    super();
+    __publicField$2(this, "_sessionId");
+    __publicField$2(this, "_status");
+    __publicField$2(this, "_cursor");
+    __publicField$2(this, "_resultPromise");
+    __publicField$2(this, "_stream");
+    __publicField$2(this, "_abortController");
+    __publicField$2(this, "_client");
+    __publicField$2(this, "_agentId");
+    __publicField$2(this, "_mode");
+    __publicField$2(this, "_reconnectDelayMs");
+    this._client = context.client;
+    this._agentId = context.agentId;
+    this._mode = context.mode ?? "run";
+    this._sessionId = context.sessionId;
+    this._reconnectDelayMs = context.reconnectDelayMs ?? RECONNECT_DELAY_MS;
+    this._abortController = new AbortController();
+  }
+  /**
+   * Builds a resumable execution bound to an existing session id.
+   *
+   * Used by `tela.agents.getSession()`. The returned execution can `.stream`,
+   * `.result`, `.cancel`, or `.recover` — but not `.continue` (a new turn
+   * needs the agent id).
+   */
+  static fromSession(sessionId, client) {
+    return new AgentExecution({ client, sessionId });
+  }
+  /**
+   * The session id assigned by the server.
+   *
+   * @throws {ExecutionNotStartedError} If the execution has not started yet.
+   */
+  get sessionId() {
+    if (!this._sessionId)
+      throw new ExecutionNotStartedError();
+    return this._sessionId;
+  }
+  /**
+   * The latest known session status.
+   *
+   * @throws {ExecutionNotStartedError} If no status has been observed yet.
+   */
+  get status() {
+    if (!this._status)
+      throw new ExecutionNotStartedError();
+    return this._status;
+  }
+  set status(status) {
+    const changed = this._status !== status;
+    this._status = status;
+    if (changed)
+      this.emit("status", status).catch(() => {
+      });
+  }
+  /**
+   * Starts (or continues) the session by POSTing to `/agent/:id/run`
+   * (or `/agent/:id/test` in draft mode). Resets any in-flight stream/result
+   * so the next read re-opens.
+   *
+   * @throws {AgentExecutionFailedError} If the server rejects the execution.
+   */
+  async start(params) {
+    if (!this._agentId)
+      throw new InvalidExecutionModeError("agents: this execution is bound to an existing session \u2014 use recover() to resume it (a new turn requires the agent id).");
+    this._abortController = new AbortController();
+    const message = resolveMessage(params);
+    const inputSchema = await this.resolveInputs(params.inputs);
+    const attachments = await this.resolveAttachments(params.attachments);
+    const body = {
+      message,
+      sessionId: this._sessionId,
+      inputSchema,
+      attachments,
+      environmentVariables: params.environmentVariables
+    };
+    if (this._mode === "test") {
+      body.ref = params.ref;
+      body.isMultiturn = params.isMultiturn;
+    }
+    const envelope = await this._client.post(`/agent/${this._agentId}/${this._mode}`, {
+      ...AGENT_NO_TRANSFORM$1,
+      body,
+      signal: this._abortController.signal,
+      headers: params.headers ? new Headers(params.headers) : void 0
+    });
+    const response = envelope.data;
+    if (!response?.success || !response.sessionId)
+      throw new AgentExecutionFailedError({ sessionId: response?.sessionId, error: response?.error });
+    this._sessionId = response.sessionId;
+    this._stream = void 0;
+    this._resultPromise = void 0;
+    this.status = "pending";
+    return this;
+  }
+  /**
+   * Continues this session with another turn (same `sessionId`).
+   *
+   * @returns A promise-like handle for the new turn (`.result` / `.stream`).
+   */
+  continue(params) {
+    return toExecutionPromise(this, params);
+  }
+  /**
+   * Recovers a failed/terminal session (`POST /agent/sessions/:id/recover`),
+   * then re-opens the stream from the current cursor.
+   *
+   * @throws {ExecutionNotStartedError} If there is no session to recover.
+   * @throws {AgentExecutionFailedError} If recovery is rejected.
+   */
+  async recover() {
+    if (!this._sessionId)
+      throw new ExecutionNotStartedError();
+    this._abortController = new AbortController();
+    const envelope = await this._client.post(`/agent/sessions/${this._sessionId}/recover`, {
+      ...AGENT_NO_TRANSFORM$1,
+      signal: this._abortController.signal
+    });
+    const response = envelope.data;
+    if (!response?.success || !response.sessionId)
+      throw new AgentExecutionFailedError({ sessionId: response?.sessionId ?? this._sessionId, error: response?.error });
+    this._sessionId = response.sessionId;
+    this._stream = void 0;
+    this._resultPromise = void 0;
+    this.status = "pending";
+    return this;
+  }
+  /**
+   * A live, typed stream of session events. Memoized: repeated access returns
+   * the same generator. Updates `status` and the resume cursor as it goes.
+   *
+   * @throws {ExecutionNotStartedError} If the session has no id yet.
+   */
+  get stream() {
+    if (!this._stream)
+      this._stream = this.openStream();
+    return this._stream;
+  }
+  async *openStream() {
+    if (!this._sessionId)
+      throw new ExecutionNotStartedError();
+    let consecutiveErrors = 0;
+    try {
+      while (!this._abortController.signal.aborted) {
+        try {
+          const { response } = await this._client.requestRaw("GET", `/agent/sessions/${this._sessionId}`, {
+            ...AGENT_NO_TRANSFORM$1,
+            query: this._cursor !== void 0 ? { cursor: this._cursor } : void 0,
+            signal: this._abortController.signal,
+            headers: new Headers({ Accept: "text/event-stream" })
+          });
+          if (!response.body)
+            throw new Error("agent session stream response has no body");
+          for await (const event of agentSdk.parseSessionStream(response.body)) {
+            consecutiveErrors = 0;
+            if ("status" in event)
+              this.status = event.status;
+            if ("nextCursor" in event && event.nextCursor != null)
+              this._cursor = event.nextCursor;
+            if (event.kind === "steps")
+              this.emit("step", event.steps).catch(() => {
+              });
+            if (event.kind === "result")
+              this.emit("result", event.result).catch(() => {
+              });
+            yield event;
+            switch (event.kind) {
+              case "error":
+                throw this.fail(event.sessionId, event.error);
+              case "result":
+                return;
+              case "status":
+              case "steps":
+              case "timeline-finalize":
+                if (event.status === "failed")
+                  throw this.fail(event.sessionId, "error" in event ? event.error : void 0);
+                if (event.status === "cancelled")
+                  return;
+                break;
+            }
+          }
+        } catch (error) {
+          if (error instanceof AgentExecutionFailedError)
+            throw error;
+          if (this._abortController.signal.aborted)
+            return;
+          if (++consecutiveErrors > MAX_STREAM_RECONNECT_ERRORS)
+            throw error;
+        }
+        if (this._abortController.signal.aborted)
+          return;
+        await delay(this._reconnectDelayMs, this._abortController.signal);
+      }
+    } finally {
+      this._abortController.abort();
+    }
+  }
+  fail(sessionId, error) {
+    const failure = new AgentExecutionFailedError({ sessionId, error });
+    this.status = "failed";
+    this.emit("error", failure).catch(() => {
+    });
+    return failure;
+  }
+  /**
+   * Resolves with the session's result payload, lazily consuming the stream.
+   *
+   * Memoized: repeated access returns the same promise. Resolves on the first
+   * `result` event — for `completed` *or* `waiting_messages`. Inspect
+   * `.status` to tell them apart, and `.continue()` from a paused turn.
+   *
+   * @throws {AgentExecutionFailedError} If the session fails or the stream
+   * ends without producing a result.
+   */
+  get result() {
+    if (this._resultPromise)
+      return this._resultPromise;
+    this._resultPromise = (async () => {
+      let lastResult;
+      for await (const event of this.stream) {
+        if (event.kind === "result")
+          lastResult = event.result;
+      }
+      if (lastResult !== void 0)
+        return lastResult;
+      throw new AgentExecutionFailedError({
+        sessionId: this._sessionId,
+        error: "session stream ended without a result"
+      });
+    })();
+    this._resultPromise.catch(() => {
+    });
+    return this._resultPromise;
+  }
+  /**
+   * Cancels the session: aborts the open stream immediately, then requests a
+   * server-side cancel (`POST /agent/sessions/:id/cancel`).
+   */
+  async cancel() {
+    this._abortController.abort();
+    if (this._sessionId) {
+      await this._client.post(`/agent/sessions/${this._sessionId}/cancel`, { ...AGENT_NO_TRANSFORM$1 }).catch(() => {
+      });
+    }
+  }
+  /**
+   * Resolves the agent's input values into {@link AgentInputItem}s, uploading
+   * any `TelaFile`s to the vault and passing strings through as text.
+   */
+  async resolveInputs(inputs) {
+    if (!inputs)
+      return void 0;
+    const entries = Object.entries(inputs);
+    if (entries.length === 0)
+      return void 0;
+    return Promise.all(
+      entries.map(async ([name, value]) => {
+        if (isTelaFile(value)) {
+          const { fileUrl } = await uploadFile(value, this._client);
+          return { type: "file", name, vaultRef: fileUrl, filename: value.name ?? name };
+        }
+        return { type: "text", name, content: value };
+      })
+    );
+  }
+  /**
+   * Resolves attachments to {@link AgentAttachment}s, uploading any `TelaFile`s.
+   */
+  async resolveAttachments(attachments) {
+    if (!attachments || attachments.length === 0)
+      return void 0;
+    return Promise.all(
+      attachments.map(async (attachment) => {
+        if (isTelaFile(attachment)) {
+          const { fileUrl } = await uploadFile(attachment, this._client);
+          return { vaultRef: fileUrl, filename: attachment.name ?? "file" };
+        }
+        return attachment;
+      })
+    );
+  }
+}
+function resolveMessage(params) {
+  if (params.prompt !== void 0 && params.message !== void 0)
+    throw new InvalidExecutionModeError("agents.execute: provide either `prompt` or `message`, not both");
+  return params.prompt ?? params.message ?? DEFAULT_MESSAGE;
+}
+function delay(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve();
+      return;
+    }
+    const timeout = setTimeout(resolve, ms);
+    signal.addEventListener("abort", () => {
+      clearTimeout(timeout);
+      resolve();
+    }, { once: true });
+  });
+}
+function toExecutionPromise(execution, params) {
+  let started;
+  let stream;
+  const ensureStarted = () => started ?? (started = execution.start(params));
+  async function* deferredStream() {
+    await ensureStarted();
+    yield* execution.stream;
+  }
+  return {
+    then(onfulfilled, onrejected) {
+      return ensureStarted().then(() => onfulfilled?.(execution) ?? execution).catch(onrejected);
+    },
+    get result() {
+      return ensureStarted().then(() => execution.result);
+    },
+    get stream() {
+      return stream ?? (stream = deferredStream());
+    }
+  };
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Agent {
+  constructor(client, record) {
+    __publicField$1(this, "_client");
+    __publicField$1(this, "_record");
+    this._client = client;
+    this._record = record;
+  }
+  /** The agent id. */
+  get id() {
+    return this._record.id;
+  }
+  /** The agent's display title. */
+  get title() {
+    return this._record.title;
+  }
+  /** The organization that owns the agent's repository. */
+  get organizationName() {
+    return this._record.organizationName;
+  }
+  /** The agent's repository name. */
+  get repository() {
+    return this._record.repository;
+  }
+  /** The agent's declared input variables. */
+  get inputSchema() {
+    return this._record.inputSchema;
+  }
+  /** The published commit id, or `null` if the agent has never been published. */
+  get publishedId() {
+    return this._record.publishedId;
+  }
+  /** Whether the agent supports multi-turn sessions. */
+  get isMultiturn() {
+    return this._record.isMultiturn ?? false;
+  }
+  /** The full agent record as returned by the API. */
+  get record() {
+    return this._record;
+  }
+  /**
+   * Executes the agent. By default this runs the **published** version
+   * (`POST /agent/:id/run`); pass `{ draft: true }` to run the current draft
+   * (`POST /agent/:id/test`).
+   *
+   * Returns a promise-like handle: `await` it for the {@link AgentExecution},
+   * read `.result` for the final payload, or iterate `.stream` for live events.
+   *
+   * @param params - Execution parameters (notably `prompt`, `inputs`, `draft`).
+   */
+  execute(params = {}) {
+    const execution = new AgentExecution({
+      client: this._client,
+      agentId: this._record.id,
+      mode: params.draft ? "test" : "run"
+    });
+    return toExecutionPromise(execution, params);
+  }
+}
+
+const AGENT_NO_TRANSFORM = { transformCase: false };
+class Agents {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Lists the agents available in the workspace (optionally filtered by project).
+   */
+  async list(query = {}) {
+    const response = await this.client.get("/agent", {
+      ...AGENT_NO_TRANSFORM,
+      query
+    });
+    return response.data;
+  }
+  /**
+   * Fetches an agent by id and returns a handle for running it.
+   */
+  async get(agentId) {
+    const response = await this.client.get(`/agent/${agentId}`, {
+      ...AGENT_NO_TRANSFORM
+    });
+    return new Agent(this.client, response.data);
+  }
+  /**
+   * Executes an agent by id without first fetching its record.
+   *
+   * Convenience shortcut equivalent to `(await get(id)).execute(params)` but
+   * skipping the metadata fetch. Defaults to the published version; pass
+   * `{ draft: true }` to run the draft.
+   */
+  execute(agentId, params = {}) {
+    const execution = new AgentExecution({
+      client: this.client,
+      agentId,
+      mode: params.draft ? "test" : "run"
+    });
+    return toExecutionPromise(execution, params);
+  }
+  /**
+   * Returns a resumable execution bound to an existing session id. Use it to
+   * monitor (`.stream` / `.result`), `.cancel()`, or `.recover()` a session
+   * that was started elsewhere.
+   */
+  async getSession(sessionId) {
+    return AgentExecution.fromSession(sessionId, this.client);
+  }
+  /**
+   * Fetches the session timeline summary (`GET /agent/sessions/:id/timeline`):
+   * duration, token/cost metrics, prompt, and spans.
+   */
+  async getTimeline(sessionId) {
+    const response = await this.client.get(`/agent/sessions/${sessionId}/timeline`, {
+      ...AGENT_NO_TRANSFORM
+    });
+    return response.data;
+  }
+  /**
+   * Cancels a running session (`POST /agent/sessions/:id/cancel`).
+   */
+  async cancel(sessionId) {
+    const response = await this.client.post(`/agent/sessions/${sessionId}/cancel`, {
+      ...AGENT_NO_TRANSFORM
+    });
+    return response?.data ?? {};
+  }
+  /**
+   * Recovers a failed/terminal session and returns a resumable execution for
+   * the new turn.
+   */
+  async recover(sessionId) {
+    const execution = AgentExecution.fromSession(sessionId, this.client);
+    await execution.recover();
+    return execution;
+  }
+  /**
+   * Ends a session (`DELETE /agent/sessions/:id`), marking it finished.
+   */
+  async endSession(sessionId) {
+    const response = await this.client.delete(`/agent/sessions/${sessionId}`, {
+      ...AGENT_NO_TRANSFORM
+    });
+    return response?.data ?? {};
+  }
+}
+
 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) => {
@@ -4736,6 +5291,17 @@ const _TelaSDK = class _TelaSDK extends BaseClient {
      * ```
      */
     __publicField(this, "vault", new Vault(this));
+    /**
+     * Agents API resource for running agent sessions by `agentId` — execute,
+     * stream events, multi-turn, cancel — and reading session state.
+     *
+     * @example
+     * ```typescript
+     * const agent = await tela.agents.get('agent-id')
+     * const result = await agent.execute({ prompt: 'Hello' }).result
+     * ```
+     */
+    __publicField(this, "agents");
     __publicField(this, "workstation", {
       get: async (options) => {
         return Workstation.get({
@@ -4751,6 +5317,7 @@ const _TelaSDK = class _TelaSDK extends BaseClient {
     this.apiKey = apiKey;
     this.jwt = jwt;
     this.dataToken = dataToken;
+    this.agents = new Agents(this);
     this.validateAuth();
   }
   get authToken() {
@@ -4827,12 +5394,18 @@ __publicField(_TelaSDK, "ConflictApiKeyAndJWTError", ConflictApiKeyAndJWTError);
 __publicField(_TelaSDK, "ExecutionFailedError", ExecutionFailedError);
 /** Thrown when a workstation task fails on the server. */
 __publicField(_TelaSDK, "TaskFailedError", TaskFailedError);
+/** Thrown when an agent session fails on the server. */
+__publicField(_TelaSDK, "AgentExecutionFailedError", AgentExecutionFailedError);
 let TelaSDK = _TelaSDK;
 function createTelaClient(opts) {
   return new TelaSDK(opts);
 }
 
 exports.APIError = APIError;
+exports.Agent = Agent;
+exports.AgentExecution = AgentExecution;
+exports.AgentExecutionFailedError = AgentExecutionFailedError;
+exports.Agents = Agents;
 exports.AuthenticationError = AuthenticationError;
 exports.AuthorizationError = AuthorizationError;
 exports.BadRequestError = BadRequestError;