重构会话管理，简化上下文存储逻辑

src/chat/sessionBridge.ts

@@ -2,10 +2,7 @@ import { randomUUID } from "node:crypto";
 
 import { logger } from "../logger.js";
 import { type OpencodeRuntimeAdapter } from "../runtime/opencode.js";
-import {
-  buildToolSessionScopeKey,
-  ToolSessionContextStore,
-} from "../session/toolContextStore.js";
+import { ToolSessionContextStore } from "../session/toolContextStore.js";
 import { toActorKey, toProjectKey } from "../utils/fileStore.js";
 
 export type SessionBinding = {
@@ -28,9 +25,6 @@ export type ChatRequestContext = SessionContext & {
 };
 
 export class ChatSessionBridge {
-  // runtime session 仅在单次请求生命周期内有效；线程连续性由 clientSessionId 对应的持久状态承担。
-  private readonly activeRuntimeSessions = new Map<string, string>();
-  private readonly activeSensitiveContexts = new Map<string, ChatRequestContext>();
   private readonly abortControllers = new Map<string, AbortController>();
   private readonly toolContextStore = new ToolSessionContextStore();
 
@@ -38,6 +32,7 @@ export class ChatSessionBridge {
 
   async resolve(context: {
     clientSessionId?: string;
+    sessionId?: string;
     accessToken?: string;
     projectId?: string;
     traceId?: string;
@@ -48,70 +43,63 @@ export class ChatSessionBridge {
     created: boolean;
   }> {
     const requestContext = this.buildRequestContext(context);
-    await this.abortActiveRuntime(requestContext.clientSessionId);
+    const existingSessionId = context.sessionId?.trim();
+    await this.abortActiveRuntime(requestContext.clientSessionId, existingSessionId);
 
-    const session = await this.runtime.createSession(requestContext.clientSessionId);
+    let sessionId = existingSessionId;
+    let created = false;
+    if (!sessionId) {
+      const session = await this.runtime.createSession(requestContext.clientSessionId);
+      sessionId = session.id;
+      created = true;
+    }
     const binding: SessionBinding = {
       clientSessionId: requestContext.clientSessionId,
-      sessionId: session.id,
+      sessionId,
       startedAt: Date.now(),
     };
-    const sessionScopeKey = buildToolSessionScopeKey(
-      requestContext.actorKey,
-      requestContext.projectKey,
-      requestContext.clientSessionId,
-    );
-    this.activeRuntimeSessions.set(requestContext.clientSessionId, session.id);
-    this.activeSensitiveContexts.set(sessionScopeKey, requestContext);
     await this.toolContextStore.write({
+      accessToken: requestContext.accessToken,
       actorKey: requestContext.actorKey,
       allowLearningWrite: true,
       clientSessionId: requestContext.clientSessionId,
       learningMode: "interactive",
       projectId: requestContext.projectId,
       projectKey: requestContext.projectKey,
-      sessionId: session.id,
-      sessionScopeKey,
+      sessionId,
       traceId: requestContext.traceId,
     });
 
-    return { binding, requestContext, created: true };
+    return { binding, requestContext, created };
   }
 
   count(): number {
-    return this.activeRuntimeSessions.size;
+    return this.abortControllers.size;
   }
 
   createClientSessionId() {
     return `agent-${randomUUID().slice(0, 12)}`;
   }
 
-  getActiveSensitiveContext(sessionScopeKey: string) {
-    return this.activeSensitiveContexts.get(sessionScopeKey) ?? null;
-  }
-
   registerAbortController(clientSessionId: string, controller: AbortController) {
     this.abortControllers.set(clientSessionId, controller);
   }
 
-  deleteAbortController(clientSessionId: string) {
+  finalizeRequest(clientSessionId: string) {
     this.abortControllers.delete(clientSessionId);
   }
 
   async abort(context: {
     clientSessionId?: string;
+    sessionId?: string;
   }): Promise<SessionBinding | null> {
     const clientSessionId = context.clientSessionId?.trim();
-    if (!clientSessionId) {
+    const sessionId = context.sessionId?.trim();
+    if (!clientSessionId || !sessionId) {
       return null;
     }
 
-    const sessionId = this.activeRuntimeSessions.get(clientSessionId);
-    if (!sessionId) {
-      return null;
-    }
-
-    await this.abortActiveRuntime(clientSessionId);
+    await this.abortActiveRuntime(clientSessionId, sessionId);
     return {
       clientSessionId,
       sessionId,
@@ -119,18 +107,32 @@ export class ChatSessionBridge {
     };
   }
 
-  async releaseRuntimeSession(clientSessionId: string, sessionId: string) {
-    const activeSessionId = this.activeRuntimeSessions.get(clientSessionId);
-    if (activeSessionId === sessionId) {
-      this.activeRuntimeSessions.delete(clientSessionId);
+  async deleteConversationSession(context: {
+    clientSessionId: string;
+    sessionId: string;
+  }) {
+    const clientSessionId = context.clientSessionId.trim();
+    const sessionId = context.sessionId.trim();
+    const controller = this.abortControllers.get(clientSessionId);
+    if (controller) {
+      this.abortControllers.delete(clientSessionId);
+      controller.abort();
     }
-    this.activeSensitiveContexts.delete(findScopeKey(this.activeSensitiveContexts, clientSessionId));
+    await this.runtime.abortSession(sessionId).catch((error) => {
+      logger.warn(
+        { clientSessionId, sessionId, err: error },
+        "failed to abort conversation runtime session",
+      );
+    });
+    await this.runtime.waitForSessionIdle(sessionId).catch((error) => {
+      logger.warn(
+        { clientSessionId, sessionId, err: error },
+        "failed while waiting for conversation runtime session to become idle",
+      );
+    });
     await this.toolContextStore.remove(sessionId).catch((error) => {
       logger.debug({ sessionId, err: error }, "failed to cleanup runtime tool context");
     });
-    await this.runtime.abortSession(sessionId).catch((error) => {
-      logger.debug({ sessionId, err: error }, "failed to cleanup runtime session");
-    });
   }
 
   private buildRequestContext(context: {
@@ -151,44 +153,27 @@ export class ChatSessionBridge {
     };
   }
 
-  private async abortActiveRuntime(clientSessionId: string) {
-    const activeSessionId = this.activeRuntimeSessions.get(clientSessionId);
-    this.activeRuntimeSessions.delete(clientSessionId);
-    this.activeSensitiveContexts.delete(findScopeKey(this.activeSensitiveContexts, clientSessionId));
-
+  private async abortActiveRuntime(clientSessionId: string, sessionId?: string) {
     const controller = this.abortControllers.get(clientSessionId);
     if (controller) {
       this.abortControllers.delete(clientSessionId);
       controller.abort();
     }
 
-    if (!activeSessionId) {
+    if (!sessionId) {
       return;
     }
-    await this.toolContextStore.remove(activeSessionId).catch(() => undefined);
-    await this.runtime.abortSession(activeSessionId).catch((error) => {
+    await this.runtime.abortSession(sessionId).catch((error) => {
       logger.warn(
-        { clientSessionId, sessionId: activeSessionId, err: error },
-        "failed to abort previous active runtime session",
+        { clientSessionId, sessionId, err: error },
+        "failed to abort active runtime session",
       );
     });
-    await this.runtime.waitForSessionIdle(activeSessionId).catch((error) => {
+    await this.runtime.waitForSessionIdle(sessionId).catch((error) => {
       logger.warn(
-        { clientSessionId, sessionId: activeSessionId, err: error },
-        "failed while waiting for previous runtime session to become idle",
+        { clientSessionId, sessionId, err: error },
+        "failed while waiting for active runtime session to become idle",
       );
     });
   }
 }
-
-const findScopeKey = (
-  contexts: Map<string, ChatRequestContext>,
-  clientSessionId: string,
-) => {
-  for (const [scopeKey, context] of contexts.entries()) {
-    if (context.clientSessionId === clientSessionId) {
-      return scopeKey;
-    }
-  }
-  return clientSessionId;
-};