@downcity/agent 1.1.338 → 1.1.400

package/src/session/messages/SessionJsonValue.ts

@@ -6,7 +6,6 @@
  */
 
 import type { JsonObject, JsonValue } from "@/types/common/Json.js";
-import type { SessionProviderMetadata } from "@/types/session/SessionMessage.js";
 
 /** 把任意运行时输入转换为可持久化的 JSON 值。 */
 export function to_session_json_value(input: unknown): JsonValue {
@@ -36,28 +35,6 @@ export function to_session_json_object(input: unknown): JsonObject | undefined {
   }
 }
 
-/**
- * 把 AI SDK Provider metadata 规整为可持久化快照。
- *
- * 关键点（中文）
- * - ProviderMetadata 顶层是 provider ID 到 JSON 对象的映射。
- * - 新 metadata 代表完整快照，不在这里猜测 Provider 的字段合并语义。
- * - 非法 metadata 返回 undefined，由调用方保留已经持久化的旧快照。
- */
-export function to_session_provider_metadata(
-  input: unknown,
-): SessionProviderMetadata | undefined {
-  if (!is_plain_object(input)) return undefined;
-  try {
-    const value = JSON.parse(JSON.stringify(input)) as unknown;
-    if (!is_plain_object(value)) return undefined;
-    if (!Object.values(value).every(is_plain_object)) return undefined;
-    return value as SessionProviderMetadata;
-  } catch {
-    return undefined;
-  }
-}
-
 /** 判断未知值是否为普通对象。 */
 function is_plain_object(input: unknown): input is Record<string, unknown> {
   if (!input || typeof input !== "object" || Array.isArray(input)) return false;

package/src/session/messages/SessionMessageCompaction.ts

@@ -1,33 +1,34 @@
 /**
  * SessionMessages Active/Segment 上下文压缩计划生成。
  *
- * Compact 把 Active 前缀写入不可变 Segment，并在 footer 保存累计 Summary。
+ * 关键点（中文）
+ * - 按 Active 中 User/Assistant Message 数量选择最旧的 `floor(n / 2)` 条。
+ * - 旧累计 Summary 与选中前缀只执行一次摘要模型调用。
+ * - 较新的消息不进入摘要输入；摘要失败时不生成计划、不修改 canonical history。
+ * - 成功计划由 SessionMessages 把连续 Active 前缀写入不可变 Segment，并保存累计 Summary。
  */
 
-import { generateText, type LanguageModel } from "ai";
+import type { ModelClient } from "@downcity/type";
+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 { fold_compacted_text } from "@executor/core-engine/CoreEngineContextCompaction.js";
-import { to_executor_ui_message } from "@/session/messages/SessionMessageCodec.js";
-import type { SessionMessage } from "@/types/session/SessionMessage.js";
+import type {
+  SessionAssistantMessagePart,
+  SessionMessage,
+  SessionUserMessagePart,
+} from "@/types/session/SessionMessage.js";
 import type {
   SessionCompactionPlan,
 } from "@/types/session/SessionComposer.js";
 import type { SessionContextSnapshot } from "@/types/session/SessionSegment.js";
 
-/** 单次摘要请求中 conversation 文本的最大字符数。 */
-const SUMMARY_CHUNK_MAX_CHARS = 20_000;
-
-/** 单条 canonical Message 投影到摘要输入后的最大字符数。 */
-const SUMMARY_MESSAGE_MAX_CHARS = 12_000;
-
-/** 上一轮累计 Summary 进入下一次 reduce 请求时的最大字符数。 */
-const PREVIOUS_SUMMARY_MAX_CHARS = 12_000;
-
 /** 摘要模型的最大输出 token，用于避免 Summary 自身无限增长。 */
 const SUMMARY_MAX_OUTPUT_TOKENS = 4_000;
 
@@ -42,56 +43,43 @@ export async function compose_session_compaction(input: {
   /** 当前累计 Summary 与 Active Message 快照。 */
   snapshot: Readonly<SessionContextSnapshot>;
   /** 生成累计 Summary 使用的模型。 */
-  model: LanguageModel;
+  model: ModelClient;
 }): Promise<SessionCompactionPlan | null> {
   const context_messages = input.snapshot.messages.filter(
     (message) => message.type === "user" || message.type === "assistant",
   );
-  const boundary = context_messages.at(-1);
+  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_messages = context_messages
+  const conversation_text = compact_messages
     .map((message) => message_to_compaction_text(message))
-    .filter(Boolean);
-  const chunks = build_summary_chunks(conversation_messages);
-  let summary = String(input.snapshot.summary?.text || "").trim();
-  let used_fallback = false;
-  for (const chunk of chunks) {
-    const prompt = summary
-      ? build_update_session_compaction_prompt({
-          previous_summary: fold_compacted_text(
-            summary,
-            PREVIOUS_SUMMARY_MAX_CHARS,
-          ),
-          new_conversation_text: chunk || "(none)",
-        })
-      : build_initial_session_compaction_prompt({
-          conversation_text: chunk || "(none)",
-        });
-    try {
-      const result = await generateText({
-        model: input.model,
-        system: [{ role: "system", content: SESSION_COMPACTION_SYSTEM_PROMPT }],
-        prompt,
-        maxOutputTokens: SUMMARY_MAX_OUTPUT_TOKENS,
-      });
-      const next_summary = String(result.text || "").trim();
-      if (!next_summary) throw new Error("Compaction model returned an empty Summary");
-      summary = next_summary;
-    } catch {
-      used_fallback = true;
-      summary = build_deterministic_summary(summary, chunk);
-    }
+    .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,
+  });
+  const summary = String(result.text || "").trim();
   if (!summary) {
-    used_fallback = true;
-    summary = build_deterministic_summary("", "(no textual context)");
+    throw new Error("Compaction model returned an empty Summary");
   }
 
   return {
     through_sequence: boundary.sequence,
     boundary_message_id: boundary.message_id,
-    used_fallback,
     summary: {
       record_type: "summary",
       session_id: input.session_id,
@@ -104,63 +92,50 @@ export async function compose_session_compaction(input: {
 }
 
 function message_to_compaction_text(message: SessionMessage): string {
-  const projected = to_executor_ui_message(message);
-  if (!projected) return "";
-  const parts = projected.parts
-    .filter((part) => part.type !== "reasoning")
-    .map((part) => {
-      const serialized = safe_stringify(part);
-      return serialized.length <= SUMMARY_MESSAGE_MAX_CHARS
-        ? part
-        : {
-            type: part.type,
-            compacted_preview: fold_compacted_text(
-              serialized,
-              SUMMARY_MESSAGE_MAX_CHARS,
-            ),
-          };
-    });
-  return fold_compacted_text(safe_stringify({
-    role: projected.role,
+  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,
-  }), SUMMARY_MESSAGE_MAX_CHARS);
+  });
 }
 
-/** 按 Message 边界把摘要输入拆为固定字符上限的 chunk。 */
-function build_summary_chunks(messages: string[]): string[] {
-  const chunks: string[] = [];
-  let current = "";
-  for (const message of messages) {
-    const value = fold_compacted_text(message, SUMMARY_CHUNK_MAX_CHARS);
-    const candidate = current ? `${current}\n${value}` : value;
-    if (current && candidate.length > SUMMARY_CHUNK_MAX_CHARS) {
-      chunks.push(current);
-      current = value;
-      continue;
-    }
-    current = candidate;
+/** 把 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 === "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 (current) chunks.push(current);
-  return chunks;
-}
-
-/** 摘要模型不可用时仍可完成归档的确定性 checkpoint。 */
-function build_deterministic_summary(
-  previous_summary: string,
-  new_context: string,
-): string {
-  const body = [
-    String(previous_summary || "").trim(),
-    String(new_context || "").trim(),
-  ]
-    .filter(Boolean)
-    .join("\n\n");
-  return [
-    "## Compacted Context",
-    "The summary model was unavailable. The following deterministic checkpoint preserves the beginning and latest context.",
-    "",
-    fold_compacted_text(body || "(none)", PREVIOUS_SUMMARY_MAX_CHARS),
-  ].join("\n");
+  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 {

package/src/session/messages/SessionMessageInteractionWriter.ts

@@ -63,8 +63,9 @@ export class SessionMessageInteractionWriter {
   async request(
     request: SessionInteractionRequest,
   ): Promise<SessionAssistantInteractionPart> {
-    const message_id = request.source.type === "tool"
-      ? this.require_streaming_tool(request.source.tool_call_id).message_id
+    const tool_call_id = request.source.tool_call_id;
+    const message_id = tool_call_id
+      ? this.require_streaming_tool(tool_call_id).message_id
       : this.require_streaming_assistant().message_id;
     await this.options.enqueue_assistant_write(message_id, async () => {
       const current = this.require_streaming_assistant(message_id);
@@ -79,23 +80,19 @@ export class SessionMessageInteractionWriter {
       }
 
       let parts = current.parts;
-      if (request.source.type === "tool") {
-        const tool = this.require_streaming_tool(request.source.tool_call_id);
+      if (tool_call_id) {
+        const tool = this.require_streaming_tool(tool_call_id);
         if (tool.message_id !== message_id) {
           throw new Error(
-            `Tool Assistant Message changed: ${request.source.tool_call_id}`,
+            `Tool Assistant Message changed: ${tool_call_id}`,
           );
         }
-        const native_tool_approval =
-          request.kind === "approval" &&
-          request.operation === "tool" &&
-          tool.part.state === "waiting-user";
-        if (tool.part.state !== "ready" && !native_tool_approval) {
+        if (tool.part.state !== "ready" && tool.part.state !== "waiting-user") {
           throw new Error(
-            `Tool Interaction requires ready input: ${request.source.tool_call_id} (${tool.part.state})`,
+            `Tool Interaction requires ready input: ${tool_call_id} (${tool.part.state})`,
           );
         }
-        if (!native_tool_approval) {
+        if (tool.part.state === "ready") {
           parts = parts.map((part) =>
             part.part_id === tool.part.part_id
               ? { ...tool.part, state: "waiting-user" as const }
@@ -112,7 +109,7 @@ export class SessionMessageInteractionWriter {
         ),
         type: "interaction",
         interaction_id: request.interaction_id,
-        interaction_type: request.kind,
+        interaction_type: request.type,
         status: "pending",
         request: structuredClone(request),
       };
@@ -133,30 +130,32 @@ export class SessionMessageInteractionWriter {
       if (interaction.message_id !== message_id) {
         throw new Error(`Session Interaction Message changed: ${interaction_id}`);
       }
-      if (interaction.part.interaction_type !== response.kind) {
-        throw new Error(`Session Interaction response kind mismatch: ${interaction_id}`);
+      if (interaction.part.interaction_type !== response.type) {
+        throw new Error(`Session Interaction response type mismatch: ${interaction_id}`);
       }
-      const denied = response.kind === "approval" && response.decision === "denied";
+      const tool_call_id = interaction.part.request.source.tool_call_id;
       const parts = current.parts.map((part) => {
         if (part.part_id === interaction.part.part_id) {
           return {
             ...interaction.part,
-            status: "resolved" as const,
+            status: response.outcome === "denied"
+              ? "denied" as const
+              : "resolved" as const,
             response: structuredClone(response),
             resolved_at: Date.now(),
           };
         }
         if (
-          interaction.part.request.source.type === "tool" &&
+          tool_call_id &&
           part.type === "tool" &&
-          part.tool_call_id === interaction.part.request.source.tool_call_id
+          part.tool_call_id === tool_call_id
         ) {
           if (part.state !== "waiting-user") {
             throw new Error(
               `Tool is not waiting for Interaction: ${part.tool_call_id} (${part.state})`,
             );
           }
-          return denied
+          return response.outcome === "denied"
             ? { ...part, state: "failed" as const, error: "Interaction denied" }
             : { ...part, state: "running" as const };
         }
@@ -195,10 +194,11 @@ export class SessionMessageInteractionWriter {
               : {}),
           };
         }
+        const tool_call_id = interaction.part.request.source.tool_call_id;
         if (
-          interaction.part.request.source.type === "tool" &&
+          tool_call_id &&
           part.type === "tool" &&
-          part.tool_call_id === interaction.part.request.source.tool_call_id
+          part.tool_call_id === tool_call_id
         ) {
           if (part.state !== "waiting-user") return part;
           return { ...part, state: "failed" as const, error };

package/src/session/messages/SessionMessageText.ts

@@ -0,0 +1,73 @@
+/**
+ * Canonical SessionMessage 文本与工具摘要读取器。
+ *
+ * 该模块只读取 Session 持久化事实，供标题、预览和外部时间线复用。
+ */
+
+import type {
+  SessionAssistantMessage,
+  SessionMessage,
+} from "@/types/session/SessionMessage.js";
+import type { JsonObject, JsonValue } from "@/types/common/Json.js";
+
+/** Session 工具调用的只读摘要。 */
+export interface SessionToolCallSummary {
+  /** 工具注册名称。 */
+  tool_name: string;
+  /** 工具结构化输入。 */
+  input: JsonObject;
+  /** 工具成功输出或失败信息。 */
+  output: JsonValue;
+  /** 工具是否已成功完成。 */
+  succeeded: boolean;
+}
+
+/** 提取单条 canonical Message 的全部普通文本。 */
+export function extract_session_message_text(message: SessionMessage): string {
+  if (message.type !== "user" && message.type !== "assistant") return "";
+  return message.parts
+    .flatMap((part) => part.type === "text" ? [part.text] : [])
+    .map((text) => text.trim())
+    .filter(Boolean)
+    .join("\n")
+    .trim();
+}
+
+/** 提取 Assistant Message 中的 canonical 工具调用摘要。 */
+export function extract_session_tool_calls(
+  message: SessionAssistantMessage,
+): SessionToolCallSummary[] {
+  return message.parts.flatMap((part) => {
+    if (part.type !== "tool" || part.input === undefined) return [];
+    return [{
+      tool_name: part.tool_name,
+      input: to_json_object(part.input),
+      output: part.state === "failed"
+        ? { error: part.error || "tool_error" }
+        : part.output ?? null,
+      succeeded: part.state === "completed",
+    }];
+  });
+}
+
+/** 读取最终一次成功 `chat_send` 的可见文本，并回退到普通 Assistant 文本。 */
+export function resolve_session_assistant_visible_text(
+  message: SessionAssistantMessage,
+): string {
+  const calls = extract_session_tool_calls(message);
+  for (let index = calls.length - 1; index >= 0; index -= 1) {
+    const call = calls[index];
+    if (call.tool_name !== "chat_send") continue;
+    const text = typeof call.input.text === "string" ? call.input.text.trim() : "";
+    if (text && call.succeeded) return text;
+  }
+  return extract_session_message_text(message);
+}
+
+/** 把工具输入收窄为 JSON 对象。 */
+function to_json_object(value: JsonValue): JsonObject {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value as JsonObject;
+  }
+  return { value };
+}

package/src/session/preview/SessionMessagePreview.ts

@@ -2,51 +2,21 @@
  * Session 消息预览投影。
  *
  * 关键点（中文）
- * - 只负责从单条持久化 record 提取用户可见文本。
+ * - 只负责从单条 canonical Message 提取用户可见文本。
  * - history store 与浏览层共用该投影，避免摘要写入和读取采用不同规则。
  */
 
 import {
-  getToolName,
-  isToolUIPart,
-  type UIMessagePart,
-} from "ai";
-import { pick_last_successful_chat_send_text } from "@/executor/messages/UserVisibleText.js";
-import type {
-  SessionMessageRecordV1,
-  SessionRecordV1,
-} from "@/executor/types/SessionRecords.js";
-import {
-  is_session_action_record,
-  is_session_message_record,
-} from "@/executor/types/SessionRecords.js";
-
-type SessionPreviewPart = UIMessagePart<
-  Record<string, never>,
-  Record<string, never>
->;
-
-function extract_message_text(parts: unknown): string {
-  if (!Array.isArray(parts)) return "";
-  const texts: string[] = [];
-  for (const part of parts) {
-    if (!part || typeof part !== "object") continue;
-    const text_part = part as { type?: unknown; text?: unknown };
-    if (text_part.type !== "text" || typeof text_part.text !== "string") continue;
-    const text = text_part.text.trim();
-    if (text) texts.push(text);
-  }
-  return texts.join("\n").trim();
-}
+  extract_session_message_text,
+  resolve_session_assistant_visible_text,
+} from "@/session/messages/SessionMessageText.js";
+import type { SessionMessage } from "@/types/session/SessionMessage.js";
 
-function extract_assistant_tool_summary(
-  message: SessionMessageRecordV1,
-): string {
-  if (!Array.isArray(message.parts)) return "";
+function extract_assistant_tool_summary(message: Extract<SessionMessage, { type: "assistant" }>): string {
   const tool_names = new Set<string>();
-  for (const part of message.parts as SessionPreviewPart[]) {
-    if (!part || typeof part !== "object" || !isToolUIPart(part)) continue;
-    const tool_name = String(getToolName(part) || "").trim();
+  for (const part of message.parts) {
+    if (part.type !== "tool") continue;
+    const tool_name = part.tool_name.trim();
     if (tool_name) tool_names.add(tool_name);
   }
   return tool_names.size > 0
@@ -58,18 +28,18 @@ function extract_assistant_tool_summary(
  * 解析单条 session record 的用户可见预览文本。
  */
 export function resolve_session_message_preview(
-  message: SessionRecordV1,
+  message: SessionMessage,
 ): string {
-  if (is_session_action_record(message)) {
+  if (message.type === "action") {
     return message.description
       ? `${message.title}\n${message.description}`
       : message.title;
   }
-  if (!is_session_message_record(message)) return "";
-  const plain_text = extract_message_text(message.parts);
+  if (message.type === "error") return message.message;
+  const plain_text = extract_session_message_text(message);
   if (plain_text) return plain_text;
-  if (message.role !== "assistant") return "";
+  if (message.type !== "assistant") return "";
 
-  const user_visible = pick_last_successful_chat_send_text(message).trim();
+  const user_visible = resolve_session_assistant_visible_text(message).trim();
   return user_visible || extract_assistant_tool_summary(message);
 }

package/src/session/runtime/SessionTurnContext.ts

@@ -7,8 +7,8 @@
  * - Plugin 每次只获得新建的只读快照，不能越过扩展边界访问内核运行能力。
  */
 
-import type { UIMessage } from "ai";
-import type { SessionUserMessageV1 } from "@/executor/types/SessionRecords.js";
+import type { SessionUserMessage } from "@/types/session/SessionMessage.js";
+import type { SessionAssistantResultPart } from "@/types/session/SessionContent.js";
 import type {
   SessionTurnContext,
   SessionTurnContextInit,
@@ -41,9 +41,9 @@ class DefaultSessionTurnContext implements SessionTurnContext {
   private workspace_env_snapshot?: Readonly<Record<string, string>>;
   private agent_systems_snapshot: readonly string[] = Object.freeze([]);
   private plugin_lease?: AgentPluginExecutionLease;
-  private injected_user_messages: SessionUserMessageV1[] = [];
-  private deferred_messages: SessionUserMessageV1[] = [];
-  private pending_assistant_parts: UIMessage["parts"] = [];
+  private injected_user_messages: SessionUserMessage[] = [];
+  private deferred_messages: SessionUserMessage[] = [];
+  private pending_assistant_parts: SessionAssistantResultPart[] = [];
 
   readonly lifecycle: SessionTurnContext["lifecycle"];
   readonly step: SessionTurnContext["step"];
@@ -123,15 +123,15 @@ class DefaultSessionTurnContext implements SessionTurnContext {
         if (previous && previous !== plugins) await previous.release();
       },
       release: async () => await context.release_plugins(),
-      plugin_execution_context: () =>
-        context.create_plugin_execution_context(),
+      plugin_execution_context: (call_id?: string) =>
+        context.create_plugin_execution_context(call_id),
     });
 
     this.input = Object.freeze({
       checkpoint: async () => {
         const injected = context.injected_user_messages;
         context.injected_user_messages = [];
-        let queued: SessionUserMessageV1[] = [];
+        let queued: SessionUserMessage[] = [];
         try {
           queued = (await context.init.merge_step_input?.()) || [];
         } catch {
@@ -168,10 +168,12 @@ class DefaultSessionTurnContext implements SessionTurnContext {
   }
 
   /** 为 Plugin 生成不共享根对象引用的只读快照。 */
-  private create_plugin_execution_context(): PluginExecutionContext {
+  private create_plugin_execution_context(call_id?: string): PluginExecutionContext {
+    const normalized_call_id = String(call_id || "").trim();
     return Object.freeze({
       session_id: this.session.session_id,
       turn_id: this.session.turn_id,
+      ...(normalized_call_id ? { call_id: normalized_call_id } : {}),
       ...(this.session.project_root
         ? { project_root: this.session.project_root }
         : {}),