@chucky.cloud/sdk 0.2.7 → 0.3.1

package/dist/node.cjs

@@ -0,0 +1,1371 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/node.ts
+var node_exports = {};
+__export(node_exports, {
+  AuthenticationError: () => AuthenticationError,
+  BudgetExceededError: () => BudgetExceededError,
+  ChuckyClient: () => ChuckyClient,
+  ChuckyError: () => ChuckyError,
+  ConcurrencyLimitError: () => ConcurrencyLimitError,
+  ConnectionError: () => ConnectionError,
+  McpServerBuilder: () => McpServerBuilder,
+  RateLimitError: () => RateLimitError,
+  Session: () => Session,
+  SessionError: () => SessionError,
+  TimeoutError: () => TimeoutError,
+  ToolExecutionError: () => ToolExecutionError,
+  ValidationError: () => ValidationError,
+  WebSocketTransport: () => WebSocketTransport,
+  browserTool: () => browserTool,
+  createBudget: () => createBudget,
+  createClient: () => createClient,
+  createControlMessage: () => createControlMessage,
+  createError: () => createError,
+  createInitMessage: () => createInitMessage,
+  createMcpServer: () => createMcpServer,
+  createPingMessage: () => createPingMessage,
+  createToken: () => createToken,
+  createTool: () => createTool,
+  createToolResultMessage: () => createToolResultMessage,
+  createUserMessage: () => createUserMessage,
+  decodeToken: () => decodeToken,
+  errorResult: () => errorResult,
+  extractProjectId: () => extractProjectId,
+  getAssistantText: () => getAssistantText,
+  getResultText: () => getResultText,
+  imageResult: () => imageResult,
+  isAssistantMessage: () => isAssistantMessage,
+  isControlMessage: () => isControlMessage,
+  isErrorMessage: () => isErrorMessage,
+  isErrorResult: () => isErrorResult,
+  isResultMessage: () => isResultMessage,
+  isStreamEvent: () => isStreamEvent,
+  isSuccessResult: () => isSuccessResult,
+  isSystemMessage: () => isSystemMessage,
+  isTokenExpired: () => isTokenExpired,
+  isToolCallMessage: () => isToolCallMessage,
+  isUserMessage: () => isUserMessage,
+  mcpServer: () => mcpServer,
+  serverTool: () => serverTool,
+  textResult: () => textResult,
+  tool: () => tool,
+  verifyToken: () => verifyToken
+});
+module.exports = __toCommonJS(node_exports);
+
+// src/types/messages.ts
+function createInitMessage(payload) {
+  return { type: "init", payload };
+}
+function createUserMessage(content, sessionId, options = {}) {
+  const messageContent = typeof content === "string" ? content : content;
+  return {
+    type: "user",
+    uuid: options.uuid,
+    session_id: sessionId,
+    message: {
+      role: "user",
+      content: messageContent
+    },
+    parent_tool_use_id: options.parentToolUseId ?? null
+  };
+}
+function createControlMessage(action, data) {
+  return { type: "control", payload: { action, data } };
+}
+function createPingMessage() {
+  return { type: "ping", payload: { timestamp: Date.now() } };
+}
+function createToolResultMessage(callId, result) {
+  return { type: "tool_result", payload: { callId, result } };
+}
+function isUserMessage(message) {
+  return message.type === "user";
+}
+function isAssistantMessage(message) {
+  return message.type === "assistant";
+}
+function isResultMessage(message) {
+  return message.type === "result";
+}
+function isSuccessResult(message) {
+  return message.type === "result" && message.subtype === "success";
+}
+function isErrorResult(message) {
+  return message.type === "result" && message.subtype !== "success";
+}
+function isSystemMessage(message) {
+  return message.type === "system";
+}
+function isStreamEvent(message) {
+  return message.type === "stream_event";
+}
+function isToolCallMessage(message) {
+  return message.type === "tool_call";
+}
+function isControlMessage(message) {
+  return message.type === "control";
+}
+function isErrorMessage(message) {
+  return message.type === "error";
+}
+
+// src/transport/Transport.ts
+var BaseTransport = class {
+  constructor(config) {
+    __publicField(this, "_status", "disconnected");
+    __publicField(this, "handlers", {});
+    __publicField(this, "config");
+    const cleanConfig = Object.fromEntries(
+      Object.entries(config).filter(([_, v]) => v !== void 0)
+    );
+    this.config = {
+      timeout: 6e4,
+      // 60s - container startup can take time
+      keepAliveInterval: 3e5,
+      // 5 minutes
+      autoReconnect: false,
+      // Disabled - server doesn't support reconnect
+      maxReconnectAttempts: 0,
+      debug: false,
+      ...cleanConfig
+    };
+  }
+  get status() {
+    return this._status;
+  }
+  setStatus(status) {
+    if (this._status !== status) {
+      this._status = status;
+      this.handlers.onStatusChange?.(status);
+    }
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[ChuckySDK]", ...args);
+    }
+  }
+  logError(...args) {
+    console.error("[ChuckySDK]", ...args);
+  }
+  setEventHandlers(handlers) {
+    this.handlers = { ...this.handlers, ...handlers };
+  }
+};
+
+// src/transport/WebSocketTransport.ts
+async function getWebSocket() {
+  if (typeof WebSocket !== "undefined") {
+    return WebSocket;
+  }
+  const ws = await import("ws");
+  return ws.default;
+}
+var WebSocketTransport = class extends BaseTransport {
+  constructor(config) {
+    super(config);
+    __publicField(this, "ws", null);
+    __publicField(this, "keepAliveTimer", null);
+    __publicField(this, "reconnectAttempts", 0);
+    __publicField(this, "reconnectTimer", null);
+    __publicField(this, "readyPromise", null);
+    __publicField(this, "readyResolve", null);
+    __publicField(this, "readyReject", null);
+    __publicField(this, "messageQueue", []);
+  }
+  /**
+   * Build the WebSocket URL with token
+   */
+  buildUrl() {
+    const url = new URL(this.config.url);
+    url.searchParams.set("token", this.config.token);
+    return url.toString();
+  }
+  /**
+   * Connect to the WebSocket server
+   */
+  async connect() {
+    if (this._status === "connected" || this._status === "connecting") {
+      return this.waitForReady();
+    }
+    this.setStatus("connecting");
+    this.log("Connecting to", this.config.url);
+    this.readyPromise = new Promise((resolve, reject) => {
+      this.readyResolve = resolve;
+      this.readyReject = reject;
+    });
+    try {
+      const WS = await getWebSocket();
+      const wsUrl = this.buildUrl();
+      this.ws = new WS(wsUrl);
+      const timeoutId = setTimeout(() => {
+        if (this._status === "connecting") {
+          this.ws?.close();
+          const error = new Error("Connection timeout");
+          this.readyReject?.(error);
+          this.handlers.onError?.(error);
+          this.setStatus("error");
+        }
+      }, this.config.timeout);
+      this.ws.onopen = () => {
+        clearTimeout(timeoutId);
+        this.log("Connected");
+        this.setStatus("connected");
+        this.reconnectAttempts = 0;
+        this.startKeepAlive();
+        this.readyResolve?.();
+        this.flushMessageQueue();
+      };
+      this.ws.onclose = (event) => {
+        clearTimeout(timeoutId);
+        this.log("Disconnected:", event.code, event.reason);
+        this.stopKeepAlive();
+        if (this._status === "connecting") {
+          const error = new Error(`Connection failed: ${event.reason || "Unknown"}`);
+          this.readyReject?.(error);
+        }
+        this.setStatus("disconnected");
+        this.handlers.onClose?.(event.code, event.reason);
+        if (this.config.autoReconnect && this.reconnectAttempts < (this.config.maxReconnectAttempts || 5)) {
+          this.scheduleReconnect();
+        }
+      };
+      this.ws.onerror = (event) => {
+        clearTimeout(timeoutId);
+        const error = new Error("WebSocket error");
+        this.logError("WebSocket error:", event);
+        this.handlers.onError?.(error);
+        if (this._status === "connecting") {
+          this.readyReject?.(error);
+        }
+        this.setStatus("error");
+      };
+      this.ws.onmessage = (event) => {
+        this.handleMessage(event.data);
+      };
+      return this.readyPromise;
+    } catch (error) {
+      this.setStatus("error");
+      this.readyReject?.(error);
+      throw error;
+    }
+  }
+  /**
+   * Disconnect from the server
+   */
+  async disconnect() {
+    this.log("Disconnecting");
+    this.stopKeepAlive();
+    this.clearReconnectTimer();
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnect");
+      this.ws = null;
+    }
+    this.setStatus("disconnected");
+  }
+  /**
+   * Send a message to the server
+   */
+  async send(message) {
+    if (this._status === "disconnected" && !this.config.autoReconnect) {
+      this.log("Message dropped (disconnected):", message.type);
+      return;
+    }
+    if (this._status !== "connected") {
+      this.messageQueue.push(message);
+      this.log("Message queued (not connected):", message.type);
+      if (this._status === "disconnected" && this.config.autoReconnect) {
+        await this.connect();
+      }
+      return;
+    }
+    this.sendImmediate(message);
+  }
+  /**
+   * Send a message immediately
+   */
+  sendImmediate(message) {
+    if (!this.ws || this.ws.readyState !== 1) {
+      this.logError("Cannot send: WebSocket not ready");
+      return;
+    }
+    const data = JSON.stringify(message);
+    this.handlers.onRawMessage?.("out", message);
+    this.ws.send(data);
+    this.log("Sent:", message.type);
+  }
+  /**
+   * Wait for the connection to be ready
+   */
+  async waitForReady() {
+    if (this._status === "connected") {
+      return;
+    }
+    if (this.readyPromise) {
+      return this.readyPromise;
+    }
+    return this.connect();
+  }
+  /**
+   * Handle incoming message
+   */
+  handleMessage(data) {
+    try {
+      const text = typeof data === "string" ? data : new TextDecoder().decode(data);
+      const message = JSON.parse(text);
+      this.handlers.onRawMessage?.("in", message);
+      this.log("Received:", message.type);
+      if (message.type === "pong") {
+        return;
+      }
+      if (isErrorMessage(message)) {
+        const error = new Error(message.payload.message);
+        this.handlers.onError?.(error);
+      }
+      this.handlers.onMessage?.(message);
+    } catch (error) {
+      this.logError("Failed to parse message:", error);
+    }
+  }
+  /**
+   * Start keep-alive ping
+   */
+  startKeepAlive() {
+    this.stopKeepAlive();
+    if (this.config.keepAliveInterval && this.config.keepAliveInterval > 0) {
+      this.keepAliveTimer = setInterval(() => {
+        if (this._status === "connected" && this.ws?.readyState === 1) {
+          this.sendImmediate(createPingMessage());
+        }
+      }, this.config.keepAliveInterval);
+    }
+  }
+  /**
+   * Stop keep-alive ping
+   */
+  stopKeepAlive() {
+    if (this.keepAliveTimer) {
+      clearInterval(this.keepAliveTimer);
+      this.keepAliveTimer = null;
+    }
+  }
+  /**
+   * Schedule a reconnection attempt
+   */
+  scheduleReconnect() {
+    this.clearReconnectTimer();
+    this.reconnectAttempts++;
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts - 1), 16e3);
+    this.log(`Scheduling reconnect in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    this.setStatus("reconnecting");
+    this.reconnectTimer = setTimeout(() => {
+      this.connect().catch((error) => {
+        this.logError("Reconnect failed:", error);
+      });
+    }, delay);
+  }
+  /**
+   * Clear reconnect timer
+   */
+  clearReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  /**
+   * Flush queued messages
+   */
+  flushMessageQueue() {
+    while (this.messageQueue.length > 0) {
+      const message = this.messageQueue.shift();
+      this.sendImmediate(message);
+    }
+  }
+};
+
+// src/client/Session.ts
+function generateUUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var Session = class {
+  constructor(transport, options, config = {}) {
+    __publicField(this, "transport");
+    __publicField(this, "options");
+    __publicField(this, "config");
+    __publicField(this, "eventHandlers", {});
+    __publicField(this, "toolHandlers", /* @__PURE__ */ new Map());
+    __publicField(this, "messageBuffer", []);
+    __publicField(this, "_state", "idle");
+    __publicField(this, "_sessionId");
+    __publicField(this, "messageResolvers", []);
+    __publicField(this, "connected", false);
+    __publicField(this, "connectPromise", null);
+    this.transport = transport;
+    this.options = options;
+    this.config = config;
+    this._sessionId = options.sessionId || generateUUID();
+    if (options.mcpServers) {
+      for (const server of options.mcpServers) {
+        if ("tools" in server) {
+          for (const tool2 of server.tools) {
+            if (tool2.handler) {
+              this.toolHandlers.set(tool2.name, tool2.handler);
+            }
+          }
+        }
+      }
+    }
+    this.transport.setEventHandlers({
+      onMessage: (message) => this.handleMessage(message),
+      onError: (error) => this.eventHandlers.onError?.(error),
+      onStatusChange: (status) => {
+        if (status === "disconnected" && this._state !== "completed") {
+          this._state = "error";
+        }
+      }
+    });
+  }
+  /**
+   * Get the session ID
+   */
+  get sessionId() {
+    return this._sessionId;
+  }
+  /**
+   * Set event handlers
+   */
+  on(handlers) {
+    this.eventHandlers = { ...this.eventHandlers, ...handlers };
+    return this;
+  }
+  /**
+   * Connect and initialize the session (called automatically on first send)
+   */
+  async ensureConnected() {
+    if (this.connected) return;
+    if (this.connectPromise) {
+      return this.connectPromise;
+    }
+    this.connectPromise = this.connect();
+    await this.connectPromise;
+  }
+  async connect() {
+    this._state = "initializing";
+    await this.transport.connect();
+    const initPayload = this.buildInitPayload();
+    await this.transport.send(createInitMessage(initPayload));
+    await this.waitForReady();
+    this._state = "ready";
+    this.connected = true;
+  }
+  /**
+   * Send a message to the session
+   *
+   * Matches V2 SDK: send() returns Promise<void>
+   * Use stream() to get the response.
+   *
+   * Supports both text-only messages and multimodal content (text + images).
+   *
+   * @example
+   * ```typescript
+   * // Text-only message
+   * await session.send('Hello!');
+   *
+   * // Multimodal message with image
+   * await session.send([
+   *   { type: 'text', text: 'What is in this image?' },
+   *   { type: 'image', source: { type: 'base64', media_type: 'image/png', data: '...' } }
+   * ]);
+   *
+   * for await (const msg of session.stream()) {
+   *   // Handle messages
+   * }
+   * ```
+   */
+  async send(message) {
+    await this.ensureConnected();
+    if (this._state !== "ready") {
+      throw new Error(`Cannot send: session state is ${this._state}`);
+    }
+    this._state = "processing";
+    const userMessage = createUserMessage(message, this._sessionId);
+    await this.transport.send(userMessage);
+  }
+  /**
+   * Stream the response after sending a message
+   *
+   * Matches V2 SDK: Returns AsyncGenerator<SDKMessage>
+   *
+   * @example
+   * ```typescript
+   * await session.send('Hello!');
+   * for await (const msg of session.stream()) {
+   *   if (msg.type === 'assistant') {
+   *     const text = msg.message.content
+   *       .filter(b => b.type === 'text')
+   *       .map(b => b.text)
+   *       .join('');
+   *     console.log(text);
+   *   }
+   *   if (msg.type === 'result') {
+   *     console.log('Done:', msg.result);
+   *   }
+   * }
+   * ```
+   */
+  async *stream() {
+    while (this._state === "processing" || this._state === "waiting_tool") {
+      const msg = await this.waitForNextMessage();
+      if (isToolCallMessage(msg)) {
+        this._state = "waiting_tool";
+        await this.handleToolCall(msg.payload);
+        this._state = "processing";
+        continue;
+      }
+      if (isAssistantMessage(msg) || isResultMessage(msg) || isSystemMessage(msg) || isStreamEvent(msg)) {
+        yield msg;
+      }
+      if (isResultMessage(msg)) {
+        this._state = "ready";
+        break;
+      }
+      if (isErrorMessage(msg)) {
+        this._state = "ready";
+        throw new Error(msg.payload.message);
+      }
+    }
+  }
+  /**
+   * Receive messages (alias for stream for V2 compatibility)
+   */
+  receive() {
+    return this.stream();
+  }
+  /**
+   * Close the session
+   */
+  close() {
+    this.transport.send(createControlMessage("close")).catch(() => {
+    });
+    this.transport.disconnect().catch(() => {
+    });
+    this._state = "completed";
+  }
+  /**
+   * Support for `await using` (TypeScript 5.2+)
+   */
+  async [Symbol.asyncDispose]() {
+    this.close();
+  }
+  /**
+   * Build init payload from options
+   */
+  buildInitPayload() {
+    const { mcpServers, ...rest } = this.options;
+    const serializedMcpServers = mcpServers?.map((server) => {
+      if ("tools" in server) {
+        return {
+          name: server.name,
+          version: server.version,
+          tools: server.tools.map((tool2) => ({
+            name: tool2.name,
+            description: tool2.description,
+            inputSchema: tool2.inputSchema,
+            // If tool has a handler, it executes on the client (SDK) side
+            executeIn: tool2.handler ? "client" : tool2.executeIn
+          }))
+        };
+      }
+      return server;
+    });
+    return {
+      ...rest,
+      // tools is passed through as-is (string[] or preset for allowlisting)
+      mcpServers: serializedMcpServers
+    };
+  }
+  /**
+   * Handle incoming message
+   */
+  handleMessage(message) {
+    this.log("Received:", message.type);
+    if (isControlMessage(message)) {
+      if (message.payload.action === "session_info") {
+        const info = message.payload.data;
+        this._sessionId = info.sessionId || this._sessionId;
+        this.eventHandlers.onSessionInfo?.(info);
+      }
+    }
+    if (isSystemMessage(message) && message.subtype === "init") {
+      this._sessionId = message.session_id || this._sessionId;
+      this.eventHandlers.onSessionInfo?.({
+        sessionId: message.session_id,
+        model: message.model,
+        tools: message.tools
+      });
+    }
+    if (isErrorMessage(message)) {
+      const error = new Error(message.payload.message);
+      this.eventHandlers.onError?.(error);
+    }
+    const resolver = this.messageResolvers.shift();
+    if (resolver) {
+      resolver(message);
+    } else {
+      this.messageBuffer.push(message);
+    }
+  }
+  /**
+   * Wait for session to be ready
+   */
+  async waitForReady() {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Session initialization timeout"));
+      }, 3e4);
+      const checkReady = (message) => {
+        if (isControlMessage(message)) {
+          if (message.payload.action === "ready" || message.payload.action === "session_info") {
+            clearTimeout(timeout);
+            resolve();
+            return true;
+          }
+        }
+        if (isSystemMessage(message) && message.subtype === "init") {
+          clearTimeout(timeout);
+          resolve();
+          return true;
+        }
+        if (isErrorMessage(message)) {
+          clearTimeout(timeout);
+          reject(new Error(message.payload.message));
+          return true;
+        }
+        return false;
+      };
+      for (let i = 0; i < this.messageBuffer.length; i++) {
+        if (checkReady(this.messageBuffer[i])) {
+          this.messageBuffer.splice(i, 1);
+          return;
+        }
+      }
+      this.messageResolvers.push((msg) => {
+        checkReady(msg);
+      });
+    });
+  }
+  /**
+   * Wait for next message
+   */
+  async waitForNextMessage() {
+    if (this.messageBuffer.length > 0) {
+      return this.messageBuffer.shift();
+    }
+    return new Promise((resolve) => {
+      this.messageResolvers.push(resolve);
+    });
+  }
+  /**
+   * Handle a tool call
+   */
+  async handleToolCall(toolCall) {
+    const handler = this.toolHandlers.get(toolCall.toolName);
+    if (!handler) {
+      this.log("No local handler for tool:", toolCall.toolName);
+      return;
+    }
+    this.log("Executing tool:", toolCall.toolName);
+    try {
+      const result = await handler(toolCall.input);
+      await this.transport.send(createToolResultMessage(toolCall.callId, result));
+    } catch (error) {
+      const errorResult2 = {
+        content: [{ type: "text", text: error.message }],
+        isError: true
+      };
+      await this.transport.send(createToolResultMessage(toolCall.callId, errorResult2));
+    }
+  }
+  /**
+   * Log debug messages
+   */
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[Session]", ...args);
+    }
+  }
+};
+function getAssistantText(msg) {
+  if (msg.type !== "assistant") return null;
+  return msg.message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+function getResultText(msg) {
+  if (msg.type !== "result") return null;
+  const resultMsg = msg;
+  if (resultMsg.subtype === "success") {
+    return resultMsg.result;
+  }
+  return null;
+}
+
+// src/client/ChuckyClient.ts
+var DEFAULT_BASE_URL = "wss://conjure.chucky.cloud/ws";
+var ChuckyClient = class {
+  /**
+   * Create a new Chucky client
+   */
+  constructor(options) {
+    __publicField(this, "options");
+    __publicField(this, "eventHandlers", {});
+    __publicField(this, "activeSessions", /* @__PURE__ */ new Map());
+    this.options = {
+      baseUrl: DEFAULT_BASE_URL,
+      debug: false,
+      ...options
+    };
+  }
+  /**
+   * Set event handlers
+   */
+  on(handlers) {
+    this.eventHandlers = { ...this.eventHandlers, ...handlers };
+    return this;
+  }
+  /**
+   * Create a new session
+   *
+   * Matches V2 SDK: createSession() returns a Session immediately.
+   * Connection happens automatically on first send().
+   *
+   * @param options - Session configuration options
+   * @returns A new session instance
+   *
+   * @example
+   * ```typescript
+   * const session = client.createSession({
+   *   model: 'claude-sonnet-4-5-20250929',
+   *   systemPrompt: 'You are a helpful coding assistant.',
+   * });
+   *
+   * await session.send('Hello!');
+   * for await (const msg of session.stream()) {
+   *   // Handle messages
+   * }
+   * ```
+   */
+  createSession(options = {}) {
+    const transport = this.createTransport();
+    const session = new Session(transport, options, {
+      debug: this.options.debug
+    });
+    session.on({
+      onSessionInfo: (info) => {
+        if (info.sessionId) {
+          this.activeSessions.set(info.sessionId, session);
+        }
+      }
+    });
+    return session;
+  }
+  /**
+   * Resume an existing session
+   *
+   * @param sessionId - The session ID to resume
+   * @param options - Additional session options
+   * @returns The resumed session
+   *
+   * @example
+   * ```typescript
+   * const session = client.resumeSession('session-123');
+   * await session.send('Continue our conversation');
+   * ```
+   */
+  resumeSession(sessionId, options = {}) {
+    return this.createSession({
+      ...options,
+      sessionId
+    });
+  }
+  /**
+   * Execute a one-shot prompt (stateless)
+   *
+   * Supports two call signatures:
+   * - `prompt('message', { model: '...' })` - positional style
+   * - `prompt({ message: '...', model: '...' })` - object style
+   *
+   * @param messageOrOptions - The message string OR an options object with message
+   * @param options - Prompt configuration (only used with positional style)
+   * @returns The result message
+   *
+   * @example
+   * ```typescript
+   * // Positional style
+   * const result = await client.prompt(
+   *   'Explain quantum computing in simple terms',
+   *   { model: 'claude-sonnet-4-5-20250929' }
+   * );
+   *
+   * // Object style
+   * const result = await client.prompt({
+   *   message: 'Explain quantum computing in simple terms',
+   *   model: 'claude-sonnet-4-5-20250929',
+   * });
+   *
+   * if (result.subtype === 'success') {
+   *   console.log(result.result);
+   * }
+   * ```
+   */
+  async prompt(messageOrOptions, options = {}) {
+    let message;
+    let sessionOptions;
+    if (typeof messageOrOptions === "object") {
+      const { message: msg, ...rest } = messageOrOptions;
+      message = msg;
+      sessionOptions = rest;
+    } else {
+      message = messageOrOptions;
+      sessionOptions = options;
+    }
+    const session = this.createSession(sessionOptions);
+    try {
+      await session.send(message);
+      let result = null;
+      for await (const msg of session.stream()) {
+        if (msg.type === "result") {
+          result = msg;
+          break;
+        }
+      }
+      if (!result) {
+        throw new Error("No result message received");
+      }
+      return result;
+    } finally {
+      session.close();
+    }
+  }
+  /**
+   * Close all active sessions and disconnect
+   */
+  close() {
+    for (const session of this.activeSessions.values()) {
+      session.close();
+    }
+    this.activeSessions.clear();
+  }
+  /**
+   * Create a new transport instance
+   */
+  createTransport() {
+    return new WebSocketTransport({
+      url: this.options.baseUrl,
+      token: this.options.token,
+      timeout: this.options.timeout,
+      keepAliveInterval: this.options.keepAliveInterval,
+      autoReconnect: this.options.autoReconnect,
+      maxReconnectAttempts: this.options.maxReconnectAttempts,
+      debug: this.options.debug
+    });
+  }
+};
+function createClient(options) {
+  return new ChuckyClient(options);
+}
+
+// src/tools/tool.ts
+function isZodSchema(schema) {
+  return typeof schema === "object" && schema !== null && ("_def" in schema || "shape" in schema);
+}
+function zodToJsonSchema(zodSchema) {
+  const def = zodSchema._def;
+  if (!def) {
+    return {
+      type: "object",
+      properties: {}
+    };
+  }
+  const typeName = def.typeName;
+  if (typeName === "ZodObject") {
+    const shape = def.shape?.() || {};
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(shape)) {
+      const valueDef = value._def;
+      if (valueDef) {
+        const prop = zodDefToJsonSchema(valueDef);
+        if (prop) {
+          properties[key] = prop;
+          if (valueDef.typeName !== "ZodOptional") {
+            required.push(key);
+          }
+        }
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      required: required.length > 0 ? required : void 0
+    };
+  }
+  return {
+    type: "object",
+    properties: {}
+  };
+}
+function zodDefToJsonSchema(def) {
+  const typeName = def.typeName;
+  switch (typeName) {
+    case "ZodString":
+      return { type: "string", description: def.description };
+    case "ZodNumber":
+      return { type: "number", description: def.description };
+    case "ZodBoolean":
+      return { type: "boolean", description: def.description };
+    case "ZodArray":
+      const innerDef = def.innerType?._def;
+      return {
+        type: "array",
+        description: def.description,
+        items: innerDef ? zodDefToJsonSchema(innerDef) || { type: "string" } : { type: "string" }
+      };
+    case "ZodEnum":
+      return {
+        type: "string",
+        description: def.description,
+        enum: def.values
+      };
+    case "ZodOptional":
+      const innerOptDef = def.innerType?._def;
+      return innerOptDef ? zodDefToJsonSchema(innerOptDef) : null;
+    default:
+      return { type: "string" };
+  }
+}
+function createTool(options) {
+  let inputSchema;
+  if (isZodSchema(options.inputSchema)) {
+    inputSchema = zodToJsonSchema(options.inputSchema);
+  } else {
+    inputSchema = options.inputSchema;
+  }
+  return {
+    name: options.name,
+    description: options.description,
+    inputSchema,
+    executeIn: options.executeIn ?? "server",
+    handler: options.handler
+  };
+}
+function tool(name, description, inputSchema, handler) {
+  return createTool({ name, description, inputSchema, handler });
+}
+function browserTool(options) {
+  return createTool({ ...options, executeIn: "browser" });
+}
+function serverTool(options) {
+  return createTool({ ...options, executeIn: "server" });
+}
+function textResult(text) {
+  return {
+    content: [{ type: "text", text }]
+  };
+}
+function errorResult(message) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+function imageResult(data, mimeType) {
+  return {
+    content: [{ type: "image", data, mimeType }]
+  };
+}
+
+// src/tools/McpServer.ts
+var McpServerBuilder = class {
+  /**
+   * Create a new MCP server builder
+   *
+   * @param name - Server name
+   * @param version - Server version (default: '1.0.0')
+   */
+  constructor(name, version = "1.0.0") {
+    __publicField(this, "name");
+    __publicField(this, "version");
+    __publicField(this, "tools", []);
+    this.name = name;
+    this.version = version;
+  }
+  /**
+   * Add a tool to the server
+   *
+   * @param options - Tool configuration
+   * @returns This builder for chaining
+   */
+  addTool(options) {
+    this.tools.push(createTool(options));
+    return this;
+  }
+  /**
+   * Add an existing tool definition
+   *
+   * @param tool - Tool definition
+   * @returns This builder for chaining
+   */
+  add(tool2) {
+    this.tools.push(tool2);
+    return this;
+  }
+  /**
+   * Add multiple tools at once
+   *
+   * @param tools - Array of tool definitions
+   * @returns This builder for chaining
+   */
+  addTools(tools) {
+    this.tools.push(...tools);
+    return this;
+  }
+  /**
+   * Build the MCP server definition
+   *
+   * @returns Complete MCP server definition
+   */
+  build() {
+    return {
+      name: this.name,
+      version: this.version,
+      tools: this.tools
+    };
+  }
+};
+function createMcpServer(name, tools, version = "1.0.0") {
+  return {
+    name,
+    version,
+    tools
+  };
+}
+function mcpServer(name, version) {
+  return new McpServerBuilder(name, version);
+}
+
+// src/utils/token.ts
+function base64UrlEncode(data) {
+  let base64;
+  if (typeof data === "string") {
+    const bytes = new TextEncoder().encode(data);
+    base64 = btoa(String.fromCharCode(...bytes));
+  } else {
+    base64 = btoa(String.fromCharCode(...data));
+  }
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlDecode(str) {
+  const base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = "=".repeat((4 - base64.length % 4) % 4);
+  const bytes = atob(base64 + padding);
+  return bytes;
+}
+async function getCrypto() {
+  if (typeof crypto !== "undefined" && crypto.subtle) {
+    return crypto;
+  }
+  const nodeCrypto = await import("crypto");
+  return nodeCrypto.webcrypto;
+}
+async function createHmacSignature(secret, data) {
+  const { subtle } = await getCrypto();
+  const keyData = new TextEncoder().encode(secret);
+  const key = await subtle.importKey(
+    "raw",
+    keyData,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await subtle.sign("HMAC", key, new TextEncoder().encode(data));
+  return base64UrlEncode(new Uint8Array(signature));
+}
+async function verifyHmacSignature(secret, data, signature) {
+  const expectedSignature = await createHmacSignature(secret, data);
+  return signature === expectedSignature;
+}
+async function createToken(options) {
+  const {
+    userId,
+    projectId,
+    secret,
+    expiresIn = 3600,
+    budget,
+    permissions,
+    sdkConfig
+  } = options;
+  const now = Math.floor(Date.now() / 1e3);
+  const payload = {
+    sub: userId,
+    iss: projectId,
+    iat: now,
+    exp: now + expiresIn,
+    budget,
+    ...permissions && { permissions },
+    ...sdkConfig && { sdkConfig }
+  };
+  const header = {
+    alg: "HS256",
+    typ: "JWT"
+  };
+  const encodedHeader = base64UrlEncode(JSON.stringify(header));
+  const encodedPayload = base64UrlEncode(JSON.stringify(payload));
+  const signatureInput = `${encodedHeader}.${encodedPayload}`;
+  const signature = await createHmacSignature(secret, signatureInput);
+  return `${encodedHeader}.${encodedPayload}.${signature}`;
+}
+function decodeToken(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    throw new Error("Invalid token format");
+  }
+  const [encodedHeader, encodedPayload, signature] = parts;
+  const header = JSON.parse(base64UrlDecode(encodedHeader));
+  const payload = JSON.parse(base64UrlDecode(encodedPayload));
+  return { header, payload, signature };
+}
+async function verifyToken(token, secret) {
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    return false;
+  }
+  const [encodedHeader, encodedPayload, signature] = parts;
+  const signatureInput = `${encodedHeader}.${encodedPayload}`;
+  return verifyHmacSignature(secret, signatureInput, signature);
+}
+function isTokenExpired(token) {
+  try {
+    const decoded = decodeToken(token);
+    const now = Math.floor(Date.now() / 1e3);
+    return decoded.payload.exp < now;
+  } catch {
+    return true;
+  }
+}
+function extractProjectId(_hmacKey) {
+  throw new Error(
+    "extractProjectId() is deprecated. The project ID is now separate from the HMAC key for security. Get your project ID from the Chucky portal (app.chucky.cloud) in your project settings."
+  );
+}
+function createBudget(options) {
+  return {
+    ai: Math.floor(options.aiDollars * 1e6),
+    // Convert to microdollars
+    compute: Math.floor(options.computeHours * 3600),
+    // Convert to seconds
+    window: options.window,
+    windowStart: (options.windowStart || /* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/utils/errors.ts
+var ChuckyError = class _ChuckyError extends Error {
+  constructor(message, code, details) {
+    super(message);
+    /** Error code */
+    __publicField(this, "code");
+    /** Additional error details */
+    __publicField(this, "details");
+    this.name = "ChuckyError";
+    this.code = code;
+    this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _ChuckyError);
+    }
+  }
+};
+var ConnectionError = class extends ChuckyError {
+  constructor(message, details) {
+    super(message, "CONNECTION_ERROR", details);
+    this.name = "ConnectionError";
+  }
+};
+var AuthenticationError = class extends ChuckyError {
+  constructor(message, details) {
+    super(message, "AUTHENTICATION_ERROR", details);
+    this.name = "AuthenticationError";
+  }
+};
+var BudgetExceededError = class extends ChuckyError {
+  constructor(message, details) {
+    super(message, "BUDGET_EXCEEDED", details);
+    this.name = "BudgetExceededError";
+  }
+};
+var ConcurrencyLimitError = class extends ChuckyError {
+  constructor(message, details) {
+    super(message, "CONCURRENCY_LIMIT", details);
+    this.name = "ConcurrencyLimitError";
+  }
+};
+var RateLimitError = class extends ChuckyError {
+  constructor(message, details) {
+    super(message, "RATE_LIMIT", details);
+    this.name = "RateLimitError";
+  }
+};
+var SessionError = class extends ChuckyError {
+  constructor(message, details) {
+    super(message, "SESSION_ERROR", details);
+    this.name = "SessionError";
+  }
+};
+var ToolExecutionError = class extends ChuckyError {
+  constructor(message, toolName, details) {
+    super(message, "TOOL_EXECUTION_ERROR", { ...details, toolName });
+    /** Tool name */
+    __publicField(this, "toolName");
+    this.name = "ToolExecutionError";
+    this.toolName = toolName;
+  }
+};
+var TimeoutError = class extends ChuckyError {
+  constructor(message, details) {
+    super(message, "TIMEOUT", details);
+    this.name = "TimeoutError";
+  }
+};
+var ValidationError = class extends ChuckyError {
+  constructor(message, details) {
+    super(message, "VALIDATION_ERROR", details);
+    this.name = "ValidationError";
+  }
+};
+function parseErrorCode(message) {
+  const patterns = [
+    { pattern: /budget.*exceed/i, code: "BUDGET_EXCEEDED" },
+    { pattern: /concurrency.*limit/i, code: "CONCURRENCY_LIMIT" },
+    { pattern: /rate.*limit/i, code: "RATE_LIMIT" },
+    { pattern: /auth|unauthorized|forbidden/i, code: "AUTHENTICATION_ERROR" },
+    { pattern: /timeout/i, code: "TIMEOUT" },
+    { pattern: /connect|disconnect|websocket/i, code: "CONNECTION_ERROR" },
+    { pattern: /session/i, code: "SESSION_ERROR" },
+    { pattern: /tool/i, code: "TOOL_EXECUTION_ERROR" },
+    { pattern: /invalid|validation/i, code: "VALIDATION_ERROR" }
+  ];
+  for (const { pattern, code } of patterns) {
+    if (pattern.test(message)) {
+      return code;
+    }
+  }
+  return null;
+}
+function createError(message, code) {
+  const errorCode = code || parseErrorCode(message) || "UNKNOWN_ERROR";
+  switch (errorCode) {
+    case "CONNECTION_ERROR":
+      return new ConnectionError(message);
+    case "AUTHENTICATION_ERROR":
+      return new AuthenticationError(message);
+    case "BUDGET_EXCEEDED":
+      return new BudgetExceededError(message);
+    case "CONCURRENCY_LIMIT":
+      return new ConcurrencyLimitError(message);
+    case "RATE_LIMIT":
+      return new RateLimitError(message);
+    case "SESSION_ERROR":
+      return new SessionError(message);
+    case "TIMEOUT":
+      return new TimeoutError(message);
+    case "VALIDATION_ERROR":
+      return new ValidationError(message);
+    default:
+      return new ChuckyError(message, errorCode);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticationError,
+  BudgetExceededError,
+  ChuckyClient,
+  ChuckyError,
+  ConcurrencyLimitError,
+  ConnectionError,
+  McpServerBuilder,
+  RateLimitError,
+  Session,
+  SessionError,
+  TimeoutError,
+  ToolExecutionError,
+  ValidationError,
+  WebSocketTransport,
+  browserTool,
+  createBudget,
+  createClient,
+  createControlMessage,
+  createError,
+  createInitMessage,
+  createMcpServer,
+  createPingMessage,
+  createToken,
+  createTool,
+  createToolResultMessage,
+  createUserMessage,
+  decodeToken,
+  errorResult,
+  extractProjectId,
+  getAssistantText,
+  getResultText,
+  imageResult,
+  isAssistantMessage,
+  isControlMessage,
+  isErrorMessage,
+  isErrorResult,
+  isResultMessage,
+  isStreamEvent,
+  isSuccessResult,
+  isSystemMessage,
+  isTokenExpired,
+  isToolCallMessage,
+  isUserMessage,
+  mcpServer,
+  serverTool,
+  textResult,
+  tool,
+  verifyToken
+});
+//# sourceMappingURL=node.cjs.map