@witqq/agent-sdk 0.6.0 → 0.7.0

package/dist/chat/react.cjs

@@ -0,0 +1,2739 @@
+'use strict';
+
+var crypto$1 = require('crypto');
+var react = require('react');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/errors.ts
+var AgentSDKError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    AgentSDKError = class extends Error {
+      /** @internal Marker for cross-bundle identity checks */
+      _agentSDKError = true;
+      constructor(message, options) {
+        super(message, options);
+        this.name = "AgentSDKError";
+      }
+      /** Check if an error is an AgentSDKError (works across bundled copies) */
+      static is(error) {
+        return error instanceof Error && "_agentSDKError" in error && error._agentSDKError === true;
+      }
+    };
+  }
+});
+
+// src/auth/types.ts
+var AuthError, DeviceCodeExpiredError, AccessDeniedError, TokenExchangeError;
+var init_types = __esm({
+  "src/auth/types.ts"() {
+    init_errors();
+    AuthError = class extends AgentSDKError {
+      constructor(message, options) {
+        super(message, options);
+        this.name = "AuthError";
+      }
+    };
+    DeviceCodeExpiredError = class extends AuthError {
+      constructor() {
+        super("Device code expired. Please restart the auth flow.");
+        this.name = "DeviceCodeExpiredError";
+      }
+    };
+    AccessDeniedError = class extends AuthError {
+      constructor() {
+        super("Access was denied by the user.");
+        this.name = "AccessDeniedError";
+      }
+    };
+    TokenExchangeError = class extends AuthError {
+      constructor(message, options) {
+        super(message, options);
+        this.name = "TokenExchangeError";
+      }
+    };
+  }
+});
+
+// src/auth/copilot-auth.ts
+var CLIENT_ID, DEVICE_CODE_URL, ACCESS_TOKEN_URL, USER_API_URL, DEFAULT_SCOPES, GRANT_TYPE, CopilotAuth;
+var init_copilot_auth = __esm({
+  "src/auth/copilot-auth.ts"() {
+    init_types();
+    CLIENT_ID = "Ov23ctDVkRmgkPke0Mmm";
+    DEVICE_CODE_URL = "https://github.com/login/device/code";
+    ACCESS_TOKEN_URL = "https://github.com/login/oauth/access_token";
+    USER_API_URL = "https://api.github.com/user";
+    DEFAULT_SCOPES = "read:user,read:org,repo,gist";
+    GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
+    CopilotAuth = class {
+      fetchFn;
+      /** @param options - Optional configuration with custom fetch for testing */
+      constructor(options) {
+        this.fetchFn = options?.fetch ?? globalThis.fetch;
+      }
+      /**
+       * Start the GitHub Device Flow.
+       * Returns a device code result with user code, verification URL,
+       * and a `waitForToken()` function that polls until the user authorizes.
+       *
+       * @param options - Optional scopes and abort signal
+       * @returns Device flow result with user code, verification URL, and waitForToken poller
+       * @throws {AuthError} If the device code request fails
+       * @throws {DeviceCodeExpiredError} If the device code expires before user authorizes
+       * @throws {AccessDeniedError} If the user denies access
+       *
+       * @example
+       * ```ts
+       * const auth = new CopilotAuth();
+       * const { userCode, verificationUrl, waitForToken } = await auth.startDeviceFlow();
+       * console.log(`Open ${verificationUrl} and enter code: ${userCode}`);
+       * const token = await waitForToken();
+       * ```
+       */
+      async startDeviceFlow(options) {
+        const scopes = options?.scopes ?? DEFAULT_SCOPES;
+        const response = await this.fetchFn(DEVICE_CODE_URL, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            Accept: "application/json"
+          },
+          body: new URLSearchParams({
+            client_id: CLIENT_ID,
+            scope: scopes
+          }),
+          signal: options?.signal
+        });
+        if (!response.ok) {
+          throw new AuthError(
+            `Failed to request device code: ${response.status} ${response.statusText}`
+          );
+        }
+        const data = await response.json();
+        return {
+          userCode: data.user_code,
+          verificationUrl: data.verification_uri,
+          waitForToken: (signal) => this.pollForToken(data.device_code, data.interval, signal)
+        };
+      }
+      async pollForToken(deviceCode, interval, signal) {
+        let pollIntervalMs = interval * 1e3;
+        while (true) {
+          if (signal?.aborted) {
+            throw new AuthError("Authentication was aborted.");
+          }
+          await this.delay(pollIntervalMs, signal);
+          const response = await this.fetchFn(ACCESS_TOKEN_URL, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/x-www-form-urlencoded",
+              Accept: "application/json"
+            },
+            body: new URLSearchParams({
+              client_id: CLIENT_ID,
+              device_code: deviceCode,
+              grant_type: GRANT_TYPE
+            }),
+            signal
+          });
+          if (!response.ok) {
+            throw new AuthError(
+              `Token poll failed: ${response.status} ${response.statusText}`
+            );
+          }
+          const data = await response.json();
+          if (data.access_token) {
+            const token = {
+              accessToken: data.access_token,
+              tokenType: data.token_type ?? "bearer",
+              obtainedAt: Date.now()
+            };
+            try {
+              const login = await this.fetchUserLogin(data.access_token, signal);
+              if (login) token.login = login;
+            } catch {
+            }
+            return token;
+          }
+          if (data.error === "authorization_pending") {
+            continue;
+          }
+          if (data.error === "slow_down") {
+            pollIntervalMs = (data.interval ?? interval + 5) * 1e3;
+            continue;
+          }
+          if (data.error === "expired_token") {
+            throw new DeviceCodeExpiredError();
+          }
+          if (data.error === "access_denied") {
+            throw new AccessDeniedError();
+          }
+          throw new AuthError(
+            data.error_description ?? `Unexpected error: ${data.error}`
+          );
+        }
+      }
+      async fetchUserLogin(token, signal) {
+        const response = await this.fetchFn(USER_API_URL, {
+          headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/json"
+          },
+          signal
+        });
+        if (!response.ok) return void 0;
+        const user = await response.json();
+        return user.login;
+      }
+      delay(ms, signal) {
+        return new Promise((resolve, reject) => {
+          const timer = setTimeout(resolve, ms);
+          signal?.addEventListener(
+            "abort",
+            () => {
+              clearTimeout(timer);
+              reject(new AuthError("Authentication was aborted."));
+            },
+            { once: true }
+          );
+        });
+      }
+    };
+  }
+});
+function defaultRandomBytes(size) {
+  return new Uint8Array(crypto$1.randomBytes(size));
+}
+function base64Encode(bytes) {
+  return Buffer.from(bytes).toString("base64");
+}
+function hexEncode(bytes) {
+  return Buffer.from(bytes).toString("hex");
+}
+var CLIENT_ID2, AUTHORIZE_URL, TOKEN_URL, DEFAULT_REDIRECT_URI, DEFAULT_SCOPES2, ClaudeAuth;
+var init_claude_auth = __esm({
+  "src/auth/claude-auth.ts"() {
+    init_types();
+    CLIENT_ID2 = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+    AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
+    TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+    DEFAULT_REDIRECT_URI = "https://platform.claude.com/oauth/code/callback";
+    DEFAULT_SCOPES2 = "user:profile user:inference user:sessions:claude_code user:mcp_servers";
+    ClaudeAuth = class _ClaudeAuth {
+      fetchFn;
+      randomBytes;
+      /**
+       * @param options - Optional configuration with custom fetch and random bytes for testing
+       */
+      constructor(options) {
+        this.fetchFn = options?.fetch ?? globalThis.fetch;
+        this.randomBytes = options?.randomBytes ?? defaultRandomBytes;
+      }
+      /**
+       * Start the Claude OAuth+PKCE flow.
+       * Generates PKCE code verifier/challenge and returns an authorize URL
+       * plus a `completeAuth(code)` function for token exchange.
+       *
+       * @param options - Redirect URI and optional scopes
+       * @returns OAuth flow result with authorize URL and completeAuth function
+       * @throws {AuthError} If PKCE generation fails
+       *
+       * @example
+       * ```ts
+       * const auth = new ClaudeAuth();
+       * const { authorizeUrl, completeAuth } = auth.startOAuthFlow({
+       *   redirectUri: "https://platform.claude.com/oauth/code/callback",
+       * });
+       * console.log(`Open: ${authorizeUrl}`);
+       * const token = await completeAuth(authorizationCode);
+       * ```
+       */
+      startOAuthFlow(options) {
+        const redirectUri = options?.redirectUri ?? DEFAULT_REDIRECT_URI;
+        const scopes = options?.scopes ?? DEFAULT_SCOPES2;
+        const codeVerifier = this.generateCodeVerifier();
+        const state = this.generateState();
+        const authorizeUrl = this.buildAuthorizeUrl(
+          redirectUri,
+          scopes,
+          codeVerifier,
+          state
+        );
+        return {
+          authorizeUrl,
+          completeAuth: (codeOrUrl) => {
+            const code = _ClaudeAuth.extractCode(codeOrUrl);
+            return this.exchangeCode(code, codeVerifier, state, redirectUri);
+          }
+        };
+      }
+      /**
+       * Extract an authorization code from user input.
+       * Accepts a raw code string or a full redirect URL containing a `code` query parameter.
+       *
+       * @param input - Raw authorization code or redirect URL
+       * @returns The extracted authorization code
+       *
+       * @example
+       * ```ts
+       * ClaudeAuth.extractCode("abc123"); // "abc123"
+       * ClaudeAuth.extractCode("https://platform.claude.com/oauth/code/callback?code=abc123&state=xyz"); // "abc123"
+       * ```
+       */
+      static extractCode(input) {
+        const trimmed = input.trim();
+        try {
+          const url = new URL(trimmed);
+          const code = url.searchParams.get("code");
+          if (code) return code;
+        } catch {
+        }
+        const hashIdx = trimmed.indexOf("#");
+        if (hashIdx > 0) {
+          return trimmed.substring(0, hashIdx);
+        }
+        return trimmed;
+      }
+      /**
+       * Refresh an expired Claude token.
+       *
+       * @param refreshToken - The refresh token from a previous authentication
+       * @returns New auth token with refreshed access token
+       * @throws {TokenExchangeError} If the refresh request fails
+       *
+       * @example
+       * ```ts
+       * const auth = new ClaudeAuth();
+       * const newToken = await auth.refreshToken(oldToken.refreshToken);
+       * ```
+       */
+      async refreshToken(refreshToken) {
+        const response = await this.fetchFn(TOKEN_URL, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            grant_type: "refresh_token",
+            refresh_token: refreshToken,
+            client_id: CLIENT_ID2
+          })
+        });
+        if (!response.ok) {
+          const text = await response.text();
+          throw new TokenExchangeError(
+            `Token refresh failed: ${response.status} ${text}`
+          );
+        }
+        const data = await response.json();
+        return this.mapTokenResponse(data);
+      }
+      generateCodeVerifier() {
+        const bytes = this.randomBytes(96);
+        return base64Encode(bytes).replace(/\+/g, "~").replace(/=/g, "_").replace(/\//g, "-");
+      }
+      generateState() {
+        const bytes = this.randomBytes(16);
+        return hexEncode(bytes);
+      }
+      buildAuthorizeUrl(redirectUri, scopes, codeVerifier, state) {
+        const codeChallenge = this.generateCodeChallengeSync(codeVerifier);
+        const url = new URL(AUTHORIZE_URL);
+        url.searchParams.set("code", "true");
+        url.searchParams.set("client_id", CLIENT_ID2);
+        url.searchParams.set("response_type", "code");
+        url.searchParams.set("redirect_uri", redirectUri);
+        url.searchParams.set("scope", scopes);
+        url.searchParams.set("code_challenge", codeChallenge);
+        url.searchParams.set("code_challenge_method", "S256");
+        url.searchParams.set("state", state);
+        return url.toString();
+      }
+      generateCodeChallengeSync(verifier) {
+        const hash = crypto$1.createHash("sha256").update(verifier).digest("base64");
+        return hash.split("=")[0].replace(/\+/g, "-").replace(/\//g, "_");
+      }
+      async exchangeCode(code, codeVerifier, state, redirectUri) {
+        const response = await this.fetchFn(TOKEN_URL, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            grant_type: "authorization_code",
+            code,
+            redirect_uri: redirectUri,
+            client_id: CLIENT_ID2,
+            code_verifier: codeVerifier,
+            state
+          })
+        });
+        if (!response.ok) {
+          const text = await response.text();
+          throw new TokenExchangeError(
+            `Token exchange failed: ${response.status} ${text}`
+          );
+        }
+        const data = await response.json();
+        return this.mapTokenResponse(data);
+      }
+      mapTokenResponse(data) {
+        return {
+          accessToken: data.access_token,
+          tokenType: data.token_type ?? "bearer",
+          expiresIn: data.expires_in,
+          obtainedAt: Date.now(),
+          refreshToken: data.refresh_token,
+          scopes: data.scope?.split(" ") ?? []
+        };
+      }
+    };
+  }
+});
+
+// src/auth/refresh-manager.ts
+var TokenRefreshManager;
+var init_refresh_manager = __esm({
+  "src/auth/refresh-manager.ts"() {
+    TokenRefreshManager = class {
+      currentToken;
+      refreshFn;
+      threshold;
+      maxRetries;
+      retryDelayMs;
+      minDelayMs;
+      timerId = null;
+      running = false;
+      disposed = false;
+      listeners = {
+        refreshed: /* @__PURE__ */ new Set(),
+        error: /* @__PURE__ */ new Set(),
+        expired: /* @__PURE__ */ new Set(),
+        disposed: /* @__PURE__ */ new Set()
+      };
+      constructor(options) {
+        this.currentToken = { ...options.token };
+        this.refreshFn = options.refresh;
+        this.threshold = options.refreshThreshold ?? 0.8;
+        this.maxRetries = options.maxRetries ?? 3;
+        this.retryDelayMs = options.retryDelayMs ?? 1e3;
+        this.minDelayMs = options.minDelayMs ?? 1e3;
+      }
+      /** Register an event listener */
+      on(event, listener) {
+        this.listeners[event].add(listener);
+        return this;
+      }
+      /** Remove an event listener */
+      off(event, listener) {
+        this.listeners[event].delete(listener);
+        return this;
+      }
+      /** Current token managed by this instance */
+      get token() {
+        return { ...this.currentToken };
+      }
+      /** Whether the manager is currently running */
+      get isRunning() {
+        return this.running;
+      }
+      /** Whether the manager has been disposed */
+      get isDisposed() {
+        return this.disposed;
+      }
+      /**
+       * Start automatic refresh scheduling.
+       * If the token is already expired, emits "expired" immediately.
+       * If the token has no expiresIn, does nothing (long-lived token).
+       */
+      start() {
+        if (this.disposed) return;
+        if (this.running) return;
+        this.running = true;
+        this.schedule();
+      }
+      /** Stop automatic refresh (can be restarted with start()) */
+      stop() {
+        this.running = false;
+        this.clearTimer();
+      }
+      /**
+       * Update the managed token (e.g. after manual refresh).
+       * Reschedules automatic refresh if running.
+       */
+      updateToken(token) {
+        if (this.disposed) return;
+        this.currentToken = { ...token };
+        if (this.running) {
+          this.clearTimer();
+          this.schedule();
+        }
+      }
+      /** Stop and clean up all resources */
+      dispose() {
+        if (this.disposed) return;
+        this.stop();
+        this.disposed = true;
+        this.emit("disposed");
+        for (const set of Object.values(this.listeners)) {
+          set.clear();
+        }
+      }
+      // ─── Private ──────────────────────────────────────────────────
+      schedule() {
+        if (!this.running || this.disposed) return;
+        const delayMs = this.computeRefreshDelay();
+        if (delayMs === null) {
+          return;
+        }
+        if (delayMs <= 0) {
+          this.timerId = setTimeout(() => {
+            this.timerId = null;
+            if (!this.running || this.disposed) return;
+            void this.performRefresh();
+          }, 0);
+          return;
+        }
+        this.timerId = setTimeout(() => {
+          this.timerId = null;
+          if (!this.running || this.disposed) return;
+          void this.performRefresh();
+        }, Math.max(delayMs, this.minDelayMs));
+      }
+      async performRefresh(attempt = 1) {
+        if (!this.running || this.disposed) return;
+        try {
+          const newToken = await this.refreshFn(this.currentToken);
+          if (!this.running || this.disposed) return;
+          this.currentToken = { ...newToken };
+          this.emit("refreshed", newToken);
+          this.schedule();
+        } catch (err) {
+          if (!this.running || this.disposed) return;
+          const error = err instanceof Error ? err : new Error(String(err));
+          this.emit("error", error, attempt);
+          if (attempt < this.maxRetries) {
+            const delay = this.retryDelayMs * Math.pow(2, attempt - 1);
+            this.timerId = setTimeout(() => {
+              this.timerId = null;
+              if (!this.running || this.disposed) return;
+              void this.performRefresh(attempt + 1);
+            }, delay);
+          } else {
+            if (this.isTokenExpired()) {
+              this.running = false;
+              this.emit("expired");
+            } else {
+              const expiresIn = this.currentToken.expiresIn;
+              if (expiresIn == null) return;
+              const expiresAt = this.currentToken.obtainedAt + expiresIn * 1e3;
+              const waitMs = Math.max(expiresAt - Date.now(), this.minDelayMs);
+              this.timerId = setTimeout(() => {
+                this.timerId = null;
+                if (!this.running || this.disposed) return;
+                void this.performRefresh();
+              }, waitMs);
+            }
+          }
+        }
+      }
+      computeRefreshDelay() {
+        if (this.currentToken.expiresIn == null) return null;
+        const lifetimeMs = this.currentToken.expiresIn * 1e3;
+        const refreshAtMs = this.currentToken.obtainedAt + lifetimeMs * this.threshold;
+        const now = Date.now();
+        const delay = refreshAtMs - now;
+        return delay;
+      }
+      isTokenExpired() {
+        if (this.currentToken.expiresIn == null) return false;
+        const expiresAt = this.currentToken.obtainedAt + this.currentToken.expiresIn * 1e3;
+        return Date.now() >= expiresAt;
+      }
+      clearTimer() {
+        if (this.timerId !== null) {
+          clearTimeout(this.timerId);
+          this.timerId = null;
+        }
+      }
+      emit(event, ...args) {
+        for (const listener of this.listeners[event]) {
+          try {
+            listener(...args);
+          } catch {
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/auth/index.ts
+var auth_exports = {};
+__export(auth_exports, {
+  AccessDeniedError: () => AccessDeniedError,
+  AuthError: () => AuthError,
+  ClaudeAuth: () => ClaudeAuth,
+  CopilotAuth: () => CopilotAuth,
+  DeviceCodeExpiredError: () => DeviceCodeExpiredError,
+  TokenExchangeError: () => TokenExchangeError,
+  TokenRefreshManager: () => TokenRefreshManager
+});
+var init_auth = __esm({
+  "src/auth/index.ts"() {
+    init_types();
+    init_copilot_auth();
+    init_claude_auth();
+    init_refresh_manager();
+  }
+});
+var ChatRuntimeContext = react.createContext(null);
+function ChatProvider({ runtime, children }) {
+  return react.createElement(ChatRuntimeContext.Provider, { value: runtime }, children);
+}
+function useChatRuntime() {
+  const runtime = react.useContext(ChatRuntimeContext);
+  if (!runtime) {
+    throw new Error("useChatRuntime must be used within a ChatProvider");
+  }
+  return runtime;
+}
+
+// src/chat/core.ts
+function createChatId() {
+  return crypto.randomUUID();
+}
+function chatEventToAgentEvent(event) {
+  switch (event.type) {
+    case "message:delta":
+      return { type: "text_delta", text: event.text };
+    case "thinking:start":
+      return { type: "thinking_start" };
+    case "thinking:delta":
+      return { type: "thinking_delta", text: event.text };
+    case "thinking:end":
+      return { type: "thinking_end" };
+    case "tool:start":
+      return {
+        type: "tool_call_start",
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        args: event.args
+      };
+    case "tool:complete":
+      return {
+        type: "tool_call_end",
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        result: event.result
+      };
+    case "error":
+      return { type: "error", error: event.error, recoverable: event.recoverable };
+    default:
+      return null;
+  }
+}
+
+// src/chat/accumulator.ts
+var MessageAccumulator = class {
+  messageId;
+  parts = [];
+  status = "pending";
+  currentTextPart = null;
+  currentReasoningPart = null;
+  toolCallParts = /* @__PURE__ */ new Map();
+  _finalized = false;
+  constructor(messageId) {
+    this.messageId = messageId ?? createChatId();
+  }
+  /** Get current message ID */
+  get id() {
+    return this.messageId;
+  }
+  /**
+   * Apply an AgentEvent to accumulate into the message
+   * @param event - AgentEvent to process
+   * @throws Error if accumulator is already finalized
+   */
+  apply(event) {
+    if (this._finalized) throw new Error("Cannot apply events to finalized accumulator");
+    if (this.status === "pending") {
+      this.status = "streaming";
+    }
+    switch (event.type) {
+      case "text_delta":
+        this.handleTextDelta(event.text);
+        break;
+      case "thinking_start":
+        this.finalizeCurrentText();
+        this.currentReasoningPart = { type: "reasoning", text: "", status: "streaming" };
+        this.parts.push(this.currentReasoningPart);
+        break;
+      case "thinking_delta":
+        if (this.currentReasoningPart) {
+          this.currentReasoningPart.text += event.text;
+        }
+        break;
+      case "thinking_end":
+        if (this.currentReasoningPart) {
+          this.currentReasoningPart.status = "complete";
+          this.currentReasoningPart = null;
+        }
+        break;
+      case "tool_call_start": {
+        this.finalizeCurrentText();
+        const toolPart = {
+          type: "tool_call",
+          toolCallId: event.toolCallId,
+          name: event.toolName,
+          args: event.args,
+          status: "running"
+        };
+        this.toolCallParts.set(event.toolCallId, toolPart);
+        this.parts.push(toolPart);
+        break;
+      }
+      case "tool_call_end": {
+        const existing = this.toolCallParts.get(event.toolCallId);
+        if (existing) {
+          existing.result = event.result;
+          existing.status = "complete";
+        }
+        break;
+      }
+      case "error":
+        this.status = "error";
+        break;
+    }
+  }
+  handleTextDelta(text) {
+    if (!this.currentTextPart) {
+      this.currentTextPart = { type: "text", text: "", status: "streaming" };
+      this.parts.push(this.currentTextPart);
+    }
+    this.currentTextPart.text += text;
+  }
+  finalizeCurrentText() {
+    if (this.currentTextPart) {
+      this.currentTextPart.status = "complete";
+      this.currentTextPart = null;
+    }
+  }
+  /**
+   * Get a snapshot of the current accumulated message (for streaming UI)
+   * @returns ChatMessage with current parts and "streaming" status
+   */
+  snapshot() {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      id: this.messageId,
+      role: "assistant",
+      parts: this.parts.map((p) => ({ ...p })),
+      status: this.status === "pending" ? "pending" : "streaming",
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  /**
+   * Finalize the accumulator and return the complete ChatMessage
+   * @returns Completed ChatMessage with all parts finalized
+   * @throws Error if accumulator is already finalized
+   */
+  finalize() {
+    if (this._finalized) throw new Error("Accumulator already finalized");
+    this._finalized = true;
+    this.finalizeCurrentText();
+    if (this.currentReasoningPart) {
+      this.currentReasoningPart.status = "complete";
+      this.currentReasoningPart = null;
+    }
+    for (const [, toolPart] of this.toolCallParts) {
+      if (toolPart.status === "running" || toolPart.status === "pending") {
+        toolPart.status = "error";
+      }
+    }
+    if (this.status !== "error" && this.status !== "cancelled") {
+      this.status = "complete";
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      id: this.messageId,
+      role: "assistant",
+      parts: this.parts,
+      status: this.status,
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  /** Check if the accumulator has been finalized */
+  get finalized() {
+    return this._finalized;
+  }
+};
+
+// src/chat/react/useChat.ts
+function useChat(options = {}) {
+  const runtime = useChatRuntime();
+  const [sessionId, setSessionId] = react.useState(
+    options.sessionId ?? null
+  );
+  const [messages, setMessages] = react.useState([]);
+  const [isGenerating, setIsGenerating] = react.useState(false);
+  const [status, setStatus] = react.useState("idle");
+  const [error, setError] = react.useState(null);
+  const generatingRef = react.useRef(false);
+  const onErrorRef = react.useRef(options.onError);
+  onErrorRef.current = options.onError;
+  react.useEffect(() => {
+    if (!sessionId) {
+      setMessages([]);
+      return;
+    }
+    runtime.getSession(sessionId).then((session) => {
+      if (session) {
+        setMessages([...session.messages]);
+      }
+    });
+  }, [sessionId, runtime]);
+  const ensureSession = react.useCallback(async () => {
+    if (sessionId) return sessionId;
+    const session = await runtime.createSession({
+      config: { model: "", backend: "" }
+    });
+    setSessionId(session.id);
+    return session.id;
+  }, [sessionId, runtime]);
+  const sendMessage = react.useCallback(
+    async (content) => {
+      if (generatingRef.current) return;
+      setError(null);
+      generatingRef.current = true;
+      setIsGenerating(true);
+      setStatus("streaming");
+      const accumulator = new MessageAccumulator();
+      let hasEvents = false;
+      try {
+        const sid = await ensureSession();
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const userMsg = {
+          id: crypto.randomUUID(),
+          role: "user",
+          parts: [{ type: "text", text: content, status: "complete" }],
+          status: "complete",
+          createdAt: now,
+          updatedAt: now
+        };
+        setMessages((prev) => [...prev, userMsg]);
+        for await (const event of runtime.send(sid, content)) {
+          const agentEvent = chatEventToAgentEvent(event);
+          if (agentEvent) {
+            accumulator.apply(agentEvent);
+            hasEvents = true;
+            const snapshot = accumulator.snapshot();
+            setMessages((prev) => {
+              const last = prev[prev.length - 1];
+              if (last && last.id === snapshot.id) {
+                return [...prev.slice(0, -1), snapshot];
+              }
+              return [...prev, snapshot];
+            });
+          }
+        }
+        const session = await runtime.getSession(sid);
+        if (session) {
+          setMessages([...session.messages]);
+        } else if (hasEvents) {
+          const final = accumulator.finalize();
+          setMessages((prev) => {
+            const last = prev[prev.length - 1];
+            if (last && last.id === final.id) {
+              return [...prev.slice(0, -1), final];
+            }
+            return [...prev, final];
+          });
+        }
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onErrorRef.current?.(e);
+        if (hasEvents && !accumulator.finalized) {
+          accumulator.apply({ type: "error", error: e.message, recoverable: false });
+          const errorSnapshot = accumulator.finalize();
+          setMessages((prev) => {
+            const last = prev[prev.length - 1];
+            if (last && last.id === errorSnapshot.id) {
+              return [...prev.slice(0, -1), errorSnapshot];
+            }
+            return prev;
+          });
+        }
+      } finally {
+        generatingRef.current = false;
+        setIsGenerating(false);
+        setStatus(runtime.status);
+      }
+    },
+    [ensureSession, runtime]
+  );
+  const stop = react.useCallback(() => {
+    runtime.abort();
+  }, [runtime]);
+  const clearError = react.useCallback(() => {
+    setError(null);
+  }, []);
+  const newSession = react.useCallback(async () => {
+    const session = await runtime.createSession({
+      config: { model: "", backend: "" }
+    });
+    setSessionId(session.id);
+    setMessages([]);
+    setError(null);
+    return session.id;
+  }, [runtime]);
+  return {
+    sessionId,
+    messages,
+    sendMessage,
+    stop,
+    isGenerating,
+    status,
+    error,
+    clearError,
+    newSession
+  };
+}
+var EMPTY_MESSAGES = [];
+function useMessages(options) {
+  const runtime = useChatRuntime();
+  const { sessionId } = options;
+  const sessionRef = react.useRef(null);
+  const messagesRef = react.useRef(EMPTY_MESSAGES);
+  const isLoadedRef = react.useRef(false);
+  const versionRef = react.useRef(0);
+  const listenersRef = react.useRef(/* @__PURE__ */ new Set());
+  const emitChange = react.useCallback(() => {
+    versionRef.current++;
+    for (const listener of listenersRef.current) {
+      listener();
+    }
+  }, []);
+  const subscribe = react.useCallback(
+    (callback) => {
+      listenersRef.current.add(callback);
+      return () => {
+        listenersRef.current.delete(callback);
+      };
+    },
+    []
+  );
+  const getSnapshot = react.useCallback(() => {
+    return messagesRef.current;
+  }, []);
+  react.useEffect(() => {
+    let cancelled = false;
+    let unsubscribe;
+    let pollInterval;
+    async function load() {
+      const session = await runtime.getSession(sessionId);
+      if (cancelled) return;
+      if (!session) {
+        sessionRef.current = null;
+        messagesRef.current = EMPTY_MESSAGES;
+        isLoadedRef.current = false;
+        emitChange();
+        return;
+      }
+      sessionRef.current = session;
+      messagesRef.current = session.messages;
+      isLoadedRef.current = true;
+      emitChange();
+      if (session.subscribe && session.getSnapshot) {
+        unsubscribe = session.subscribe(() => {
+          const snapshot = session.getSnapshot();
+          messagesRef.current = snapshot.messages;
+          emitChange();
+        });
+      } else {
+        pollInterval = setInterval(async () => {
+          if (cancelled) return;
+          const updated = await runtime.getSession(sessionId);
+          if (cancelled || !updated) return;
+          if (updated.messages.length !== messagesRef.current.length) {
+            messagesRef.current = updated.messages;
+            emitChange();
+          }
+        }, 500);
+      }
+    }
+    load();
+    return () => {
+      cancelled = true;
+      unsubscribe?.();
+      if (pollInterval) clearInterval(pollInterval);
+    };
+  }, [sessionId, runtime, emitChange]);
+  const messages = react.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  return {
+    messages,
+    isLoaded: isLoadedRef.current
+  };
+}
+function toSessionInfo(s) {
+  return {
+    id: s.id,
+    title: s.title,
+    status: s.status,
+    messageCount: s.metadata.messageCount,
+    lastMessage: s.messages[s.messages.length - 1],
+    createdAt: s.createdAt,
+    updatedAt: s.updatedAt
+  };
+}
+function useSessions() {
+  const runtime = useChatRuntime();
+  const [sessions, setSessions] = react.useState([]);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const fetchSessions = react.useCallback(async () => {
+    try {
+      const list = await runtime.listSessions();
+      setSessions(list.map(toSessionInfo));
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [runtime]);
+  react.useEffect(() => {
+    fetchSessions();
+  }, [fetchSessions]);
+  react.useEffect(() => {
+    return runtime.onSessionChange(() => {
+      fetchSessions();
+    });
+  }, [runtime, fetchSessions]);
+  const refresh = react.useCallback(() => {
+    setLoading(true);
+    fetchSessions();
+  }, [fetchSessions]);
+  return { sessions, loading, error, refresh };
+}
+function defaultRenderText(part, index) {
+  return react.createElement("span", { key: index, "data-part": "text" }, part.text);
+}
+function defaultRenderReasoning(part, index) {
+  return react.createElement("span", { key: index, "data-part": "reasoning" }, part.text);
+}
+function defaultRenderToolCall(part, index) {
+  return react.createElement("span", { key: index, "data-part": "tool_call", "data-tool-name": part.name }, part.name);
+}
+function defaultRenderSource(part, index) {
+  return react.createElement("a", { key: index, href: part.url, "data-part": "source" }, part.title ?? part.url);
+}
+function defaultRenderFile(part, index) {
+  return react.createElement("span", { key: index, "data-part": "file" }, part.name);
+}
+function renderPart(props, part, index) {
+  switch (part.type) {
+    case "text":
+      return (props.renderText ?? defaultRenderText)(part, index);
+    case "reasoning":
+      return (props.renderReasoning ?? defaultRenderReasoning)(part, index);
+    case "tool_call":
+      return (props.renderToolCall ?? defaultRenderToolCall)(part, index);
+    case "source":
+      return (props.renderSource ?? defaultRenderSource)(part, index);
+    case "file":
+      return (props.renderFile ?? defaultRenderFile)(part, index);
+  }
+}
+function Message(props) {
+  const { message } = props;
+  const children = message.parts.map((part, i) => renderPart(props, part, i));
+  return react.createElement(
+    "div",
+    {
+      "data-role": message.role,
+      "data-status": message.status
+    },
+    ...children
+  );
+}
+function ThinkingBlock({ text, isStreaming, defaultOpen }) {
+  const attrs = {
+    "data-thinking": "true"
+  };
+  if (isStreaming) {
+    attrs["data-streaming"] = "true";
+  }
+  if (defaultOpen) {
+    attrs.open = true;
+  }
+  return react.createElement(
+    "details",
+    attrs,
+    react.createElement("summary", null, isStreaming ? "Thinking..." : "Reasoning"),
+    react.createElement("div", null, text)
+  );
+}
+function ToolCallView({ part, onApprove, onDeny, renderArgs, renderResult }) {
+  const children = [
+    react.createElement("span", { key: "name", "data-tool-label": "name" }, part.name),
+    react.createElement("span", { key: "status", "data-tool-label": "status" }, part.status)
+  ];
+  if (part.args !== void 0) {
+    children.push(
+      renderArgs ? renderArgs(part.args) : react.createElement("pre", { key: "args", "data-tool-label": "args" }, JSON.stringify(part.args, null, 2))
+    );
+  }
+  if (part.result !== void 0) {
+    children.push(
+      renderResult ? renderResult(part.result) : react.createElement("pre", { key: "result", "data-tool-label": "result" }, JSON.stringify(part.result, null, 2))
+    );
+  }
+  if (part.error) {
+    children.push(
+      react.createElement("span", { key: "error", "data-tool-label": "error", role: "alert" }, part.error)
+    );
+  }
+  if (part.status === "requires_approval") {
+    children.push(
+      react.createElement("button", { key: "approve", onClick: onApprove, "data-action": "approve" }, "Approve"),
+      react.createElement("button", { key: "deny", onClick: onDeny, "data-action": "deny" }, "Deny")
+    );
+  }
+  return react.createElement(
+    "div",
+    {
+      "data-tool-status": part.status,
+      "data-tool-name": part.name
+    },
+    ...children
+  );
+}
+function useToolApproval(messages, onApprove, onDeny) {
+  const pendingRequests = react.useMemo(() => {
+    const requests = [];
+    for (const msg of messages) {
+      for (const part of msg.parts) {
+        if (part.type === "tool_call" && part.status === "requires_approval") {
+          requests.push({
+            toolCallId: part.toolCallId,
+            toolName: part.name,
+            toolArgs: part.args ?? {},
+            messageId: msg.id
+          });
+        }
+      }
+    }
+    return requests;
+  }, [messages]);
+  const approve = react.useCallback((toolCallId) => {
+    onApprove?.(toolCallId);
+  }, [onApprove]);
+  const deny = react.useCallback((toolCallId) => {
+    onDeny?.(toolCallId);
+  }, [onDeny]);
+  return { pendingRequests, approve, deny };
+}
+function parseBlocks(text) {
+  const tokens = [];
+  const lines = text.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const fenceMatch = line.match(/^```(\w*)/);
+    if (fenceMatch) {
+      const language = fenceMatch[1] || void 0;
+      const codeLines = [];
+      i++;
+      while (i < lines.length && !lines[i].startsWith("```")) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      i++;
+      tokens.push({ type: "code_block", code: codeLines.join("\n"), language });
+      continue;
+    }
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      tokens.push({ type: "heading", level: headingMatch[1].length, content: headingMatch[2] });
+      i++;
+      continue;
+    }
+    if (line.startsWith("> ")) {
+      const quoteLines = [];
+      while (i < lines.length && lines[i].startsWith("> ")) {
+        quoteLines.push(lines[i].slice(2));
+        i++;
+      }
+      tokens.push({ type: "blockquote", content: quoteLines.join("\n") });
+      continue;
+    }
+    if (/^[-*]\s+/.test(line)) {
+      const items = [];
+      while (i < lines.length && /^[-*]\s+/.test(lines[i])) {
+        items.push(lines[i].replace(/^[-*]\s+/, ""));
+        i++;
+      }
+      tokens.push({ type: "list", ordered: false, items });
+      continue;
+    }
+    if (/^\d+\.\s+/.test(line)) {
+      const items = [];
+      while (i < lines.length && /^\d+\.\s+/.test(lines[i])) {
+        items.push(lines[i].replace(/^\d+\.\s+/, ""));
+        i++;
+      }
+      tokens.push({ type: "list", ordered: true, items });
+      continue;
+    }
+    if (line.trim() === "") {
+      i++;
+      continue;
+    }
+    const paraLines = [];
+    while (i < lines.length && lines[i].trim() !== "" && !lines[i].match(/^(#{1,6}\s|```|>\s|[-*]\s|\d+\.\s)/)) {
+      paraLines.push(lines[i]);
+      i++;
+    }
+    if (paraLines.length > 0) {
+      tokens.push({ type: "paragraph", content: paraLines.join("\n") });
+    }
+  }
+  return tokens;
+}
+function parseInline(text, props) {
+  const nodes = [];
+  const regex = /(`[^`]+`)|(\*\*[^*]+\*\*)|(\*[^*]+\*)|(_[^_]+_)|(\[[^\]]+\]\([^)]+\))/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    if (match.index > lastIndex) {
+      nodes.push(text.slice(lastIndex, match.index));
+    }
+    const fragment = match[0];
+    if (fragment.startsWith("`")) {
+      const code = fragment.slice(1, -1);
+      nodes.push(react.createElement("code", { key: `ic-${match.index}`, "data-md-inline-code": true }, code));
+    } else if (fragment.startsWith("**")) {
+      const content = fragment.slice(2, -2);
+      nodes.push(react.createElement("strong", { key: `b-${match.index}` }, content));
+    } else if (fragment.startsWith("*") || fragment.startsWith("_")) {
+      const content = fragment.slice(1, -1);
+      nodes.push(react.createElement("em", { key: `i-${match.index}` }, content));
+    } else if (fragment.startsWith("[")) {
+      const linkMatch = fragment.match(/\[([^\]]+)\]\(([^)]+)\)/);
+      if (linkMatch) {
+        nodes.push(
+          props?.renderLink ? props.renderLink(linkMatch[2], linkMatch[1]) : react.createElement("a", { key: `a-${match.index}`, href: linkMatch[2] }, linkMatch[1])
+        );
+      }
+    }
+    lastIndex = match.index + fragment.length;
+  }
+  if (lastIndex < text.length) {
+    nodes.push(text.slice(lastIndex));
+  }
+  return nodes;
+}
+function renderBlock(token, index, props) {
+  switch (token.type) {
+    case "heading":
+      return react.createElement(
+        `h${token.level}`,
+        { key: index, "data-md-heading": true },
+        ...parseInline(token.content, props)
+      );
+    case "paragraph":
+      return react.createElement(
+        "p",
+        { key: index, "data-md-paragraph": true },
+        ...parseInline(token.content, props)
+      );
+    case "code_block":
+      if (props.renderCode) {
+        return props.renderCode(token.code, token.language);
+      }
+      return react.createElement(
+        "pre",
+        { key: index, "data-md-code-block": true },
+        react.createElement(
+          "code",
+          { className: token.language ? `language-${token.language}` : void 0 },
+          token.code
+        )
+      );
+    case "blockquote":
+      return react.createElement(
+        "blockquote",
+        { key: index, "data-md-blockquote": true },
+        ...parseInline(token.content, props)
+      );
+    case "list": {
+      const tag = token.ordered ? "ol" : "ul";
+      const items = token.items.map(
+        (item, i) => react.createElement("li", { key: i }, ...parseInline(item, props))
+      );
+      return react.createElement(tag, { key: index, "data-md-list": true }, ...items);
+    }
+  }
+}
+function MarkdownRenderer(props) {
+  const tokens = parseBlocks(props.content);
+  const children = tokens.map((token, i) => renderBlock(token, i, props));
+  return react.createElement("div", { "data-md-root": true }, ...children);
+}
+var ThreadSlotsContext = react.createContext(null);
+function ThreadProvider({
+  children,
+  renderMessage,
+  renderToolCall,
+  renderThinkingBlock
+}) {
+  const value = { renderMessage, renderToolCall, renderThinkingBlock };
+  return react.createElement(ThreadSlotsContext.Provider, { value }, children);
+}
+function useThreadSlots() {
+  const ctx = react.useContext(ThreadSlotsContext);
+  if (!ctx) {
+    throw new Error("useThreadSlots must be used within a ThreadProvider");
+  }
+  return ctx;
+}
+function useOptionalThreadSlots() {
+  return react.useContext(ThreadSlotsContext);
+}
+
+// src/chat/react/Thread.ts
+function Thread({
+  messages,
+  isGenerating,
+  autoScroll = true,
+  className
+}) {
+  const sentinelRef = react.useRef(null);
+  const containerRef = react.useRef(null);
+  const [userScrolledUp, setUserScrolledUp] = react.useState(false);
+  const handleScroll = react.useCallback(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    const atBottom = el.scrollHeight - el.scrollTop - el.clientHeight < 1;
+    setUserScrolledUp(!atBottom);
+  }, []);
+  react.useEffect(() => {
+    if (!autoScroll || userScrolledUp) return;
+    sentinelRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [messages, autoScroll, userScrolledUp]);
+  const slots = useOptionalThreadSlots();
+  const attrs = { "data-thread": "true", className };
+  if (isGenerating) {
+    attrs["data-thread-loading"] = "true";
+  }
+  attrs.ref = containerRef;
+  attrs.onScroll = handleScroll;
+  const children = messages.map((msg, i) => {
+    const content = slots?.renderMessage ? slots.renderMessage(msg, i) : react.createElement(Message, {
+      key: msg.id,
+      message: msg,
+      renderToolCall: slots?.renderToolCall,
+      renderReasoning: slots?.renderThinkingBlock ? (part, idx) => slots.renderThinkingBlock(part, idx) : void 0
+    });
+    return react.createElement(
+      "div",
+      { key: msg.id, "data-thread-message": "true", "data-role": msg.role },
+      content
+    );
+  });
+  children.push(react.createElement("div", { key: "__sentinel", ref: sentinelRef }));
+  return react.createElement("div", attrs, ...children);
+}
+function Composer({
+  onSend,
+  onStop,
+  isGenerating,
+  disabled,
+  placeholder = "Type a message...",
+  maxRows = 5,
+  className
+}) {
+  const textareaRef = react.useRef(null);
+  const [value, setValue] = react.useState("");
+  const resize = react.useCallback(() => {
+    const el = textareaRef.current;
+    if (!el) return;
+    el.style.height = "auto";
+    const lineHeight = parseInt(getComputedStyle(el).lineHeight) || 20;
+    const maxHeight = lineHeight * maxRows;
+    el.style.height = `${Math.min(el.scrollHeight, maxHeight)}px`;
+  }, [maxRows]);
+  react.useEffect(() => {
+    resize();
+  }, [value, resize]);
+  const handleSend = react.useCallback(() => {
+    const trimmed = value.trim();
+    if (!trimmed || isGenerating) return;
+    onSend(trimmed);
+    setValue("");
+  }, [value, isGenerating, onSend]);
+  const handleKeyDown = react.useCallback(
+    (e) => {
+      if (e.key === "Enter" && !e.shiftKey) {
+        e.preventDefault();
+        handleSend();
+      }
+    },
+    [handleSend]
+  );
+  const handleChange = react.useCallback(
+    (e) => {
+      setValue(e.target.value);
+    },
+    []
+  );
+  const children = [
+    react.createElement("textarea", {
+      key: "textarea",
+      ref: textareaRef,
+      value,
+      onChange: handleChange,
+      onKeyDown: handleKeyDown,
+      placeholder,
+      disabled: disabled || false,
+      "aria-label": "Message input",
+      rows: 1
+    })
+  ];
+  if (isGenerating) {
+    children.push(
+      react.createElement(
+        "button",
+        {
+          key: "stop",
+          "data-action": "stop",
+          onClick: onStop,
+          type: "button"
+        },
+        "Stop"
+      )
+    );
+  } else {
+    children.push(
+      react.createElement(
+        "button",
+        {
+          key: "send",
+          "data-action": "send",
+          onClick: handleSend,
+          disabled: !value.trim() || isGenerating,
+          type: "button"
+        },
+        "Send"
+      )
+    );
+  }
+  return react.createElement(
+    "div",
+    { "data-composer": "true", className },
+    ...children
+  );
+}
+function isFullSession(item) {
+  return "messages" in item && Array.isArray(item.messages);
+}
+function normalizeSession(item) {
+  if (isFullSession(item)) {
+    return {
+      id: item.id,
+      title: item.title,
+      status: item.status,
+      messageCount: item.metadata?.messageCount ?? item.messages.length,
+      lastMessage: item.messages[item.messages.length - 1],
+      createdAt: item.createdAt,
+      updatedAt: item.updatedAt
+    };
+  }
+  return item;
+}
+function ThreadList({
+  sessions,
+  activeSessionId,
+  onSelect,
+  onCreate,
+  onDelete,
+  searchQuery,
+  onSearchChange,
+  className
+}) {
+  const handleSearchChange = react.useCallback(
+    (e) => {
+      onSearchChange?.(e.target.value);
+    },
+    [onSearchChange]
+  );
+  const normalized = react.useMemo(() => sessions.map(normalizeSession), [sessions]);
+  const filtered = react.useMemo(() => {
+    if (!searchQuery) return normalized;
+    const q = searchQuery.toLowerCase();
+    return normalized.filter((s) => (s.title ?? "").toLowerCase().includes(q));
+  }, [normalized, searchQuery]);
+  const children = [];
+  children.push(
+    react.createElement("input", {
+      key: "search",
+      "data-thread-list-search": "true",
+      value: searchQuery ?? "",
+      onChange: handleSearchChange,
+      placeholder: "Search sessions..."
+    })
+  );
+  children.push(
+    react.createElement(
+      "button",
+      {
+        key: "create",
+        "data-action": "create-session",
+        onClick: onCreate,
+        type: "button"
+      },
+      "New"
+    )
+  );
+  const items = filtered.map((session) => {
+    const isActive = session.id === activeSessionId;
+    const itemChildren = [
+      react.createElement("span", { key: "title" }, session.title ?? "Untitled")
+    ];
+    if (onDelete) {
+      itemChildren.push(
+        react.createElement(
+          "button",
+          {
+            key: "delete",
+            "data-action": "delete-session",
+            onClick: (e) => {
+              e.stopPropagation();
+              onDelete(session.id);
+            },
+            type: "button"
+          },
+          "Delete"
+        )
+      );
+    }
+    return react.createElement(
+      "div",
+      {
+        key: session.id,
+        "data-session-item": "true",
+        "data-session-active": isActive ? "true" : "false",
+        onClick: () => onSelect(session.id)
+      },
+      ...itemChildren
+    );
+  });
+  children.push(
+    react.createElement(
+      "div",
+      { key: "items", "data-thread-list-items": "true" },
+      ...items
+    )
+  );
+  return react.createElement(
+    "div",
+    { "data-thread-list": "true", className },
+    ...children
+  );
+}
+function useSSE(url, options = {}) {
+  const [status, setStatus] = react.useState(url === null ? "idle" : "idle");
+  const [lastEvent, setLastEvent] = react.useState(null);
+  const abortRef = react.useRef(null);
+  const reconnectTimerRef = react.useRef(null);
+  const optionsRef = react.useRef(options);
+  optionsRef.current = options;
+  const disconnect = react.useCallback(() => {
+    if (reconnectTimerRef.current !== null) {
+      clearTimeout(reconnectTimerRef.current);
+      reconnectTimerRef.current = null;
+    }
+    if (abortRef.current) {
+      abortRef.current.abort();
+      abortRef.current = null;
+    }
+    setStatus("closed");
+  }, []);
+  const connect = react.useCallback(() => {
+    if (!url) return;
+    if (reconnectTimerRef.current !== null) {
+      clearTimeout(reconnectTimerRef.current);
+      reconnectTimerRef.current = null;
+    }
+    if (abortRef.current) {
+      abortRef.current.abort();
+    }
+    const controller = new AbortController();
+    abortRef.current = controller;
+    setStatus("connecting");
+    (async () => {
+      try {
+        const response = await fetch(url, {
+          headers: {
+            Accept: "text/event-stream",
+            ...optionsRef.current.headers
+          },
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          throw new Error(`SSE request failed: ${response.status}`);
+        }
+        if (!response.body) {
+          throw new Error("SSE response has no body");
+        }
+        setStatus("open");
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let dataLines = [];
+        const dispatchEvent = () => {
+          if (dataLines.length === 0) return;
+          const data = dataLines.join("\n");
+          dataLines = [];
+          try {
+            const parsed = JSON.parse(data);
+            setLastEvent(parsed);
+            optionsRef.current.onEvent?.(parsed);
+          } catch {
+          }
+        };
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop();
+          for (const line of lines) {
+            if (line === "") {
+              dispatchEvent();
+            } else if (line.startsWith("data:")) {
+              dataLines.push(line.slice(5).trimStart());
+            } else if (line.startsWith("event:")) {
+            }
+          }
+        }
+        if (dataLines.length > 0) {
+          dispatchEvent();
+        }
+        if (!controller.signal.aborted) {
+          setStatus("closed");
+        }
+      } catch (err) {
+        if (controller.signal.aborted) return;
+        const error = err instanceof Error ? err : new Error(String(err));
+        setStatus("error");
+        optionsRef.current.onError?.(error);
+        if (optionsRef.current.reconnect && !controller.signal.aborted) {
+          const delay = optionsRef.current.reconnectInterval ?? 3e3;
+          reconnectTimerRef.current = setTimeout(() => {
+            if (abortRef.current && !abortRef.current.signal.aborted) {
+              connect();
+            }
+          }, delay);
+        }
+      }
+    })();
+  }, [url]);
+  react.useEffect(() => {
+    return () => {
+      if (reconnectTimerRef.current !== null) {
+        clearTimeout(reconnectTimerRef.current);
+        reconnectTimerRef.current = null;
+      }
+      if (abortRef.current) {
+        abortRef.current.abort();
+        abortRef.current = null;
+      }
+    };
+  }, []);
+  return { status, connect, disconnect, lastEvent };
+}
+function useModels() {
+  const runtime = useChatRuntime();
+  const [models, setModels] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const mountedRef = react.useRef(true);
+  const fetchModels = react.useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await runtime.listModels();
+      if (!mountedRef.current) return;
+      const mapped = result.map((m) => ({
+        id: m.id,
+        name: m.name ?? m.id,
+        tier: m.provider
+      }));
+      setModels(mapped);
+    } catch (err) {
+      if (!mountedRef.current) return;
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      if (mountedRef.current) {
+        setIsLoading(false);
+      }
+    }
+  }, [runtime]);
+  react.useEffect(() => {
+    mountedRef.current = true;
+    fetchModels();
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [fetchModels]);
+  const search = react.useCallback(
+    (query) => {
+      const q = query.toLowerCase();
+      return models.filter((m) => m.name.toLowerCase().includes(q));
+    },
+    [models]
+  );
+  return { models, isLoading, error, refresh: fetchModels, search };
+}
+function ModelSelector({
+  models,
+  selectedModel,
+  onSelect,
+  placeholder = "Select model",
+  className
+}) {
+  const [open, setOpen] = react.useState(false);
+  const [search, setSearch] = react.useState("");
+  const [highlightIndex, setHighlightIndex] = react.useState(0);
+  const containerRef = react.useRef(null);
+  const filtered = react.useMemo(() => {
+    if (!search) return models;
+    const q = search.toLowerCase();
+    return models.filter((m) => m.name.toLowerCase().includes(q));
+  }, [models, search]);
+  react.useEffect(() => {
+    setHighlightIndex(0);
+  }, [filtered.length]);
+  const selectedInfo = react.useMemo(
+    () => models.find((m) => m.id === selectedModel),
+    [models, selectedModel]
+  );
+  const handleToggle = react.useCallback(() => {
+    setOpen((prev) => {
+      if (!prev) {
+        setSearch("");
+        setHighlightIndex(0);
+      }
+      return !prev;
+    });
+  }, []);
+  const handleSelect = react.useCallback(
+    (modelId) => {
+      onSelect(modelId);
+      setOpen(false);
+      setSearch("");
+    },
+    [onSelect]
+  );
+  const handleSearchChange = react.useCallback((e) => {
+    setSearch(e.target.value);
+  }, []);
+  const handleKeyDown = react.useCallback(
+    (e) => {
+      if (e.key === "ArrowDown") {
+        e.preventDefault();
+        setHighlightIndex((prev) => Math.min(prev + 1, filtered.length - 1));
+      } else if (e.key === "ArrowUp") {
+        e.preventDefault();
+        setHighlightIndex((prev) => Math.max(prev - 1, 0));
+      } else if (e.key === "Enter") {
+        e.preventDefault();
+        if (filtered[highlightIndex]) {
+          handleSelect(filtered[highlightIndex].id);
+        }
+      } else if (e.key === "Escape") {
+        e.preventDefault();
+        setOpen(false);
+      }
+    },
+    [filtered, highlightIndex, handleSelect]
+  );
+  const children = [];
+  children.push(
+    react.createElement(
+      "button",
+      {
+        key: "trigger",
+        "data-model-selector-trigger": "true",
+        onClick: handleToggle,
+        type: "button"
+      },
+      selectedInfo ? selectedInfo.name : placeholder
+    )
+  );
+  if (open) {
+    const dropdownChildren = [];
+    dropdownChildren.push(
+      react.createElement("input", {
+        key: "search",
+        "data-model-selector-search": "true",
+        value: search,
+        onChange: handleSearchChange,
+        onKeyDown: handleKeyDown,
+        placeholder: "Search models...",
+        autoFocus: true
+      })
+    );
+    filtered.forEach((model, idx) => {
+      const isSelected = model.id === selectedModel;
+      const isHighlighted = idx === highlightIndex;
+      const attrs = {
+        key: model.id,
+        "data-model-option": "true",
+        onClick: () => handleSelect(model.id)
+      };
+      if (model.tier) {
+        attrs["data-tier"] = model.tier;
+      }
+      if (isSelected) {
+        attrs["data-model-selected"] = "true";
+      }
+      if (isHighlighted) {
+        attrs["data-model-highlighted"] = "true";
+      }
+      dropdownChildren.push(react.createElement("div", attrs, model.name));
+    });
+    children.push(
+      react.createElement(
+        "div",
+        { key: "dropdown", "data-model-selector-dropdown": "true" },
+        ...dropdownChildren
+      )
+    );
+  }
+  return react.createElement(
+    "div",
+    {
+      "data-model-selector": "true",
+      className,
+      ref: containerRef
+    },
+    ...children
+  );
+}
+var _authLoaders = {
+  async loadCopilotAuth() {
+    const { CopilotAuth: CopilotAuth2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+    return CopilotAuth2;
+  },
+  async loadClaudeAuth() {
+    const { ClaudeAuth: ClaudeAuth2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+    return ClaudeAuth2;
+  }
+};
+function useAuth(options) {
+  const { backend, onAuthenticated } = options;
+  const [status, setStatus] = react.useState("idle");
+  const [error, setError] = react.useState(null);
+  const [token, setToken] = react.useState(null);
+  const [deviceCode, setDeviceCode] = react.useState(null);
+  const [verificationUrl, setVerificationUrl] = react.useState(null);
+  const [authorizeUrl, setAuthorizeUrl] = react.useState(null);
+  const onAuthenticatedRef = react.useRef(onAuthenticated);
+  onAuthenticatedRef.current = onAuthenticated;
+  const completeAuthRef = react.useRef(null);
+  const startDeviceFlow = react.useCallback(async () => {
+    if (backend !== "copilot") return;
+    setStatus("pending");
+    setError(null);
+    try {
+      const CopilotAuth2 = await _authLoaders.loadCopilotAuth();
+      const auth = new CopilotAuth2();
+      const result = await auth.startDeviceFlow();
+      setDeviceCode(result.userCode);
+      setVerificationUrl(result.verificationUrl);
+      const authToken = await result.waitForToken();
+      setToken(authToken);
+      setStatus("authenticated");
+      onAuthenticatedRef.current?.(authToken);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setStatus("error");
+    }
+  }, [backend]);
+  const startOAuthFlow = react.useCallback(async () => {
+    if (backend !== "claude") return;
+    setStatus("pending");
+    setError(null);
+    try {
+      const ClaudeAuth2 = await _authLoaders.loadClaudeAuth();
+      const auth = new ClaudeAuth2();
+      const result = auth.startOAuthFlow();
+      setAuthorizeUrl(result.authorizeUrl);
+      completeAuthRef.current = result.completeAuth;
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setStatus("error");
+    }
+  }, [backend]);
+  const completeOAuth = react.useCallback(async (codeOrUrl) => {
+    if (!completeAuthRef.current) return;
+    try {
+      const authToken = await completeAuthRef.current(codeOrUrl);
+      setToken(authToken);
+      setStatus("authenticated");
+      onAuthenticatedRef.current?.(authToken);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setStatus("error");
+    }
+  }, []);
+  const submitApiKey = react.useCallback((key) => {
+    if (backend !== "api-key") return;
+    if (!key || !key.trim()) {
+      setError(new Error("API key cannot be empty"));
+      setStatus("error");
+      return;
+    }
+    const authToken = {
+      accessToken: key.trim(),
+      tokenType: "bearer",
+      obtainedAt: Date.now()
+    };
+    setToken(authToken);
+    setStatus("authenticated");
+    onAuthenticatedRef.current?.(authToken);
+  }, [backend]);
+  const reset = react.useCallback(() => {
+    setStatus("idle");
+    setError(null);
+    setToken(null);
+    setDeviceCode(null);
+    setVerificationUrl(null);
+    setAuthorizeUrl(null);
+    completeAuthRef.current = null;
+  }, []);
+  return {
+    status,
+    error,
+    startDeviceFlow,
+    deviceCode,
+    verificationUrl,
+    startOAuthFlow,
+    authorizeUrl,
+    completeOAuth,
+    submitApiKey,
+    token,
+    reset
+  };
+}
+function useRemoteAuth(options) {
+  const { backend, baseUrl, onAuthenticated, headers } = options;
+  const fetchFn = options.fetch ?? globalThis.fetch.bind(globalThis);
+  const [status, setStatus] = react.useState("idle");
+  const [error, setError] = react.useState(null);
+  const [token, setToken] = react.useState(null);
+  const [deviceCode, setDeviceCode] = react.useState(null);
+  const [verificationUrl, setVerificationUrl] = react.useState(null);
+  const [authorizeUrl, setAuthorizeUrl] = react.useState(null);
+  const [savedProviders, setSavedProviders] = react.useState([]);
+  const onAuthenticatedRef = react.useRef(onAuthenticated);
+  onAuthenticatedRef.current = onAuthenticated;
+  const post = react.useCallback(
+    async (path, body) => {
+      const res = await fetchFn(`${baseUrl}${path}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...headers },
+        body: body ? JSON.stringify(body) : void 0
+      });
+      const data = await res.json();
+      if (!res.ok) throw new Error(data.error || `HTTP ${res.status}`);
+      return data;
+    },
+    [baseUrl, fetchFn, headers]
+  );
+  const get = react.useCallback(
+    async (path) => {
+      const res = await fetchFn(`${baseUrl}${path}`, {
+        method: "GET",
+        headers: { ...headers }
+      });
+      const data = await res.json();
+      if (!res.ok) throw new Error(data.error || `HTTP ${res.status}`);
+      return data;
+    },
+    [baseUrl, fetchFn, headers]
+  );
+  const startDeviceFlow = react.useCallback(async () => {
+    if (backend !== "copilot") return;
+    setStatus("pending");
+    setError(null);
+    try {
+      const result = await post("/auth/start", { provider: "copilot" });
+      setDeviceCode(result.userCode);
+      setVerificationUrl(result.verificationUrl);
+      await post("/auth/copilot/poll");
+      const authToken = {
+        accessToken: "server-managed",
+        tokenType: "bearer",
+        obtainedAt: Date.now()
+      };
+      setToken(authToken);
+      setStatus("authenticated");
+      onAuthenticatedRef.current?.(authToken);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setStatus("error");
+    }
+  }, [backend, post]);
+  const startOAuthFlow = react.useCallback(async () => {
+    if (backend !== "claude") return;
+    setStatus("pending");
+    setError(null);
+    try {
+      const result = await post("/auth/start", { provider: "claude" });
+      setAuthorizeUrl(result.authorizeUrl);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setStatus("error");
+    }
+  }, [backend, post]);
+  const completeOAuth = react.useCallback(
+    async (codeOrUrl) => {
+      try {
+        await post("/auth/claude/complete", { code: codeOrUrl });
+        const authToken = {
+          accessToken: "server-managed",
+          tokenType: "bearer",
+          obtainedAt: Date.now()
+        };
+        setToken(authToken);
+        setStatus("authenticated");
+        onAuthenticatedRef.current?.(authToken);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setStatus("error");
+      }
+    },
+    [post]
+  );
+  const submitApiKey = react.useCallback(
+    async (key, apiBaseUrl) => {
+      if (backend !== "vercel-ai") return;
+      if (!key || !key.trim()) {
+        setError(new Error("API key cannot be empty"));
+        setStatus("error");
+        return;
+      }
+      try {
+        await post("/auth/vercel/complete", {
+          apiKey: key.trim(),
+          ...apiBaseUrl ? { baseUrl: apiBaseUrl } : {}
+        });
+        const authToken = {
+          accessToken: "server-managed",
+          tokenType: "bearer",
+          obtainedAt: Date.now()
+        };
+        setToken(authToken);
+        setStatus("authenticated");
+        onAuthenticatedRef.current?.(authToken);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setStatus("error");
+      }
+    },
+    [backend, post]
+  );
+  const loadSavedTokens = react.useCallback(async () => {
+    try {
+      const data = await get("/tokens/saved");
+      setSavedProviders(data.saved || []);
+    } catch {
+    }
+  }, [get]);
+  const useSavedToken = react.useCallback(
+    async (provider) => {
+      try {
+        await post("/tokens/use", { provider });
+        const authToken = {
+          accessToken: "server-managed",
+          tokenType: "bearer",
+          obtainedAt: Date.now()
+        };
+        setToken(authToken);
+        setStatus("authenticated");
+        onAuthenticatedRef.current?.(authToken);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setStatus("error");
+      }
+    },
+    [post]
+  );
+  const clearTokens = react.useCallback(async () => {
+    try {
+      await post("/tokens/clear");
+      setSavedProviders([]);
+    } catch {
+    }
+  }, [post]);
+  const reset = react.useCallback(() => {
+    setStatus("idle");
+    setError(null);
+    setToken(null);
+    setDeviceCode(null);
+    setVerificationUrl(null);
+    setAuthorizeUrl(null);
+    setSavedProviders([]);
+  }, []);
+  const start = react.useCallback(async (provider) => {
+    const target = provider ?? backend;
+    setStatus("pending");
+    setError(null);
+    try {
+      switch (target) {
+        case "copilot": {
+          const result = await post("/auth/start", { provider: "copilot" });
+          setDeviceCode(result.userCode);
+          setVerificationUrl(result.verificationUrl);
+          await post("/auth/copilot/poll");
+          const authToken = {
+            accessToken: "server-managed",
+            tokenType: "bearer",
+            obtainedAt: Date.now()
+          };
+          setToken(authToken);
+          setStatus("authenticated");
+          onAuthenticatedRef.current?.(authToken);
+          break;
+        }
+        case "claude": {
+          const result = await post("/auth/start", { provider: "claude" });
+          setAuthorizeUrl(result.authorizeUrl);
+          break;
+        }
+        case "vercel-ai":
+          throw new Error("vercel-ai requires submitApiKey(key, baseUrl) \u2014 cannot auto-start");
+        default:
+          throw new Error(`Unknown auth provider: ${target}`);
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setStatus("error");
+    }
+  }, [backend, post]);
+  return {
+    status,
+    error,
+    startDeviceFlow,
+    deviceCode,
+    verificationUrl,
+    startOAuthFlow,
+    authorizeUrl,
+    completeOAuth,
+    submitApiKey,
+    start,
+    token,
+    reset,
+    savedProviders,
+    loadSavedTokens,
+    useSavedToken,
+    clearTokens
+  };
+}
+
+// src/chat/react/RemoteChatRuntime.ts
+var RemoteChatRuntime = class {
+  _status = "idle";
+  _activeSessionId = null;
+  _currentBackend = "default";
+  _currentModel;
+  _abortController = null;
+  _tools = /* @__PURE__ */ new Map();
+  _middlewares = [];
+  baseUrl;
+  headers;
+  _fetch;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.headers = options.headers ?? {};
+    this._fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  // ─── Lifecycle ──────────────────────────────────────────────
+  get status() {
+    return this._status;
+  }
+  async dispose() {
+    this.abort();
+    this._status = "disposed";
+  }
+  assertNotDisposed() {
+    if (this._status === "disposed") {
+      throw new Error("Runtime is disposed");
+    }
+  }
+  // ─── Sessions ───────────────────────────────────────────────
+  get activeSessionId() {
+    return this._activeSessionId;
+  }
+  async createSession(options) {
+    this.assertNotDisposed();
+    const res = await this._post("/sessions/create", options);
+    const session = await res.json();
+    this._activeSessionId = session.id;
+    this._notifySessionChange();
+    return session;
+  }
+  async getSession(id) {
+    this.assertNotDisposed();
+    const res = await this._get(`/sessions/${id}`);
+    if (res.status === 404) return null;
+    return await res.json();
+  }
+  async listSessions(_options) {
+    this.assertNotDisposed();
+    const res = await this._get("/sessions");
+    return await res.json();
+  }
+  async deleteSession(id) {
+    this.assertNotDisposed();
+    await this._delete(`/sessions/${id}`);
+    if (this._activeSessionId === id) {
+      this._activeSessionId = null;
+    }
+    this._notifySessionChange();
+  }
+  async archiveSession(id) {
+    this.assertNotDisposed();
+    await this._post(`/sessions/${id}/archive`, {});
+    this._notifySessionChange();
+  }
+  async switchSession(id) {
+    this.assertNotDisposed();
+    const session = await this.getSession(id);
+    if (!session) throw new Error(`Session not found: ${id}`);
+    this._activeSessionId = session.id;
+    return session;
+  }
+  // ─── Messaging ──────────────────────────────────────────────
+  async *send(sessionId, message, options) {
+    this.assertNotDisposed();
+    this._status = "streaming";
+    this._abortController = new AbortController();
+    try {
+      const res = await this._fetch(`${this.baseUrl}/send`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "text/event-stream",
+          ...this.headers
+        },
+        body: JSON.stringify({
+          sessionId,
+          message,
+          model: options?.model
+        }),
+        signal: this._abortController.signal
+      });
+      if (!res.ok) {
+        throw new Error(`Send failed: ${res.status} ${res.statusText}`);
+      }
+      if (!res.body) {
+        throw new Error("No response body for SSE stream");
+      }
+      yield* this._parseSSEStream(res.body, this._abortController.signal);
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "AbortError") ; else {
+        this._status = "error";
+        throw err;
+      }
+    } finally {
+      this._abortController = null;
+      if (this._status === "streaming") {
+        this._status = "idle";
+      }
+      this._notifySessionChange();
+    }
+  }
+  abort() {
+    if (this._abortController) {
+      this._abortController.abort();
+      this._abortController = null;
+    }
+    if (this._status === "streaming") {
+      this._status = "idle";
+    }
+    this._post("/abort", {}).catch(() => {
+    });
+  }
+  // ─── Backend / Model ────────────────────────────────────────
+  get currentBackend() {
+    return this._currentBackend;
+  }
+  get currentModel() {
+    return this._currentModel;
+  }
+  async switchBackend(name) {
+    this.assertNotDisposed();
+    await this._post("/backend/switch", { backend: name });
+    this._currentBackend = name;
+  }
+  switchModel(model) {
+    this._currentModel = model;
+    this._post("/model/switch", { model }).catch(() => {
+    });
+  }
+  async listModels() {
+    this.assertNotDisposed();
+    const res = await this._get("/models");
+    return await res.json();
+  }
+  // ─── Tools (client-side registry) ───────────────────────────
+  get registeredTools() {
+    return this._tools;
+  }
+  registerTool(tool) {
+    this._tools.set(tool.name, tool);
+  }
+  removeTool(name) {
+    this._tools.delete(name);
+  }
+  // ─── Middleware (client-side) ───────────────────────────────
+  use(middleware) {
+    this._middlewares.push(middleware);
+  }
+  removeMiddleware(middleware) {
+    const idx = this._middlewares.indexOf(middleware);
+    if (idx !== -1) this._middlewares.splice(idx, 1);
+  }
+  // ─── Context ────────────────────────────────────────────────
+  getContextStats(_sessionId) {
+    return null;
+  }
+  _sessionListeners = /* @__PURE__ */ new Set();
+  onSessionChange(callback) {
+    this._sessionListeners.add(callback);
+    return () => {
+      this._sessionListeners.delete(callback);
+    };
+  }
+  _notifySessionChange() {
+    for (const cb of this._sessionListeners) {
+      try {
+        cb();
+      } catch {
+      }
+    }
+  }
+  // ─── Internal HTTP helpers ──────────────────────────────────
+  async _get(path) {
+    const res = await this._fetch(`${this.baseUrl}${path}`, {
+      method: "GET",
+      headers: { ...this.headers }
+    });
+    if (!res.ok && res.status !== 404) {
+      throw new Error(`GET ${path} failed: ${res.status} ${res.statusText}`);
+    }
+    return res;
+  }
+  async _post(path, body) {
+    const res = await this._fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.headers
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      throw new Error(`POST ${path} failed: ${res.status} ${res.statusText}`);
+    }
+    return res;
+  }
+  async _delete(path) {
+    const res = await this._fetch(`${this.baseUrl}${path}`, {
+      method: "DELETE",
+      headers: { ...this.headers }
+    });
+    if (!res.ok) {
+      throw new Error(`DELETE ${path} failed: ${res.status} ${res.statusText}`);
+    }
+    return res;
+  }
+  // ─── SSE Parser ─────────────────────────────────────────────
+  async *_parseSSEStream(body, signal) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const abortPromise = new Promise((_, reject) => {
+      if (signal.aborted) {
+        reject(new DOMException("Aborted", "AbortError"));
+        return;
+      }
+      signal.addEventListener("abort", () => {
+        reject(new DOMException("Aborted", "AbortError"));
+      }, { once: true });
+    });
+    try {
+      while (true) {
+        if (signal.aborted) break;
+        const { done, value } = await Promise.race([
+          reader.read(),
+          abortPromise
+        ]);
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop();
+        for (const line of lines) {
+          if (signal.aborted) return;
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6).trim();
+            if (data === "[DONE]") return;
+            try {
+              yield JSON.parse(data);
+            } catch {
+            }
+          }
+        }
+      }
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "AbortError") ; else {
+        throw err;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+};
+
+// src/chat/react/useRemoteChat.ts
+function useRemoteChat(options) {
+  const {
+    chatBaseUrl,
+    authBaseUrl,
+    backend,
+    onReady,
+    headers,
+    autoRestore = true
+  } = options;
+  const fetchFn = options.fetch ?? globalThis.fetch.bind(globalThis);
+  const [phase, setPhase] = react.useState("initializing");
+  const [runtime, setRuntime] = react.useState(null);
+  const [sessionId, setSessionId] = react.useState(null);
+  const [error, setError] = react.useState(null);
+  const onReadyRef = react.useRef(onReady);
+  onReadyRef.current = onReady;
+  const mountedRef = react.useRef(true);
+  react.useEffect(() => {
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const auth = useRemoteAuth({
+    backend,
+    baseUrl: authBaseUrl,
+    fetch: fetchFn,
+    headers
+  });
+  const restoredRef = react.useRef(false);
+  const [tokensLoaded, setTokensLoaded] = react.useState(false);
+  react.useEffect(() => {
+    if (!autoRestore || restoredRef.current) return;
+    restoredRef.current = true;
+    (async () => {
+      try {
+        await auth.loadSavedTokens();
+      } catch {
+      }
+      if (mountedRef.current) setTokensLoaded(true);
+    })();
+  }, [autoRestore]);
+  react.useEffect(() => {
+    if (!tokensLoaded) return;
+    if (auth.status === "idle" && auth.savedProviders.includes(backend) && phase === "initializing") {
+      auth.useSavedToken(backend).catch(() => {
+        if (mountedRef.current) setPhase("unauthenticated");
+      });
+    } else if (auth.status === "idle" && !auth.savedProviders.includes(backend) && phase === "initializing") {
+      setPhase("unauthenticated");
+    }
+  }, [tokensLoaded, auth.status, auth.savedProviders, backend, phase]);
+  react.useEffect(() => {
+    if (auth.status === "pending") {
+      setPhase("authenticating");
+    } else if (auth.status === "error" && auth.error) {
+      setError(auth.error);
+      setPhase("error");
+    }
+  }, [auth.status, auth.error]);
+  const creatingRef = react.useRef(false);
+  react.useEffect(() => {
+    if (auth.status !== "authenticated" || creatingRef.current || runtime !== null) return;
+    creatingRef.current = true;
+    setPhase("creating");
+    setError(null);
+    (async () => {
+      try {
+        const rt = new RemoteChatRuntime({
+          baseUrl: chatBaseUrl,
+          headers,
+          fetch: fetchFn
+        });
+        const session = await rt.createSession({});
+        if (!mountedRef.current) return;
+        setRuntime(rt);
+        setSessionId(session.id);
+        setPhase("ready");
+        onReadyRef.current?.();
+      } catch (err) {
+        if (!mountedRef.current) return;
+        creatingRef.current = false;
+        setError(err instanceof Error ? err : new Error(String(err)));
+        setPhase("error");
+      }
+    })();
+  }, [auth.status, chatBaseUrl]);
+  const newSession = react.useCallback(async () => {
+    if (!runtime) throw new Error("Runtime not ready");
+    const session = await runtime.createSession({});
+    setSessionId(session.id);
+    return session.id;
+  }, [runtime]);
+  const logout = react.useCallback(async () => {
+    try {
+      await auth.clearTokens();
+    } catch {
+    }
+    if (runtime) {
+      try {
+        runtime.dispose();
+      } catch {
+      }
+    }
+    auth.reset();
+    setRuntime(null);
+    setSessionId(null);
+    setError(null);
+    setTokensLoaded(false);
+    creatingRef.current = false;
+    restoredRef.current = false;
+    setPhase("unauthenticated");
+  }, [auth.clearTokens, auth.reset, runtime]);
+  return {
+    phase,
+    runtime,
+    sessionId,
+    auth,
+    error,
+    newSession,
+    logout
+  };
+}
+function AuthDialog({
+  backends,
+  selectedBackend: controlledBackend,
+  onBackendChange,
+  onAuthenticated,
+  renderCopilotFlow,
+  renderClaudeFlow,
+  renderApiKeyFlow,
+  className
+}) {
+  const [internalBackend, setInternalBackend] = react.useState(
+    controlledBackend ?? backends[0] ?? "copilot"
+  );
+  const activeBackend = controlledBackend ?? internalBackend;
+  const handleBackendChange = react.useCallback(
+    (backend) => {
+      setInternalBackend(backend);
+      onBackendChange?.(backend);
+    },
+    [onBackendChange]
+  );
+  const auth = useAuth({ backend: activeBackend, onAuthenticated });
+  const children = [];
+  const selectorButtons = backends.map(
+    (backend) => react.createElement(
+      "button",
+      {
+        key: backend,
+        type: "button",
+        "data-auth-backend": backend,
+        "data-auth-selected": String(backend === activeBackend),
+        onClick: () => handleBackendChange(backend)
+      },
+      backend
+    )
+  );
+  children.push(
+    react.createElement(
+      "div",
+      { key: "selector", "data-auth-selector": "true" },
+      ...selectorButtons
+    )
+  );
+  const contentAttrs = {
+    key: "content",
+    "data-auth-content": "true",
+    "data-auth-status": auth.status
+  };
+  if (auth.error) {
+    contentAttrs["data-auth-error"] = auth.error.message;
+  }
+  let flowContent = null;
+  if (activeBackend === "copilot") {
+    if (renderCopilotFlow && auth.deviceCode && auth.verificationUrl) {
+      flowContent = renderCopilotFlow({
+        deviceCode: auth.deviceCode,
+        verificationUrl: auth.verificationUrl,
+        status: auth.status
+      });
+    } else {
+      const copilotChildren = [];
+      if (auth.status === "idle") {
+        copilotChildren.push(
+          react.createElement(
+            "button",
+            {
+              key: "start",
+              type: "button",
+              "data-action": "start-device-flow",
+              onClick: auth.startDeviceFlow
+            },
+            "Start Device Flow"
+          )
+        );
+      }
+      if (auth.deviceCode && auth.verificationUrl) {
+        copilotChildren.push(
+          react.createElement("span", { key: "code", "data-device-code": "true" }, auth.deviceCode)
+        );
+        copilotChildren.push(
+          react.createElement("a", { key: "url", "data-verification-url": "true", href: auth.verificationUrl }, auth.verificationUrl)
+        );
+      }
+      if (auth.status === "pending") {
+        copilotChildren.push(
+          react.createElement("span", { key: "loading", "data-auth-loading": "true" }, "Waiting...")
+        );
+      }
+      flowContent = react.createElement(
+        "div",
+        { "data-auth-flow": "copilot" },
+        ...copilotChildren
+      );
+    }
+  } else if (activeBackend === "claude") {
+    if (renderClaudeFlow) {
+      flowContent = renderClaudeFlow({
+        authorizeUrl: auth.authorizeUrl,
+        status: auth.status,
+        completeOAuth: auth.completeOAuth
+      });
+    } else {
+      const claudeChildren = [];
+      if (auth.status === "idle") {
+        claudeChildren.push(
+          react.createElement(
+            "button",
+            {
+              key: "start",
+              type: "button",
+              "data-action": "start-oauth-flow",
+              onClick: auth.startOAuthFlow
+            },
+            "Start OAuth Flow"
+          )
+        );
+      }
+      if (auth.authorizeUrl) {
+        claudeChildren.push(
+          react.createElement("a", { key: "url", "data-authorize-url": "true", href: auth.authorizeUrl }, auth.authorizeUrl)
+        );
+      }
+      flowContent = react.createElement(
+        "div",
+        { "data-auth-flow": "claude" },
+        ...claudeChildren
+      );
+    }
+  } else if (activeBackend === "api-key") {
+    if (renderApiKeyFlow) {
+      flowContent = renderApiKeyFlow({
+        submitApiKey: auth.submitApiKey,
+        status: auth.status
+      });
+    } else {
+      flowContent = react.createElement(
+        "div",
+        { "data-auth-flow": "api-key" },
+        react.createElement(
+          "button",
+          {
+            key: "submit",
+            type: "button",
+            "data-action": "submit-api-key",
+            onClick: () => auth.submitApiKey("")
+          },
+          "Submit API Key"
+        )
+      );
+    }
+  }
+  children.push(react.createElement("div", contentAttrs, flowContent));
+  if (auth.error) {
+    children.push(
+      react.createElement(
+        "div",
+        { key: "error", "data-auth-error-display": "true" },
+        auth.error.message
+      )
+    );
+  }
+  return react.createElement(
+    "div",
+    { "data-auth-dialog": "true", className },
+    ...children
+  );
+}
+
+exports.AuthDialog = AuthDialog;
+exports.ChatProvider = ChatProvider;
+exports.Composer = Composer;
+exports.MarkdownRenderer = MarkdownRenderer;
+exports.Message = Message;
+exports.ModelSelector = ModelSelector;
+exports.RemoteChatRuntime = RemoteChatRuntime;
+exports.ThinkingBlock = ThinkingBlock;
+exports.Thread = Thread;
+exports.ThreadList = ThreadList;
+exports.ThreadProvider = ThreadProvider;
+exports.ToolCallView = ToolCallView;
+exports.useAuth = useAuth;
+exports.useChat = useChat;
+exports.useChatRuntime = useChatRuntime;
+exports.useMessages = useMessages;
+exports.useModels = useModels;
+exports.useOptionalThreadSlots = useOptionalThreadSlots;
+exports.useRemoteAuth = useRemoteAuth;
+exports.useRemoteChat = useRemoteChat;
+exports.useSSE = useSSE;
+exports.useSessions = useSessions;
+exports.useThreadSlots = useThreadSlots;
+exports.useToolApproval = useToolApproval;
+//# sourceMappingURL=react.cjs.map
+//# sourceMappingURL=react.cjs.map