@downcity/agent 1.1.228 → 1.1.236

package/src/executor/Executor.ts

@@ -32,6 +32,7 @@ import type {
 import { to_session_action_record } from "@/executor/types/SessionRecords.js";
 import type { SessionExecutor } from "@/executor/types/SessionExecutor.js";
 import type { SessionRunContext } from "@/types/executor/SessionRunContext.js";
+import type { AgentPluginExecutionRuntime } from "@/types/plugin/PluginRuntime.js";
 import type {
   SessionExecuteInput,
   SessionRunResult,
@@ -61,6 +62,11 @@ type ExecutorOptions = {
    */
   getModel: () => LanguageModel | undefined;
 
+  /**
+   * 读取当前 session 模型支持的总上下文窗口长度。
+   */
+  get_model_context_window?: () => number | undefined;
+
   /**
    * 统一日志器。
    */
@@ -81,6 +87,17 @@ type ExecutorOptions = {
    */
   getTools: () => Record<string, Tool>;
 
+  /**
+   * 读取当前 Session effective Agent env。
+   */
+  getEnv: () => Record<string, string>;
+
+  /** 读取当前 Session effective Agent instruction 文本。 */
+  get_systems?: () => string[];
+
+  /** 创建当前 Session effective Plugin 执行视图。 */
+  get_plugins?: () => AgentPluginExecutionRuntime;
+
   /**
    * 可选自定义 context Composer。
    */
@@ -100,6 +117,10 @@ export class Executor implements SessionExecutor {
   private readonly historyComposer: SessionHistoryComposer;
   private readonly historyStore: SessionHistoryStore;
   private readonly getModel: ExecutorOptions["getModel"];
+  private readonly getEnv: ExecutorOptions["getEnv"];
+  private readonly get_systems: ExecutorOptions["get_systems"];
+  private readonly get_plugins: ExecutorOptions["get_plugins"];
+  private readonly get_model_context_window?: ExecutorOptions["get_model_context_window"];
   private readonly logger: Logger;
   private readonly compactionComposer: SessionCompactionComposer;
   private readonly systemComposer: SessionSystemComposer;
@@ -122,6 +143,10 @@ export class Executor implements SessionExecutor {
     this.historyStore = options.historyStore;
     this.historyComposer = options.historyComposer;
     this.getModel = options.getModel;
+    this.getEnv = options.getEnv;
+    this.get_systems = options.get_systems;
+    this.get_plugins = options.get_plugins;
+    this.get_model_context_window = options.get_model_context_window;
     this.logger = options.logger;
     this.compactionComposer =
       options.compactionComposer || new JsonlSessionCompactionComposer();
@@ -317,6 +342,7 @@ export class Executor implements SessionExecutor {
       );
       return result;
     } finally {
+      await this.release_step_plugins(run_context);
       this.recovery_policy.reset_run_state();
       if (this.abort_controller === abort_controller) {
         this.abort_controller = null;
@@ -339,6 +365,7 @@ export class Executor implements SessionExecutor {
       throw new Error("Executor.run requires historyComposer.sessionId");
     }
 
+    await this.refresh_step_runtime(run_context);
     const composed_context = await this.contextComposer.compose(run_context);
     const tools = this.bind_run_scope_to_tools(composed_context.tools, run_context);
     const system = await this.systemComposer.resolve(run_context);
@@ -359,14 +386,19 @@ export class Executor implements SessionExecutor {
         }
         await this.emitAction(run_context, action);
       };
+      const context_window = this.get_model_context_window?.();
 
-      await this.compactionComposer.run({
-        historyStore: this.historyStore,
-        model,
-        system,
-        retryCount: retry_count,
-        onAction: emit_compaction_action,
-      });
+      if (retry_count > 0) {
+        await this.compactionComposer.run({
+          historyStore: this.historyStore,
+          model,
+          ...(context_window !== undefined ? { context_window } : {}),
+          system,
+          retryCount: retry_count,
+          force: true,
+          onAction: emit_compaction_action,
+        });
+      }
     } catch (error) {
       await this.emitAction(run_context, {
         type: "action",
@@ -413,9 +445,122 @@ export class Executor implements SessionExecutor {
       execute_input: input,
       model,
       run_context,
+      resolve_step_inputs: async () =>
+        await this.resolve_step_inputs(run_context),
     });
   }
 
+  /**
+   * 在 Assistant writer 完成后归档当前 canonical 历史。
+   *
+   * 关键点（中文）：持久化 compact 不能发生在流式 Assistant 草稿仍打开时，
+   * 因此由 SessionTurnService 在 writer complete/fail 之后显式调用。
+   */
+  async compact_history(run_context: SessionRunContext): Promise<{
+    compacted: boolean;
+    reason?: string;
+  }> {
+    let compaction_action_id = "";
+    try {
+      await this.refresh_step_runtime(run_context);
+      const model = this.resolveModelOrThrow();
+      const system = await this.systemComposer.resolve(run_context);
+      const emit_compaction_action = async (
+        action: SessionActionRecordV1,
+      ): Promise<void> => {
+        if (action.state === "running") compaction_action_id = action.id;
+        await this.emitAction(run_context, action);
+      };
+      const context_window = this.get_model_context_window?.();
+      return await this.compactionComposer.run({
+        historyStore: this.historyStore,
+        model,
+        ...(context_window !== undefined ? { context_window } : {}),
+        system,
+        retryCount: 0,
+        force: true,
+        onAction: emit_compaction_action,
+      });
+    } catch (error) {
+      await this.emitAction(run_context, {
+        type: "action",
+        id:
+          compaction_action_id ||
+          `compacting:${this.sessionId}:failed:${Date.now()}:${generateId()}`,
+        title: "Session records compact failed",
+        description: error instanceof Error ? error.message : String(error),
+        state: "failed",
+        metadata: {
+          v: 1,
+          ts: Date.now(),
+          sessionId: this.sessionId,
+        },
+      });
+      return { compacted: false, reason: "compact_failed" };
+    } finally {
+      await this.release_step_plugins(run_context);
+    }
+  }
+
+  /**
+   * 解析下一 Session step 实际使用的运行配置。
+   *
+   * 关键点（中文）
+   * - 调用方必须先提交 Session 统一输入队列，再调用本方法。
+   * - 每次调用只读取一次 model、system 与 tools，并把它们传给同一个 `streamText()`。
+   */
+  private async resolve_step_inputs(run_context: SessionRunContext): Promise<{
+    model: LanguageModel;
+    system: SessionExecuteInput["system"];
+    tools: SessionExecuteInput["tools"];
+    context_window?: number;
+  }> {
+    await this.refresh_step_runtime(run_context);
+    const composed_context = await this.contextComposer.compose(run_context);
+    const context_window = this.get_model_context_window?.();
+    return {
+      model: this.resolveModelOrThrow(),
+      system: await this.systemComposer.resolve(run_context),
+      tools: this.bind_run_scope_to_tools(
+        composed_context.tools,
+        run_context,
+      ),
+      ...(context_window !== undefined ? { context_window } : {}),
+    };
+  }
+
+  /**
+   * 刷新当前 Session step 的 effective Agent 运行视图。
+   */
+  private async refresh_step_runtime(
+    run_context: SessionRunContext,
+  ): Promise<void> {
+    await this.release_step_plugins(run_context);
+    run_context.agentEnv = Object.freeze({ ...this.getEnv() });
+    if (this.get_systems) {
+      run_context.agentSystems = Object.freeze([...this.get_systems()]);
+    } else {
+      delete run_context.agentSystems;
+    }
+    if (this.get_plugins) {
+      run_context.agentPlugins = this.get_plugins().acquire();
+    } else {
+      delete run_context.agentPlugins;
+    }
+  }
+
+  /**
+   * 释放当前 Session step 持有的 Plugin execution lease。
+   */
+  private async release_step_plugins(
+    run_context: SessionRunContext,
+  ): Promise<void> {
+    const plugins = run_context.agentPlugins;
+    if (!plugins) return;
+    delete run_context.agentPlugins;
+    await plugins.release();
+  }
+
   /**
    * 为所有 tool 的 execute callback 绑定 ShellRunScope。
    *
@@ -446,6 +591,9 @@ export class Executor implements SessionExecutor {
               run_context: {
                 ...(session_id ? { session_id } : {}),
                 ...(turn_id ? { turn_id } : {}),
+                ...(run_context.agentEnv
+                  ? { env: run_context.agentEnv }
+                  : {}),
               },
             },
             async () => await original_execute(args, options),
@@ -470,6 +618,12 @@ export class Executor implements SessionExecutor {
       ...(typeof input?.onStepCallback === "function"
         ? { onStepCallback: input.onStepCallback }
         : {}),
+      ...(typeof input?.hasPendingStepInput === "function"
+        ? { hasPendingStepInput: input.hasPendingStepInput }
+        : {}),
+      ...(typeof input?.consume_history_reload === "function"
+        ? { consume_history_reload: input.consume_history_reload }
+        : {}),
       ...(typeof input?.onAssistantStepCallback === "function"
         ? { onAssistantStepCallback: input.onAssistantStepCallback }
         : {}),

package/src/executor/composer/compaction/SessionCompactionComposer.ts

@@ -24,6 +24,11 @@ export type SessionCompactionInput = {
    */
   model: LanguageModel;
 
+  /**
+   * 当前模型支持的总上下文窗口长度，单位为 token。
+   */
+  context_window?: number;
+
   /**
    * 当前轮 system messages。
    */
@@ -42,6 +47,13 @@ export type SessionCompactionInput = {
    * - 回调由上层 Session 负责转成订阅事件与 action record。
    */
   onAction?: (action: SessionActionRecordV1) => Promise<void>;
+
+  /**
+   * 是否明确要求持久化 deep compact。
+   *
+   * 普通模型调用不应因为历史字符数量而触发 compact；仅 usage 反馈或超限恢复会设置此值。
+   */
+  force?: boolean;
 };
 
 /**

package/src/executor/composer/compaction/jsonl/JsonlSessionCompactionComposer.ts

@@ -11,74 +11,23 @@ import type {
   SessionCompactionInput,
 } from "@executor/composer/compaction/SessionCompactionComposer.js";
 
-type JsonlSessionCompactionComposerOptions = {
-  keepLastMessages?: number;
-  maxInputTokensApprox?: number;
-  archiveOnCompact?: boolean;
-  compactRatio?: number;
-};
-
 /**
  * JsonlSessionCompactionComposer 默认实现。
  */
 export class JsonlSessionCompactionComposer implements SessionCompactionComposer {
   readonly name = "summary_compaction_composer";
-  private readonly options: JsonlSessionCompactionComposerOptions;
-
-  constructor(options?: JsonlSessionCompactionComposerOptions) {
-    this.options = options || {};
-  }
-
-  private resolvePolicy(retryCount: number): {
-    keepLastMessages: number;
-    maxInputTokensApprox: number;
-    archiveOnCompact: boolean;
-    compactRatio: number;
-  } {
-    const baseKeepLastMessages =
-      typeof this.options.keepLastMessages === "number"
-        ? Math.max(6, Math.min(5000, Math.floor(this.options.keepLastMessages)))
-        : 30;
-    const baseMaxInputTokensApprox =
-      typeof this.options.maxInputTokensApprox === "number"
-        ? Math.max(2000, Math.min(200_000, Math.floor(this.options.maxInputTokensApprox)))
-        : 128000;
-    const retryFactor = Math.max(1, Math.pow(2, retryCount));
-    const keepLastMessages = Math.max(6, Math.floor(baseKeepLastMessages / retryFactor));
-    const maxInputTokensApprox = Math.max(
-      2000,
-      Math.floor(baseMaxInputTokensApprox / retryFactor),
-    );
-    const archiveOnCompact =
-      this.options.archiveOnCompact === undefined
-        ? true
-        : Boolean(this.options.archiveOnCompact);
-    const compactRatioRaw =
-      typeof this.options.compactRatio === "number" &&
-      Number.isFinite(this.options.compactRatio)
-        ? this.options.compactRatio
-        : 0.5;
-    const compactRatio = Math.max(0.1, Math.min(0.9, compactRatioRaw));
-    return {
-      keepLastMessages,
-      maxInputTokensApprox,
-      archiveOnCompact,
-      compactRatio,
-    };
-  }
 
   async run(input: SessionCompactionInput): Promise<{
     compacted: boolean;
     reason?: string;
   }> {
-    const policy = this.resolvePolicy(input.retryCount);
+    if (!input.force && input.retryCount <= 0) {
+      return { compacted: false, reason: "not_requested" };
+    }
     return await input.historyStore.compact({
       model: input.model,
       system: input.system,
-      keepLastMessages: policy.keepLastMessages,
-      maxInputTokensApprox: policy.maxInputTokensApprox,
-      archiveOnCompact: policy.archiveOnCompact,
-      compactRatio: policy.compactRatio,
+      force: true,
       ...(input.onAction ? { onAction: input.onAction } : {}),
     });
   }

package/src/executor/composer/compaction/jsonl/JsonlSessionCompactionExecutor.ts

@@ -37,10 +37,8 @@ import { format_session_compaction_file_operations } from "@executor/composer/co
 export type SessionCompactParams = {
   model: LanguageModel;
   system: Array<SystemModelMessage>;
-  keepLastMessages: number;
-  maxInputTokensApprox: number;
   archiveOnCompact: boolean;
-  compactRatio: number;
+  force?: boolean;
   onAction?: (action: SessionActionRecordV1) => Promise<void>;
 };
 
@@ -104,29 +102,15 @@ export async function compactSessionMessagesIfNeeded(
         : "";
   });
 
-  if (snapshot.length < 4) {
-    return { compacted: false, reason: "small_messages" };
+  if (snapshot.length === 0) {
+    return { compacted: false, reason: "nothing_to_compact" };
   }
-
-  const systemText = (params.system || [])
-    .map((m) => String(m.content ?? ""))
-    .join("\n\n");
-  // 关键点（中文）：session messages 现在可能包含 tool parts / output，必须把它们计入预算估算，否则会低估 token。
-  let messagesJson = "";
-  try {
-    messagesJson = JSON.stringify(snapshot);
-  } catch {
-    messagesJson = "";
-  }
-  const est = estimateTokensApproxFromText(systemText + "\n\n" + messagesJson);
-  if (est <= params.maxInputTokensApprox) {
-    return { compacted: false, reason: "under_budget" };
+  if (!params.force) {
+    return { compacted: false, reason: "not_requested" };
   }
 
-  // 关键点（中文）：触发 compact 后，优先压缩“最早一段消息”，默认比例 50%。
-  const compactRatio = normalizeCompactRatio(params.compactRatio);
-  const compactCount = resolveCompactCount(snapshot.length, compactRatio);
-  const older = snapshot.slice(0, compactCount);
+  // 关键点（中文）：明确 compact 时归档全部当前模型历史，避免单条巨大 assistant 永远留在 Active。
+  const older = snapshot;
   if (older.length === 0) return { compacted: false, reason: "nothing_to_compact" };
 
   action_started = true;
@@ -215,11 +199,7 @@ export async function compactSessionMessagesIfNeeded(
     const current_model_messages = current.filter(
       is_session_message_record,
     );
-    const currentCompactCount = resolveCompactCount(
-      current_model_messages.length,
-      compactRatio,
-    );
-    const currentOlder = current_model_messages.slice(0, currentCompactCount);
+    const currentOlder = current_model_messages;
     if (currentOlder.length === 0) return;
     const compacted_ids = new Set(
       currentOlder
@@ -271,44 +251,6 @@ export async function compactSessionMessagesIfNeeded(
   return { compacted: true };
 }
 
-/**
- * 归一化压缩比例。
- *
- * 关键点（中文）
- * - 仅允许 0.1~0.9，避免“几乎不压缩”或“几乎全压缩”。
- */
-function normalizeCompactRatio(value: number): number {
-  if (!Number.isFinite(value)) return 0.5;
-  return Math.max(0.1, Math.min(0.9, value));
-}
-
-/**
- * 按比例计算前段压缩条数。
- *
- * 关键点（中文）
- * - 至少压缩 1 条；
- * - 至少保留 1 条未压缩消息。
- */
-function resolveCompactCount(total: number, ratio: number): number {
-  const n = Math.max(0, Math.floor(total));
-  if (n <= 1) return 0;
-  const raw = Math.floor(n * ratio);
-  return Math.max(1, Math.min(n - 1, raw));
-}
-
-/**
- * 近似 token 估算。
- *
- * 算法说明（中文）
- * - 这里使用经验近似，不追求精确 tokenizer 一致性。
- * - 目标是为 compact 提供保守预算，宁可略高估也不要低估。
- */
-function estimateTokensApproxFromText(text: string): number {
-  const t = String(text || "");
-  // 经验值：英文 ~4 chars/token；中文更接近 1-2 chars/token。这里用保守的 3 chars/token。
-  return Math.ceil(t.length / 3);
-}
-
 /**
  * 从 UIMessage 提取可摘要的纯文本。
  *