@steventsao/agent-session 0.1.23 → 0.1.24

package/dist/index.d.ts

@@ -1,27 +1,87 @@
-/**
- * agent-session client SDK
- *
- * Connect to agent-session Cloudflare Worker via WebSocket.
- *
- * @example
- * ```ts
- * import { AgentSessionClient } from 'agent-session';
- *
- * const client = new AgentSessionClient({
- *   url: 'wss://your-agent-session.workers.dev',
- *   sessionId: 'doc-123',
- *   userId: 'user-456',
- * });
- *
- * client.on('AGENT_MESSAGE', (event) => {
- *   console.log('Agent:', event.message);
- * });
- *
- * client.connect();
- * client.sendAgentMessage('Hello!');
- * ```
- */
+import * as _steventsao_agent_session_core from '@steventsao/agent-session-core';
+import { ServerEvent, ClientEvent } from '@steventsao/agent-session-core';
 export * from '@steventsao/agent-session-core';
-export { AgentSessionClient } from './client';
-export type { AgentSessionClientOptions } from './client';
-//# sourceMappingURL=index.d.ts.map
+
+type ServerEventHandler<T extends ServerEvent = ServerEvent> = (event: T) => void;
+interface AgentSessionClientOptions {
+    /** WebSocket base URL (e.g., wss://your-worker.workers.dev) */
+    url: string;
+    /** Session ID to connect to */
+    sessionId: string;
+    /** User ID for session tracking */
+    userId?: string;
+    /** Max reconnection attempts (default: 5) */
+    maxReconnectAttempts?: number;
+    /** Auto-reconnect on disconnect (default: true) */
+    autoReconnect?: boolean;
+    /** Ping interval in ms (default: 30000) */
+    pingInterval?: number;
+    /** Auto-connect on instantiation (default: false) */
+    autoConnect?: boolean;
+    /** Initial lastEventId for resumption (loaded from storage) */
+    lastEventId?: string;
+    /** Callback when lastEventId changes (for persistence) */
+    onEventIdChange?: (eventId: string) => void;
+}
+declare class AgentSessionClient {
+    private ws;
+    private baseUrl;
+    private sessionId;
+    private userId;
+    private pingIntervalId;
+    private reconnectTimeout;
+    private reconnectAttempts;
+    private socketId;
+    private maxReconnectAttempts;
+    private autoReconnect;
+    private pingInterval;
+    private lastEventId;
+    private onEventIdChange;
+    private handlers;
+    private globalHandlers;
+    constructor(options: AgentSessionClientOptions);
+    connect(): void;
+    disconnect(): void;
+    get isConnected(): boolean;
+    /** Get current event cursor for persistence */
+    getLastEventId(): string | null;
+    /** Set event cursor (load from storage before connect) */
+    setLastEventId(eventId: string | null): void;
+    /** Clear event cursor (for new chat/reset) */
+    clearEventId(): void;
+    on<T extends ServerEvent['type']>(eventType: T, handler: ServerEventHandler<Extract<ServerEvent, {
+        type: T;
+    }>>): () => void;
+    onAny(handler: ServerEventHandler): () => void;
+    off(eventType: ServerEvent['type']): void;
+    offAll(): void;
+    private handleMessage;
+    private updateEventId;
+    private emit;
+    send(message: ClientEvent): void;
+    init(metadata?: Record<string, unknown>): void;
+    startSandbox(template?: string): void;
+    stopSandbox(): void;
+    exec(cmd: string, cwd?: string): void;
+    sendAgentMessage(content: string, model?: {
+        id: string;
+        provider?: string;
+    }, options?: {
+        config?: {
+            temperature?: number;
+            maxTokens?: number;
+        };
+        systemPrompt?: string;
+        agentType?: string;
+        clientMessageId?: string;
+        author?: _steventsao_agent_session_core.MessageAuthor;
+    }): void;
+    stopAgent(): void;
+    resetAgent(): void;
+    private startPing;
+    private stopPing;
+    private clearReconnect;
+    private maybeReconnect;
+}
+
+export { AgentSessionClient, type AgentSessionClientOptions };

package/dist/index.js

@@ -1,39 +1,244 @@
-/**
- * agent-session client SDK
- *
- * Connect to agent-session Cloudflare Worker via WebSocket.
- *
- * @example
- * ```ts
- * import { AgentSessionClient } from 'agent-session';
- *
- * const client = new AgentSessionClient({
- *   url: 'wss://your-agent-session.workers.dev',
- *   sessionId: 'doc-123',
- *   userId: 'user-456',
- * });
- *
- * client.on('AGENT_MESSAGE', (event) => {
- *   console.log('Agent:', event.message);
- * });
- *
- * client.connect();
- * client.sendAgentMessage('Hello!');
- * ```
- */
-// Re-export types from core
-export * from '@steventsao/agent-session-core';
-// Export vanilla client
-export { AgentSessionClient } from './client';
-// Export RTK slice (import from '@agent-session/client/redux')
-// Usage:
-// ```ts
-// import agentSessionReducer, { connectSession, selectIsConnected } from '@agent-session/client/redux';
-//
-// const store = configureStore({
-//   reducer: { agentSession: agentSessionReducer }
-// });
-//
-// dispatch(connectSession({ url: 'wss://...', sessionId: 'session-123' }));
-// ```
-//# sourceMappingURL=index.js.map
+// src/index.ts
+export * from "@steventsao/agent-session-core";
+
+// src/client.ts
+var AgentSessionClient = class {
+  ws = null;
+  baseUrl;
+  sessionId;
+  userId;
+  pingIntervalId = null;
+  reconnectTimeout = null;
+  reconnectAttempts = 0;
+  socketId = 0;
+  maxReconnectAttempts;
+  autoReconnect;
+  pingInterval;
+  // Event resumption (Manus pattern)
+  lastEventId = null;
+  onEventIdChange = null;
+  // Event handlers
+  handlers = /* @__PURE__ */ new Map();
+  globalHandlers = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.baseUrl = options.url.replace(/\/$/, "");
+    this.sessionId = options.sessionId;
+    this.userId = options.userId || null;
+    this.maxReconnectAttempts = options.maxReconnectAttempts ?? 5;
+    this.autoReconnect = options.autoReconnect ?? true;
+    this.pingInterval = options.pingInterval ?? 3e4;
+    this.lastEventId = options.lastEventId || null;
+    this.onEventIdChange = options.onEventIdChange || null;
+    if (options.autoConnect) {
+      this.connect();
+    }
+  }
+  // ==========================================================================
+  // Connection Management
+  // ==========================================================================
+  connect() {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      return;
+    }
+    this.reconnectAttempts = 0;
+    const thisSocketId = ++this.socketId;
+    const params = new URLSearchParams();
+    if (this.userId) params.set("userId", this.userId);
+    const url = `${this.baseUrl}/session/${this.sessionId}/ws?${params}`;
+    console.log("[AgentSession] Connecting to:", url);
+    this.ws = new WebSocket(url);
+    this.ws.onopen = () => {
+      if (thisSocketId !== this.socketId) return;
+      console.log("[AgentSession] Connected");
+      this.reconnectAttempts = 0;
+      this.startPing();
+      this.send({
+        type: "JOIN_SESSION",
+        lastEventId: this.lastEventId || void 0
+      });
+    };
+    this.ws.onmessage = (event) => {
+      if (thisSocketId !== this.socketId) return;
+      try {
+        const data = JSON.parse(event.data);
+        this.handleMessage(data);
+      } catch (err) {
+        console.error("[AgentSession] Parse error:", err);
+      }
+    };
+    this.ws.onclose = (event) => {
+      if (thisSocketId !== this.socketId) return;
+      console.log("[AgentSession] Disconnected:", event.code);
+      this.stopPing();
+      this.emit({ type: "SYSTEM", msg: "Disconnected" });
+      if (this.autoReconnect) {
+        this.maybeReconnect();
+      }
+    };
+    this.ws.onerror = (event) => {
+      if (thisSocketId !== this.socketId) return;
+      console.error("[AgentSession] Error:", event);
+    };
+  }
+  disconnect() {
+    this.stopPing();
+    this.clearReconnect();
+    this.socketId++;
+    this.ws?.close();
+    this.ws = null;
+  }
+  get isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  /** Get current event cursor for persistence */
+  getLastEventId() {
+    return this.lastEventId;
+  }
+  /** Set event cursor (load from storage before connect) */
+  setLastEventId(eventId) {
+    this.lastEventId = eventId;
+  }
+  /** Clear event cursor (for new chat/reset) */
+  clearEventId() {
+    this.lastEventId = null;
+  }
+  // ==========================================================================
+  // Event Handling
+  // ==========================================================================
+  on(eventType, handler) {
+    if (!this.handlers.has(eventType)) {
+      this.handlers.set(eventType, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(eventType).add(handler);
+    return () => this.handlers.get(eventType)?.delete(handler);
+  }
+  onAny(handler) {
+    this.globalHandlers.add(handler);
+    return () => this.globalHandlers.delete(handler);
+  }
+  off(eventType) {
+    this.handlers.delete(eventType);
+  }
+  offAll() {
+    this.handlers.clear();
+    this.globalHandlers.clear();
+  }
+  handleMessage(event) {
+    if (event.type === "EVENTS_BATCH") {
+      const batchEvent = event;
+      console.log(`[AgentSession] Replaying ${batchEvent.count} events from batch`);
+      for (const batchedEvent of batchEvent.events) {
+        this.handleMessage(batchedEvent);
+      }
+      if (batchEvent.lastEventId) {
+        this.updateEventId(batchEvent.lastEventId);
+      }
+      return;
+    }
+    const eventWithMeta = event;
+    if (eventWithMeta.eventId) {
+      this.updateEventId(eventWithMeta.eventId);
+    }
+    const handlers = this.handlers.get(event.type);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(event);
+        } catch (err) {
+          console.error("[AgentSession] Handler error:", err);
+        }
+      }
+    }
+    for (const handler of this.globalHandlers) {
+      try {
+        handler(event);
+      } catch (err) {
+        console.error("[AgentSession] Global handler error:", err);
+      }
+    }
+  }
+  updateEventId(eventId) {
+    this.lastEventId = eventId;
+    this.onEventIdChange?.(eventId);
+  }
+  emit(event) {
+    this.handleMessage(event);
+  }
+  // ==========================================================================
+  // Client Commands
+  // ==========================================================================
+  send(message) {
+    if (this.ws?.readyState !== WebSocket.OPEN) {
+      console.warn("[AgentSession] Not connected");
+      return;
+    }
+    this.ws.send(JSON.stringify(message));
+  }
+  init(metadata) {
+    this.send({ type: "INIT", metadata });
+  }
+  startSandbox(template) {
+    this.send({ type: "START_SANDBOX", template });
+  }
+  stopSandbox() {
+    this.send({ type: "STOP_SANDBOX" });
+  }
+  exec(cmd, cwd) {
+    this.send({ type: "EXEC", cmd, cwd });
+  }
+  sendAgentMessage(content, model, options) {
+    this.send({
+      type: "AGENT_MESSAGE",
+      clientMessageId: options?.clientMessageId,
+      content,
+      model,
+      config: options?.config,
+      systemPrompt: options?.systemPrompt,
+      agentType: options?.agentType,
+      author: options?.author
+    });
+  }
+  stopAgent() {
+    this.send({ type: "AGENT_STOP" });
+  }
+  resetAgent() {
+    this.send({ type: "AGENT_RESET" });
+  }
+  // ==========================================================================
+  // Private Helpers
+  // ==========================================================================
+  startPing() {
+    this.stopPing();
+    this.pingIntervalId = setInterval(() => {
+      this.send({ type: "PING" });
+    }, this.pingInterval);
+  }
+  stopPing() {
+    if (this.pingIntervalId) {
+      clearInterval(this.pingIntervalId);
+      this.pingIntervalId = null;
+    }
+  }
+  clearReconnect() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+  }
+  maybeReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error("[AgentSession] Max reconnect attempts");
+      this.emit({ type: "ERROR", msg: "Max reconnect attempts reached" });
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
+    console.log(`[AgentSession] Reconnecting in ${delay}ms`);
+    this.reconnectTimeout = setTimeout(() => {
+      this.connect();
+    }, delay);
+  }
+};
+export {
+  AgentSessionClient
+};

package/dist/react.d.ts

@@ -1,26 +1,68 @@
+import { SessionRefreshConfig, SandboxLifecycle, ServerEvent, SandboxStatus, ContentBlock } from '@steventsao/agent-session-core';
+export * from '@steventsao/agent-session-core';
+
 /**
- * React bindings for agent-session
- *
- * @example
- * ```tsx
- * import { useAgentSession } from 'agent-session/react';
- *
- * function Chat() {
- *   const { messages, sendMessage, isConnected } = useAgentSession({
- *     url: 'wss://your-agent-session.workers.dev',
- *     sessionId: 'doc-123',
- *   });
- *
- *   return (
- *     <div>
- *       {messages.map(m => <p key={m.id}>{m.content}</p>)}
- *       <button onClick={() => sendMessage('Hello!')}>Send</button>
- *     </div>
- *   );
- * }
- * ```
+ * React Hook for agent-session
  */
-export { useAgentSession } from './use-agent-session';
-export type { UseAgentSessionOptions, UseAgentSessionReturn, AgentMessage } from './use-agent-session';
-export * from '@steventsao/agent-session-core';
-//# sourceMappingURL=react.d.ts.map
+
+interface AgentMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    content: string | ContentBlock[];
+    timestamp: number;
+}
+interface UseAgentSessionOptions {
+    /** WebSocket base URL (e.g., wss://your-worker.workers.dev) */
+    url: string;
+    /** Session ID to connect to */
+    sessionId?: string;
+    /** User ID for session tracking */
+    userId?: string;
+    /** Auto-connect on mount (default: true if sessionId provided) */
+    autoConnect?: boolean;
+    /**
+     * Session refresh configuration - controls behavior when sessionId changes.
+     * Default: 'reset' - clears all state when switching sessions (recommended for document isolation)
+     */
+    refreshConfig?: SessionRefreshConfig;
+    /** Event callbacks */
+    onLifecycle?: (phase: SandboxLifecycle, message?: string) => void;
+    onAgentMessage?: (event: ServerEvent) => void;
+    onError?: (error: string) => void;
+}
+interface UseAgentSessionReturn {
+    isConnected: boolean;
+    clientId: string | null;
+    sessionId: string | null;
+    sandboxStatus: SandboxStatus;
+    sandboxId: string | null;
+    sandboxUrl: string | null;
+    lifecycle: SandboxLifecycle;
+    lifecycleMessage: string | null;
+    agentStatus: 'idle' | 'streaming' | 'error';
+    agentSessionId: string | null;
+    messages: AgentMessage[];
+    error: string | null;
+    connect: (sessionId: string, userId?: string) => void;
+    disconnect: () => void;
+    startSandbox: (template?: string) => void;
+    stopSandbox: () => void;
+    exec: (cmd: string, cwd?: string) => void;
+    sendMessage: (content: string, model?: {
+        id: string;
+        provider?: string;
+    }, options?: {
+        config?: {
+            temperature?: number;
+            maxTokens?: number;
+        };
+        systemPrompt?: string;
+        agentType?: string;
+    }) => void;
+    stopAgent: () => void;
+    resetAgent: () => void;
+    clearMessages: () => void;
+}
+declare function useAgentSession(options: UseAgentSessionOptions): UseAgentSessionReturn;
+
+export { type AgentMessage, type UseAgentSessionOptions, type UseAgentSessionReturn, useAgentSession };