@cadraos/sdk 0.1.3 → 0.1.5

package/dist/chat/index.cjs

@@ -10,77 +10,2293 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var ReactMarkdown__default = /*#__PURE__*/_interopDefault(ReactMarkdown);
 var remarkGfm__default = /*#__PURE__*/_interopDefault(remarkGfm);
 
-// src/chat/adapters/default-adapter.ts
-function createDefaultAdapter(config) {
-  const fetchFn = config.fetch ?? fetch;
-  const headers = () => {
-    const h = {
-      "Content-Type": "application/json"
+// 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();
+    console.log("[SDK:SSE] Connecting to:", this.config.url);
+    console.log("[SDK:SSE] Auth header:", this.config.authHeader ? `${this.config.authHeader.substring(0, 30)}...` : "MISSING");
+    console.log("[SDK:SSE] Org ID:", this.config.orgId);
+    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
+      });
+      console.log("[SDK:SSE] Response status:", response.status, response.statusText);
+      console.log("[SDK:SSE] Response headers:", {
+        contentType: response.headers.get("content-type"),
+        cacheControl: response.headers.get("cache-control")
+      });
+      if (!response.ok) {
+        let errorBody = "";
+        try {
+          errorBody = await response.text();
+          console.error("[SDK:SSE] Error response body:", errorBody);
+        } catch (e) {
+          console.error("[SDK:SSE] Could not read error body");
+        }
+        throw new Error(`SSE connection failed: ${response.status} ${response.statusText} - ${errorBody}`);
+      }
+      if (!response.body) {
+        throw new Error("Response body not available");
+      }
+      console.log("[SDK:SSE] Connection successful, starting stream parsing");
+      this.connected = true;
+      this.config.onConnectionChange(true);
+      await this.parseStream(response.body);
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        console.log("[SDK:SSE] Connection aborted (intentional)");
+        return;
+      }
+      console.error("[SDK:SSE] Connection error:", error);
+      this.config.onError(error instanceof Error ? error : new Error(String(error)));
+    } finally {
+      this.connected = false;
+      this.config.onConnectionChange(false);
+      console.log("[SDK:SSE] Connection closed");
+    }
+  }
+  /**
+   * 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 = {};
+    let chunkCount = 0;
+    let eventCount = 0;
+    console.log("[SDK:SSE] Starting to parse stream");
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          console.log("[SDK:SSE] Stream reading complete. Total chunks:", chunkCount, "events:", eventCount);
+          break;
+        }
+        chunkCount++;
+        const chunk = decoder.decode(value, { stream: true });
+        buffer += chunk;
+        if (chunkCount <= 5) {
+          console.log(`[SDK:SSE] Chunk ${chunkCount} (${value.length} bytes):`, chunk.substring(0, 200));
+        }
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (line === "") {
+            if (currentEvent.type && currentEvent.data !== void 0) {
+              eventCount++;
+              console.log(`[SDK:SSE] Event ${eventCount}:`, currentEvent.type, "- data length:", currentEvent.data.length);
+              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 {
+      console.log("[SDK:SSE] parseStream finished. Releasing reader lock.");
+      reader.releaseLock();
+    }
+  }
+  /**
+   * Dispatch parsed event
+   */
+  dispatchEvent(event) {
+    console.log("[SDK:SSE] dispatchEvent called:", event.type, "id:", event.id);
+    try {
+      let data;
+      try {
+        data = JSON.parse(event.data);
+        console.log("[SDK:SSE] Parsed event data:", typeof data, data && typeof data === "object" ? Object.keys(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: [],
+    paused: [],
+    started: [],
+    progress: [],
+    taskListUpdate: [],
+    delegationStarted: [],
+    delegationCompleted: [],
+    textDelta: [],
+    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;
+  }
+  /**
+   * Get the execution ID
+   */
+  get executionId() {
+    return this.options.executionId;
+  }
+  /**
+   * Get the session ID (if available)
+   */
+  get sessionId() {
+    return this.options.sessionId;
+  }
+  /**
+   * 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`;
+    let authToken = this.options.apiKey;
+    if (!authToken && this.options.tokenProvider) {
+      authToken = await this.options.tokenProvider();
+    }
+    console.log("[SDK:StreamController] Connecting to SSE");
+    console.log("[SDK:StreamController] URL:", url);
+    console.log("[SDK:StreamController] baseUrl:", this.options.baseUrl);
+    console.log("[SDK:StreamController] executionId:", this.options.executionId);
+    console.log("[SDK:StreamController] orgId:", this.options.orgId);
+    console.log("[SDK:StreamController] apiKey:", authToken ? `${authToken.substring(0, 20)}...` : "MISSING");
+    this.sseClient = new SSEClient({
+      url,
+      authHeader: `Bearer ${authToken}`,
+      orgId: this.options.orgId,
+      onEvent: (event) => this.handleEvent(event),
+      onError: (error) => {
+        console.error("[SDK:StreamController] SSE error:", error);
+        this.handleConnectionError(error);
+      },
+      onConnectionChange: (connected) => {
+        console.log("[SDK:StreamController] SSE connection change:", connected);
+        if (connected) {
+          this.status = "connected";
+          this.reconnectAttempts = 0;
+          this.resetActivityTimeout();
+        }
+        this.emit("connectionChange", { connected, usingFallback: false });
+      }
+    });
+    try {
+      await this.sseClient.connect();
+      console.log("[SDK:StreamController] SSE connect() completed");
+    } catch (error) {
+      console.error("[SDK:StreamController] SSE connect() threw:", error);
+      throw error;
+    }
+  }
+  /**
+   * Handle incoming SSE event
+   */
+  handleEvent(event) {
+    console.log("[SDK:StreamController] handleEvent called:", event.type, "id:", event.id);
+    this.resetActivityTimeout();
+    if (event.id) {
+      if (this.seenEventIds.has(event.id)) {
+        console.log("[SDK:StreamController] Skipping duplicate event:", 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;
+    console.log("[SDK:StreamController] Event data keys:", Object.keys(data));
+    switch (event.type) {
+      case "log": {
+        const rawLog = data.log;
+        if (!rawLog) {
+          console.warn("[StreamController] Received log event without log data");
+          break;
+        }
+        const logTypeValue = rawLog.logType || rawLog.type || "info";
+        const transformedLog = {
+          uuid: rawLog.uuid || `log-${rawLog.stepIndex || Date.now()}`,
+          type: logTypeValue,
+          title: rawLog.message || rawLog.title || "",
+          content: rawLog.content,
+          metadata: {
+            ...rawLog.metadata || {},
+            // Include stepIndex in metadata for deduplication
+            stepIndex: rawLog.stepIndex ?? 0
+          },
+          timestamp: rawLog.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+          durationMs: rawLog.durationMs
+        };
+        this.emit("log", transformedLog);
+        break;
+      }
+      case "tool_call":
+        this.emit("toolCall", {
+          toolCallId: data.toolCallId || `tool-call-${Date.now()}`,
+          toolName: data.toolName || "Unknown Tool",
+          inputs: data.args || {},
+          stepIndex: data.stepIndex ?? 0
+        });
+        break;
+      case "tool_result":
+        this.emit("toolResult", {
+          toolCallId: data.toolCallId || `tool-result-${Date.now()}`,
+          toolName: data.toolName || "Unknown Tool",
+          result: data.result,
+          durationMs: data.durationMs ?? 0
+        });
+        break;
+      case "execution_paused":
+        this.emit("paused", {
+          question: data.question || data.output || "",
+          options: data.options,
+          reason: "waiting_user_input"
+        });
+        break;
+      case "complete":
+        this.handleComplete(data);
+        break;
+      case "error":
+        this.handleError({
+          error: data.error,
+          errorCode: data.errorCode
+        });
+        break;
+      case "failed":
+        this.handleError({
+          error: data.error || data.message || "Execution failed",
+          errorCode: data.errorCode || "execution_failed"
+        });
+        break;
+      case "timeout":
+        if (data.retryable) {
+          this.handleConnectionError(new Error("Stream timeout"));
+        } else {
+          this.handleError({
+            error: data.error,
+            errorCode: "timeout"
+          });
+        }
+        break;
+      // Handle started event - immediate feedback that execution began
+      case "started":
+        this.emit("started", {
+          executionId: data.executionId,
+          agentUuid: data.agentUuid,
+          status: "initializing",
+          currentStep: data.currentStep
+        });
+        break;
+      // Handle progress event - status updates during execution
+      case "progress":
+        this.emit("progress", {
+          status: data.status,
+          iteration: data.iteration ?? 0,
+          currentStep: data.currentStep,
+          tokenUsage: data.tokenUsage,
+          cost: data.cost,
+          toolCalls: data.toolCalls
+        });
+        break;
+      // Handle task list update event from TaskTracker
+      case "task_list_update":
+        this.emit("taskListUpdate", {
+          executionId: data.executionId,
+          tasks: data.tasks,
+          timestamp: data.timestamp
+        });
+        break;
+      // Handle delegation started event (handoff_to_agent initiated)
+      case "delegation_started":
+        this.emit("delegationStarted", {
+          type: "delegation_started",
+          handoffId: data.handoffId,
+          targetAgentUuid: data.targetAgentUuid,
+          targetAgentName: data.targetAgentName,
+          taskPreview: data.taskPreview,
+          timestamp: data.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+        });
+        break;
+      // Handle delegation completed event (handoff_to_agent finished)
+      case "delegation_completed":
+        this.emit("delegationCompleted", {
+          type: "delegation_completed",
+          handoffId: data.handoffId,
+          status: data.status,
+          resultPreview: data.resultPreview,
+          error: data.error,
+          durationMs: data.durationMs,
+          timestamp: data.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+        });
+        break;
+      // Handle status_update event - immediate feedback (e.g., "thinking")
+      // Map to progress event for consistency
+      case "status_update":
+        this.emit("progress", {
+          status: data.status || "thinking",
+          iteration: 0,
+          currentStep: data.message
+        });
+        break;
+      // Handle text_delta event - token-by-token streaming
+      case "text_delta":
+        this.emit("textDelta", {
+          delta: data.delta,
+          executionId: data.executionId,
+          timestamp: data.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+        });
+        break;
+    }
+  }
+  /**
+   * Handle completion
+   */
+  handleComplete(data) {
+    this.status = "closed";
+    this.stopActivityTimeout();
+    const sessionId = data.sessionId ?? this.options.sessionId;
+    const execution = {
+      uuid: this.options.executionId,
+      agentUuid: "",
+      sessionId,
+      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];
+    console.log(`[SDK:StreamController] Emitting '${event}' to ${listeners?.length || 0} listeners`);
+    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 ?? {},
+        attachmentIds: input.attachmentIds,
+        options: input.options,
+        ...input.teamUuid ? { teamUuid: input.teamUuid } : {}
+      },
+      { 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) {
+    console.log("[SDK:Agents] stream() called for agent:", uuid);
+    const { executionId, sessionId } = await this.execute(uuid, input);
+    console.log("[SDK:Agents] Execution started:", { executionId, sessionId });
+    const config = this.getStreamConfig();
+    console.log("[SDK:Agents] Stream config:", {
+      baseUrl: config.baseUrl,
+      apiKey: config.apiKey ? `${config.apiKey.substring(0, 20)}...` : "MISSING",
+      orgId: config.orgId
+    });
+    const controller = createExecutionStreamController({
+      executionId,
+      sessionId,
+      baseUrl: config.baseUrl,
+      apiKey: config.apiKey,
+      tokenProvider: config.tokenProvider,
+      orgId: config.orgId,
+      getExecution: (id) => this.getExecution(id)
+    });
+    console.log("[SDK:Agents] Stream controller created - caller must call connect() after registering listeners");
+    return controller;
+  }
+  /**
+   * Connect to an existing execution's stream
+   *
+   * Use this when the execution was started externally (e.g., via tRPC for team executions)
+   * and you need to connect to its SSE stream for real-time updates.
+   *
+   * @param executionId - Execution UUID (already running)
+   * @param sessionId - Optional session ID for conversation continuity
+   * @returns Stream controller for the execution
+   *
+   * @example
+   * ```typescript
+   * // Execution started via tRPC
+   * const executionId = await trpc.executions.start.mutate({ teamUuid, task });
+   *
+   * // Connect to SSE stream for real-time updates
+   * const stream = client.agents.streamExecution(executionId);
+   *
+   * stream.on('log', (log) => console.log(log.title));
+   * stream.on('delegationStarted', (data) => console.log('Subagent:', data.targetAgentName));
+   * stream.on('complete', ({ execution }) => console.log(execution.output));
+   *
+   * await stream.connect();
+   * const result = await stream.wait();
+   * ```
+   */
+  streamExecution(executionId, sessionId) {
+    console.log("[SDK:Agents] streamExecution() called for execution:", executionId);
+    const config = this.getStreamConfig();
+    console.log("[SDK:Agents] Stream config:", {
+      baseUrl: config.baseUrl,
+      apiKey: config.apiKey ? `${config.apiKey.substring(0, 20)}...` : "MISSING",
+      orgId: config.orgId
+    });
+    const controller = createExecutionStreamController({
+      executionId,
+      sessionId,
+      baseUrl: config.baseUrl,
+      apiKey: config.apiKey,
+      tokenProvider: config.tokenProvider,
+      orgId: config.orgId,
+      getExecution: (id) => this.getExecution(id)
+    });
+    console.log("[SDK:Agents] Stream controller created for existing execution - caller must call connect() after registering listeners");
+    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
     };
-    if (config.apiKey) {
-      h["Authorization"] = `Bearer ${config.apiKey}`;
+    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;
+        chunks.push(new Uint8Array(value));
+      }
+      const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+      const combined = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        combined.set(chunk, offset);
+        offset += chunk.length;
+      }
+      const blob = new Blob([combined.buffer], { 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,
+        // Pass attachment IDs for multi-modal messages (images, documents, etc.)
+        attachmentIds: input.attachmentIds
+      },
+      { 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,
+      sessionId,
+      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));
     }
-    if (config.orgId) {
-      h["X-Org-Id"] = String(config.orgId);
+  }
+};
+
+// 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;
     }
-    return h;
-  };
-  async function request(method, path, body) {
-    const url = `${config.baseUrl}${path}`;
-    const response = await fetchFn(url, {
-      method,
-      headers: headers(),
-      body: body ? JSON.stringify(body) : void 0
+    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,
+      tokenProvider: this.config.tokenProvider,
+      orgId: this.config.orgId
     });
-    if (!response.ok) {
-      const errorText = await response.text();
-      let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
-      try {
-        const errorData = JSON.parse(errorText);
-        if (errorData.message) {
-          errorMessage = errorData.message;
-        }
-      } catch {
-        if (errorText) {
-          errorMessage = errorText;
-        }
-      }
-      throw new Error(errorMessage);
+    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.");
     }
-    const text = await response.text();
-    if (!text) {
-      return void 0;
+  }
+};
+
+// src/chat/adapters/default-adapter.ts
+function resolveClient(config) {
+  if (config.client) return config.client;
+  if (!config.baseUrl) {
+    throw new Error("DefaultAdapterConfig requires either 'client' or 'baseUrl'");
+  }
+  if (config.orgId === void 0 || config.orgId === null) {
+    throw new Error("DefaultAdapterConfig requires 'orgId' when 'client' is not provided");
+  }
+  if (config.apiKey) {
+    return new AISaaSClient({
+      apiKey: config.apiKey,
+      orgId: config.orgId,
+      baseUrl: config.baseUrl
+    });
+  }
+  if (config.token) {
+    return new AISaaSClient({
+      token: config.token,
+      orgId: config.orgId,
+      baseUrl: config.baseUrl
+    });
+  }
+  if (config.tokenProvider) {
+    return new AISaaSClient({
+      tokenProvider: config.tokenProvider,
+      orgId: config.orgId,
+      baseUrl: config.baseUrl
+    });
+  }
+  throw new Error(
+    "DefaultAdapterConfig requires 'apiKey', 'token', or 'tokenProvider' when 'client' is not provided"
+  );
+}
+function resolveBaseUrl(config) {
+  if (config.baseUrl) return config.baseUrl;
+  return "https://api.aisaas.com/v1";
+}
+async function getAuthHeaders(config) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (config.apiKey) {
+    headers["Authorization"] = `Bearer ${config.apiKey}`;
+  } else if (config.token) {
+    headers["Authorization"] = `Bearer ${config.token}`;
+  } else if (config.tokenProvider) {
+    const token = await config.tokenProvider();
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (config.orgId !== void 0) {
+    headers["X-Org-Id"] = String(config.orgId);
+  }
+  return headers;
+}
+async function rawRequest(config, method, path, body) {
+  const baseUrl = resolveBaseUrl(config);
+  const url = `${baseUrl}${path}`;
+  const headers = await getAuthHeaders(config);
+  const response = await fetch(url, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : void 0
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+    try {
+      const errorData = JSON.parse(errorText);
+      if (errorData.message) errorMessage = errorData.message;
+      if (errorData.error?.message) errorMessage = errorData.error.message;
+    } catch {
+      if (errorText) errorMessage = errorText;
     }
-    return JSON.parse(text);
+    throw new Error(errorMessage);
   }
+  const text = await response.text();
+  if (!text) return void 0;
+  const parsed = JSON.parse(text);
+  if (parsed && typeof parsed === "object" && "success" in parsed && parsed.success && "data" in parsed) {
+    return parsed.data;
+  }
+  return parsed;
+}
+function createDefaultAdapter(config) {
+  const client = resolveClient(config);
+  const baseUrl = resolveBaseUrl(config);
   return {
     // -------------------------------------------------------------------------
     // Execution Methods
     // -------------------------------------------------------------------------
     async startExecution(input) {
-      return request("POST", `/agents/${input.agentId}/execute`, {
-        sessionId: input.sessionId,
-        input: input.content,
-        attachmentUuids: input.attachmentUuids
+      const tenantContext = config.orgId ? { tenantOrgId: config.orgId } : {};
+      if (input.sessionId) {
+        const result2 = await client.sessions.sendMessage(input.sessionId, {
+          message: input.content,
+          attachmentIds: input.attachmentUuids,
+          context: tenantContext
+        });
+        return {
+          executionId: result2.executionId,
+          sessionId: result2.sessionId ?? input.sessionId
+        };
+      }
+      const pathId = input.agentId || input.teamId || "";
+      const result = await client.agents.execute(pathId, {
+        task: input.content,
+        context: tenantContext,
+        attachmentIds: input.attachmentUuids,
+        teamUuid: input.teamId
       });
+      return {
+        executionId: result.executionId,
+        sessionId: result.sessionId ?? ""
+      };
     },
     async sendMessage(input) {
-      return request("POST", `/sessions/${input.sessionId}/messages`, {
-        content: input.content,
-        attachmentUuids: input.attachmentUuids
+      const result = await client.sessions.sendMessage(input.sessionId, {
+        message: input.content,
+        attachmentIds: input.attachmentUuids,
+        // Always include tenantOrgId so follow-up messages use the correct
+        // tenant org for tool calls (not cadra's internal org).
+        context: config.orgId ? { tenantOrgId: config.orgId } : void 0
       });
+      return {
+        executionId: result.executionId,
+        sessionId: result.sessionId ?? input.sessionId
+      };
     },
     async cancelExecution(uuid) {
-      await request("POST", `/executions/${uuid}/cancel`);
+      await client.agents.cancelExecution(uuid);
     },
     async getExecution(uuid) {
-      return request("GET", `/executions/${uuid}`);
+      const exec = await client.agents.getExecution(uuid);
+      return {
+        uuid: exec.uuid,
+        status: exec.status === "queued" ? "pending" : exec.status,
+        result: exec.output,
+        error: exec.error
+      };
     },
     // -------------------------------------------------------------------------
-    // Attachment Methods
+    // Attachment Methods (raw fetch — AISaaSClient has no AttachmentsAPI yet)
     // -------------------------------------------------------------------------
     async getUploadUrl(input) {
-      return request("POST", `/attachments/upload-url`, {
+      return rawRequest(config, "POST", "/attachments/upload-url", {
         sessionId: input.sessionId,
         filename: input.filename,
         mimeType: input.mimeType,
@@ -88,37 +2304,77 @@ function createDefaultAdapter(config) {
       });
     },
     async confirmUpload(uuid) {
-      await request("POST", `/attachments/${uuid}/confirm`);
+      await rawRequest(config, "POST", `/attachments/${uuid}/confirm`);
     },
     async getDownloadUrl(uuid) {
-      const result = await request("GET", `/attachments/${uuid}/download-url`);
+      const result = await rawRequest(config, "GET", `/attachments/${uuid}/download-url`);
       return result.url;
     },
     // -------------------------------------------------------------------------
     // Artifact Methods
     // -------------------------------------------------------------------------
     async getSessionArtifacts(sessionId) {
-      const result = await request("GET", `/sessions/${sessionId}/artifacts`);
-      return result.data ?? [];
+      const result = await client.sessions.listArtifacts(sessionId);
+      return (result.data ?? []).map((a) => ({
+        uuid: a.uuid,
+        type: a.type,
+        filename: a.filename,
+        mimeType: a.mimeType,
+        url: a.url,
+        createdAt: a.createdAt
+      }));
     },
     // -------------------------------------------------------------------------
     // Session History Methods
     // -------------------------------------------------------------------------
     async getSessionHistory(sessionId) {
-      return request("GET", `/sessions/${sessionId}`);
+      const history = await client.sessions.getHistory(sessionId);
+      return {
+        sessionId: history.session.id,
+        agentId: history.session.agentUuid,
+        messages: history.messages.map((m) => ({
+          uuid: m.id,
+          role: m.role,
+          content: m.content,
+          timestamp: m.timestamp
+        })),
+        createdAt: history.session.createdAt,
+        updatedAt: history.session.lastMessageAt
+      };
+    },
+    // -------------------------------------------------------------------------
+    // Session List Methods
+    // -------------------------------------------------------------------------
+    async listSessions(input) {
+      const result = await client.sessions.list({
+        agentUuid: input.agentId,
+        limit: input.limit,
+        offset: input.offset
+      });
+      return {
+        sessions: result.data.map((s) => ({
+          id: s.id,
+          agentId: s.agentUuid,
+          createdAt: s.createdAt,
+          lastMessageAt: s.lastMessageAt,
+          messageCount: s.messageCount,
+          lastUserMessage: s.lastUserMessage
+        })),
+        total: result.pagination.total,
+        hasMore: result.pagination.hasMore
+      };
+    },
+    // -------------------------------------------------------------------------
+    // Stream Methods
+    // -------------------------------------------------------------------------
+    createStream(executionId, sessionId) {
+      return client.agents.streamExecution(executionId, sessionId);
     },
     // -------------------------------------------------------------------------
-    // SSE Stream URL
+    // SSE Stream URL (legacy backward compat)
     // -------------------------------------------------------------------------
     getStreamUrl(executionId) {
-      const url = new URL(`${config.baseUrl}/executions/${executionId}/stream`);
-      if (config.apiKey) {
-        url.searchParams.set("apiKey", config.apiKey);
-      }
-      if (config.orgId) {
-        url.searchParams.set("orgId", String(config.orgId));
-      }
-      return url.toString();
+      return `${baseUrl}/agents/runs/${executionId}/stream`;
     }
   };
 }
@@ -127,7 +2383,7 @@ function ChatConfigProvider({ config, children }) {
   const adapter = react.useMemo(
     () => createDefaultAdapter(config),
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [config.baseUrl, config.apiKey, config.orgId]
+    [config.baseUrl, config.apiKey, config.token, config.tokenProvider, config.orgId, config.client]
   );
   const value = react.useMemo(() => ({ adapter }), [adapter]);
   return /* @__PURE__ */ jsxRuntime.jsx(ChatConfigContext.Provider, { value, children });
@@ -426,6 +2682,9 @@ function useExecutionStream(options) {
 }
 
 // src/chat/hooks/useAgentChat.ts
+var SILENT_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "check_delegations"
+]);
 function generateId() {
   return `msg-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
 }
@@ -458,6 +2717,7 @@ function historyToMessage(historyMsg) {
 function useAgentChat(options) {
   const {
     agentId,
+    teamId,
     sessionId: initialSessionId,
     adapter: propsAdapter,
     initialMessages = [],
@@ -467,6 +2727,7 @@ function useAgentChat(options) {
     onSessionStart,
     // Deprecated, but still supported
     onToolCall,
+    onToolResult,
     onClarification
   } = options;
   const contextConfig = useChatConfigOptional();
@@ -476,6 +2737,15 @@ function useAgentChat(options) {
       "No adapter provided. Use ChatConfigProvider or pass adapter prop to AgentChat."
     );
   }
+  const useStreamController = !!adapter.createStream;
+  const onToolCallRef = react.useRef(onToolCall);
+  const onToolResultRef = react.useRef(onToolResult);
+  react.useEffect(() => {
+    onToolCallRef.current = onToolCall;
+  }, [onToolCall]);
+  react.useEffect(() => {
+    onToolResultRef.current = onToolResult;
+  }, [onToolResult]);
   const [messages, setMessages] = react.useState(initialMessages);
   const [isLoading, setIsLoading] = react.useState(false);
   const [isLoadingHistory, setIsLoadingHistory] = react.useState(false);
@@ -483,11 +2753,15 @@ function useAgentChat(options) {
   const [currentSessionId, setCurrentSessionId] = react.useState(initialSessionId ?? null);
   const [currentExecutionId, setCurrentExecutionId] = react.useState(null);
   const [clarification, setClarification] = react.useState(null);
+  const [isStreamControllerConnected, setIsStreamControllerConnected] = react.useState(false);
   const hasLoadedInitialSession = react.useRef(false);
+  const internallyCreatedSessionRef = react.useRef(null);
   const streamingContentRef = react.useRef("");
   const streamingMessageIdRef = react.useRef(null);
   const pendingToolCallsRef = react.useRef(/* @__PURE__ */ new Map());
   const lastMessageContentRef = react.useRef("");
+  const firedToolResultsRef = react.useRef(/* @__PURE__ */ new Set());
+  const streamControllerRef = react.useRef(null);
   const updateStreamingMessage = react.useCallback((content) => {
     if (!streamingMessageIdRef.current) return;
     setMessages(
@@ -497,10 +2771,11 @@ function useAgentChat(options) {
     );
   }, []);
   const updateToolCall = react.useCallback((toolCall) => {
-    if (!streamingMessageIdRef.current) return;
-    setMessages(
-      (prev) => prev.map((msg) => {
-        if (msg.id !== streamingMessageIdRef.current) return msg;
+    setMessages((prev) => {
+      const targetId = streamingMessageIdRef.current ?? [...prev].reverse().find((m) => m.role === "assistant")?.id;
+      if (!targetId) return prev;
+      return prev.map((msg) => {
+        if (msg.id !== targetId) return msg;
         const existingIndex = msg.toolCalls?.findIndex((tc) => tc.id === toolCall.id) ?? -1;
         if (existingIndex >= 0) {
           const newToolCalls = [...msg.toolCalls ?? []];
@@ -512,8 +2787,8 @@ function useAgentChat(options) {
             toolCalls: [...msg.toolCalls ?? [], toolCall]
           };
         }
-      })
-    );
+      });
+    });
   }, []);
   const finalizeStreamingMessage = react.useCallback(() => {
     if (!streamingMessageIdRef.current) return;
@@ -525,14 +2800,103 @@ function useAgentChat(options) {
     streamingMessageIdRef.current = null;
     streamingContentRef.current = "";
     pendingToolCallsRef.current.clear();
+    firedToolResultsRef.current.clear();
   }, []);
+  const handleExecutionLog = react.useCallback(
+    (log) => {
+      console.log("[useAgentChat] handleExecutionLog:", log.type, log.metadata);
+      switch (log.type) {
+        // Primary handlers for ai-saas-api worker log types
+        case "llm_response": {
+          const llmText = log.metadata?.text || "";
+          if (llmText) {
+            streamingContentRef.current = llmText;
+            updateStreamingMessage(llmText);
+          }
+          break;
+        }
+        case "message": {
+          const role = log.metadata?.role;
+          const content = log.metadata?.content;
+          if (role === "assistant" && content) {
+            streamingContentRef.current = content;
+            updateStreamingMessage(content);
+          }
+          break;
+        }
+        case "info":
+        case "system":
+          console.log("[useAgentChat] Status:", log.type, log.title);
+          break;
+        case "tool_call": {
+          const toolName = log.metadata?.toolName;
+          if (SILENT_TOOL_NAMES.has(toolName)) break;
+          const toolCallId = log.metadata?.toolCallId || `tool-${Date.now()}`;
+          const args = log.metadata?.inputs;
+          const newToolCall = {
+            id: toolCallId,
+            name: toolName,
+            args,
+            status: "running"
+          };
+          pendingToolCallsRef.current.set(toolCallId, newToolCall);
+          updateToolCall(newToolCall);
+          onToolCallRef.current?.(toolName, args);
+          break;
+        }
+        case "tool_result": {
+          const resultToolName = log.metadata?.toolName;
+          if (SILENT_TOOL_NAMES.has(resultToolName)) break;
+          const resultToolCallId = log.metadata?.toolCallId;
+          const result = log.metadata?.output;
+          const durationMs = log.durationMs;
+          let matchedToolCall = resultToolCallId ? pendingToolCallsRef.current.get(resultToolCallId) : void 0;
+          if (!matchedToolCall) {
+            for (const [, tc] of pendingToolCallsRef.current) {
+              if (tc.name === resultToolName && tc.status === "running") {
+                matchedToolCall = tc;
+                break;
+              }
+            }
+          }
+          if (matchedToolCall) {
+            const completedToolCall = {
+              ...matchedToolCall,
+              result,
+              status: "completed",
+              durationMs
+            };
+            updateToolCall(completedToolCall);
+            pendingToolCallsRef.current.delete(matchedToolCall.id);
+          } else if (resultToolCallId) {
+            const lateToolCall = {
+              id: resultToolCallId,
+              name: resultToolName || "unknown",
+              args: {},
+              result,
+              status: "completed",
+              durationMs
+            };
+            updateToolCall(lateToolCall);
+          }
+          if (resultToolCallId) {
+            firedToolResultsRef.current.add(resultToolCallId);
+          }
+          onToolResultRef.current?.(resultToolName, result, durationMs);
+          break;
+        }
+        default:
+          console.log("[useAgentChat] Unhandled log type:", log.type, log);
+      }
+    },
+    [updateStreamingMessage, updateToolCall]
+  );
   const handleStreamLog = react.useCallback(
     (log) => {
       console.log("[useAgentChat] handleStreamLog:", log.logType, log.metadata);
       switch (log.logType) {
-        // Primary handlers for ai-saas-api worker log types
         case "llm_response": {
-          const llmText = log.metadata?.text || log.message || "";
+          const llmText = log.metadata?.text || "";
           if (llmText) {
             streamingContentRef.current = llmText;
             updateStreamingMessage(llmText);
@@ -552,7 +2916,6 @@ function useAgentChat(options) {
         case "system":
           console.log("[useAgentChat] Status:", log.logType, log.message);
           break;
-        // Legacy/fallback handlers
         case "response_text":
         case "text_chunk": {
           const text = log.metadata?.text || log.message || "";
@@ -562,6 +2925,7 @@ function useAgentChat(options) {
         }
         case "tool_call": {
           const toolName = log.metadata?.toolName;
+          if (SILENT_TOOL_NAMES.has(toolName)) break;
           const toolCallId = log.metadata?.toolCallId || `tool-${Date.now()}`;
           const args = log.metadata?.inputs;
           const newToolCall = {
@@ -572,11 +2936,12 @@ function useAgentChat(options) {
           };
           pendingToolCallsRef.current.set(toolCallId, newToolCall);
           updateToolCall(newToolCall);
-          onToolCall?.(toolName, args);
+          onToolCallRef.current?.(toolName, args);
           break;
         }
         case "tool_result": {
           const resultToolName = log.metadata?.toolName;
+          if (SILENT_TOOL_NAMES.has(resultToolName)) break;
           const resultToolCallId = log.metadata?.toolCallId;
           const result = log.metadata?.output;
           const durationMs = log.durationMs;
@@ -598,7 +2963,21 @@ function useAgentChat(options) {
             };
             updateToolCall(completedToolCall);
             pendingToolCallsRef.current.delete(matchedToolCall.id);
+          } else if (resultToolCallId) {
+            const lateToolCall = {
+              id: resultToolCallId,
+              name: resultToolName || "unknown",
+              args: {},
+              result,
+              status: "completed",
+              durationMs
+            };
+            updateToolCall(lateToolCall);
           }
+          if (resultToolCallId) {
+            firedToolResultsRef.current.add(resultToolCallId);
+          }
+          onToolResultRef.current?.(resultToolName, result, durationMs);
           break;
         }
         case "final_response": {
@@ -613,7 +2992,7 @@ function useAgentChat(options) {
           console.log("[useAgentChat] Unknown log type:", log.logType, log);
       }
     },
-    [updateStreamingMessage, updateToolCall, onToolCall]
+    [updateStreamingMessage, updateToolCall]
   );
   const handleClarification = react.useCallback(
     (data) => {
@@ -625,8 +3004,10 @@ function useAgentChat(options) {
   const handleComplete = react.useCallback(() => {
     console.log("[useAgentChat] handleComplete called");
     setIsLoading(false);
+    setIsStreamControllerConnected(false);
     finalizeStreamingMessage();
     setCurrentExecutionId(null);
+    streamControllerRef.current = null;
   }, [finalizeStreamingMessage]);
   const handleError = react.useCallback(
     (errorMsg) => {
@@ -638,21 +3019,184 @@ function useAgentChat(options) {
       };
       setError(chatError);
       setIsLoading(false);
+      setIsStreamControllerConnected(false);
       finalizeStreamingMessage();
       setCurrentExecutionId(null);
+      streamControllerRef.current = null;
       onError?.(chatError);
     },
     [finalizeStreamingMessage, onError]
   );
-  const { isConnected, disconnect } = useExecutionStream({
-    executionId: currentExecutionId ?? void 0,
-    getStreamUrl: adapter.getStreamUrl,
-    enabled: !!currentExecutionId,
+  const legacyExecutionId = useStreamController ? void 0 : currentExecutionId;
+  const { isConnected: legacyIsConnected, isUsingFallback, disconnect } = useExecutionStream({
+    executionId: legacyExecutionId ?? void 0,
+    getStreamUrl: adapter.getStreamUrl ?? (() => ""),
+    enabled: !!legacyExecutionId,
     onLog: handleStreamLog,
     onClarification: handleClarification,
     onComplete: handleComplete,
     onError: handleError
   });
+  const pollingIntervalRef = react.useRef(null);
+  const pollingExecutionIdRef = react.useRef(null);
+  const stopPolling = react.useCallback(() => {
+    if (pollingIntervalRef.current) {
+      clearInterval(pollingIntervalRef.current);
+      pollingIntervalRef.current = null;
+    }
+    pollingExecutionIdRef.current = null;
+  }, []);
+  const startPolling = react.useCallback((executionId) => {
+    if (pollingExecutionIdRef.current === executionId) return;
+    stopPolling();
+    pollingExecutionIdRef.current = executionId;
+    console.log("[useAgentChat] Starting polling fallback for:", executionId);
+    const poll = async () => {
+      if (pollingExecutionIdRef.current !== executionId) return;
+      try {
+        const execution = await adapter.getExecution(executionId);
+        if (execution.status === "completed") {
+          console.log("[useAgentChat] Polling: execution completed");
+          if (execution.result) {
+            streamingContentRef.current = execution.result;
+            updateStreamingMessage(execution.result);
+          }
+          stopPolling();
+          handleComplete();
+        } else if (execution.status === "failed") {
+          console.log("[useAgentChat] Polling: execution failed");
+          stopPolling();
+          handleError(execution.error || "Execution failed");
+        }
+      } catch (err) {
+        console.warn("[useAgentChat] Polling error (will retry):", err);
+      }
+    };
+    poll();
+    pollingIntervalRef.current = setInterval(poll, 2e3);
+  }, [adapter, stopPolling, updateStreamingMessage, handleComplete, handleError]);
+  react.useEffect(() => {
+    if (!useStreamController && isUsingFallback && currentExecutionId && isLoading) {
+      console.log("[useAgentChat] SSE fallback detected, activating polling");
+      startPolling(currentExecutionId);
+    }
+  }, [useStreamController, isUsingFallback, currentExecutionId, isLoading, startPolling]);
+  const sseTimeoutRef = react.useRef(null);
+  react.useEffect(() => {
+    if (!useStreamController && currentExecutionId && isLoading && !legacyIsConnected && !isUsingFallback) {
+      sseTimeoutRef.current = setTimeout(() => {
+        if (!legacyIsConnected && currentExecutionId && isLoading) {
+          console.log("[useAgentChat] SSE connection timeout, activating polling fallback");
+          startPolling(currentExecutionId);
+        }
+      }, 1e4);
+    }
+    return () => {
+      if (sseTimeoutRef.current) {
+        clearTimeout(sseTimeoutRef.current);
+        sseTimeoutRef.current = null;
+      }
+    };
+  }, [useStreamController, currentExecutionId, isLoading, legacyIsConnected, isUsingFallback, startPolling]);
+  react.useEffect(() => {
+    if (!currentExecutionId) {
+      stopPolling();
+    }
+    return () => {
+      stopPolling();
+    };
+  }, [currentExecutionId, stopPolling]);
+  const connectStreamController = react.useCallback(
+    (executionId, sessionId) => {
+      if (!adapter.createStream) return;
+      if (streamControllerRef.current) {
+        streamControllerRef.current.cancel();
+        streamControllerRef.current = null;
+      }
+      console.log("[useAgentChat] Creating stream controller for:", executionId);
+      const controller = adapter.createStream(executionId, sessionId);
+      streamControllerRef.current = controller;
+      controller.on("log", (log) => {
+        handleExecutionLog(log);
+      });
+      controller.on("toolCall", (data) => {
+        const toolCallId = data.toolCallId || `tool-${Date.now()}`;
+        const toolName = data.toolName;
+        if (SILENT_TOOL_NAMES.has(toolName)) return;
+        if (!pendingToolCallsRef.current.has(toolCallId)) {
+          const newToolCall = {
+            id: toolCallId,
+            name: toolName,
+            args: data.inputs,
+            status: "running"
+          };
+          pendingToolCallsRef.current.set(toolCallId, newToolCall);
+          updateToolCall(newToolCall);
+          onToolCallRef.current?.(toolName, data.inputs);
+        }
+      });
+      controller.on("toolResult", (data) => {
+        const toolCallId = data.toolCallId;
+        const toolName = data.toolName;
+        if (SILENT_TOOL_NAMES.has(toolName)) return;
+        if (firedToolResultsRef.current.has(toolCallId)) return;
+        const existing = pendingToolCallsRef.current.get(toolCallId);
+        if (existing && existing.status === "completed") return;
+        if (existing) {
+          const completedToolCall = {
+            ...existing,
+            result: data.result,
+            status: "completed",
+            durationMs: data.durationMs
+          };
+          updateToolCall(completedToolCall);
+          pendingToolCallsRef.current.delete(toolCallId);
+        } else {
+          const lateToolCall = {
+            id: toolCallId,
+            name: toolName,
+            args: {},
+            result: data.result,
+            status: "completed",
+            durationMs: data.durationMs
+          };
+          updateToolCall(lateToolCall);
+        }
+        firedToolResultsRef.current.add(toolCallId);
+        onToolResultRef.current?.(toolName, data.result, data.durationMs);
+      });
+      controller.on("textDelta", (data) => {
+        streamingContentRef.current += data.delta;
+        updateStreamingMessage(streamingContentRef.current);
+      });
+      controller.on("paused", (data) => {
+        handleClarification({
+          question: data.question,
+          reason: data.reason,
+          suggestedOptions: data.options
+        });
+      });
+      controller.on("complete", ({ execution }) => {
+        if (execution?.output && !streamingContentRef.current) {
+          streamingContentRef.current = execution.output;
+          updateStreamingMessage(execution.output);
+        }
+        handleComplete();
+      });
+      controller.on("error", (errorEvent) => {
+        handleError(errorEvent.error);
+      });
+      controller.on("connectionChange", (data) => {
+        setIsStreamControllerConnected(data.connected);
+      });
+      controller.connect().catch((err) => {
+        console.error("[useAgentChat] Stream controller connect error:", err);
+        handleError(err instanceof Error ? err.message : "Stream connection failed");
+      });
+      setIsStreamControllerConnected(true);
+    },
+    [adapter, handleExecutionLog, updateStreamingMessage, updateToolCall, handleClarification, handleComplete, handleError]
+  );
   const sendMessage = react.useCallback(
     async (content) => {
       if (!content.trim()) return;
@@ -684,17 +3228,24 @@ function useAgentChat(options) {
         console.log("[useAgentChat] Starting execution...", { agentId, sessionId: currentSessionId });
         const result = await adapter.startExecution({
           agentId,
+          teamId,
           sessionId: currentSessionId ?? void 0,
           content: content.trim()
         });
         console.log("[useAgentChat] Execution started:", result);
         if (!currentSessionId && result.sessionId) {
+          internallyCreatedSessionRef.current = result.sessionId;
           setCurrentSessionId(result.sessionId);
           onSessionCreated?.(result.sessionId);
           onSessionStart?.(result.sessionId);
         }
-        console.log("[useAgentChat] Setting executionId:", result.executionId);
-        setCurrentExecutionId(result.executionId);
+        if (useStreamController) {
+          connectStreamController(result.executionId, result.sessionId || currentSessionId || void 0);
+          setCurrentExecutionId(result.executionId);
+        } else {
+          console.log("[useAgentChat] Setting executionId:", result.executionId);
+          setCurrentExecutionId(result.executionId);
+        }
       } catch (err) {
         console.error("[useAgentChat] Error starting execution:", err);
         const errorMessage = err instanceof Error ? err.message : "Failed to send message";
@@ -703,8 +3254,11 @@ function useAgentChat(options) {
     },
     [
       agentId,
+      teamId,
       currentSessionId,
       adapter,
+      useStreamController,
+      connectStreamController,
       onMessage,
       onSessionCreated,
       onSessionStart,
@@ -725,8 +3279,13 @@ function useAgentChat(options) {
         await adapter.cancelExecution(currentExecutionId);
       } catch {
       }
+      if (streamControllerRef.current) {
+        streamControllerRef.current.cancel();
+        streamControllerRef.current = null;
+      }
       disconnect();
       setIsLoading(false);
+      setIsStreamControllerConnected(false);
       finalizeStreamingMessage();
       setCurrentExecutionId(null);
     }
@@ -744,6 +3303,7 @@ function useAgentChat(options) {
     setMessages([]);
     setCurrentSessionId(null);
     hasLoadedInitialSession.current = false;
+    internallyCreatedSessionRef.current = null;
   }, []);
   const loadSession = react.useCallback(
     async (sessionId) => {
@@ -760,8 +3320,67 @@ function useAgentChat(options) {
       setIsLoadingHistory(true);
       setError(null);
       try {
-        const history = await adapter.getSessionHistory(sessionId);
+        const [history, artifacts] = await Promise.all([
+          adapter.getSessionHistory(sessionId),
+          adapter.getSessionArtifacts?.(sessionId).catch(() => []) ?? Promise.resolve([])
+        ]);
         const loadedMessages = history.messages.map(historyToMessage);
+        const imageArtifacts = artifacts.filter(
+          (a) => a.type === "image" || a.mimeType?.startsWith("image/")
+        );
+        if (imageArtifacts.length > 0) {
+          const assistantIndices = [];
+          for (let i = 0; i < loadedMessages.length; i++) {
+            if (loadedMessages[i].role === "assistant") {
+              assistantIndices.push(i);
+            }
+          }
+          if (assistantIndices.length > 0) {
+            const artifactsByMsgIdx = /* @__PURE__ */ new Map();
+            for (const artifact of imageArtifacts) {
+              let targetIdx = assistantIndices[assistantIndices.length - 1];
+              if (artifact.createdAt) {
+                const artifactTime = new Date(artifact.createdAt).getTime();
+                for (let i = assistantIndices.length - 1; i >= 0; i--) {
+                  const msgIdx = assistantIndices[i];
+                  const msg = loadedMessages[msgIdx];
+                  const msgTime = msg.timestamp ? new Date(msg.timestamp).getTime() : 0;
+                  if (msgTime <= artifactTime) {
+                    targetIdx = msgIdx;
+                    break;
+                  }
+                }
+              }
+              const existing = artifactsByMsgIdx.get(targetIdx) ?? [];
+              existing.push(artifact);
+              artifactsByMsgIdx.set(targetIdx, existing);
+            }
+            for (const [msgIdx, msgArtifacts] of artifactsByMsgIdx) {
+              const targetMsg = loadedMessages[msgIdx];
+              const existingToolCalls = targetMsg.toolCalls ?? [];
+              const imageToolCalls = msgArtifacts.map((artifact, i) => ({
+                id: `history-artifact-${artifact.uuid}-${i}`,
+                name: "generate_image",
+                args: {},
+                result: {
+                  success: true,
+                  images: [{ url: artifact.url }]
+                },
+                status: "completed"
+              }));
+              loadedMessages[msgIdx] = {
+                id: targetMsg.id,
+                role: targetMsg.role,
+                content: targetMsg.content,
+                timestamp: targetMsg.timestamp,
+                isStreaming: targetMsg.isStreaming,
+                attachments: targetMsg.attachments,
+                thinkingBlocks: targetMsg.thinkingBlocks,
+                toolCalls: [...existingToolCalls, ...imageToolCalls]
+              };
+            }
+          }
+        }
         setMessages(loadedMessages);
         setCurrentSessionId(sessionId);
       } catch (err) {
@@ -781,14 +3400,28 @@ function useAgentChat(options) {
   );
   react.useEffect(() => {
     if (initialSessionId && !hasLoadedInitialSession.current) {
+      if (internallyCreatedSessionRef.current === initialSessionId) {
+        hasLoadedInitialSession.current = true;
+        return;
+      }
       hasLoadedInitialSession.current = true;
       loadSession(initialSessionId);
     }
   }, [initialSessionId, loadSession]);
-  const isStreaming = react.useMemo(
-    () => !!currentExecutionId && isConnected,
-    [currentExecutionId, isConnected]
-  );
+  react.useEffect(() => {
+    return () => {
+      if (streamControllerRef.current) {
+        streamControllerRef.current.cancel();
+        streamControllerRef.current = null;
+      }
+    };
+  }, []);
+  const isStreaming = react.useMemo(() => {
+    if (useStreamController) {
+      return !!currentExecutionId && isStreamControllerConnected;
+    }
+    return !!currentExecutionId && legacyIsConnected;
+  }, [useStreamController, currentExecutionId, isStreamControllerConnected, legacyIsConnected]);
   return {
     messages,
     isLoading,
@@ -1684,8 +4317,18 @@ function AskUserPrompt({
 function cn5(...classes) {
   return classes.filter(Boolean).join(" ");
 }
-function MarkdownContent({ content, className }) {
-  const components = react.useMemo(
+function MarkdownContent({
+  content,
+  className,
+  components: customComponents,
+  urlTransform,
+  contentTransform
+}) {
+  const transformedContent = react.useMemo(
+    () => contentTransform ? contentTransform(content) : content,
+    [content, contentTransform]
+  );
+  const defaultComponents = react.useMemo(
     () => ({
       // Headers
       h1: ({ children }) => /* @__PURE__ */ jsxRuntime.jsx("h1", { className: "text-2xl font-bold mt-4 mb-2 first:mt-0", children }),
@@ -1775,7 +4418,19 @@ function MarkdownContent({ content, className }) {
     }),
     []
   );
-  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn5("prose prose-sm dark:prose-invert max-w-none", className), children: /* @__PURE__ */ jsxRuntime.jsx(ReactMarkdown__default.default, { remarkPlugins: [remarkGfm__default.default], components, children: content }) });
+  const mergedComponents = react.useMemo(
+    () => customComponents ? { ...defaultComponents, ...customComponents } : defaultComponents,
+    [defaultComponents, customComponents]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn5("prose prose-sm dark:prose-invert max-w-none", className), children: /* @__PURE__ */ jsxRuntime.jsx(
+    ReactMarkdown__default.default,
+    {
+      remarkPlugins: [remarkGfm__default.default],
+      components: mergedComponents,
+      ...urlTransform ? { urlTransform } : {},
+      children: transformedContent
+    }
+  ) });
 }
 function cn6(...classes) {
   return classes.filter(Boolean).join(" ");
@@ -1847,16 +4502,53 @@ function formatJsonPreview(data, maxLength = 100) {
     return String(data);
   }
 }
+function extractImagesFromResult(result) {
+  if (!result) return [];
+  let data = result;
+  if (typeof result === "string") {
+    try {
+      data = JSON.parse(result);
+    } catch {
+      if (/\.(png|jpg|jpeg|gif|webp|svg|bmp)(\?.*)?$/i.test(result) || result.startsWith("data:image/")) {
+        return [{ url: result }];
+      }
+      return [];
+    }
+  }
+  if (typeof data !== "object" || data === null) return [];
+  const obj = data;
+  if (Array.isArray(obj.images)) {
+    return obj.images.filter((img) => typeof img.url === "string").map((img) => ({
+      url: img.url,
+      thumbnailUrl: img.thumbnailUrl,
+      prompt: img.prompt,
+      alt: img.alt || img.prompt || void 0
+    }));
+  }
+  if (typeof obj.url === "string" && /\.(png|jpg|jpeg|gif|webp|svg|bmp)(\?.*)?$/i.test(obj.url)) {
+    return [{ url: obj.url, alt: obj.alt }];
+  }
+  if (typeof obj.imageUrl === "string") {
+    return [{ url: obj.imageUrl, alt: obj.alt }];
+  }
+  return [];
+}
 function ToolCallEntry({
   toolCall,
   className,
-  showFullJson = true
+  showFullJson = true,
+  onImageClick
 }) {
   const [isExpanded, setIsExpanded] = react.useState(false);
   const formattedName = react.useMemo(
     () => formatToolName(toolCall.name),
     [toolCall.name]
   );
+  const resultImages = react.useMemo(
+    () => toolCall.status === "completed" && toolCall.result ? extractImagesFromResult(toolCall.result) : [],
+    [toolCall.status, toolCall.result]
+  );
+  const hasImages = resultImages.length > 0;
   const statusIcon = react.useMemo(() => {
     switch (toolCall.status) {
       case "pending":
@@ -1909,6 +4601,47 @@ function ToolCallEntry({
             ]
           }
         ),
+        hasImages && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-3 pb-2", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn6(
+          "grid gap-2",
+          resultImages.length === 1 ? "grid-cols-1" : "grid-cols-2"
+        ), children: resultImages.map((img, idx) => {
+          const altText = img.alt || img.prompt || `Generated image ${idx + 1}`;
+          const imageElement = /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "img",
+              {
+                src: img.thumbnailUrl || img.url,
+                alt: altText,
+                className: "w-full h-auto max-h-[300px] object-contain bg-gray-50 dark:bg-gray-900",
+                loading: "lazy"
+              }
+            ),
+            img.prompt && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-2 py-1 text-xs text-gray-500 dark:text-gray-400 truncate bg-gray-50 dark:bg-gray-800 border-t border-gray-200 dark:border-gray-700", children: img.prompt })
+          ] });
+          if (onImageClick) {
+            return /* @__PURE__ */ jsxRuntime.jsx(
+              "button",
+              {
+                type: "button",
+                onClick: () => onImageClick({ url: img.url, alt: altText, filename: altText }),
+                className: "block rounded-lg overflow-hidden border border-gray-200 dark:border-gray-700 hover:border-blue-400 dark:hover:border-blue-600 transition-colors cursor-pointer text-left",
+                children: imageElement
+              },
+              idx
+            );
+          }
+          return /* @__PURE__ */ jsxRuntime.jsx(
+            "a",
+            {
+              href: img.url,
+              target: "_blank",
+              rel: "noopener noreferrer",
+              className: "block rounded-lg overflow-hidden border border-gray-200 dark:border-gray-700 hover:border-blue-400 dark:hover:border-blue-600 transition-colors",
+              children: imageElement
+            },
+            idx
+          );
+        }) }) }),
         isExpanded && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "border-t border-gray-200 dark:border-gray-700 px-3 py-2 space-y-2", children: [
           toolCall.args && Object.keys(toolCall.args).length > 0 && /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
             /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-xs font-medium text-gray-500 dark:text-gray-400 mb-1", children: "Input" }),
@@ -1934,7 +4667,11 @@ function ChatMessage({
   message,
   enableMarkdown = true,
   showToolCalls = true,
-  className
+  className,
+  markdownComponents,
+  markdownUrlTransform,
+  markdownContentTransform,
+  onImageClick
 }) {
   const isUser = message.role === "user";
   const isAssistant = message.role === "assistant";
@@ -1994,6 +4731,14 @@ function ChatMessage({
                 },
                 block.id
               )) }),
+              showToolCalls && message.toolCalls && message.toolCalls.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-2", children: message.toolCalls.map((toolCall) => /* @__PURE__ */ jsxRuntime.jsx(
+                ToolCallEntry,
+                {
+                  toolCall,
+                  onImageClick
+                },
+                toolCall.id
+              )) }),
               message.content && /* @__PURE__ */ jsxRuntime.jsx(
                 "div",
                 {
@@ -2001,16 +4746,17 @@ function ChatMessage({
                     "rounded-lg p-3",
                     isUser ? "bg-blue-500 text-white" : "bg-gray-100 dark:bg-gray-800 text-gray-900 dark:text-gray-100"
                   ),
-                  children: isAssistant && enableMarkdown ? /* @__PURE__ */ jsxRuntime.jsx(MarkdownContent, { content: message.content }) : /* @__PURE__ */ jsxRuntime.jsx("p", { className: "whitespace-pre-wrap", children: message.content })
+                  children: isAssistant && enableMarkdown ? /* @__PURE__ */ jsxRuntime.jsx(
+                    MarkdownContent,
+                    {
+                      content: message.content,
+                      components: markdownComponents,
+                      urlTransform: markdownUrlTransform,
+                      contentTransform: markdownContentTransform
+                    }
+                  ) : /* @__PURE__ */ jsxRuntime.jsx("p", { className: "whitespace-pre-wrap", children: message.content })
                 }
               ),
-              showToolCalls && message.toolCalls && message.toolCalls.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "space-y-2", children: message.toolCalls.map((toolCall) => /* @__PURE__ */ jsxRuntime.jsx(
-                ToolCallEntry,
-                {
-                  toolCall
-                },
-                toolCall.id
-              )) }),
               message.attachments && message.attachments.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex flex-wrap gap-2", children: message.attachments.map((attachment) => /* @__PURE__ */ jsxRuntime.jsx(
                 "div",
                 {
@@ -2032,12 +4778,18 @@ function cn8(...classes) {
 function MessageList({
   messages,
   welcomeMessage = "Hello! How can I help you today?",
+  renderWelcome,
   isLoading = false,
   isStreaming = false,
   isLoadingHistory = false,
   enableMarkdown = true,
   showToolCalls = true,
-  className
+  className,
+  markdownComponents,
+  markdownUrlTransform,
+  markdownContentTransform,
+  onImageClick,
+  sendMessage
 }) {
   const scrollRef = react.useRef(null);
   const messagesEndRef = react.useRef(null);
@@ -2059,13 +4811,18 @@ function MessageList({
           /* @__PURE__ */ jsxRuntime.jsx(LoadingSpinner, { className: "h-6 w-6 mx-auto mb-2" }),
           /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm", children: "Loading conversation..." })
         ] }) }),
-        messages.length === 0 && !isLoading && !isLoadingHistory && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center justify-center h-full p-8", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-center text-gray-500 dark:text-gray-400", children: /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-lg", children: welcomeMessage }) }) }),
+        messages.length === 0 && !isLoading && !isLoadingHistory && (renderWelcome ? /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: typeof renderWelcome === "function" ? renderWelcome({ sendMessage: sendMessage || (() => {
+        }) }) : renderWelcome }) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex items-center justify-center h-full p-8", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "text-center text-gray-500 dark:text-gray-400", children: /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-lg", children: welcomeMessage }) }) })),
         /* @__PURE__ */ jsxRuntime.jsx("div", { className: "divide-y divide-gray-100 dark:divide-gray-800", children: messages.map((message) => /* @__PURE__ */ jsxRuntime.jsx(
           ChatMessage,
           {
             message,
             enableMarkdown,
-            showToolCalls
+            showToolCalls,
+            markdownComponents,
+            markdownUrlTransform,
+            markdownContentTransform,
+            onImageClick
           },
           message.id
         )) }),
@@ -2107,6 +4864,7 @@ function ErrorBanner({ error, onRetry, onDismiss }) {
 }
 function AgentChat({
   agentId,
+  teamId,
   sessionId,
   adapter,
   onMessage,
@@ -2114,16 +4872,22 @@ function AgentChat({
   onSessionCreated,
   onSessionStart,
   onToolCall,
+  onToolResult,
   onClarification,
   initialMessages = [],
   placeholder = "Type a message...",
   welcomeMessage = "Hello! How can I help you today?",
+  renderWelcome,
   maxHeight = "600px",
   className,
   theme = "system",
   enableAttachments = false,
   enableMarkdown = true,
-  showToolCalls = true
+  showToolCalls = true,
+  markdownComponents,
+  markdownUrlTransform,
+  markdownContentTransform,
+  onImageClick
 }) {
   const {
     messages,
@@ -2139,6 +4903,7 @@ function AgentChat({
     clearError
   } = useAgentChat({
     agentId,
+    teamId,
     sessionId,
     adapter,
     initialMessages,
@@ -2147,6 +4912,7 @@ function AgentChat({
     onSessionCreated,
     onSessionStart,
     onToolCall,
+    onToolResult,
     onClarification
   });
   return /* @__PURE__ */ jsxRuntime.jsxs(ChatContainer, { maxHeight, className, theme, children: [
@@ -2155,11 +4921,17 @@ function AgentChat({
       {
         messages,
         welcomeMessage,
+        renderWelcome,
         isLoading,
         isStreaming,
         isLoadingHistory,
         enableMarkdown,
-        showToolCalls
+        showToolCalls,
+        markdownComponents,
+        markdownUrlTransform,
+        markdownContentTransform,
+        onImageClick,
+        sendMessage
       }
     ),
     clarification && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "border-t border-gray-200 dark:border-gray-700 p-4", children: /* @__PURE__ */ jsxRuntime.jsx(