@downcity/agent 1.1.430 → 1.1.438

package/src/executor/Executor.ts

@@ -11,23 +11,15 @@ import type {
   ModelClient,
   RuntimeTool as Tool,
   RuntimeToolExecutionOptions as ToolExecutionOptions,
+  SessionHookRuntime,
 } from "@downcity/type";
 import { CoreEngineRunner } from "@executor/core-engine/CoreEngineRunner.js";
 import { ExecutorRecoveryPolicy } from "@executor/services/ExecutorRecoveryPolicy.js";
 import type { Logger } from "@/utils/logger/Logger.js";
-import type {
-  SessionCompactHistory,
-  SessionExecutor,
-} from "@/types/session/SessionExecution.js";
+import type { SessionExecutor } from "@/types/session/SessionExecution.js";
 import type { SessionTurnContext } from "@/types/executor/SessionTurnContext.js";
 import type { SessionToolExecutionContext } from "@/types/executor/SessionToolExecutionContext.js";
-import type { SessionHookRuntime } from "@downcity/type";
 import { is_action_result } from "@/types/action/ActionResult.js";
-import { generate_id } from "@/utils/Id.js";
-import {
-  normalize_session_context_content,
-  normalize_session_context_tag,
-} from "@/session/messages/SessionUserContext.js";
 import type {
   SessionStepExecutionInput,
   SessionTurnExecutionResult,
@@ -37,6 +29,7 @@ import type {
   SessionComposeInput,
   SessionStepInput,
 } from "@/types/session/SessionComposer.js";
+import type { SessionContextRecoveryReason } from "@/types/session/SessionContextPolicy.js";
 
 type ExecutorOptions = {
   /**
@@ -49,21 +42,16 @@ type ExecutorOptions = {
 
   /** 为 Composer 创建当前 Step 的只读输入快照。 */
   get_compose_input: (
-    turn_context: SessionTurnContext | undefined,
+    turn_context: SessionTurnContext,
     retry_count: number,
   ) => Promise<SessionComposeInput>;
 
+  /** 请求当前 Composer 推进派生上下文状态。 */
+  recover_context: (reason: SessionContextRecoveryReason) => Promise<boolean>;
+
   /** 应用 Session 级固定 system snapshot。 */
   apply_system_snapshot?: (input: SessionStepInput) => SessionStepInput;
 
-  /** 请求 Session 领域生成并提交 canonical 历史压缩。 */
-  compact_history: SessionCompactHistory;
-
-  /**
-   * 读取当前 session 使用的模型实例。
-   */
-  get_model: () => ModelClient | undefined;
-
   /**
    * 统一日志器。
    */
@@ -84,9 +72,8 @@ export class Executor implements SessionExecutor {
 
   private readonly composer: SessionComposer;
   private readonly get_compose_input: ExecutorOptions["get_compose_input"];
+  private readonly recover_context: ExecutorOptions["recover_context"];
   private readonly apply_system_snapshot?: ExecutorOptions["apply_system_snapshot"];
-  private readonly compact_history: ExecutorOptions["compact_history"];
-  private readonly get_model: ExecutorOptions["get_model"];
   private readonly get_hooks: ExecutorOptions["get_hooks"];
   private readonly logger: Logger;
   private readonly recovery_policy: ExecutorRecoveryPolicy;
@@ -103,21 +90,23 @@ export class Executor implements SessionExecutor {
     this.session_id = session_id;
     this.composer = options.composer;
     this.get_compose_input = options.get_compose_input;
+    this.recover_context = options.recover_context;
     this.apply_system_snapshot = options.apply_system_snapshot;
-    this.compact_history = options.compact_history;
-    this.get_model = options.get_model;
     this.get_hooks = options.get_hooks;
     this.logger = options.logger;
     this.recovery_policy = new ExecutorRecoveryPolicy({
       session_id: this.session_id,
-      should_compact: (error) => this.composer.should_compact(error),
+      recover_context: async (error) =>
+        is_provider_context_limit_error(error)
+          ? await this.recover_context("provider_context_limit")
+          : false,
       logger: this.logger,
     });
     this.core_engine_runner = new CoreEngineRunner({
       session_id: this.session_id,
       logger: this.logger,
       should_compact_on_error: (error) =>
-        this.composer.should_compact(error),
+        is_provider_context_limit_error(error),
     });
   }
 
@@ -136,7 +125,6 @@ export class Executor implements SessionExecutor {
    * - scope 绑定、assistant step 持久化、executing 状态都收在实例内部。
    */
   async execute(params: {
-    query: string;
     turn_context: SessionTurnContext;
   }): Promise<SessionTurnExecutionResult> {
     if (this.executing) {
@@ -144,125 +132,46 @@ export class Executor implements SessionExecutor {
       // 否则 step 回调、scope 与执行器状态都会互相污染。
       throw new Error("Executor.execute does not support concurrent execution");
     }
-    const query = String(params.query || "").trim();
     const turn_context = params.turn_context;
     this.executing = true;
-    this.recovery_policy.reset_execution_state();
     try {
       const result = await this.recovery_policy.execute_with_retry({
-        query,
-        model: this.resolve_model_or_throw(),
-        turn_context,
-        prepare_execute_input: async ({
-          query: next_query,
-          model,
-          turn_context: next_turn_context,
-          retry_count,
-        }) =>
-          await this.prepare_execute_input(
-            next_query,
-            model,
-            next_turn_context,
-            retry_count,
-          ),
-        execute_prepared_input: async ({
-          execute_input,
-          model,
-          turn_context: next_turn_context,
-        }) =>
-          await this.execute_prepared_input(
-            execute_input,
-            model,
-            next_turn_context,
-          ),
+        execute_turn: async (retry_count) =>
+          await this.core_engine_runner.execute({
+            turn_context,
+            resolve_step_input: async () =>
+              await this.resolve_step_input(turn_context, retry_count),
+          }),
       });
       return result;
     } finally {
-      this.recovery_policy.reset_execution_state();
       this.executing = false;
     }
   }
 
   /**
-   * 调用 Composer 组装当前轮执行输入。
-   */
-  private async prepare_execute_input(
-    query: string,
-    _model: ModelClient,
-    turn_context: SessionTurnContext,
-    retry_count: number,
-  ): Promise<SessionStepExecutionInput> {
-    if (retry_count > 0) {
-      await this.logger.log("info", "[agent] compacting", {
-        retryCount: retry_count,
-      });
-      await this.compact_history({
-        turn_id: turn_context.session.turn_id,
-      });
-    }
-    const step = await this.compose_step(turn_context, retry_count, true);
-    return {
-      query,
-      system: step.input.system,
-      messages: step.input.messages,
-      ...(step.compose_input.history.summary?.summary_id
-        ? { history_summary_id: step.compose_input.history.summary.summary_id }
-        : {}),
-      tools: step.input.tools,
-    };
-  }
-
-  /**
-   * 执行一次已装配完成的 Step 输入。
-   */
-  private async execute_prepared_input(
-    input: SessionStepExecutionInput,
-    model: ModelClient,
-    turn_context: SessionTurnContext,
-  ): Promise<SessionTurnExecutionResult> {
-    return await this.core_engine_runner.execute({
-      execute_input: input,
-      model,
-      turn_context,
-      resolve_step_inputs: async () =>
-        await this.resolve_step_inputs(turn_context),
-      reload_history: async () => {
-        const step = await this.compose_step(turn_context, 0, false);
-        return {
-          messages: step.input.messages,
-          ...(step.compose_input.history.summary?.summary_id
-            ? { summary_id: step.compose_input.history.summary.summary_id }
-            : {}),
-        };
-      },
-    });
-  }
-
-  /**
-   * 解析下一 Session step 实际使用的运行配置。
+   * 为下一 Provider Step 生成唯一一份完整输入。
    *
    * 关键点（中文）
    * - 调用方必须先提交 Session 统一输入队列，再调用本方法。
    * - 每次调用只读取一次 model、system 与 tools，并把它们传给同一个模型 step。
    */
-  private async resolve_step_inputs(turn_context: SessionTurnContext): Promise<{
-    model: ModelClient;
-    system: SessionStepExecutionInput["system"];
-    tools: SessionStepExecutionInput["tools"];
-    context_window?: number;
-  }> {
-    const composed = await this.compose_step(turn_context, 0, true);
+  private async resolve_step_input(
+    turn_context: SessionTurnContext,
+    retry_count: number,
+  ): Promise<SessionStepExecutionInput> {
+    const composed = await this.compose_step(turn_context, retry_count);
     return {
       model: composed.model,
       system: composed.input.system,
+      messages: composed.input.messages,
       tools: this.bind_turn_context_to_tools(
         composed.input.tools,
         turn_context,
       ),
-      ...(composed.compose_input.state.model_context_window !== undefined
+      ...(composed.context_window !== undefined
         ? {
-            context_window:
-              composed.compose_input.state.model_context_window,
+            context_window: composed.context_window,
           }
         : {}),
     };
@@ -270,32 +179,33 @@ export class Executor implements SessionExecutor {
 
   /** 读取只读 Session 快照并交给统一 Composer。 */
   private async compose_step(
-    turn_context: SessionTurnContext | undefined,
+    turn_context: SessionTurnContext,
     retry_count: number,
-    refresh_plugins: boolean,
   ): Promise<{
-    compose_input: SessionComposeInput;
     input: SessionStepInput;
     model: ModelClient;
+    context_window?: number;
   }> {
-    if (refresh_plugins && turn_context) await this.refresh_step_runtime(turn_context);
+    await this.refresh_step_runtime(turn_context);
     const compose_input = await this.get_compose_input(
       turn_context,
       retry_count,
     );
     const model = compose_input.state.model;
     if (!model) throw new Error("requires a configured model.");
-    turn_context?.step.commit({
+    turn_context.step.commit({
       workspace_env: compose_input.state.env,
       agent_systems: compose_input.state.systems,
     });
     const raw_input = await this.composer.compose(compose_input);
     return {
-      compose_input,
       input: this.apply_system_snapshot
         ? this.apply_system_snapshot(raw_input)
         : raw_input,
       model,
+      ...(compose_input.state.model_context_window !== undefined
+        ? { context_window: compose_input.state.model_context_window }
+        : {}),
     };
   }
 
@@ -384,57 +294,11 @@ export class Executor implements SessionExecutor {
             turn_context.effects.append(output.effects);
           }
           for (const message of output.messages) {
-            if (message.role === "assistant") {
+            if (message.role === "agent") {
               turn_context.output.enqueue_assistant_parts(message.parts);
               continue;
             }
-            const now = Date.now();
-            turn_context.input.inject_user_message({
-              message_id: `runtime-user:${turn_context.session.session_id}:${generate_id()}`,
-              session_id: turn_context.session.session_id,
-              turn_id: turn_context.session.turn_id,
-              sequence: 0,
-              revision: 1,
-              visibility: "internal",
-              created_at: now,
-              updated_at: now,
-              type: "user",
-              input_type: "steer",
-              parts: message.parts.map((part, index) => {
-                if (part.type === "text") {
-                  return {
-                    part_id: `runtime-text:${index + 1}`,
-                    type: "text" as const,
-                    text: part.text,
-                    state: "done" as const,
-                  };
-                }
-                if (part.type === "context") {
-                  return {
-                    part_id: `runtime-context:${index + 1}`,
-                    type: "context" as const,
-                    tag: normalize_session_context_tag(part.tag),
-                    context: normalize_session_context_content(part.context),
-                  };
-                }
-                if (part.type === "file") {
-                  return {
-                    part_id: `runtime-file:${index + 1}`,
-                    type: "file" as const,
-                    media_type: part.media_type,
-                    url: part.url,
-                    ...(part.filename ? { filename: part.filename } : {}),
-                  };
-                }
-                return {
-                  part_id: `runtime-data:${index + 1}`,
-                  type: "data" as const,
-                  data_type: part.data_type,
-                  data: part.data,
-                  ...(part.data_id ? { data_id: part.data_id } : {}),
-                };
-              }),
-            });
+            await turn_context.input.append_internal(message.parts);
           }
           return output.output;
         },
@@ -443,14 +307,13 @@ export class Executor implements SessionExecutor {
     return wrapped;
   }
 
-  /**
-   * 读取当前 session 模型。
-   */
-  private resolve_model_or_throw(): ModelClient {
-    const model = this.get_model();
-    if (!model) {
-      throw new Error("requires a configured model.");
-    }
-    return model;
-  }
+}
+
+/** Core Engine 的单 Step 内恢复仍需同步识别 Provider 上下文错误。 */
+function is_provider_context_limit_error(error: unknown): boolean {
+  const message = String(error ?? "").toLowerCase();
+  return message.includes("context_length") ||
+    message.includes("too long") ||
+    message.includes("maximum context") ||
+    message.includes("context window");
 }

package/src/executor/README.md

@@ -11,7 +11,7 @@
 - `SessionComposer` 根据只读 Session 快照组装 system、messages 和 tools。
 - `Executor` 管理一次 Turn 的输入装配、上下文超限恢复和 Step Plugin Lease；它只对外提供 `execute()`。
 - `ModelRequestRunner` 唯一拥有普通模型请求的五次重试、退避和逐次失败通知。
-- `CoreEngineRunner` 执行 Tool Loop、续写和内存上下文折叠，不维护普通请求重试状态。
+- `CoreEngineRunner` 执行 Tool Loop、续写和真实 usage 观测，不自行改写模型历史，也不维护普通请求重试状态。
 - `SessionMessages` 是 Message 唯一事实源；Executor 不写文件、不持有 Store。
 
 ## 执行关系
@@ -55,29 +55,28 @@ Session.prompt()
 | 旧能力 | 当前归属 |
 | --- | --- |
 | `SystemComposer` | `DefaultSessionComposer.compose()` + `SessionSystem` |
-| `HistoryComposer` | `SessionMessages.context_snapshot()` + `SessionModelMessages` |
+| `HistoryComposer` | `SessionComposer` + `SessionContextPolicy` + `SessionModelMessages` |
 | `ContextComposer` 的 tools | `Session.create_compose_input()` + `SessionComposer.compose()` |
 | `ContextComposer` 的 Step Callback | `SessionLoop` + `CoreEngineRunner` |
 | `ContextComposer` 的 fallback Assistant | `CoreEngineRunner` + `ExecutorRecoveryPolicy` |
-| `CompactionComposer` | `SessionComposer.compact()` + `should_compact()`，由 Session 提交计划 |
+| `CompactionComposer` | `SessionComposer.recover_context()` + Context Policy 派生表 |
 
-统一 Composer 只回答两个策略问题：
+统一 Composer 只回答一个策略问题：
 
-1. 当前 Step 的 system、messages 和 tools 是什么？
-2. 当前只读 Message 快照应生成什么压缩计划？
+1. 当前 Step 的 system、messages 和 tools 是什么？上下文超限时是否能由当前 Policy 推进派生状态？
 
-Queue 消费、Turn 控制、Message 写入、Mutation 发布和 Segment 提交都不是 Composer 职责。
+Queue 消费、Turn 控制、Message 写入和 Mutation 发布都不是 Composer 职责。
 
-## Compaction
+## Context recovery
 
 ```text
-SessionComposer.compact(readonly snapshot)
-  -> SessionCompactionPlan
-  -> Session.commit_compaction_plan()
-  -> SessionMessages.compact_active()
+SessionLoop / CoreEngine
+  -> SessionComposer.recover_context()
+  -> SessionContextPolicy 写入自己的派生表
+  -> Composer 下一次 compose() 读取最新派生上下文
 ```
 
-Composer 可以调用模型生成 Summary，但不能修改 Message、Metadata 或发布事件。持久化提交始终由 Session 领域完成。
+Composer 可以调用模型生成 Summary，但不能修改 canonical Message、Metadata 或发布事件。持久化提交始终由 `SessionStorage` 事务完成。
 
 ## 目录
 

package/src/executor/composer/system/default/SystemPromptAssets.ts

@@ -7,14 +7,8 @@
  */
 
 import coreSystemPromptText from "@executor/composer/system/default/assets/core.prompt.js";
-import taskSystemPromptText from "@executor/composer/system/default/assets/task.prompt.js";
 
 /**
  * 默认 core system prompt。
  */
 export const CORE_SYSTEM_PROMPT = coreSystemPromptText.trim();
-
-/**
- * task 模式专用 system prompt。
- */
-export const TASK_SYSTEM_PROMPT = taskSystemPromptText.trim();

package/src/executor/core-engine/CoreEngineContextCompaction.ts

@@ -1,21 +1,12 @@
 /**
  * CoreEngine Downcity 模型上下文压缩模块。
  *
- * 压缩基于标准 ModelMessage，保留 system、最新 user 及其后的完整工具事务。
+ * 本模块只判断真实 Provider usage 是否达到恢复阈值；具体选择、摘要和持久化全部
+ * 归属于 SessionComposer 的 Context Policy。
  */
 
-import type { ModelContent, ModelMessage } from "@downcity/type";
-
 /** usage 达到模型上下文窗口 95% 时安排下一 step 压缩。 */
 export const MODEL_CONTEXT_COMPACTION_TRIGGER_RATIO = 0.95;
-/** 压缩后的真实 usage 需要回落到模型上下文窗口 50% 以内。 */
-export const MODEL_CONTEXT_COMPACTION_TARGET_RATIO = 0.5;
-/** 历史 checkpoint 的基础最大字符数。 */
-const INITIAL_HISTORY_CHECKPOINT_CHARS = 24_000;
-/** 单条保留消息的基础字符预算。 */
-const INITIAL_RETAINED_MESSAGE_CHARS = 16_000;
-/** 折叠后至少保留的字符数。 */
-const MIN_FOLDED_PART_CHARS = 64;
 
 /** 读取 Provider usage 中的实际总 token。 */
 export function resolve_model_usage_tokens(usage: unknown): number | null {
@@ -42,132 +33,9 @@ export function resolve_model_usage_ratio(
 /** 判断一次真实 usage 是否要求下一 step 继续压缩。 */
 export function should_compact_after_usage(
   usage_ratio: number | null,
-  validating_compaction: boolean,
 ): boolean {
   if (usage_ratio === null || !Number.isFinite(usage_ratio)) return false;
-  return validating_compaction
-    ? usage_ratio > MODEL_CONTEXT_COMPACTION_TARGET_RATIO
-    : usage_ratio >= MODEL_CONTEXT_COMPACTION_TRIGGER_RATIO;
-}
-
-/** 对当前模型消息做一次确定性深度压缩。 */
-export function deep_compact_model_messages(
-  messages: ModelMessage[],
-  compact_depth = 0,
-): ModelMessage[] {
-  if (!Array.isArray(messages) || messages.length === 0) return [];
-  const depth = Math.max(0, Math.min(8, Math.floor(compact_depth)));
-  const last_user_index = find_last_user_index(messages);
-  if (depth === 0) {
-    const limit = resolve_depth_budget(INITIAL_RETAINED_MESSAGE_CHARS, depth);
-    return messages.flatMap((message, index) => {
-      const compacted = compact_message(message, limit, index >= last_user_index);
-      return compacted ? [compacted] : [];
-    });
-  }
-  const system_messages = messages.filter((message) => message.role === "system");
-  const retained_start = last_user_index >= 0 ? last_user_index : Math.max(0, messages.length - 2);
-  const history = messages.filter((message, index) => message.role !== "system" && index < retained_start);
-  const retained = messages.filter((message, index) => message.role !== "system" && index >= retained_start);
-  const checkpoint = build_checkpoint(
-    history,
-    resolve_depth_budget(INITIAL_HISTORY_CHECKPOINT_CHARS, depth),
-  );
-  const limit = resolve_depth_budget(INITIAL_RETAINED_MESSAGE_CHARS, depth);
-  return [
-    ...system_messages.flatMap((message) => {
-      const compacted = compact_message(message, limit, false);
-      return compacted ? [compacted] : [];
-    }),
-    ...(checkpoint ? [{ role: "assistant", content: [{ type: "text", text: checkpoint }] } as ModelMessage] : []),
-    ...retained.flatMap((message) => {
-      const compacted = compact_message(message, limit, true);
-      return compacted ? [compacted] : [];
-    }),
-  ];
-}
-
-/** 对文本做确定性的 head/tail 折叠。 */
-export function fold_compacted_text(text: string, max_chars: number): string {
-  const value = String(text || "");
-  const limit = Math.max(MIN_FOLDED_PART_CHARS, Math.floor(max_chars));
-  if (value.length <= limit) return value;
-  const marker = `\n...[compacted ${String(value.length - limit)} chars]...\n`;
-  const available = Math.max(0, limit - marker.length);
-  const head = Math.ceil(available / 2);
-  return `${value.slice(0, head)}${marker}${value.slice(-(available - head))}`;
-}
-
-/** 压缩单条消息中的高体积内容。 */
-function compact_message(
-  message: ModelMessage,
-  max_chars: number,
-  keep_tools: boolean,
-): ModelMessage | undefined {
-  const part_limit = Math.max(MIN_FOLDED_PART_CHARS, Math.floor(max_chars / Math.max(1, message.content.length)));
-  const content = message.content.flatMap<ModelContent>((part) => {
-      // 推理过程不属于压缩后仍需保留的稳定事实。
-      if (part.type === "reasoning") return [];
-      if (part.type === "text") {
-        return [{ ...part, text: fold_compacted_text(part.text, part_limit) }];
-      }
-      if (part.type === "tool_call" && !keep_tools) return [];
-      if (part.type === "tool_result") {
-        if (!keep_tools) return [];
-        return [{
-          ...part,
-          content: part.content.map((result_part) => {
-            if (result_part.type === "text") {
-              return {
-                ...result_part,
-                text: fold_compacted_text(result_part.text, part_limit),
-              };
-            }
-            if (result_part.type !== "json") return result_part;
-            const serialized = JSON.stringify(result_part.value);
-            if (serialized.length <= part_limit) return result_part;
-            return {
-              type: "json" as const,
-              value: {
-                compacted: true,
-                preview: fold_compacted_text(serialized, part_limit),
-              },
-            };
-          }),
-        }];
-      }
-      return [part];
-    });
-  if (content.length === 0) return undefined;
-  return { ...message, content };
-}
-
-/** 生成历史 checkpoint 文本。 */
-function build_checkpoint(messages: ModelMessage[], max_chars: number): string {
-  const text = messages.map((message) => {
-    const content = message.content.map((part) => {
-      if (part.type === "text") return part.text;
-      if (part.type === "reasoning") return "";
-      if (part.type === "file") return `[file ${part.media_type}${part.filename ? ` ${part.filename}` : ""}]`;
-      if (part.type === "tool_call") return `[tool_call ${part.tool_name}]`;
-      return `[tool_result ${part.tool_name} ${part.outcome}]`;
-    }).join("\n");
-    return `${message.role}: ${content}`;
-  }).join("\n\n");
-  return text ? `Earlier conversation checkpoint:\n${fold_compacted_text(text, max_chars)}` : "";
-}
-
-/** 查找最新用户消息索引。 */
-function find_last_user_index(messages: ModelMessage[]): number {
-  for (let index = messages.length - 1; index >= 0; index -= 1) {
-    if (messages[index]?.role === "user") return index;
-  }
-  return -1;
-}
-
-/** 按压缩深度计算当前字符预算。 */
-function resolve_depth_budget(initial_budget: number, depth: number): number {
-  return Math.max(MIN_FOLDED_PART_CHARS, Math.floor(initial_budget / (2 ** depth)));
+  return usage_ratio >= MODEL_CONTEXT_COMPACTION_TRIGGER_RATIO;
 }
 
 /** 读取非负数字。 */