@agent-nexus/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2129 @@
+// src/errors.ts
+var NexusError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NexusError";
+  }
+};
+var NexusApiError = class extends NexusError {
+  constructor(code, message, status, details) {
+    super(message);
+    this.name = "NexusApiError";
+    this.code = code;
+    this.status = status;
+    this.details = details;
+  }
+};
+var NexusAuthenticationError = class extends NexusApiError {
+  constructor(message = "Invalid or missing API key") {
+    super("UNAUTHORIZED", message, 401);
+    this.name = "NexusAuthenticationError";
+  }
+};
+var NexusConnectionError = class extends NexusError {
+  constructor(message, cause) {
+    super(message);
+    this.name = "NexusConnectionError";
+    this.cause = cause;
+  }
+};
+
+// src/http-client.ts
+var HttpClient = class {
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.apiKey = opts.apiKey;
+    this.fetchFn = opts.fetch ?? globalThis.fetch;
+    this.defaultHeaders = opts.defaultHeaders ?? {};
+    this.timeout = opts.timeout ?? 3e4;
+  }
+  /**
+   * Make a request and return the unwrapped `data` field.
+   *
+   * @param method - HTTP method (GET, POST, PATCH, DELETE).
+   * @param path - API path relative to `/api/public/v1` (e.g. `"/agents"`).
+   * @param opts - Optional body, query params, and headers.
+   * @returns The response `data` field, typed as `T`.
+   * @throws {NexusAuthenticationError} On 401 responses.
+   * @throws {NexusApiError} On other error responses.
+   * @throws {NexusConnectionError} On network failures or timeouts.
+   */
+  async request(method, path, opts = {}) {
+    const { data } = await this.requestWithMeta(method, path, opts);
+    return data;
+  }
+  /**
+   * Make a request and return `{ data, meta }` (useful for paginated lists).
+   *
+   * @param method - HTTP method.
+   * @param path - API path relative to `/api/public/v1`.
+   * @param opts - Optional body, query params, and headers.
+   * @returns The response `data` and optional pagination `meta`.
+   * @throws {NexusAuthenticationError} On 401 responses.
+   * @throws {NexusApiError} On other error responses.
+   * @throws {NexusConnectionError} On network failures or timeouts.
+   */
+  async requestWithMeta(method, path, opts = {}) {
+    const url = new URL(`${this.baseUrl}/api/public/v1${path}`);
+    if (opts.query) {
+      for (const [k, v] of Object.entries(opts.query)) {
+        if (v !== void 0) url.searchParams.set(k, String(v));
+      }
+    }
+    const headers = {
+      ...this.defaultHeaders,
+      ...opts.headers,
+      "api-key": this.apiKey,
+      Accept: "application/json"
+    };
+    const fetchInit = { method, headers };
+    if (opts.body !== void 0) {
+      if (opts.body instanceof FormData) {
+        fetchInit.body = opts.body;
+      } else {
+        headers["Content-Type"] = "application/json";
+        fetchInit.body = JSON.stringify(opts.body);
+      }
+    }
+    const controller = new AbortController();
+    fetchInit.signal = controller.signal;
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    let res;
+    try {
+      res = await this.fetchFn(url.toString(), fetchInit);
+    } catch (err) {
+      clearTimeout(timer);
+      if (err instanceof DOMException && err.name === "AbortError") {
+        throw new NexusConnectionError(`Request timed out after ${this.timeout}ms`);
+      }
+      throw new NexusConnectionError(
+        err instanceof Error ? err.message : "Network request failed",
+        err instanceof Error ? err : void 0
+      );
+    } finally {
+      clearTimeout(timer);
+    }
+    let json;
+    try {
+      json = await res.json();
+    } catch {
+      throw new NexusApiError(
+        "PARSE_ERROR",
+        `Failed to parse response body (status ${res.status})`,
+        res.status
+      );
+    }
+    if (!json.success) {
+      const err = json.error;
+      if (!err || typeof err !== "object") {
+        const raw = json;
+        const msg = raw.message ?? `Request failed with status ${res.status}`;
+        const code = raw.error ?? `HTTP_${res.status}`;
+        if (res.status === 401) {
+          throw new NexusAuthenticationError(msg);
+        }
+        throw new NexusApiError(code, msg, res.status);
+      }
+      if (res.status === 401) {
+        throw new NexusAuthenticationError(err.message);
+      }
+      throw new NexusApiError(err.code, err.message, res.status, err.details);
+    }
+    const success = json;
+    return { data: success.data, meta: success.meta };
+  }
+};
+
+// src/resources/base-resource.ts
+var BaseResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+};
+
+// src/resources/agent-collections.ts
+var AgentCollectionsResource = class extends BaseResource {
+  async list(agentId) {
+    return this.http.request("GET", `/agents/${agentId}/collections`);
+  }
+  async attach(agentId, body) {
+    return this.http.request("POST", `/agents/${agentId}/collections`, { body });
+  }
+  async detach(agentId, body) {
+    return this.http.request("DELETE", `/agents/${agentId}/collections`, { body });
+  }
+};
+
+// src/resources/agent-tools.ts
+var AgentToolsResource = class extends BaseResource {
+  /**
+   * List all tool configurations for an agent.
+   *
+   * @param agentId - Agent UUID.
+   * @returns Array of tool configurations.
+   */
+  async list(agentId) {
+    return this.http.request("GET", `/agents/${agentId}/tools`);
+  }
+  /**
+   * Get a specific tool configuration.
+   *
+   * @param agentId - Agent UUID.
+   * @param toolId - Tool config UUID.
+   * @returns Tool configuration detail.
+   */
+  async get(agentId, toolId) {
+    return this.http.request("GET", `/agents/${agentId}/tools/${toolId}`);
+  }
+  /**
+   * Add a new tool configuration to an agent.
+   *
+   * @param agentId - Agent UUID.
+   * @param body - Tool configuration. `label` and `type` are required.
+   * @returns The created tool configuration.
+   */
+  async create(agentId, body) {
+    return this.http.request("POST", `/agents/${agentId}/tools`, { body });
+  }
+  /**
+   * Update an existing tool configuration. Only provided fields are updated.
+   *
+   * @param agentId - Agent UUID.
+   * @param toolId - Tool config UUID.
+   * @param body - Fields to update.
+   * @returns The updated tool configuration.
+   */
+  async update(agentId, toolId, body) {
+    return this.http.request("PATCH", `/agents/${agentId}/tools/${toolId}`, {
+      body
+    });
+  }
+  /**
+   * Remove a tool configuration from an agent.
+   *
+   * @param agentId - Agent UUID.
+   * @param toolId - Tool config UUID.
+   * @returns Confirmation with the deleted tool config's ID.
+   */
+  async delete(agentId, toolId) {
+    return this.http.request("DELETE", `/agents/${agentId}/tools/${toolId}`);
+  }
+  /**
+   * Attach a knowledge collection to an agent.
+   *
+   * Creates a COLLECTION-type tool that allows the agent to search the
+   * collection during conversations. If `label` is omitted, the collection
+   * name is used.
+   *
+   * @param agentId - Agent UUID.
+   * @param body - Collection ID and optional label/description/instructions.
+   * @returns The created tool configuration.
+   *
+   * @example
+   * ```ts
+   * const tool = await client.agents.tools.attachCollection("agent-uuid", {
+   *   collectionId: "collection-uuid"
+   * });
+   * ```
+   */
+  async attachCollection(agentId, body) {
+    return this.http.request(
+      "POST",
+      `/agents/${agentId}/tools/attach-collection`,
+      { body }
+    );
+  }
+};
+
+// src/resources/versions.ts
+var VersionsResource = class extends BaseResource {
+  /**
+   * List prompt versions for an agent (paginated).
+   *
+   * @param agentId - Agent UUID.
+   * @param params - Optional type filter and pagination.
+   * @returns Paginated list of version summaries.
+   */
+  async list(agentId, params) {
+    const { data, meta } = await this.http.requestWithMeta(
+      "GET",
+      `/agents/${agentId}/versions`,
+      { query: params }
+    );
+    return { data, meta };
+  }
+  /**
+   * Get detailed information about a specific version, including the full prompt content.
+   *
+   * @param agentId - Agent UUID.
+   * @param versionId - Version UUID.
+   * @returns Version detail with the prompt text.
+   */
+  async get(agentId, versionId) {
+    return this.http.request("GET", `/agents/${agentId}/versions/${versionId}`);
+  }
+  /**
+   * Create a named checkpoint of the agent's current prompt.
+   *
+   * @param agentId - Agent UUID.
+   * @param body - Optional name and description for the checkpoint.
+   * @returns The created checkpoint version.
+   */
+  async createCheckpoint(agentId, body) {
+    return this.http.request("POST", `/agents/${agentId}/versions`, {
+      body: body ?? {}
+    });
+  }
+  /**
+   * Update a version's metadata (name or description).
+   *
+   * @param agentId - Agent UUID.
+   * @param versionId - Version UUID.
+   * @param body - Fields to update.
+   * @returns The updated version detail.
+   */
+  async update(agentId, versionId, body) {
+    return this.http.request("PATCH", `/agents/${agentId}/versions/${versionId}`, {
+      body
+    });
+  }
+  /**
+   * Delete a prompt version. Cannot delete the current production version.
+   *
+   * @param agentId - Agent UUID.
+   * @param versionId - Version UUID.
+   * @returns Confirmation with the deleted version's ID.
+   */
+  async delete(agentId, versionId) {
+    return this.http.request("DELETE", `/agents/${agentId}/versions/${versionId}`);
+  }
+  /**
+   * Restore the agent's prompt to a specific version. This overwrites the
+   * agent's current prompt with the content from the specified version.
+   *
+   * @param agentId - Agent UUID.
+   * @param versionId - Version UUID to restore.
+   * @returns The restored prompt content and a confirmation message.
+   */
+  async restore(agentId, versionId) {
+    return this.http.request(
+      "POST",
+      `/agents/${agentId}/versions/${versionId}/restore`
+    );
+  }
+  /**
+   * Publish a version to production. This marks the version as the active
+   * production version for the agent.
+   *
+   * @param agentId - Agent UUID.
+   * @param versionId - Version UUID to publish.
+   * @returns The published version detail with `isProduction: true`.
+   */
+  async publish(agentId, versionId) {
+    return this.http.request(
+      "POST",
+      `/agents/${agentId}/versions/${versionId}/publish`
+    );
+  }
+};
+
+// src/resources/agents.ts
+var AgentsResource = class extends BaseResource {
+  constructor(http) {
+    super(http);
+    this.tools = new AgentToolsResource(http);
+    this.versions = new VersionsResource(http);
+  }
+  /**
+   * List agents with optional filtering and pagination.
+   *
+   * @param params - Optional filters and pagination.
+   * @returns Paginated list of agent summaries.
+   */
+  async list(params) {
+    const { data, meta } = await this.http.requestWithMeta("GET", "/agents", {
+      query: params
+    });
+    return { data, meta };
+  }
+  /**
+   * Get detailed information about a specific agent.
+   *
+   * @param agentId - Agent UUID.
+   * @returns Full agent detail including prompt, behaviour rules, and model configuration.
+   */
+  async get(agentId) {
+    return this.http.request("GET", `/agents/${agentId}`);
+  }
+  /**
+   * Create a new agent.
+   *
+   * @param body - Agent properties. `firstName`, `lastName`, and `role` are required.
+   * @returns The created agent detail.
+   */
+  async create(body) {
+    return this.http.request("POST", "/agents", { body });
+  }
+  /**
+   * Update an existing agent's properties. Only provided fields are updated.
+   *
+   * @param agentId - Agent UUID.
+   * @param body - Fields to update.
+   * @returns The updated agent detail.
+   */
+  async update(agentId, body) {
+    return this.http.request("PATCH", `/agents/${agentId}`, { body });
+  }
+  /**
+   * Permanently delete an agent and all its tool configurations and versions.
+   *
+   * @param agentId - Agent UUID.
+   * @returns Confirmation with the deleted agent's ID.
+   */
+  async delete(agentId) {
+    return this.http.request("DELETE", `/agents/${agentId}`);
+  }
+  /**
+   * Create a copy of an existing agent, including its configuration and tools.
+   *
+   * @param agentId - Agent UUID to duplicate.
+   * @returns The newly created agent detail.
+   */
+  async duplicate(agentId) {
+    return this.http.request("POST", `/agents/${agentId}/duplicate`);
+  }
+  /**
+   * Upload a profile picture for an agent.
+   *
+   * @param agentId - Agent UUID.
+   * @param file - Image file as a Blob or File.
+   * @returns URL to the uploaded profile picture.
+   */
+  async uploadProfilePicture(agentId, file) {
+    const formData = new FormData();
+    formData.append("file", file);
+    return this.http.request(
+      "POST",
+      `/agents/${agentId}/profile-picture`,
+      { body: formData }
+    );
+  }
+  /**
+   * Generate an AI profile picture for an agent using its name and role.
+   *
+   * @param agentId - Agent UUID.
+   * @param body - Optional custom prompt to guide image style.
+   * @returns URLs of the generated profile picture in multiple sizes.
+   */
+  async generateProfilePicture(agentId, body) {
+    return this.http.request("POST", `/agents/${agentId}/generate-profile-picture`, { body });
+  }
+};
+
+// src/resources/analytics.ts
+var AnalyticsResource = class extends BaseResource {
+  async getOverview(params) {
+    return this.http.request("GET", "/analytics/overview", {
+      query: params
+    });
+  }
+  async exportCsv(params) {
+    return this.http.request("GET", "/analytics/export", {
+      query: params
+    });
+  }
+  async listFeedback(params) {
+    const { data, meta } = await this.http.requestWithMeta("GET", "/analytics/feedback", {
+      query: params
+    });
+    return { data, meta };
+  }
+};
+
+// src/resources/cloud-imports.ts
+var CloudImportsResource = class extends BaseResource {
+  // Google Drive
+  async googleDriveAuth(body) {
+    return this.http.request("POST", "/documents/google-drive/auth", { body });
+  }
+  async googleDriveRefresh(body) {
+    return this.http.request("POST", "/documents/google-drive/refresh", { body });
+  }
+  async listGoogleDriveFiles(params) {
+    return this.http.request("GET", "/documents/google-drive/files", {
+      query: params
+    });
+  }
+  async importGoogleDrive(body) {
+    return this.http.request("POST", "/documents/google-drive/import", { body });
+  }
+  // SharePoint
+  async sharePointAuth(body) {
+    return this.http.request("POST", "/documents/sharepoint/auth", { body });
+  }
+  async sharePointRefresh(body) {
+    return this.http.request("POST", "/documents/sharepoint/refresh", { body });
+  }
+  async listSharePointSites(params) {
+    return this.http.request("GET", "/documents/sharepoint/sites", {
+      query: params
+    });
+  }
+  async listSharePointFiles(params) {
+    return this.http.request("GET", "/documents/sharepoint/files", {
+      query: params
+    });
+  }
+  async importSharePoint(body) {
+    return this.http.request("POST", "/documents/sharepoint/import", { body });
+  }
+  // Notion
+  async notionAuth(body) {
+    return this.http.request("POST", "/documents/notion/auth", { body });
+  }
+  async searchNotion(params) {
+    return this.http.request("GET", "/documents/notion/search", {
+      query: params
+    });
+  }
+  async importNotion(body) {
+    return this.http.request("POST", "/documents/notion/import", { body });
+  }
+};
+
+// src/resources/deployment-folders.ts
+var DeploymentFoldersResource = class extends BaseResource {
+  async list() {
+    return this.http.request("GET", "/deployment-folders");
+  }
+  async create(body) {
+    return this.http.request("POST", "/deployment-folders", { body });
+  }
+  async update(folderId, body) {
+    return this.http.request("PATCH", `/deployment-folders/${folderId}`, { body });
+  }
+  async delete(folderId) {
+    return this.http.request("DELETE", `/deployment-folders/${folderId}`);
+  }
+  async assign(body) {
+    return this.http.request("POST", "/deployment-folders/assign", { body });
+  }
+};
+
+// src/resources/deployments.ts
+var DeploymentsResource = class extends BaseResource {
+  async list(params) {
+    const { data, meta } = await this.http.requestWithMeta("GET", "/deployments", {
+      query: params
+    });
+    return { data, meta };
+  }
+  async create(body) {
+    return this.http.request("POST", "/deployments", { body });
+  }
+  async get(deploymentId) {
+    return this.http.request("GET", `/deployments/${deploymentId}`);
+  }
+  async update(deploymentId, body) {
+    return this.http.request("PATCH", `/deployments/${deploymentId}`, { body });
+  }
+  async delete(deploymentId) {
+    return this.http.request("DELETE", `/deployments/${deploymentId}`);
+  }
+  async duplicate(deploymentId) {
+    return this.http.request("POST", `/deployments/${deploymentId}/duplicate`);
+  }
+  async getStatistics(deploymentId) {
+    return this.http.request("GET", `/deployments/${deploymentId}/statistics`);
+  }
+  async getEmbedConfig(deploymentId) {
+    return this.http.request("GET", `/deployments/${deploymentId}/embed-config`);
+  }
+  async updateEmbedConfig(deploymentId, body) {
+    return this.http.request("PATCH", `/deployments/${deploymentId}/embed-config`, { body });
+  }
+};
+
+// src/resources/document-template-folders.ts
+var DocumentTemplateFoldersResource = class extends BaseResource {
+  async list() {
+    return this.http.request("GET", "/document-template-folders");
+  }
+  async create(body) {
+    return this.http.request("POST", "/document-template-folders", { body });
+  }
+  async update(folderId, body) {
+    return this.http.request("PATCH", `/document-template-folders/${folderId}`, { body });
+  }
+  async delete(folderId) {
+    return this.http.request("DELETE", `/document-template-folders/${folderId}`);
+  }
+  async assign(body) {
+    return this.http.request("POST", "/document-template-folders/assign", { body });
+  }
+};
+
+// src/resources/documents.ts
+var DocumentsResource = class extends BaseResource {
+  /**
+   * Get a document by ID.
+   *
+   * @param documentId - The document's UUID.
+   * @returns Detailed document information.
+   *
+   * @example
+   * ```ts
+   * const doc = await client.documents.get("doc-uuid");
+   * console.log(doc.name, doc.status, doc.processingProgress);
+   * ```
+   */
+  async get(documentId) {
+    return this.http.request("GET", `/documents/${documentId}`);
+  }
+  /**
+   * Upload a file as a new document.
+   *
+   * @param file - File as a `Blob`, `File`, or `Buffer`.
+   * @param fileName - File name (required when passing a `Blob` or `Buffer`).
+   * @param description - Optional description.
+   * @returns Created document info.
+   *
+   * @example
+   * ```ts
+   * import fs from "fs";
+   *
+   * const buffer = fs.readFileSync("report.pdf");
+   * const doc = await client.documents.uploadFile(
+   *   new Blob([buffer]),
+   *   "report.pdf",
+   *   "Q4 financial report"
+   * );
+   * console.log(doc.id, doc.status);
+   * ```
+   */
+  async uploadFile(file, fileName, description) {
+    const formData = new FormData();
+    formData.append("file", file, fileName);
+    if (description) {
+      formData.append("description", description);
+    }
+    return this.http.request("POST", "/documents/file", { body: formData });
+  }
+  /**
+   * Create a new document from inline text content.
+   *
+   * @param body - Document name, content, and optional description.
+   * @returns Created document info.
+   *
+   * @example
+   * ```ts
+   * const doc = await client.documents.createText({
+   *   name: "Meeting Notes",
+   *   content: "Key decisions from today's meeting..."
+   * });
+   * ```
+   */
+  async createText(body) {
+    return this.http.request("POST", "/documents/text", { body });
+  }
+  /**
+   * Crawl a website and create document(s) from the content.
+   *
+   * @param body - URL, crawl mode, optional config and description.
+   * @returns Created document info (folder for crawled pages).
+   *
+   * @example
+   * ```ts
+   * const doc = await client.documents.addWebsite({
+   *   url: "https://docs.example.com",
+   *   mode: "sitemap"
+   * });
+   * ```
+   */
+  async addWebsite(body) {
+    return this.http.request("POST", "/documents/website", { body });
+  }
+  /**
+   * Import a Google Sheet as document(s).
+   *
+   * @param body - Sheet name, URL, and optional metadata.
+   * @returns Folder document, individual sheet documents, and status message.
+   *
+   * @example
+   * ```ts
+   * const result = await client.documents.createGoogleSheet({
+   *   name: "Product Catalog",
+   *   url: "https://docs.google.com/spreadsheets/d/..."
+   * });
+   * console.log(result.folder.id, result.sheets.length);
+   * ```
+   */
+  async createGoogleSheet(body) {
+    return this.http.request("POST", "/documents/google-sheet", { body });
+  }
+  async list(params) {
+    const { data, meta } = await this.http.requestWithMeta("GET", "/documents", {
+      query: params
+    });
+    return { data, meta };
+  }
+  async update(documentId, body) {
+    return this.http.request("PATCH", `/documents/${documentId}`, { body });
+  }
+  async delete(documentId) {
+    return this.http.request("DELETE", `/documents/${documentId}`);
+  }
+  async getDownloadUrl(documentId) {
+    return this.http.request(
+      "GET",
+      `/documents/${documentId}/download`
+    );
+  }
+  async listChildren(documentId, params) {
+    const { data, meta } = await this.http.requestWithMeta(
+      "GET",
+      `/documents/${documentId}/children`,
+      {
+        query: params
+      }
+    );
+    return { data, meta };
+  }
+  async reprocess(documentId) {
+    return this.http.request("POST", `/documents/${documentId}/reprocess`);
+  }
+  async createFolder(body) {
+    return this.http.request("POST", "/documents/folder", { body });
+  }
+};
+
+// src/resources/emulator.ts
+var EmulatorResource = class extends BaseResource {
+  // ─── Sessions ───────────────────────────────────────────────────────────────
+  /** Create a new emulator session for a deployment. */
+  async createSession(deploymentId, body) {
+    return this.http.request("POST", `/emulator/${deploymentId}/sessions`, {
+      body
+    });
+  }
+  /** List emulator sessions for a deployment. */
+  async listSessions(deploymentId) {
+    return this.http.request("GET", `/emulator/${deploymentId}/sessions`);
+  }
+  /** Get detailed information about an emulator session, including messages. */
+  async getSession(deploymentId, sessionId) {
+    return this.http.request(
+      "GET",
+      `/emulator/${deploymentId}/sessions/${sessionId}`
+    );
+  }
+  /** Send a message in an emulator session. Returns debug info about agent execution. */
+  async sendMessage(deploymentId, sessionId, body) {
+    return this.http.request(
+      "POST",
+      `/emulator/${deploymentId}/sessions/${sessionId}/messages`,
+      { body }
+    );
+  }
+  /** Delete an emulator session. */
+  async deleteSession(deploymentId, sessionId) {
+    await this.http.request("DELETE", `/emulator/${deploymentId}/sessions/${sessionId}`);
+  }
+  // ─── Scenarios ──────────────────────────────────────────────────────────────
+  /** Save a scenario from an existing emulator session. */
+  async saveScenario(body) {
+    return this.http.request("POST", "/emulator/scenarios", {
+      body
+    });
+  }
+  /** List scenarios, optionally filtered by deployment. */
+  async listScenarios(params) {
+    return this.http.request("GET", "/emulator/scenarios", {
+      query: params
+    });
+  }
+  /** Get detailed information about a scenario, including its messages. */
+  async getScenario(scenarioId) {
+    return this.http.request("GET", `/emulator/scenarios/${scenarioId}`);
+  }
+  /** Replay a scenario against a deployment. Runs asynchronously. */
+  async replayScenario(scenarioId, body) {
+    return this.http.request("POST", `/emulator/scenarios/${scenarioId}/replay`, { body });
+  }
+  /** Delete a scenario. */
+  async deleteScenario(scenarioId) {
+    await this.http.request("DELETE", `/emulator/scenarios/${scenarioId}`);
+  }
+};
+
+// src/resources/evaluations.ts
+var EvaluationsResource = class extends BaseResource {
+  async createSession(taskId, body) {
+    return this.http.request("POST", `/skills/tasks/${taskId}/evaluations`, { body });
+  }
+  async listSessions(taskId, params) {
+    const { data, meta } = await this.http.requestWithMeta(
+      "GET",
+      `/skills/tasks/${taskId}/evaluations`,
+      {
+        query: params
+      }
+    );
+    return { data, meta };
+  }
+  async getSession(taskId, sessionId) {
+    return this.http.request("GET", `/skills/tasks/${taskId}/evaluations/${sessionId}`);
+  }
+  async deleteSession(taskId, sessionId) {
+    return this.http.request("DELETE", `/skills/tasks/${taskId}/evaluations/${sessionId}`);
+  }
+  async getDatasetRows(taskId, sessionId, params) {
+    const { data, meta } = await this.http.requestWithMeta(
+      "GET",
+      `/skills/tasks/${taskId}/evaluations/${sessionId}/dataset`,
+      {
+        query: params
+      }
+    );
+    return { data, meta };
+  }
+  async addDatasetRow(taskId, sessionId, body) {
+    return this.http.request(
+      "POST",
+      `/skills/tasks/${taskId}/evaluations/${sessionId}/dataset/rows`,
+      { body }
+    );
+  }
+  async execute(taskId, sessionId) {
+    return this.http.request(
+      "POST",
+      `/skills/tasks/${taskId}/evaluations/${sessionId}/execute`
+    );
+  }
+  async judge(taskId, sessionId, body) {
+    return this.http.request(
+      "POST",
+      `/skills/tasks/${taskId}/evaluations/${sessionId}/judge`,
+      { body }
+    );
+  }
+  async getResults(taskId, sessionId, params) {
+    const { data, meta } = await this.http.requestWithMeta(
+      "GET",
+      `/skills/tasks/${taskId}/evaluations/${sessionId}/results`,
+      {
+        query: params
+      }
+    );
+    return { data, meta };
+  }
+  async listFormats() {
+    return this.http.request("GET", "/skills/evaluations/formats");
+  }
+  async listJudges() {
+    return this.http.request("GET", "/skills/evaluations/judges");
+  }
+};
+
+// src/resources/folders.ts
+var FoldersResource = class extends BaseResource {
+  /**
+   * List all folders and their agent assignments.
+   *
+   * @returns All folders and a flat list of agent-to-folder assignments.
+   */
+  async list() {
+    return this.http.request("GET", "/folders");
+  }
+  /**
+   * Create a new folder for organizing agents.
+   *
+   * @param body - Folder properties. `name` is required. Set `parentId` for nesting.
+   * @returns The created folder.
+   */
+  async create(body) {
+    return this.http.request("POST", "/folders", { body });
+  }
+  /**
+   * Update a folder's properties.
+   *
+   * @param folderId - Folder UUID.
+   * @param body - Fields to update. Set `parentId` to `null` to move to root level.
+   * @returns The updated folder.
+   */
+  async update(folderId, body) {
+    return this.http.request("PATCH", `/folders/${folderId}`, { body });
+  }
+  /**
+   * Delete a folder. Agents in the folder are unassigned, not deleted.
+   *
+   * @param folderId - Folder UUID.
+   * @returns Confirmation with the deleted folder's ID.
+   */
+  async delete(folderId) {
+    return this.http.request("DELETE", `/folders/${folderId}`);
+  }
+  /**
+   * Assign an agent to a folder, or remove from folder.
+   *
+   * @param body - Agent ID and target folder ID. Set `folderId` to `null` to remove the agent from its folder.
+   * @returns Confirmation of the assignment.
+   */
+  async assignAgent(body) {
+    return this.http.request("POST", "/folders/assign", {
+      body
+    });
+  }
+};
+
+// src/resources/models.ts
+var ModelsResource = class extends BaseResource {
+  constructor(http) {
+    super(http);
+  }
+  /**
+   * List all enabled AI models available for agents.
+   *
+   * @returns Array of model summaries with identifiers, providers, and capabilities.
+   */
+  async list() {
+    return this.http.request("GET", "/models");
+  }
+};
+
+// src/resources/prompt-assistant.ts
+var PromptAssistantResource = class extends BaseResource {
+  async chat(body) {
+    return this.http.request("POST", "/prompt-assistant/chat", {
+      body
+    });
+  }
+  async getThread(threadId) {
+    return this.http.request(
+      "GET",
+      `/prompt-assistant/threads/${threadId}`
+    );
+  }
+  async deleteThread(threadId) {
+    return this.http.request(
+      "DELETE",
+      `/prompt-assistant/threads/${threadId}`
+    );
+  }
+};
+
+// src/resources/skills.ts
+var SkillsResource = class extends BaseResource {
+  /**
+   * List the organization's workflows.
+   *
+   * @param params - Optional search, limit, and offset.
+   * @returns Matching workflows with `agentInputSchema` and total count.
+   *
+   * @example
+   * ```ts
+   * const { items, total } = await client.skills.listWorkflows({ search: "onboarding" });
+   * for (const wf of items) {
+   *   console.log(`${wf.name} (${wf.status}) - trigger: ${wf.triggerType}`);
+   * }
+   * ```
+   */
+  async listWorkflows(params) {
+    return this.http.request("GET", "/skills/workflows", {
+      query: params
+    });
+  }
+  /**
+   * Get a single workflow by ID.
+   *
+   * @param workflowId - Workflow UUID.
+   * @returns Full workflow detail including `agentInputSchema`.
+   *
+   * @example
+   * ```ts
+   * const wf = await client.skills.getWorkflow("workflow-uuid");
+   * console.log(wf.agentInputSchema); // JSON Schema the agent fills
+   * ```
+   */
+  async getWorkflow(workflowId) {
+    return this.http.request("GET", `/skills/workflows/${workflowId}`);
+  }
+  /**
+   * List the organization's AI tasks.
+   *
+   * @param params - Optional search, limit, and offset.
+   * @returns Matching tasks (summary view) and total count.
+   *
+   * @example
+   * ```ts
+   * const { items, total } = await client.skills.listTasks({ limit: 50 });
+   * for (const task of items) {
+   *   console.log(`${task.name} (${task.category}) - ${task.inputFormat} → ${task.outputFormat}`);
+   * }
+   * ```
+   */
+  async listTasks(params) {
+    return this.http.request("GET", "/skills/tasks", {
+      query: params
+    });
+  }
+  /**
+   * Get a single AI task by ID with full detail.
+   *
+   * Includes `jsonInputSchema` and `jsonOutputSchema` when the task uses
+   * structured JSON input/output.
+   *
+   * @param taskId - AI Task UUID.
+   * @returns Full task detail.
+   *
+   * @example
+   * ```ts
+   * const task = await client.skills.getTask("task-uuid");
+   * if (task.jsonInputSchema) {
+   *   console.log("Input schema:", task.jsonInputSchema);
+   * }
+   * ```
+   */
+  async getTask(taskId) {
+    return this.http.request("GET", `/skills/tasks/${taskId}`);
+  }
+  /**
+   * List the organization's knowledge collections.
+   *
+   * @param params - Optional search, limit, and offset.
+   * @returns Matching collections (summary view) and total count.
+   *
+   * @example
+   * ```ts
+   * const { items } = await client.skills.listCollections();
+   * for (const col of items) {
+   *   console.log(`${col.name}: ${col.documentCount} documents`);
+   * }
+   * ```
+   */
+  async listCollections(params) {
+    return this.http.request("GET", "/skills/collections", {
+      query: params
+    });
+  }
+  /**
+   * Get a single knowledge collection by ID with retrieval settings.
+   *
+   * @param collectionId - Collection UUID.
+   * @returns Full collection detail with `k`, `reranker`, etc.
+   *
+   * @example
+   * ```ts
+   * const col = await client.skills.getCollection("collection-uuid");
+   * console.log(`k=${col.k}, reranker=${col.reranker}`);
+   * ```
+   */
+  async getCollection(collectionId) {
+    return this.http.request("GET", `/skills/collections/${collectionId}`);
+  }
+  /**
+   * List the organization's document templates.
+   *
+   * @param params - Optional search, limit, and offset.
+   * @returns Matching templates (summary view) and total count.
+   *
+   * @example
+   * ```ts
+   * const { items } = await client.skills.listDocumentTemplates({ search: "invoice" });
+   * for (const tpl of items) {
+   *   console.log(`${tpl.name} (${tpl.type}) - ${tpl.status}`);
+   * }
+   * ```
+   */
+  async listDocumentTemplates(params) {
+    return this.http.request("GET", "/skills/document-templates", {
+      query: params
+    });
+  }
+  /**
+   * Get a single document template by ID with full detail.
+   *
+   * Includes `inputFormat` (JSON schema of required inputs) and
+   * `slidesInputFormat` (per-slide schemas for presentations).
+   *
+   * @param templateId - Document template UUID.
+   * @returns Full template detail.
+   *
+   * @example
+   * ```ts
+   * const tpl = await client.skills.getDocumentTemplate("template-uuid");
+   * console.log("Input format:", tpl.inputFormat);
+   * ```
+   */
+  async getDocumentTemplate(templateId) {
+    return this.http.request(
+      "GET",
+      `/skills/document-templates/${templateId}`
+    );
+  }
+  // =========================================================================
+  // CREATE OPERATIONS
+  // =========================================================================
+  /**
+   * Create a new document template (metadata only).
+   *
+   * Upload a file separately with `uploadDocumentTemplateFile`.
+   *
+   * @param body - Template name, optional description, and type.
+   * @returns Created template detail.
+   *
+   * @example
+   * ```ts
+   * const tpl = await client.skills.createDocumentTemplate({
+   *   name: "Invoice",
+   *   type: "WORD_FORMAT"
+   * });
+   * ```
+   */
+  async createDocumentTemplate(body) {
+    return this.http.request("POST", "/skills/document-templates", {
+      body
+    });
+  }
+  /**
+   * Upload a file and link it to an existing document template.
+   *
+   * @param templateId - Document template UUID.
+   * @param file - File as a `Blob`, `File`, or `Buffer`.
+   * @param fileName - File name (required when passing a `Blob` or `Buffer`).
+   * @returns Updated template detail with `fileUrl` populated.
+   *
+   * @example
+   * ```ts
+   * import fs from "fs";
+   *
+   * const buffer = fs.readFileSync("template.docx");
+   * const tpl = await client.skills.uploadDocumentTemplateFile(
+   *   "template-uuid",
+   *   new Blob([buffer]),
+   *   "template.docx"
+   * );
+   * console.log(tpl.fileUrl);
+   * ```
+   */
+  async uploadDocumentTemplateFile(templateId, file, fileName) {
+    const formData = new FormData();
+    formData.append("file", file, fileName);
+    return this.http.request(
+      "POST",
+      `/skills/document-templates/${templateId}/upload-file`,
+      { body: formData }
+    );
+  }
+  /**
+   * Create a new GENERATION AI task.
+   *
+   * The category is hardcoded to "GENERATION". The `modelName` is validated
+   * against the available AI models — on invalid model, returns 400 with
+   * the list of valid model names.
+   *
+   * @param body - Task definition.
+   * @returns Created task detail.
+   *
+   * @example
+   * ```ts
+   * const task = await client.skills.createTask({
+   *   name: "Summarize Email",
+   *   modelName: "gpt-4o",
+   *   modelProvider: "OPEN_AI",
+   *   generation: {
+   *     expectedInput: "Raw email text",
+   *     expectedOutput: "A concise 2-sentence summary"
+   *   }
+   * });
+   * ```
+   */
+  async createTask(body) {
+    return this.http.request("POST", "/skills/tasks", { body });
+  }
+  /**
+   * Create a new knowledge collection.
+   *
+   * @param body - Collection name and optional settings.
+   * @returns Created collection detail.
+   *
+   * @example
+   * ```ts
+   * const col = await client.skills.createCollection({
+   *   name: "product-docs",
+   *   displayName: "Product Documentation",
+   *   k: 15
+   * });
+   * ```
+   */
+  async createCollection(body) {
+    return this.http.request("POST", "/skills/collections", { body });
+  }
+  // =========================================================================
+  // EXTERNAL TOOLS (CUSTOM_MANIFEST)
+  // =========================================================================
+  /**
+   * List the organization's external tools (CUSTOM_MANIFEST).
+   *
+   * @param params - Optional search, limit, and offset.
+   * @returns Matching external tools and total count.
+   *
+   * @example
+   * ```ts
+   * const { items, total } = await client.skills.listExternalTools({ search: "weather" });
+   * for (const tool of items) {
+   *   console.log(`${tool.name} (${tool.actionsCount} actions) - auth: ${tool.authType}`);
+   * }
+   * ```
+   */
+  async listExternalTools(params) {
+    return this.http.request("GET", "/skills/external-tools", {
+      query: params
+    });
+  }
+  /**
+   * Get a single external tool by ID.
+   *
+   * @param externalToolId - External tool UUID.
+   * @returns Full external tool detail.
+   *
+   * @example
+   * ```ts
+   * const tool = await client.skills.getExternalTool("tool-uuid");
+   * console.log(`${tool.name}: ${tool.actionsCount} actions, auth: ${tool.authType}`);
+   * ```
+   */
+  async getExternalTool(externalToolId) {
+    return this.http.request("GET", `/skills/external-tools/${externalToolId}`);
+  }
+  /**
+   * Create a new external tool from an OpenAPI spec.
+   *
+   * Parses the provided OpenAPI spec (JSON or YAML), extracts actions,
+   * and creates the tool with the specified auth configuration.
+   *
+   * @param body - Tool name, OpenAPI spec, endpoint URL, and auth config.
+   * @returns Created external tool detail with `actionsCount`.
+   *
+   * @example
+   * ```ts
+   * const tool = await client.skills.createExternalTool({
+   *   name: "Weather API",
+   *   openApiSpec: '{"openapi":"3.0.0",...}',
+   *   endpointUrl: "https://api.weather.com",
+   *   auth: { type: "service_http", apiKey: "sk-...", authorization_type: "bearer" }
+   * });
+   * console.log(`Created: ${tool.name} with ${tool.actionsCount} actions`);
+   * ```
+   */
+  async createExternalTool(body) {
+    return this.http.request("POST", "/skills/external-tools", { body });
+  }
+  /**
+   * Test an external tool action by operationId with input parameters.
+   *
+   * Executes a specific action on an external tool and returns the result.
+   * Optionally uses stored credentials for authentication.
+   *
+   * @param externalToolId - External tool UUID.
+   * @param body - operationId, input params, and optional toolCredentialId.
+   * @returns Execution result with status, output, and timing.
+   *
+   * @example
+   * ```ts
+   * const result = await client.skills.testExternalTool("tool-uuid", {
+   *   operationId: "getWeather",
+   *   input: { city: "London" }
+   * });
+   * console.log(`${result.status} in ${result.executionTimeMs}ms:`, result.output);
+   * ```
+   */
+  async testExternalTool(externalToolId, body) {
+    return this.http.request(
+      "POST",
+      `/skills/external-tools/${externalToolId}/test`,
+      { body }
+    );
+  }
+  // =========================================================================
+  // COLLECTION DOCUMENT LINKING
+  // =========================================================================
+  /**
+   * Attach existing documents to a knowledge collection.
+   *
+   * @param collectionId - Collection UUID.
+   * @param body - Array of document IDs to link.
+   * @returns Status message.
+   *
+   * @example
+   * ```ts
+   * await client.skills.attachDocumentsToCollection("collection-uuid", {
+   *   documentIds: ["doc-1", "doc-2"]
+   * });
+   * ```
+   */
+  async attachDocumentsToCollection(collectionId, body) {
+    return this.http.request(
+      "POST",
+      `/skills/collections/${collectionId}/documents`,
+      { body }
+    );
+  }
+  // =========================================================================
+  // EXECUTION OPERATIONS
+  // =========================================================================
+  /**
+   * Generate a document from a template with variable values.
+   *
+   * @param templateId - Document template UUID.
+   * @param body - Variables to fill in the template.
+   * @returns URL to the generated document.
+   *
+   * @example
+   * ```ts
+   * const { url } = await client.skills.generateDocumentTemplate("template-uuid", {
+   *   variables: { name: "John", date: "2025-01-01" }
+   * });
+   * console.log("Generated document:", url);
+   * ```
+   */
+  async generateDocumentTemplate(templateId, body) {
+    return this.http.request(
+      "POST",
+      `/skills/document-templates/${templateId}/generate`,
+      { body }
+    );
+  }
+  /**
+   * Execute an AI task with input and get the output.
+   *
+   * @param taskId - AI Task UUID.
+   * @param body - Input to the task.
+   * @returns Task output and output type.
+   *
+   * @example
+   * ```ts
+   * const { output, outputType } = await client.skills.executeTask("task-uuid", {
+   *   input: "Summarize this document"
+   * });
+   * console.log(`Output (${outputType}):`, output);
+   * ```
+   */
+  async executeTask(taskId, body) {
+    return this.http.request("POST", `/skills/tasks/${taskId}/execute`, {
+      body
+    });
+  }
+  // ===== COLLECTION MANAGEMENT (Enhanced) =====
+  async listCollectionDocuments(collectionId, params) {
+    const { data, meta } = await this.http.requestWithMeta(
+      "GET",
+      `/skills/collections/${collectionId}/documents`,
+      {
+        query: params
+      }
+    );
+    return { data, meta };
+  }
+  async removeCollectionDocument(collectionId, documentId) {
+    return this.http.request(
+      "DELETE",
+      `/skills/collections/${collectionId}/documents/${documentId}`
+    );
+  }
+  async getCollectionStatistics(collectionId) {
+    return this.http.request("GET", `/skills/collections/${collectionId}/statistics`);
+  }
+  async searchCollection(collectionId, body) {
+    return this.http.request("POST", `/skills/collections/${collectionId}/search`, { body });
+  }
+  async searchMultipleCollections(body) {
+    return this.http.request("POST", "/skills/collections/search", { body });
+  }
+  async updateCollection(collectionId, body) {
+    return this.http.request("PATCH", `/skills/collections/${collectionId}`, { body });
+  }
+  async deleteCollection(collectionId) {
+    return this.http.request("DELETE", `/skills/collections/${collectionId}`);
+  }
+};
+
+// src/resources/tickets.ts
+var TicketsResource = class extends BaseResource {
+  constructor(http) {
+    super(http);
+  }
+  async list(params) {
+    const { data, meta } = await this.http.requestWithMeta("GET", "/tickets", {
+      query: params
+    });
+    return { data, meta };
+  }
+  async get(ticketId) {
+    return this.http.request("GET", `/tickets/${ticketId}`);
+  }
+  async create(body) {
+    return this.http.request("POST", "/tickets", { body });
+  }
+  async update(ticketId, body) {
+    return this.http.request("PATCH", `/tickets/${ticketId}`, { body });
+  }
+  async addComment(ticketId, body) {
+    return this.http.request("POST", `/tickets/${ticketId}/comments`, { body });
+  }
+  async listComments(ticketId) {
+    return this.http.request("GET", `/tickets/${ticketId}/comments`);
+  }
+  async uploadAttachment(ticketId, file) {
+    const formData = new FormData();
+    formData.append("file", file);
+    return this.http.request("POST", `/tickets/${ticketId}/attachments`, {
+      body: formData
+    });
+  }
+  async listAttachments(ticketId) {
+    return this.http.request(
+      "GET",
+      `/tickets/${ticketId}/attachments`
+    );
+  }
+};
+
+// src/resources/tool-connection.ts
+var ToolConnectionResource = class extends BaseResource {
+  /**
+   * Initiate a tool connection via OAuth or create an HTTP credential directly.
+   *
+   * For OAuth, returns an `authorizationUrl` the user must visit, plus a
+   * `handshakeId` for polling. For HTTP, creates the credential immediately.
+   *
+   * @param toolId - Marketplace tool ID.
+   * @param body - Connection type and parameters.
+   * @returns OAuth authorization details or the created HTTP credential.
+   */
+  async connect(toolId, body) {
+    return this.http.request(
+      "POST",
+      `/tools/${toolId}/connect`,
+      { body }
+    );
+  }
+  /**
+   * Poll the status of an OAuth handshake.
+   *
+   * @param handshakeId - Handshake UUID returned by `connect()`.
+   * @returns Current handshake status and connection ID if completed.
+   */
+  async pollStatus(handshakeId) {
+    return this.http.request(
+      "GET",
+      `/tools/connect/${handshakeId}/status`
+    );
+  }
+  /**
+   * Wait for an OAuth handshake to complete by polling at regular intervals.
+   *
+   * Resolves when the status changes from `PENDING` to any terminal state
+   * (`COMPLETED`, `FAILED`, or `EXPIRED`), or when the timeout is reached.
+   *
+   * @param handshakeId - Handshake UUID returned by `connect()`.
+   * @param opts - Optional timeout (default 5 min) and polling interval (default 2 s).
+   * @returns Final handshake status.
+   */
+  async waitForConnection(handshakeId, opts) {
+    const timeout = opts?.timeoutMs ?? 5 * 60 * 1e3;
+    const interval = opts?.intervalMs ?? 2e3;
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+      const status = await this.pollStatus(handshakeId);
+      if (status.status !== "PENDING") return status;
+      await new Promise((r) => setTimeout(r, interval));
+    }
+    return {
+      status: "EXPIRED",
+      connectionId: null,
+      errorMessage: "Polling timed out",
+      expiresAt: null
+    };
+  }
+  /**
+   * Delete a credential (connected account) from a tool.
+   *
+   * @param toolId - Marketplace tool ID.
+   * @param credentialId - Credential UUID to delete.
+   */
+  async deleteCredential(toolId, credentialId) {
+    await this.http.request("DELETE", `/tools/${toolId}/credentials/${credentialId}`);
+  }
+};
+
+// src/resources/tool-discovery.ts
+var ToolDiscoveryResource = class extends BaseResource {
+  /**
+   * Search marketplace tools by keyword with optional category and type filters.
+   * Uses Typesense full-text search with SQL fallback.
+   *
+   * @param params - Search query and filters.
+   * @returns Matching tools, category facets, and total count.
+   *
+   * @example
+   * ```ts
+   * const result = await client.tools.search({ q: "gmail", limit: 5 });
+   * console.log(`Found ${result.total} tools`);
+   * for (const tool of result.tools) {
+   *   console.log(`${tool.name} (${tool.type}): ${tool.description}`);
+   * }
+   * ```
+   */
+  async search(params) {
+    return this.http.request("GET", "/tools/search", {
+      query: params
+    });
+  }
+  /**
+   * Get full marketplace tool detail including actions and their parameter schemas.
+   *
+   * For Pipedream tools, each action's parameters are enriched with the full
+   * component definition including types, descriptions, defaults, and
+   * `remoteOptions` flags indicating which fields need dynamic option resolution.
+   *
+   * @param toolId - Marketplace tool ID (from search results).
+   * @param params - Optional pagination/filter params for actions.
+   * @returns Full tool detail with actions and parameter schemas.
+   *
+   * @example
+   * ```ts
+   * // Get all actions
+   * const detail = await client.tools.get("tool-uuid");
+   * console.log(`${detail.totalActions} total actions`);
+   *
+   * // Paginate actions
+   * const page = await client.tools.get("tool-uuid", { actionsLimit: 10, actionsOffset: 20 });
+   *
+   * // Search for a specific action
+   * const filtered = await client.tools.get("tool-uuid", { actionsSearch: "get-values" });
+   * ```
+   */
+  async get(toolId, params) {
+    return this.http.request("GET", `/tools/${toolId}`, {
+      query: params
+    });
+  }
+  /**
+   * List existing credentials (connected accounts) for a marketplace tool.
+   *
+   * Credentials represent authenticated connections (e.g. a Gmail OAuth token).
+   * They are read-only through this endpoint — users create credentials via the
+   * Nexus dashboard. Use the credential `id` when calling `resolveOptions()` or
+   * when configuring an agent tool.
+   *
+   * @param toolId - Marketplace tool ID.
+   * @returns List of credentials for this tool in the organization.
+   *
+   * @example
+   * ```ts
+   * const { credentials } = await client.tools.credentials("tool-uuid");
+   * if (credentials.length === 0) {
+   *   console.log("No credentials — user must connect account in dashboard first");
+   * }
+   * ```
+   */
+  async credentials(toolId) {
+    return this.http.request("GET", `/tools/${toolId}/credentials`);
+  }
+  /**
+   * Resolve dynamic dropdown options for a tool action parameter.
+   *
+   * Some parameters (those with `remoteOptions: true` in the tool detail) have
+   * values that depend on the user's connected account — for example, a list of
+   * Gmail labels or Slack channels. This method fetches those options at runtime.
+   *
+   * For cascading dependencies (e.g. "select folder" → "select file in folder"),
+   * pass previously selected values in `configuredProps`.
+   *
+   * @param toolId - Marketplace tool ID.
+   * @param body - Component ID, parameter name, credential, and current values.
+   * @returns Available options for the specified parameter.
+   *
+   * @example
+   * ```ts
+   * const { options } = await client.tools.resolveOptions("tool-uuid", {
+   *   componentId: "gmail-send-email",   // from ToolAction.key
+   *   propName: "label",                  // from ToolActionParameter.name
+   *   credentialId: "cred-uuid",          // from ToolCredential.id
+   *   configuredProps: {}                  // previously selected values
+   * });
+   * for (const opt of options) {
+   *   console.log(`${opt.label}: ${opt.value}`);
+   * }
+   * ```
+   */
+  async resolveOptions(toolId, body) {
+    return this.http.request(
+      "POST",
+      `/tools/${toolId}/resolve-options`,
+      { body }
+    );
+  }
+  /**
+   * List the organization's skills — workflows, AI tasks, and collections.
+   *
+   * Skills are org-owned assets that can be attached to agents as tool
+   * configurations of type WORKFLOW, TASK, or COLLECTION (as opposed to
+   * marketplace PLUGIN tools).
+   *
+   * @param params - Optional type filter, search, and pagination.
+   * @returns Matching skills and total count.
+   *
+   * @example
+   * ```ts
+   * // List all workflows
+   * const { skills, total } = await client.tools.skills({ type: "WORKFLOW" });
+   * console.log(`${total} workflows found`);
+   *
+   * // Search across all skill types
+   * const result = await client.tools.skills({ search: "onboarding", limit: 10 });
+   * ```
+   */
+  async skills(params) {
+    return this.http.request("GET", "/tools/skills", {
+      query: params
+    });
+  }
+  /**
+   * Test-execute a configured agent tool with sample input.
+   *
+   * This runs the tool using its saved configuration (action, credentials,
+   * parameter setup) and returns the execution result. Use this to verify a
+   * tool is correctly configured before deploying the agent.
+   *
+   * @param agentId - Agent UUID that owns the tool config.
+   * @param toolConfigId - Agent tool configuration UUID (from `client.agents.tools.list()`).
+   * @param body - Sample input values to pass to the tool.
+   * @returns Execution result with status, output, and timing.
+   *
+   * @example
+   * ```ts
+   * const result = await client.tools.test("agent-uuid", "tool-config-uuid", {
+   *   input: { to: "test@example.com", subject: "Hello", body: "Test email" }
+   * });
+   * if (result.status === "success") {
+   *   console.log(`Executed in ${result.executionTimeMs}ms`, result.output);
+   * } else {
+   *   console.error(`Tool error: ${result.error}`);
+   * }
+   * ```
+   */
+  async test(agentId, toolConfigId, body) {
+    return this.http.request(
+      "POST",
+      `/agents/${agentId}/tools/${toolConfigId}/test`,
+      { body }
+    );
+  }
+};
+
+// src/resources/workflow-executions.ts
+var WorkflowExecutionsResource = class extends BaseResource {
+  async list(params) {
+    const { data, meta } = await this.http.requestWithMeta("GET", "/workflows/executions", {
+      query: params
+    });
+    return { data, meta };
+  }
+  async listByWorkflow(workflowId, params) {
+    const { data, meta } = await this.http.requestWithMeta(
+      "GET",
+      `/workflows/${workflowId}/executions`,
+      {
+        query: params
+      }
+    );
+    return { data, meta };
+  }
+  async get(executionId) {
+    return this.http.request("GET", `/workflows/executions/${executionId}`);
+  }
+  async getGraph(executionId) {
+    return this.http.request("GET", `/workflows/executions/${executionId}/graph`);
+  }
+  async getNodeResult(executionId, nodeId) {
+    return this.http.request("GET", `/workflows/executions/${executionId}/nodes/${nodeId}`);
+  }
+  async getOutput(executionId) {
+    return this.http.request("GET", `/workflows/executions/${executionId}/output`);
+  }
+  async retryNode(executionId, nodeId) {
+    return this.http.request(
+      "POST",
+      `/workflows/executions/${executionId}/nodes/${nodeId}/retry`
+    );
+  }
+  async export(executionId) {
+    return this.http.request("POST", `/workflows/executions/${executionId}/export`);
+  }
+};
+
+// src/resources/workflows.ts
+var WorkflowsResource = class extends BaseResource {
+  // =========================================================================
+  // CRUD
+  // =========================================================================
+  /**
+   * List workflows with optional filtering and pagination.
+   *
+   * @param params - Optional status filter, search, and pagination.
+   * @returns Paginated list of workflow summaries.
+   */
+  async list(params) {
+    const { data, meta } = await this.http.requestWithMeta("GET", "/workflows", {
+      query: params
+    });
+    return { data, meta };
+  }
+  /**
+   * Create a new workflow.
+   *
+   * @param body - Workflow name and optional description.
+   * @returns The created workflow detail.
+   */
+  async create(body) {
+    return this.http.request("POST", "/workflows", { body });
+  }
+  /**
+   * Get detailed information about a specific workflow, including nodes and edges.
+   *
+   * @param workflowId - Workflow UUID.
+   * @returns Full workflow detail.
+   */
+  async get(workflowId) {
+    return this.http.request("GET", `/workflows/${workflowId}`);
+  }
+  /**
+   * Update an existing workflow's properties. Only provided fields are updated.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param body - Fields to update.
+   * @returns The updated workflow detail.
+   */
+  async update(workflowId, body) {
+    return this.http.request("PATCH", `/workflows/${workflowId}`, { body });
+  }
+  /**
+   * Permanently delete a workflow and all its nodes, edges, and executions.
+   *
+   * @param workflowId - Workflow UUID.
+   * @returns Confirmation with the deleted workflow's ID.
+   */
+  async delete(workflowId) {
+    return this.http.request("DELETE", `/workflows/${workflowId}`);
+  }
+  /**
+   * Create a copy of an existing workflow.
+   *
+   * @param workflowId - Workflow UUID to duplicate.
+   * @returns The newly created workflow detail.
+   */
+  async duplicate(workflowId) {
+    return this.http.request("POST", `/workflows/${workflowId}/duplicate`);
+  }
+  /**
+   * Publish a workflow, making it available for execution.
+   *
+   * @param workflowId - Workflow UUID.
+   * @returns Publish confirmation with updated status.
+   */
+  async publish(workflowId) {
+    return this.http.request("POST", `/workflows/${workflowId}/publish`);
+  }
+  /**
+   * Unpublish a workflow, reverting it to draft status.
+   *
+   * @param workflowId - Workflow UUID.
+   * @returns Unpublish confirmation with updated status.
+   */
+  async unpublish(workflowId) {
+    return this.http.request("POST", `/workflows/${workflowId}/unpublish`);
+  }
+  /**
+   * Upload an icon image for a workflow.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param file - Image file as a Blob or File.
+   * @returns URL of the uploaded icon.
+   */
+  async uploadIcon(workflowId, file) {
+    const formData = new FormData();
+    formData.append("file", file);
+    return this.http.request("POST", `/workflows/${workflowId}/icon`, {
+      body: formData
+    });
+  }
+  // =========================================================================
+  // BUILDER (Node Types)
+  // =========================================================================
+  /**
+   * List all available node types for the workflow builder.
+   *
+   * @returns Array of node type summaries.
+   */
+  async listNodeTypes() {
+    return this.http.request("GET", "/workflows/node-types");
+  }
+  /**
+   * Get the full schema for a specific node type, including fields and connection rules.
+   *
+   * @param nodeType - Node type identifier.
+   * @returns Node type schema with fields, configuration steps, and defaults.
+   */
+  async getNodeTypeSchema(nodeType) {
+    return this.http.request("GET", `/workflows/node-types/${nodeType}`);
+  }
+  // =========================================================================
+  // NODES
+  // =========================================================================
+  /**
+   * Create a new node in a workflow.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param body - Node type, position, data, and optional parent.
+   * @returns The created node.
+   */
+  async createNode(workflowId, body) {
+    return this.http.request("POST", `/workflows/${workflowId}/nodes`, { body });
+  }
+  /**
+   * Get a specific node within a workflow.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param nodeId - Node UUID.
+   * @returns The node detail.
+   */
+  async getNode(workflowId, nodeId) {
+    return this.http.request("GET", `/workflows/${workflowId}/nodes/${nodeId}`);
+  }
+  /**
+   * Update a node's data. Only the `data` field is replaced.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param nodeId - Node UUID.
+   * @param body - New data for the node.
+   * @returns The updated node.
+   */
+  async updateNode(workflowId, nodeId, body) {
+    return this.http.request("PATCH", `/workflows/${workflowId}/nodes/${nodeId}`, {
+      body
+    });
+  }
+  /**
+   * Delete a node from a workflow. Connected edges are also removed.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param nodeId - Node UUID.
+   * @returns Confirmation with the deleted node's ID.
+   */
+  async deleteNode(workflowId, nodeId) {
+    return this.http.request("DELETE", `/workflows/${workflowId}/nodes/${nodeId}`);
+  }
+  /**
+   * Reload dynamic properties for a node (e.g. after selecting a tool or action).
+   *
+   * @param workflowId - Workflow UUID.
+   * @param nodeId - Node UUID.
+   * @param body - Currently configured props and optional dynamic props ID.
+   * @returns Updated parameters setup and any errors.
+   */
+  async reloadProps(workflowId, nodeId, body) {
+    return this.http.request(
+      "POST",
+      `/workflows/${workflowId}/nodes/${nodeId}/reload-props`,
+      { body }
+    );
+  }
+  /**
+   * Replace the trigger node of a workflow with a different trigger type.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param body - New trigger type.
+   * @returns The updated workflow detail.
+   */
+  async replaceTrigger(workflowId, body) {
+    return this.http.request("PUT", `/workflows/${workflowId}/trigger`, { body });
+  }
+  // =========================================================================
+  // BRANCHES
+  // =========================================================================
+  /**
+   * List branches on a conditional or router node.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param nodeId - Node UUID.
+   * @returns Array of branches.
+   */
+  async listBranches(workflowId, nodeId) {
+    return this.http.request("GET", `/workflows/${workflowId}/nodes/${nodeId}/branches`);
+  }
+  /**
+   * Create a new branch on a conditional or router node.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param nodeId - Node UUID.
+   * @param body - Branch name and optional description.
+   * @returns The created branch.
+   */
+  async createBranch(workflowId, nodeId, body) {
+    return this.http.request("POST", `/workflows/${workflowId}/nodes/${nodeId}/branches`, {
+      body
+    });
+  }
+  /**
+   * Update a branch on a node.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param nodeId - Node UUID.
+   * @param branchId - Branch UUID.
+   * @param body - Fields to update.
+   * @returns The updated branch.
+   */
+  async updateBranch(workflowId, nodeId, branchId, body) {
+    return this.http.request(
+      "PATCH",
+      `/workflows/${workflowId}/nodes/${nodeId}/branches/${branchId}`,
+      { body }
+    );
+  }
+  /**
+   * Delete a branch from a node.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param nodeId - Node UUID.
+   * @param branchId - Branch UUID.
+   * @returns Confirmation with the deleted branch's ID.
+   */
+  async deleteBranch(workflowId, nodeId, branchId) {
+    return this.http.request(
+      "DELETE",
+      `/workflows/${workflowId}/nodes/${nodeId}/branches/${branchId}`
+    );
+  }
+  // =========================================================================
+  // EDGES
+  // =========================================================================
+  /**
+   * Create an edge between two nodes in a workflow.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param body - Source node, target node, optional handle and type.
+   * @returns The created edge.
+   */
+  async createEdge(workflowId, body) {
+    return this.http.request("POST", `/workflows/${workflowId}/edges`, { body });
+  }
+  /**
+   * Delete an edge from a workflow.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param edgeId - Edge UUID.
+   * @returns Confirmation with the deleted edge's ID.
+   */
+  async deleteEdge(workflowId, edgeId) {
+    return this.http.request("DELETE", `/workflows/${workflowId}/edges/${edgeId}`);
+  }
+  // =========================================================================
+  // OVERVIEW
+  // =========================================================================
+  /**
+   * Get a high-level overview of a workflow with node summaries.
+   *
+   * @param workflowId - Workflow UUID.
+   * @returns Workflow overview with node labels and config statuses.
+   */
+  async getOverview(workflowId) {
+    return this.http.request("GET", `/workflows/${workflowId}/overview`);
+  }
+  /**
+   * Auto-layout the nodes in a workflow graph.
+   *
+   * @param workflowId - Workflow UUID.
+   * @returns The updated workflow detail with new node positions.
+   */
+  async layout(workflowId) {
+    return this.http.request("POST", `/workflows/${workflowId}/layout`);
+  }
+  /**
+   * Get variables available to a specific node from upstream nodes.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param nodeId - Node UUID.
+   * @returns Array of available variables grouped by source node.
+   */
+  async getAvailableVariables(workflowId, nodeId) {
+    return this.http.request(
+      "GET",
+      `/workflows/${workflowId}/nodes/${nodeId}/available-variables`
+    );
+  }
+  /**
+   * Get the output format definition for a specific node.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param nodeId - Node UUID.
+   * @returns Output format with source indicator.
+   */
+  async getOutputFormat(workflowId, nodeId) {
+    return this.http.request(
+      "GET",
+      `/workflows/${workflowId}/nodes/${nodeId}/output-format`
+    );
+  }
+  /**
+   * Validate a workflow for completeness and correctness.
+   *
+   * @param workflowId - Workflow UUID.
+   * @returns Validation report with node issues and graph issues.
+   */
+  async validate(workflowId) {
+    return this.http.request("GET", `/workflows/${workflowId}/validate`);
+  }
+  // =========================================================================
+  // TESTING
+  // =========================================================================
+  /**
+   * Test-execute a single node with optional input.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param nodeId - Node UUID.
+   * @param body - Optional input data for the node.
+   * @returns Execution ID for polling status.
+   */
+  async testNode(workflowId, nodeId, body) {
+    return this.http.request("POST", `/workflows/${workflowId}/nodes/${nodeId}/test`, {
+      body
+    });
+  }
+  /**
+   * Test-execute an entire workflow with optional trigger data.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param body - Optional trigger data to start the workflow.
+   * @returns Execution ID for polling status.
+   */
+  async testWorkflow(workflowId, body) {
+    return this.http.request("POST", `/workflows/${workflowId}/test`, { body });
+  }
+  /**
+   * Get the status of a workflow execution.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param executionId - Execution UUID.
+   * @returns Execution status with per-node statuses.
+   */
+  async getExecutionStatus(workflowId, executionId) {
+    return this.http.request(
+      "GET",
+      `/workflows/${workflowId}/executions/${executionId}`
+    );
+  }
+  /**
+   * Get the execution result for a specific node within a workflow execution.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param executionId - Execution UUID.
+   * @param nodeId - Node UUID.
+   * @returns Node execution result with input, output, and logs.
+   */
+  async getNodeExecutionResult(workflowId, executionId, nodeId) {
+    return this.http.request(
+      "GET",
+      `/workflows/${workflowId}/executions/${executionId}/nodes/${nodeId}`
+    );
+  }
+  /**
+   * Stop a running workflow execution.
+   *
+   * @param workflowId - Workflow UUID.
+   * @param executionId - Execution UUID.
+   * @returns Updated execution status.
+   */
+  async stopExecution(workflowId, executionId) {
+    return this.http.request(
+      "POST",
+      `/workflows/${workflowId}/executions/${executionId}/stop`
+    );
+  }
+};
+
+// src/client.ts
+function getEnv(key) {
+  try {
+    return typeof process !== "undefined" ? process.env[key] : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var NexusClient = class {
+  constructor(opts = {}) {
+    const apiKey = opts.apiKey ?? getEnv("NEXUS_API_KEY");
+    if (!apiKey) {
+      throw new NexusError(
+        "No API key provided. Pass `apiKey` in options or set the NEXUS_API_KEY environment variable."
+      );
+    }
+    const baseUrl = opts.baseUrl ?? getEnv("NEXUS_BASE_URL") ?? "https://api.nexusgpt.io";
+    const http = new HttpClient({
+      baseUrl,
+      apiKey,
+      fetch: opts.fetch,
+      defaultHeaders: opts.defaultHeaders,
+      timeout: opts.timeout
+    });
+    this.agents = new AgentsResource(http);
+    this.documents = new DocumentsResource(http);
+    this.folders = new FoldersResource(http);
+    this.models = new ModelsResource(http);
+    this.tools = new ToolDiscoveryResource(http);
+    this.skills = new SkillsResource(http);
+    this.workflows = new WorkflowsResource(http);
+    this.toolConnection = new ToolConnectionResource(http);
+    this.deployments = new DeploymentsResource(http);
+    this.emulator = new EmulatorResource(http);
+    this.deploymentFolders = new DeploymentFoldersResource(http);
+    this.documentTemplateFolders = new DocumentTemplateFoldersResource(http);
+    this.analytics = new AnalyticsResource(http);
+    this.agentCollections = new AgentCollectionsResource(http);
+    this.workflowExecutions = new WorkflowExecutionsResource(http);
+    this.evaluations = new EvaluationsResource(http);
+    this.cloudImports = new CloudImportsResource(http);
+    this.promptAssistant = new PromptAssistantResource(http);
+    this.tickets = new TicketsResource(http);
+  }
+};
+export {
+  AgentCollectionsResource,
+  AgentToolsResource,
+  AgentsResource,
+  AnalyticsResource,
+  CloudImportsResource,
+  DeploymentFoldersResource,
+  DeploymentsResource,
+  DocumentTemplateFoldersResource,
+  DocumentsResource,
+  EmulatorResource,
+  EvaluationsResource,
+  FoldersResource,
+  HttpClient,
+  ModelsResource,
+  NexusApiError,
+  NexusAuthenticationError,
+  NexusClient,
+  NexusConnectionError,
+  NexusError,
+  PromptAssistantResource,
+  SkillsResource,
+  TicketsResource,
+  ToolConnectionResource,
+  ToolDiscoveryResource,
+  VersionsResource,
+  WorkflowExecutionsResource,
+  WorkflowsResource
+};