@dexto/client-sdk 1.1.5

package/dist/index.cjs

@@ -0,0 +1,849 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ClientError: () => ClientError,
+  DextoClient: () => DextoClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var ClientError = class {
+  /**
+   * Connection and Network Errors
+   */
+  static connectionFailed(baseUrl, originalError) {
+    const error = new Error(`Failed to connect to Dexto server at ${baseUrl}`);
+    error.name = "ConnectionError";
+    error.baseUrl = baseUrl;
+    error.originalError = originalError == null ? void 0 : originalError.message;
+    return error;
+  }
+  static networkError(message, originalError) {
+    const error = new Error(`Network error: ${message}`);
+    error.name = "NetworkError";
+    error.originalError = originalError == null ? void 0 : originalError.message;
+    return error;
+  }
+  static httpError(status, statusText, endpoint, details) {
+    const error = new Error(`HTTP ${status}: ${statusText}${endpoint ? ` (${endpoint})` : ""}`);
+    error.name = "HttpError";
+    error.status = status;
+    error.statusText = statusText;
+    error.endpoint = endpoint;
+    error.details = details;
+    return error;
+  }
+  static timeoutError(operation, timeout) {
+    const error = new Error(`Operation '${operation}' timed out after ${timeout}ms`);
+    error.name = "TimeoutError";
+    error.operation = operation;
+    error.timeout = timeout;
+    return error;
+  }
+  /**
+   * WebSocket Errors
+   */
+  static websocketConnectionFailed(url, originalError) {
+    const error = new Error(`Failed to connect WebSocket to ${url}`);
+    error.name = "WebSocketConnectionError";
+    error.url = url;
+    error.originalError = originalError == null ? void 0 : originalError.message;
+    return error;
+  }
+  static websocketSendFailed(originalError) {
+    const error = new Error("Failed to send WebSocket message");
+    error.name = "WebSocketSendError";
+    error.originalError = originalError == null ? void 0 : originalError.message;
+    return error;
+  }
+  /**
+   * Configuration Errors
+   */
+  static invalidConfig(field, value, reason) {
+    const error = new Error(`Invalid configuration for ${field}: ${reason}`);
+    error.name = "InvalidConfigError";
+    error.field = field;
+    error.value = value;
+    error.reason = reason;
+    return error;
+  }
+  static responseParseError(originalError) {
+    const error = new Error("Failed to parse server response");
+    error.name = "ResponseParseError";
+    error.originalError = originalError == null ? void 0 : originalError.message;
+    return error;
+  }
+};
+
+// src/http-client.ts
+var HttpClient = class {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "fetchFn");
+    this.config = config;
+    if (typeof window !== "undefined" && window.fetch) {
+      this.fetchFn = window.fetch.bind(window);
+    } else if (typeof globalThis !== "undefined" && globalThis.fetch) {
+      this.fetchFn = globalThis.fetch;
+    } else {
+      throw ClientError.invalidConfig(
+        "fetch",
+        "unavailable",
+        "No fetch implementation available. Use Node.js 18+ or a browser."
+      );
+    }
+  }
+  async request(endpoint, options = {}) {
+    var _a;
+    const { method = "GET", body, headers = {}, timeout = this.config.timeout } = options;
+    const url = new URL(endpoint, this.config.baseUrl).toString();
+    const requestHeaders = { ...headers };
+    const hasContentType = Object.keys(requestHeaders).some(
+      (k) => k.toLowerCase() === "content-type"
+    );
+    let payload = void 0;
+    const isBodyInit = (b) => {
+      if (b == null) return false;
+      return typeof b === "string" || typeof globalThis.Blob !== "undefined" && b instanceof globalThis.Blob || typeof globalThis.FormData !== "undefined" && b instanceof globalThis.FormData || typeof globalThis.URLSearchParams !== "undefined" && b instanceof globalThis.URLSearchParams || typeof globalThis.ReadableStream !== "undefined" && b instanceof globalThis.ReadableStream || typeof ArrayBuffer !== "undefined" && b instanceof ArrayBuffer;
+    };
+    if (body !== void 0) {
+      if (isBodyInit(body)) {
+        payload = body;
+      } else {
+        payload = JSON.stringify(body);
+        if (!hasContentType) {
+          requestHeaders["Content-Type"] = "application/json";
+        }
+      }
+    }
+    if (this.config.apiKey) {
+      requestHeaders["Authorization"] = `Bearer ${this.config.apiKey}`;
+    }
+    const requestInit = {
+      method,
+      headers: requestHeaders,
+      ...payload !== void 0 && { body: payload }
+    };
+    const controller = new AbortController();
+    const resolvedTimeout = (_a = timeout != null ? timeout : this.config.timeout) != null ? _a : 3e4;
+    const timeoutId = setTimeout(() => controller.abort(), resolvedTimeout);
+    requestInit.signal = controller.signal;
+    try {
+      const response = await this.fetchWithRetry(url, requestInit);
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorData = await this.safeParseJson(response);
+        throw ClientError.httpError(
+          response.status,
+          response.statusText,
+          endpoint,
+          errorData
+        );
+      }
+      if (response.status === 204 || response.headers.get("content-length") === "0") {
+        return {};
+      }
+      const contentType = response.headers.get("content-type") || "";
+      if (contentType.includes("application/json")) {
+        const data = await response.json();
+        return data;
+      }
+      const text = await response.text();
+      return text ? text : {};
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name.startsWith("ClientError")) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw ClientError.timeoutError(endpoint, resolvedTimeout);
+      }
+      throw ClientError.networkError(
+        error instanceof Error ? error.message : "Unknown network error",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  async fetchWithRetry(url, init) {
+    var _a;
+    let lastError = null;
+    const method = (init.method || "GET").toUpperCase();
+    const canRetry = ["GET", "HEAD", "PUT", "DELETE"].includes(method);
+    const maxRetries = (_a = this.config.retries) != null ? _a : 3;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const response = await this.fetchFn(url, init);
+        const transientStatus = [429, 502, 503, 504];
+        if (canRetry && transientStatus.includes(response.status) && attempt < maxRetries) {
+          const retryAfter = response.headers.get("retry-after");
+          let delay = Math.min(1e3 * Math.pow(2, attempt), 1e4);
+          if (retryAfter) {
+            const secs = Number(retryAfter);
+            if (Number.isFinite(secs) && secs >= 0) {
+              delay = secs * 1e3;
+            } else {
+              const retryTime = Date.parse(retryAfter);
+              if (retryTime > Date.now()) {
+                delay = Math.max(0, retryTime - Date.now());
+              }
+            }
+          }
+          delay = Math.min(delay, 3e4);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          continue;
+        }
+        return response;
+      } catch (error) {
+        lastError = error instanceof Error ? error : ClientError.networkError(
+          error instanceof Error ? error.message : String(error),
+          error instanceof Error ? error : void 0
+        );
+        if (attempt === maxRetries || !canRetry || error instanceof Error && error.name === "AbortError") {
+          break;
+        }
+        const delay = Math.min(1e3 * Math.pow(2, attempt), 1e4);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    throw lastError;
+  }
+  async safeParseJson(response) {
+    try {
+      return await response.json();
+    } catch (e) {
+      return null;
+    }
+  }
+  // Convenience methods
+  async get(endpoint, headers) {
+    const options = { method: "GET" };
+    if (headers) options.headers = headers;
+    return this.request(endpoint, options);
+  }
+  async post(endpoint, body, headers) {
+    const options = { method: "POST" };
+    if (body !== void 0) options.body = body;
+    if (headers) options.headers = headers;
+    return this.request(endpoint, options);
+  }
+  async put(endpoint, body, headers) {
+    const options = { method: "PUT" };
+    if (body !== void 0) options.body = body;
+    if (headers) options.headers = headers;
+    return this.request(endpoint, options);
+  }
+  async delete(endpoint, headers) {
+    const options = { method: "DELETE" };
+    if (headers) options.headers = headers;
+    return this.request(endpoint, options);
+  }
+};
+
+// src/websocket-client.ts
+var WebSocketClient = class {
+  constructor(url, options = {}) {
+    __publicField(this, "ws", null);
+    __publicField(this, "url");
+    __publicField(this, "eventHandlers", /* @__PURE__ */ new Map());
+    __publicField(this, "stateHandlers", /* @__PURE__ */ new Set());
+    __publicField(this, "reconnectEnabled", true);
+    __publicField(this, "reconnectInterval", 5e3);
+    __publicField(this, "maxReconnectAttempts", 10);
+    __publicField(this, "reconnectAttempts", 0);
+    __publicField(this, "isIntentionallyClosed", false);
+    var _a, _b, _c;
+    this.url = url;
+    this.reconnectEnabled = (_a = options.reconnect) != null ? _a : true;
+    this.reconnectInterval = (_b = options.reconnectInterval) != null ? _b : 5e3;
+    this.maxReconnectAttempts = (_c = options.maxReconnectAttempts) != null ? _c : 10;
+  }
+  connect() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.isIntentionallyClosed = false;
+        this.emitState("connecting");
+        if (typeof WebSocket !== "undefined") {
+          this.ws = new WebSocket(this.url);
+        } else {
+          reject(
+            ClientError.websocketConnectionFailed(
+              this.url,
+              new Error(
+                "WebSocket not available in this environment. Use HTTP methods or run in a browser."
+              )
+            )
+          );
+          return;
+        }
+        this.setupEventHandlers(resolve, reject);
+      } catch (error) {
+        reject(
+          ClientError.websocketConnectionFailed(
+            this.url,
+            error instanceof Error ? error : new Error("Failed to create WebSocket connection")
+          )
+        );
+      }
+    });
+  }
+  setupEventHandlers(resolve, reject) {
+    if (!this.ws) return;
+    this.ws.onopen = () => {
+      this.reconnectAttempts = 0;
+      this.emitState("open");
+      resolve();
+    };
+    this.ws.onmessage = (event) => {
+      const raw = event.data;
+      const tryDispatch = (text) => {
+        try {
+          this.handleIncomingMessage(JSON.parse(text));
+        } catch (err) {
+          console.warn(
+            `[WebSocketClient] Failed to parse WebSocket message: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      };
+      if (typeof raw === "string") {
+        tryDispatch(raw);
+      } else if (typeof globalThis.Blob !== "undefined" && raw instanceof globalThis.Blob) {
+        raw.text().then(tryDispatch).catch((err) => {
+          console.warn(
+            `[WebSocketClient] Failed to read Blob message: ${err instanceof Error ? err.message : String(err)}`
+          );
+        });
+      } else if (typeof ArrayBuffer !== "undefined" && raw instanceof ArrayBuffer) {
+        try {
+          const text = new globalThis.TextDecoder().decode(raw);
+          tryDispatch(text);
+        } catch (err) {
+          console.warn(
+            `[WebSocketClient] Failed to decode ArrayBuffer message: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      } else {
+        console.warn(
+          `[WebSocketClient] Ignoring non-text WebSocket message of type: ${Object.prototype.toString.call(raw)}`
+        );
+      }
+    };
+    this.ws.onclose = (_event) => {
+      this.emitState("closed");
+      const shouldReconnect = !this.isIntentionallyClosed && this.reconnectEnabled && this.reconnectAttempts < this.maxReconnectAttempts;
+      if (shouldReconnect) {
+        this.scheduleReconnect(resolve, reject);
+      } else if (!this.isIntentionallyClosed && this.reconnectAttempts >= this.maxReconnectAttempts) {
+        reject(
+          ClientError.websocketConnectionFailed(
+            this.url,
+            new Error(`Max reconnect attempts reached (${this.maxReconnectAttempts})`)
+          )
+        );
+      }
+    };
+    this.ws.onerror = (_error) => {
+      this.emitState("error");
+      if (this.reconnectAttempts === 0) {
+        reject(ClientError.websocketConnectionFailed(this.url));
+      }
+    };
+  }
+  scheduleReconnect(resolve, reject) {
+    this.reconnectAttempts++;
+    setTimeout(() => {
+      if (!this.isIntentionallyClosed) {
+        this.emitState("connecting");
+        if (resolve && reject) {
+          this.connect().then(resolve).catch(reject);
+        } else {
+          this.connect().catch(() => {
+          });
+        }
+      }
+    }, this.reconnectInterval);
+  }
+  handleIncomingMessage(data) {
+    var _a;
+    const msgData = data;
+    const eventType = msgData.type || msgData.event;
+    if (!eventType) {
+      console.warn("Received WebSocket message without event type:", msgData);
+      return;
+    }
+    const event = {
+      type: eventType,
+      data: msgData.data || msgData,
+      sessionId: msgData.sessionId || ((_a = msgData.data) == null ? void 0 : _a.sessionId)
+    };
+    const handlers = this.eventHandlers.get(event.type);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(event);
+        } catch (error) {
+          console.error(
+            `Error in event handler for ${event.type}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      });
+    }
+    const wildcardHandlers = this.eventHandlers.get("*");
+    if (wildcardHandlers) {
+      wildcardHandlers.forEach((handler) => {
+        try {
+          handler(event);
+        } catch (error) {
+          console.error(
+            `Error in wildcard event handler: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      });
+    }
+  }
+  // Send a message through the WebSocket
+  send(message) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return false;
+    }
+    try {
+      this.ws.send(JSON.stringify(message));
+      return true;
+    } catch (error) {
+      console.error(
+        `Failed to send WebSocket message: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return false;
+    }
+  }
+  // Subscribe to specific event types
+  on(eventType, handler) {
+    if (!this.eventHandlers.has(eventType)) {
+      this.eventHandlers.set(eventType, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(eventType).add(handler);
+    return () => {
+      const handlers = this.eventHandlers.get(eventType);
+      if (handlers) {
+        handlers.delete(handler);
+        if (handlers.size === 0) {
+          this.eventHandlers.delete(eventType);
+        }
+      }
+    };
+  }
+  // Subscribe to connection state changes
+  onConnectionState(handler) {
+    this.stateHandlers.add(handler);
+    return () => {
+      this.stateHandlers.delete(handler);
+    };
+  }
+  emitState(state) {
+    this.stateHandlers.forEach((handler) => {
+      try {
+        handler(state);
+      } catch (error) {
+        console.error(
+          `Error in connection state handler: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    });
+  }
+  // Get current connection state
+  get state() {
+    if (!this.ws) return "closed";
+    switch (this.ws.readyState) {
+      case WebSocket.CONNECTING:
+        return "connecting";
+      case WebSocket.OPEN:
+        return "open";
+      case WebSocket.CLOSING:
+      case WebSocket.CLOSED:
+        return "closed";
+      default:
+        return "closed";
+    }
+  }
+  // Close the connection
+  close() {
+    this.isIntentionallyClosed = true;
+    this.reconnectEnabled = false;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  // Enable/disable automatic reconnection
+  setReconnectEnabled(enabled) {
+    this.reconnectEnabled = enabled;
+  }
+};
+
+// src/schemas.ts
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return /^https?:\/\//i.test(url);
+  } catch (e) {
+    return false;
+  }
+}
+
+// src/client.ts
+var DextoClient = class {
+  constructor(config, options = {}) {
+    __publicField(this, "http");
+    __publicField(this, "ws", null);
+    __publicField(this, "config");
+    __publicField(this, "options");
+    var _a, _b, _c, _d, _e, _f;
+    if (!isValidUrl(config.baseUrl)) {
+      throw ClientError.invalidConfig(
+        "baseUrl",
+        config.baseUrl,
+        "Must be a valid HTTP/HTTPS URL"
+      );
+    }
+    this.config = {
+      baseUrl: config.baseUrl,
+      apiKey: config.apiKey,
+      timeout: (_a = config.timeout) != null ? _a : 3e4,
+      retries: (_b = config.retries) != null ? _b : 3
+    };
+    this.options = {
+      enableWebSocket: (_c = options.enableWebSocket) != null ? _c : true,
+      reconnect: (_d = options.reconnect) != null ? _d : true,
+      reconnectInterval: (_e = options.reconnectInterval) != null ? _e : 5e3,
+      debug: (_f = options.debug) != null ? _f : false
+    };
+    this.http = new HttpClient(this.config);
+    if (this.options.enableWebSocket) {
+      this.initializeWebSocket();
+    }
+  }
+  initializeWebSocket() {
+    var _a, _b;
+    const wsUrl = this.config.baseUrl.replace(/^https/, "wss").replace(/^http/, "ws");
+    this.ws = new WebSocketClient(wsUrl, {
+      reconnect: (_a = this.options.reconnect) != null ? _a : true,
+      reconnectInterval: (_b = this.options.reconnectInterval) != null ? _b : 5e3
+    });
+  }
+  // ============= CONNECTION MANAGEMENT =============
+  /**
+   * Establish connection to Dexto server (including WebSocket if enabled)
+   */
+  async connect() {
+    try {
+      await this.http.get("/health");
+    } catch (error) {
+      throw ClientError.connectionFailed(
+        this.config.baseUrl,
+        error instanceof Error ? error : void 0
+      );
+    }
+    if (this.options.enableWebSocket && this.ws) {
+      try {
+        await this.ws.connect();
+      } catch (error) {
+        if (this.options.debug) {
+          console.warn(
+            `WebSocket connection failed, continuing with HTTP-only mode: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        this.ws = null;
+      }
+    }
+  }
+  /**
+   * Disconnect from Dexto server
+   */
+  disconnect() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  // ============= MESSAGING =============
+  /**
+   * Send a message to the Dexto agent
+   */
+  async sendMessage(input) {
+    if (input.stream === true) {
+      throw ClientError.invalidConfig(
+        "input.stream",
+        input.stream,
+        "Use sendMessageStream() for streaming responses"
+      );
+    }
+    const endpoint = "/api/message-sync";
+    const requestBody = {
+      message: input.content,
+      ...input.sessionId && { sessionId: input.sessionId },
+      ...input.imageData && { imageData: input.imageData },
+      ...input.fileData && { fileData: input.fileData }
+    };
+    return this.http.post(endpoint, requestBody);
+  }
+  /**
+   * Send a message via WebSocket for streaming responses
+   */
+  sendMessageStream(input) {
+    if (!this.ws || this.ws.state !== "open") {
+      throw ClientError.connectionFailed(
+        "WebSocket endpoint",
+        new Error("WebSocket connection not available for streaming")
+      );
+    }
+    return this.ws.send({
+      type: "message",
+      content: input.content,
+      ...input.sessionId && { sessionId: input.sessionId },
+      ...input.imageData && { imageData: input.imageData },
+      ...input.fileData && { fileData: input.fileData },
+      stream: true
+    });
+  }
+  // ============= SESSION MANAGEMENT =============
+  /**
+   * List all sessions
+   */
+  async listSessions() {
+    const response = await this.http.get("/api/sessions");
+    return response.sessions;
+  }
+  /**
+   * Create a new session
+   */
+  async createSession(sessionId) {
+    const response = await this.http.post("/api/sessions", {
+      ...sessionId && { sessionId }
+    });
+    return response.session;
+  }
+  /**
+   * Get session details
+   */
+  async getSession(sessionId) {
+    const response = await this.http.get(
+      `/api/sessions/${encodeURIComponent(sessionId)}`
+    );
+    return response.session;
+  }
+  /**
+   * Get session conversation history
+   */
+  async getSessionHistory(sessionId) {
+    const response = await this.http.get(
+      `/api/sessions/${encodeURIComponent(sessionId)}/history`
+    );
+    return response.history;
+  }
+  /**
+   * Delete a session permanently
+   */
+  async deleteSession(sessionId) {
+    await this.http.delete(`/api/sessions/${encodeURIComponent(sessionId)}`);
+  }
+  /**
+   * Load a session as the current working session
+   */
+  async loadSession(sessionId) {
+    const id = sessionId === null ? "null" : sessionId;
+    await this.http.post(`/api/sessions/${encodeURIComponent(id)}/load`);
+  }
+  /**
+   * Get the current working session
+   */
+  async getCurrentSession() {
+    const response = await this.http.get("/api/sessions/current");
+    return response.currentSessionId;
+  }
+  /**
+   * Reset conversation (clear history while keeping session alive)
+   */
+  async resetConversation(sessionId) {
+    await this.http.post("/api/reset", {
+      ...sessionId && { sessionId }
+    });
+  }
+  // ============= LLM MANAGEMENT =============
+  /**
+   * Get current LLM configuration
+   */
+  async getCurrentLLMConfig(sessionId) {
+    const params = sessionId ? `?sessionId=${encodeURIComponent(sessionId)}` : "";
+    const response = await this.http.get(`/api/llm/current${params}`);
+    return response.config;
+  }
+  /**
+   * Switch LLM configuration
+   */
+  async switchLLM(config, sessionId) {
+    const requestBody = {
+      ...config,
+      ...sessionId && { sessionId }
+    };
+    const response = await this.http.post(
+      "/api/llm/switch",
+      requestBody
+    );
+    return response.config;
+  }
+  /**
+   * Get available LLM providers and models
+   */
+  async getLLMProviders() {
+    const response = await this.http.get(
+      "/api/llm/providers"
+    );
+    return response.providers;
+  }
+  /**
+   * Get LLM catalog with filtering options
+   */
+  async getLLMCatalog(options = {}) {
+    const params = new globalThis.URLSearchParams();
+    if (options.provider) params.set("provider", options.provider);
+    if (options.hasKey !== void 0) params.set("hasKey", options.hasKey.toString());
+    if (options.router) params.set("router", options.router);
+    if (options.fileType) params.set("fileType", options.fileType);
+    if (options.defaultOnly) params.set("defaultOnly", "true");
+    if (options.mode) params.set("mode", options.mode);
+    const queryString = params.toString();
+    const endpoint = queryString ? `/api/llm/catalog?${queryString}` : "/api/llm/catalog";
+    return this.http.get(endpoint);
+  }
+  // ============= MCP SERVER MANAGEMENT =============
+  /**
+   * List connected MCP servers
+   */
+  async listMCPServers() {
+    const response = await this.http.get("/api/mcp/servers");
+    return response.servers;
+  }
+  /**
+   * Connect to a new MCP server
+   */
+  async connectMCPServer(name, config) {
+    await this.http.post("/api/mcp/servers", { name, config });
+  }
+  /**
+   * Disconnect from an MCP server
+   */
+  async disconnectMCPServer(serverId) {
+    await this.http.delete(`/api/mcp/servers/${encodeURIComponent(serverId)}`);
+  }
+  /**
+   * Get tools from a specific MCP server
+   */
+  async getMCPServerTools(serverId) {
+    const response = await this.http.get(
+      `/api/mcp/servers/${encodeURIComponent(serverId)}/tools`
+    );
+    return response.tools;
+  }
+  /**
+   * Execute a tool from an MCP server
+   */
+  async executeMCPTool(serverId, toolName, args) {
+    const response = await this.http.post(
+      `/api/mcp/servers/${encodeURIComponent(serverId)}/tools/${encodeURIComponent(toolName)}/execute`,
+      args
+    );
+    return response.data;
+  }
+  // ============= SEARCH =============
+  /**
+   * Search messages across sessions
+   */
+  async searchMessages(query, options = {}) {
+    const params = new globalThis.URLSearchParams();
+    params.append("q", query);
+    if (options.limit !== void 0) params.append("limit", String(options.limit));
+    if (options.offset !== void 0) params.append("offset", String(options.offset));
+    if (options.sessionId) params.append("sessionId", options.sessionId);
+    if (options.role) params.append("role", options.role);
+    return this.http.get(`/api/search/messages?${params}`);
+  }
+  /**
+   * Search sessions that contain the query
+   */
+  async searchSessions(query) {
+    const params = new globalThis.URLSearchParams({ q: query });
+    return this.http.get(`/api/search/sessions?${params}`);
+  }
+  // ============= EVENT HANDLING =============
+  /**
+   * Subscribe to real-time events
+   */
+  on(eventType, handler) {
+    if (!this.ws) {
+      if (this.options.debug) {
+        console.warn("WebSocket not available, events will not be received");
+      }
+      return () => {
+      };
+    }
+    return this.ws.on(eventType, handler);
+  }
+  /**
+   * Subscribe to connection state changes
+   */
+  onConnectionState(handler) {
+    if (!this.ws) {
+      return () => {
+      };
+    }
+    return this.ws.onConnectionState(handler);
+  }
+  // ============= GREETING =============
+  /**
+   * Get agent greeting message
+   */
+  async getGreeting(sessionId) {
+    const params = sessionId ? `?sessionId=${encodeURIComponent(sessionId)}` : "";
+    const response = await this.http.get(`/api/greeting${params}`);
+    return response.greeting;
+  }
+  // ============= UTILITY METHODS =============
+  /**
+   * Get connection status
+   */
+  get connectionState() {
+    return this.ws ? this.ws.state : "closed";
+  }
+  /**
+   * Check if client is connected
+   */
+  get isConnected() {
+    return this.connectionState === "open";
+  }
+  /**
+   * Get client configuration
+   */
+  get clientConfig() {
+    return { ...this.config };
+  }
+};