@downcity/agent 1.1.430 → 1.1.437

package/src/session/messages/SessionMessageCompaction.ts

@@ -1,160 +0,0 @@
-/**
- * SessionMessages Active/Segment 上下文压缩计划生成。
- *
- * 关键点（中文）
- * - 按 Active 中 User/Assistant Message 数量选择最旧的 `floor(n / 2)` 条。
- * - 旧累计 Summary 与选中前缀只执行一次摘要模型调用。
- * - 较新的消息不进入摘要输入；摘要失败时不生成计划、不修改 canonical history。
- * - 成功计划由 SessionMessages 把连续 Active 前缀写入不可变 Segment，并保存累计 Summary。
- */
-
-import type { ModelClient } from "@downcity/type";
-import type { ModelRequestFailureReporter } from "@/types/executor/ModelRequest.js";
-import {
-  build_text_model_messages,
-  generate_model,
-} from "@executor/model/ModelGenerate.js";
-import { generate_id } from "@/utils/Id.js";
-import {
-  build_initial_session_compaction_prompt,
-  build_update_session_compaction_prompt,
-  SESSION_COMPACTION_SYSTEM_PROMPT,
-} from "@executor/composer/compaction/jsonl/JsonlSessionCompactionPrompts.js";
-import type {
-  SessionAssistantMessagePart,
-  SessionMessage,
-  SessionUserMessagePart,
-} from "@downcity/type";
-import type {
-  SessionCompactionPlan,
-} from "@/types/session/SessionComposer.js";
-import type { SessionContextSnapshot } from "@/types/session/SessionSegment.js";
-
-/** 摘要模型的最大输出 token，用于避免 Summary 自身无限增长。 */
-const SUMMARY_MAX_OUTPUT_TOKENS = 4_000;
-
-/**
- * 根据只读 Message 快照生成持久化压缩计划。
- *
- * 该函数可以调用模型生成 Summary，但不会写文件、修改 Recorder 或发布事件。
- */
-export async function compose_session_compaction(input: {
-  /** 当前 Session 标识。 */
-  session_id: string;
-  /** 当前累计 Summary 与 Active Message 快照。 */
-  snapshot: Readonly<SessionContextSnapshot>;
-  /** 生成累计 Summary 使用的模型。 */
-  model: ModelClient;
-  /** 可选的模型请求逐次失败通知入口。 */
-  on_model_request_failure?: ModelRequestFailureReporter;
-}): Promise<SessionCompactionPlan | null> {
-  const context_messages = input.snapshot.messages.filter(
-    (message) => message.type === "user" || message.type === "assistant",
-  );
-  const compact_message_count = Math.floor(context_messages.length / 2);
-  if (compact_message_count <= 0) return null;
-  const compact_messages = context_messages.slice(0, compact_message_count);
-  const boundary = compact_messages.at(-1);
-  if (!boundary) return null;
-
-  const conversation_text = compact_messages
-    .map((message) => message_to_compaction_text(message))
-    .filter(Boolean)
-    .join("\n");
-  if (!conversation_text) {
-    throw new Error("Compaction requires non-empty Message context");
-  }
-  const previous_summary = String(input.snapshot.summary?.text || "").trim();
-  const prompt = previous_summary
-    ? build_update_session_compaction_prompt({
-        previous_summary,
-        new_conversation_text: conversation_text,
-      })
-    : build_initial_session_compaction_prompt({ conversation_text });
-  const result = await generate_model(input.model, {
-    messages: build_text_model_messages(SESSION_COMPACTION_SYSTEM_PROMPT, prompt),
-    max_output_tokens: SUMMARY_MAX_OUTPUT_TOKENS,
-  }, {
-    request_kind: "history_compaction",
-    on_failure: input.on_model_request_failure,
-  });
-  const summary = String(result.text || "").trim();
-  if (!summary) {
-    throw new Error("Compaction model returned an empty Summary");
-  }
-
-  return {
-    through_sequence: boundary.sequence,
-    boundary_message_id: boundary.message_id,
-    summary: {
-      record_type: "summary",
-      session_id: input.session_id,
-      summary_id: `summary:${input.session_id}:${generate_id()}`,
-      through_sequence: boundary.sequence,
-      text: summary,
-      created_at: Date.now(),
-    },
-  };
-}
-
-function message_to_compaction_text(message: SessionMessage): string {
-  if (message.type !== "user" && message.type !== "assistant") return "";
-  const parts = message.parts
-    .map(to_compaction_part)
-    .filter((part) => part !== null);
-  return safe_stringify({
-    role: message.type,
-    parts,
-  });
-}
-
-/** 把 canonical Part 收窄为 Summary 模型需要的稳定会话事实。 */
-function to_compaction_part(
-  part: SessionUserMessagePart | SessionAssistantMessagePart,
-): Record<string, unknown> | null {
-  if (part.type === "text") return { type: "text", text: part.text };
-  if (part.type === "context") {
-    return {
-      type: "context",
-      tag: part.tag,
-      context: part.context,
-    };
-  }
-  if (part.type === "reasoning" || part.type === "interaction") return null;
-  if (part.type === "file") {
-    return {
-      type: "file",
-      media_type: part.media_type,
-      url: part.url,
-      ...(part.filename ? { filename: part.filename } : {}),
-    };
-  }
-  if (part.type === "data") {
-    return {
-      type: "data",
-      data_type: part.data_type,
-      data: part.data,
-      ...(part.data_id ? { data_id: part.data_id } : {}),
-    };
-  }
-  if (part.type === "tool") {
-    return {
-      type: "tool",
-      tool_call_id: part.tool_call_id,
-      tool_name: part.tool_name,
-      state: part.state,
-      ...(part.input !== undefined ? { input: part.input } : {}),
-      ...(part.output !== undefined ? { output: part.output } : {}),
-      ...(part.error ? { error: part.error } : {}),
-    };
-  }
-  return null;
-}
-
-function safe_stringify(value: unknown): string {
-  try {
-    return JSON.stringify(value) || String(value || "");
-  } catch {
-    return String(value || "");
-  }
-}

package/src/session/runtime/SessionCompactOperation.ts

@@ -1,93 +0,0 @@
-/**
- * Session 显式压缩操作生命周期。
- *
- * 该模块只负责把队列 Command 的异步执行映射为公开 Compact Handle；压缩计划、
- * canonical 历史提交与事件发布仍由 Session 领域拥有。
- */
-
-import type {
-  AgentSessionCompactHandle,
-  AgentSessionCompactResult,
-} from "@/types/sdk/AgentSessionCompact.js";
-import type { SessionCompactHistory } from "@/types/session/SessionExecution.js";
-
-/** 创建显式压缩操作所需的领域回调。 */
-export interface CreateSessionCompactOperationOptions {
-  /** 当前显式压缩请求的稳定标识。 */
-  compact_id: string;
-  /** 在 Session Queue 检查点执行统一历史压缩。 */
-  run: () => ReturnType<SessionCompactHistory>;
-  /** 发布最终 Compact Mutation；观测失败不能改变结果。 */
-  publish_finish: (result: AgentSessionCompactResult) => void;
-  /** 尽力记录未被压缩领域入口吸收的异常。 */
-  log_error: (error_message: string) => Promise<void>;
-}
-
-/** 显式压缩操作暴露给 Session Queue 的内部能力。 */
-export interface SessionCompactOperation {
-  /** 立即返回给 SDK 调用方的等待句柄。 */
-  handle: AgentSessionCompactHandle;
-  /** 由排队的 Session Command 调用并负责最终兑现句柄。 */
-  execute: () => Promise<void>;
-}
-
-/** 创建一个与单次 Session Compact Command 绑定的操作生命周期。 */
-export function create_session_compact_operation(
-  options: CreateSessionCompactOperationOptions,
-): SessionCompactOperation {
-  let result: AgentSessionCompactResult | null = null;
-  let resolve_finished!: (value: AgentSessionCompactResult) => void;
-  const finished = new Promise<AgentSessionCompactResult>((resolve) => {
-    resolve_finished = resolve;
-  });
-
-  return {
-    handle: {
-      id: options.compact_id,
-      get result() {
-        return result;
-      },
-      finished,
-    },
-    execute: async () => {
-      let final_result: AgentSessionCompactResult;
-      try {
-        const outcome = await options.run();
-        const reason = outcome.compacted
-          ? "compacted"
-          : outcome.reason === "nothing_to_compact"
-            ? "nothing_to_compact"
-            : "compact_failed";
-        final_result = {
-          compact_id: options.compact_id,
-          success: reason !== "compact_failed",
-          compacted: outcome.compacted,
-          reason,
-          ...(outcome.error ? { error: outcome.error } : {}),
-        };
-      } catch (error) {
-        const error_message = error instanceof Error ? error.message : String(error);
-        final_result = {
-          compact_id: options.compact_id,
-          success: false,
-          compacted: false,
-          reason: "compact_failed",
-          error: error_message,
-        };
-        try {
-          await options.log_error(error_message);
-        } catch {
-          // 关键点（中文）：日志属于观测侧，失败不能阻止 Handle 收口。
-        }
-      }
-
-      result = final_result;
-      try {
-        options.publish_finish(final_result);
-      } catch {
-        // 关键点（中文）：事件发布失败不能让已完成的 Command 反向失败。
-      }
-      resolve_finished(final_result);
-    },
-  };
-}

package/src/session/runtime/SessionHistoryCompaction.ts

@@ -1,45 +0,0 @@
-/**
- * Session 历史压缩结果收口器。
- *
- * Session 仍提供 Composer 输入和 canonical 提交回调；本模块统一成功、空计划、
- * 失败与 best-effort 日志的结果映射，供显式压缩和自动恢复共同复用。
- */
-
-import type { SessionCompactionPlan } from "@/types/session/SessionComposer.js";
-import type { SessionCompactHistory } from "@/types/session/SessionExecution.js";
-
-/** 执行一次历史压缩所需的 Session 领域回调。 */
-export interface RunSessionHistoryCompactionOptions {
-  /** 当前压缩所属 Turn；空值表示显式队列命令尚未进入 Turn。 */
-  turn_id?: string;
-  /** 让 Composer 基于只读 Session 快照生成压缩计划。 */
-  create_plan: () => Promise<SessionCompactionPlan | null>;
-  /** 原子提交 Composer 返回的 canonical 压缩计划。 */
-  commit_plan: (plan: SessionCompactionPlan) => Promise<void>;
-  /** 尽力记录压缩错误，不得覆盖领域结果。 */
-  log_error: (error_message: string) => Promise<void>;
-}
-
-/** 执行并收口一次统一 Session 历史压缩。 */
-export async function run_session_history_compaction(
-  options: RunSessionHistoryCompactionOptions,
-): ReturnType<SessionCompactHistory> {
-  try {
-    const plan = await options.create_plan();
-    if (!plan) return { compacted: false, reason: "nothing_to_compact" };
-    await options.commit_plan(plan);
-    return { compacted: true };
-  } catch (error) {
-    const error_message = error instanceof Error ? error.message : String(error);
-    try {
-      await options.log_error(error_message);
-    } catch {
-      // 关键点（中文）：日志失败不能覆盖稳定的压缩领域结果。
-    }
-    return {
-      compacted: false,
-      reason: "compact_failed",
-      error: error_message,
-    };
-  }
-}