@downcity/agent 1.1.332 → 1.1.337

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

@@ -1199,6 +1199,66 @@ 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);
+
+});
+
 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,6 +84,7 @@ export function deep_compact_model_messages(
   const depth = Math.max(0, Math.min(8, Math.floor(compact_depth)));
   const pruned_messages = pruneMessages({
     messages,
+    // 压缩后只保留语义内容；Provider replay 状态由 Federation 在最终路由后按作用域决定。
     reasoning: "all",
     // 工具事务由本模块按 toolCallId/approvalId 选择；先让 SDK 保留完整关联，
     // 避免 approval response 作为最后一条消息时 SDK 丢掉更早的 tool-call。
@@ -343,25 +344,24 @@ 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 relevant_parts = message.content.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 part.type !== "reasoning";
+  });
   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;
-    })
     .map((part) =>
       compact_model_part(
         part as unknown as Record<string, unknown>,
@@ -376,23 +376,24 @@ function compact_model_part(
   part: Record<string, unknown>,
   part_limit: number,
 ): Record<string, unknown> {
+  const semantic_part = strip_provider_replay_state(part);
   if (part.type === "text") {
     return {
-      ...part,
+      ...semantic_part,
       text: fold_compacted_text(String(part.text || ""), part_limit),
     };
   }
   if (part.type === "tool-call") {
     return {
-      ...part,
+      ...semantic_part,
       input: fold_compacted_value(part.input, part_limit),
     };
   }
   if (part.type === "tool-result") {
     const serialized_output = safe_stringify(part.output);
-    if (serialized_output.length <= part_limit) return part;
+    if (serialized_output.length <= part_limit) return semantic_part;
     return {
-      ...part,
+      ...semantic_part,
       output: {
         type: "text",
         value: fold_compacted_text(serialized_output, part_limit),
@@ -417,7 +418,19 @@ function compact_model_part(
       };
     }
   }
-  return part;
+  return semantic_part;
+}
+
+/** 压缩后的模型 Part 只作为语义历史传递，不继续携带任何 Provider replay state。 */
+function strip_provider_replay_state(
+  part: Record<string, unknown>,
+): Record<string, unknown> {
+  const {
+    providerOptions: _provider_options,
+    providerMetadata: _provider_metadata,
+    ...semantic_part
+  } = part;
+  return semantic_part;
 }
 
 function fold_compacted_value(value: unknown, max_chars: number): unknown {

package/src/executor/messages/SessionMessageCodec.ts

@@ -96,10 +96,11 @@ 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 converted_messages;
 }

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,