@dexto/client-sdk 1.2.4 → 1.2.6

package/dist/index.cjs

@@ -3,7 +3,6 @@ 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 });
@@ -17,833 +16,150 @@ var __copyProps = (to, from, except, desc) => {
   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
+  SSEError: () => SSEError,
+  createDextoClient: () => createDextoClient,
+  createMessageStream: () => createMessageStream,
+  createStream: () => createStream,
+  stream: () => stream
 });
 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/client.ts
+var import_client = require("hono/client");
 
-// 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."
-      );
-    }
+// src/streaming.ts
+var SSEError = class extends Error {
+  constructor(status, body) {
+    super(`SSE Error: ${status}`);
+    this.status = status;
+    this.body = body;
+    this.name = "SSEError";
   }
-  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;
+};
+async function* stream(response, options) {
+  var _a;
+  if (!response.ok) {
+    const contentType = response.headers.get("content-type");
+    let errorBody;
     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));
+      if (contentType && contentType.includes("application/json")) {
+        errorBody = await response.json();
+      } else {
+        errorBody = await response.text();
       }
-    }
-    throw lastError;
-  }
-  async safeParseJson(response) {
-    try {
-      return await response.json();
     } catch (e) {
-      return null;
+      errorBody = "Unknown error";
     }
+    throw new SSEError(response.status, errorBody);
   }
-  // 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);
+  const reader = (_a = response.body) == null ? void 0 : _a.getReader();
+  if (!reader) {
+    throw new Error("Response body is null");
   }
-  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")
-          )
-        );
-      }
+  const decoder = new globalThis.TextDecoder();
+  let buffer = "";
+  const signal = options == null ? void 0 : options.signal;
+  let aborted = false;
+  const abortHandler = () => {
+    aborted = true;
+    reader.cancel().catch(() => {
     });
-  }
-  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)}`
-          );
-        }
+  };
+  if (signal) {
+    if (signal.aborted) {
+      reader.cancel().catch(() => {
       });
+      return;
     }
+    signal.addEventListener("abort", abortHandler);
   }
-  // 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);
+  try {
+    while (true) {
+      if (aborted || (signal == null ? void 0 : signal.aborted)) {
+        return;
+      }
+      const parts = buffer.split("\n\n");
+      if (parts.length > 1) {
+        const eventString = parts.shift();
+        buffer = parts.join("\n\n");
+        const event = parseSSE(eventString);
+        if (event) {
+          yield event;
         }
+        continue;
+      }
+      const { done, value } = await reader.read();
+      if (done) {
+        if (buffer.trim()) {
+          const event = parseSSE(buffer);
+          if (event) {
+            yield event;
+          }
+        }
+        return;
       }
-    };
-  }
-  // 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"
-      );
+      buffer += decoder.decode(value, { stream: true }).replace(/\r\n/g, "\n");
     }
-    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();
+  } finally {
+    if (signal) {
+      signal.removeEventListener("abort", abortHandler);
     }
-  }
-  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
+    reader.cancel().catch(() => {
     });
   }
-  // ============= 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) {
+}
+async function* createStream(responsePromise, options) {
+  const response = await responsePromise;
+  yield* stream(response, options);
+}
+async function* createMessageStream(responsePromise, options) {
+  const sseStream = createStream(responsePromise, options);
+  for await (const event of sseStream) {
+    if (event.data) {
       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)}`
-          );
+        const parsed = JSON.parse(event.data);
+        if (event.event && !parsed.type) {
+          parsed.type = event.event;
         }
-        this.ws = null;
+        yield parsed;
+      } catch (e) {
       }
     }
   }
-  /**
-   * 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 }
+}
+function parseSSE(raw) {
+  const lines = raw.split("\n").map((line) => line.replace(/\r$/, ""));
+  const event = {};
+  let hasData = false;
+  for (const line of lines) {
+    if (line.startsWith(":")) continue;
+    if (line.startsWith("data: ")) {
+      const data = line.slice(6);
+      event.data = event.data ? event.data + "\n" + data : data;
+      hasData = true;
+    } else if (line.startsWith("event: ")) {
+      event.event = line.slice(7);
+    } else if (line.startsWith("id: ")) {
+      event.id = line.slice(4);
+    } else if (line.startsWith("retry: ")) {
+      event.retry = parseInt(line.slice(7), 10);
+    }
+  }
+  if (!hasData && !event.event && !event.id) return null;
+  return event;
+}
+
+// src/client.ts
+function createDextoClient(config) {
+  const options = {};
+  if (config.apiKey) {
+    options.headers = {
+      Authorization: `Bearer ${config.apiKey}`
     };
-    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 };
-  }
-};
+  return (0, import_client.hc)(config.baseUrl, options);
+}