magic-agent 1.0.3 → 1.0.49

package/internal/agent/dsh_resume.go

@@ -0,0 +1,258 @@
+package agent
+
+// dsh_resume.go - dsh 的会话续接：**真续接**（headless `--session-id`）+ `--json` 事件解析。
+//
+// 结论先行（2026-10-09 实测，dsh 0.1.7-rc.2 与 0.2.0-rc.2 都如此）：
+//
+//	dsh 的会话由 **dsh 自己**持久化在 $DSH_HOME/sessions/<cwd-key>/<sessionId>/；
+//	headless profile 提供 `--session-id <id>`（官方 help 原文：
+//	"adopt the persisted Session with this id; an unknown id is an error"）
+//	→ **跨进程续接是支持的**，未知 id 会明确报错、exit 1，绝不静默开新会话。
+//
+// 但只有 headless 通道支持它：SDK 通道（initialize / session/prompt / shutdown）
+// 没有 resume 方法。所以本引擎的分工是：
+//
+//	续接轮（-s <id> / -c）  → headless + --session-id（上下文由 dsh 自己接回来，真续接）
+//	普通轮                → 仍走 SDK 通道（默认：逐 step 流式 + 工具事件）
+//
+// 实测验收：拿 magic-agent 之前**经 SDK 通道**建出的会话 id 直接跑
+//
+//	dsh --profile headless --session-id magic-agent-… "我让你记的数是多少？"
+//
+// 答出了上一轮让它记住的数字，且 `--json` 里的 turn 计数接着往下走
+// （同一条会话，不是副本）—— 说明两条通道共用同一份持久化会话。
+//
+// ⚠️ 会话按 **cwd 分桶**：$DSH_HOME/sessions 下的目录名就是工作区路径的转义。
+// 换工作区就找不到那条会话，所以续接**必须**与上一轮在同一个 workspace 发起 —— 与
+// magic-agent 的 -w 语义一致。找不到时 dsh 会报 `session "…" does not exist`，照实透出。
+//
+// ⚠️ 曾经的「回放式续接」（把 magic-agent 的会话日志前置进 prompt）**已删除**：
+// 那是「以为 dsh 不能按 id 续接」时的兜底，既然真续接可用，就不该再用假续接。
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+)
+
+// ── 续接目标：-s / -c → 会话 id ────────────────────────────────
+
+// dshCanonicalWorkspace 把工作区路径规范化成 dsh 自己会看到的那一份。
+//
+// 为什么必须做：dsh 记会话时用的是**我们交给它的 cwd 字符串**（SDK 通道的
+// initialize.cwd），而续接时 headless 拿自己的 getcwd 去**逐字比对**，只要字符串不同就
+// 拒接 —— macOS 实测：`-w /tmp` 时会话被记成 "/tmp"，续接进程的 getcwd 是
+// "/private/tmp"，于是报
+//
+//	dsh: session "…" was recorded in "/tmp", not "/private/tmp"
+//
+// 两条通道都先用**解析掉符号链接**的路径，记录值与被比对值才是同一份。
+// 解析失败（路径不存在等）就用原值 —— 不做额外猜测。
+func dshCanonicalWorkspace(dir string) string {
+	dir = strings.TrimSpace(dir)
+	if dir == "" {
+		return ""
+	}
+	if resolved, err := filepath.EvalSymlinks(dir); err == nil && resolved != "" {
+		return resolved
+	}
+	return dir
+}
+
+// dshResumeSessionID 本轮要续接的会话 id（空 = 新会话）。
+//
+//	-s/--session <id>  原样交给 dsh（存在性由 dsh 自己校验，未知 id 明确报错）
+//	-c/--continue      从 magic-agent 的会话登记表里挑**同一 workspace** 下最近一条
+//	                   dsh 会话。为什么不读 dsh 自己的会话目录：那个目录名是 cwd 的
+//	                   内部转义（`/private/tmp` → `--private-tmp--`），解析它是猜实现；
+//	                   登记表里 engine / session_id / workspace / 时间都是明文字段。
+func dshResumeSessionID(req Request) string {
+	if id := strings.TrimSpace(req.SessionID); id != "" {
+		return id
+	}
+	if !req.Continue {
+		return ""
+	}
+	return dshLatestSessionID(strings.TrimSpace(req.Workspace))
+}
+
+// dshLatestSessionID 最近一条 dsh 会话的 session_id（可限定 workspace）。
+func dshLatestSessionID(workspace string) string {
+	dir := dshSessionDir()
+	if dir == "" {
+		return ""
+	}
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return ""
+	}
+	var (
+		bestID     string
+		bestAt     time.Time
+		fallback   string // 没有同 workspace 记录时的兜底（同为 dsh 的最近一条）
+		fallbackAt time.Time
+	)
+	for _, e := range entries {
+		name := e.Name()
+		if e.IsDir() || !strings.HasPrefix(name, "run-") || !strings.HasSuffix(name, ".json") {
+			continue
+		}
+		data, err := os.ReadFile(filepath.Join(dir, name))
+		if err != nil {
+			continue
+		}
+		var rec struct {
+			SessionID string    `json:"session_id"`
+			Engine    string    `json:"engine"`
+			Workspace string    `json:"workspace"`
+			UpdatedAt time.Time `json:"updated_at"`
+		}
+		if json.Unmarshal(data, &rec) != nil {
+			continue
+		}
+		if rec.Engine != "dsh" || strings.TrimSpace(rec.SessionID) == "" {
+			continue
+		}
+		if fallback == "" || rec.UpdatedAt.After(fallbackAt) {
+			fallback, fallbackAt = rec.SessionID, rec.UpdatedAt
+		}
+		if workspace != "" && strings.TrimSpace(rec.Workspace) != workspace {
+			continue
+		}
+		if bestID == "" || rec.UpdatedAt.After(bestAt) {
+			bestID, bestAt = rec.SessionID, rec.UpdatedAt
+		}
+	}
+	if bestID != "" {
+		return bestID
+	}
+	return fallback
+}
+
+// dshSessionsEnv 覆盖会话目录的环境变量（与 session.EnvDir 同名同义）。
+const dshSessionsEnv = "MAGIC_AGENT_SESSIONS"
+
+// dshSessionDir 会话日志 / 登记表目录（口径同 session.Dir()）。
+//
+// ⚠️ 不直接调 internal/session：那个包**反向依赖** internal/agent
+// （session.go 用了 agent 的类型），agent 再 import 它就成了环。
+// 路径口径必须与 session.Dir() 保持一致，改一处要改另一处。
+func dshSessionDir() string {
+	if p := strings.TrimSpace(os.Getenv(dshSessionsEnv)); p != "" {
+		return p
+	}
+	home, err := os.UserHomeDir()
+	if err != nil || home == "" {
+		return ""
+	}
+	return filepath.Join(home, ".magic-agent", "sessions")
+}
+
+// ── 能力探测：这台 dsh 的 headless 认不认 --session-id / --json ──
+
+// dshHeadlessCaps headless 支持的两个 flag。
+type dshHeadlessCaps struct {
+	SessionID bool // --session-id（0.1.7+ 才有；没有就当不了真续接）
+	JSON      bool // --json（事件流；没有就走旧版 stderr 推理增量）
+}
+
+var dshCapsCache sync.Map // bin → dshHeadlessCaps
+
+// dshHeadlessCapabilities 探测这台 dsh 支持哪些 headless flag（按 bin 路径缓存）。
+//
+// 为什么必须探测：dsh 启动器在**第一个它不认识的 token 处结束**解析，剩下的都当
+// app 参数交给 headless —— 老版本不认这俩 flag 时，它们会被拼进**任务文本**
+// （静默改写提示词），比直接报错难查得多。探测代价约一次 `--help`，一进程一次。
+//
+// ⚠️ 只有在输出**确实是 headless 的 help**（同时含 "Usage:" 与 "--profile"）时才据它判断；
+// 否则（--help 跑不起来、被包装脚本吞掉、输出被截断）一律按「都支持」处理 ——
+// 「探测不到」不等于「不支持」，宁可让现代 dsh 正常工作，也不因一次探测抖动把续接判死。
+func dshHeadlessCapabilities(ctx context.Context, bin string) dshHeadlessCaps {
+	if v, ok := dshCapsCache.Load(bin); ok {
+		return v.(dshHeadlessCaps)
+	}
+	caps := dshHeadlessCaps{SessionID: true, JSON: true}
+	if stdout, stderr, err := runCLI(ctx, bin, "--profile", "headless", "--help"); err == nil {
+		help := stdout + stderr
+		if strings.Contains(help, "Usage:") && strings.Contains(help, "--profile") {
+			caps.SessionID = strings.Contains(help, "--session-id")
+			caps.JSON = strings.Contains(help, "--json")
+		}
+	}
+	dshCapsCache.Store(bin, caps)
+	return caps
+}
+
+// ── `--json` 事件流（dsh-headless 的 run 投影）────────────────────
+
+// dshJSONEvent `--json` 事件流的一行。
+//
+// 字段与 @deepseek-ai/dsh-headless 的 json-stream 投影逐一对齐（2026-10-09 读源码 +
+// 实测样本核对），只声明本实现用到的部分：
+//
+//	{"type":"session","sessionId":…,"cwd":…}                 会话抬头（id 就在这）
+//	{"type":"status","phase":"turn_start|step_start|step_end|turn_end","turn":N,…}
+//	{"type":"thinking","text":…}                              推理块（已提交）
+//	{"type":"text","text":…}                                  正文块（已提交，按 step）
+//	{"type":"tool_call","callId":…,"tool":…,"input":…}        工具调用（input 是**解析后**的 JSON）
+//	{"type":"tool_result","callId":…,"status":…,"result":…}   工具结果
+//	{"type":"final","text":…}                                 收尾正文（整轮汇总）
+//
+// 文本与推理都来自**已提交的 assistant/message**，不会是随后被重试/丢弃的尝试内容。
+type dshJSONEvent struct {
+	Type      string          `json:"type"`
+	Text      string          `json:"text"`
+	Phase     string          `json:"phase"`
+	Turn      int             `json:"turn"`
+	Step      int             `json:"step"`
+	SessionID string          `json:"sessionId"`
+	Cwd       string          `json:"cwd"`
+	CallID    string          `json:"callId"`
+	Tool      string          `json:"tool"`
+	Input     json.RawMessage `json:"input"`
+	Status    string          `json:"status"`
+	Result    string          `json:"result"`
+}
+
+// parseDshJSONEvent 解析一行事件；空行 / 非 JSON / 认不出（无 type）都不算事件。
+func parseDshJSONEvent(line string) (dshJSONEvent, bool) {
+	line = strings.TrimSpace(line)
+	if line == "" || line[0] != '{' {
+		return dshJSONEvent{}, false
+	}
+	var ev dshJSONEvent
+	if json.Unmarshal([]byte(line), &ev) != nil || ev.Type == "" {
+		return dshJSONEvent{}, false
+	}
+	return ev, true
+}
+
+// dshJSONArgs 把 tool_call 的 `input` 变成可放进 StreamEvent.Text 的字符串。
+//
+// dsh 给的是**解析后的** JSON（对象或原始字符串），而 SDK 通道给的是原始字符串 ——
+// 两条通道最终都要「一段文本」，所以这里：JSON 字符串取内容，其余保留其 JSON 文本。
+func dshJSONArgs(raw json.RawMessage) string {
+	s := strings.TrimSpace(string(raw))
+	if s == "" || s == "null" {
+		return ""
+	}
+	if s[0] == '"' {
+		var unquoted string
+		if json.Unmarshal(raw, &unquoted) == nil {
+			return unquoted
+		}
+	}
+	return s
+}
+
+// dshResumeUnsupportedHint 给「这台 dsh 不支持 --session-id」时的可执行结论。
+func dshResumeUnsupportedHint(bin string) string {
+	return fmt.Sprintf("dsh: 这台 dsh 的 headless 不认 --session-id，无法按 id 续接（%s）。"+
+		"升级 dsh（`npm i -g @deepseek-ai/dsh`）后重试；需要多轮上下文也可以改用常驻会话："+
+		"`magic-agent -e dsh --stream --keep-alive \"首轮\"` 再 `magic-agent --append <run_id|session_id> -p \"追加\"`", bin)
+}

package/internal/agent/dsh_sdk.go

@@ -61,7 +61,6 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"path/filepath"
 	"strings"
 	"sync"
 	"time"
@@ -176,9 +175,43 @@ type dshSDKTextBlock struct {
 	Text string `json:"text"`
 }
 
+// dshSDKImageBlock = SdkEncodedImageBlock：prompt 里内联的图片（官方 d.ts 具名结构）。
+//
+// mimeType 只接受下面四种（协议原文），故调用方先按 MIME 过滤（见 dshNativeImageMIME）：
+// 图片以 base64 inline 进运行时自己的附件存储，模型真的能看到，不再依赖读文件工具。
+type dshSDKImageBlock struct {
+	Type     string `json:"type"`     // 恒为 "image"
+	Data     string `json:"data"`     // 规范 base64 编码的位图字节
+	MimeType string `json:"mimeType"` // image/png | image/jpeg | image/webp | image/gif
+}
+
+// dshSDKPromptParams = SessionPromptParams。contentBlocks 允许混排
+// 普通 ContentBlock（text 等）与待收纳的内联图片块 → 用 []any 承载。
 type dshSDKPromptParams struct {
-	SessionID     string            `json:"sessionId"`
-	ContentBlocks []dshSDKTextBlock `json:"contentBlocks"`
+	SessionID     string `json:"sessionId"`
+	ContentBlocks []any  `json:"contentBlocks"`
+}
+
+// dshPromptBlocks 组装一条 prompt 的 contentBlocks：正文 text 块 + 图片附件的原生 image 块。
+//
+// 为什么图片不再走「路径写进提示词」：能读图的模型（如 deepseek-v4.1-flash）配好模态后，
+// SDK 的 `session/prompt` 直接接受 SdkEncodedImageBlock，图片以 base64 inline 进模型上下文
+// —— 真识图。非图片附件（PDF / bmp / 文本…）协议里没有内联类型，仍由调用方写进提示词。
+//
+// 读盘失败返回错误（附件是调用方点名要发的东西，静默丢掉比失败更糟）。
+func dshPromptBlocks(text string, atts []Attachment) ([]any, error) {
+	blocks := []any{dshSDKTextBlock{Type: "text", Text: text}}
+	for _, a := range atts {
+		if !dshNativeImageMIME(a.MIME) {
+			continue
+		}
+		data, err := readAttachmentBase64(a)
+		if err != nil {
+			return nil, err
+		}
+		blocks = append(blocks, dshSDKImageBlock{Type: "image", Data: data, MimeType: a.MIME})
+	}
+	return blocks, nil
 }
 
 // dshSDKSessionEvent = SessionEventNotification。
@@ -259,6 +292,10 @@ func dshSDKTurn(ctx context.Context, bin, workspace string, req Request, prompt
 	}
 
 	cmd := newStreamCmdIn(workspace, bin, []string{"--profile", dshSDKProfile})
+	/* 权限档位：dsh 没有逐调用的权限 flag，档位走子进程环境变量 —— shipped 的 sdk
+	   profile 里 sandbox-policy.mode 与 user-approval.policy 都直接读它（见
+	   permission.go::dshPermissionMode 的核实来源）。空档位 = 不注入，用 dsh 自己的默认。 */
+	cmd.Env = append(cmd.Env, dshPermissionEnv(req.Permission)...)
 
 	/* 三条管道都自建（不直挂 bytes.Buffer / StdinPipe 的 stdout 侧）：
 	   沿用 runcmd.go / stream.go 的同一条经验 —— Go 只在目标是 *os.File 时才不做内部
@@ -406,6 +443,13 @@ func dshSDKTurn(ctx context.Context, bin, workspace string, req Request, prompt
 	// agent on it」），但 SDK 协议只有 initialize / session/prompt / shutdown 三个方法，
 	// 没有暴露它 —— 只有 Web/TUI 那条 host API 用得上 resume。
 	sessionID := newDshSessionID()
+	// 会话 id 由 magic-agent 生成 → **立刻**回报给调用方（「看历史」持久化靠它）。
+	// ⚠️ 必须在 session/prompt 之前：core CLI 的 sessionWriter 拿到 id 才会开文件，
+	// 报晚了本轮前几条事件就没有落点（历史里会缺开头）。dsh 是唯一一个
+	// id 由我们自造、而不是从 CLI 流里读出来的引擎（见 engine.go 的 OnSessionID）。
+	if req.OnSessionID != nil {
+		req.OnSessionID(sessionID)
+	}
 	out := dshSDKTurnResult{Provider: provider, Model: model, SessionID: sessionID}
 	callIndex := map[string]int{}
 	promptIDs := map[int]bool{} // 已发出的 prompt 请求 id（用来把它的错误响应挑出来）
@@ -423,10 +467,10 @@ func dshSDKTurn(ctx context.Context, bin, workspace string, req Request, prompt
 			onEvent(ev)
 		}
 	}
-	sendPrompt := func(text string) error {
+	sendPrompt := func(blocks []any) error {
 		id, serr := send("session/prompt", dshSDKPromptParams{
 			SessionID:     sessionID,
-			ContentBlocks: []dshSDKTextBlock{{Type: "text", Text: text}},
+			ContentBlocks: blocks,
 		})
 		if serr != nil {
 			return serr
@@ -436,6 +480,10 @@ func dshSDKTurn(ctx context.Context, bin, workspace string, req Request, prompt
 		roundEnded = false
 		return nil
 	}
+	// textBlocks 单文本块（追加轮用：附件只随首轮发）。
+	textBlocks := func(text string) []any {
+		return []any{dshSDKTextBlock{Type: "text", Text: text}}
+	}
 	// finish 收尾：先让读线程转入「只读不投递」，再发 shutdown（协议唯一的「结束」
 	// 手段，没有 cancel 方法）。幂等 —— turn/end、session.status:idle、追加通道关闭
 	// 三条收尾路径都可能走到。
@@ -466,7 +514,12 @@ func dshSDKTurn(ctx context.Context, bin, workspace string, req Request, prompt
 		}
 		return dshSDKTurnResult{}, false, nil
 	}
-	if err := sendPrompt(prompt); err != nil {
+	// 首轮带附件：图片走协议原生 image 块（非图片附件已由调用方写进 prompt 正文）。
+	initialBlocks, berr := dshPromptBlocks(prompt, req.Attachments)
+	if berr != nil {
+		return dshSDKTurnResult{}, fmt.Errorf("dsh sdk: 读附件: %v", berr)
+	}
+	if err := sendPrompt(initialBlocks); err != nil {
 		return dshSDKTurnResult{}, fmt.Errorf("dsh sdk: 写 session/prompt: %v", err)
 	}
 
@@ -494,7 +547,7 @@ func dshSDKTurn(ctx context.Context, bin, workspace string, req Request, prompt
 			if strings.TrimSpace(text) == "" {
 				continue
 			}
-			if err := sendPrompt(text); err != nil {
+			if err := sendPrompt(textBlocks(text)); err != nil {
 				return out, fmt.Errorf("dsh sdk: 写 session/prompt（追加）: %v", err)
 			}
 		case msg, ok := <-inbound:
@@ -656,18 +709,16 @@ func dshStderrTail(s string) string {
 	return ": " + strings.TrimSpace(lines[len(lines)-1])
 }
 
-// DshConfiguredRoute 读 $DSH_HOME/settings.yaml 里 agent-default-model 的 (provider, model)。
-// SDK 的 initialize 两者都是必填；读不到就只能回退 headless。
+// DshConfiguredRoute 读 dsh 配置里 agent-default-model 的 (provider, model)
+// （位置随版本变：0.1.7+ 在 profile 的 cordis.patch.yml，更早在 settings.yaml，
+// 见 dshConfigDocs）。SDK 的 initialize 两者都是必填；读不到就只能回退 headless。
 func DshConfiguredRoute() (string, string) {
-	home := DshHome()
-	if home == "" {
-		return "", ""
-	}
-	data, err := os.ReadFile(filepath.Join(home, "settings.yaml"))
-	if err != nil {
-		return "", ""
+	for _, d := range dshConfigDocs() {
+		if p, m := parseDshDefaultModelRoute(d.legacyText()); p != "" || m != "" {
+			return p, m
+		}
 	}
-	return parseDshDefaultModelRoute(string(data))
+	return "", ""
 }
 
 // newDshSessionID 生成 SDK 侧会话 id。

package/internal/agent/dsh_sdk_test.go

@@ -19,6 +19,8 @@ package agent
 
 import (
 	"context"
+	"encoding/base64"
+	"encoding/json"
 	"errors"
 	"os"
 	"path/filepath"
@@ -137,9 +139,9 @@ func TestDshSDKIsDefaultTransport(t *testing.T) {
 	if resp.Model != "modelverse/deepseek-v4.1-flash" {
 		t.Errorf("Model = %q want modelverse/deepseek-v4.1-flash", resp.Model)
 	}
-	// dsh 续不上会话 → 不回可续接的 id（见 errDshNoSessionResume）。
+	// Complete 只回正文，不回会话 id（Stream 才回，见下一条用例）。
 	if resp.SessionID != "" {
-		t.Errorf("SessionID = %q want 空（dsh 不支持续接）", resp.SessionID)
+		t.Errorf("SessionID = %q want 空", resp.SessionID)
 	}
 	args := readFileString(t, argsLog)
 	if !strings.Contains(args, "--profile sdk") {
@@ -150,6 +152,26 @@ func TestDshSDKIsDefaultTransport(t *testing.T) {
 	}
 }
 
+// 会话 id 由 magic-agent 自造 → 必须回报给调用方（「看历史」持久化靠它；
+// 早先 dsh 从不调 OnSessionID，导致 dsh 会话根本不落盘）。
+func TestDshSDKReportsSessionID(t *testing.T) {
+	dshSDKHome(t, "modelverse", "deepseek-v4.1-flash")
+	dir := t.TempDir()
+	bin, _, _ := dshSDKStub(t, dir, dshSDKStubOpts{})
+
+	var got []string
+	_, err := (&DshEngine{BinPath: bin}).Stream(context.Background(), Request{
+		Messages:    []Message{{Role: "user", Content: "hi"}},
+		OnSessionID: func(id string) { got = append(got, id) },
+	}, nil)
+	if err != nil {
+		t.Fatalf("Stream: %v", err)
+	}
+	if len(got) == 0 || !strings.HasPrefix(got[0], "magic-agent-") {
+		t.Errorf("OnSessionID 应收到自造的会话 id, got %v", got)
+	}
+}
+
 // 流式：推理 / 工具调用 / 工具结果 / 正文 / turn 收尾，全部按顺序上报。
 func TestDshSDKStreamEmitsAllEventKinds(t *testing.T) {
 	dshSDKHome(t, "modelverse", "deepseek-v4.1-flash")
@@ -706,6 +728,84 @@ func TestDshSDKAppendSkipsBlank(t *testing.T) {
 	}
 }
 
+// 图片附件走协议原生 image 块（SdkEncodedImageBlock）：base64 inline 进
+// session/prompt 的 contentBlocks（真进模型上下文）；非图片附件仍写进提示词正文
+// （协议里没有通用文件内联类型，只能走路径，靠 dsh 自己的读文件工具看）。
+func TestDshSDKImageAttachmentIsNativeBlock(t *testing.T) {
+	dshSDKHome(t, "modelverse", "deepseek-v4.1-flash")
+	dir := t.TempDir()
+	bin, _, stdinLog := dshSDKStub(t, dir, dshSDKStubOpts{})
+
+	img := writeTestPNG(t, "shot.png")
+	txt := writeTestFile(t, "notes.txt", "文件里的说明")
+
+	if _, err := (&DshEngine{BinPath: bin}).Complete(context.Background(), Request{
+		Messages:    []Message{{Role: "user", Content: "这张图什么颜色"}},
+		Attachments: []Attachment{NewAttachment(img), NewAttachment(txt)},
+	}); err != nil {
+		t.Fatalf("Complete: %v", err)
+	}
+
+	type block struct {
+		Type     string `json:"type"`
+		Text     string `json:"text"`
+		Data     string `json:"data"`
+		MimeType string `json:"mimeType"`
+	}
+	type frame struct {
+		Method string `json:"method"`
+		Params struct {
+			ContentBlocks []block `json:"contentBlocks"`
+		} `json:"params"`
+	}
+
+	var blocks []block
+	var sawPrompt bool
+	for _, ln := range strings.Split(readFileString(t, stdinLog), "\n") {
+		var f frame
+		if err := json.Unmarshal([]byte(ln), &f); err != nil {
+			continue
+		}
+		if f.Method == "session/prompt" {
+			blocks = append(blocks, f.Params.ContentBlocks...)
+			sawPrompt = true
+		}
+	}
+	if !sawPrompt {
+		t.Fatal("没有发出 session/prompt 请求")
+	}
+
+	var textBlock string
+	var images []string
+	for _, b := range blocks {
+		switch b.Type {
+		case "text":
+			textBlock = b.Text
+		case "image":
+			if b.MimeType != "image/png" {
+				t.Errorf("image 块 mimeType = %q want image/png", b.MimeType)
+			}
+			images = append(images, b.Data)
+		}
+	}
+	if len(images) != 1 {
+		t.Fatalf("image 块数 = %d want 1（只有那张 png 走原生）", len(images))
+	}
+	want, err := os.ReadFile(img)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if images[0] != base64.StdEncoding.EncodeToString(want) {
+		t.Errorf("image 块 data 应是图片字节的 base64")
+	}
+	if strings.Contains(textBlock, "shot.png") {
+		t.Errorf("图片走原生块后不该再以路径写进正文: %q", textBlock)
+	}
+	if !strings.Contains(textBlock, "notes.txt") {
+		t.Errorf("非图片附件应写进提示词路径清单: %q", textBlock)
+	}
+}
+
 // ── 小工具 ────────────────────────────────────────────────────
 
 func readFileString(t *testing.T, p string) string {