@downcity/agent 1.1.332 → 1.1.335

package/scripts/image-plugin-job.test.mjs

@@ -31,8 +31,28 @@ function create_image_message() {
   };
 }
 
+function create_files(workspace_path) {
+  return {
+    root_path: workspace_path,
+    resolve_path: (...segments) => path.resolve(workspace_path, ...segments),
+    path_exists: async (file_path) => {
+      try {
+        await fs.access(file_path);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    ensure_directory: (directory_path) => fs.mkdir(directory_path, { recursive: true }),
+    write_file_atomically: (file_path, content) => fs.writeFile(file_path, content),
+  };
+}
+
 function create_context(workspace_path = process.cwd()) {
-  return { workspace_path };
+  return {
+    workspace_path,
+    files: create_files(workspace_path),
+  };
 }
 
 function create_registry(plugin, workspace_path = process.cwd()) {
@@ -185,13 +205,119 @@ test("ImagePlugin image_result returns final message when succeeded", async () =
   assert.equal(result.success, true);
   assert.equal(result.data.job_id, "img_1");
   assert.equal(result.data.status, "succeeded");
-  assert.equal("result" in result.data, false);
+  assert.deepEqual(result.data.result, message);
   assert.deepEqual(result.messages, [{
     role: "assistant",
     parts: message.parts,
   }]);
 });
 
+test("ImagePlugin image_result stores remote images locally and preserves source URLs", async (t) => {
+  const workspace_path = await fs.mkdtemp(path.join(os.tmpdir(), "image-plugin-result-"));
+  t.after(() => fs.rm(workspace_path, { recursive: true, force: true }));
+  t.mock.method(globalThis, "fetch", async (url) => {
+    const is_webp = String(url).endsWith("/second.webp");
+    return new Response(is_webp ? "webp-bytes" : "png-bytes", {
+      status: 200,
+      headers: {
+        "content-type": is_webp ? "image/webp" : "image/png",
+      },
+    });
+  });
+
+  const remote_message = {
+    id: "msg_remote_images",
+    role: "assistant",
+    parts: [
+      {
+        type: "file",
+        mediaType: "image/png",
+        url: "https://storage.example.com/first.png",
+      },
+      {
+        type: "file",
+        mediaType: "image/webp",
+        url: "https://storage.example.com/second.webp",
+      },
+    ],
+  };
+  const plugin = new ImagePlugin({
+    image_create: () => ({ job_id: "img_remote", status: "queued" }),
+    image_result: () => ({
+      job_id: "img_remote",
+      status: "succeeded",
+      result: remote_message,
+    }),
+  });
+
+  const result = await plugin.actions.image_result.execute({
+    context: create_context(workspace_path),
+    input: { job_id: "img_remote" },
+    plugin_name: "image",
+    action_name: "image_result",
+  });
+
+  assert.equal(result.success, true);
+  assert.deepEqual(result.data.result.parts.map((part) => part.url), [
+    ".downcity/image/results/img_remote/image_01.png",
+    ".downcity/image/results/img_remote/image_02.webp",
+  ]);
+  assert.deepEqual(
+    result.data.result.parts.map((part) => part.providerMetadata.downcity.source_url),
+    remote_message.parts.map((part) => part.url),
+  );
+  assert.equal(
+    await fs.readFile(path.join(workspace_path, result.data.result.parts[0].url), "utf8"),
+    "png-bytes",
+  );
+  assert.equal(
+    await fs.readFile(path.join(workspace_path, result.data.result.parts[1].url), "utf8"),
+    "webp-bytes",
+  );
+  assert.deepEqual(result.messages[0].parts, result.data.result.parts);
+});
+
+test("ImagePlugin image_result keeps remote URL when local storage fails", async (t) => {
+  const workspace_path = await fs.mkdtemp(path.join(os.tmpdir(), "image-plugin-fallback-"));
+  t.after(() => fs.rm(workspace_path, { recursive: true, force: true }));
+  t.mock.method(globalThis, "fetch", async () => {
+    return new Response("unavailable", { status: 503 });
+  });
+  const remote_url = "https://storage.example.com/failed.png";
+  const plugin = new ImagePlugin({
+    image_create: () => ({ job_id: "img_fallback", status: "queued" }),
+    image_result: () => ({
+      job_id: "img_fallback",
+      status: "succeeded",
+      result: {
+        id: "msg_remote_fallback",
+        role: "assistant",
+        parts: [{ type: "file", mediaType: "image/png", url: remote_url }],
+      },
+    }),
+  });
+
+  const result = await plugin.actions.image_result.execute({
+    context: create_context(workspace_path),
+    input: { job_id: "img_fallback" },
+    plugin_name: "image",
+    action_name: "image_result",
+  });
+
+  assert.equal(result.success, true);
+  assert.equal(result.data.result.parts[0].url, remote_url);
+  assert.equal(
+    result.data.result.parts[0].providerMetadata.downcity.source_url,
+    remote_url,
+  );
+  assert.match(
+    result.data.result.parts[0].providerMetadata.downcity.localization_error,
+    /HTTP 503/,
+  );
+  assert.match(result.message, /kept as remote URLs/);
+  assert.deepEqual(result.messages[0].parts, result.data.result.parts);
+});
+
 test("ImagePlugin image_result reports failed terminal job", async () => {
   const plugin = new ImagePlugin({
     image_create: () => ({ job_id: "img_1", status: "queued", poll_after_ms: 1 }),

package/scripts/session-messages.test.mjs

@@ -20,6 +20,7 @@ import {
   to_executor_history,
   to_executor_ui_message,
 } from "../bin/session/messages/SessionMessageCodec.js";
+import { to_model_messages } from "../bin/executor/messages/SessionMessageCodec.js";
 import { convertToModelMessages } from "ai";
 import { MockLanguageModelV3 } from "ai/test";
 
@@ -1199,6 +1200,103 @@ test("step 最终快照忽略没有 delta 的空 Text 与 Reasoning Part", async
   assert.equal(assistant.parts[0].tool_call_id, "call-1");
 });
 
+test("空 Reasoning 携带 Provider metadata 时作为跨轮重放协议 Part 保存", async () => {
+  const { recorder, file_path } = await create_recorder("empty-provider-reasoning-test");
+  const writer = await recorder.open_assistant_message({
+    turn_id: "turn-empty-provider-reasoning",
+  });
+  const reasoning_metadata = {
+    openai: { itemId: "rs_required" },
+  };
+  const message_metadata = {
+    openai: { itemId: "msg_required", phase: "final_answer" },
+  };
+
+  await writer.begin_step();
+  await writer.apply_chunk({
+    type: "reasoning-start",
+    id: "reasoning-empty-provider",
+    providerMetadata: reasoning_metadata,
+  });
+  await writer.apply_chunk({
+    type: "reasoning-end",
+    id: "reasoning-empty-provider",
+    providerMetadata: reasoning_metadata,
+  });
+  await writer.apply_chunk({ type: "text-start", id: "text-provider" });
+  await writer.apply_chunk({
+    type: "text-delta",
+    id: "text-provider",
+    delta: "完成",
+  });
+  await writer.apply_chunk({
+    type: "text-end",
+    id: "text-provider",
+    providerMetadata: message_metadata,
+  });
+  const final_parts = from_ui_assistant_parts([
+    {
+      type: "reasoning",
+      text: "",
+      state: "done",
+      providerMetadata: reasoning_metadata,
+    },
+    {
+      type: "text",
+      text: "完成",
+      state: "done",
+      providerMetadata: message_metadata,
+    },
+  ]);
+  assert.deepEqual(final_parts.map((part) => part.type), ["reasoning", "text"]);
+  await writer.finish_step(final_parts);
+  await writer.complete();
+
+  const assistant = (await read_jsonl(file_path))[0];
+  assert.deepEqual(assistant.parts.map((part) => part.type), ["reasoning", "text"]);
+  assert.equal(assistant.parts[0].text, "");
+  assert.deepEqual(assistant.parts[0].provider_metadata, reasoning_metadata);
+  assert.deepEqual(assistant.parts[1].provider_metadata, message_metadata);
+
+  const restored = to_executor_ui_message(assistant);
+  const model_messages = await to_model_messages([restored], {});
+  const model_parts = model_messages.flatMap((message) =>
+    Array.isArray(message.content) ? message.content : []
+  );
+  assert.deepEqual(model_parts.map((part) => part.type), ["reasoning", "text"]);
+  assert.deepEqual(model_parts[0].providerOptions, reasoning_metadata);
+  assert.deepEqual(model_parts[1].providerOptions, message_metadata);
+});
+
+test("旧 Session 缺少 Reasoning 协议 Part 时移除孤立 msg_* 引用", async () => {
+  const model_messages = await to_model_messages([{
+    id: "assistant-legacy",
+    role: "assistant",
+    metadata: {
+      v: 1,
+      ts: 1,
+      session_id: "legacy-session",
+      source: "egress",
+      kind: "normal",
+    },
+    parts: [{
+      type: "text",
+      text: "已持久化的回复",
+      state: "done",
+      providerMetadata: {
+        openai: { itemId: "msg_orphaned", phase: "final_answer" },
+      },
+    }],
+  }], {});
+  const text_part = model_messages
+    .flatMap((message) => Array.isArray(message.content) ? message.content : [])
+    .find((part) => part.type === "text");
+  assert.equal(text_part.text, "已持久化的回复");
+  assert.deepEqual(text_part.providerOptions, {
+    openai: { phase: "final_answer" },
+  });
+});
+
 test("空 Text Start 不会抢占后续 Tool 的真实顺序", async () => {
   const { recorder, events, file_path } = await create_recorder("deferred-text-order-test");
   const writer = await recorder.open_assistant_message({ turn_id: "turn-1" });

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

@@ -84,7 +84,9 @@ export function deep_compact_model_messages(
   const depth = Math.max(0, Math.min(8, Math.floor(compact_depth)));
   const pruned_messages = pruneMessages({
     messages,
-    reasoning: "all",
+    // Reasoning 由本模块在确定最新 Tool 事务后再清理，避免先丢失
+    // OpenAI Responses API 中与 Tool item 原子关联的协议 Part。
+    reasoning: "none",
     // 工具事务由本模块按 toolCallId/approvalId 选择；先让 SDK 保留完整关联，
     // 避免 approval response 作为最后一条消息时 SDK 丢掉更早的 tool-call。
     toolCalls: "none",
@@ -343,25 +345,38 @@ function compact_retained_message(
       content: fold_compacted_text(message.content, message_limit),
     } as ModelMessage;
   }
-  const relevant_parts = message.content.filter((part) => part.type !== "reasoning");
+  const retained_non_reasoning_parts = message.content.filter((part) => {
+    if (part.type === "reasoning") return false;
+    if (part.type === "tool-call" || part.type === "tool-result") {
+      return selected_tool_call_ids.has(part.toolCallId);
+    }
+    if (part.type === "tool-approval-request") {
+      return selected_tool_call_ids.has(part.toolCallId);
+    }
+    if (part.type === "tool-approval-response") {
+      const tool_call_id = approval_to_tool_call.get(part.approvalId);
+      return Boolean(tool_call_id && selected_tool_call_ids.has(tool_call_id));
+    }
+    return true;
+  });
+  const requires_provider_reasoning = retained_non_reasoning_parts.some(
+    (part) =>
+      (part.type === "tool-call" || part.type === "tool-result") &&
+      has_openai_item_reference(part as unknown as Record<string, unknown>),
+  );
+  const relevant_parts = message.content.filter((part) =>
+    part.type !== "reasoning" ||
+    (requires_provider_reasoning &&
+      has_openai_reasoning_replay_data(part as unknown as Record<string, unknown>))
+  );
   const part_limit = Math.max(
     MIN_FOLDED_PART_CHARS,
     Math.floor(message_limit / Math.max(1, relevant_parts.length)),
   );
   const content = relevant_parts
-    .filter((part) => {
-      if (part.type === "tool-call" || part.type === "tool-result") {
-        return selected_tool_call_ids.has(part.toolCallId);
-      }
-      if (part.type === "tool-approval-request") {
-        return selected_tool_call_ids.has(part.toolCallId);
-      }
-      if (part.type === "tool-approval-response") {
-        const tool_call_id = approval_to_tool_call.get(part.approvalId);
-        return Boolean(tool_call_id && selected_tool_call_ids.has(tool_call_id));
-      }
-      return true;
-    })
+    .filter((part) =>
+      part.type === "reasoning" || retained_non_reasoning_parts.includes(part)
+    )
     .map((part) =>
       compact_model_part(
         part as unknown as Record<string, unknown>,
@@ -380,8 +395,14 @@ function compact_model_part(
     return {
       ...part,
       text: fold_compacted_text(String(part.text || ""), part_limit),
+      ...without_openai_item_reference(part),
     };
   }
+  if (part.type === "reasoning") {
+    // 压缩不保留可见思维文本，但必须保留与最新 Tool 事务关联的
+    // Responses API itemId / encrypted content，否则 Provider 会拒绝孤立的 Tool item。
+    return { ...part, text: "" };
+  }
   if (part.type === "tool-call") {
     return {
       ...part,
@@ -420,6 +441,54 @@ function compact_model_part(
   return part;
 }
 
+/** 判断 Part 是否引用 OpenAI Responses API 中已存储的 item。 */
+function has_openai_item_reference(part: Record<string, unknown>): boolean {
+  const provider_options = read_record(part.providerOptions);
+  const openai_options = read_record(provider_options?.openai);
+  return typeof openai_options?.itemId === "string" && openai_options.itemId.length > 0;
+}
+
+/** 判断空 Reasoning 是否仍携带可用于跨轮重放的 Provider 协议数据。 */
+function has_openai_reasoning_replay_data(part: Record<string, unknown>): boolean {
+  const provider_options = read_record(part.providerOptions);
+  const openai_options = read_record(provider_options?.openai);
+  return (
+    (typeof openai_options?.itemId === "string" && openai_options.itemId.length > 0) ||
+    (typeof openai_options?.reasoningEncryptedContent === "string" &&
+      openai_options.reasoningEncryptedContent.length > 0)
+  );
+}
+
+/**
+ * 压缩后的 Text 已经是新的语义投影，不能继续引用 Provider 中的原始 msg_* item。
+ */
+function without_openai_item_reference(
+  part: Record<string, unknown>,
+): Pick<Record<string, unknown>, "providerOptions"> | Record<string, never> {
+  const provider_options = read_record(part.providerOptions);
+  const openai_options = read_record(provider_options?.openai);
+  if (!provider_options || !openai_options || !("itemId" in openai_options)) {
+    return {};
+  }
+  const { itemId: _item_id, ...remaining_openai_options } = openai_options;
+  const next_provider_options = { ...provider_options };
+  if (Object.keys(remaining_openai_options).length > 0) {
+    next_provider_options.openai = remaining_openai_options;
+  } else {
+    delete next_provider_options.openai;
+  }
+  return Object.keys(next_provider_options).length > 0
+    ? { providerOptions: next_provider_options }
+    : { providerOptions: undefined };
+}
+
+/** 安全读取普通 JSON object。 */
+function read_record(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
 function fold_compacted_value(value: unknown, max_chars: number): unknown {
   const serialized = safe_stringify(value);
   if (serialized.length <= max_chars) return value;

package/src/executor/messages/SessionMessageCodec.ts

@@ -96,10 +96,78 @@ export async function to_model_messages(
   });
 
   // 调用 ai-sdk 的转换函数。
-  return await convertToModelMessages(input, {
+  const converted_messages = await convertToModelMessages(input, {
     // 如果当前轮有工具，就把工具注入转换选项。
     ...(tools && Object.keys(tools).length > 0 ? { tools: tools as ToolSet } : {}),
     // 忽略历史里的不完整工具调用，提升容错性。
     ignoreIncompleteToolCalls: true,
   });
+  return repair_orphaned_openai_text_references(converted_messages);
+}
+
+/**
+ * 修复旧版 Session 中“只保存 msg_*、未保存必需 rs_*”的孤立 Responses API 引用。
+ *
+ * 关键点（中文）
+ * - reasoning itemId / encrypted content 与 message itemId 存在时，保留 Provider 原子重放。
+ * - 只有 message itemId 时，删除该引用并发送已持久化的普通文本，避免 400。
+ * - 不修改 Session canonical source，该修复是可重建的 Provider 投影。
+ */
+function repair_orphaned_openai_text_references(
+  messages: ModelMessage[],
+): ModelMessage[] {
+  return messages.map((message) => {
+    if (message.role !== "assistant" || !Array.isArray(message.content)) {
+      return message;
+    }
+    const has_reasoning_replay_data = message.content.some((part) => {
+      if (part.type !== "reasoning") return false;
+      const openai_options = read_openai_provider_options(part.providerOptions);
+      return Boolean(
+        (typeof openai_options?.itemId === "string" && openai_options.itemId) ||
+        (typeof openai_options?.reasoningEncryptedContent === "string" &&
+          openai_options.reasoningEncryptedContent),
+      );
+    });
+    if (has_reasoning_replay_data) return message;
+
+    let changed = false;
+    const content = message.content.map((part) => {
+      if (part.type !== "text") return part;
+      const provider_options = read_json_record(part.providerOptions);
+      const openai_options = read_openai_provider_options(part.providerOptions);
+      if (!provider_options || !openai_options || !("itemId" in openai_options)) {
+        return part;
+      }
+      changed = true;
+      const { itemId: _item_id, ...remaining_openai_options } = openai_options;
+      const next_provider_options = { ...provider_options };
+      if (Object.keys(remaining_openai_options).length > 0) {
+        next_provider_options.openai = remaining_openai_options;
+      } else {
+        delete next_provider_options.openai;
+      }
+      return {
+        ...part,
+        providerOptions: Object.keys(next_provider_options).length > 0
+          ? next_provider_options
+          : undefined,
+      };
+    });
+    return changed ? { ...message, content } as ModelMessage : message;
+  });
+}
+
+/** 读取 Provider options 中的 OpenAI 协议字段。 */
+function read_openai_provider_options(
+  value: unknown,
+): Record<string, unknown> | undefined {
+  return read_json_record(read_json_record(value)?.openai);
+}
+
+/** 安全读取普通 JSON object。 */
+function read_json_record(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
 }

package/src/session/messages/SessionAssistantMessageWriter.ts

@@ -156,9 +156,21 @@ export class SessionAssistantMessageWriter {
         const source_part_id = this.source_text_part_id(type, chunk.id);
         const part_id = this.active_text_part_ids.get(source_part_id);
         if (!part_id) return;
-        const part = current.parts.find((item) => item.part_id === part_id);
+        const provider_metadata = to_session_provider_metadata(chunk.providerMetadata);
+        const pending = this.pending_text_parts.get(part_id);
+        // 关键点（中文）：Responses API 可能只输出 reasoning start/end 与 itemId，
+        // 却没有可见 reasoning delta。这个空 Part 不是 UI 占位，而是后续 msg_* 重放必需的协议关联。
+        if (
+          type === "reasoning" &&
+          !current.parts.some((item) => item.part_id === part_id) &&
+          (provider_metadata !== undefined || pending?.provider_metadata !== undefined)
+        ) {
+          await this.ensure_text_part(part_id, type, provider_metadata);
+        }
+        const part = this.current_message().parts.find(
+          (item) => item.part_id === part_id,
+        );
         if (part?.type === "text" || part?.type === "reasoning") {
-          const provider_metadata = to_session_provider_metadata(chunk.providerMetadata);
           await this.upsert_part({
             ...part,
             state: "done",

package/src/session/messages/SessionMessageCodec.ts

@@ -154,10 +154,14 @@ export function from_ui_assistant_parts(
     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);
+      // 关键点（中文）：AI SDK 会为只有 start/end、没有 delta 的流生成空占位 Part。
+      // 纯空占位不保存；但 Responses API 的 reasoning 即使没有可见文本，
+      // 也可能通过 itemId / encrypted content 与后续 message 形成必须原子重放的协议组。
+      if (
+        text.length === 0 &&
+        !(type === "reasoning" && provider_metadata !== undefined)
+      ) return [];
       return [{
         part_id: `${type}:${index + 1}`,
         sequence: index + 1,