@seclai/sdk 1.0.6 → 1.1.0

package/dist/index.cjs

@@ -25,7 +25,8 @@ __export(index_exports, {
   SeclaiAPIStatusError: () => SeclaiAPIStatusError,
   SeclaiAPIValidationError: () => SeclaiAPIValidationError,
   SeclaiConfigurationError: () => SeclaiConfigurationError,
-  SeclaiError: () => SeclaiError
+  SeclaiError: () => SeclaiError,
+  SeclaiStreamingError: () => SeclaiStreamingError
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -69,6 +70,15 @@ 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/client.ts
 var SECLAI_API_URL = "https://api.seclai.com";
@@ -153,6 +163,51 @@ 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;
@@ -185,14 +240,17 @@ var Seclai = class {
     this.defaultHeaders = { ...opts.defaultHeaders ?? {} };
     this.fetcher = fetcher;
   }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 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.
@@ -213,6 +271,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,23 +306,242 @@ 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.
+   */
+  async requestRaw(method, path, opts) {
+    const url = buildURL(this.baseUrl, path, opts?.query);
+    const headers = {
+      ...this.defaultHeaders,
+      ...opts?.headers ?? {},
+      [this.apiKeyHeader]: this.apiKey
+    };
+    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 headers = {
+      ...this.defaultHeaders,
+      [this.apiKeyHeader]: this.apiKey
+    };
+    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 - Agent run request payload.
+   * @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 - 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 }
+    });
+  }
+  /**
+   * 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 block until the final `done` event.
+   * 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`);
@@ -279,12 +559,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 +598,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,188 +619,1321 @@ 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 SeclaiStreamingError(
+          `Timed out after ${timeoutMs}ms waiting for streaming agent run to complete.`,
+          lastSeen?.run_id
+        );
+      }
+      throw err;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Run an agent in streaming mode and yield each SSE event as it arrives.
+   *
+   * This is an `AsyncGenerator` suitable for real-time UIs that want to render
+   * step progress as it happens.
+   *
+   * @param agentId - Agent identifier.
+   * @param body - Streaming run request payload.
+   * @param opts - Timeout and abort signal options.
+   * @yields {@link AgentRunEvent} for each SSE message.
+   *
+   * @example
+   * ```ts
+   * for await (const event of client.runStreamingAgent("agent-id", { input: "Hello!" })) {
+   *   if (event.event === "done") {
+   *     console.log("Final:", event.data);
+   *   }
+   * }
+   * ```
+   */
+  async *runStreamingAgent(agentId, body, opts) {
+    const url = buildURL(this.baseUrl, `/agents/${agentId}/runs/stream`);
+    const headers = {
+      ...this.defaultHeaders,
+      [this.apiKeyHeader]: this.apiKey,
+      accept: "text/event-stream",
+      "content-type": "application/json"
+    };
+    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
+        });
+      }
+      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 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.`
+        );
       }
       throw err;
     } finally {
       clearTimeout(timeoutId);
     }
   }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Agent Runs — Polling
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Run an agent and poll until it reaches a terminal status.
+   *
+   * This is useful in environments where SSE streaming is unavailable.
+   *
+   * @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 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;
+      }
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Agent Run Evaluation Results
+  // ═══════════════════════════════════════════════════════════════════════════
   /**
-   * List agent runs for an agent.
+   * List evaluation results for a specific agent run.
    *
    * @param agentId - Agent identifier.
+   * @param runId - Run identifier.
    * @param opts - Pagination options.
-   * @returns A paginated list of runs.
+   * @returns Paginated list of evaluation results.
    */
-  async listAgentRuns(agentId, opts = {}) {
-    const data = await this.request("GET", `/agents/${agentId}/runs`, {
-      query: { page: opts.page ?? 1, limit: opts.limit ?? 50 }
+  async listRunEvaluationResults(agentId, runId, opts = {}) {
+    return await this.request("GET", `/agents/${agentId}/runs/${runId}/evaluation-results`, {
+      query: { page: opts.page, limit: opts.limit }
     });
-    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;
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 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);
   }
-  async deleteAgentRun(arg1, arg2) {
-    const runId = arg2 ?? arg1;
-    const data = await this.request("DELETE", `/agents/runs/${runId}`);
-    return data;
+  /**
+   * 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)
+  // ═══════════════════════════════════════════════════════════════════════════
   /**
-   * Get content detail.
+   * Generate agent workflow steps from natural language using AI.
    *
-   * Fetches a slice of a content version (use `start`/`end` to page through large content).
+   * @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 sourceConnectionContentVersion - Content version identifier.
-   * @param opts - Range options.
-   * @returns Content details for the requested range.
+   * @param agentId - Agent identifier.
+   * @param body - Step config generation request.
+   * @returns AI-generated step config.
    */
-  async getContentDetail(sourceConnectionContentVersion, opts = {}) {
-    const data = await this.request(
-      "GET",
-      `/contents/${sourceConnectionContentVersion}`,
-      { query: { start: opts.start ?? 0, end: opts.end ?? 5e3 } }
-    );
-    return data;
+  async generateStepConfig(agentId, body) {
+    return await this.request("POST", `/agents/${agentId}/ai-assistant/step-config`, { json: body });
   }
   /**
-   * Delete a specific content version.
+   * Get AI conversation history for an agent.
    *
-   * @param sourceConnectionContentVersion - Content version identifier.
+   * @param agentId - Agent identifier.
+   * @returns Conversation history.
    */
-  async deleteContent(sourceConnectionContentVersion) {
-    await this.request("DELETE", `/contents/${sourceConnectionContentVersion}`);
+  async getAgentAiConversationHistory(agentId) {
+    return await this.request("GET", `/agents/${agentId}/ai-assistant/conversations`);
   }
   /**
-   * List embeddings for a content version.
+   * Mark an AI suggestion as accepted or rejected.
    *
-   * @param sourceConnectionContentVersion - Content version identifier.
-   * @param opts - Pagination options.
-   * @returns A paginated list of embeddings.
+   * @param agentId - Agent identifier.
+   * @param conversationId - Conversation turn identifier.
+   * @param body - Mark request payload.
    */
-  async listContentEmbeddings(sourceConnectionContentVersion, opts = {}) {
-    const data = await this.request(
-      "GET",
-      `/contents/${sourceConnectionContentVersion}/embeddings`,
-      { query: { page: opts.page ?? 1, limit: opts.limit ?? 20 } }
-    );
-    return data;
+  async markAgentAiSuggestion(agentId, conversationId, body) {
+    await this.request("PATCH", `/agents/${agentId}/ai-assistant/${conversationId}`, { json: body });
   }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Agent Evaluation Criteria
+  // ═══════════════════════════════════════════════════════════════════════════
   /**
-   * List sources.
+   * List evaluation criteria for an agent.
    *
-   * @param opts - Pagination and filter options.
-   * @returns A paginated list of sources.
+   * @param agentId - Agent identifier.
+   * @param opts - Pagination options.
    */
-  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
-      }
+  async listEvaluationCriteria(agentId, opts = {}) {
+    return await this.request("GET", `/agents/${agentId}/evaluation-criteria`, {
+      query: { page: opts.page, limit: opts.limit }
     });
-    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.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`);
-    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);
-    }
-    const response = await this.fetcher(url, {
-      method: "POST",
-      headers,
-      body: form
+  }
+  /**
+   * 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 }
     });
-    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
-        });
+  }
+  /**
+   * 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
       }
-      throw new SeclaiAPIStatusError({
-        message: `Request failed with status ${response.status}`,
-        statusCode: response.status,
-        method: "POST",
-        url: url.toString(),
-        responseText
-      });
+    });
+  }
+  /**
+   * 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++;
     }
-    return await response.json();
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
@@ -536,6 +1943,7 @@ var Seclai = class {
   SeclaiAPIStatusError,
   SeclaiAPIValidationError,
   SeclaiConfigurationError,
-  SeclaiError
+  SeclaiError,
+  SeclaiStreamingError
 });
 //# sourceMappingURL=index.cjs.map