simple-ai-sdk 1.0.0

package/src/client/manager.ts

@@ -0,0 +1,814 @@
+import type {
+  ChatSession,
+  StreamManagerListener,
+  StreamManagerState,
+} from "./types.js";
+import type { Message, ChatRequest, JSONValue } from "../shared/index.js";
+import { generateId } from "../shared/generate-id.js";
+import { isAbortError } from "../shared/error-utils.js";
+
+export interface IStreamManager {
+  subscribe(listener: StreamManagerListener): () => void;
+  getSnapshot(): StreamManagerState;
+  getSession(sessionId: string): ChatSession | undefined;
+  initSession(sessionId: string, initialMessages?: Message[]): void;
+  /**
+   * セッション単位で最新の onFinish ハンドラを登録する。
+   * - ストリーム完了時は常にこの最新ハンドラを呼び出す。
+   * - コンポーネントがアンマウントされても保持され、完了時に呼ばれる。
+   */
+  setOnFinishHandler(
+    sessionId: string,
+    handler: ((messages: Message[]) => void) | undefined
+  ): void;
+  /**
+   * セッション単位で最新の onMetadata ハンドラを登録する。
+   */
+  setOnMetadataHandler(
+    sessionId: string,
+    handler: ((metadata: Record<string, JSONValue>) => void) | undefined
+  ): void;
+  /**
+   * セッション単位で最新の onError ハンドラを登録する。
+   */
+  setOnErrorHandler(
+    sessionId: string,
+    handler: ((error: Error) => void) | undefined
+  ): void;
+  /**
+   * セッションに購読者を関連付ける（マウント時に呼ぶ）。
+   */
+  retainSession(sessionId: string): void;
+  /**
+   * セッションから購読者を外す（アンマウント時に呼ぶ）。
+   */
+  releaseSession(sessionId: string): void;
+  /**
+   * セッションの最終アクセス時刻を更新する（LRU用）。
+   * レンダリング中に呼ばれる可能性があるため、通知は行わない。
+   */
+  touchSession(sessionId: string): void;
+  updateSession(sessionId: string, updates: Partial<ChatSession>): void;
+  streamChat(
+    sessionId: string,
+    messages: Message[],
+    options: {
+      api: string;
+      body?: Record<string, JSONValue>;
+    }
+  ): Promise<void>;
+  stopStream(sessionId: string): void;
+  /**
+   * ライフサイクル終了時のクリーンアップ用。
+   * SimpleAIProvider から呼び出される想定。
+   */
+  dispose(): void;
+}
+
+export type StreamManagerOptions = {
+  maxSessions?: number;
+  debug?: boolean;
+  /**
+   * TTL（ミリ秒）を過ぎてアクセスのない ready/error セッションを自動掃除する。
+   * 指定しない場合は自動掃除を行わない。
+   */
+  ttlMs?: number;
+};
+
+class StreamManager implements IStreamManager {
+  private state: StreamManagerState = {
+    sessions: new Map(),
+  };
+
+  private listeners = new Set<StreamManagerListener>();
+  // setTimeout の戻り値型に依存しないための型指定
+  // rAF-based batching for frequent updates
+  private rafScheduled = false;
+  private rafId: number | null = null;
+  private rafFallbackTimer: ReturnType<typeof setTimeout> | null = null;
+  // Typed accessors for rAF/cAF without relying on DOM types
+  private getRAF(): ((cb: (t: number) => void) => number) | undefined {
+    const g = globalThis as { requestAnimationFrame?: unknown };
+    return typeof g.requestAnimationFrame === "function"
+      ? (g.requestAnimationFrame as (cb: (t: number) => void) => number)
+      : undefined;
+  }
+  private getCAF(): ((id: number) => void) | undefined {
+    const g = globalThis as { cancelAnimationFrame?: unknown };
+    return typeof g.cancelAnimationFrame === "function"
+      ? (g.cancelAnimationFrame as (id: number) => void)
+      : undefined;
+  }
+  private maxSessions: number;
+  private debug: boolean;
+  private ttlMs?: number;
+  private sweepTimer: ReturnType<typeof setInterval> | null = null;
+  // 各セッションの購読者数（同一 sessionId を複数コンポーネントが参照するケースに対応）
+  private activeSubscribers = new Map<string, number>();
+  // セッション単位で「最新の onFinish」を保持（常に最新を呼びたい要件に対応）
+  private latestOnFinish = new Map<string, (messages: Message[]) => void>();
+  // セッション単位で「最新の onMetadata」を保持
+  private latestOnMetadata = new Map<
+    string,
+    (metadata: Record<string, JSONValue>) => void
+  >();
+  // セッション単位で「最新の onError」を保持
+  private latestOnError = new Map<string, (error: Error) => void>();
+  // 意図: 各セッションの最新ストリームIDを保持し、古いストリームの遅延イベントを無視する
+  private streamIds = new Map<string, number>();
+
+  constructor(options: StreamManagerOptions = {}) {
+    this.maxSessions = options.maxSessions ?? 5;
+    this.debug = options.debug ?? false;
+    this.ttlMs = options.ttlMs;
+
+    // TTL が設定されている場合、一定間隔で古いセッションを掃除する
+    const sweepEnabled = this.ttlMs && this.ttlMs > 0;
+    if (sweepEnabled) {
+      this.sweepTimer = setInterval(() => {
+        if (this.debug)
+          console.info("[SM] Running TTL sweep", this.state.sessions);
+        if (this.state.sessions.size === 0) return;
+        const now = Date.now();
+        let removed = false; // 意図: TTL 掃除でセッションが削除された時のみ通知して無駄な再レンダリングを回避
+        for (const [id, session] of this.state.sessions) {
+          // ストリーミング中のセッションは対象外
+          if (session.status === "streaming" || session.status === "submitted")
+            continue;
+          // 購読者がいないセッションのみ TTL 対象
+          const subCount = this.activeSubscribers.get(id) ?? 0;
+          if (subCount > 0) continue;
+          if (now - session.lastAccessed > this.ttlMs!) {
+            // 安全のため abortController が残っていれば中断
+            try {
+              session.abortController?.abort();
+            } catch (err) {
+              if (this.debug) {
+                console.warn("[SM] abort error during TTL sweep", err);
+              }
+            }
+            this.state.sessions.delete(id);
+            // 意図: ハンドラと streamId も破棄してリークを防止
+            this.latestOnFinish.delete(id);
+            this.latestOnMetadata.delete(id);
+            this.latestOnError.delete(id);
+            this.streamIds.delete(id);
+            removed = true;
+            if (this.debug) {
+              this.logSessionInfo(`Session removed by TTL GC: ${id}`);
+            }
+          }
+        }
+        // 意図: 実際に削除があった場合のみ通知して、不要な通知を抑制
+        if (removed) this.notify(true);
+      }, this.ttlMs);
+    }
+  }
+
+  // 状態変更を監視するリスナーを登録する
+  // 戻り値は登録解除用の関数（Reactのクリーンアップで使用）
+  subscribe(listener: StreamManagerListener): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  setOnFinishHandler(
+    sessionId: string,
+    handler: ((messages: Message[]) => void) | undefined
+  ) {
+    if (handler) {
+      this.latestOnFinish.set(sessionId, handler);
+    } else {
+      this.latestOnFinish.delete(sessionId);
+    }
+  }
+
+  setOnMetadataHandler(
+    sessionId: string,
+    handler: ((metadata: Record<string, JSONValue>) => void) | undefined
+  ) {
+    if (handler) {
+      this.latestOnMetadata.set(sessionId, handler);
+    } else {
+      this.latestOnMetadata.delete(sessionId);
+    }
+  }
+
+  setOnErrorHandler(
+    sessionId: string,
+    handler: ((error: Error) => void) | undefined
+  ) {
+    if (handler) {
+      this.latestOnError.set(sessionId, handler);
+    } else {
+      this.latestOnError.delete(sessionId);
+    }
+  }
+
+  // 現在の状態のスナップショットを返す
+  // useSyncExternalStoreが状態を取得する際に使用
+  getSnapshot(): StreamManagerState {
+    return this.state;
+  }
+
+  // リスナーに状態変更を通知する
+  // immediate=true の場合は即座に、false の場合は rAF で 1 フレームにまとめて通知
+  private notify(immediate = false) {
+    // 新しいstateオブジェクトを作成して参照を変更
+    // これによりuseSyncExternalStoreが変更を検知できる
+    this.state = {
+      ...this.state,
+      sessions: new Map(this.state.sessions),
+    };
+
+    if (immediate) {
+      // 重要な状態変更（ステータス変更など）は即座に通知
+      if (this.rafId != null) {
+        const caf = this.getCAF();
+        if (caf) {
+          try {
+            caf(this.rafId);
+          } catch {
+            // ignore
+          }
+        }
+      }
+      this.rafId = null;
+      if (this.rafFallbackTimer) {
+        clearTimeout(this.rafFallbackTimer);
+        this.rafFallbackTimer = null;
+      }
+      this.rafScheduled = false;
+      this.listeners.forEach((listener) => listener());
+    } else {
+      // ストリーミング中の頻繁な更新は rAF で 1 フレームにまとめる
+      if (this.rafScheduled) return;
+      this.rafScheduled = true;
+      const raf = this.getRAF();
+      if (raf) {
+        this.rafId = raf(() => {
+          this.rafId = null;
+          this.rafScheduled = false;
+          this.listeners.forEach((listener) => listener());
+        });
+      } else {
+        // Fallback (e.g., non-browser env) ~60fps
+        this.rafFallbackTimer = setTimeout(() => {
+          this.rafFallbackTimer = null;
+          this.rafScheduled = false;
+          this.listeners.forEach((listener) => listener());
+        }, 16);
+      }
+    }
+  }
+
+  getSession(sessionId: string): ChatSession | undefined {
+    const session = this.state.sessions.get(sessionId);
+    if (session) {
+      // Update last accessed time when getting a session
+      session.lastAccessed = Date.now();
+    }
+    return session;
+  }
+
+  // LRU 用に最終アクセス時刻のみを更新する（通知はしない）
+  touchSession(sessionId: string) {
+    const session = this.state.sessions.get(sessionId);
+    if (session) {
+      session.lastAccessed = Date.now();
+    }
+  }
+
+  initSession(sessionId: string, initialMessages: Message[] = []) {
+    if (!this.state.sessions.has(sessionId)) {
+      // Check if we need to remove old sessions
+      if (this.state.sessions.size >= this.maxSessions) {
+        this.removeOldestSession();
+      }
+
+      this.state.sessions.set(sessionId, {
+        id: sessionId,
+        messages: initialMessages,
+        status: "ready",
+        error: null,
+        abortController: null,
+        lastAccessed: Date.now(),
+      });
+
+      if (this.debug) {
+        this.logSessionInfo(`Session added: ${sessionId}`);
+      }
+
+      this.notify(true); // Immediate for initialization
+    }
+    if (this.debug)
+      console.log(
+        "[SM] current sessions",
+        this.state.sessions,
+        this.activeSubscribers
+      );
+  }
+
+  retainSession(sessionId: string) {
+    const prev = this.activeSubscribers.get(sessionId) ?? 0;
+    this.activeSubscribers.set(sessionId, prev + 1);
+    if (this.debug) {
+      console.info(`[SM] retainSession: ${sessionId} -> ${prev + 1}`);
+    }
+  }
+
+  releaseSession(sessionId: string) {
+    const prev = this.activeSubscribers.get(sessionId) ?? 0;
+    const next = Math.max(0, prev - 1);
+    if (next === 0) {
+      this.activeSubscribers.delete(sessionId);
+    } else {
+      this.activeSubscribers.set(sessionId, next);
+    }
+    if (this.debug) {
+      console.info(`[SM] releaseSession: ${sessionId} -> ${next}`);
+    }
+  }
+
+  private removeOldestSession() {
+    let oldestSessionId: string | null = null;
+    let oldestTime = Date.now();
+
+    // まずは「非ストリーミング かつ 購読者なし」の中から最古を探す
+    for (const [id, session] of this.state.sessions) {
+      const subCount = this.activeSubscribers.get(id) ?? 0;
+      if (
+        session.status !== "streaming" &&
+        session.status !== "submitted" &&
+        subCount === 0
+      ) {
+        if (session.lastAccessed < oldestTime) {
+          oldestTime = session.lastAccessed;
+          oldestSessionId = id;
+        }
+      }
+    }
+
+    // 上で見つからない場合は、状態・購読を問わず最古を探す（上限を強制的に守るため）
+    if (!oldestSessionId) {
+      for (const [id, session] of this.state.sessions) {
+        if (session.lastAccessed < oldestTime) {
+          oldestTime = session.lastAccessed;
+          oldestSessionId = id;
+        }
+      }
+    }
+
+    // Remove the oldest session
+    if (oldestSessionId) {
+      const session = this.state.sessions.get(oldestSessionId);
+      if (session?.abortController) {
+        session.abortController.abort();
+      }
+      this.state.sessions.delete(oldestSessionId);
+      // セッション破棄時はハンドラも破棄
+      this.latestOnFinish.delete(oldestSessionId);
+      this.latestOnMetadata.delete(oldestSessionId);
+      this.latestOnError.delete(oldestSessionId);
+      // 意図: streamId も破棄してメモリリーク・誤判定を防止
+      this.streamIds.delete(oldestSessionId);
+
+      if (this.debug) {
+        this.logSessionInfo(
+          `Session removed: ${oldestSessionId} (LRU eviction)`
+        );
+      }
+    }
+  }
+
+  private logSessionInfo(action: string) {
+    const sessionInfo = Array.from(this.state.sessions.entries()).map(
+      ([id, session]) => ({
+        id,
+        status: session.status,
+        messageCount: session.messages.length,
+        lastAccessed: new Date(session.lastAccessed).toISOString(),
+        hasError: !!session.error,
+        subscriberCount: this.activeSubscribers.get(id) ?? 0,
+      })
+    );
+
+    console.info(`[SM] ${action}`, {
+      totalSessions: this.state.sessions.size,
+      maxSessions: this.maxSessions,
+      sessions: sessionInfo,
+    });
+  }
+
+  updateSession(
+    sessionId: string,
+    updates: Partial<ChatSession>,
+    immediate = false
+  ) {
+    const session = this.state.sessions.get(sessionId);
+    if (session) {
+      // Update last accessed time
+      session.lastAccessed = Date.now();
+      Object.assign(session, updates);
+      // 再レンダリング抑制: 購読者が0のセッションに対する
+      // ストリーミング由来の message 更新では通知しない。
+      // （onFinish/onError等のイベントは immediate=true で通知される）
+      if (immediate) {
+        this.notify(true);
+      } else {
+        const subCount = this.activeSubscribers.get(sessionId) ?? 0;
+        if (subCount > 0) {
+          this.notify(false);
+        } else if (this.debug) {
+          // デバッグ時は抑制されたことをログ
+          console.info(`[SM] notify suppressed (no subscribers): ${sessionId}`);
+        }
+      }
+    }
+  }
+
+  async streamChat(
+    sessionId: string,
+    messages: Message[],
+    options: {
+      api: string;
+      body?: Record<string, JSONValue>;
+    }
+  ) {
+    const session = this.state.sessions.get(sessionId);
+    if (!session) return;
+
+    // 既存のストリームがあれば中断してから新規ストリームを開始する
+    // （同一セッションでの重複ストリーミングを防止）
+    if (session.abortController) {
+      try {
+        session.abortController.abort();
+      } catch {
+        console.error("[SM] Failed to abort stream during initiation");
+      }
+    }
+
+    const abortController = new AbortController();
+
+    // 意図: セッションごとの streamId をインクリメントし、古いストリームからの遅延イベントを無視するためのガードに使用
+    const currentStreamId = this.streamIds.get(sessionId) ?? 0;
+    this.streamIds.set(sessionId, currentStreamId + 1);
+    const streamId = currentStreamId + 1;
+
+    this.updateSession(
+      sessionId,
+      {
+        messages,
+        status: "submitted",
+        error: null,
+        abortController,
+      },
+      true
+    ); // Immediate for status change
+
+    try {
+      const requestBody: ChatRequest = {
+        messages,
+        body: options.body,
+      };
+
+      const response = await fetch(options.api, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(requestBody),
+        signal: abortController.signal,
+      });
+
+      // HTTP レベルのエラーハンドリング：SSE 解析に入る前に早期失敗
+      if (!response.ok) {
+        let message = `HTTP ${response.status}`;
+        try {
+          const text = await response.text();
+          message += text ? `: ${text}` : "";
+        } catch (err) {
+          console.warn("[SM] response.text() error", err);
+        }
+        const err = new Error(message);
+        this.updateSession(
+          sessionId,
+          {
+            status: "error",
+            error: err,
+            abortController: null,
+          },
+          true
+        );
+        // セッションに登録された最新の onError を使用
+        try {
+          this.latestOnError.get(sessionId)?.(err);
+        } catch {
+          console.error("[SM] Failed to call onError handler");
+        }
+        return;
+      }
+
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error("No response body");
+      }
+
+      const decoder = new TextDecoder();
+      let buffer = "";
+      const assistantMessage: Message = {
+        id: generateId({ prefix: "msg-" }),
+        role: "assistant",
+        content: "",
+      };
+
+      // 配列の再構築コストを下げるため、最初に一度だけ配列を作り
+      // 以降は assistantMessage の content を更新していく
+      // （Map 自体の参照を変えて通知するため、参照が同一でも UI は更新される）
+      const updatedMessages = [...messages, assistantMessage];
+      this.updateSession(
+        sessionId,
+        {
+          messages: updatedMessages,
+          status: "streaming",
+        },
+        true
+      ); // Immediate for status change
+
+      // SSE の標準仕様に従い、空行でイベントを区切って解析する
+      // - 複数行の data: をサポート
+      // - コメント行（先頭 ':'）は無視
+      // - event: が無い場合はデフォルトの 'message' を想定するが、本実装ではサーバ仕様に合わせ 'chunk' 等のみ処理
+      let failed = false; // 意図: error イベント処理後に通常完了経路や catch を踏まないためのフラグ
+      let shouldTerminate = false; // 意図: done/error 受信時にループ終了を指示
+      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() || ""; // 末尾の未完成行をバッファに残す
+
+        let eventName: string | null = null;
+        let dataLines: string[] = [];
+
+        const flushEvent = () => {
+          if (dataLines.length === 0 && !eventName) return;
+          const dataStr = dataLines.join("\n");
+          // 本ワイヤ仕様では data は常に JSON
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          let parsed: any;
+          try {
+            parsed = dataStr ? JSON.parse(dataStr) : null;
+          } catch (err) {
+            console.warn("[SM] Failed to parse JSON data:", dataStr, err);
+            // JSON でない場合は無視（接続維持のために例外は投げない）
+            parsed = null;
+          }
+
+          switch (eventName) {
+            case "chunk": {
+              if (parsed && typeof parsed.text === "string") {
+                // stale stream を無視（state 変更前に判定）
+                const latestId = this.streamIds.get(sessionId);
+                if (latestId !== streamId) return; // 意図: 中断済みのストリームからの遅延イベントを破棄
+                // 大きな文字列連結は O(n^2) になり得るが、まずは単純連結。
+                // 必要なら閾値超過で配列バッファ化する最適化を検討。
+                assistantMessage.content += parsed.text;
+                // 購読者がいる場合のみ通知（いない場合は状態は更新されるが通知は抑制）
+                const subCount = this.activeSubscribers.get(sessionId) ?? 0;
+                if (subCount > 0) {
+                  // 配列の再構築を避け、同一配列参照で通知
+                  this.updateSession(sessionId, {
+                    messages: updatedMessages,
+                  }); // Debounced for streaming chunks
+                } else if (this.debug) {
+                  console.info(
+                    `[SM] chunk suppressed (no subscribers): ${sessionId}`
+                  );
+                }
+              }
+              break;
+            }
+            case "fullContent": {
+              if (
+                parsed &&
+                parsed.type === "replace" &&
+                typeof parsed.content === "string"
+              ) {
+                // stale stream を無視（state 変更前に判定）
+                const latestId = this.streamIds.get(sessionId);
+                if (latestId !== streamId) return; // 意図: 中断済みのストリームからの遅延イベントを破棄
+                // Replace message content with transformed version
+                assistantMessage.content = parsed.content;
+                this.updateSession(
+                  sessionId,
+                  {
+                    messages: updatedMessages,
+                  },
+                  true
+                ); // Immediate update for full content
+              }
+              break;
+            }
+            case "metadata": {
+              if (parsed) {
+                // セッションに登録された最新の onMetadata を使用
+                try {
+                  this.latestOnMetadata.get(sessionId)?.(parsed);
+                } catch {
+                  console.error("[SM] Failed to call onMetadata handler");
+                }
+              }
+              break;
+            }
+            case "error": {
+              const err = new Error(parsed?.message || "Stream error");
+              // ストリームを明示的に中断
+              try {
+                abortController.abort();
+              } catch {
+                console.error("[SM] Failed to abort stream on error");
+              }
+              // stale stream を無視
+              const latestId = this.streamIds.get(sessionId);
+              if (latestId !== streamId) return; // 意図: 中断済みのストリームからの遅延イベントを破棄
+              this.updateSession(
+                sessionId,
+                {
+                  status: "error",
+                  error: err,
+                  abortController: null,
+                },
+                true
+              );
+              // セッションに登録された最新の onError を使用
+              try {
+                this.latestOnError.get(sessionId)?.(err);
+              } catch {
+                console.error("[SM] Failed to call onError handler");
+              }
+              // 意図: catch に落とさず通常完了経路も避けるため、フラグを立ててループ終了
+              failed = true;
+              shouldTerminate = true;
+              break;
+            }
+            case "done": {
+              // stale stream を無視
+              const latestId = this.streamIds.get(sessionId);
+              if (latestId !== streamId) return; // 意図: 中断済みのストリームからの遅延イベントを破棄
+              this.updateSession(
+                sessionId,
+                {
+                  status: "ready",
+                  abortController: null,
+                },
+                true
+              );
+              // セッションに登録された最新の onFinish のみ呼ぶ
+              try {
+                this.latestOnFinish.get(sessionId)?.(
+                  (this.state.sessions.get(sessionId)?.messages ||
+                    []) as Message[]
+                );
+              } catch {
+                console.error("[SM] Failed to call onFinish handler");
+              }
+              // 意図: 正常終了。外側の catch へは行かず処理を終了するためループ終了を指示
+              shouldTerminate = true;
+              break;
+            }
+            default:
+              // 未知イベントは無視
+              break;
+          }
+        };
+
+        for (const line of lines) {
+          if (line === "") {
+            // 空行で一つのイベントをフラッシュ
+            flushEvent();
+            eventName = null;
+            dataLines = [];
+            continue;
+          }
+          if (line.startsWith(":")) {
+            // コメント（無視）
+            continue;
+          }
+          if (line.startsWith("event:")) {
+            eventName = line.slice(6).trim();
+            continue;
+          }
+          if (line.startsWith("data:")) {
+            dataLines.push(line.slice(5).trimStart());
+            continue;
+          }
+          // 他のフィールド（id, retry など）は無視
+        }
+
+        // 意図: error/done を受け取ったら読み取りループを終了
+        if (shouldTerminate) break;
+      }
+
+      // 意図: 正常完了（サーバが done を送らないケース）だけをここで処理。
+      // failed=true（error）の場合は既に状態更新済みなので何もしない。
+      if (!failed && !shouldTerminate) {
+        this.updateSession(
+          sessionId,
+          {
+            status: "ready",
+            abortController: null,
+          },
+          true
+        ); // Immediate for status change
+        try {
+          this.latestOnFinish.get(sessionId)?.(
+            (this.state.sessions.get(sessionId)?.messages || []) as Message[]
+          );
+        } catch {
+          console.error("[SM] Failed to call onFinish handler on completion");
+        }
+      }
+    } catch (error) {
+      // 意図: エラーイベントは catch に到達しない（failed フラグで分岐）ため、ここは接続エラーや中断のみ
+      if (isAbortError(error)) {
+        this.updateSession(
+          sessionId,
+          {
+            status: "ready",
+            abortController: null,
+          },
+          true
+        ); // Immediate for status change
+      } else {
+        const err = error instanceof Error ? error : new Error("Unknown error");
+        // 安全のため接続を明示的に中断
+        try {
+          abortController.abort();
+        } catch {
+          console.error("[SM] Failed to abort stream during cleanup");
+        }
+        this.updateSession(
+          sessionId,
+          {
+            status: "error",
+            error: err,
+            abortController: null,
+          },
+          true
+        ); // Immediate for error status
+        // セッションに登録された最新の onError を使用
+        try {
+          this.latestOnError.get(sessionId)?.(err);
+        } catch {
+          console.error("[SM] Failed to call onError handler");
+        }
+      }
+    }
+  }
+
+  stopStream(sessionId: string) {
+    const session = this.state.sessions.get(sessionId);
+    if (session?.abortController) {
+      session.abortController.abort();
+    }
+  }
+
+  /**
+   * ライフサイクル終了時のクリーンアップ用。
+   * SimpleAIProvider から呼び出される想定。
+   */
+  dispose(): void {
+    // 通知用スケジューラの解放
+    if (this.rafId != null) {
+      const caf = this.getCAF();
+      if (caf) {
+        try {
+          caf(this.rafId);
+        } catch {
+          // ignore
+        }
+      }
+    }
+    this.rafId = null;
+    if (this.rafFallbackTimer) {
+      clearTimeout(this.rafFallbackTimer);
+      this.rafFallbackTimer = null;
+    }
+    this.rafScheduled = false;
+    if (this.sweepTimer) {
+      clearInterval(this.sweepTimer);
+      this.sweepTimer = null;
+    }
+  }
+}
+
+// Export the StreamManager class for custom initialization
+export { StreamManager };
+
+// Create default instance without options
+// Will be replaced in SimpleAIProvider if custom options are provided
+export const streamManager: IStreamManager = new StreamManager();