@cadraos/sdk 0.1.2

package/dist/index.cjs

@@ -0,0 +1,1913 @@
+'use strict';
+
+// src/resources/base.ts
+var BaseResourceAPI = class {
+  http;
+  basePath;
+  constructor(http, basePath) {
+    this.http = http;
+    this.basePath = basePath;
+  }
+  /**
+   * Build query parameters from list options
+   */
+  buildListQuery(options) {
+    if (!options) return {};
+    return {
+      limit: options.limit,
+      offset: options.offset,
+      sort: options.sort,
+      order: options.order
+    };
+  }
+  /**
+   * HTTP GET request helper
+   */
+  async httpGet(path, query) {
+    return this.http.get(`${this.basePath}${path}`, query);
+  }
+  /**
+   * HTTP POST request helper
+   */
+  async httpPost(path, body, options) {
+    return this.http.post(`${this.basePath}${path}`, body, options);
+  }
+  /**
+   * HTTP PATCH request helper
+   */
+  async httpPatch(path, body, options) {
+    return this.http.patch(`${this.basePath}${path}`, body, options);
+  }
+  /**
+   * HTTP DELETE request helper
+   */
+  async httpDelete(path) {
+    return this.http.delete(`${this.basePath}${path}`);
+  }
+  /**
+   * List resources with pagination
+   */
+  async listResources(path, options) {
+    const query = this.buildListQuery(options);
+    return this.httpGet(path, query);
+  }
+};
+
+// src/errors/sdk-errors.ts
+var AISaaSError = class extends Error {
+  /** Error code */
+  code;
+  /** HTTP status code */
+  status;
+  /** Additional error details */
+  details;
+  /** Request ID from server (for debugging) */
+  requestId;
+  constructor(message, code, status, details, requestId) {
+    super(message);
+    this.name = "AISaaSError";
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.requestId = requestId;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var AuthenticationError = class extends AISaaSError {
+  constructor(message = "Authentication failed", code = "authentication_error", details, requestId) {
+    super(message, code, 401, details, requestId);
+    this.name = "AuthenticationError";
+  }
+};
+var AuthorizationError = class extends AISaaSError {
+  constructor(message = "Access denied", code = "authorization_error", details, requestId) {
+    super(message, code, 403, details, requestId);
+    this.name = "AuthorizationError";
+  }
+};
+var NotFoundError = class extends AISaaSError {
+  constructor(message = "Resource not found", code = "not_found", details, requestId) {
+    super(message, code, 404, details, requestId);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends AISaaSError {
+  /** Field-level validation errors */
+  errors;
+  constructor(message = "Validation failed", errors = [], details, requestId) {
+    super(message, "validation_error", 400, details, requestId);
+    this.name = "ValidationError";
+    this.errors = errors;
+  }
+};
+var RateLimitError = class extends AISaaSError {
+  /** Seconds until rate limit resets */
+  retryAfter;
+  constructor(message = "Rate limit exceeded", retryAfter, details, requestId) {
+    super(message, "rate_limit_error", 429, details, requestId);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ServerError = class extends AISaaSError {
+  constructor(message = "Server error", status = 500, details, requestId) {
+    super(message, "server_error", status, details, requestId);
+    this.name = "ServerError";
+  }
+};
+var ConflictError = class extends AISaaSError {
+  constructor(message = "Resource conflict", details, requestId) {
+    super(message, "conflict", 409, details, requestId);
+    this.name = "ConflictError";
+  }
+};
+var TimeoutError = class extends AISaaSError {
+  constructor(message = "Request timed out", details, requestId) {
+    super(message, "timeout", 408, details, requestId);
+    this.name = "TimeoutError";
+  }
+};
+var NetworkError = class extends AISaaSError {
+  constructor(message = "Network error", details) {
+    super(message, "network_error", 0, details);
+    this.name = "NetworkError";
+  }
+};
+function parseApiError(status, body, requestId) {
+  const errorBody = body;
+  const message = errorBody?.error?.message ?? "An error occurred";
+  const code = errorBody?.error?.code ?? "unknown_error";
+  const details = errorBody?.error?.details;
+  switch (status) {
+    case 400:
+    case 422: {
+      const fieldErrors = details?.errors;
+      if (fieldErrors) {
+        const errors = [];
+        for (const [field, messages] of Object.entries(fieldErrors)) {
+          for (const msg of messages) {
+            errors.push({ field, message: msg });
+          }
+        }
+        return new ValidationError(message, errors, details, requestId);
+      }
+      return new ValidationError(message, [], details, requestId);
+    }
+    case 401:
+      return new AuthenticationError(message, code, details, requestId);
+    case 403:
+      return new AuthorizationError(message, code, details, requestId);
+    case 404:
+      return new NotFoundError(message, code, details, requestId);
+    case 409:
+      return new ConflictError(message, details, requestId);
+    case 429: {
+      const retryAfter = details?.retryAfter;
+      return new RateLimitError(message, retryAfter, details, requestId);
+    }
+    default:
+      if (status >= 500) {
+        return new ServerError(message, status, details, requestId);
+      }
+      return new AISaaSError(message, code, status, details, requestId);
+  }
+}
+
+// src/utils/retry.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  baseDelayMs: 1e3,
+  maxDelayMs: 3e4,
+  jitterFactor: 0.1
+};
+function shouldRetry(error, attempt, maxRetries) {
+  if (attempt >= maxRetries) {
+    return false;
+  }
+  if (error instanceof RateLimitError) {
+    return true;
+  }
+  if (error instanceof ServerError) {
+    return true;
+  }
+  if (error instanceof Error && error.name === "NetworkError") {
+    return true;
+  }
+  if (error instanceof Error && error.name === "TimeoutError") {
+    return true;
+  }
+  return false;
+}
+function calculateRetryDelay(attempt, config, retryAfter) {
+  if (retryAfter !== void 0 && retryAfter > 0) {
+    return retryAfter * 1e3;
+  }
+  const exponentialDelay = config.baseDelayMs * Math.pow(2, attempt);
+  const cappedDelay = Math.min(exponentialDelay, config.maxDelayMs);
+  const jitter = cappedDelay * config.jitterFactor * Math.random();
+  return cappedDelay + jitter;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(operation, config = {}) {
+  const fullConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
+  let lastError;
+  for (let attempt = 0; attempt <= fullConfig.maxRetries; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      lastError = error;
+      if (!shouldRetry(error, attempt, fullConfig.maxRetries)) {
+        throw error;
+      }
+      const retryAfter = error instanceof RateLimitError ? error.retryAfter : void 0;
+      const delay = calculateRetryDelay(attempt, fullConfig, retryAfter);
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+
+// src/utils/http.ts
+var HttpClient = class {
+  config;
+  tokenRefreshAttempts = 0;
+  maxTokenRefreshAttempts = 2;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Get authorization header value
+   */
+  async getAuthHeader() {
+    if (this.config.apiKey) {
+      return `Bearer ${this.config.apiKey}`;
+    }
+    if (this.config.tokenProvider) {
+      const token = await this.config.tokenProvider();
+      return `Bearer ${token}`;
+    }
+    if (this.config.token) {
+      return `Bearer ${this.config.token}`;
+    }
+    throw new Error("No authentication configured. Provide apiKey, token, or tokenProvider.");
+  }
+  /**
+   * Build full URL with query parameters
+   */
+  buildUrl(path, query) {
+    const url = new URL(path, this.config.baseUrl);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  /**
+   * Make an HTTP request
+   */
+  async request(options) {
+    const makeRequest = async () => {
+      const url = this.buildUrl(options.path, options.query);
+      const authHeader = await this.getAuthHeader();
+      const headers = {
+        "Authorization": authHeader,
+        "X-Org-Id": String(this.config.orgId),
+        "Content-Type": "application/json",
+        ...this.config.headers,
+        ...options.headers
+      };
+      if (options.idempotencyKey) {
+        headers["Idempotency-Key"] = options.idempotencyKey;
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+      try {
+        const response = await fetch(url, {
+          method: options.method,
+          headers,
+          body: options.body !== void 0 ? JSON.stringify(options.body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        const requestId = response.headers.get("X-Request-Id") ?? void 0;
+        let body;
+        const contentType = response.headers.get("Content-Type");
+        if (contentType?.includes("application/json")) {
+          body = await response.json();
+        } else {
+          body = await response.text();
+        }
+        if (!response.ok) {
+          if (response.status === 401 && this.config.tokenProvider) {
+            this.tokenRefreshAttempts++;
+            if (this.tokenRefreshAttempts < this.maxTokenRefreshAttempts) {
+              return this.request(options);
+            }
+          }
+          throw parseApiError(response.status, body, requestId);
+        }
+        this.tokenRefreshAttempts = 0;
+        const apiResponse = body;
+        if ("success" in apiResponse && apiResponse.success) {
+          return apiResponse.data;
+        }
+        return body;
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new TimeoutError(`Request timed out after ${this.config.timeout}ms`);
+        }
+        if (error instanceof TypeError && error.message.includes("fetch")) {
+          throw new NetworkError(`Network error: ${error.message}`);
+        }
+        throw error;
+      }
+    };
+    if (options.skipRetry) {
+      return makeRequest();
+    }
+    return withRetry(makeRequest, this.config.retry);
+  }
+  /**
+   * GET request
+   */
+  async get(path, query) {
+    return this.request({
+      method: "GET",
+      path,
+      query
+    });
+  }
+  /**
+   * POST request
+   */
+  async post(path, body, options) {
+    return this.request({
+      method: "POST",
+      path,
+      body,
+      idempotencyKey: options?.idempotencyKey,
+      skipRetry: options?.skipRetry
+    });
+  }
+  /**
+   * PATCH request
+   */
+  async patch(path, body, options) {
+    return this.request({
+      method: "PATCH",
+      path,
+      body,
+      idempotencyKey: options?.idempotencyKey
+    });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(path) {
+    return this.request({
+      method: "DELETE",
+      path,
+      skipRetry: true
+      // Don't retry deletes
+    });
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+};
+function generateIdempotencyKey() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 15);
+  return `idem_${timestamp}_${random}`;
+}
+
+// src/streaming/sse-client.ts
+var SSEClient = class {
+  config;
+  abortController = null;
+  connected = false;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Connect to SSE endpoint
+   */
+  async connect() {
+    this.abortController = new AbortController();
+    try {
+      const response = await fetch(this.config.url, {
+        method: "GET",
+        headers: {
+          "Authorization": this.config.authHeader,
+          "X-Org-Id": String(this.config.orgId),
+          "Accept": "text/event-stream",
+          "Cache-Control": "no-cache"
+        },
+        signal: this.abortController.signal
+      });
+      if (!response.ok) {
+        throw new Error(`SSE connection failed: ${response.status} ${response.statusText}`);
+      }
+      if (!response.body) {
+        throw new Error("Response body not available");
+      }
+      this.connected = true;
+      this.config.onConnectionChange(true);
+      await this.parseStream(response.body);
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        return;
+      }
+      this.config.onError(error instanceof Error ? error : new Error(String(error)));
+    } finally {
+      this.connected = false;
+      this.config.onConnectionChange(false);
+    }
+  }
+  /**
+   * Disconnect from SSE endpoint
+   */
+  disconnect() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    this.connected = false;
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Parse SSE stream
+   */
+  async parseStream(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let currentEvent = {};
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line === "") {
+            if (currentEvent.type && currentEvent.data !== void 0) {
+              this.dispatchEvent(currentEvent);
+            }
+            currentEvent = {};
+            continue;
+          }
+          if (line.startsWith(":")) {
+            continue;
+          }
+          const colonIndex = line.indexOf(":");
+          if (colonIndex === -1) {
+            continue;
+          }
+          const field = line.substring(0, colonIndex);
+          let value2 = line.substring(colonIndex + 1);
+          if (value2.startsWith(" ")) {
+            value2 = value2.substring(1);
+          }
+          switch (field) {
+            case "event":
+              currentEvent.type = value2;
+              break;
+            case "id":
+              currentEvent.id = value2;
+              break;
+            case "data":
+              currentEvent.data = currentEvent.data ? currentEvent.data + "\n" + value2 : value2;
+              break;
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  /**
+   * Dispatch parsed event
+   */
+  dispatchEvent(event) {
+    try {
+      let data;
+      try {
+        data = JSON.parse(event.data);
+      } catch {
+        data = event.data;
+      }
+      const sseEvent = {
+        type: event.type,
+        id: event.id,
+        data
+      };
+      this.config.onEvent(sseEvent);
+    } catch (error) {
+      this.config.onError(
+        error instanceof Error ? error : new Error(`Failed to parse event: ${String(error)}`)
+      );
+    }
+  }
+};
+
+// src/streaming/stream-controller.ts
+var DEFAULT_STREAMING_CONFIG = {
+  maxReconnectAttempts: 5,
+  reconnectBaseDelayMs: 1e3,
+  reconnectMaxDelayMs: 1e4,
+  activityTimeoutMs: 3e4,
+  pollingIntervalMs: 2e3
+};
+var ExecutionStreamControllerImpl = class {
+  options;
+  config;
+  sseClient = null;
+  status = "connecting";
+  reconnectAttempts = 0;
+  seenEventIds = /* @__PURE__ */ new Set();
+  _lastEventId = null;
+  activityTimeoutId = null;
+  pollingIntervalId = null;
+  finalExecution = null;
+  finalError = null;
+  // Event callbacks
+  listeners = {
+    log: [],
+    toolCall: [],
+    toolResult: [],
+    plan: [],
+    complete: [],
+    error: [],
+    connectionChange: []
+  };
+  // Promise for wait()
+  waitPromise = null;
+  waitResolve = null;
+  waitReject = null;
+  constructor(options) {
+    this.options = options;
+    this.config = { ...DEFAULT_STREAMING_CONFIG, ...options.config };
+  }
+  /**
+   * Get the last event ID (for resume support)
+   */
+  get lastEventId() {
+    return this._lastEventId;
+  }
+  /**
+   * Connect to the execution stream
+   */
+  async connect() {
+    this.status = "connecting";
+    this.reconnectAttempts = 0;
+    try {
+      await this.connectSSE();
+    } catch (error) {
+      await this.handleConnectionError(error);
+    }
+  }
+  /**
+   * Register event listener
+   */
+  on(event, callback) {
+    const listeners = this.listeners[event];
+    if (listeners) {
+      listeners.push(callback);
+    }
+  }
+  /**
+   * Cancel the stream
+   */
+  cancel() {
+    this.status = "closed";
+    this.stopActivityTimeout();
+    this.stopPolling();
+    if (this.sseClient) {
+      this.sseClient.disconnect();
+      this.sseClient = null;
+    }
+  }
+  /**
+   * Wait for completion
+   */
+  wait() {
+    if (this.finalExecution) {
+      return Promise.resolve(this.finalExecution);
+    }
+    if (this.finalError) {
+      return Promise.reject(new AISaaSError(
+        this.finalError.error,
+        this.finalError.errorCode ?? "execution_error",
+        500
+      ));
+    }
+    if (!this.waitPromise) {
+      this.waitPromise = new Promise((resolve, reject) => {
+        this.waitResolve = resolve;
+        this.waitReject = reject;
+      });
+    }
+    return this.waitPromise;
+  }
+  // ===== Private methods =====
+  /**
+   * Connect to SSE endpoint
+   */
+  async connectSSE() {
+    const url = `${this.options.baseUrl}/agents/runs/${this.options.executionId}/stream`;
+    this.sseClient = new SSEClient({
+      url,
+      authHeader: `Bearer ${this.options.apiKey}`,
+      orgId: this.options.orgId,
+      onEvent: (event) => this.handleEvent(event),
+      onError: (error) => this.handleConnectionError(error),
+      onConnectionChange: (connected) => {
+        if (connected) {
+          this.status = "connected";
+          this.reconnectAttempts = 0;
+          this.resetActivityTimeout();
+        }
+        this.emit("connectionChange", { connected, usingFallback: false });
+      }
+    });
+    await this.sseClient.connect();
+  }
+  /**
+   * Handle incoming SSE event
+   */
+  handleEvent(event) {
+    this.resetActivityTimeout();
+    if (event.id) {
+      if (this.seenEventIds.has(event.id)) {
+        return;
+      }
+      this.seenEventIds.add(event.id);
+      this._lastEventId = event.id;
+      if (this.seenEventIds.size > 1e3) {
+        const ids = Array.from(this.seenEventIds);
+        this.seenEventIds = new Set(ids.slice(-500));
+      }
+    }
+    const data = event.data;
+    switch (event.type) {
+      case "log":
+        this.emit("log", data.log);
+        break;
+      case "tool_call":
+        this.emit("toolCall", {
+          toolCallId: data.toolCallId,
+          toolName: data.toolName,
+          inputs: data.args,
+          stepIndex: data.stepIndex ?? 0
+        });
+        break;
+      case "tool_result":
+        this.emit("toolResult", {
+          toolCallId: data.toolCallId,
+          toolName: data.toolName,
+          result: data.result,
+          durationMs: data.durationMs
+        });
+        break;
+      case "complete":
+        this.handleComplete(data);
+        break;
+      case "error":
+        this.handleError({
+          error: data.error,
+          errorCode: data.errorCode
+        });
+        break;
+      case "timeout":
+        if (data.retryable) {
+          this.handleConnectionError(new Error("Stream timeout"));
+        } else {
+          this.handleError({
+            error: data.error,
+            errorCode: "timeout"
+          });
+        }
+        break;
+    }
+  }
+  /**
+   * Handle completion
+   */
+  handleComplete(data) {
+    this.status = "closed";
+    this.stopActivityTimeout();
+    const execution = {
+      uuid: this.options.executionId,
+      agentUuid: "",
+      status: "completed",
+      input: { task: "" },
+      output: data.output,
+      logs: [],
+      tokenUsage: data.tokenUsage,
+      cost: data.cost,
+      queuedAt: "",
+      ...data
+    };
+    this.finalExecution = execution;
+    this.emit("complete", { execution });
+    if (this.waitResolve) {
+      this.waitResolve(execution);
+    }
+  }
+  /**
+   * Handle error
+   */
+  handleError(error) {
+    this.status = "closed";
+    this.stopActivityTimeout();
+    this.finalError = error;
+    this.emit("error", error);
+    if (this.waitReject) {
+      this.waitReject(new AISaaSError(
+        error.error,
+        error.errorCode ?? "execution_error",
+        500
+      ));
+    }
+  }
+  /**
+   * Handle connection error
+   */
+  async handleConnectionError(error) {
+    if (this.status === "closed") {
+      return;
+    }
+    if (this.reconnectAttempts < this.config.maxReconnectAttempts) {
+      this.status = "reconnecting";
+      this.reconnectAttempts++;
+      const delay = Math.min(
+        this.config.reconnectBaseDelayMs * Math.pow(2, this.reconnectAttempts),
+        this.config.reconnectMaxDelayMs
+      );
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      if (this.status === "closed") {
+        return;
+      }
+      try {
+        await this.connectSSE();
+      } catch {
+        await this.handleConnectionError(error);
+      }
+    } else {
+      this.status = "fallback_polling";
+      this.emit("connectionChange", { connected: false, usingFallback: true });
+      this.startPolling();
+    }
+  }
+  /**
+   * Start polling fallback
+   */
+  startPolling() {
+    this.pollingIntervalId = setInterval(async () => {
+      try {
+        const execution = await this.options.getExecution(this.options.executionId);
+        for (const log of execution.logs) {
+          if (!this.seenEventIds.has(log.uuid)) {
+            this.seenEventIds.add(log.uuid);
+            this.emit("log", log);
+          }
+        }
+        if (execution.status === "completed") {
+          this.stopPolling();
+          this.handleComplete(execution);
+        } else if (execution.status === "failed" || execution.status === "cancelled") {
+          this.stopPolling();
+          this.handleError({
+            error: execution.error ?? `Execution ${execution.status}`,
+            errorCode: execution.status
+          });
+        }
+      } catch (error) {
+        console.error("Polling error:", error);
+      }
+    }, this.config.pollingIntervalMs);
+  }
+  /**
+   * Stop polling
+   */
+  stopPolling() {
+    if (this.pollingIntervalId) {
+      clearInterval(this.pollingIntervalId);
+      this.pollingIntervalId = null;
+    }
+  }
+  /**
+   * Reset activity timeout
+   */
+  resetActivityTimeout() {
+    this.stopActivityTimeout();
+    this.activityTimeoutId = setTimeout(() => {
+      if (this.sseClient) {
+        this.sseClient.disconnect();
+      }
+      this.handleConnectionError(new Error("Activity timeout"));
+    }, this.config.activityTimeoutMs);
+  }
+  /**
+   * Stop activity timeout
+   */
+  stopActivityTimeout() {
+    if (this.activityTimeoutId) {
+      clearTimeout(this.activityTimeoutId);
+      this.activityTimeoutId = null;
+    }
+  }
+  /**
+   * Emit event to listeners
+   */
+  emit(event, data) {
+    const listeners = this.listeners[event];
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(data);
+        } catch (error) {
+          console.error(`Error in ${event} listener:`, error);
+        }
+      }
+    }
+  }
+};
+function createExecutionStreamController(options) {
+  return new ExecutionStreamControllerImpl(options);
+}
+
+// src/resources/agents.ts
+var AgentsAPI = class extends BaseResourceAPI {
+  constructor(http, getStreamConfig) {
+    super(http, "/agents");
+    this.getStreamConfig = getStreamConfig;
+  }
+  // ===== LIST Operations =====
+  /**
+   * List all agents in the organization
+   *
+   * @param options - List options (pagination, filtering)
+   * @returns Paginated list of agents
+   *
+   * @example
+   * ```typescript
+   * const { data: agents, pagination } = await client.agents.list({ limit: 10 });
+   * ```
+   */
+  async list(options) {
+    const query = {
+      ...this.buildListQuery(options),
+      status: options?.status,
+      type: options?.type
+    };
+    return this.httpGet("", query);
+  }
+  /**
+   * Get a single agent by UUID
+   *
+   * @param uuid - Agent UUID
+   * @returns Agent with configuration
+   *
+   * @example
+   * ```typescript
+   * const agent = await client.agents.get('agent-uuid');
+   * console.log(agent.config);
+   * ```
+   */
+  async get(uuid) {
+    return this.httpGet(`/${uuid}`);
+  }
+  // ===== EXECUTE Operations =====
+  /**
+   * Start an agent execution (async)
+   *
+   * Returns immediately with execution ID. Use getExecution() to poll
+   * for results, or use stream() for real-time updates.
+   *
+   * @param uuid - Agent UUID
+   * @param input - Execution input (task, context, options)
+   * @returns Execution ID and initial status
+   *
+   * @example
+   * ```typescript
+   * const { executionId, status } = await client.agents.execute('agent-uuid', {
+   *   task: 'Summarize the latest news about AI',
+   * });
+   * ```
+   */
+  async execute(uuid, input) {
+    const idempotencyKey = input.options?.idempotencyKey ?? generateIdempotencyKey();
+    return this.httpPost(
+      `/${uuid}/execute`,
+      {
+        task: input.task,
+        context: input.context,
+        options: input.options
+      },
+      { idempotencyKey }
+    );
+  }
+  /**
+   * Execute an agent and wait for completion (sync)
+   *
+   * Polls the execution status until completion or failure.
+   *
+   * @param uuid - Agent UUID
+   * @param input - Execution input
+   * @param pollInterval - Polling interval in ms (default: 1000)
+   * @returns Final execution result
+   *
+   * @example
+   * ```typescript
+   * const execution = await client.agents.executeSync('agent-uuid', {
+   *   task: 'Write a haiku about coding',
+   * });
+   * console.log(execution.output);
+   * ```
+   */
+  async executeSync(uuid, input, pollInterval = 1e3) {
+    const { executionId } = await this.execute(uuid, input);
+    return this.pollExecution(executionId, pollInterval);
+  }
+  /**
+   * Stream an agent execution
+   *
+   * Returns a StreamController for real-time event handling.
+   *
+   * @param uuid - Agent UUID
+   * @param input - Execution input
+   * @returns Stream controller for event handling
+   *
+   * @example
+   * ```typescript
+   * const stream = await client.agents.stream('agent-uuid', {
+   *   task: 'Research climate change',
+   * });
+   *
+   * stream.on('log', (log) => console.log(log.title));
+   * stream.on('toolCall', ({ toolName }) => console.log(`Calling ${toolName}`));
+   * stream.on('complete', ({ execution }) => console.log(execution.output));
+   *
+   * const result = await stream.wait();
+   * ```
+   */
+  async stream(uuid, input) {
+    const { executionId } = await this.execute(uuid, input);
+    const config = this.getStreamConfig();
+    const controller = createExecutionStreamController({
+      executionId,
+      baseUrl: config.baseUrl,
+      apiKey: config.apiKey,
+      orgId: config.orgId,
+      getExecution: (id) => this.getExecution(id)
+    });
+    await controller.connect();
+    return controller;
+  }
+  // ===== RECEIVE Operations =====
+  /**
+   * Get execution result by ID
+   *
+   * @param executionId - Execution UUID
+   * @returns Execution details including status, output, logs
+   *
+   * @example
+   * ```typescript
+   * const execution = await client.agents.getExecution('exec-uuid');
+   * if (execution.status === 'completed') {
+   *   console.log(execution.output);
+   * }
+   * ```
+   */
+  async getExecution(executionId) {
+    return this.http.get(`/executions/${executionId}`);
+  }
+  // ===== EDIT Operations =====
+  /**
+   * Update agent details
+   *
+   * @param uuid - Agent UUID
+   * @param data - Fields to update
+   * @returns Updated agent
+   *
+   * @example
+   * ```typescript
+   * const agent = await client.agents.update('agent-uuid', {
+   *   name: 'My Updated Agent',
+   *   description: 'New description',
+   * });
+   * ```
+   */
+  async update(uuid, data) {
+    const idempotencyKey = generateIdempotencyKey();
+    return this.httpPatch(`/${uuid}`, data, { idempotencyKey });
+  }
+  /**
+   * Update agent configuration
+   *
+   * @param uuid - Agent UUID
+   * @param config - Configuration fields to update
+   * @returns Updated agent
+   *
+   * @example
+   * ```typescript
+   * const agent = await client.agents.updateConfig('agent-uuid', {
+   *   temperature: 0.7,
+   *   maxIterations: 5,
+   * });
+   * ```
+   */
+  async updateConfig(uuid, config) {
+    const idempotencyKey = generateIdempotencyKey();
+    return this.httpPatch(`/${uuid}/config`, config, { idempotencyKey });
+  }
+  /**
+   * Cancel a running execution
+   *
+   * @param executionId - Execution UUID
+   * @returns Updated execution with cancelled status
+   *
+   * @example
+   * ```typescript
+   * const execution = await client.agents.cancelExecution('exec-uuid');
+   * console.log(execution.status); // 'cancelled'
+   * ```
+   */
+  async cancelExecution(executionId) {
+    return this.http.post(
+      `/executions/${executionId}/cancel`,
+      void 0,
+      { skipRetry: true }
+    );
+  }
+  // ===== Private helpers =====
+  /**
+   * Poll execution until completion
+   */
+  async pollExecution(executionId, pollInterval) {
+    while (true) {
+      const execution = await this.getExecution(executionId);
+      if (execution.status === "completed" || execution.status === "failed" || execution.status === "cancelled") {
+        return execution;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+  }
+};
+
+// src/resources/skills.ts
+var SkillsAPI = class extends BaseResourceAPI {
+  constructor(http) {
+    super(http, "/skills");
+  }
+  // ===== LIST Operations =====
+  /**
+   * List all skills in the organization
+   *
+   * @param options - List options (pagination, filtering by category/tags)
+   * @returns Paginated list of skills
+   *
+   * @example
+   * ```typescript
+   * const { data: skills } = await client.skills.list({
+   *   category: 'writing',
+   *   tags: ['seo', 'blog'],
+   * });
+   * ```
+   */
+  async list(options) {
+    const query = {
+      ...this.buildListQuery(options),
+      category: options?.category,
+      tags: options?.tags?.join(",")
+    };
+    return this.httpGet("", query);
+  }
+  /**
+   * Get a single skill by UUID with full details
+   *
+   * @param uuid - Skill UUID
+   * @returns Skill with prompt template and tools
+   *
+   * @example
+   * ```typescript
+   * const skill = await client.skills.get('skill-uuid');
+   * console.log(skill.promptTemplate);
+   * ```
+   */
+  async get(uuid) {
+    return this.httpGet(`/${uuid}`);
+  }
+  /**
+   * Get tools associated with a skill
+   *
+   * @param uuid - Skill UUID
+   * @returns Array of tools used by the skill
+   *
+   * @example
+   * ```typescript
+   * const tools = await client.skills.getTools('skill-uuid');
+   * tools.forEach(tool => console.log(tool.name));
+   * ```
+   */
+  async getTools(uuid) {
+    return this.httpGet(`/${uuid}/tools`);
+  }
+  // ===== EXECUTE Operations =====
+  /**
+   * Execute a skill with variables
+   *
+   * @param uuid - Skill UUID
+   * @param input - Variables and context for execution
+   * @returns Skill execution result
+   *
+   * @example
+   * ```typescript
+   * const result = await client.skills.execute('skill-uuid', {
+   *   variables: {
+   *     topic: 'AI in healthcare',
+   *     tone: 'professional',
+   *   },
+   * });
+   * console.log(result.output);
+   * ```
+   */
+  async execute(uuid, input) {
+    const idempotencyKey = generateIdempotencyKey();
+    return this.httpPost(
+      `/${uuid}/execute`,
+      {
+        variables: input.variables,
+        context: input.context
+      },
+      { idempotencyKey }
+    );
+  }
+  // ===== RECEIVE Operations =====
+  /**
+   * Get skill execution result by ID
+   *
+   * @param executionId - Execution UUID
+   * @returns Skill execution details
+   *
+   * @example
+   * ```typescript
+   * const execution = await client.skills.getExecution('exec-uuid');
+   * ```
+   */
+  async getExecution(executionId) {
+    return this.http.get(`/executions/${executionId}`);
+  }
+  // ===== EDIT Operations =====
+  /**
+   * Update skill details
+   *
+   * @param uuid - Skill UUID
+   * @param data - Fields to update
+   * @returns Updated skill
+   *
+   * @example
+   * ```typescript
+   * const skill = await client.skills.update('skill-uuid', {
+   *   name: 'Updated Skill Name',
+   *   tags: ['new-tag'],
+   * });
+   * ```
+   */
+  async update(uuid, data) {
+    const idempotencyKey = generateIdempotencyKey();
+    return this.httpPatch(`/${uuid}`, data, { idempotencyKey });
+  }
+  /**
+   * Update skill prompt template
+   *
+   * @param uuid - Skill UUID
+   * @param prompt - New prompt template
+   * @returns Updated skill with new version
+   *
+   * @example
+   * ```typescript
+   * const skill = await client.skills.updatePrompt('skill-uuid',
+   *   'Write a {{tone}} article about {{topic}}...'
+   * );
+   * console.log(skill.version); // Version incremented
+   * ```
+   */
+  async updatePrompt(uuid, prompt) {
+    const idempotencyKey = generateIdempotencyKey();
+    return this.httpPatch(`/${uuid}/prompt`, { promptTemplate: prompt }, { idempotencyKey });
+  }
+};
+
+// src/resources/tools.ts
+var ToolsAPI = class extends BaseResourceAPI {
+  constructor(http) {
+    super(http, "/tools");
+  }
+  // ===== LIST Operations =====
+  /**
+   * List all tools in the organization
+   *
+   * @param options - List options (pagination, filtering)
+   * @returns Paginated list of tools
+   *
+   * @example
+   * ```typescript
+   * const { data: tools } = await client.tools.list({
+   *   category: 'data',
+   *   isEnabled: true,
+   * });
+   * ```
+   */
+  async list(options) {
+    const query = {
+      ...this.buildListQuery(options),
+      category: options?.category,
+      isEnabled: options?.isEnabled
+    };
+    return this.httpGet("", query);
+  }
+  /**
+   * Get a single tool by UUID with schema
+   *
+   * @param uuid - Tool UUID
+   * @returns Tool with input/output schemas
+   *
+   * @example
+   * ```typescript
+   * const tool = await client.tools.get('tool-uuid');
+   * console.log(tool.inputSchema);
+   * ```
+   */
+  async get(uuid) {
+    return this.httpGet(`/${uuid}`);
+  }
+  // ===== EXECUTE Operations =====
+  /**
+   * Execute a tool directly
+   *
+   * @param uuid - Tool UUID
+   * @param input - Tool input (validated against inputSchema)
+   * @returns Tool execution result
+   *
+   * @example
+   * ```typescript
+   * const result = await client.tools.execute('tool-uuid', {
+   *   query: 'weather in London',
+   *   limit: 5,
+   * });
+   * console.log(result.output);
+   * ```
+   */
+  async execute(uuid, input) {
+    const idempotencyKey = generateIdempotencyKey();
+    return this.httpPost(`/${uuid}/execute`, { input }, { idempotencyKey });
+  }
+  /**
+   * Validate input against tool schema
+   *
+   * @param uuid - Tool UUID
+   * @param input - Input to validate
+   * @returns Validation result with errors if invalid
+   *
+   * @example
+   * ```typescript
+   * const validation = await client.tools.validateInput('tool-uuid', {
+   *   query: 'test',
+   * });
+   * if (!validation.valid) {
+   *   console.log(validation.errors);
+   * }
+   * ```
+   */
+  async validateInput(uuid, input) {
+    return this.httpPost(`/${uuid}/validate`, { input }, { skipRetry: false });
+  }
+  // ===== RECEIVE Operations =====
+  /**
+   * Get tool execution result by ID
+   *
+   * @param executionId - Execution UUID
+   * @returns Tool execution details
+   *
+   * @example
+   * ```typescript
+   * const execution = await client.tools.getExecution('exec-uuid');
+   * ```
+   */
+  async getExecution(executionId) {
+    return this.http.get(`/executions/${executionId}`);
+  }
+  // ===== EDIT Operations =====
+  /**
+   * Update tool details
+   *
+   * @param uuid - Tool UUID
+   * @param data - Fields to update
+   * @returns Updated tool
+   *
+   * @example
+   * ```typescript
+   * const tool = await client.tools.update('tool-uuid', {
+   *   name: 'Updated Tool Name',
+   *   description: 'New description',
+   * });
+   * ```
+   */
+  async update(uuid, data) {
+    const idempotencyKey = generateIdempotencyKey();
+    return this.httpPatch(`/${uuid}`, data, { idempotencyKey });
+  }
+  /**
+   * Update tool configuration
+   *
+   * @param uuid - Tool UUID
+   * @param config - Configuration to update
+   * @returns Updated tool
+   *
+   * @example
+   * ```typescript
+   * const tool = await client.tools.updateConfig('tool-uuid', {
+   *   isEnabled: false,
+   *   config: { apiKey: 'new-key' },
+   * });
+   * ```
+   */
+  async updateConfig(uuid, config) {
+    const idempotencyKey = generateIdempotencyKey();
+    return this.httpPatch(`/${uuid}/config`, config, { idempotencyKey });
+  }
+};
+
+// src/resources/artifacts.ts
+var ArtifactsAPI = class extends BaseResourceAPI {
+  constructor(http) {
+    super(http, "/artifacts");
+  }
+  // ===== LIST Operations =====
+  /**
+   * List artifacts for an execution
+   *
+   * @param executionId - Execution UUID
+   * @param options - List options (pagination, filtering by type)
+   * @returns Paginated list of artifacts
+   *
+   * @example
+   * ```typescript
+   * const { data: artifacts } = await client.artifacts.list('exec-uuid', {
+   *   type: 'file',
+   * });
+   * ```
+   */
+  async list(executionId, options) {
+    const query = {
+      ...this.buildListQuery(options),
+      type: options?.type
+    };
+    return this.http.get(`/executions/${executionId}/artifacts`, query);
+  }
+  /**
+   * Get artifact metadata by UUID
+   *
+   * @param uuid - Artifact UUID
+   * @returns Artifact metadata
+   *
+   * @example
+   * ```typescript
+   * const artifact = await client.artifacts.get('artifact-uuid');
+   * console.log(artifact.name, artifact.size);
+   * ```
+   */
+  async get(uuid) {
+    return this.httpGet(`/${uuid}`);
+  }
+  // ===== RECEIVE Operations =====
+  /**
+   * Download artifact content
+   *
+   * In Node.js returns Buffer, in browser returns Blob.
+   *
+   * @param uuid - Artifact UUID
+   * @returns Artifact content as Buffer (Node.js) or Blob (browser)
+   *
+   * @example
+   * ```typescript
+   * const content = await client.artifacts.download('artifact-uuid');
+   * // Node.js: Buffer
+   * // Browser: Blob
+   * ```
+   */
+  async download(uuid) {
+    const response = await this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${uuid}/download`,
+      headers: {
+        "Accept": "*/*"
+      }
+    });
+    if (typeof window !== "undefined") {
+      return response.blob();
+    } else {
+      const arrayBuffer = await response.arrayBuffer();
+      return Buffer.from(arrayBuffer);
+    }
+  }
+  /**
+   * Download artifact as a stream
+   *
+   * In Node.js returns Readable stream, in browser returns ReadableStream.
+   *
+   * @param uuid - Artifact UUID
+   * @returns Readable stream
+   *
+   * @example
+   * ```typescript
+   * const stream = await client.artifacts.downloadStream('artifact-uuid');
+   * // Pipe to file or process incrementally
+   * ```
+   */
+  async downloadStream(uuid) {
+    const response = await this.http.request({
+      method: "GET",
+      path: `${this.basePath}/${uuid}/stream`,
+      headers: {
+        "Accept": "*/*"
+      }
+    });
+    if (!response.body) {
+      throw new Error("Response body is not available");
+    }
+    return response.body;
+  }
+  /**
+   * Get a signed URL for direct download
+   *
+   * @param uuid - Artifact UUID
+   * @param options - Options including expiration time
+   * @returns Signed URL and expiration time
+   *
+   * @example
+   * ```typescript
+   * const { url, expiresAt } = await client.artifacts.getSignedUrl('artifact-uuid', {
+   *   expiresIn: 3600, // 1 hour
+   * });
+   * // Use URL for direct download
+   * ```
+   */
+  async getSignedUrl(uuid, options) {
+    return this.httpPost(`/${uuid}/signed-url`, {
+      expiresIn: options?.expiresIn ?? 3600
+    });
+  }
+  // ===== EDIT Operations =====
+  /**
+   * Upload a new artifact for an execution
+   *
+   * @param executionId - Execution UUID
+   * @param input - Upload input (name, content, mime type)
+   * @returns Created artifact metadata
+   *
+   * @example
+   * ```typescript
+   * const artifact = await client.artifacts.upload('exec-uuid', {
+   *   name: 'report.pdf',
+   *   content: fileBuffer,
+   *   mimeType: 'application/pdf',
+   * });
+   * ```
+   */
+  async upload(executionId, input) {
+    const formData = new FormData();
+    if (input.content instanceof Blob) {
+      formData.append("file", input.content, input.name);
+    } else if (typeof Buffer !== "undefined" && Buffer.isBuffer(input.content)) {
+      const arrayBuffer = input.content.buffer.slice(
+        input.content.byteOffset,
+        input.content.byteOffset + input.content.byteLength
+      );
+      const blob = new Blob([arrayBuffer], { type: input.mimeType ?? "application/octet-stream" });
+      formData.append("file", blob, input.name);
+    } else if (input.content instanceof ReadableStream) {
+      const chunks = [];
+      const reader = input.content.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const arrayBuffer = value.buffer.slice(
+          value.byteOffset,
+          value.byteOffset + value.byteLength
+        );
+        chunks.push(arrayBuffer);
+      }
+      const blob = new Blob(chunks, { type: input.mimeType ?? "application/octet-stream" });
+      formData.append("file", blob, input.name);
+    }
+    if (input.type) {
+      formData.append("type", input.type);
+    }
+    if (input.metadata) {
+      formData.append("metadata", JSON.stringify(input.metadata));
+    }
+    return this.http.request({
+      method: "POST",
+      path: `/executions/${executionId}/artifacts`,
+      body: formData,
+      headers: {
+        // Remove Content-Type to let fetch set it with proper boundary
+      }
+    });
+  }
+  /**
+   * Delete an artifact
+   *
+   * @param uuid - Artifact UUID
+   *
+   * @example
+   * ```typescript
+   * await client.artifacts.delete('artifact-uuid');
+   * ```
+   */
+  async delete(uuid) {
+    return this.httpDelete(`/${uuid}`);
+  }
+};
+
+// src/resources/sessions.ts
+var SessionsAPI = class extends BaseResourceAPI {
+  constructor(http, getStreamConfig) {
+    super(http, "/sessions");
+    this.getStreamConfig = getStreamConfig;
+  }
+  // ===== LIST Operations =====
+  /**
+   * List all sessions in the organization
+   *
+   * @param options - List options (pagination, filtering by agent)
+   * @returns Paginated list of sessions
+   *
+   * @example
+   * ```typescript
+   * const { data: sessions } = await client.sessions.list({
+   *   agentUuid: 'agent-uuid',
+   * });
+   * ```
+   */
+  async list(options) {
+    const query = {
+      ...this.buildListQuery(options),
+      agentUuid: options?.agentUuid
+    };
+    return this.httpGet("", query);
+  }
+  /**
+   * Get session details by ID
+   *
+   * @param sessionId - Session ID
+   * @returns Session details
+   *
+   * @example
+   * ```typescript
+   * const session = await client.sessions.get('session-id');
+   * console.log(session.messageCount);
+   * ```
+   */
+  async get(sessionId) {
+    return this.httpGet(`/${sessionId}`);
+  }
+  // ===== EXECUTE Operations =====
+  /**
+   * Send a message to a session
+   *
+   * Triggers an agent execution in the context of the session.
+   * Returns immediately with execution ID. Use getHistory() to get
+   * the response, or use stream() for real-time updates.
+   *
+   * @param sessionId - Session ID
+   * @param input - Message content and optional context
+   * @returns Execution ID and status
+   *
+   * @example
+   * ```typescript
+   * const { executionId } = await client.sessions.sendMessage('session-id', {
+   *   message: 'What is the capital of France?',
+   * });
+   * ```
+   */
+  async sendMessage(sessionId, input) {
+    const idempotencyKey = generateIdempotencyKey();
+    return this.httpPost(
+      `/${sessionId}/messages`,
+      {
+        message: input.message,
+        context: input.context
+      },
+      { idempotencyKey }
+    );
+  }
+  /**
+   * Send a message and wait for response (sync)
+   *
+   * @param sessionId - Session ID
+   * @param input - Message content and optional context
+   * @param pollInterval - Polling interval in ms (default: 1000)
+   * @returns Final execution result
+   *
+   * @example
+   * ```typescript
+   * const execution = await client.sessions.sendMessageSync('session-id', {
+   *   message: 'What is the capital of France?',
+   * });
+   * console.log(execution.output);
+   * ```
+   */
+  async sendMessageSync(sessionId, input, pollInterval = 1e3) {
+    const { executionId } = await this.sendMessage(sessionId, input);
+    return this.pollExecution(executionId, pollInterval);
+  }
+  /**
+   * Stream a message response
+   *
+   * Returns a StreamController for real-time event handling.
+   *
+   * @param sessionId - Session ID
+   * @param input - Message content and optional context
+   * @returns Stream controller
+   *
+   * @example
+   * ```typescript
+   * const stream = await client.sessions.stream('session-id', {
+   *   message: 'Tell me more about that',
+   * });
+   *
+   * stream.on('log', (log) => console.log(log.title));
+   * stream.on('complete', ({ execution }) => console.log(execution.output));
+   *
+   * const result = await stream.wait();
+   * ```
+   */
+  async stream(sessionId, input) {
+    const { executionId } = await this.sendMessage(sessionId, input);
+    const config = this.getStreamConfig();
+    const controller = createExecutionStreamController({
+      executionId,
+      baseUrl: config.baseUrl,
+      apiKey: config.apiKey,
+      orgId: config.orgId,
+      getExecution: (id) => this.getExecution(id)
+    });
+    await controller.connect();
+    return controller;
+  }
+  // ===== RECEIVE Operations =====
+  /**
+   * Get session conversation history
+   *
+   * @param sessionId - Session ID
+   * @returns Session with all messages
+   *
+   * @example
+   * ```typescript
+   * const history = await client.sessions.getHistory('session-id');
+   * history.messages.forEach(msg => {
+   *   console.log(`${msg.role}: ${msg.content}`);
+   * });
+   * ```
+   */
+  async getHistory(sessionId) {
+    return this.httpGet(`/${sessionId}/history`);
+  }
+  /**
+   * List artifacts for a session
+   *
+   * Returns all artifacts generated across all executions in the session.
+   * Useful for retrieving images, files, and other outputs created during
+   * agent interactions.
+   *
+   * @param sessionId - Session ID
+   * @param options - List options (filtering by type, pagination)
+   * @returns Paginated list of session artifacts
+   *
+   * @example
+   * ```typescript
+   * // Get all images from a session
+   * const { data: artifacts } = await client.sessions.listArtifacts('session-id', {
+   *   type: 'image',
+   * });
+   *
+   * artifacts.forEach(artifact => {
+   *   console.log(artifact.filename, artifact.url);
+   * });
+   * ```
+   */
+  async listArtifacts(sessionId, options) {
+    const query = {
+      ...this.buildListQuery(options),
+      type: options?.type,
+      includeVariants: options?.includeVariants
+    };
+    return this.httpGet(`/${sessionId}/artifacts`, query);
+  }
+  /**
+   * Get execution result
+   */
+  async getExecution(executionId) {
+    return this.http.get(`/executions/${executionId}`);
+  }
+  // ===== EDIT Operations =====
+  /**
+   * Create a new session for an agent
+   *
+   * @param agentUuid - Agent UUID to associate with session
+   * @param options - Optional system message
+   * @returns Created session
+   *
+   * @example
+   * ```typescript
+   * const session = await client.sessions.create({
+   *   agentUuid: 'agent-uuid',
+   *   systemMessage: 'You are a helpful assistant.',
+   * });
+   * console.log(session.id);
+   * ```
+   */
+  async create(input) {
+    const idempotencyKey = generateIdempotencyKey();
+    return this.httpPost("", input, { idempotencyKey });
+  }
+  /**
+   * Delete a session and all its messages
+   *
+   * @param sessionId - Session ID
+   *
+   * @example
+   * ```typescript
+   * await client.sessions.delete('session-id');
+   * ```
+   */
+  async delete(sessionId) {
+    return this.httpDelete(`/${sessionId}`);
+  }
+  // ===== Private helpers =====
+  /**
+   * Poll execution until completion
+   */
+  async pollExecution(executionId, pollInterval) {
+    while (true) {
+      const execution = await this.getExecution(executionId);
+      if (execution.status === "completed" || execution.status === "failed" || execution.status === "cancelled") {
+        return execution;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.aisaas.com/v1";
+var DEFAULT_TIMEOUT = 3e4;
+var AISaaSClient = class {
+  httpClient;
+  config;
+  /**
+   * Agent operations (list, execute, stream, update)
+   */
+  agents;
+  /**
+   * Skill operations (list, get, execute, update)
+   */
+  skills;
+  /**
+   * Tool operations (list, get, execute, validate, update)
+   */
+  tools;
+  /**
+   * Artifact operations (list, get, download, upload, delete)
+   */
+  artifacts;
+  /**
+   * Session operations (list, get, create, message, delete)
+   */
+  sessions;
+  /**
+   * Create a new AI SaaS client
+   *
+   * @param options - Client configuration options
+   *
+   * @example
+   * ```typescript
+   * // API key authentication
+   * const client = new AISaaSClient({
+   *   apiKey: 'sk_...',
+   *   orgId: 123,
+   * });
+   *
+   * // OAuth token authentication
+   * const client = new AISaaSClient({
+   *   token: 'eyJ...',
+   *   orgId: 123,
+   * });
+   *
+   * // Token provider (for automatic refresh)
+   * const client = new AISaaSClient({
+   *   tokenProvider: async () => myAuth.getAccessToken(),
+   *   orgId: 123,
+   * });
+   * ```
+   */
+  constructor(options) {
+    this.validateOptions(options);
+    this.config = {
+      baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
+      orgId: options.orgId,
+      timeout: options.timeout ?? DEFAULT_TIMEOUT,
+      headers: options.headers
+    };
+    if ("apiKey" in options) {
+      this.config.apiKey = options.apiKey;
+    } else if ("token" in options) {
+      this.config.token = options.token;
+    } else if ("tokenProvider" in options) {
+      this.config.tokenProvider = options.tokenProvider;
+    }
+    const retryConfig = {
+      ...DEFAULT_RETRY_CONFIG,
+      maxRetries: options.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries
+    };
+    const httpConfig = {
+      baseUrl: this.config.baseUrl,
+      apiKey: this.config.apiKey,
+      token: this.config.token,
+      tokenProvider: this.config.tokenProvider,
+      orgId: this.config.orgId,
+      timeout: this.config.timeout,
+      retry: retryConfig,
+      headers: this.config.headers
+    };
+    this.httpClient = new HttpClient(httpConfig);
+    const getStreamConfig = () => ({
+      baseUrl: this.config.baseUrl,
+      apiKey: this.config.apiKey,
+      token: this.config.token,
+      orgId: this.config.orgId
+    });
+    this.agents = new AgentsAPI(this.httpClient, getStreamConfig);
+    this.skills = new SkillsAPI(this.httpClient);
+    this.tools = new ToolsAPI(this.httpClient);
+    this.artifacts = new ArtifactsAPI(this.httpClient);
+    this.sessions = new SessionsAPI(this.httpClient, getStreamConfig);
+  }
+  /**
+   * Validate client options
+   */
+  validateOptions(options) {
+    const hasApiKey = "apiKey" in options && options.apiKey;
+    const hasToken = "token" in options && options.token;
+    const hasTokenProvider = "tokenProvider" in options && options.tokenProvider;
+    if (!hasApiKey && !hasToken && !hasTokenProvider) {
+      throw new Error(
+        "Authentication required. Provide apiKey, token, or tokenProvider."
+      );
+    }
+    if (options.orgId === void 0 || options.orgId === null) {
+      throw new Error("Organization ID (orgId) is required.");
+    }
+    if (typeof options.orgId !== "number") {
+      throw new Error("Organization ID (orgId) must be a number.");
+    }
+  }
+};
+
+exports.AISaaSClient = AISaaSClient;
+exports.AISaaSError = AISaaSError;
+exports.AuthenticationError = AuthenticationError;
+exports.AuthorizationError = AuthorizationError;
+exports.ConflictError = ConflictError;
+exports.NetworkError = NetworkError;
+exports.NotFoundError = NotFoundError;
+exports.RateLimitError = RateLimitError;
+exports.ServerError = ServerError;
+exports.TimeoutError = TimeoutError;
+exports.ValidationError = ValidationError;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map