@moxxy/cli 0.0.2 → 0.0.3

package/dist/dist-UYA4RJUH.mjs

@@ -0,0 +1,2792 @@
+import "./chunk-6DZX6EAA.mjs";
+
+// ../molt/dist/index.mjs
+import { randomUUID } from "crypto";
+import {
+  createHash,
+  createPrivateKey,
+  createPublicKey,
+  sign as cryptoSign,
+  verify as cryptoVerify,
+  generateKeyPairSync
+} from "crypto";
+import { exec } from "child_process";
+import { promisify } from "util";
+var ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
+var DeviceIdentityManager = class {
+  identity = null;
+  /**
+   * Base64URL encode (Clawdbot format)
+   */
+  base64UrlEncode(buf) {
+    return buf.toString("base64").replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/g, "");
+  }
+  /**
+   * Base64URL decode
+   */
+  base64UrlDecode(input) {
+    const normalized = input.replaceAll("-", "+").replaceAll("_", "/");
+    const padded = normalized + "=".repeat((4 - normalized.length % 4) % 4);
+    return Buffer.from(padded, "base64");
+  }
+  /**
+   * Extract raw 32-byte public key from PEM
+   */
+  derivePublicKeyRaw(publicKeyPem) {
+    const key = createPublicKey(publicKeyPem);
+    const spki = key.export({ type: "spki", format: "der" });
+    if (spki.length === ED25519_SPKI_PREFIX.length + 32 && spki.subarray(0, ED25519_SPKI_PREFIX.length).equals(ED25519_SPKI_PREFIX)) {
+      return spki.subarray(ED25519_SPKI_PREFIX.length);
+    }
+    return spki;
+  }
+  /**
+   * Generate device ID fingerprint (SHA-256 of raw public key)
+   */
+  fingerprintPublicKey(publicKeyPem) {
+    const raw = this.derivePublicKeyRaw(publicKeyPem);
+    return createHash("sha256").update(raw).digest("hex");
+  }
+  /**
+   * Generate a new device identity
+   */
+  async generateIdentity(deviceId) {
+    const { publicKey, privateKey } = generateKeyPairSync("ed25519");
+    const publicKeyPem = publicKey.export({ type: "spki", format: "pem" }).toString();
+    const privateKeyPem = privateKey.export({ type: "pkcs8", format: "pem" }).toString();
+    const generatedDeviceId = deviceId || this.fingerprintPublicKey(publicKeyPem);
+    const identity = {
+      id: generatedDeviceId,
+      publicKeyPem,
+      privateKeyPem
+    };
+    this.identity = identity;
+    return identity;
+  }
+  /**
+   * Load identity from storage
+   */
+  setIdentity(identity) {
+    this.identity = identity;
+  }
+  /**
+   * Load identity from a private key PEM string
+   * The public key and device ID are derived from the private key
+   */
+  loadFromPrivateKey(privateKeyPem) {
+    const normalizedPem = privateKeyPem.replace(/\\n/g, "\n");
+    const privateKey = createPrivateKey(normalizedPem);
+    const publicKey = createPublicKey(privateKey);
+    const publicKeyPem = publicKey.export({ type: "spki", format: "pem" }).toString();
+    const privateKeyPemNormalized = privateKey.export({ type: "pkcs8", format: "pem" }).toString();
+    const deviceId = this.fingerprintPublicKey(publicKeyPem);
+    const identity = {
+      id: deviceId,
+      publicKeyPem,
+      privateKeyPem: privateKeyPemNormalized
+    };
+    this.identity = identity;
+    return identity;
+  }
+  /**
+   * Get current identity
+   */
+  getIdentity() {
+    return this.identity;
+  }
+  /**
+   * Sign device auth payload (Clawdbot format)
+   * Payload format: v2|deviceId|clientId|clientMode|role|scopes|signedAtMs|token|nonce
+   */
+  async signDeviceAuthPayload(params) {
+    if (!this.identity) {
+      throw new Error("Device identity not initialized");
+    }
+    const version = "v2";
+    const scopes = params.scopes.join(",");
+    const token = params.token ?? "";
+    const payloadParts = [
+      version,
+      params.deviceId,
+      params.clientId,
+      params.clientMode,
+      params.role,
+      scopes,
+      String(params.signedAtMs),
+      token,
+      params.nonce
+    ];
+    const payload = payloadParts.join("|");
+    const key = createPrivateKey(this.identity.privateKeyPem);
+    const sig = cryptoSign(null, Buffer.from(payload, "utf8"), key);
+    const signature = this.base64UrlEncode(sig);
+    if (process.env.DEBUG_MOLT_AUTH) {
+      console.log("[Auth Debug] Payload:", payload);
+      console.log("[Auth Debug] Signature (base64url):", signature);
+      console.log("[Auth Debug] Public key (raw, base64url):", this.getPublicKeyBase64Url());
+      console.log("[Auth Debug] Device ID:", this.identity.id);
+    }
+    return signature;
+  }
+  /**
+   * Get public key in base64url format (raw 32 bytes)
+   */
+  getPublicKeyBase64Url() {
+    if (!this.identity) {
+      throw new Error("Device identity not initialized");
+    }
+    const raw = this.derivePublicKeyRaw(this.identity.publicKeyPem);
+    return this.base64UrlEncode(raw);
+  }
+  /**
+   * Verify a signature (for testing)
+   */
+  async verifySignature(nonce, signature, publicKey) {
+    const pubKey = publicKey || this.identity?.publicKeyPem;
+    if (!pubKey) {
+      throw new Error("Public key not available");
+    }
+    try {
+      const key = pubKey.includes("BEGIN") ? createPublicKey(pubKey) : createPublicKey({
+        key: Buffer.concat([ED25519_SPKI_PREFIX, this.base64UrlDecode(publicKey)]),
+        type: "spki",
+        format: "der"
+      });
+      const sig = this.base64UrlDecode(signature);
+      return cryptoVerify(null, Buffer.from(nonce, "utf8"), key, sig);
+    } catch (_error) {
+      return false;
+    }
+  }
+  /**
+   * Export identity for storage
+   */
+  exportIdentity() {
+    return this.identity;
+  }
+};
+var ClawdbotClient = class {
+  ws = null;
+  config;
+  deviceManager;
+  connectionState = "disconnected";
+  connectRequestId = null;
+  pendingRequests = /* @__PURE__ */ new Map();
+  eventHandlers = /* @__PURE__ */ new Map();
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  /** Cached snapshot from connection (contains health, agents, etc.) */
+  connectionSnapshot = null;
+  constructor(config) {
+    this.config = {
+      gatewayUrl: config.gatewayUrl,
+      authToken: config.authToken,
+      clientName: config.clientName || "ava-orchestrator",
+      clientVersion: config.clientVersion || "1.0.0",
+      deviceId: config.deviceId,
+      devicePrivateKey: config.devicePrivateKey,
+      autoReconnect: config.autoReconnect ?? true,
+      reconnectInterval: config.reconnectInterval ?? 5e3,
+      maxReconnectAttempts: config.maxReconnectAttempts ?? 10,
+      requestTimeout: config.requestTimeout ?? 3e4,
+      // Use 'node' role which is the only valid role for gateway connections
+      role: config.role || "node",
+      scopes: config.scopes || ["node.read", "node.write"]
+    };
+    this.deviceManager = new DeviceIdentityManager();
+  }
+  /**
+   * Connect to Clawdbot Gateway
+   */
+  async connect() {
+    if (this.connectionState === "connected" || this.connectionState === "connecting") {
+      throw new Error(`Already ${this.connectionState}`);
+    }
+    this.setConnectionState("connecting");
+    let identity = this.deviceManager.getIdentity();
+    if (!identity) {
+      if (this.config.devicePrivateKey) {
+        identity = this.deviceManager.loadFromPrivateKey(this.config.devicePrivateKey);
+      } else {
+        await this.deviceManager.generateIdentity(this.config.deviceId);
+      }
+    }
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = new WebSocket(this.config.gatewayUrl);
+        this.ws.onopen = () => {
+          this.emit("connection:connected");
+        };
+        this.ws.onmessage = async (event) => {
+          try {
+            const message = JSON.parse(event.data);
+            this.emit("message", message);
+            await this.handleMessage(message, resolve, reject);
+          } catch (error) {
+            console.error("Failed to parse message:", error);
+          }
+        };
+        this.ws.onerror = (_error) => {
+          console.error("[Molt SDK] WebSocket error (molt may reconnect)");
+          this.emit("connection:error", new Error("WebSocket error"));
+        };
+        this.ws.onclose = (event) => {
+          this.handleDisconnect(event.reason);
+          if (this.connectionState === "connecting" || this.connectionState === "authenticating") {
+            reject(new Error(`Connection closed: ${event.reason || "Unknown reason"}`));
+          }
+        };
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Handle incoming messages
+   */
+  async handleMessage(message, connectResolve, connectReject) {
+    if (message.type === "event" && message.event === "connect.challenge") {
+      await this.handleChallenge(message.payload);
+      return;
+    }
+    if (message.type === "event" && message.event === "hello-ok") {
+      this.setConnectionState("connected");
+      this.reconnectAttempts = 0;
+      if (connectResolve) {
+        connectResolve(void 0);
+      }
+      return;
+    }
+    if (message.type === "res") {
+      const response = message;
+      const isConnectResponse = this.connectRequestId && response.id === this.connectRequestId || response.ok && response.payload?.type === "hello-ok";
+      if (isConnectResponse) {
+        this.connectRequestId = null;
+        if (response.ok) {
+          const payload = response.payload;
+          if (payload?.snapshot) {
+            this.connectionSnapshot = payload.snapshot;
+          }
+          this.setConnectionState("connected");
+          this.reconnectAttempts = 0;
+          if (connectResolve) {
+            connectResolve(void 0);
+          }
+        } else {
+          const error = new Error(response.error?.message || "Connection failed");
+          error.code = response.error?.code;
+          if (connectReject) {
+            connectReject(error);
+          }
+        }
+        return;
+      }
+      this.handleResponse(response);
+      return;
+    }
+    if (message.type === "event") {
+      const eventMsg = message;
+      this.emit("event", eventMsg.event, eventMsg.payload);
+      if (eventMsg.event === "health" && eventMsg.payload) {
+        if (this.connectionSnapshot) {
+          this.connectionSnapshot.health = eventMsg.payload;
+        } else {
+          this.connectionSnapshot = { health: eventMsg.payload };
+        }
+      }
+      if (eventMsg.event.startsWith("agent:")) {
+        const agentId = eventMsg.payload?.agentId;
+        if (agentId) {
+          if (eventMsg.event === "agent:status") {
+            this.emit("agent:status", agentId, eventMsg.payload.status);
+          } else if (eventMsg.event === "agent:log") {
+            this.emit("agent:log", agentId, eventMsg.payload.message, eventMsg.payload.level);
+          }
+        }
+      }
+      return;
+    }
+    if (message.type === "err") {
+      console.error("Gateway error:", message);
+      if (connectReject && (this.connectionState === "connecting" || this.connectionState === "authenticating")) {
+        connectReject(new Error(message.error?.message || "Unknown error"));
+      }
+    }
+  }
+  /**
+   * Detect platform
+   */
+  getPlatform() {
+    if (typeof process !== "undefined" && process.platform) {
+      const platformMap = {
+        darwin: "macos",
+        linux: "linux",
+        win32: "windows",
+        freebsd: "freebsd",
+        openbsd: "openbsd"
+      };
+      return platformMap[process.platform] || process.platform;
+    }
+    return "unknown";
+  }
+  /**
+   * Handle connect challenge from gateway
+   */
+  async handleChallenge(challenge) {
+    this.setConnectionState("authenticating");
+    const identity = this.deviceManager.getIdentity();
+    if (!identity) {
+      throw new Error("Device identity not initialized");
+    }
+    const clientId = "cli";
+    const clientMode = "node";
+    const role = this.config.role;
+    const scopes = this.config.scopes;
+    const token = this.config.authToken;
+    const signature = await this.deviceManager.signDeviceAuthPayload({
+      deviceId: identity.id,
+      clientId,
+      clientMode,
+      role,
+      scopes,
+      signedAtMs: challenge.ts,
+      token,
+      nonce: challenge.nonce
+    });
+    const connectParams = {
+      minProtocol: 3,
+      maxProtocol: 3,
+      client: {
+        id: clientId,
+        platform: this.getPlatform(),
+        mode: clientMode,
+        version: this.config.clientVersion
+      },
+      role,
+      scopes,
+      caps: [],
+      commands: [],
+      permissions: {},
+      locale: "en-US",
+      userAgent: `${this.config.clientName}/${this.config.clientVersion}`,
+      device: {
+        id: identity.id,
+        publicKey: this.deviceManager.getPublicKeyBase64Url(),
+        // Use base64url raw format
+        signature,
+        signedAt: challenge.ts,
+        nonce: challenge.nonce
+      }
+    };
+    if (this.config.authToken) {
+      connectParams.auth = {
+        token: this.config.authToken
+      };
+    }
+    const connectRequest = {
+      type: "req",
+      id: randomUUID(),
+      method: "connect",
+      params: connectParams
+    };
+    this.connectRequestId = connectRequest.id;
+    this.send(connectRequest);
+  }
+  /**
+   * Handle RPC response
+   */
+  handleResponse(message) {
+    const pending = this.pendingRequests.get(message.id);
+    if (!pending) {
+      console.warn("Received response for unknown request:", message.id);
+      return;
+    }
+    clearTimeout(pending.timeout);
+    this.pendingRequests.delete(message.id);
+    if (message.ok) {
+      pending.resolve(message.result ?? message.payload);
+    } else {
+      const error = new Error(message.error?.message || "Request failed");
+      error.code = message.error?.code;
+      error.details = message.error?.details;
+      pending.reject(error);
+    }
+  }
+  /**
+   * Handle disconnection
+   */
+  handleDisconnect(reason) {
+    const previousState = this.connectionState;
+    this.setConnectionState("disconnected");
+    this.emit("connection:disconnected", reason);
+    for (const [_id, pending] of this.pendingRequests.entries()) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("Connection closed"));
+    }
+    this.pendingRequests.clear();
+    if (this.config.autoReconnect && previousState === "connected" && this.reconnectAttempts < this.config.maxReconnectAttempts) {
+      this.scheduleReconnect();
+    }
+  }
+  /**
+   * Schedule reconnection attempt
+   */
+  scheduleReconnect() {
+    if (this.reconnectTimer) {
+      return;
+    }
+    this.reconnectAttempts++;
+    this.setConnectionState("reconnecting");
+    const delay = this.config.reconnectInterval * Math.min(this.reconnectAttempts, 5);
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      try {
+        await this.connect();
+      } catch (error) {
+        console.error("Reconnection failed:", error);
+        if (this.reconnectAttempts < this.config.maxReconnectAttempts) {
+          this.scheduleReconnect();
+        } else {
+          this.setConnectionState("error");
+        }
+      }
+    }, delay);
+  }
+  /**
+   * Send a message to the gateway
+   */
+  send(message) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket is not connected");
+    }
+    this.ws.send(JSON.stringify(message));
+  }
+  /**
+   * Make an RPC request
+   */
+  async request(method, params = {}) {
+    if (this.connectionState !== "connected") {
+      throw new Error(`Cannot send request: connection state is ${this.connectionState}`);
+    }
+    const id = randomUUID();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Request timeout: ${method}`));
+      }, this.config.requestTimeout);
+      this.pendingRequests.set(id, { resolve, reject, timeout });
+      const request = {
+        type: "req",
+        id,
+        method,
+        params
+      };
+      this.send(request);
+    });
+  }
+  /**
+   * Get gateway status
+   */
+  async getStatus() {
+    return await this.request("status", {});
+  }
+  /**
+   * List agents
+   */
+  async listAgents() {
+    const result = await this.request("agents.list", {});
+    return result?.agents || [];
+  }
+  /**
+   * Execute a task with an agent
+   */
+  async executeTask(params) {
+    const result = await this.request("agent.execute", {
+      sessionId: params.sessionId,
+      agentId: params.agentId,
+      message: params.message,
+      timeout: params.timeout,
+      deliver: params.deliver
+    });
+    return result;
+  }
+  /**
+   * Event emitter
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+  }
+  /**
+   * Remove event handler
+   */
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+    }
+  }
+  /**
+   * Emit event
+   */
+  emit(event, ...args) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(...args);
+        } catch (error) {
+          console.error(`Error in event handler for ${event}:`, error);
+        }
+      });
+    }
+  }
+  /**
+   * Set connection state and emit event
+   */
+  setConnectionState(state) {
+    this.connectionState = state;
+    this.emit("connection:state", state);
+  }
+  /**
+   * Get current connection state
+   */
+  getConnectionState() {
+    return this.connectionState;
+  }
+  /**
+   * Disconnect from gateway
+   */
+  disconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.setConnectionState("disconnected");
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.connectionState === "connected";
+  }
+  /**
+   * Get cached connection snapshot (contains health, agents, etc.)
+   * This is populated from the initial connection and updated by events
+   */
+  getSnapshot() {
+    return this.connectionSnapshot;
+  }
+  /**
+   * Get cached health from connection snapshot
+   * Returns null if not connected or no health data available
+   */
+  getCachedHealth() {
+    return this.connectionSnapshot?.health || null;
+  }
+  /**
+   * Invalidate cached health data
+   * Call this after external operations (like CLI) that modify state
+   */
+  invalidateHealthCache() {
+    if (this.connectionSnapshot) {
+      delete this.connectionSnapshot.health?.agents;
+    }
+  }
+};
+var MoltError = class extends Error {
+  /** Error code */
+  code;
+  /** Additional error details */
+  details;
+  /** Original error if wrapped */
+  cause;
+  constructor(message, code, details, cause) {
+    super(message);
+    this.name = "MoltError";
+    this.code = code;
+    this.details = details;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Convert error to JSON for logging/serialization
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      details: this.details,
+      stack: this.stack
+    };
+  }
+};
+var ConnectionError = class extends MoltError {
+  constructor(message, details, cause) {
+    super(message, "CONNECTION_ERROR", details, cause);
+    this.name = "ConnectionError";
+  }
+};
+var AuthenticationError = class extends MoltError {
+  constructor(message, details, cause) {
+    super(message, "AUTHENTICATION_ERROR", details, cause);
+    this.name = "AuthenticationError";
+  }
+};
+var TimeoutError = class extends MoltError {
+  /** The method that timed out */
+  method;
+  /** Timeout duration in ms */
+  timeoutMs;
+  constructor(message, method, timeoutMs, details) {
+    super(message, "TIMEOUT_ERROR", { ...details, method, timeoutMs });
+    this.name = "TimeoutError";
+    this.method = method;
+    this.timeoutMs = timeoutMs;
+  }
+};
+var RPCError = class extends MoltError {
+  /** The RPC method that failed */
+  method;
+  /** Gateway error code */
+  gatewayCode;
+  constructor(message, method, gatewayCode, details) {
+    super(message, "RPC_ERROR", { ...details, method, gatewayCode });
+    this.name = "RPCError";
+    this.method = method;
+    this.gatewayCode = gatewayCode;
+  }
+};
+var ValidationError = class extends MoltError {
+  /** Field that failed validation */
+  field;
+  constructor(message, field, details) {
+    super(message, "VALIDATION_ERROR", { ...details, field });
+    this.name = "ValidationError";
+    this.field = field;
+  }
+};
+var NotFoundError = class extends MoltError {
+  /** Type of resource not found */
+  resourceType;
+  /** ID of the resource */
+  resourceId;
+  constructor(resourceType, resourceId, details) {
+    super(`${resourceType} '${resourceId}' not found`, "NOT_FOUND", {
+      ...details,
+      resourceType,
+      resourceId
+    });
+    this.name = "NotFoundError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+  }
+};
+var NotConnectedError = class extends MoltError {
+  constructor(message = "Transport is not connected") {
+    super(message, "NOT_CONNECTED");
+    this.name = "NotConnectedError";
+  }
+};
+var CLIError = class extends MoltError {
+  /** Exit code from CLI */
+  exitCode;
+  /** stdout from CLI */
+  stdout;
+  /** stderr from CLI */
+  stderr;
+  constructor(message, exitCode, stdout, stderr, details) {
+    super(message, "CLI_ERROR", { ...details, exitCode, stdout, stderr });
+    this.name = "CLIError";
+    this.exitCode = exitCode;
+    this.stdout = stdout;
+    this.stderr = stderr;
+  }
+};
+var ErrorCodes = {
+  CONNECTION_ERROR: "CONNECTION_ERROR",
+  AUTHENTICATION_ERROR: "AUTHENTICATION_ERROR",
+  TIMEOUT_ERROR: "TIMEOUT_ERROR",
+  RPC_ERROR: "RPC_ERROR",
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  NOT_FOUND: "NOT_FOUND",
+  NOT_CONNECTED: "NOT_CONNECTED",
+  CLI_ERROR: "CLI_ERROR"
+};
+var TypedEventEmitter = class {
+  handlers = /* @__PURE__ */ new Map();
+  /**
+   * Subscribe to an event with type-safe handler
+   */
+  on(event, handler) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(event).add(handler);
+    return this;
+  }
+  /**
+   * Subscribe to an event once
+   */
+  once(event, handler) {
+    const onceHandler = ((...args) => {
+      this.off(event, onceHandler);
+      handler(...args);
+    });
+    return this.on(event, onceHandler);
+  }
+  /**
+   * Unsubscribe from an event
+   */
+  off(event, handler) {
+    const eventHandlers = this.handlers.get(event);
+    if (eventHandlers) {
+      eventHandlers.delete(handler);
+      if (eventHandlers.size === 0) {
+        this.handlers.delete(event);
+      }
+    }
+    return this;
+  }
+  /**
+   * Emit an event with type-safe arguments
+   */
+  emit(event, ...args) {
+    const eventHandlers = this.handlers.get(event);
+    if (!eventHandlers || eventHandlers.size === 0) {
+      return false;
+    }
+    eventHandlers.forEach((handler) => {
+      try {
+        handler(...args);
+      } catch (error) {
+        console.error(`Error in event handler for '${event}':`, error);
+      }
+    });
+    return true;
+  }
+  /**
+   * Remove all handlers for an event or all events
+   */
+  removeAllListeners(event) {
+    if (event) {
+      this.handlers.delete(event);
+    } else {
+      this.handlers.clear();
+    }
+    return this;
+  }
+  /**
+   * Get the number of listeners for an event
+   */
+  listenerCount(event) {
+    return this.handlers.get(event)?.size ?? 0;
+  }
+  /**
+   * Get all registered event names
+   */
+  eventNames() {
+    return Array.from(this.handlers.keys());
+  }
+  /**
+   * Wait for an event to occur (promisified)
+   */
+  waitFor(event, timeout) {
+    return new Promise((resolve, reject) => {
+      let timeoutId;
+      const handler = ((...args) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        resolve(args);
+      });
+      this.once(event, handler);
+      if (timeout) {
+        timeoutId = setTimeout(() => {
+          this.off(event, handler);
+          reject(new Error(`Timeout waiting for event '${event}'`));
+        }, timeout);
+      }
+    });
+  }
+};
+function createEventEmitter() {
+  return new TypedEventEmitter();
+}
+var BaseModule = class {
+  transport;
+  events;
+  constructor(config) {
+    this.transport = config.transport;
+    this.events = config.events;
+  }
+  /**
+   * Make an RPC request with error handling
+   */
+  async request(method, params = {}) {
+    if (!this.transport.isConnected()) {
+      throw new NotConnectedError();
+    }
+    try {
+      return await this.transport.request(method, params);
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.message.includes("timeout") || error.message.includes("Timeout")) {
+          throw new TimeoutError(error.message, method);
+        }
+        const anyError = error;
+        if (anyError.code || anyError.gatewayCode) {
+          throw new RPCError(
+            error.message,
+            method,
+            anyError.code || anyError.gatewayCode,
+            anyError.details
+          );
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * Subscribe to transport events
+   */
+  onTransportEvent(event, handler) {
+    this.transport.on(event, handler);
+  }
+  /**
+   * Unsubscribe from transport events
+   */
+  offTransportEvent(event, handler) {
+    this.transport.off(event, handler);
+  }
+  /**
+   * Check if transport is connected
+   */
+  isConnected() {
+    return this.transport.isConnected();
+  }
+};
+var AgentsModule = class extends BaseModule {
+  /**
+   * List all agents
+   */
+  async list() {
+    const result = await this.request("agents.list", {});
+    if (!result) {
+      console.warn("[Molt SDK] agents.list returned null/undefined");
+      return {
+        agents: [],
+        defaultAgentId: void 0
+      };
+    }
+    if (typeof result !== "object") {
+      console.warn("[Molt SDK] agents.list returned non-object:", typeof result);
+      return {
+        agents: [],
+        defaultAgentId: void 0
+      };
+    }
+    const agents = (result.agents || []).map((a) => ({
+      ...a,
+      agentId: a.agentId || a.id
+      // Normalize to agentId
+    }));
+    const anyResult = result;
+    return {
+      agents,
+      defaultAgentId: result.defaultAgentId || anyResult.defaultId
+    };
+  }
+  /**
+   * Get a specific agent by ID
+   */
+  async get(agentId) {
+    const result = await this.list();
+    const agent = result.agents.find((a) => a.agentId === agentId || a.id === agentId);
+    if (!agent) {
+      throw new NotFoundError("Agent", agentId);
+    }
+    return agent;
+  }
+  /**
+   * Create a new agent with comprehensive configuration
+   */
+  async create(options) {
+    return this.request("agents.create", {
+      agentId: options.agentId,
+      workspace: options.workspace,
+      isDefault: options.isDefault,
+      identity: options.identity,
+      model: options.model,
+      sandbox: options.sandbox,
+      heartbeat: options.heartbeat,
+      systemPrompt: options.systemPrompt,
+      tools: options.tools,
+      groupChat: options.groupChat
+    });
+  }
+  /**
+   * Update an agent's configuration
+   */
+  async update(agentId, options) {
+    return this.request("agents.update", {
+      agentId,
+      ...options
+    });
+  }
+  /**
+   * Delete an agent
+   */
+  async delete(agentId) {
+    await this.request("agents.delete", { agentId });
+  }
+  /**
+   * Clone an existing agent with new settings
+   */
+  async clone(options) {
+    const sourceConfig = await this.getConfig(options.sourceAgentId);
+    return this.create({
+      agentId: options.newAgentId,
+      workspace: options.workspace,
+      isDefault: false,
+      identity: options.identity || sourceConfig.identity,
+      model: options.model || sourceConfig.model,
+      sandbox: sourceConfig.sandbox,
+      heartbeat: sourceConfig.heartbeat,
+      systemPrompt: sourceConfig.systemPrompt,
+      tools: sourceConfig.tools,
+      groupChat: sourceConfig.groupChat
+    });
+  }
+  // Identity Management
+  /**
+   * Get agent identity
+   */
+  async getIdentity(agentId) {
+    return this.request("agents.identity", { agentId });
+  }
+  /**
+   * Set agent identity
+   * @deprecated Gateway doesn't support agents.setIdentity
+   */
+  async setIdentity(agentId, _identity) {
+    return {
+      agentId
+    };
+  }
+  /**
+   * Load identity from IDENTITY.md file in workspace
+   */
+  async loadIdentityFromFile(agentId, identityFile) {
+    return this.request("agents.loadIdentity", {
+      agentId,
+      identityFile,
+      fromIdentity: true
+    });
+  }
+  // Default Agent
+  /**
+   * Get the default agent
+   */
+  async getDefault() {
+    const result = await this.list();
+    if (!result.defaultAgentId) {
+      return null;
+    }
+    return result.agents.find((a) => a.agentId === result.defaultAgentId) || null;
+  }
+  /**
+   * Set the default agent
+   */
+  async setDefault(agentId) {
+    await this.request("agents.setDefault", { agentId });
+  }
+  // Configuration
+  /**
+   * Get full agent configuration
+   */
+  async getConfig(agentId) {
+    return this.request("agents.getConfig", { agentId });
+  }
+  /**
+   * Export agent configuration (for backup/transfer)
+   */
+  async exportConfig(agentId) {
+    return this.getConfig(agentId);
+  }
+  /**
+   * Import agent configuration
+   */
+  async importConfig(config) {
+    return this.create(config);
+  }
+  // Model Configuration
+  /**
+   * Set agent's primary model
+   */
+  async setModel(agentId, model) {
+    await this.update(agentId, {
+      model: { primary: model }
+    });
+  }
+  /**
+   * Set agent's model fallbacks
+   */
+  async setModelFallbacks(agentId, fallbacks) {
+    await this.update(agentId, {
+      model: { fallbacks }
+    });
+  }
+  // Workspace
+  /**
+   * Set agent's workspace
+   */
+  async setWorkspace(agentId, workspace) {
+    await this.update(agentId, { workspace });
+  }
+  /**
+   * Get agent's workspace path
+   */
+  async getWorkspace(agentId) {
+    try {
+      const config = await this.getConfig(agentId);
+      return config.workspace;
+    } catch (error) {
+      console.warn(`[Molt SDK] Could not get workspace for ${agentId}: ${error?.message || error}`);
+      return void 0;
+    }
+  }
+  // System Prompt
+  // NOTE: These methods are disabled because the Molt Gateway doesn't support agents.update
+  /**
+   * Set agent's system prompt
+   * @deprecated Gateway doesn't support agents.update
+   */
+  async setSystemPrompt(_agentId, _systemPrompt) {
+  }
+  /**
+   * Get agent's system prompt
+   * @deprecated Gateway doesn't support agents.getConfig
+   */
+  async getSystemPrompt(_agentId) {
+    return void 0;
+  }
+  // Sandbox
+  /**
+   * Configure agent sandbox settings
+   */
+  async configureSandbox(agentId, sandbox) {
+    await this.update(agentId, { sandbox });
+  }
+  /**
+   * Enable sandbox for agent
+   */
+  async enableSandbox(agentId, mode = "non-main") {
+    await this.configureSandbox(agentId, { mode });
+  }
+  /**
+   * Disable sandbox for agent
+   */
+  async disableSandbox(agentId) {
+    await this.configureSandbox(agentId, { mode: "off" });
+  }
+  // Heartbeat
+  /**
+   * Configure agent heartbeat
+   */
+  async configureHeartbeat(agentId, heartbeat) {
+    await this.update(agentId, { heartbeat });
+  }
+  /**
+   * Enable heartbeat for agent
+   */
+  async enableHeartbeat(agentId, options = {}) {
+    await this.configureHeartbeat(agentId, {
+      enabled: true,
+      every: options.every || "1h",
+      prompt: options.prompt,
+      target: options.target
+    });
+  }
+  /**
+   * Disable heartbeat for agent
+   */
+  async disableHeartbeat(agentId) {
+    await this.configureHeartbeat(agentId, { enabled: false });
+  }
+  // Tools
+  // NOTE: These methods are disabled because the Molt Gateway doesn't support
+  // agents.getConfig, agents.update, or agents.setIdentity methods.
+  /**
+   * Configure agent tools
+   * @deprecated Gateway doesn't support agents.update
+   */
+  async configureTools(_agentId, _tools) {
+  }
+  /**
+   * Enable specific tools for agent
+   * @deprecated Gateway doesn't support agents.getConfig/agents.update
+   */
+  async enableTools(_agentId, _tools) {
+  }
+  /**
+   * Disable specific tools for agent
+   * @deprecated Gateway doesn't support agents.getConfig/agents.update
+   */
+  async disableTools(_agentId, _tools) {
+  }
+  // Group Chat
+  /**
+   * Configure group chat settings
+   */
+  async configureGroupChat(agentId, groupChat) {
+    await this.update(agentId, { groupChat });
+  }
+  /**
+   * Enable group chat for agent
+   */
+  async enableGroupChat(agentId, options = {}) {
+    await this.configureGroupChat(agentId, {
+      enabled: true,
+      mentionPatterns: options.mentionPatterns,
+      replyToAll: options.replyToAll
+    });
+  }
+  /**
+   * Disable group chat for agent
+   */
+  async disableGroupChat(agentId) {
+    await this.configureGroupChat(agentId, { enabled: false });
+  }
+  // Utility Methods
+  /**
+   * Check if an agent exists
+   */
+  async exists(agentId) {
+    try {
+      await this.get(agentId);
+      return true;
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * List all agent IDs
+   */
+  async listIds() {
+    const result = await this.list();
+    return result.agents.map((a) => a.agentId);
+  }
+  /**
+   * Get agent count
+   */
+  async count() {
+    const result = await this.list();
+    return result.agents.length;
+  }
+};
+var ChatModule = class extends BaseModule {
+  /**
+   * Generate an idempotency key for RPC requests
+   */
+  generateIdempotencyKey() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+  }
+  /**
+   * Send a message and wait for response
+   * Gateway is async - returns runId and actual response comes via events
+   */
+  async send(options) {
+    let sessionKey = options.sessionKey;
+    if (!sessionKey && options.agentId) {
+      sessionKey = `agent:${options.agentId}:${Date.now()}`;
+    } else if (options.agentId && sessionKey && !sessionKey.startsWith("agent:")) {
+      sessionKey = `agent:${options.agentId}:${sessionKey}`;
+    }
+    const timeout = options.timeout || 36e5;
+    let fullResponse = "";
+    let responseReceived = false;
+    let runId = null;
+    let resolved = false;
+    const responsePromise = new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        if (!resolved) {
+          cleanup();
+          reject(new Error("Chat response timeout"));
+        }
+      }, timeout);
+      const handleAgentEvent = (event) => {
+        if (!runId) return;
+        if (event.runId !== runId) return;
+        if (event.stream === "lifecycle") {
+          if (event.data?.phase === "end" || event.data?.phase === "complete") {
+            if (!resolved) {
+              resolved = true;
+              cleanup();
+              resolve(fullResponse);
+            }
+          }
+          return;
+        }
+        if (event.stream === "assistant" && event.data?.text) {
+          fullResponse = event.data.text;
+        }
+      };
+      const handleChatEvent = (event) => {
+        if (!runId) return;
+        if (event.runId !== runId) return;
+        if (event.state === "final" || event.state === "complete" || event.state === "done") {
+          if (event.message?.content) {
+            const content = event.message.content;
+            if (Array.isArray(content)) {
+              fullResponse = content.map((c) => c.text || "").join("");
+            } else if (typeof content === "string") {
+              fullResponse = content;
+            }
+          }
+          if (!resolved) {
+            resolved = true;
+            cleanup();
+            resolve(fullResponse);
+          }
+        }
+      };
+      const cleanup = () => {
+        clearTimeout(timeoutId);
+        this.offTransportEvent("agent", handleAgentEvent);
+        this.offTransportEvent("chat", handleChatEvent);
+      };
+      this.onTransportEvent("agent", handleAgentEvent);
+      this.onTransportEvent("chat", handleChatEvent);
+    });
+    const result = await this.request("chat.send", {
+      idempotencyKey: this.generateIdempotencyKey(),
+      message: options.message,
+      sessionKey,
+      target: options.target,
+      deliver: options.deliver,
+      replyChannel: options.replyChannel,
+      replyTo: options.replyTo,
+      thinking: options.thinking
+    });
+    if (result?.runId) {
+      runId = result.runId;
+    } else {
+      console.warn("[Molt SDK] chat.send: No runId in result, events may not be matched");
+    }
+    if (result?.response || result?.content || result?.message) {
+      fullResponse = result.response || result.content || result.message;
+      responseReceived = true;
+    }
+    if (!responseReceived && result?.status === "started") {
+      try {
+        fullResponse = await responsePromise;
+      } catch (err) {
+        console.warn("[Molt SDK] chat.send: Failed to get async response:", err?.message);
+      }
+    }
+    const normalizedResult = {
+      sessionKey: result?.sessionKey || sessionKey || "",
+      agentId: result?.agentId || options.agentId || "",
+      response: fullResponse,
+      timestamp: result?.timestamp || Date.now()
+    };
+    if (normalizedResult.response) {
+      this.events.emit("chat:message", {
+        role: "assistant",
+        content: normalizedResult.response,
+        timestamp: normalizedResult.timestamp
+      });
+    }
+    return normalizedResult;
+  }
+  /**
+   * Send a message with streaming response
+   * Returns an async iterator for streaming chunks
+   */
+  async *sendStream(options) {
+    const agentId = options.agentId;
+    let sessionKey;
+    if (options.sessionKey) {
+      if (agentId && !options.sessionKey.startsWith("agent:")) {
+        sessionKey = `agent:${agentId}:${options.sessionKey}`;
+      } else {
+        sessionKey = options.sessionKey;
+      }
+    } else if (agentId) {
+      sessionKey = `agent:${agentId}:stream-${Date.now()}`;
+    } else {
+      sessionKey = `stream-${Date.now()}`;
+    }
+    const chunks = [];
+    const _resolveStream = null;
+    const _rejectStream = null;
+    let streamDone = false;
+    let fullResponse = "";
+    const chunkQueue = [];
+    let resolveNextChunk = null;
+    const handleStreamChunk = (chunk) => {
+      if (chunk.sessionKey !== sessionKey) return;
+      chunks.push(chunk);
+      fullResponse += chunk.content;
+      if (options.onChunk) {
+        options.onChunk(chunk);
+      }
+      this.events.emit("chat:stream", chunk);
+      if (chunk.done) {
+        streamDone = true;
+        this.events.emit("chat:stream:end", sessionKey, agentId || "");
+        if (options.onEnd) {
+          options.onEnd(sessionKey, agentId || "");
+        }
+      }
+      if (resolveNextChunk) {
+        const resolve = resolveNextChunk;
+        resolveNextChunk = null;
+        if (chunk.done) {
+          resolve({
+            done: true,
+            value: {
+              sessionKey,
+              agentId: agentId || "",
+              response: fullResponse,
+              timestamp: Date.now()
+            }
+          });
+        } else {
+          resolve({ done: false, value: chunk });
+        }
+      } else {
+        chunkQueue.push(chunk);
+      }
+    };
+    this.onTransportEvent("chat.stream", handleStreamChunk);
+    try {
+      this.events.emit("chat:stream:start", sessionKey, agentId || "");
+      if (options.onStart) {
+        options.onStart(sessionKey, agentId || "");
+      }
+      const requestPromise = this.request("chat.stream", {
+        idempotencyKey: this.generateIdempotencyKey(),
+        message: options.message,
+        sessionKey,
+        target: options.target,
+        deliver: options.deliver,
+        replyChannel: options.replyChannel,
+        replyTo: options.replyTo,
+        thinking: options.thinking,
+        stream: true
+      });
+      while (!streamDone) {
+        if (chunkQueue.length > 0) {
+          const chunk = chunkQueue.shift();
+          if (chunk.done) {
+            return {
+              sessionKey,
+              agentId: agentId || "",
+              response: fullResponse,
+              timestamp: Date.now()
+            };
+          }
+          yield chunk;
+        } else {
+          const result = await new Promise(
+            (resolve) => {
+              resolveNextChunk = resolve;
+            }
+          );
+          if (result.done) {
+            return result.value;
+          }
+          yield result.value;
+        }
+      }
+      await requestPromise;
+      return {
+        sessionKey,
+        agentId: agentId || "",
+        response: fullResponse,
+        timestamp: Date.now()
+      };
+    } finally {
+      this.offTransportEvent("chat.stream", handleStreamChunk);
+    }
+  }
+  /**
+   * Get chat history for a session
+   */
+  async history(sessionKey, options = {}) {
+    return this.request("chat.history", {
+      sessionKey,
+      limit: options.limit ?? 100,
+      offset: options.offset ?? 0,
+      since: options.since,
+      until: options.until
+    });
+  }
+  /**
+   * Get recent messages across all sessions
+   */
+  async recentMessages(options = {}) {
+    const result = await this.request("chat.recent", {
+      limit: options.limit ?? 50,
+      agentId: options.agentId
+    });
+    return result.messages || [];
+  }
+  /**
+   * Simple message send (convenience method)
+   */
+  async message(message, agentId, sessionKey) {
+    const result = await this.send({ message, agentId, sessionKey });
+    return result.response;
+  }
+  /**
+   * Deliver a message to a target channel
+   */
+  async deliver(message, target, options = {}) {
+    return this.send({
+      message,
+      target,
+      deliver: true,
+      replyChannel: options.channel,
+      agentId: options.agentId,
+      sessionKey: options.sessionKey
+    });
+  }
+  /**
+   * Cancel an ongoing chat request by runId
+   * Note: This attempts to cancel but the gateway may not support it yet
+   * In that case, the execution will complete but results should be ignored
+   */
+  async cancel(runId) {
+    try {
+      const result = await this.request("chat.cancel", {
+        runId
+      });
+      return result;
+    } catch (error) {
+      const errorMsg = error?.message || String(error);
+      console.warn("[Molt SDK] chat.cancel: Failed or not supported:", errorMsg);
+      return {
+        success: false,
+        message: `Cancel not supported or failed: ${errorMsg}`
+      };
+    }
+  }
+};
+var ConfigModule = class extends BaseModule {
+  /**
+   * Get a configuration value
+   */
+  async get(key) {
+    const result = await this.request("config.get", { key });
+    return result.value;
+  }
+  /**
+   * Set a configuration value
+   */
+  async set(key, value) {
+    await this.request("config.set", { key, value });
+  }
+  /**
+   * Get multiple configuration values
+   */
+  async getMany(keys) {
+    const result = await this.request("config.getMany", {
+      keys
+    });
+    return result.values || {};
+  }
+  /**
+   * Set multiple configuration values
+   */
+  async setMany(values) {
+    await this.request("config.setMany", { values });
+  }
+  /**
+   * Delete a configuration value
+   */
+  async delete(key) {
+    await this.request("config.delete", { key });
+  }
+  /**
+   * Get configuration schema
+   */
+  async getSchema(section) {
+    return this.request("config.schema", { section });
+  }
+  /**
+   * Get all configuration for a section
+   */
+  async getSection(section) {
+    return this.request("config.getSection", { section });
+  }
+  /**
+   * Reset a configuration key to default
+   */
+  async reset(key) {
+    await this.request("config.reset", { key });
+  }
+  /**
+   * Reset a section to defaults
+   */
+  async resetSection(section) {
+    await this.request("config.resetSection", { section });
+  }
+  /**
+   * Export all configuration
+   */
+  async export() {
+    return this.request("config.export", {});
+  }
+  /**
+   * Import configuration
+   */
+  async import(config, merge = true) {
+    await this.request("config.import", { config, merge });
+  }
+  /**
+   * Validate configuration
+   */
+  async validate(config) {
+    return this.request("config.validate", { config });
+  }
+  // Convenience methods for common config operations
+  /**
+   * Get gateway configuration
+   */
+  async getGateway() {
+    return this.getSection("gateway");
+  }
+  /**
+   * Get channels configuration
+   */
+  async getChannels() {
+    return this.getSection("channels");
+  }
+  /**
+   * Get agents configuration
+   */
+  async getAgents() {
+    return this.getSection("agents");
+  }
+  /**
+   * Get models configuration
+   */
+  async getModels() {
+    return this.getSection("models");
+  }
+  /**
+   * Set gateway port
+   */
+  async setGatewayPort(port) {
+    await this.set("gateway.port", port);
+  }
+  /**
+   * Set gateway token
+   */
+  async setGatewayToken(token) {
+    await this.set("gateway.auth.token", token);
+  }
+};
+var ModelsModule = class extends BaseModule {
+  /**
+   * List all available models
+   */
+  async list() {
+    const result = await this.request("models.list", {});
+    return {
+      models: result.models || [],
+      providers: result.providers || []
+    };
+  }
+  /**
+   * Get model status (default model, fallbacks, auth overview)
+   */
+  async status() {
+    return this.request("models.status", {});
+  }
+  /**
+   * Get a specific model by ID
+   */
+  async get(modelId) {
+    const result = await this.list();
+    const model = result.models.find((m) => m.id === modelId);
+    if (!model) {
+      throw new NotFoundError("Model", modelId);
+    }
+    return model;
+  }
+  /**
+   * Set the default model
+   */
+  async setDefault(model, agentId) {
+    await this.request("models.set", {
+      model,
+      agentId
+    });
+  }
+  /**
+   * Get the current default model
+   */
+  async getDefault(_agentId) {
+    const status = await this.status();
+    return status.defaultModel;
+  }
+  /**
+   * Scan for available models from all providers
+   */
+  async scan() {
+    return this.request("models.scan", {});
+  }
+  /**
+   * List configured providers
+   */
+  async listProviders() {
+    const status = await this.status();
+    return status.providers;
+  }
+  /**
+   * Get models from a specific provider
+   */
+  async getProviderModels(providerId) {
+    const result = await this.list();
+    return result.models.filter((m) => m.provider === providerId);
+  }
+  // Aliases
+  /**
+   * List model aliases
+   */
+  async listAliases() {
+    const result = await this.request("models.aliases.list", {});
+    return result.aliases || [];
+  }
+  /**
+   * Add a model alias
+   */
+  async addAlias(alias, model) {
+    await this.request("models.aliases.add", { alias, model });
+  }
+  /**
+   * Remove a model alias
+   */
+  async removeAlias(alias) {
+    await this.request("models.aliases.remove", { alias });
+  }
+  /**
+   * Resolve an alias to full model reference
+   */
+  async resolveAlias(alias) {
+    const aliases = await this.listAliases();
+    const found = aliases.find((a) => a.alias === alias);
+    return found?.model || null;
+  }
+  // Fallbacks
+  /**
+   * List fallback configurations
+   */
+  async listFallbacks() {
+    const result = await this.request("models.fallbacks.list", {});
+    return result.fallbacks || [];
+  }
+  /**
+   * Set fallback models for a primary model
+   */
+  async setFallbacks(primary, fallbacks) {
+    await this.request("models.fallbacks.set", { primary, fallbacks });
+  }
+  /**
+   * Add a fallback model
+   */
+  async addFallback(primary, fallback) {
+    const current = await this.listFallbacks();
+    const existing = current.find((f) => f.primary === primary);
+    const fallbacks = existing ? [...existing.fallbacks, fallback] : [fallback];
+    await this.setFallbacks(primary, fallbacks);
+  }
+  /**
+   * Remove a fallback model
+   */
+  async removeFallback(primary, fallback) {
+    const current = await this.listFallbacks();
+    const existing = current.find((f) => f.primary === primary);
+    if (existing) {
+      const fallbacks = existing.fallbacks.filter((f) => f !== fallback);
+      await this.setFallbacks(primary, fallbacks);
+    }
+  }
+  // Auth Profiles
+  /**
+   * List auth profiles
+   */
+  async listAuthProfiles() {
+    const status = await this.status();
+    return status.authProfiles;
+  }
+  /**
+   * Add an auth profile (API key or token)
+   */
+  async addAuth(options) {
+    return this.request("models.auth.add", {
+      provider: options.provider,
+      type: options.type,
+      value: options.value,
+      profileId: options.profileId
+    });
+  }
+  /**
+   * Remove an auth profile
+   */
+  async removeAuth(profileId) {
+    await this.request("models.auth.remove", { profileId });
+  }
+  /**
+   * Probe auth profiles to verify they work
+   */
+  async probeAuth(options = {}) {
+    const result = await this.request("models.auth.probe", {
+      provider: options.provider,
+      profileId: options.profileId,
+      timeout: options.timeout,
+      maxTokens: options.maxTokens
+    });
+    return result.results || [];
+  }
+  /**
+   * Check if a provider is configured and authenticated
+   */
+  async isProviderConfigured(providerId) {
+    const providers = await this.listProviders();
+    const provider = providers.find((p) => p.id === providerId);
+    return Boolean(provider?.configured && provider?.authStatus === "valid");
+  }
+  // Convenience methods
+  /**
+   * Get recommended models for a provider
+   */
+  async getRecommended(providerId) {
+    const result = await this.list();
+    let models = result.models;
+    if (providerId) {
+      models = models.filter((m) => m.provider === providerId);
+    }
+    return models.filter((m) => m.contextWindow >= 1e5).sort((a, b) => b.contextWindow - a.contextWindow);
+  }
+  /**
+   * Get the best available model based on current configuration
+   */
+  async getBestAvailable() {
+    const status = await this.status();
+    const models = await this.list();
+    const defaultModel = models.models.find((m) => m.id === status.defaultModel);
+    if (defaultModel) {
+      return defaultModel;
+    }
+    for (const fallback of status.fallbacks) {
+      const model = models.models.find((m) => m.id === fallback);
+      if (model) {
+        return model;
+      }
+    }
+    return null;
+  }
+};
+var NodesModule = class extends BaseModule {
+  /**
+   * List all nodes
+   */
+  async list(options = {}) {
+    const result = await this.request("nodes.list", {
+      status: options.status ?? "all",
+      capability: options.capability
+    });
+    return result.nodes || [];
+  }
+  /**
+   * Get a specific node
+   */
+  async get(nodeId) {
+    const nodes = await this.list();
+    const node = nodes.find((n) => n.nodeId === nodeId);
+    if (!node) {
+      throw new NotFoundError("Node", nodeId);
+    }
+    return node;
+  }
+  /**
+   * Invoke a method on a node
+   */
+  async invoke(options) {
+    return this.request("nodes.invoke", {
+      nodeId: options.nodeId,
+      method: options.method,
+      params: options.params || {},
+      timeout: options.timeout
+    });
+  }
+  /**
+   * Get capabilities of a node
+   */
+  async getCapabilities(nodeId) {
+    const result = await this.request("nodes.capabilities", {
+      nodeId
+    });
+    return result.capabilities || [];
+  }
+  /**
+   * Get all online nodes
+   */
+  async online() {
+    return this.list({ status: "online" });
+  }
+  /**
+   * Get nodes with a specific capability
+   */
+  async withCapability(capability) {
+    return this.list({ capability });
+  }
+  /**
+   * Check if a node is online
+   */
+  async isOnline(nodeId) {
+    try {
+      const node = await this.get(nodeId);
+      return node.status === "online";
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Ping a node
+   */
+  async ping(nodeId) {
+    const start = Date.now();
+    const _result = await this.invoke({
+      nodeId,
+      method: "ping",
+      timeout: 5e3
+    });
+    return {
+      pong: true,
+      latencyMs: Date.now() - start
+    };
+  }
+  // Convenience methods for common node operations
+  /**
+   * Take a camera snapshot (camera capability)
+   */
+  async cameraSnap(nodeId) {
+    const result = await this.invoke({
+      nodeId,
+      method: "camera.snap"
+    });
+    return result.result;
+  }
+  /**
+   * Get device location (location capability)
+   */
+  async getLocation(nodeId) {
+    const result = await this.invoke({
+      nodeId,
+      method: "location.get"
+    });
+    return result.result;
+  }
+  /**
+   * Execute a system command (system.run capability)
+   */
+  async exec(nodeId, command, options = {}) {
+    const result = await this.invoke({
+      nodeId,
+      method: "system.run",
+      params: { command, cwd: options.cwd },
+      timeout: options.timeout
+    });
+    return result.result;
+  }
+  /**
+   * Navigate browser canvas (canvas capability)
+   */
+  async canvasNavigate(nodeId, url) {
+    const result = await this.invoke({
+      nodeId,
+      method: "canvas.navigate",
+      params: { url }
+    });
+    return result.result;
+  }
+};
+var SessionsModule = class extends BaseModule {
+  /**
+   * List sessions
+   */
+  async list(options = {}) {
+    const result = await this.request("sessions.list", {
+      agentId: options.agentId,
+      limit: options.limit ?? 50,
+      activeWithinMinutes: options.activeWithinMinutes,
+      includeArchived: options.includeArchived
+    });
+    return {
+      sessions: result.sessions || [],
+      total: result.total ?? result.sessions?.length ?? 0
+    };
+  }
+  /**
+   * Get a specific session by key
+   */
+  async get(sessionKey) {
+    const result = await this.request("sessions.get", {
+      key: sessionKey
+    });
+    if (!result.session) {
+      throw new NotFoundError("Session", sessionKey);
+    }
+    return result.session;
+  }
+  /**
+   * Create a new session
+   */
+  async create(options = {}) {
+    return this.request("sessions.create", {
+      key: options.key,
+      agentId: options.agentId,
+      initialMessage: options.initialMessage,
+      name: options.name,
+      tags: options.tags
+    });
+  }
+  /**
+   * Update a session (patch)
+   */
+  async update(sessionKey, updates) {
+    return this.request("sessions.patch", {
+      key: sessionKey,
+      updates
+    });
+  }
+  /**
+   * Delete a session
+   */
+  async delete(sessionKey) {
+    await this.request("sessions.delete", { key: sessionKey });
+  }
+  /**
+   * Get session preview (summary)
+   */
+  async preview(sessionKey) {
+    return this.request("sessions.preview", {
+      key: sessionKey
+    });
+  }
+  /**
+   * Get session chat history
+   */
+  async history(sessionKey, options = {}) {
+    return this.request("sessions.history", {
+      key: sessionKey,
+      limit: options.limit ?? 100,
+      offset: options.offset ?? 0
+    });
+  }
+  /**
+   * Archive a session
+   */
+  async archive(sessionKey) {
+    return this.update(sessionKey, { archived: true });
+  }
+  /**
+   * Unarchive a session
+   */
+  async unarchive(sessionKey) {
+    return this.update(sessionKey, { archived: false });
+  }
+  /**
+   * Add tags to a session
+   */
+  async addTags(sessionKey, tags) {
+    const session = await this.get(sessionKey);
+    const existingTags = session.tags || [];
+    const newTags = [.../* @__PURE__ */ new Set([...existingTags, ...tags])];
+    return this.update(sessionKey, { tags: newTags });
+  }
+  /**
+   * Remove tags from a session
+   */
+  async removeTags(sessionKey, tags) {
+    const session = await this.get(sessionKey);
+    const existingTags = session.tags || [];
+    const newTags = existingTags.filter((t) => !tags.includes(t));
+    return this.update(sessionKey, { tags: newTags });
+  }
+  /**
+   * Check if a session exists
+   */
+  async exists(sessionKey) {
+    try {
+      await this.get(sessionKey);
+      return true;
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get recent sessions
+   */
+  async recent(limit = 10) {
+    const result = await this.list({ limit, activeWithinMinutes: 60 * 24 });
+    return result.sessions;
+  }
+};
+var SystemModule = class extends BaseModule {
+  /**
+   * Get detailed gateway health status
+   */
+  async health() {
+    return this.request("health", {});
+  }
+  /**
+   * Get gateway status
+   */
+  async status() {
+    return this.request("status", {});
+  }
+  /**
+   * Get system presence (connected devices/clients)
+   */
+  async presence() {
+    const result = await this.request("system-presence", {});
+    return result.presence || [];
+  }
+  /**
+   * Query logs
+   */
+  async logs(options = {}) {
+    const result = await this.request("logs.query", {
+      since: options.since,
+      until: options.until,
+      level: options.level,
+      limit: options.limit ?? 100,
+      agentId: options.agentId
+    });
+    return result.logs || [];
+  }
+  /**
+   * Get usage statistics
+   */
+  async usage(options = {}) {
+    return this.request("usage.status", {
+      since: options.since,
+      until: options.until,
+      agentId: options.agentId,
+      model: options.model
+    });
+  }
+  /**
+   * Get usage cost breakdown
+   */
+  async usageCost(options = {}) {
+    return this.request("usage.cost", {
+      since: options.since,
+      until: options.until,
+      agentId: options.agentId,
+      model: options.model
+    });
+  }
+  /**
+   * Ping the gateway (simple health check)
+   */
+  async ping() {
+    return this.request("ping", {});
+  }
+  /**
+   * Get gateway version information
+   */
+  async version() {
+    return this.request("version", {});
+  }
+};
+var execAsync = promisify(exec);
+var DEFAULT_CLI_CONFIG = {
+  cliPath: "moltbot",
+  timeout: 6e5,
+  // 10 minutes
+  maxBuffer: 50 * 1024 * 1024
+  // 50MB
+};
+var CLITransport = class {
+  config;
+  eventHandlers = /* @__PURE__ */ new Map();
+  connected = false;
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_CLI_CONFIG,
+      ...config
+    };
+  }
+  /**
+   * "Connect" - validates CLI is available
+   */
+  async connect() {
+    try {
+      await execAsync(`${this.config.cliPath} --version`, {
+        timeout: 5e3
+      });
+      this.connected = true;
+      this.emit("connection:connected");
+      this.emit("connection:state", "connected");
+    } catch (error) {
+      this.connected = false;
+      const err = new CLIError(
+        `CLI not available at '${this.config.cliPath}'`,
+        error.code,
+        error.stdout,
+        error.stderr
+      );
+      this.emit("connection:error", err);
+      throw err;
+    }
+  }
+  /**
+   * "Disconnect" - no-op for CLI
+   */
+  disconnect() {
+    this.connected = false;
+    this.emit("connection:disconnected");
+    this.emit("connection:state", "disconnected");
+  }
+  /**
+   * Check if "connected" (CLI available)
+   */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Get connection state
+   */
+  getConnectionState() {
+    return this.connected ? "connected" : "disconnected";
+  }
+  /**
+   * Execute a CLI command and parse JSON response
+   */
+  async execCommand(command) {
+    try {
+      const { stdout } = await execAsync(command, {
+        timeout: this.config.timeout,
+        maxBuffer: this.config.maxBuffer
+      });
+      if (stdout.trim()) {
+        try {
+          return JSON.parse(stdout.trim());
+        } catch {
+          return { raw: stdout.trim() };
+        }
+      }
+      return { success: true };
+    } catch (error) {
+      const execError = error;
+      throw new CLIError(
+        execError.message || "CLI command failed",
+        execError.code,
+        execError.stdout,
+        execError.stderr
+      );
+    }
+  }
+  /**
+   * Make an RPC-like request via CLI
+   */
+  async request(method, params = {}) {
+    if (!this.connected) {
+      throw new NotConnectedError("CLI transport not initialized. Call connect() first.");
+    }
+    const command = this.buildCommand(method, params);
+    const result = await this.execCommand(command);
+    return result;
+  }
+  /**
+   * Build CLI command from RPC method and params
+   */
+  buildCommand(method, params) {
+    const cli = this.config.cliPath;
+    switch (method) {
+      // Health/Status
+      case "health":
+        return `${cli} health --json`;
+      case "status":
+        return `${cli} status --json`;
+      case "ping":
+        return `${cli} health --json`;
+      // Agents
+      case "agents.list":
+        return `${cli} agents list --json`;
+      case "agents.create":
+        return this.buildAgentCreateCommand(cli, params);
+      case "agents.delete":
+        return `${cli} agents delete ${params.agentId} --json`;
+      // Sessions
+      case "sessions.list":
+        return this.buildSessionsListCommand(cli, params);
+      case "sessions.delete":
+        return `${cli} sessions delete ${params.key} --json`;
+      // Chat/Agent execution
+      case "chat.send":
+      case "agent.execute":
+        return this.buildAgentCommand(cli, params);
+      // Models
+      case "models.list":
+        return `${cli} models list --json`;
+      // Config
+      case "config.get":
+        return `${cli} config get ${params.key} --json`;
+      case "config.set":
+        return `${cli} config set ${params.key} ${JSON.stringify(params.value)} --json`;
+      // Logs
+      case "logs.query":
+        return this.buildLogsCommand(cli, params);
+      // Default: try direct CLI command
+      default:
+        return this.buildGenericCommand(cli, method, params);
+    }
+  }
+  buildAgentCreateCommand(cli, params) {
+    const parts = [cli, "agents", "add", params.agentId];
+    if (params.workspace) {
+      parts.push("--workspace", params.workspace);
+    }
+    parts.push("--json");
+    return parts.join(" ");
+  }
+  buildSessionsListCommand(cli, params) {
+    const parts = [cli, "sessions"];
+    if (params.activeWithinMinutes) {
+      parts.push("--active", String(params.activeWithinMinutes));
+    }
+    parts.push("--json");
+    return parts.join(" ");
+  }
+  buildAgentCommand(cli, params) {
+    const parts = [cli, "agent"];
+    if (params.sessionKey || params.sessionId) {
+      parts.push("--session-id", params.sessionKey || params.sessionId);
+    }
+    if (params.agentId) {
+      parts.push("--agent", params.agentId);
+    }
+    if (params.message) {
+      const escapedMessage = params.message.replace(/"/g, '\\"');
+      parts.push("--message", `"${escapedMessage}"`);
+    }
+    if (params.target) {
+      parts.push("--to", params.target);
+    }
+    if (params.deliver) {
+      parts.push("--deliver");
+    }
+    if (params.timeout) {
+      parts.push("--timeout", String(Math.floor(params.timeout / 1e3)));
+    }
+    if (params.thinking) {
+      parts.push("--thinking", params.thinking);
+    }
+    parts.push("--json");
+    return parts.join(" ");
+  }
+  buildLogsCommand(cli, params) {
+    const parts = [cli, "logs"];
+    if (params.limit) {
+      parts.push("--limit", String(params.limit));
+    }
+    if (params.level) {
+      parts.push("--level", params.level);
+    }
+    parts.push("--json");
+    return parts.join(" ");
+  }
+  buildGenericCommand(cli, method, params) {
+    const command = method.replace(/\./g, " ");
+    const parts = [cli, command];
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0 && value !== null) {
+        const flag = `--${key.replace(/([A-Z])/g, "-$1").toLowerCase()}`;
+        if (typeof value === "boolean") {
+          if (value) parts.push(flag);
+        } else {
+          parts.push(flag, String(value));
+        }
+      }
+    }
+    parts.push("--json");
+    return parts.join(" ");
+  }
+  /**
+   * Subscribe to an event (limited support for CLI)
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+  }
+  /**
+   * Unsubscribe from an event
+   */
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+    }
+  }
+  /**
+   * Emit an event
+   */
+  emit(event, ...args) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(...args);
+        } catch (error) {
+          console.error(`Error in event handler for ${event}:`, error);
+        }
+      });
+    }
+  }
+};
+function createCLITransport(config = {}) {
+  return new CLITransport(config);
+}
+var WebSocketTransport = class {
+  client;
+  eventHandlers = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.client = new ClawdbotClient({
+      gatewayUrl: config.gatewayUrl,
+      authToken: config.authToken,
+      clientName: config.clientName || "molt-sdk",
+      clientVersion: config.clientVersion || "1.0.0",
+      deviceId: config.deviceId,
+      devicePrivateKey: config.devicePrivateKey,
+      autoReconnect: config.autoReconnect ?? true,
+      reconnectInterval: config.reconnectInterval ?? 5e3,
+      maxReconnectAttempts: config.maxReconnectAttempts ?? 10,
+      requestTimeout: config.requestTimeout ?? 3e4,
+      role: config.role,
+      scopes: config.scopes
+    });
+    this.setupEventForwarding();
+  }
+  /**
+   * Setup event forwarding from internal client
+   */
+  setupEventForwarding() {
+    this.client.on("connection:state", (state) => {
+      this.emit("connection:state", state);
+    });
+    this.client.on("connection:connected", () => {
+      this.emit("connection:connected");
+    });
+    this.client.on("connection:disconnected", (reason) => {
+      this.emit("connection:disconnected", reason);
+    });
+    this.client.on("connection:error", (error) => {
+      this.emit("connection:error", error);
+    });
+    this.client.on("message", (message) => {
+      this.emit("message", message);
+    });
+    this.client.on("event", (event, payload) => {
+      this.emit("event", event, payload);
+      this.emit(event, payload);
+    });
+    this.client.on("agent:status", (agentId, status) => {
+      this.emit("agent:status", agentId, status);
+    });
+    this.client.on("agent:log", (agentId, message, level) => {
+      this.emit("agent:log", agentId, message, level);
+    });
+  }
+  /**
+   * Connect to the gateway
+   */
+  async connect() {
+    await this.client.connect();
+  }
+  /**
+   * Disconnect from the gateway
+   */
+  disconnect() {
+    this.client.disconnect();
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.client.isConnected();
+  }
+  /**
+   * Get current connection state
+   */
+  getConnectionState() {
+    return this.client.getConnectionState();
+  }
+  /**
+   * Make an RPC request
+   */
+  async request(method, params = {}) {
+    return this.client.request(method, params);
+  }
+  /**
+   * Subscribe to an event
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+  }
+  /**
+   * Unsubscribe from an event
+   */
+  off(event, handler) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+    }
+  }
+  /**
+   * Emit an event
+   */
+  emit(event, ...args) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(...args);
+        } catch (error) {
+          console.error(`Error in event handler for ${event}:`, error);
+        }
+      });
+    }
+  }
+  /**
+   * Get the underlying client (for advanced use cases)
+   */
+  getClient() {
+    return this.client;
+  }
+  /**
+   * Get cached connection snapshot
+   */
+  getSnapshot() {
+    return this.client.getSnapshot();
+  }
+  /**
+   * Get cached health from connection snapshot
+   */
+  getCachedHealth() {
+    return this.client.getCachedHealth();
+  }
+  /**
+   * Invalidate cached health data
+   */
+  invalidateHealthCache() {
+    this.client.invalidateHealthCache();
+  }
+};
+var DEFAULT_CONFIG = {
+  gatewayUrl: "ws://127.0.0.1:18789",
+  clientName: "molt-sdk",
+  clientVersion: "1.0.0",
+  autoReconnect: true,
+  reconnectInterval: 5e3,
+  maxReconnectAttempts: 10,
+  requestTimeout: 3e4,
+  autoConnect: true
+};
+var MoltSDK = class _MoltSDK {
+  transport;
+  events;
+  config;
+  // Domain modules
+  system;
+  agents;
+  sessions;
+  chat;
+  configuration;
+  nodes;
+  models;
+  /**
+   * Private constructor - use static factory methods
+   */
+  constructor(config, transport, events) {
+    this.config = config;
+    this.transport = transport;
+    this.events = events;
+    const moduleConfig = { transport, events };
+    this.system = new SystemModule(moduleConfig);
+    this.agents = new AgentsModule(moduleConfig);
+    this.sessions = new SessionsModule(moduleConfig);
+    this.chat = new ChatModule(moduleConfig);
+    this.configuration = new ConfigModule(moduleConfig);
+    this.nodes = new NodesModule(moduleConfig);
+    this.models = new ModelsModule(moduleConfig);
+    this.setupEventForwarding();
+  }
+  /**
+   * Setup event forwarding from transport
+   */
+  setupEventForwarding() {
+    this.transport.on("connection:state", (state) => {
+      this.events.emit("connection:state", state);
+    });
+    this.transport.on("connection:connected", () => {
+      this.events.emit("connection:connected");
+    });
+    this.transport.on("connection:disconnected", (reason) => {
+      this.events.emit("connection:disconnected", reason);
+    });
+    this.transport.on("connection:error", (error) => {
+      this.events.emit("connection:error", error);
+    });
+    this.transport.on("message", (message) => {
+      this.events.emit("message", message);
+    });
+    this.transport.on("event", (eventName, payload) => {
+      this.events.emit("event", eventName, payload);
+    });
+  }
+  /**
+   * Create a new MoltSDK instance with WebSocket transport
+   * Automatically connects to the gateway
+   */
+  static async create(config = {}) {
+    const fullConfig = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+    const events = new TypedEventEmitter();
+    const transport = new WebSocketTransport(fullConfig);
+    const sdk = new _MoltSDK(fullConfig, transport, events);
+    if (fullConfig.autoConnect !== false) {
+      try {
+        await sdk.connect();
+      } catch (error) {
+        throw new ConnectionError(
+          `Failed to connect to gateway: ${error instanceof Error ? error.message : String(error)}`,
+          { gatewayUrl: fullConfig.gatewayUrl },
+          error instanceof Error ? error : void 0
+        );
+      }
+    }
+    return sdk;
+  }
+  /**
+   * Create a new MoltSDK instance without auto-connecting
+   * Call connect() manually when ready
+   */
+  static createDisconnected(config = {}) {
+    const fullConfig = {
+      ...DEFAULT_CONFIG,
+      ...config,
+      autoConnect: false
+    };
+    const events = new TypedEventEmitter();
+    const transport = new WebSocketTransport(fullConfig);
+    return new _MoltSDK(fullConfig, transport, events);
+  }
+  /**
+   * Connect to the gateway
+   */
+  async connect() {
+    await this.transport.connect();
+  }
+  /**
+   * Disconnect from the gateway
+   */
+  disconnect() {
+    this.transport.disconnect();
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.transport.isConnected();
+  }
+  /**
+   * Get current connection state
+   */
+  getConnectionState() {
+    return this.transport.getConnectionState();
+  }
+  /**
+   * Subscribe to an event
+   */
+  on(event, handler) {
+    this.events.on(event, handler);
+    return this;
+  }
+  /**
+   * Subscribe to an event once
+   */
+  once(event, handler) {
+    this.events.once(event, handler);
+    return this;
+  }
+  /**
+   * Unsubscribe from an event
+   */
+  off(event, handler) {
+    this.events.off(event, handler);
+    return this;
+  }
+  /**
+   * Wait for an event (promisified)
+   */
+  waitFor(event, timeout) {
+    return this.events.waitFor(event, timeout);
+  }
+  /**
+   * Get the event emitter (for advanced use)
+   */
+  getEventEmitter() {
+    return this.events;
+  }
+  /**
+   * Get the transport (for advanced use)
+   */
+  getTransport() {
+    return this.transport;
+  }
+  /**
+   * Get SDK configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Make a raw RPC request (for advanced use)
+   */
+  async request(method, params = {}) {
+    return this.transport.request(method, params);
+  }
+  /**
+   * Get cached connection snapshot (contains health, agents, etc.)
+   * This data is populated from the initial connection and updated by events
+   */
+  getSnapshot() {
+    return this.transport.getSnapshot?.() || null;
+  }
+  /**
+   * Get cached health from connection snapshot
+   * This avoids the "unauthorized role" error when calling health RPC
+   */
+  getCachedHealth() {
+    return this.transport.getCachedHealth?.() || null;
+  }
+  /**
+   * Invalidate cached health data
+   * Call this after external operations (like CLI) that modify agent state
+   */
+  invalidateHealthCache() {
+    if (typeof this.transport.invalidateHealthCache === "function") {
+      this.transport.invalidateHealthCache();
+    }
+  }
+  /**
+   * Create a MoltSDK instance with CLI transport
+   * Uses CLI commands instead of WebSocket for communication
+   *
+   * @example
+   * ```typescript
+   * const sdk = await MoltSDK.createWithCLI();
+   * const agents = await sdk.agents.list();
+   * const response = await sdk.chat.send({ message: 'Hello!' });
+   * ```
+   */
+  static async createWithCLI(config = {}) {
+    const events = new TypedEventEmitter();
+    const transport = new CLITransport(config);
+    const sdkConfig = {
+      gatewayUrl: "cli://",
+      clientName: "molt-sdk-cli",
+      clientVersion: "1.0.0",
+      autoReconnect: false,
+      autoConnect: false
+    };
+    const sdk = new _MoltSDK(sdkConfig, transport, events);
+    await sdk.connect();
+    return sdk;
+  }
+  /**
+   * Create a disconnected CLI SDK instance
+   */
+  static createCLIDisconnected(config = {}) {
+    const events = new TypedEventEmitter();
+    const transport = new CLITransport(config);
+    const sdkConfig = {
+      gatewayUrl: "cli://",
+      clientName: "molt-sdk-cli",
+      clientVersion: "1.0.0",
+      autoReconnect: false,
+      autoConnect: false
+    };
+    return new _MoltSDK(sdkConfig, transport, events);
+  }
+};
+async function createMoltSDK(config = {}) {
+  return MoltSDK.create(config);
+}
+function createDisconnectedMoltSDK(config = {}) {
+  return MoltSDK.createDisconnected(config);
+}
+export {
+  AgentsModule,
+  AuthenticationError,
+  BaseModule,
+  CLIError,
+  CLITransport,
+  ChatModule,
+  ClawdbotClient,
+  ConfigModule,
+  ConnectionError,
+  DeviceIdentityManager,
+  ErrorCodes,
+  ModelsModule,
+  MoltError,
+  MoltSDK,
+  NodesModule,
+  NotConnectedError,
+  NotFoundError,
+  RPCError,
+  SessionsModule,
+  SystemModule,
+  TimeoutError,
+  TypedEventEmitter,
+  ValidationError,
+  WebSocketTransport,
+  createCLITransport,
+  createDisconnectedMoltSDK,
+  createEventEmitter,
+  createMoltSDK
+};