@seclai/sdk 1.0.7 → 1.1.1

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -25,7 +35,8 @@ __export(index_exports, {
   SeclaiAPIStatusError: () => SeclaiAPIStatusError,
   SeclaiAPIValidationError: () => SeclaiAPIValidationError,
   SeclaiConfigurationError: () => SeclaiConfigurationError,
-  SeclaiError: () => SeclaiError
+  SeclaiError: () => SeclaiError,
+  SeclaiStreamingError: () => SeclaiStreamingError
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -69,10 +80,293 @@ var SeclaiAPIValidationError = class extends SeclaiAPIStatusError {
     this.validationError = opts.validationError;
   }
 };
+var SeclaiStreamingError = class extends SeclaiError {
+  /** The run ID associated with the failed stream, when available. */
+  runId;
+  constructor(message, runId) {
+    super(message);
+    this.name = "SeclaiStreamingError";
+    this.runId = runId;
+  }
+};
+
+// src/auth.ts
+var DEFAULT_CONFIG_DIR = ".seclai";
+var SSO_CACHE_DIR = "sso/cache";
+var CONFIG_FILE = "config";
+var EXPIRY_BUFFER_MS = 3e4;
+var DEFAULT_API_KEY_HEADER = "x-api-key";
+function getEnv(name) {
+  const p = globalThis?.process;
+  return p?.env?.[name];
+}
+function getHomeDir() {
+  const p = globalThis?.process;
+  return p?.env?.HOME ?? p?.env?.USERPROFILE;
+}
+async function sha1Hex(input) {
+  try {
+    const { createHash } = await import("crypto");
+    return createHash("sha1").update(input).digest("hex");
+  } catch {
+    const encoded = new TextEncoder().encode(input);
+    const buffer = await crypto.subtle.digest("SHA-1", encoded);
+    return Array.from(new Uint8Array(buffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+}
+async function cacheFileName(domain, clientId) {
+  return sha1Hex(`${domain}|${clientId}`);
+}
+function parseIni(content) {
+  const sections = {};
+  let currentSection = null;
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#") || line.startsWith(";")) continue;
+    const sectionMatch = line.match(/^\[(.+)\]$/);
+    if (sectionMatch) {
+      const raw = sectionMatch[1].trim();
+      currentSection = raw.startsWith("profile ") ? raw.slice("profile ".length).trim() : raw;
+      sections[currentSection] ??= {};
+      continue;
+    }
+    if (currentSection !== null) {
+      const eqIdx = line.indexOf("=");
+      if (eqIdx > 0) {
+        const key = line.slice(0, eqIdx).trim();
+        const value = line.slice(eqIdx + 1).trim();
+        sections[currentSection][key] = value;
+      }
+    }
+  }
+  return sections;
+}
+var _fs = null;
+var _path = null;
+async function getFs() {
+  if (!_fs) {
+    _fs = await import("fs");
+  }
+  return _fs;
+}
+async function getPath() {
+  if (!_path) {
+    _path = await import("path");
+  }
+  return _path;
+}
+async function resolveConfigDir(override) {
+  if (override) return override;
+  const envDir = getEnv("SECLAI_CONFIG_DIR");
+  if (envDir) return envDir;
+  const home = getHomeDir();
+  if (!home) {
+    throw new Error("Cannot determine home directory. Set SECLAI_CONFIG_DIR.");
+  }
+  const pathMod = await getPath();
+  return pathMod.join(home, DEFAULT_CONFIG_DIR);
+}
+async function loadSsoProfile(configDir, profileName) {
+  const fs = await getFs();
+  const pathMod = await getPath();
+  const configPath = pathMod.join(configDir, CONFIG_FILE);
+  if (!fs.existsSync(configPath)) return null;
+  const content = fs.readFileSync(configPath, "utf-8");
+  const sections = parseIni(content);
+  const defaultSection = sections["default"] ?? {};
+  const profileSection = profileName === "default" ? defaultSection : sections[profileName];
+  if (!profileSection) return null;
+  const merged = profileName === "default" ? profileSection : { ...defaultSection, ...profileSection };
+  const ssoAccountId = merged["sso_account_id"];
+  const ssoRegion = merged["sso_region"];
+  const ssoClientId = merged["sso_client_id"];
+  const ssoDomain = merged["sso_domain"];
+  if (!ssoAccountId || !ssoRegion || !ssoClientId || !ssoDomain) return null;
+  return { ssoAccountId, ssoRegion, ssoClientId, ssoDomain };
+}
+async function resolveCachePath(configDir, profile) {
+  const pathMod = await getPath();
+  const hash = await cacheFileName(profile.ssoDomain, profile.ssoClientId);
+  return pathMod.join(configDir, SSO_CACHE_DIR, `${hash}.json`);
+}
+async function readSsoCache(configDir, profile) {
+  const fs = await getFs();
+  const cachePath = await resolveCachePath(configDir, profile);
+  if (!fs.existsSync(cachePath)) return null;
+  try {
+    const raw = fs.readFileSync(cachePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeSsoCache(configDir, profile, entry) {
+  const fs = await getFs();
+  const pathMod = await getPath();
+  const cacheDir = pathMod.join(configDir, SSO_CACHE_DIR);
+  fs.mkdirSync(cacheDir, { recursive: true, mode: 448 });
+  const cachePath = await resolveCachePath(configDir, profile);
+  const tmpPath = `${cachePath}.tmp`;
+  fs.writeFileSync(tmpPath, JSON.stringify(entry, null, 2), { mode: 384 });
+  if (fs.existsSync(cachePath)) {
+    try {
+      fs.unlinkSync(cachePath);
+    } catch {
+    }
+  }
+  fs.renameSync(tmpPath, cachePath);
+}
+function isTokenValid(entry) {
+  const expiresAt = new Date(entry.expiresAt).getTime();
+  return Date.now() + EXPIRY_BUFFER_MS < expiresAt;
+}
+async function refreshToken(profile, refreshTokenValue, fetcher) {
+  const tokenUrl = `https://${profile.ssoDomain}/oauth2/token`;
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: profile.ssoClientId,
+    refresh_token: refreshTokenValue
+  });
+  const response = await fetcher(tokenUrl, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: body.toString()
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Token refresh failed (HTTP ${response.status}): ${text}`);
+  }
+  const data = await response.json();
+  const expiresAt = new Date(Date.now() + data.expires_in * 1e3).toISOString();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token ?? refreshTokenValue,
+    idToken: data.id_token ?? void 0,
+    expiresAt,
+    clientId: profile.ssoClientId,
+    region: profile.ssoRegion,
+    cognitoDomain: profile.ssoDomain
+  };
+}
+async function resolveCredentialChain(opts) {
+  const apiKeyHeader = opts.apiKeyHeader ?? DEFAULT_API_KEY_HEADER;
+  if (opts.apiKey) {
+    return {
+      mode: "apiKey",
+      apiKey: opts.apiKey,
+      apiKeyHeader,
+      accountId: opts.accountId,
+      autoRefresh: false
+    };
+  }
+  if (opts.accessToken) {
+    return {
+      mode: "bearerStatic",
+      accessToken: opts.accessToken,
+      apiKeyHeader,
+      accountId: opts.accountId,
+      autoRefresh: false
+    };
+  }
+  if (opts.accessTokenProvider) {
+    return {
+      mode: "bearerProvider",
+      accessTokenProvider: opts.accessTokenProvider,
+      apiKeyHeader,
+      accountId: opts.accountId,
+      autoRefresh: false
+    };
+  }
+  const envApiKey = getEnv("SECLAI_API_KEY");
+  if (envApiKey) {
+    return {
+      mode: "apiKey",
+      apiKey: envApiKey,
+      apiKeyHeader,
+      accountId: opts.accountId,
+      autoRefresh: false
+    };
+  }
+  try {
+    const configDir = await resolveConfigDir(opts.configDir);
+    const profileName = opts.profile ?? getEnv("SECLAI_PROFILE") ?? "default";
+    const ssoProfile = await loadSsoProfile(configDir, profileName);
+    if (ssoProfile) {
+      return {
+        mode: "sso",
+        apiKeyHeader,
+        accountId: opts.accountId ?? ssoProfile.ssoAccountId,
+        ssoProfile,
+        configDir,
+        autoRefresh: opts.autoRefresh !== false,
+        fetcher: opts.fetch
+      };
+    }
+  } catch {
+  }
+  throw new Error(
+    "Missing credentials. Provide apiKey, accessToken, set SECLAI_API_KEY, or run `seclai auth login`."
+  );
+}
+async function resolveAuthHeaders(state) {
+  const headers = {};
+  switch (state.mode) {
+    case "apiKey":
+      headers[state.apiKeyHeader] = state.apiKey;
+      break;
+    case "bearerStatic":
+      headers["authorization"] = `Bearer ${state.accessToken}`;
+      break;
+    case "bearerProvider": {
+      const token = await Promise.resolve(state.accessTokenProvider());
+      headers["authorization"] = `Bearer ${token}`;
+      break;
+    }
+    case "sso": {
+      const token = await resolveSsoToken(state);
+      headers["authorization"] = `Bearer ${token}`;
+      break;
+    }
+  }
+  if (state.accountId) {
+    headers["x-account-id"] = state.accountId;
+  }
+  return headers;
+}
+async function resolveSsoToken(state) {
+  const profile = state.ssoProfile;
+  const configDir = state.configDir;
+  const cached = await readSsoCache(configDir, profile);
+  if (cached && isTokenValid(cached)) {
+    return cached.accessToken;
+  }
+  if (cached?.refreshToken && state.autoRefresh) {
+    if (state._refreshPromise) {
+      return state._refreshPromise;
+    }
+    const fetcher = state.fetcher ?? globalThis.fetch;
+    if (!fetcher) {
+      throw new Error("No fetch implementation available for token refresh.");
+    }
+    state._refreshPromise = (async () => {
+      try {
+        const refreshed = await refreshToken(profile, cached.refreshToken, fetcher);
+        await writeSsoCache(configDir, profile, refreshed);
+        return refreshed.accessToken;
+      } finally {
+        state._refreshPromise = void 0;
+      }
+    })();
+    return state._refreshPromise;
+  }
+  throw new Error(
+    `SSO token expired. Run \`seclai auth login\` to re-authenticate.`
+  );
+}
 
 // src/client.ts
 var SECLAI_API_URL = "https://api.seclai.com";
-function getEnv(name) {
+function getEnv2(name) {
   const p = globalThis?.process;
   return p?.env?.[name];
 }
@@ -153,24 +447,75 @@ function anySignal(signals) {
   }
   return controller.signal;
 }
+function toBlob(file, mimeType) {
+  if (file instanceof Blob) return file;
+  const opts = mimeType ? { type: mimeType } : void 0;
+  if (file instanceof ArrayBuffer) return new Blob([new Uint8Array(file)], opts);
+  return new Blob([file], opts);
+}
+var MIME_TYPES = {
+  txt: "text/plain",
+  html: "text/html",
+  htm: "text/html",
+  md: "text/markdown",
+  csv: "text/csv",
+  xml: "text/xml",
+  json: "application/json",
+  pdf: "application/pdf",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ppt: "application/vnd.ms-powerpoint",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  msg: "application/vnd.ms-outlook",
+  zip: "application/zip",
+  epub: "application/epub+zip",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  bmp: "image/bmp",
+  tiff: "image/tiff",
+  webp: "image/webp",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  m4a: "audio/mp4",
+  flac: "audio/flac",
+  ogg: "audio/ogg",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  avi: "video/x-msvideo"
+};
+function inferMimeType(fileName) {
+  if (!fileName) return void 0;
+  const ext = fileName.split(".").pop()?.toLowerCase();
+  return ext ? MIME_TYPES[ext] : void 0;
+}
 var Seclai = class {
-  apiKey;
   baseUrl;
-  apiKeyHeader;
   defaultHeaders;
   fetcher;
+  _authState = null;
+  _authInitPromise = null;
+  _authInitError = null;
   /**
    * Create a new Seclai client.
    *
+   * Credentials are resolved via a chain (first match wins):
+   * 1. Explicit `apiKey` option
+   * 2. Explicit `accessToken` option (static string or provider function)
+   * 3. `SECLAI_API_KEY` environment variable
+   * 4. SSO profile from `~/.seclai/config` + cached tokens in `~/.seclai/sso/cache/`
+   *
    * @param opts - Client configuration.
-   * @throws {@link SeclaiConfigurationError} If no API key is provided (and `SECLAI_API_KEY` is not set).
    * @throws {@link SeclaiConfigurationError} If no `fetch` implementation is available.
+   * @throws {@link SeclaiConfigurationError} If both `apiKey` and `accessToken` are provided.
    */
   constructor(opts = {}) {
-    const apiKey = opts.apiKey ?? getEnv("SECLAI_API_KEY");
-    if (!apiKey) {
+    if (opts.apiKey && opts.accessToken) {
       throw new SeclaiConfigurationError(
-        "Missing API key. Provide apiKey or set SECLAI_API_KEY."
+        "Provide either apiKey or accessToken, not both."
       );
     }
     const fetcher = opts.fetch ?? globalThis.fetch;
@@ -179,30 +524,72 @@ var Seclai = class {
         "No fetch implementation available. Provide opts.fetch or run in an environment with global fetch."
       );
     }
-    this.apiKey = apiKey;
-    this.baseUrl = opts.baseUrl ?? getEnv("SECLAI_API_URL") ?? SECLAI_API_URL;
-    this.apiKeyHeader = opts.apiKeyHeader ?? "x-api-key";
+    this.baseUrl = opts.baseUrl ?? getEnv2("SECLAI_API_URL") ?? SECLAI_API_URL;
     this.defaultHeaders = { ...opts.defaultHeaders ?? {} };
     this.fetcher = fetcher;
+    const accessTokenProvider = typeof opts.accessToken === "function" ? opts.accessToken : void 0;
+    const accessTokenStatic = typeof opts.accessToken === "string" ? opts.accessToken : void 0;
+    this._authInitPromise = resolveCredentialChain({
+      apiKey: opts.apiKey,
+      accessToken: accessTokenStatic,
+      accessTokenProvider,
+      profile: opts.profile,
+      configDir: opts.configDir,
+      autoRefresh: opts.autoRefresh,
+      accountId: opts.accountId,
+      apiKeyHeader: opts.apiKeyHeader,
+      fetch: fetcher
+    }).then((state) => {
+      this._authState = state;
+    }).catch((err) => {
+      this._authInitError = new SeclaiConfigurationError(
+        err instanceof Error ? err.message : String(err)
+      );
+    });
+  }
+  /** Ensure the credential chain has been resolved. */
+  async ensureAuth() {
+    if (this._authInitPromise) {
+      await this._authInitPromise;
+      this._authInitPromise = null;
+    }
+    if (this._authInitError) {
+      throw this._authInitError;
+    }
+    if (!this._authState) {
+      throw new SeclaiConfigurationError(
+        "Missing credentials. Provide apiKey, accessToken, set SECLAI_API_KEY, or run `seclai auth login`."
+      );
+    }
+    return this._authState;
   }
+  /** Resolve auth headers for the current request. */
+  async authHeaders() {
+    const state = await this.ensureAuth();
+    return resolveAuthHeaders(state);
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Low-level request
+  // ═══════════════════════════════════════════════════════════════════════════
   /**
    * Make a raw HTTP request to the Seclai API.
    *
    * This is a low-level escape hatch. For most operations, prefer the typed convenience methods.
    *
    * @param method - HTTP method (e.g. `"GET"`, `"POST"`).
-  * @param path - Request path relative to `baseUrl` (e.g. `"/sources/"`).
-   * @param opts - Query params, JSON body, and per-request headers.
+   * @param path - Request path relative to `baseUrl` (e.g. `"/sources/"`).
+   * @param opts - Query params, JSON body, per-request headers, and optional AbortSignal.
    * @returns Parsed JSON for JSON responses, raw text for non-JSON responses, or `null` for empty bodies.
    * @throws {@link SeclaiAPIValidationError} For validation errors (typically HTTP 422).
    * @throws {@link SeclaiAPIStatusError} For other non-success HTTP status codes.
    */
   async request(method, path, opts) {
     const url = buildURL(this.baseUrl, path, opts?.query);
+    const authHeaders = await this.authHeaders();
     const headers = {
       ...this.defaultHeaders,
       ...opts?.headers ?? {},
-      [this.apiKeyHeader]: this.apiKey
+      ...authHeaders
     };
     let body;
     if (opts?.json !== void 0) {
@@ -213,6 +600,9 @@ var Seclai = class {
     if (body !== void 0) {
       init.body = body;
     }
+    if (opts?.signal) {
+      init.signal = opts.signal;
+    }
     const response = await this.fetcher(url, init);
     if (response.status === 204) return null;
     const contentType = response.headers.get("content-type") ?? "";
@@ -245,29 +635,253 @@ var Seclai = class {
     return await response.text();
   }
   /**
-   * Run an agent.
+   * Make a raw HTTP request and return the raw `Response` object (for binary downloads, etc.).
+   *
+   * @param method - HTTP method.
+   * @param path - Request path relative to `baseUrl`.
+   * @param opts - Query params, JSON body, per-request headers, and optional AbortSignal.
+   * @returns The raw `Response` object.
+   * @throws {SeclaiAPIValidationError} On HTTP 422 responses.
+   * @throws {SeclaiAPIStatusError} On other non-2xx responses.
+   */
+  async requestRaw(method, path, opts) {
+    const url = buildURL(this.baseUrl, path, opts?.query);
+    const authHeaders = await this.authHeaders();
+    const headers = {
+      ...this.defaultHeaders,
+      ...opts?.headers ?? {},
+      ...authHeaders
+    };
+    let body;
+    if (opts?.json !== void 0) {
+      headers["content-type"] = headers["content-type"] ?? "application/json";
+      body = JSON.stringify(opts.json);
+    }
+    const init = { method, headers };
+    if (body !== void 0) init.body = body;
+    if (opts?.signal) init.signal = opts.signal;
+    const response = await this.fetcher(url, init);
+    if (!response.ok) {
+      const responseText = await safeText(response);
+      if (response.status === 422) {
+        const validation = await safeJson(response);
+        throw new SeclaiAPIValidationError({
+          message: "Validation error",
+          statusCode: response.status,
+          method,
+          url: url.toString(),
+          responseText,
+          validationError: validation
+        });
+      }
+      throw new SeclaiAPIStatusError({
+        message: `Request failed with status ${response.status}`,
+        statusCode: response.status,
+        method,
+        url: url.toString(),
+        responseText
+      });
+    }
+    return response;
+  }
+  /** Shared multipart upload helper. */
+  async uploadFile(path, opts) {
+    const url = buildURL(this.baseUrl, path);
+    const authHeaders = await this.authHeaders();
+    const headers = {
+      ...this.defaultHeaders,
+      ...authHeaders
+    };
+    delete headers["content-type"];
+    delete headers["Content-Type"];
+    const form = new FormData();
+    const mimeType = opts.mimeType ?? inferMimeType(opts.fileName);
+    const blob = toBlob(opts.file, mimeType);
+    form.set("file", blob, opts.fileName ?? "upload");
+    if (opts.title !== void 0) form.set("title", opts.title);
+    if (opts.metadata !== void 0) form.set("metadata", JSON.stringify(opts.metadata));
+    const init = { method: "POST", headers, body: form };
+    if (opts.signal) init.signal = opts.signal;
+    const response = await this.fetcher(url, init);
+    if (!response.ok) {
+      const responseText = await safeText(response);
+      if (response.status === 422) {
+        const validation = await safeJson(response);
+        throw new SeclaiAPIValidationError({
+          message: "Validation error",
+          statusCode: response.status,
+          method: "POST",
+          url: url.toString(),
+          responseText,
+          validationError: validation
+        });
+      }
+      throw new SeclaiAPIStatusError({
+        message: `Request failed with status ${response.status}`,
+        statusCode: response.status,
+        method: "POST",
+        url: url.toString(),
+        responseText
+      });
+    }
+    return await response.json();
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Agents — CRUD
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * List agents.
+   *
+   * @param opts - Pagination options.
+   * @returns Paginated list of agents.
+   */
+  async listAgents(opts = {}) {
+    return await this.request("GET", "/agents", {
+      query: { page: opts.page, limit: opts.limit }
+    });
+  }
+  /**
+   * Create a new agent.
+   *
+   * @param body - Agent creation payload (name, trigger type, template, etc.).
+   * @returns Summary of the created agent.
+   */
+  async createAgent(body) {
+    return await this.request("POST", "/agents", { json: body });
+  }
+  /**
+   * Get agent details including its definition.
+   *
+   * @param agentId - Agent identifier.
+   * @returns Full agent metadata.
+   */
+  async getAgent(agentId) {
+    return await this.request("GET", `/agents/${agentId}`);
+  }
+  /**
+   * Update an agent.
+   *
+   * @param agentId - Agent identifier.
+   * @param body - Fields to update.
+   * @returns Updated agent summary.
+   */
+  async updateAgent(agentId, body) {
+    return await this.request("PUT", `/agents/${agentId}`, { json: body });
+  }
+  /**
+   * Delete an agent.
+   *
+   * @param agentId - Agent identifier.
+   */
+  async deleteAgent(agentId) {
+    await this.request("DELETE", `/agents/${agentId}`);
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Agent Definitions
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Get an agent's full definition (steps, model config, etc.).
+   *
+   * @param agentId - Agent identifier.
+   * @returns The agent definition.
+   */
+  async getAgentDefinition(agentId) {
+    return await this.request("GET", `/agents/${agentId}/definition`);
+  }
+  /**
+   * Update an agent's definition.
+   *
+   * @param agentId - Agent identifier.
+   * @param body - Updated definition payload.
+   * @returns Updated agent definition.
+   */
+  async updateAgentDefinition(agentId, body) {
+    return await this.request("PUT", `/agents/${agentId}/definition`, { json: body });
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Agent Runs
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Start an agent run.
    *
    * @param agentId - Agent identifier.
-   * @param body - Agent run request payload.
+   * @param body - Run request payload (`input`, `metadata`, `priority`, etc.).
    * @returns The created agent run.
    */
   async runAgent(agentId, body) {
-    const data = await this.request("POST", `/agents/${agentId}/runs`, { json: body });
-    return data;
+    return await this.request("POST", `/agents/${agentId}/runs`, { json: body });
+  }
+  /**
+   * List runs for a specific agent.
+   *
+   * @param agentId - Agent identifier.
+   * @param opts - Pagination and filter options.
+   * @returns Paginated list of runs.
+   */
+  async listAgentRuns(agentId, opts = {}) {
+    return await this.request("GET", `/agents/${agentId}/runs`, {
+      query: { page: opts.page, limit: opts.limit, status: opts.status }
+    });
   }
   /**
-   * Run an agent in streaming mode (SSE) and block until the final `done` event.
+   * Search agent runs (traces) across all agents.
+   *
+   * @param body - Search query and filters.
+   * @returns Search results with matching runs.
+   */
+  async searchAgentRuns(body) {
+    return await this.request("POST", "/agents/runs/search", { json: body });
+  }
+  /**
+   * Get details of a specific agent run.
+   *
+   * @param runId - Run identifier.
+   * @param opts - Optional flags.
+   * @returns Agent run details.
+   */
+  async getAgentRun(runId, opts) {
+    return await this.request("GET", `/agents/runs/${runId}`, opts?.includeStepOutputs ? {
+      query: { include_step_outputs: true }
+    } : void 0);
+  }
+  /**
+   * Delete an agent run.
+   *
+   * @param runId - Run identifier.
+   */
+  async deleteAgentRun(runId) {
+    await this.request("DELETE", `/agents/runs/${runId}`);
+  }
+  /**
+   * Cancel a running agent run.
+   *
+   * @param runId - Run identifier.
+   * @returns Updated run (with cancelled status).
+   */
+  async cancelAgentRun(runId) {
+    return await this.request("POST", `/agents/runs/${runId}/cancel`);
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Agent Runs — Streaming
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Run an agent in streaming mode (SSE) and wait for the final result.
+   *
+   * Consumes the entire SSE stream and returns only the terminal `done` payload.
+   * For real-time event access, use {@link runStreamingAgent} instead.
    *
    * @param agentId - Agent identifier.
-   * @param body - Streaming agent run request payload.
-   * @param opts - Optional timeout + abort signal.
+   * @param body - Streaming run request payload.
+   * @param opts - Timeout and abort signal options.
    * @returns Final agent run payload from the `done` event.
+   * @throws {@link SeclaiStreamingError} If the stream ends before a `done` event.
    */
   async runStreamingAgentAndWait(agentId, body, opts) {
     const url = buildURL(this.baseUrl, `/agents/${agentId}/runs/stream`);
+    const authHdrs = await this.authHeaders();
     const headers = {
       ...this.defaultHeaders,
-      [this.apiKeyHeader]: this.apiKey,
+      ...authHdrs,
       accept: "text/event-stream",
       "content-type": "application/json"
     };
@@ -279,12 +893,9 @@ var Seclai = class {
       timeoutController.abort();
     }, timeoutMs);
     const signal = anySignal([opts?.signal, timeoutController.signal]);
+    let lastSeen;
     try {
-      const init = {
-        method: "POST",
-        headers,
-        body: JSON.stringify(body)
-      };
+      const init = { method: "POST", headers, body: JSON.stringify(body) };
       if (signal) init.signal = signal;
       const response = await this.fetcher(url, init);
       const contentType = response.headers.get("content-type") ?? "";
@@ -321,16 +932,13 @@ var Seclai = class {
       const reader = response.body.getReader();
       const decoder = new TextDecoder();
       let final;
-      let lastSeen;
       const parser = createSseParser((msg) => {
         if (!msg.data) return;
         if (msg.event === "init" || msg.event === "done") {
           try {
             const parsed = JSON.parse(msg.data);
             lastSeen = parsed;
-            if (msg.event === "done") {
-              final = parsed;
-            }
+            if (msg.event === "done") final = parsed;
           } catch {
           }
         }
@@ -345,10 +953,13 @@ var Seclai = class {
       if (lastSeen && lastSeen.status && lastSeen.status !== "pending") {
         return lastSeen;
       }
-      throw new SeclaiError("Stream ended before receiving a 'done' event.");
+      throw new SeclaiStreamingError("Stream ended before receiving a 'done' event.", lastSeen?.run_id);
     } catch (err) {
       if (timedOut) {
-        throw new SeclaiError(`Timed out after ${timeoutMs}ms waiting for streaming agent run to complete.`);
+        throw new SeclaiStreamingError(
+          `Timed out after ${timeoutMs}ms waiting for streaming agent run to complete.`,
+          lastSeen?.run_id
+        );
       }
       throw err;
     } finally {
@@ -356,245 +967,1308 @@ var Seclai = class {
     }
   }
   /**
-   * List agent runs for an agent.
-   *
-   * @param agentId - Agent identifier.
-   * @param opts - Pagination options.
-   * @returns A paginated list of runs.
-   */
-  async listAgentRuns(agentId, opts = {}) {
-    const data = await this.request("GET", `/agents/${agentId}/runs`, {
-      query: { page: opts.page ?? 1, limit: opts.limit ?? 50 }
-    });
-    return data;
-  }
-  async getAgentRun(arg1, arg2, arg3 = {}) {
-    const hasOldSignature = typeof arg2 === "string";
-    const runId = hasOldSignature ? arg2 : arg1;
-    const opts = hasOldSignature ? arg3 : arg2 ?? {};
-    const data = await this.request(
-      "GET",
-      `/agents/runs/${runId}`,
-      opts.includeStepOutputs ? { query: { include_step_outputs: true } } : void 0
-    );
-    return data;
-  }
-  async deleteAgentRun(arg1, arg2) {
-    const runId = arg2 ?? arg1;
-    const data = await this.request("DELETE", `/agents/runs/${runId}`);
-    return data;
-  }
-  /**
-   * Get content detail.
-   *
-   * Fetches a slice of a content version (use `start`/`end` to page through large content).
-   *
-   * @param sourceConnectionContentVersion - Content version identifier.
-   * @param opts - Range options.
-   * @returns Content details for the requested range.
-   */
-  async getContentDetail(sourceConnectionContentVersion, opts = {}) {
-    const data = await this.request(
-      "GET",
-      `/contents/${sourceConnectionContentVersion}`,
-      { query: { start: opts.start ?? 0, end: opts.end ?? 5e3 } }
-    );
-    return data;
-  }
-  /**
-   * Delete a specific content version.
+   * Run an agent in streaming mode and yield each SSE event as it arrives.
    *
-   * @param sourceConnectionContentVersion - Content version identifier.
-   */
-  async deleteContent(sourceConnectionContentVersion) {
-    await this.request("DELETE", `/contents/${sourceConnectionContentVersion}`);
-  }
-  /**
-   * List embeddings for a content version.
+   * This is an `AsyncGenerator` suitable for real-time UIs that want to render
+   * step progress as it happens.
    *
-   * @param sourceConnectionContentVersion - Content version identifier.
-   * @param opts - Pagination options.
-   * @returns A paginated list of embeddings.
-   */
-  async listContentEmbeddings(sourceConnectionContentVersion, opts = {}) {
-    const data = await this.request(
-      "GET",
-      `/contents/${sourceConnectionContentVersion}/embeddings`,
-      { query: { page: opts.page ?? 1, limit: opts.limit ?? 20 } }
-    );
-    return data;
-  }
-  /**
-   * List sources.
+   * @param agentId - Agent identifier.
+   * @param body - Streaming run request payload.
+   * @param opts - Timeout and abort signal options.
+   * @yields {@link AgentRunEvent} for each SSE message.
    *
-   * @param opts - Pagination and filter options.
-   * @returns A paginated list of sources.
+   * @example
+   * ```ts
+   * for await (const event of client.runStreamingAgent("agent-id", { input: "Hello!" })) {
+   *   if (event.event === "done") {
+   *     console.log("Final:", event.data);
+   *   }
+   * }
+   * ```
    */
-  async listSources(opts = {}) {
-    const data = await this.request("GET", "/sources/", {
-      query: {
-        page: opts.page ?? 1,
-        limit: opts.limit ?? 20,
-        sort: opts.sort ?? "created_at",
-        order: opts.order ?? "desc",
-        account_id: opts.accountId ?? void 0
-      }
-    });
-    return data;
-  }
-  /**
-   * Upload a file to a specific source connection.
-    *
-    * Maximum file size: 200 MiB.
-    *
-    * Supported MIME types:
-    * - `application/epub+zip`
-    * - `application/json`
-    * - `application/msword`
-    * - `application/pdf`
-    * - `application/vnd.ms-excel`
-    * - `application/vnd.ms-outlook`
-    * - `application/vnd.ms-powerpoint`
-    * - `application/vnd.openxmlformats-officedocument.presentationml.presentation`
-    * - `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet`
-    * - `application/vnd.openxmlformats-officedocument.wordprocessingml.document`
-    * - `application/xml`
-    * - `application/zip`
-    * - `audio/flac`, `audio/mp4`, `audio/mpeg`, `audio/ogg`, `audio/wav`
-    * - `image/bmp`, `image/gif`, `image/jpeg`, `image/png`, `image/tiff`, `image/webp`
-    * - `text/csv`, `text/html`, `text/markdown`, `text/x-markdown`, `text/plain`, `text/xml`
-    * - `video/mp4`, `video/quicktime`, `video/x-msvideo`
-    *
-    * Notes:
-    * - If `mimeType` is omitted, the upload is typically sent as `application/octet-stream`.
-    *   In that case, the server attempts to infer the type from the uploaded filename/extension,
-    *   so prefer providing `fileName` with a meaningful extension (e.g. `"recording.mp3"`).
-   *
-   * @param sourceConnectionId - Source connection identifier.
-   * @param opts - File payload and optional metadata.
-   * @param opts.file - File payload as a `Blob`, `Uint8Array`, or `ArrayBuffer`.
-   * @param opts.title - Optional title for the uploaded file.
-   * @param opts.metadata - Optional metadata object. This is sent as a JSON string form field named `metadata`.
-   *   Example: `{ category: "docs", author: "Ada" }`.
-   * @param opts.fileName - Optional filename to send with the upload.
-   * @param opts.mimeType - Optional MIME type to attach to the upload.
-   * @returns Upload response details.
-   */
-  async uploadFileToSource(sourceConnectionId, opts) {
-    const url = buildURL(this.baseUrl, `/sources/${sourceConnectionId}/upload`);
+  async *runStreamingAgent(agentId, body, opts) {
+    const url = buildURL(this.baseUrl, `/agents/${agentId}/runs/stream`);
+    const authHdrs = await this.authHeaders();
     const headers = {
       ...this.defaultHeaders,
-      [this.apiKeyHeader]: this.apiKey
+      ...authHdrs,
+      accept: "text/event-stream",
+      "content-type": "application/json"
     };
-    const form = new FormData();
-    let blob;
-    if (opts.file instanceof Blob) {
-      blob = opts.file;
-    } else if (opts.file instanceof ArrayBuffer) {
-      const blobOpts = opts.mimeType ? { type: opts.mimeType } : void 0;
-      blob = new Blob([new Uint8Array(opts.file)], blobOpts);
-    } else {
-      const blobOpts = opts.mimeType ? { type: opts.mimeType } : void 0;
-      blob = new Blob([opts.file], blobOpts);
-    }
-    const fileName = opts.fileName ?? "upload";
-    form.set("file", blob, fileName);
-    if (opts.title !== void 0) {
-      form.set("title", opts.title);
-    }
-    if (opts.metadata !== void 0) {
-      form.set("metadata", JSON.stringify(opts.metadata));
-    }
-    const response = await this.fetcher(url, {
-      method: "POST",
-      headers,
-      body: form
-    });
-    if (!response.ok) {
-      const responseText = await safeText(response);
-      if (response.status === 422) {
-        const validation = await safeJson(response);
-        throw new SeclaiAPIValidationError({
-          message: "Validation error",
+    const timeoutMs = opts?.timeoutMs ?? 6e4;
+    const timeoutController = new AbortController();
+    let timedOut = false;
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      timeoutController.abort();
+    }, timeoutMs);
+    const signal = anySignal([opts?.signal, timeoutController.signal]);
+    try {
+      const init = { method: "POST", headers, body: JSON.stringify(body) };
+      if (signal) init.signal = signal;
+      const response = await this.fetcher(url, init);
+      const contentType = response.headers.get("content-type") ?? "";
+      const isJson = contentType.includes("application/json");
+      if (!response.ok) {
+        const responseText = await safeText(response);
+        if (response.status === 422) {
+          const validation = await safeJson(response);
+          throw new SeclaiAPIValidationError({
+            message: "Validation error",
+            statusCode: response.status,
+            method: "POST",
+            url: url.toString(),
+            responseText,
+            validationError: validation
+          });
+        }
+        throw new SeclaiAPIStatusError({
+          message: `Request failed with status ${response.status}`,
           statusCode: response.status,
           method: "POST",
           url: url.toString(),
-          responseText,
-          validationError: validation
+          responseText
         });
       }
-      throw new SeclaiAPIStatusError({
-        message: `Request failed with status ${response.status}`,
-        statusCode: response.status,
-        method: "POST",
-        url: url.toString(),
-        responseText
+      if (isJson) {
+        const data = await response.json();
+        yield { event: "done", data };
+        return;
+      }
+      if (!response.body) {
+        throw new SeclaiConfigurationError(
+          "Streaming response body is not available in this environment."
+        );
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      const events = [];
+      const parser = createSseParser((msg) => {
+        if (!msg.data) return;
+        let data;
+        try {
+          data = JSON.parse(msg.data);
+        } catch {
+          data = msg.data;
+        }
+        events.push({ event: msg.event ?? "message", data });
       });
+      while (true) {
+        const { value, done } = await reader.read();
+        if (value) parser.feed(decoder.decode(value, { stream: true }));
+        while (events.length > 0) {
+          yield events.shift();
+        }
+        if (done) break;
+      }
+      parser.end();
+      while (events.length > 0) {
+        yield events.shift();
+      }
+    } catch (err) {
+      if (timedOut) {
+        throw new SeclaiStreamingError(
+          `Timed out after ${timeoutMs}ms waiting for streaming agent run to complete.`
+        );
+      }
+      throw err;
+    } finally {
+      clearTimeout(timeoutId);
     }
-    return await response.json();
   }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Agent Runs — Polling
+  // ═══════════════════════════════════════════════════════════════════════════
   /**
-   * Upload a new file and replace the content backing an existing content version.
+   * Run an agent and poll until it reaches a terminal status.
    *
-   * This endpoint is useful when you need to correct or update an uploaded document while keeping
-   * references stable (the content version ID stays the same).
+   * This is useful in environments where SSE streaming is unavailable.
    *
-   * Notes:
-   * - `metadata` is sent as a JSON string form field named `metadata`.
-   * - `title` is a convenience field and may be merged into `metadata.title` by the server.
+   * @param agentId - Agent identifier.
+   * @param body - Run request payload.
+   * @param opts - Polling configuration and abort signal.
+   * @returns The terminal agent run.
+   * @throws {@link SeclaiStreamingError} On timeout.
    */
-  async uploadFileToContent(sourceConnectionContentVersion, opts) {
-    const url = buildURL(this.baseUrl, `/contents/${sourceConnectionContentVersion}/upload`);
-    const headers = {
-      ...this.defaultHeaders,
-      [this.apiKeyHeader]: this.apiKey
-    };
-    const form = new FormData();
-    let blob;
-    if (opts.file instanceof Blob) {
-      blob = opts.file;
-    } else if (opts.file instanceof ArrayBuffer) {
-      const blobOpts = opts.mimeType ? { type: opts.mimeType } : void 0;
-      blob = new Blob([new Uint8Array(opts.file)], blobOpts);
-    } else {
-      const blobOpts = opts.mimeType ? { type: opts.mimeType } : void 0;
-      blob = new Blob([opts.file], blobOpts);
-    }
-    const fileName = opts.fileName ?? "upload";
-    form.set("file", blob, fileName);
-    if (opts.title !== void 0) {
-      form.set("title", opts.title);
-    }
-    if (opts.metadata !== void 0) {
-      form.set("metadata", JSON.stringify(opts.metadata));
-    }
-    const response = await this.fetcher(url, {
-      method: "POST",
-      headers,
-      body: form
-    });
-    if (!response.ok) {
-      const responseText = await safeText(response);
-      if (response.status === 422) {
-        const validation = await safeJson(response);
-        throw new SeclaiAPIValidationError({
-          message: "Validation error",
-          statusCode: response.status,
-          method: "POST",
-          url: url.toString(),
-          responseText,
-          validationError: validation
-        });
+  async runAgentAndPoll(agentId, body, opts) {
+    const pollInterval = opts?.pollIntervalMs ?? 2e3;
+    const timeout = opts?.timeoutMs ?? 3e5;
+    const startTime = Date.now();
+    const run = await this.runAgent(agentId, body);
+    const runId = run.id ?? run.run_id;
+    if (!runId) throw new SeclaiError("Agent run response did not contain an id.");
+    while (true) {
+      if (opts?.signal?.aborted) throw new SeclaiError("Polling aborted.");
+      if (Date.now() - startTime > timeout) {
+        throw new SeclaiStreamingError(`Polling timed out after ${timeout}ms.`, runId);
+      }
+      await new Promise((r) => setTimeout(r, pollInterval));
+      const current = await this.getAgentRun(
+        runId,
+        opts?.includeStepOutputs ? { includeStepOutputs: true } : void 0
+      );
+      const status = current.status;
+      if (status === "completed" || status === "failed" || status === "cancelled") {
+        return current;
       }
-      throw new SeclaiAPIStatusError({
-        message: `Request failed with status ${response.status}`,
-        statusCode: response.status,
-        method: "POST",
-        url: url.toString(),
-        responseText
-      });
     }
-    return await response.json();
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Agent Run Evaluation Results
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * List evaluation results for a specific agent run.
+   *
+   * @param agentId - Agent identifier.
+   * @param runId - Run identifier.
+   * @param opts - Pagination options.
+   * @returns Paginated list of evaluation results.
+   */
+  async listRunEvaluationResults(agentId, runId, opts = {}) {
+    return await this.request("GET", `/agents/${agentId}/runs/${runId}/evaluation-results`, {
+      query: { page: opts.page, limit: opts.limit }
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Agent Input Uploads
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Upload a file to use as input for a `dynamic_input` agent run.
+   *
+   * After uploading, poll {@link getAgentInputUploadStatus} until `status` is `ready`,
+   * then pass `input_upload_id` to {@link runAgent}.
+   *
+   * @param agentId - Agent identifier.
+   * @param opts - File payload and optional metadata.
+   * @returns Upload response with the upload ID and status.
+   */
+  async uploadAgentInput(agentId, opts) {
+    return await this.uploadFile(`/agents/${agentId}/upload-input`, opts);
+  }
+  /**
+   * Get the status of an agent input upload.
+   *
+   * @param agentId - Agent identifier.
+   * @param uploadId - Upload identifier.
+   * @returns Upload status and metadata.
+   */
+  async getAgentInputUploadStatus(agentId, uploadId) {
+    return await this.request("GET", `/agents/${agentId}/input-uploads/${uploadId}`);
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Agent AI Assistant (Steps Generation)
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Generate agent workflow steps from natural language using AI.
+   *
+   * @param agentId - Agent identifier.
+   * @param body - Generation request with user instructions.
+   * @returns AI-generated step configuration.
+   */
+  async generateAgentSteps(agentId, body) {
+    return await this.request("POST", `/agents/${agentId}/ai-assistant/generate-steps`, { json: body });
+  }
+  /**
+   * Generate a single step configuration using AI.
+   *
+   * @param agentId - Agent identifier.
+   * @param body - Step config generation request.
+   * @returns AI-generated step config.
+   */
+  async generateStepConfig(agentId, body) {
+    return await this.request("POST", `/agents/${agentId}/ai-assistant/step-config`, { json: body });
+  }
+  /**
+   * Get AI conversation history for an agent.
+   *
+   * @param agentId - Agent identifier.
+   * @returns Conversation history.
+   */
+  async getAgentAiConversationHistory(agentId) {
+    return await this.request("GET", `/agents/${agentId}/ai-assistant/conversations`);
+  }
+  /**
+   * Mark an AI suggestion as accepted or rejected.
+   *
+   * @param agentId - Agent identifier.
+   * @param conversationId - Conversation turn identifier.
+   * @param body - Mark request payload.
+   */
+  async markAgentAiSuggestion(agentId, conversationId, body) {
+    await this.request("PATCH", `/agents/${agentId}/ai-assistant/${conversationId}`, { json: body });
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Agent Evaluation Criteria
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * List evaluation criteria for an agent.
+   *
+   * @param agentId - Agent identifier.
+   * @param opts - Pagination options.
+   */
+  async listEvaluationCriteria(agentId, opts = {}) {
+    return await this.request("GET", `/agents/${agentId}/evaluation-criteria`, {
+      query: { page: opts.page, limit: opts.limit }
+    });
+  }
+  /**
+   * Create evaluation criteria for an agent.
+   *
+   * @param agentId - Agent identifier.
+   * @param body - Criteria definition.
+   * @returns Created evaluation criteria.
+   */
+  async createEvaluationCriteria(agentId, body) {
+    return await this.request("POST", `/agents/${agentId}/evaluation-criteria`, { json: body });
+  }
+  /**
+   * Get a single evaluation criteria by ID.
+   *
+   * @param criteriaId - Criteria identifier.
+   * @returns Evaluation criteria details.
+   */
+  async getEvaluationCriteria(criteriaId) {
+    return await this.request("GET", `/agents/evaluation-criteria/${criteriaId}`);
+  }
+  /**
+   * Update an evaluation criteria.
+   *
+   * @param criteriaId - Criteria identifier.
+   * @param body - Fields to update.
+   * @returns Updated evaluation criteria.
+   */
+  async updateEvaluationCriteria(criteriaId, body) {
+    return await this.request("PATCH", `/agents/evaluation-criteria/${criteriaId}`, { json: body });
+  }
+  /**
+   * Delete an evaluation criteria and all associated results.
+   *
+   * @param criteriaId - Criteria identifier.
+   */
+  async deleteEvaluationCriteria(criteriaId) {
+    await this.request("DELETE", `/agents/evaluation-criteria/${criteriaId}`);
+  }
+  /**
+   * Get the evaluation summary for a specific criteria.
+   *
+   * @param criteriaId - Criteria identifier.
+   * @returns Evaluation result summary.
+   */
+  async getEvaluationCriteriaSummary(criteriaId) {
+    return await this.request("GET", `/agents/evaluation-criteria/${criteriaId}/summary`);
+  }
+  /**
+   * List evaluation results for a specific criteria.
+   *
+   * @param criteriaId - Criteria identifier.
+   * @param opts - Pagination options.
+   */
+  async listEvaluationResults(criteriaId, opts = {}) {
+    return await this.request("GET", `/agents/evaluation-criteria/${criteriaId}/results`, {
+      query: { page: opts.page, limit: opts.limit }
+    });
+  }
+  /**
+   * Create a manual evaluation result for a criteria.
+   *
+   * @param criteriaId - Criteria identifier.
+   * @param body - Evaluation result payload.
+   * @returns Created evaluation result.
+   */
+  async createEvaluationResult(criteriaId, body) {
+    return await this.request("POST", `/agents/evaluation-criteria/${criteriaId}/results`, { json: body });
+  }
+  /**
+   * List runs compatible with a specific evaluation criteria.
+   *
+   * @param criteriaId - Criteria identifier.
+   * @param opts - Pagination options.
+   */
+  async listCompatibleRuns(criteriaId, opts = {}) {
+    return await this.request("GET", `/agents/evaluation-criteria/${criteriaId}/compatible-runs`, {
+      query: { page: opts.page, limit: opts.limit }
+    });
+  }
+  /**
+   * Test a draft evaluation criteria without persisting it.
+   *
+   * @param agentId - Agent identifier.
+   * @param body - Draft evaluation to test.
+   * @returns Test evaluation response.
+   */
+  async testDraftEvaluation(agentId, body) {
+    return await this.request("POST", `/agents/${agentId}/evaluation-criteria/test-draft`, { json: body });
+  }
+  /**
+   * List all evaluation results for an agent.
+   *
+   * @param agentId - Agent identifier.
+   * @param opts - Pagination options.
+   */
+  async listAgentEvaluationResults(agentId, opts = {}) {
+    return await this.request("GET", `/agents/${agentId}/evaluation-results`, {
+      query: { page: opts.page, limit: opts.limit }
+    });
+  }
+  /**
+   * List evaluation run summaries for an agent.
+   *
+   * @param agentId - Agent identifier.
+   * @param opts - Pagination options.
+   */
+  async listEvaluationRuns(agentId, opts = {}) {
+    return await this.request("GET", `/agents/${agentId}/evaluation-runs`, {
+      query: { page: opts.page, limit: opts.limit }
+    });
+  }
+  /**
+   * Get a summary of non-manual evaluations across an agent's runs.
+   *
+   * @param agentId - Agent identifier.
+   */
+  async getNonManualEvaluationSummary(agentId) {
+    return await this.request("GET", "/agents/evaluation-results/non-manual-summary", {
+      query: { agent_id: agentId }
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Knowledge Bases
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * List knowledge bases.
+   *
+   * @param opts - Pagination and sorting options.
+   * @returns Paginated list of knowledge bases.
+   */
+  async listKnowledgeBases(opts = {}) {
+    return await this.request("GET", "/knowledge_bases", {
+      query: { page: opts.page, limit: opts.limit, sort: opts.sort, order: opts.order }
+    });
+  }
+  /**
+   * Create a new knowledge base.
+   *
+   * @param body - Knowledge base configuration.
+   * @returns The created knowledge base.
+   */
+  async createKnowledgeBase(body) {
+    return await this.request("POST", "/knowledge_bases", { json: body });
+  }
+  /**
+   * Get a knowledge base by ID.
+   *
+   * @param knowledgeBaseId - Knowledge base identifier.
+   * @returns Knowledge base details.
+   */
+  async getKnowledgeBase(knowledgeBaseId) {
+    return await this.request("GET", `/knowledge_bases/${knowledgeBaseId}`);
+  }
+  /**
+   * Update a knowledge base.
+   *
+   * @param knowledgeBaseId - Knowledge base identifier.
+   * @param body - Fields to update.
+   * @returns Updated knowledge base.
+   */
+  async updateKnowledgeBase(knowledgeBaseId, body) {
+    return await this.request("PUT", `/knowledge_bases/${knowledgeBaseId}`, { json: body });
+  }
+  /**
+   * Delete a knowledge base.
+   *
+   * @param knowledgeBaseId - Knowledge base identifier.
+   */
+  async deleteKnowledgeBase(knowledgeBaseId) {
+    await this.request("DELETE", `/knowledge_bases/${knowledgeBaseId}`);
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Memory Banks
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * List memory banks.
+   *
+   * @param opts - Pagination and sorting options.
+   * @returns Paginated list of memory banks.
+   */
+  async listMemoryBanks(opts = {}) {
+    return await this.request("GET", "/memory_banks", {
+      query: { page: opts.page, limit: opts.limit, sort: opts.sort, order: opts.order }
+    });
+  }
+  /**
+   * Create a new memory bank.
+   *
+   * Memory banks give agents persistent memory across conversations.
+   * Types: `conversation` (chat-style history) or `general` (flat factual entries).
+   *
+   * @param body - Memory bank configuration.
+   * @returns The created memory bank.
+   */
+  async createMemoryBank(body) {
+    return await this.request("POST", "/memory_banks", { json: body });
+  }
+  /**
+   * Get a memory bank by ID.
+   *
+   * @param memoryBankId - Memory bank identifier.
+   * @returns Memory bank details.
+   */
+  async getMemoryBank(memoryBankId) {
+    return await this.request("GET", `/memory_banks/${memoryBankId}`);
+  }
+  /**
+   * Update a memory bank.
+   *
+   * @param memoryBankId - Memory bank identifier.
+   * @param body - Fields to update.
+   * @returns Updated memory bank.
+   */
+  async updateMemoryBank(memoryBankId, body) {
+    return await this.request("PUT", `/memory_banks/${memoryBankId}`, { json: body });
+  }
+  /**
+   * Delete a memory bank.
+   *
+   * @param memoryBankId - Memory bank identifier.
+   */
+  async deleteMemoryBank(memoryBankId) {
+    await this.request("DELETE", `/memory_banks/${memoryBankId}`);
+  }
+  /**
+   * Get agents that are using a specific memory bank.
+   *
+   * @param memoryBankId - Memory bank identifier.
+   */
+  async getAgentsUsingMemoryBank(memoryBankId) {
+    return await this.request("GET", `/memory_banks/${memoryBankId}/agents`);
+  }
+  /**
+   * Get stats for a memory bank.
+   *
+   * @param memoryBankId - Memory bank identifier.
+   */
+  async getMemoryBankStats(memoryBankId) {
+    return await this.request("GET", `/memory_banks/${memoryBankId}/stats`);
+  }
+  /**
+   * Compact a memory bank (trigger compaction).
+   *
+   * @param memoryBankId - Memory bank identifier.
+   */
+  async compactMemoryBank(memoryBankId) {
+    await this.request("POST", `/memory_banks/${memoryBankId}/compact`);
+  }
+  /**
+   * Delete a memory bank source.
+   *
+   * @param memoryBankId - Memory bank identifier.
+   */
+  async deleteMemoryBankSource(memoryBankId) {
+    await this.request("DELETE", `/memory_banks/${memoryBankId}/source`);
+  }
+  /**
+   * Test compaction for a specific memory bank.
+   *
+   * @param memoryBankId - Memory bank identifier.
+   * @param body - Test compaction request.
+   */
+  async testMemoryBankCompaction(memoryBankId, body) {
+    return await this.request("POST", `/memory_banks/${memoryBankId}/test-compaction`, { json: body });
+  }
+  /**
+   * Test compaction prompt standalone (not tied to a specific memory bank).
+   *
+   * @param body - Standalone compaction test request.
+   */
+  async testCompactionPromptStandalone(body) {
+    return await this.request("POST", "/memory_banks/test-compaction", { json: body });
+  }
+  /**
+   * List available memory bank templates.
+   */
+  async listMemoryBankTemplates() {
+    return await this.request("GET", "/memory_banks/templates");
+  }
+  // ─── Memory Bank AI Assistant ──────────────────────────────────────────────
+  /**
+   * Generate memory bank configuration using AI.
+   *
+   * @param body - AI assistant request with user instructions.
+   * @returns AI-generated memory bank config.
+   */
+  async generateMemoryBankConfig(body) {
+    return await this.request("POST", "/memory_banks/ai-assistant", { json: body });
+  }
+  /**
+   * Get the last AI conversation for memory banks.
+   */
+  async getMemoryBankAiLastConversation() {
+    return await this.request("GET", "/memory_banks/ai-assistant/last-conversation");
+  }
+  /**
+   * Accept a memory bank AI suggestion.
+   *
+   * @param conversationId - Conversation identifier.
+   * @param body - Accept request payload.
+   */
+  async acceptMemoryBankAiSuggestion(conversationId, body) {
+    return await this.request("PATCH", `/memory_banks/ai-assistant/${conversationId}`, { json: body });
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Sources
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * List sources.
+   *
+   * @param opts - Pagination, sorting, and filter options.
+   * @returns Paginated list of sources.
+   */
+  async listSources(opts = {}) {
+    return await this.request("GET", "/sources/", {
+      query: {
+        page: opts.page,
+        limit: opts.limit,
+        sort: opts.sort,
+        order: opts.order,
+        account_id: opts.accountId
+      }
+    });
+  }
+  /**
+   * Create a new content source.
+   *
+   * @param body - Source configuration (type, name, knowledge base link, etc.).
+   * @returns The created source.
+   */
+  async createSource(body) {
+    return await this.request("POST", "/sources", { json: body });
+  }
+  /**
+   * Get a source by ID.
+   *
+   * @param sourceId - Source connection identifier.
+   * @returns Source details.
+   */
+  async getSource(sourceId) {
+    return await this.request("GET", `/sources/${sourceId}`);
+  }
+  /**
+   * Update a source.
+   *
+   * @param sourceId - Source connection identifier.
+   * @param body - Fields to update.
+   * @returns Updated source.
+   */
+  async updateSource(sourceId, body) {
+    return await this.request("PUT", `/sources/${sourceId}`, { json: body });
+  }
+  /**
+   * Delete a source.
+   *
+   * @param sourceId - Source connection identifier.
+   */
+  async deleteSource(sourceId) {
+    await this.request("DELETE", `/sources/${sourceId}`);
+  }
+  /**
+   * Upload a file to a source.
+   *
+   * Maximum file size: 200 MiB. Supports text, PDF, DOCX, audio, video, images, and more.
+   * If `mimeType` is omitted, it will be inferred from the `fileName` extension when possible.
+   *
+   * @param sourceId - Source connection identifier.
+   * @param opts - File payload and optional metadata.
+   * @returns Upload response details.
+   */
+  async uploadFileToSource(sourceId, opts) {
+    return await this.uploadFile(`/sources/${sourceId}/upload`, opts);
+  }
+  /**
+   * Upload inline text to a source.
+   *
+   * @param sourceId - Source connection identifier.
+   * @param body - Inline text upload payload.
+   * @returns Upload response.
+   */
+  async uploadInlineTextToSource(sourceId, body) {
+    return await this.request("POST", `/sources/${sourceId}`, { json: body });
+  }
+  // ─── Source Exports ────────────────────────────────────────────────────────
+  /**
+   * List exports for a source.
+   *
+   * @param sourceId - Source connection identifier.
+   * @param opts - Pagination options.
+   * @returns Paginated list of exports.
+   */
+  async listSourceExports(sourceId, opts = {}) {
+    return await this.request("GET", `/sources/${sourceId}/exports`, {
+      query: { page: opts.page, limit: opts.limit }
+    });
+  }
+  /**
+   * Create a source data export.
+   *
+   * @param sourceId - Source connection identifier.
+   * @param body - Export configuration (format, etc.).
+   * @returns Export response with job status.
+   */
+  async createSourceExport(sourceId, body) {
+    return await this.request("POST", `/sources/${sourceId}/exports`, { json: body });
+  }
+  /**
+   * Get a specific source export.
+   *
+   * @param sourceId - Source connection identifier.
+   * @param exportId - Export identifier.
+   * @returns Export details.
+   */
+  async getSourceExport(sourceId, exportId) {
+    return await this.request("GET", `/sources/${sourceId}/exports/${exportId}`);
+  }
+  /**
+   * Cancel a source export.
+   *
+   * @param sourceId - Source connection identifier.
+   * @param exportId - Export identifier.
+   */
+  async cancelSourceExport(sourceId, exportId) {
+    return await this.request("POST", `/sources/${sourceId}/exports/${exportId}/cancel`);
+  }
+  /**
+   * Download a source export file.
+   *
+   * Returns the raw `Response` so you can stream or save the binary data.
+   *
+   * @param sourceId - Source connection identifier.
+   * @param exportId - Export identifier.
+   * @returns Raw response with the export file.
+   */
+  async downloadSourceExport(sourceId, exportId) {
+    return await this.requestRaw("GET", `/sources/${sourceId}/exports/${exportId}/download`);
+  }
+  /**
+   * Estimate a source export.
+   *
+   * @param sourceId - Source connection identifier.
+   * @param body - Estimate request.
+   * @returns Export estimate.
+   */
+  async estimateSourceExport(sourceId, body) {
+    return await this.request("POST", `/sources/${sourceId}/exports/estimate`, { json: body });
+  }
+  /**
+   * Delete a source export.
+   *
+   * @param sourceId - Source connection identifier.
+   * @param exportId - Export identifier.
+   */
+  async deleteSourceExport(sourceId, exportId) {
+    await this.request("DELETE", `/sources/${sourceId}/exports/${exportId}`);
+  }
+  // ─── Source Embedding Migrations ───────────────────────────────────────────
+  /**
+   * Get the status of a source embedding migration.
+   *
+   * @param sourceId - Source connection identifier.
+   * @returns Migration status.
+   */
+  async getSourceEmbeddingMigration(sourceId) {
+    return await this.request("GET", `/sources/${sourceId}/embedding-migration`);
+  }
+  /**
+   * Start a source embedding migration.
+   *
+   * @param sourceId - Source connection identifier.
+   * @param body - Migration configuration (target embedding model, etc.).
+   * @returns Migration status.
+   */
+  async startSourceEmbeddingMigration(sourceId, body) {
+    return await this.request("POST", `/sources/${sourceId}/embedding-migration`, { json: body });
+  }
+  /**
+   * Cancel a source embedding migration.
+   *
+   * @param sourceId - Source connection identifier.
+   * @returns Updated migration status.
+   */
+  async cancelSourceEmbeddingMigration(sourceId) {
+    return await this.request("POST", `/sources/${sourceId}/embedding-migration/cancel`);
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Content
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Get content detail for a specific content version.
+   *
+   * @param contentVersionId - Content version identifier.
+   * @param opts - Range options for slicing large content.
+   * @returns Content details for the requested range.
+   */
+  async getContentDetail(contentVersionId, opts = {}) {
+    return await this.request("GET", `/contents/${contentVersionId}`, {
+      query: { start: opts.start ?? 0, end: opts.end ?? 5e3 }
+    });
+  }
+  /**
+   * Replace content with inline text.
+   *
+   * @param contentVersionId - Content version identifier.
+   * @param body - Inline text replacement payload.
+   */
+  async replaceContentWithInlineText(contentVersionId, body) {
+    return await this.request("PUT", `/contents/${contentVersionId}`, { json: body });
+  }
+  /**
+   * Delete a specific content version.
+   *
+   * @param contentVersionId - Content version identifier.
+   */
+  async deleteContent(contentVersionId) {
+    await this.request("DELETE", `/contents/${contentVersionId}`);
+  }
+  /**
+   * List embeddings for a content version.
+   *
+   * @param contentVersionId - Content version identifier.
+   * @param opts - Pagination options.
+   * @returns Paginated list of embeddings.
+   */
+  async listContentEmbeddings(contentVersionId, opts = {}) {
+    return await this.request("GET", `/contents/${contentVersionId}/embeddings`, {
+      query: { page: opts.page ?? 1, limit: opts.limit ?? 20 }
+    });
+  }
+  /**
+   * Upload a file to replace content for an existing content version.
+   *
+   * @param contentVersionId - Content version identifier.
+   * @param opts - File payload and optional metadata.
+   * @returns Upload response.
+   */
+  async uploadFileToContent(contentVersionId, opts) {
+    return await this.uploadFile(`/contents/${contentVersionId}/upload`, opts);
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Solutions
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * List solutions.
+   *
+   * @param opts - Pagination and sorting options.
+   * @returns Paginated list of solutions.
+   */
+  async listSolutions(opts = {}) {
+    return await this.request("GET", "/solutions", {
+      query: { page: opts.page, limit: opts.limit, sort: opts.sort, order: opts.order }
+    });
+  }
+  /**
+   * Create a new solution.
+   *
+   * @param body - Solution configuration.
+   * @returns The created solution.
+   */
+  async createSolution(body) {
+    return await this.request("POST", "/solutions", { json: body });
+  }
+  /**
+   * Get a solution by ID.
+   *
+   * @param solutionId - Solution identifier.
+   * @returns Solution details.
+   */
+  async getSolution(solutionId) {
+    return await this.request("GET", `/solutions/${solutionId}`);
+  }
+  /**
+   * Update a solution.
+   *
+   * @param solutionId - Solution identifier.
+   * @param body - Fields to update.
+   * @returns Updated solution.
+   */
+  async updateSolution(solutionId, body) {
+    return await this.request("PATCH", `/solutions/${solutionId}`, { json: body });
+  }
+  /**
+   * Delete a solution.
+   *
+   * @param solutionId - Solution identifier.
+   */
+  async deleteSolution(solutionId) {
+    await this.request("DELETE", `/solutions/${solutionId}`);
+  }
+  // ─── Solution Resource Linking ─────────────────────────────────────────────
+  /**
+   * Link agents to a solution.
+   *
+   * @param solutionId - Solution identifier.
+   * @param body - Resource IDs to link.
+   * @returns Updated solution.
+   */
+  async linkAgentsToSolution(solutionId, body) {
+    return await this.request("POST", `/solutions/${solutionId}/agents`, { json: body });
+  }
+  /**
+   * Unlink agents from a solution.
+   *
+   * @param solutionId - Solution identifier.
+   * @param body - Resource IDs to unlink.
+   * @returns Updated solution.
+   */
+  async unlinkAgentsFromSolution(solutionId, body) {
+    return await this.request("DELETE", `/solutions/${solutionId}/agents`, { json: body });
+  }
+  /**
+   * Link knowledge bases to a solution.
+   *
+   * @param solutionId - Solution identifier.
+   * @param body - Resource IDs to link.
+   * @returns Updated solution.
+   */
+  async linkKnowledgeBasesToSolution(solutionId, body) {
+    return await this.request("POST", `/solutions/${solutionId}/knowledge-bases`, { json: body });
+  }
+  /**
+   * Unlink knowledge bases from a solution.
+   *
+   * @param solutionId - Solution identifier.
+   * @param body - Resource IDs to unlink.
+   * @returns Updated solution.
+   */
+  async unlinkKnowledgeBasesFromSolution(solutionId, body) {
+    return await this.request("DELETE", `/solutions/${solutionId}/knowledge-bases`, { json: body });
+  }
+  /**
+   * Link source connections to a solution.
+   *
+   * @param solutionId - Solution identifier.
+   * @param body - Resource IDs to link.
+   * @returns Updated solution.
+   */
+  async linkSourceConnectionsToSolution(solutionId, body) {
+    return await this.request("POST", `/solutions/${solutionId}/source-connections`, { json: body });
+  }
+  /**
+   * Unlink source connections from a solution.
+   *
+   * @param solutionId - Solution identifier.
+   * @param body - Resource IDs to unlink.
+   * @returns Updated solution.
+   */
+  async unlinkSourceConnectionsFromSolution(solutionId, body) {
+    return await this.request("DELETE", `/solutions/${solutionId}/source-connections`, { json: body });
+  }
+  // ─── Solution Conversations ────────────────────────────────────────────────
+  /**
+   * List conversations for a solution.
+   *
+   * @param solutionId - Solution identifier.
+   * @returns List of conversations.
+   */
+  async listSolutionConversations(solutionId) {
+    return await this.request("GET", `/solutions/${solutionId}/conversations`);
+  }
+  /**
+   * Add a conversation turn to a solution.
+   *
+   * @param solutionId - Solution identifier.
+   * @param body - Conversation turn payload.
+   * @returns Updated conversation.
+   */
+  async addSolutionConversationTurn(solutionId, body) {
+    return await this.request("POST", `/solutions/${solutionId}/conversations`, { json: body });
+  }
+  /**
+   * Mark a conversation turn (e.g. accepted/rejected).
+   *
+   * @param solutionId - Solution identifier.
+   * @param conversationId - Conversation identifier.
+   * @param body - Mark payload.
+   */
+  async markSolutionConversationTurn(solutionId, conversationId, body) {
+    await this.request("PATCH", `/solutions/${solutionId}/conversations/${conversationId}`, { json: body });
+  }
+  // ─── Solution AI Assistant ─────────────────────────────────────────────────
+  /**
+   * Generate a solution AI plan.
+   *
+   * @param solutionId - Solution identifier.
+   * @param body - Generation request.
+   * @returns AI-generated plan.
+   */
+  async generateSolutionAiPlan(solutionId, body) {
+    return await this.request("POST", `/solutions/${solutionId}/ai-assistant/generate`, { json: body });
+  }
+  /**
+   * Generate a knowledge base configuration via solution AI.
+   *
+   * @param solutionId - Solution identifier.
+   * @param body - Generation request.
+   * @returns AI-generated knowledge base config.
+   */
+  async generateSolutionAiKnowledgeBase(solutionId, body) {
+    return await this.request("POST", `/solutions/${solutionId}/ai-assistant/knowledge-base`, { json: body });
+  }
+  /**
+   * Generate a source configuration via solution AI.
+   *
+   * @param solutionId - Solution identifier.
+   * @param body - Generation request.
+   * @returns AI-generated source config.
+   */
+  async generateSolutionAiSource(solutionId, body) {
+    return await this.request("POST", `/solutions/${solutionId}/ai-assistant/source`, { json: body });
+  }
+  /**
+   * Accept a solution AI plan.
+   *
+   * @param solutionId - Solution identifier.
+   * @param conversationId - Conversation identifier.
+   * @param body - Accept request.
+   * @returns Acceptance result with executed actions.
+   */
+  async acceptSolutionAiPlan(solutionId, conversationId, body) {
+    return await this.request("POST", `/solutions/${solutionId}/ai-assistant/${conversationId}/accept`, { json: body });
+  }
+  /**
+   * Decline a solution AI plan.
+   *
+   * @param solutionId - Solution identifier.
+   * @param conversationId - Conversation identifier.
+   */
+  async declineSolutionAiPlan(solutionId, conversationId) {
+    await this.request("POST", `/solutions/${solutionId}/ai-assistant/${conversationId}/decline`);
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Governance — AI Assistant
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Generate governance policy suggestions using AI.
+   *
+   * @param body - AI governance request.
+   * @returns AI-generated governance suggestions.
+   */
+  async generateGovernanceAiPlan(body) {
+    return await this.request("POST", "/governance/ai-assistant", { json: body });
+  }
+  /**
+   * List governance AI conversations.
+   */
+  async listGovernanceAiConversations() {
+    return await this.request("GET", "/governance/ai-assistant/conversations");
+  }
+  /**
+   * Accept a governance AI plan.
+   *
+   * @param conversationId - Conversation identifier.
+   * @returns Acceptance result.
+   */
+  async acceptGovernanceAiPlan(conversationId) {
+    return await this.request("POST", `/governance/ai-assistant/${conversationId}/accept`);
+  }
+  /**
+   * Decline a governance AI plan.
+   *
+   * @param conversationId - Conversation identifier.
+   */
+  async declineGovernanceAiPlan(conversationId) {
+    await this.request("POST", `/governance/ai-assistant/${conversationId}/decline`);
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Alerts
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * List alerts.
+   *
+   * @param opts - Pagination and filter options.
+   * @returns Paginated list of alerts.
+   */
+  async listAlerts(opts = {}) {
+    return await this.request("GET", "/alerts", {
+      query: { page: opts.page, limit: opts.limit, status: opts.status, severity: opts.severity }
+    });
+  }
+  /**
+   * Get alert details by ID.
+   *
+   * @param alertId - Alert identifier.
+   * @returns Alert details.
+   */
+  async getAlert(alertId) {
+    return await this.request("GET", `/alerts/${alertId}`);
+  }
+  /**
+   * Change the status of an alert.
+   *
+   * @param alertId - Alert identifier.
+   * @param body - Status change request.
+   */
+  async changeAlertStatus(alertId, body) {
+    return await this.request("POST", `/alerts/${alertId}/status`, { json: body });
+  }
+  /**
+   * Add a comment to an alert.
+   *
+   * @param alertId - Alert identifier.
+   * @param body - Comment payload.
+   */
+  async addAlertComment(alertId, body) {
+    return await this.request("POST", `/alerts/${alertId}/comments`, { json: body });
+  }
+  /**
+   * Subscribe to an alert.
+   *
+   * @param alertId - Alert identifier.
+   */
+  async subscribeToAlert(alertId) {
+    return await this.request("POST", `/alerts/${alertId}/subscribe`);
+  }
+  /**
+   * Unsubscribe from an alert.
+   *
+   * @param alertId - Alert identifier.
+   */
+  async unsubscribeFromAlert(alertId) {
+    return await this.request("POST", `/alerts/${alertId}/unsubscribe`);
+  }
+  // ─── Alert Configs ─────────────────────────────────────────────────────────
+  /**
+   * List alert configurations.
+   *
+   * @param opts - Pagination options.
+   * @returns Paginated list of alert configs.
+   */
+  async listAlertConfigs(opts = {}) {
+    return await this.request("GET", "/alerts/configs", {
+      query: { page: opts.page, limit: opts.limit }
+    });
+  }
+  /**
+   * Create an alert configuration.
+   *
+   * @param body - Alert config definition.
+   * @returns Created alert config.
+   */
+  async createAlertConfig(body) {
+    return await this.request("POST", "/alerts/configs", { json: body });
+  }
+  /**
+   * Get an alert configuration by ID.
+   *
+   * @param configId - Alert config identifier.
+   * @returns Alert config details.
+   */
+  async getAlertConfig(configId) {
+    return await this.request("GET", `/alerts/configs/${configId}`);
+  }
+  /**
+   * Update an alert configuration.
+   *
+   * @param configId - Alert config identifier.
+   * @param body - Fields to update.
+   * @returns Updated alert config.
+   */
+  async updateAlertConfig(configId, body) {
+    return await this.request("PATCH", `/alerts/configs/${configId}`, { json: body });
+  }
+  /**
+   * Delete an alert configuration.
+   *
+   * @param configId - Alert config identifier.
+   */
+  async deleteAlertConfig(configId) {
+    await this.request("DELETE", `/alerts/configs/${configId}`);
+  }
+  // ─── Organization Alert Preferences ────────────────────────────────────────
+  /**
+   * List organization alert preferences.
+   */
+  async listOrganizationAlertPreferences() {
+    return await this.request("GET", "/alerts/organization-preferences/list");
+  }
+  /**
+   * Update an organization alert preference.
+   *
+   * @param organizationId - Organization identifier.
+   * @param alertType - Alert type.
+   * @param body - Preference update.
+   */
+  async updateOrganizationAlertPreference(organizationId, alertType, body) {
+    return await this.request("PATCH", `/alerts/organization-preferences/${organizationId}/${alertType}`, { json: body });
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Models & Model Alerts
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * List model alerts.
+   *
+   * @param opts - Pagination options.
+   */
+  async listModelAlerts(opts = {}) {
+    return await this.request("GET", "/models/alerts", {
+      query: { page: opts.page, limit: opts.limit }
+    });
+  }
+  /**
+   * Mark all model alerts as read.
+   */
+  async markAllModelAlertsRead() {
+    await this.request("POST", "/models/alerts/mark-all-read");
+  }
+  /**
+   * Get unread model alert count.
+   */
+  async getUnreadModelAlertCount() {
+    return await this.request("GET", "/models/alerts/unread-count");
+  }
+  /**
+   * Mark a specific model alert as read.
+   *
+   * @param alertId - Model alert identifier.
+   */
+  async markModelAlertRead(alertId) {
+    await this.request("PATCH", `/models/alerts/${alertId}/read`);
+  }
+  /**
+   * Get model recommendations.
+   *
+   * @param modelId - Model identifier.
+   */
+  async getModelRecommendations(modelId) {
+    return await this.request("GET", `/models/${modelId}/recommendations`);
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Search
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Search across all resource types in your account.
+   *
+   * Accepts a free-text keyword query or a UUID. Results are ranked:
+   * name-prefix > name-substring > description-substring.
+   *
+   * @param opts - Search options.
+   * @param opts.query - Search query string (required, 1-200 chars).
+   * @param opts.limit - Maximum results (1-50, default 10).
+   * @param opts.entityType - Optional entity type filter (e.g. "agent", "knowledge_base").
+   * @returns Search results.
+   */
+  async search(opts) {
+    return await this.request("GET", "/search", {
+      query: { q: opts.query, limit: opts.limit, entity_type: opts.entityType }
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Top-Level AI Assistant
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Submit feedback on an AI assistant interaction.
+   *
+   * @param body - Feedback payload (thumbs up/down, optional comment).
+   * @returns Feedback response.
+   */
+  async submitAiFeedback(body) {
+    return await this.request("POST", "/ai-assistant/feedback", { json: body });
+  }
+  /**
+   * Generate a knowledge base configuration via AI assistant.
+   *
+   * @param body - Generation request.
+   */
+  async aiAssistantKnowledgeBase(body) {
+    return await this.request("POST", "/ai-assistant/knowledge-base", { json: body });
+  }
+  /**
+   * Generate a source configuration via AI assistant.
+   *
+   * @param body - Generation request.
+   */
+  async aiAssistantSource(body) {
+    return await this.request("POST", "/ai-assistant/source", { json: body });
+  }
+  /**
+   * Generate a solution via AI assistant.
+   *
+   * @param body - Generation request.
+   */
+  async aiAssistantSolution(body) {
+    return await this.request("POST", "/ai-assistant/solution", { json: body });
+  }
+  /**
+   * Generate a memory bank configuration via AI assistant.
+   *
+   * @param body - Generation request.
+   */
+  async aiAssistantMemoryBank(body) {
+    return await this.request("POST", "/ai-assistant/memory-bank", { json: body });
+  }
+  /**
+   * Get AI assistant memory bank conversation history.
+   */
+  async getAiAssistantMemoryBankHistory() {
+    return await this.request("GET", "/ai-assistant/memory-bank/last-conversation");
+  }
+  /**
+   * Accept an AI assistant suggestion.
+   *
+   * @param conversationId - Conversation identifier.
+   * @param body - Acceptance request payload.
+   */
+  async acceptAiAssistantPlan(conversationId, body) {
+    return await this.request("POST", `/ai-assistant/${conversationId}/accept`, { json: body });
+  }
+  /**
+   * Decline an AI assistant suggestion.
+   *
+   * @param conversationId - Conversation identifier.
+   */
+  async declineAiAssistantPlan(conversationId) {
+    await this.request("POST", `/ai-assistant/${conversationId}/decline`);
+  }
+  /**
+   * Accept/mark an AI memory bank suggestion.
+   *
+   * @param conversationId - Conversation identifier.
+   * @param body - Acceptance payload for the memory bank suggestion.
+   */
+  async acceptAiMemoryBankSuggestion(conversationId, body) {
+    return await this.request("PATCH", `/ai-assistant/memory-bank/${conversationId}`, { json: body });
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Pagination Helpers
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Auto-paginate through a list endpoint.
+   *
+   * Yields individual items from each page, automatically fetching the next page
+   * until all items have been returned.
+   *
+   * @param fetchPage - A function that fetches a single page given `{ page, limit }`.
+   * @param opts - Page size (default: 50).
+   *
+   * @example
+   * ```ts
+   * for await (const agent of client.paginate(
+   *   (opts) => client.listAgents(opts),
+   * )) {
+   *   console.log(agent);
+   * }
+   * ```
+   */
+  async *paginate(fetchPage, opts) {
+    const limit = opts?.limit ?? 50;
+    let page = 1;
+    while (true) {
+      const result = await fetchPage({ page, limit });
+      for (const item of result.items) {
+        yield item;
+      }
+      if (!result.pagination || result.items.length < limit || page >= result.pagination.total_pages) {
+        break;
+      }
+      page++;
+    }
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
@@ -604,6 +2278,7 @@ var Seclai = class {
   SeclaiAPIStatusError,
   SeclaiAPIValidationError,
   SeclaiConfigurationError,
-  SeclaiError
+  SeclaiError,
+  SeclaiStreamingError
 });
 //# sourceMappingURL=index.cjs.map