@keyou007/agent-bot 0.1.19-alpha.1 → 0.1.19

package/docs/technical-reference.md

@@ -261,7 +261,7 @@ Starting a Feishu thread from a mapped user message, progress card, or final res
 
 `/forkgroup` has thread-aware source selection. An unbound thread, or a bound thread task with no completed turn of its own, forks directly from the thread's original anchor turn without creating an intermediate thread task. Once the thread task has completed a turn, `/forkgroup` uses its latest locally persisted completed turn. A newer active turn does not block the command and is excluded from the fork point.
 
-Agent Bot sends the experimental `excludeTurns: true` field on every `thread/fork` request. This suppresses populated `thread.turns` in the response without changing the history copied into the fork. The App Server connection enables `experimentalApi`; no user-facing command option is required. If an older App Server explicitly rejects `excludeTurns` as unknown, unsupported, or unavailable without experimental support, Agent Bot retries once without that field. Timeouts, disconnects, and unrelated fork errors are never retried because the first request may already have created a branch.
+Before forking a task that has never been bound to Agent Bot, Agent Bot reads metadata without Turns and pages backward through the lightweight `summary` Turn view only until it finds the latest completed Turn. It does not load the task's complete tool history as a Fork prerequisite. Agent Bot then sends the experimental `excludeTurns: true` field on every `thread/fork` request. This suppresses populated `thread.turns` in the response without changing the history copied into the fork. The App Server connection enables `experimentalApi`; no user-facing command option is required. If an older App Server explicitly rejects the lightweight Turn-list method or the `excludeTurns` field, Agent Bot falls back to the compatible complete-history read or Fork request. Timeouts, disconnects, and unrelated Fork errors are never retried because a timed-out Fork request may already have created a branch.
 
 The new group's welcome message reports the persisted fork settings: Provider, model, reasoning effort, and permission type. Permission type is rendered as automatic execution or confirmation before execution.
 

package/docs/technical-reference.zh.md

@@ -261,7 +261,7 @@ AGENT_BOT_LARK_USER_OPEN_ID=<已保存的授权用户 open_id，可用时提供>
 
 `/forkgroup` 会根据话题状态选择来源。话题尚未绑定任务，或者已绑定任务但尚未完成过自己的 turn 时，直接从话题原始锚点 turn fork，不创建中间话题任务。话题任务完成过 turn 后，使用本地持久化的最近完成 turn；更晚的执行中 turn 不会阻塞命令，也不会成为 fork 点。
 
-Agent Bot 会在每个 `thread/fork` 请求中默认发送实验性的 `excludeTurns: true`。它只阻止响应填充 `thread.turns`，不会改变复制到分支中的历史。App Server 连接已启用 `experimentalApi`，不需要用户提供命令参数。如果旧版 App Server 明确提示 `excludeTurns` 字段未知、不支持或需要实验能力，Agent Bot 会移除该字段并重试一次。超时、断连和无关的 Fork 错误绝不重试，因为第一次请求可能已经创建分支。
+Fork 从未绑定过 Agent Bot 的任务前，Agent Bot 会先读取不含 Turns 的元数据，再通过轻量的 `summary` Turn 视图从新到旧分页，只读到最近一个已完成 Turn，不再把完整工具历史作为 Fork 前置条件。随后每个 `thread/fork` 请求仍默认发送实验性的 `excludeTurns: true`；它只阻止响应填充 `thread.turns`，不会改变复制到分支中的历史。App Server 连接已启用 `experimentalApi`，不需要用户提供命令参数。如果旧版 App Server 明确不支持轻量 Turn 列表或 `excludeTurns` 字段，Agent Bot 会分别回退到兼容的完整历史读取或 Fork 请求。超时、断连和无关的 Fork 错误绝不重试，因为超时的 Fork 请求可能已经创建分支。
 
 新群欢迎消息会显示分支任务持久化后的 Provider、模型、思考强度和权限类型；权限类型显示为自动执行或执行前确认。
 

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.19-alpha.1",
+  "version": "0.1.19",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@keyou007/agent-bot",
-      "version": "0.1.19-alpha.1",
+      "version": "0.1.19",
       "license": "GPL-3.0-only",
       "dependencies": {
         "@agentclientprotocol/sdk": "1.2.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyou007/agent-bot",
-  "version": "0.1.19-alpha.1",
+  "version": "0.1.19",
   "type": "module",
   "description": "Use Codex, TraeX, and compatible coding agents from Lark/Feishu.",
   "license": "GPL-3.0-only",

package/src/codex/CodexRuntime.ts

@@ -42,6 +42,8 @@ const SESSION_REQUEST_TIMEOUT_MS = 60_000;
 const CONTROL_REQUEST_TIMEOUT_MS = 10_000;
 const SYNC_REQUEST_TIMEOUT_MS = 5_000;
 const THREAD_TURN_PAGE_SIZE = 100;
+const FORK_SOURCE_TURN_PAGE_SIZE = 20;
+const FORK_SOURCE_REQUEST_TIMEOUT_MS = 15_000;
 const USER_RESUMABLE_THREAD_SOURCE_KINDS = ["cli", "vscode", "exec", "appServer"] as const;
 // A timed-out fork keeps running in App Server and can create an orphan thread.
 // Wait for its response; connection closure still rejects the request.
@@ -305,7 +307,37 @@ export class CodexRuntime implements AgentRuntime {
   async readRemoteSession(remoteSessionId: string): Promise<RemoteSessionSummary> {
     const client = await this.client();
     const response = await this.readThreadWithTurns(client, remoteSessionId);
-    const summary = remoteSessionSummary(response.thread);
+    return this.decorateRemoteSession(remoteSessionId, remoteSessionSummary(response.thread));
+  }
+
+  async readRemoteForkSource(remoteSessionId: string): Promise<RemoteSessionSummary> {
+    const client = await this.client();
+    const metadata = await client.request<ThreadReadResponse>(
+      "thread/read",
+      { threadId: remoteSessionId, includeTurns: false },
+      FORK_SOURCE_REQUEST_TIMEOUT_MS,
+    );
+    let turns: CodexTurnSnapshot[];
+    try {
+      turns = await this.listRecentThreadTurnsThroughCompleted(client, remoteSessionId);
+    } catch (error) {
+      if (!isUnsupportedThreadTurnsListError(error)) throw error;
+      this.logger.warn(
+        { error, remoteSessionId },
+        "App Server does not support lightweight Fork source reads; falling back to complete thread history.",
+      );
+      return this.readRemoteSession(remoteSessionId);
+    }
+    return this.decorateRemoteSession(remoteSessionId, remoteSessionSummary({
+      ...metadata.thread,
+      turns,
+    }));
+  }
+
+  private async decorateRemoteSession(
+    remoteSessionId: string,
+    summary: RemoteSessionSummary,
+  ): Promise<RemoteSessionSummary> {
     const activeThreads = await this.localActivityDetector?.activeThreads([remoteSessionId]);
     const activeSummary = activeThreads ? markLocallyDetectedActive(summary, activeThreads) : summary;
     const settings = await this.localActivityDetector?.threadSettings([remoteSessionId]);
@@ -315,6 +347,46 @@ export class CodexRuntime implements AgentRuntime {
     };
   }
 
+  private async listRecentThreadTurnsThroughCompleted(
+    client: AppServerClient,
+    remoteSessionId: string,
+  ): Promise<CodexTurnSnapshot[]> {
+    const turns: CodexTurnSnapshot[] = [];
+    const seenCursors = new Set<string>();
+    let cursor: string | undefined;
+    do {
+      const response = await client.request<ThreadTurnsListResponse>(
+        "thread/turns/list",
+        {
+          threadId: remoteSessionId,
+          ...(cursor ? { cursor } : {}),
+          limit: FORK_SOURCE_TURN_PAGE_SIZE,
+          sortDirection: "desc",
+          itemsView: "summary",
+        },
+        FORK_SOURCE_REQUEST_TIMEOUT_MS,
+      );
+      turns.push(...response.data);
+      const completedIndex = turns.findIndex((turn) => turn.status === "completed");
+      if (completedIndex >= 0) {
+        turns.splice(completedIndex + 1);
+        break;
+      }
+      const nextCursor = response.nextCursor ?? undefined;
+      if (!nextCursor) break;
+      if (seenCursors.has(nextCursor)) {
+        this.logger.warn(
+          { remoteSessionId, cursor: nextCursor },
+          "App Server repeated a Fork source Turn cursor; stopping pagination.",
+        );
+        break;
+      }
+      seenCursors.add(nextCursor);
+      cursor = nextCursor;
+    } while (cursor);
+    return turns.reverse();
+  }
+
   private async readThreadWithTurns(
     client: AppServerClient,
     remoteSessionId: string,
@@ -1229,6 +1301,12 @@ function isPaginatedThreadReadError(error: unknown): boolean {
   return /paginated threads?[^\n]*do(?:es)? not support[^\n]*thread\/read[^\n]*includeTurns\s*=\s*true/i.test(details);
 }
 
+function isUnsupportedThreadTurnsListError(error: unknown): boolean {
+  if (!(error instanceof AppServerRequestError) || error.method !== "thread/turns/list") return false;
+  return error.code === -32601
+    || /method not found|unknown method|unsupported|not supported/i.test(appServerErrorDetails(error));
+}
+
 function isUnmaterializedThreadReadError(error: unknown): boolean {
   const details = appServerErrorDetails(error);
   return /thread[^\n]*(?:not materialized|not loaded)[^\n]*includeTurns[^\n]*(?:unavailable|before first user message)/i

package/src/proxy/ProxySessionController.ts

@@ -3041,7 +3041,7 @@ export class ProxySessionController {
       runtime = this.runtimes.forAgent(agentName);
     } else {
       if (!taskId) throw new Error("缺少要 fork 的 App Server 任务 ID。");
-      const resolved = await this.resolveRemoteCodexSession(taskId);
+      const resolved = await this.resolveRemoteCodexSession(taskId, { forFork: true });
       agentName = resolved.agentName;
       runtime = resolved.runtime;
       remote = resolved.remote;
@@ -6218,7 +6218,10 @@ export class ProxySessionController {
       : this.store.findSessionByRemoteSessionId(reference, contextKey);
   }
 
-  private async resolveRemoteCodexSession(reference: string): Promise<AgentRemoteSession> {
+  private async resolveRemoteCodexSession(
+    reference: string,
+    options: { forFork?: boolean } = {},
+  ): Promise<AgentRemoteSession> {
     const scoped = parseRemoteSessionReference(reference);
     const candidates = scoped
       ? [[scoped.agentName, this.runtimes.forAgent(scoped.agentName)] as const]
@@ -6229,10 +6232,13 @@ export class ProxySessionController {
       if (runtime.kind !== "codex" || !runtime.readRemoteSession) {
         throw new Error(`Agent ${agentName} 不支持读取远端任务。`);
       }
+      const remoteSessionId = scoped?.remoteSessionId ?? reference;
       return {
         agentName,
         runtime,
-        remote: await runtime.readRemoteSession(scoped?.remoteSessionId ?? reference),
+        remote: options.forFork && runtime.readRemoteForkSource
+          ? await runtime.readRemoteForkSource(remoteSessionId)
+          : await runtime.readRemoteSession(remoteSessionId),
       } satisfies AgentRemoteSession;
     }));
     const matches = reads

package/src/runtime/types.ts

@@ -230,6 +230,7 @@ export interface AgentRuntime {
   readSessionMetadata(remoteSessionId: string): Promise<RuntimeSessionMetadata>;
   listRemoteSessions?(input?: { searchTerm?: string; cursor?: string; limit?: number }): Promise<RemoteSessionPage>;
   readRemoteSession?(remoteSessionId: string): Promise<RemoteSessionSummary>;
+  readRemoteForkSource?(remoteSessionId: string): Promise<RemoteSessionSummary>;
   inspectRemoteSessionActivity?(remoteSessionId: string): Promise<RemoteSessionActivity>;
   synchronizeSession(sessionId: string): Promise<RuntimeSession>;
   startTurn(sessionId: string, prompt: RuntimePrompt): Promise<string>;