@downcity/agent 1.1.287 → 1.1.310

package/src/session/messages/SessionAssistantMessageWriter.ts

@@ -21,9 +21,9 @@ import type {
   SessionAssistantToolPart,
 } from "@/types/session/SessionMessage.js";
 import type { SessionToolInputReady } from "@/types/session/SessionTool.js";
-import { generateId } from "@/utils/Id.js";
+import { generate_id } from "@/utils/Id.js";
 
-/** 单个 Assistant segment 的流式 writer。 */
+/** 单个 Assistant Message 的流式 writer。 */
 export class SessionAssistantMessageWriter {
   readonly message_id: string;
   private readonly recorder: SessionMessages;
@@ -134,6 +134,7 @@ export class SessionAssistantMessageWriter {
       }
       case "text-delta":
       case "reasoning-delta": {
+        if (chunk.delta.length === 0) return;
         const type = chunk.type === "text-delta" ? "text" : "reasoning";
         const part_id = this.resolve_text_part_id(type, chunk.id);
         await this.ensure_text_part(
@@ -305,17 +306,13 @@ export class SessionAssistantMessageWriter {
         const tool = this.find_tool(chunk.toolCallId);
         await this.upsert_tool(chunk.toolCallId, {
           tool_name: tool?.tool_name || "unknown",
-          state: "approval-required",
-          approval: { approval_id: chunk.approvalId },
+          state: "waiting-user",
         });
         return;
       }
       case "tool-output-available": {
         const tool = this.find_tool(chunk.toolCallId);
-        if (
-          tool?.state === "failed" &&
-          (tool.error === "Approval denied" || tool.error === "Approval expired")
-        ) return;
+        if (tool?.state === "failed") return;
         const result_provider_metadata = to_session_provider_metadata(
           chunk.providerMetadata,
         );
@@ -365,12 +362,6 @@ export class SessionAssistantMessageWriter {
           tool_name: tool?.tool_name || "unknown",
           state: "failed",
           error: "Tool output denied",
-          approval: {
-            ...(tool?.approval || {}),
-            approval_id:
-              tool?.approval?.approval_id || `approval:${chunk.toolCallId}`,
-            approved: false,
-          },
         });
         return;
       }
@@ -420,7 +411,7 @@ export class SessionAssistantMessageWriter {
       }
       case "start-step":
         await this.upsert_part({
-          part_id: `step:${generateId()}`,
+          part_id: `step:${generate_id()}`,
           sequence: this.next_part_sequence(),
           type: "step-start",
         });
@@ -434,7 +425,7 @@ export class SessionAssistantMessageWriter {
             : undefined;
           const part_id = data_id
             ? `data:${this.step_index}:${data_id}`
-            : `data:${generateId()}`;
+            : `data:${generate_id()}`;
           const current_part = current.parts.find((part) => part.part_id === part_id);
           await this.upsert_part({
             part_id,
@@ -508,7 +499,7 @@ export class SessionAssistantMessageWriter {
       return;
     }
     await this.upsert_part({
-      part_id: `file:${generateId()}`,
+      part_id: `file:${generate_id()}`,
       sequence: this.next_part_sequence(),
       type: "file",
       media_type: input.media_type,
@@ -520,26 +511,47 @@ export class SessionAssistantMessageWriter {
     });
   }
 
+  /** 把 Action 产生的完整 Assistant Parts 按当前消息顺序追加。 */
+  async append_parts(parts: SessionAssistantMessagePart[]): Promise<void> {
+    await this.enqueue_write(async () => {
+      if (this.closed) throw new Error("Assistant Message writer is closed");
+      for (const part of parts) {
+        if (part.type === "tool" || part.type === "interaction") {
+          throw new Error(`Action cannot append Assistant ${part.type} Part`);
+        }
+        const part_id = `${part.type}:${generate_id()}`;
+        await this.upsert_part({
+          ...part,
+          part_id,
+          sequence: this.next_part_sequence(),
+          ...(part.type === "text" || part.type === "reasoning"
+            ? { state: "done" as const }
+            : {}),
+        } as SessionAssistantMessagePart);
+      }
+    });
+  }
+
   /** 等待当前 Assistant writer 已入队的全部写操作完成。 */
   async flush(): Promise<void> {
     await this.write_chain;
   }
 
-  /** 正常完成当前 assistant segment。 */
+  /** 正常完成当前 Assistant Message。 */
   async complete(): Promise<void> {
     await this.enqueue_write(async () => {
       await this.close_serialized("completed");
     });
   }
 
-  /** 停止当前 assistant segment，并保留已有 parts。 */
+  /** 停止当前 Assistant Message，并保留已有 Parts。 */
   async stop(): Promise<void> {
     await this.enqueue_write(async () => {
       await this.close_serialized("stopped");
     });
   }
 
-  /** 以失败状态关闭当前 assistant segment。 */
+  /** 以失败状态关闭当前 Assistant Message。 */
   async fail(_error: unknown): Promise<void> {
     await this.enqueue_write(async () => {
       await this.close_serialized("failed");
@@ -651,7 +663,7 @@ export class SessionAssistantMessageWriter {
     const source_part_id = this.source_text_part_id(type, chunk_id);
     const active_part_id = this.active_text_part_ids.get(source_part_id);
     if (active_part_id) return active_part_id;
-    const part_id = `${type}:${generateId()}`;
+    const part_id = `${type}:${generate_id()}`;
     this.active_text_part_ids.set(source_part_id, part_id);
     return part_id;
   }

package/src/session/messages/SessionJsonValue.ts

@@ -5,8 +5,8 @@
  * 避免 Tool、User Data 等外部输入污染 canonical Message。
  */
 
-import type { ProviderMetadata } from "ai";
 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 {
@@ -46,13 +46,13 @@ export function to_session_json_object(input: unknown): JsonObject | undefined {
  */
 export function to_session_provider_metadata(
   input: unknown,
-): ProviderMetadata | undefined {
+): 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 ProviderMetadata;
+    return value as SessionProviderMetadata;
   } catch {
     return undefined;
   }

package/src/session/messages/SessionMessageCodec.ts

@@ -40,7 +40,7 @@ export function to_executor_history(
       metadata: {
         v: 1,
         ts: snapshot.summary.created_at,
-        sessionId: session_id,
+        session_id: session_id,
         source: "compact",
         kind: "summary",
         extra: {
@@ -66,8 +66,8 @@ export function to_executor_ui_message(
   const metadata: SessionMetadataV1 = {
     v: 1,
     ts: message.updated_at,
-    sessionId: message.session_id,
-    turnId: message.turn_id,
+    session_id: message.session_id,
+    turn_id: message.turn_id,
     source:
       message.type === "user"
         ? "ingress"
@@ -84,7 +84,7 @@ export function to_executor_ui_message(
       visibility: message.visibility,
       ...(message.type === "user"
         ? { inputType: message.input_type }
-        : { segmentIndex: message.segment_index, status: message.status }),
+        : { status: message.status }),
     },
   };
   return {
@@ -153,12 +153,16 @@ export function from_ui_assistant_parts(
     const candidate = part as Record<string, unknown>;
     const type = String(candidate.type || "");
     if (type === "text" || type === "reasoning") {
+      const text = String(candidate.text || "");
+      // 关键点（中文）：AI SDK 会为只有 start/end、没有 delta 的流生成空占位 Part。
+      // canonical history 不保存无内容的协议占位，避免与只按 delta 创建 Part 的 writer 分叉。
+      if (text.length === 0) return [];
       const provider_metadata = to_session_provider_metadata(candidate.providerMetadata);
       return [{
         part_id: `${type}:${index + 1}`,
         sequence: index + 1,
         type: type as "text" | "reasoning",
-        text: String(candidate.text || ""),
+        text,
         state: candidate.state === "streaming" ? "streaming" as const : "done" as const,
         ...(provider_metadata !== undefined ? { provider_metadata } : {}),
       }];
@@ -224,7 +228,6 @@ export function from_ui_assistant_parts(
         candidate.resultProviderMetadata,
       );
       const tool_metadata = to_session_json_object(candidate.toolMetadata);
-      const approval = to_session_json_object(candidate.approval);
       return [{
         part_id: String(candidate.toolCallId || `tool:${index + 1}`),
         sequence: index + 1,
@@ -240,7 +243,7 @@ export function from_ui_assistant_parts(
             : state === "output-error" || state === "output-denied"
               ? "failed" as const
               : state === "approval-requested"
-                ? "approval-required" as const
+                ? "waiting-user" as const
                 : state === "input-streaming"
                   ? "input-streaming" as const
                   : state === "input-available"
@@ -275,19 +278,6 @@ export function from_ui_assistant_parts(
         ...(typeof candidate.providerExecuted === "boolean"
           ? { provider_executed: candidate.providerExecuted }
           : {}),
-        ...(approval?.id
-          ? {
-              approval: {
-                approval_id: String(approval.id),
-                ...(typeof approval.approved === "boolean"
-                  ? { approved: approval.approved }
-                  : {}),
-                ...(typeof approval.reason === "string"
-                  ? { reason: approval.reason }
-                  : {}),
-              },
-            }
-          : {}),
       }];
     }
     if (type.startsWith("data-")) {
@@ -405,6 +395,25 @@ function to_ui_assistant_parts(
     if (part.type === "step-start") {
       return { type: "step-start" };
     }
+    if (part.type === "interaction") {
+      return {
+        type: "data-session-interaction",
+        id: part.interaction_id,
+        data: {
+          interaction_id: part.interaction_id,
+          interaction_type: part.interaction_type,
+          status: part.status,
+          request: part.request,
+          ...(part.response !== undefined ? { response: part.response } : {}),
+          ...(part.resolved_at !== undefined
+            ? { resolved_at: part.resolved_at }
+            : {}),
+          ...(part.cancel_reason !== undefined
+            ? { cancel_reason: part.cancel_reason }
+            : {}),
+        },
+      } as UIMessage["parts"][number];
+    }
     if (!("tool_call_id" in part)) {
       throw new Error(`Unsupported Assistant part: ${part.type}`);
     }
@@ -442,39 +451,12 @@ function to_ui_assistant_parts(
         ...(part.preliminary !== undefined
           ? { preliminary: part.preliminary }
           : {}),
-        ...(part.approval?.approved === true
-          ? {
-              approval: {
-                id: part.approval.approval_id,
-                approved: true as const,
-                ...(part.approval.reason !== undefined
-                  ? { reason: part.approval.reason }
-                  : {}),
-              },
-            }
-          : {}),
         ...(part.result_provider_metadata !== undefined
           ? { resultProviderMetadata: part.result_provider_metadata }
           : {}),
       };
     }
     if (part.state === "failed") {
-      if (part.approval?.approved === false) {
-        return {
-          ...tool_identity_fields,
-          toolCallId: part.tool_call_id,
-          state: "output-denied",
-          input,
-          ...call_provider_fields,
-          approval: {
-            id: part.approval.approval_id,
-            approved: false,
-            ...(part.approval.reason !== undefined
-              ? { reason: part.approval.reason }
-              : {}),
-          },
-        };
-      }
       return {
         ...tool_identity_fields,
         toolCallId: part.tool_call_id,
@@ -483,48 +465,11 @@ function to_ui_assistant_parts(
         ...(part.raw_input !== undefined ? { rawInput: part.raw_input } : {}),
         errorText: part.error || "Tool failed",
         ...call_provider_fields,
-        ...(part.approval?.approved === true
-          ? {
-              approval: {
-                id: part.approval.approval_id,
-                approved: true as const,
-                ...(part.approval.reason !== undefined
-                  ? { reason: part.approval.reason }
-                  : {}),
-              },
-            }
-          : {}),
         ...(part.result_provider_metadata !== undefined
           ? { resultProviderMetadata: part.result_provider_metadata }
           : {}),
       };
     }
-    if (part.state === "approval-required") {
-      return {
-        ...tool_identity_fields,
-        toolCallId: part.tool_call_id,
-        state: "approval-requested",
-        input,
-        approval: { id: part.approval?.approval_id || `approval:${part.tool_call_id}` },
-        ...call_provider_fields,
-      };
-    }
-    if (part.state === "running" && part.approval?.approved !== undefined) {
-      return {
-        ...tool_identity_fields,
-        toolCallId: part.tool_call_id,
-        state: "approval-responded",
-        input,
-        ...call_provider_fields,
-        approval: {
-          id: part.approval.approval_id,
-          approved: part.approval.approved,
-          ...(part.approval.reason !== undefined
-            ? { reason: part.approval.reason }
-            : {}),
-        },
-      };
-    }
     return {
       ...tool_identity_fields,
       toolCallId: part.tool_call_id,

package/src/session/messages/SessionMessageCompaction.ts

@@ -5,7 +5,7 @@
  */
 
 import { generateText, type LanguageModel } from "ai";
-import { generateId } from "@/utils/Id.js";
+import { generate_id } from "@/utils/Id.js";
 import {
   build_initial_session_compaction_prompt,
   build_update_session_compaction_prompt,
@@ -95,7 +95,7 @@ export async function compose_session_compaction(input: {
     summary: {
       record_type: "summary",
       session_id: input.session_id,
-      summary_id: `summary:${input.session_id}:${generateId()}`,
+      summary_id: `summary:${input.session_id}:${generate_id()}`,
       through_sequence: boundary.sequence,
       text: summary,
       created_at: Date.now(),

package/src/session/messages/SessionMessageInteractionWriter.ts

@@ -0,0 +1,277 @@
+/**
+ * Session Message Interaction 写入器。
+ *
+ * 该模块只负责 Assistant Message 内 Interaction Part 与关联 Tool Part 的
+ * 原子状态转换；消息持久化、revision 串行化和 Mutation 发布仍由
+ * SessionMessages 提供，避免复制 canonical Message 状态。
+ */
+
+import type {
+  SessionAssistantInteractionPart,
+  SessionAssistantMessage,
+  SessionAssistantMessagePart,
+  SessionMessage,
+} from "@/types/session/SessionMessage.js";
+import type {
+  SessionInteractionRequest,
+  SessionInteractionResponse,
+} from "@/types/session/SessionInteraction.js";
+import type { SessionStreamingToolLocation } from "@/types/session/SessionTool.js";
+
+/** Interaction 写入器依赖的最小 Message 能力。 */
+interface SessionMessageInteractionWriterOptions {
+  /** 返回当前 Session 内存中的 canonical Message 集合。 */
+  list_messages: () => Iterable<SessionMessage>;
+  /** 查找当前流式 Assistant 中的指定 Tool Part。 */
+  find_streaming_tool: (
+    tool_call_id: string,
+  ) => SessionStreamingToolLocation | undefined;
+  /** 在指定 Assistant Message 的串行事务链中执行写操作。 */
+  enqueue_assistant_write: <T>(
+    message_id: string,
+    operation: () => Promise<T>,
+  ) => Promise<T>;
+  /** 原子持久化 Assistant 完整快照并发布发生变化的 Part。 */
+  commit_assistant_snapshot: (
+    current: SessionAssistantMessage,
+    parts: SessionAssistantMessagePart[],
+  ) => Promise<void>;
+}
+
+/** 管理 canonical Assistant Message 内的 Interaction 生命周期。 */
+export class SessionMessageInteractionWriter {
+  private readonly options: SessionMessageInteractionWriterOptions;
+
+  constructor(options: SessionMessageInteractionWriterOptions) {
+    this.options = options;
+  }
+
+  /** 返回当前 Session 中全部等待用户响应的 canonical Interaction。 */
+  list_pending(): SessionAssistantInteractionPart[] {
+    return [...this.options.list_messages()].flatMap((message) =>
+      message.type === "assistant" && message.status === "streaming"
+        ? message.parts.flatMap((part) =>
+            part.type === "interaction" && part.status === "pending"
+              ? [structuredClone(part)]
+              : [],
+          )
+        : [],
+    );
+  }
+
+  /** 原子创建 Interaction，并把关联 Tool 转为 waiting-user。 */
+  async request(
+    request: SessionInteractionRequest,
+  ): Promise<SessionAssistantInteractionPart> {
+    const message_id = request.source.type === "tool"
+      ? this.require_streaming_tool(request.source.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);
+      if (
+        current.parts.some(
+          (part) =>
+            part.type === "interaction" &&
+            part.interaction_id === request.interaction_id,
+        )
+      ) {
+        throw new Error(`Session Interaction already exists: ${request.interaction_id}`);
+      }
+
+      let parts = current.parts;
+      if (request.source.type === "tool") {
+        const tool = this.require_streaming_tool(request.source.tool_call_id);
+        if (tool.message_id !== message_id) {
+          throw new Error(
+            `Tool Assistant Message changed: ${request.source.tool_call_id}`,
+          );
+        }
+        if (tool.part.state !== "ready") {
+          throw new Error(
+            `Tool Interaction requires ready input: ${request.source.tool_call_id} (${tool.part.state})`,
+          );
+        }
+        parts = parts.map((part) =>
+          part.part_id === tool.part.part_id
+            ? { ...tool.part, state: "waiting-user" as const }
+            : part,
+        );
+      }
+
+      const interaction: SessionAssistantInteractionPart = {
+        part_id: `interaction:${request.interaction_id}`,
+        sequence: parts.reduce(
+          (sequence, part) => Math.max(sequence, part.sequence + 1),
+          1,
+        ),
+        type: "interaction",
+        interaction_id: request.interaction_id,
+        interaction_type: request.kind,
+        status: "pending",
+        request: structuredClone(request),
+      };
+      await this.options.commit_assistant_snapshot(current, [...parts, interaction]);
+    });
+    return this.require_pending_interaction(request.interaction_id).part;
+  }
+
+  /** 原子保存用户响应，并按 Interaction 结果恢复或终止关联 Tool。 */
+  async resolve(
+    interaction_id: string,
+    response: SessionInteractionResponse,
+  ): Promise<SessionAssistantInteractionPart> {
+    const { message_id } = this.require_pending_interaction(interaction_id);
+    await this.options.enqueue_assistant_write(message_id, async () => {
+      const current = this.require_streaming_assistant(message_id);
+      const interaction = this.require_pending_interaction(interaction_id);
+      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}`);
+      }
+      const denied = response.kind === "approval" && response.decision === "denied";
+      const parts = current.parts.map((part) => {
+        if (part.part_id === interaction.part.part_id) {
+          return {
+            ...interaction.part,
+            status: "resolved" as const,
+            response: structuredClone(response),
+            resolved_at: Date.now(),
+          };
+        }
+        if (
+          interaction.part.request.source.type === "tool" &&
+          part.type === "tool" &&
+          part.tool_call_id === interaction.part.request.source.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
+            ? { ...part, state: "failed" as const, error: "Interaction denied" }
+            : { ...part, state: "running" as const };
+        }
+        return part;
+      });
+      await this.options.commit_assistant_snapshot(current, parts);
+    });
+    return this.require_interaction(interaction_id).part;
+  }
+
+  /** 原子结束未响应 Interaction，并把关联 Tool 标记为失败。 */
+  async close(
+    interaction_id: string,
+    input:
+      | { status: "expired" }
+      | {
+          status: "cancelled";
+          reason: "turn_stopped" | "session_disposed" | "runtime_interrupted";
+        },
+  ): Promise<SessionAssistantInteractionPart> {
+    const { message_id } = this.require_pending_interaction(interaction_id);
+    await this.options.enqueue_assistant_write(message_id, async () => {
+      const current = this.require_streaming_assistant(message_id);
+      const interaction = this.require_pending_interaction(interaction_id);
+      const error = input.status === "expired"
+        ? "Interaction expired"
+        : "Interaction cancelled";
+      const parts = current.parts.map((part) => {
+        if (part.part_id === interaction.part.part_id) {
+          return {
+            ...interaction.part,
+            status: input.status,
+            resolved_at: Date.now(),
+            ...(input.status === "cancelled"
+              ? { cancel_reason: input.reason }
+              : {}),
+          };
+        }
+        if (
+          interaction.part.request.source.type === "tool" &&
+          part.type === "tool" &&
+          part.tool_call_id === interaction.part.request.source.tool_call_id
+        ) {
+          if (part.state !== "waiting-user") return part;
+          return { ...part, state: "failed" as const, error };
+        }
+        return part;
+      });
+      await this.options.commit_assistant_snapshot(current, parts);
+    });
+    return this.require_interaction(interaction_id).part;
+  }
+
+  /** 读取指定或当前唯一的流式 Assistant Message。 */
+  private require_streaming_assistant(
+    message_id?: string,
+  ): SessionAssistantMessage {
+    const message = message_id
+      ? [...this.options.list_messages()].find(
+          (item) => item.message_id === message_id,
+        )
+      : [...this.options.list_messages()].find(
+          (item) => item.type === "assistant" && item.status === "streaming",
+        );
+    if (!message || message.type !== "assistant" || message.status !== "streaming") {
+      throw new Error(
+        message_id
+          ? `Streaming Assistant Message not found: ${message_id}`
+          : "Streaming Assistant Message not found",
+      );
+    }
+    return message;
+  }
+
+  /** 查找指定 Interaction Part 及其所属流式 Assistant。 */
+  private find_interaction(interaction_id: string):
+    | {
+        message_id: string;
+        part: SessionAssistantInteractionPart;
+      }
+    | undefined {
+    for (const message of this.options.list_messages()) {
+      if (message.type !== "assistant" || message.status !== "streaming") continue;
+      const part = message.parts.find(
+        (item): item is SessionAssistantInteractionPart =>
+          item.type === "interaction" &&
+          item.interaction_id === interaction_id,
+      );
+      if (part) return { message_id: message.message_id, part };
+    }
+    return undefined;
+  }
+
+  /** 读取指定 Interaction，否则抛出稳定领域错误。 */
+  private require_interaction(interaction_id: string): {
+    message_id: string;
+    part: SessionAssistantInteractionPart;
+  } {
+    const interaction = this.find_interaction(interaction_id);
+    if (interaction) return interaction;
+    throw new Error(`Session Interaction not found: ${interaction_id}`);
+  }
+
+  /** 读取指定 pending Interaction，否则拒绝重复响应终态 Interaction。 */
+  private require_pending_interaction(interaction_id: string): {
+    message_id: string;
+    part: SessionAssistantInteractionPart;
+  } {
+    const interaction = this.require_interaction(interaction_id);
+    if (interaction.part.status !== "pending") {
+      throw new Error(
+        `Session Interaction is already ${interaction.part.status}: ${interaction_id}`,
+      );
+    }
+    return interaction;
+  }
+
+  /** 查找当前流式 Assistant 中的 Tool Part，否则抛出明确错误。 */
+  private require_streaming_tool(tool_call_id: string): SessionStreamingToolLocation {
+    const tool = this.options.find_streaming_tool(tool_call_id);
+    if (tool) return tool;
+    throw new Error(`Streaming Tool Part not found: ${tool_call_id}`);
+  }
+}

package/src/session/preview/SessionMessagePreview.ts

@@ -11,7 +11,7 @@ import {
   isToolUIPart,
   type UIMessagePart,
 } from "ai";
-import { pickLastSuccessfulChatSendText } from "@/executor/messages/UserVisibleText.js";
+import { pick_last_successful_chat_send_text } from "@/executor/messages/UserVisibleText.js";
 import type {
   SessionMessageRecordV1,
   SessionRecordV1,
@@ -70,6 +70,6 @@ export function resolve_session_message_preview(
   if (plain_text) return plain_text;
   if (message.role !== "assistant") return "";
 
-  const user_visible = pickLastSuccessfulChatSendText(message).trim();
+  const user_visible = pick_last_successful_chat_send_text(message).trim();
   return user_visible || extract_assistant_tool_summary(message);
 }