magic-agent 1.0.0

package/internal/cli/control_test.go

@@ -0,0 +1,192 @@
+package cli
+
+import (
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+// lineWriter 收集每次写入的行，供异步断言使用（控制通道是后台 goroutine 在写）。
+type lineWriter struct {
+	mu    sync.Mutex
+	lines []string
+	ch    chan string
+}
+
+func newLineWriter() *lineWriter {
+	return &lineWriter{ch: make(chan string, 64)}
+}
+
+func (w *lineWriter) Write(p []byte) (int, error) {
+	for _, ln := range strings.Split(strings.TrimSpace(string(p)), "\n") {
+		if ln == "" {
+			continue
+		}
+		w.mu.Lock()
+		w.lines = append(w.lines, ln)
+		w.mu.Unlock()
+		w.ch <- ln
+	}
+	return len(p), nil
+}
+
+// wait 等够 n 行（超时即失败），返回收到的行。
+func (w *lineWriter) wait(t *testing.T, n int) []string {
+	t.Helper()
+	got := make([]string, 0, n)
+	deadline := time.After(3 * time.Second)
+	for len(got) < n {
+		select {
+		case ln := <-w.ch:
+			got = append(got, ln)
+		case <-deadline:
+			t.Fatalf("等待第 %d 行超时；已收到 %v", n, got)
+		}
+	}
+	return got
+}
+
+// TestControlPingAndUnknownOp 未知 op 只回一条 control_error，**不中断读取** ——
+// 一个拼错的 op 不该让整条控制通道失效。
+func TestControlPingAndUnknownOp(t *testing.T) {
+	w := newLineWriter()
+	ctl := startControlReader(
+		strings.NewReader(`{"op":"ping"}`+"\n"+`{"op":"nope"}`+"\n"+`{"op":"ping"}`+"\n"),
+		newEventSink(w, "claude", true), controlHooks{})
+	defer ctl.Close()
+
+	lines := w.wait(t, 3)
+	if !strings.Contains(lines[0], `"type":"pong"`) {
+		t.Errorf("第 1 行应是 pong，实际 %s", lines[0])
+	}
+	if !strings.Contains(lines[1], `"type":"control_error"`) {
+		t.Errorf("未知 op 应回 control_error，实际 %s", lines[1])
+	}
+	if !strings.Contains(lines[2], `"type":"pong"`) {
+		t.Errorf("未知 op 之后应继续读命令，实际 %s", lines[2])
+	}
+}
+
+// TestControlBadJSON 非 JSON 行回 control_error 并继续。
+func TestControlBadJSON(t *testing.T) {
+	w := newLineWriter()
+	ctl := startControlReader(strings.NewReader("这不是 JSON\n"+`{"op":"ping"}`+"\n"),
+		newEventSink(w, "claude", true), controlHooks{})
+	defer ctl.Close()
+
+	lines := w.wait(t, 2)
+	if !strings.Contains(lines[0], "control_error") {
+		t.Errorf("非 JSON 行应回 control_error，实际 %s", lines[0])
+	}
+	if !strings.Contains(lines[1], "pong") {
+		t.Errorf("之后应继续读，实际 %s", lines[1])
+	}
+}
+
+// TestControlAnswer 常驻不可用时 answer 要回**可读的** control_error（不静默丢）；
+// 可用时回 answered 且文本原样送达。
+func TestControlAnswer(t *testing.T) {
+	t.Run("常驻不可用", func(t *testing.T) {
+		w := newLineWriter()
+		ctl := startControlReader(strings.NewReader(`{"op":"answer","text":"选 A"}`+"\n"),
+			newEventSink(w, "claude", true), controlHooks{})
+		defer ctl.Close()
+		ln := w.wait(t, 1)[0]
+		if !strings.Contains(ln, "control_error") {
+			t.Errorf("应回 control_error，实际 %s", ln)
+		}
+		if !strings.Contains(ln, "常驻") {
+			t.Errorf("错误文案应说明走的是常驻会话，实际 %s", ln)
+		}
+	})
+
+	t.Run("空文本", func(t *testing.T) {
+		w := newLineWriter()
+		ctl := startControlReader(strings.NewReader(`{"op":"answer"}`+"\n"),
+			newEventSink(w, "claude", true), controlHooks{answer: func(string) bool { return true }})
+		defer ctl.Close()
+		if ln := w.wait(t, 1)[0]; !strings.Contains(ln, "control_error") {
+			t.Errorf("空 text 应回 control_error，实际 %s", ln)
+		}
+	})
+
+	t.Run("可用", func(t *testing.T) {
+		w := newLineWriter()
+		var got atomic.Value
+		ctl := startControlReader(strings.NewReader(`{"op":"answer","text":"选 A"}`+"\n"),
+			newEventSink(w, "claude", true), controlHooks{
+				answer: func(text string) bool { got.Store(text); return true },
+			})
+		defer ctl.Close()
+		if ln := w.wait(t, 1)[0]; !strings.Contains(ln, `"type":"answered"`) {
+			t.Errorf("应回 answered，实际 %s", ln)
+		}
+		if v, _ := got.Load().(string); v != "选 A" {
+			t.Errorf("答案文本 = %q want 选 A", v)
+		}
+	})
+}
+
+// TestControlInterruptAndStop interrupt 不立即回应答（应答在本轮真的结束时发），
+// stop 立即回；两个标志位都要落。
+func TestControlInterruptAndStop(t *testing.T) {
+	w := newLineWriter()
+	var gotReason atomic.Value
+	ctl := startControlReader(
+		strings.NewReader(`{"op":"interrupt","reason":"用户点了停止"}`+"\n"+`{"op":"stop"}`+"\n"),
+		newEventSink(w, "claude", true), controlHooks{
+			interrupt: func(reason string) { gotReason.Store(reason) },
+		})
+	defer ctl.Close()
+
+	// interrupt 不发应答，所以第一条应当是 stop 的 stopped。
+	if ln := w.wait(t, 1)[0]; !strings.Contains(ln, `"type":"stopped"`) {
+		t.Errorf("第一条应答应是 stopped，实际 %s", ln)
+	}
+	if v, _ := gotReason.Load().(string); v != "用户点了停止" {
+		t.Errorf("interrupt reason = %q want 用户点了停止", v)
+	}
+	if !ctl.WasInterrupted() {
+		t.Error("WasInterrupted 应为 true")
+	}
+	if !ctl.WasStopped() {
+		t.Error("WasStopped 应为 true")
+	}
+}
+
+// TestControlStopCallsHook stop 要真的触发收工动作。
+func TestControlStopCallsHook(t *testing.T) {
+	w := newLineWriter()
+	var stopped atomic.Bool
+	ctl := startControlReader(strings.NewReader(`{"op":"stop"}`+"\n"),
+		newEventSink(w, "claude", true), controlHooks{stop: func() { stopped.Store(true) }})
+	defer ctl.Close()
+	w.wait(t, 1)
+	if !stopped.Load() {
+		t.Error("stop hook 未调用")
+	}
+}
+
+// TestKeepAlivePushAfterShutdown Push 与 shutdown 的竞态防线：
+// 收工之后必须返回 false，**不能**向已关闭通道发送（那会 panic）。
+func TestKeepAlivePushAfterShutdown(t *testing.T) {
+	ka := &keepAlive{in: make(chan string, 1), appendCh: make(chan string, 1)}
+
+	if !ka.Push("hello") {
+		t.Fatal("收工前 Push 应成功")
+	}
+	if got := <-ka.in; got != "hello" {
+		t.Errorf("Push 内容 = %q want hello", got)
+	}
+
+	ka.shutdown()
+	if ka.Push("again") {
+		t.Error("收工后 Push 必须返回 false")
+	}
+	ka.shutdown() // 幂等：重复收工不该 panic
+	if ka.Push("") {
+		t.Error("空文本不该被接受")
+	}
+}

package/internal/cli/engines_test.go

@@ -0,0 +1,205 @@
+package cli
+
+// engines_test.go - `--engines` 的「一键安装 / 升级命令」（install 字段）与版本号（version）装配测试。
+//
+// 需求（2026-09-21）：「引擎列表返回不可用的引擎时包括一键安装引擎的命令 这样检测到
+// 无法安装的可以直接安装」；（2026-09-23）「引擎检测除了 a2a 的 其他也要支持有升级」。
+// 约定（**当前契约**）：
+//
+//	有官方安装方式的引擎 → **一律给 install**（不管 ok 是 true 还是 false）：
+//	    ok:false → 调用方当「安装」用；ok:true → 当「升级」用（重跑一遍 = 装最新版）
+//	没有可执行安装路径的引擎（codebuddy 是 GUI 应用、arkclaw / 具名 A2A agent 是远端网关）
+//	    → 不给该字段，原因在同行的 note 里（不编一条跑不通的命令）
+//	version → 可用引擎尽力而为地给（`<bin> --version` 的第一个 semver）；`--no-models`
+//	    跳过探测 → 一个都不给（本文件据此断言「该档零探测」）
+//
+// ⚠️ 注册假引擎的名字必须避开「别的测试行为上依赖」的名字：
+// `agent.Lookup` 取注册表里**首个**同名匹配，而 Go 按文件名字母序跑测试
+// （engines_test.go 在 keepalive_test.go / permission_test.go 之前）。两个坑：
+//   - name:"codebuddy" 会挡住 keepalive_test.go 需要的**流式** codebuddy 假引擎
+//     → TestKeepAliveIsDefaultForStreaming / TestKeepAliveAppendEndToEnd 稳定超时；
+//   - name:"dsh" 会被 attach_test.go（先跑）注册的可用假引擎挡住 → ok 报 true。
+// 故这里只用 openclaw（install 用例）、codebuddy-ai（无 install 用例）与 llm（可用 + 有命令用例）：
+// 整包测试里没有别的文件在它们之前注册过这三个名字。
+//
+// 注：codebuddy / arkclaw 确实没有一键安装命令，但那个断言放在
+// internal/agent/engine_base_test.go 的 TestInstallCommandOf 里做（纯函数、零副作用），
+// 不必在这个会改全局注册表的测试里再注册一次它们的同名假引擎。
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/darren/magic-agent/internal/agent"
+)
+
+// unavailableEngine 探测失败的假引擎（ok:false 路径）。
+type unavailableEngine struct{ name string }
+
+func (u *unavailableEngine) Name() string { return u.name }
+
+func (u *unavailableEngine) Detect() (bool, string) {
+	return false, u.name + " CLI not found (install it or set the BIN env)"
+}
+
+func (u *unavailableEngine) Complete(context.Context, agent.Request) (agent.Response, error) {
+	return agent.Response{}, errors.New("unavailable")
+}
+
+func TestEnginesInstallCommandByAvailability(t *testing.T) {
+	// 四个假引擎：
+	//   不可用 + 有一键安装命令（openclaw）
+	//   不可用 + 也有（codebuddy-ai：2026-09-28 起是**独立安装**的 CodeBuddy Code CLI，
+	//     不再是桌面 GUI 应用）
+	//   不可用 + 没有（codebuddy-gateway：它要的是「把网关跑起来」而不是安装）
+	//   可用 + 有一键安装命令（llm，用来钉「可用时也给 = 当升级用」）
+	registerFake(&unavailableEngine{name: "openclaw"})
+	registerFake(&unavailableEngine{name: "codebuddy-ai"})
+	registerFake(&unavailableEngine{name: "codebuddy-gateway"})
+	registerFake(&stringEngine{name: "llm", text: "x"})
+
+	stdout, _, err := runAskCmd(t, "", "--engines", "--no-models")
+	if err != nil {
+		t.Fatalf("--engines: %v", err)
+	}
+	var rows []struct {
+		Engine  string `json:"engine"`
+		OK      bool   `json:"ok"`
+		Note    string `json:"note"`
+		Install string `json:"install"`
+	}
+	if err := json.Unmarshal([]byte(strings.TrimSpace(stdout)), &rows); err != nil {
+		t.Fatalf("--engines 输出不是 JSON 数组: %v\n%s", err, stdout)
+	}
+
+	// 1) 不可用 + 有安装命令：install 非空、note 也保留（人读原因）。
+	const wantInstall = "npm install -g openclaw@latest"
+	foundWithInstall := false
+	for _, r := range rows {
+		if r.Engine != "openclaw" {
+			continue
+		}
+		if r.OK {
+			t.Fatal("openclaw 假引擎应报 ok:false")
+		}
+		foundWithInstall = true
+		if r.Install != wantInstall {
+			t.Errorf("openclaw 的 install = %q want %q", r.Install, wantInstall)
+		}
+		if r.Note == "" {
+			t.Error("openclaw 不可用却没给 note")
+		}
+	}
+	if !foundWithInstall {
+		t.Fatal("--engines 缺 openclaw 行")
+	}
+
+	// 2) 不可用但没有可执行安装命令：install 必须为空（原因在 note）。
+	foundGateway := false
+	for _, r := range rows {
+		if r.Engine != "codebuddy-gateway" {
+			continue
+		}
+		if r.OK {
+			t.Fatal("codebuddy-gateway 假引擎应报 ok:false")
+		}
+		foundGateway = true
+		if r.Install != "" {
+			t.Errorf("codebuddy-gateway（要的是「把网关跑起来」，不是安装）不该给 install，got %q", r.Install)
+		}
+		if r.Note == "" {
+			t.Error("codebuddy-gateway 不可用却没给 note（怎么才能用要靠它说明）")
+		}
+	}
+	if !foundGateway {
+		t.Fatal("--engines 缺 codebuddy-gateway 行")
+	}
+
+	// 2b) codebuddy-ai 改成独立安装的 CLI 之后，要给一键安装命令
+	//     （2026-09-28：不再走桌面 App 内置 CLI，见 engine_base.go 的 codebuddyBase 注释）。
+	foundAI := false
+	for _, r := range rows {
+		if r.Engine != "codebuddy-ai" {
+			continue
+		}
+		foundAI = true
+		if want := agent.InstallCommandOf("codebuddy-ai"); r.Install != want {
+			t.Errorf("codebuddy-ai 的 install = %q want %q", r.Install, want)
+		}
+	}
+	if !foundAI {
+		t.Fatal("--engines 缺 codebuddy-ai 行")
+	}
+
+	// 3) **可用**引擎只要该引擎有官方安装方式，照样给 install（2026-09-23 新契约：
+	//    同一条命令对已装好的引擎重跑一遍 = 升级到最新版，调用方据此把按钮写成「升级」）。
+	foundOKWithInstall := false
+	for _, r := range rows {
+		if r.Engine != "llm" || !r.OK {
+			continue
+		}
+		foundOKWithInstall = true
+		if r.Install != agent.InstallCommandOf("llm") {
+			t.Errorf("llm（可用）的 install = %q want %q", r.Install, agent.InstallCommandOf("llm"))
+		}
+	}
+	if !foundOKWithInstall {
+		t.Fatal("--engines 缺可用的 llm 行（本用例要钉「可用时也给 install」）")
+	}
+
+	// 4) 全局不变式：install 非空 ⟺ 该引擎确实有官方安装命令（与 ok 无关）。
+	for _, r := range rows {
+		want := agent.InstallCommandOf(r.Engine)
+		if want == "" && r.Install != "" {
+			t.Errorf("%s 没有官方安装方式却带了 install = %q", r.Engine, r.Install)
+		}
+		if want != "" && r.Install != want {
+			t.Errorf("%s 的 install = %q want %q（不管 ok 是 %v）", r.Engine, r.Install, want, r.OK)
+		}
+	}
+}
+
+// `--no-models` 档跳过版本探测：一个 version 都不给（该档的卖点就是「不启动任何 CLI」）。
+func TestEnginesVersionSkippedWithNoModels(t *testing.T) {
+	registerFake(&stringEngine{name: "fake-eng-ver", text: "x"})
+
+	stdout, _, err := runAskCmd(t, "", "--engines", "--no-models")
+	if err != nil {
+		t.Fatalf("--engines: %v", err)
+	}
+	var rows []map[string]any
+	if err := json.Unmarshal([]byte(strings.TrimSpace(stdout)), &rows); err != nil {
+		t.Fatalf("解析失败: %v\n%s", err, stdout)
+	}
+	for _, r := range rows {
+		if _, ok := r["version"]; ok {
+			t.Errorf("--no-models 不该给 version（零探测）: %v", r)
+		}
+	}
+}
+
+// install 字段的 omitempty：没有官方安装方式的引擎，JSON 里**不应出现**该 key（不是空串）。
+func TestEnginesInstallKeyOmittedWhenNoCommand(t *testing.T) {
+	registerFake(&stringEngine{name: "install-fake-ok-2", text: "x"})
+
+	stdout, _, err := runAskCmd(t, "", "--engines", "--no-models")
+	if err != nil {
+		t.Fatalf("--engines: %v", err)
+	}
+	var rows []map[string]any
+	if err := json.Unmarshal([]byte(strings.TrimSpace(stdout)), &rows); err != nil {
+		t.Fatalf("解析失败: %v\n%s", err, stdout)
+	}
+	for _, r := range rows {
+		if r["engine"] == "install-fake-ok-2" {
+			if _, ok := r["install"]; ok {
+				t.Errorf("没有官方安装方式的引擎不该有 install key: %v", r)
+			}
+			return
+		}
+	}
+	t.Fatal("--engines 输出里没找到 install-fake-ok-2")
+}

package/internal/cli/events.go

@@ -0,0 +1,198 @@
+package cli
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"sync"
+
+	"github.com/darren/magic-agent/internal/agent"
+)
+
+/* 事件契约 v1（客户端消费形态）：给流式事件加版本与游标。
+ *
+ * 为什么需要（2026-09-27）：`--stream` 的 NDJSON 事件流此前没有版本号、也没有
+ * 序号，客户端（magic-client 桌面 / 移动插件）因此回答不了两个必须回答的问题：
+ *   1) 这份输出我能不能解析？—— 字段改名时老客户端会静默解析失败，界面上表现为空白；
+ *   2) 我收到的是否连续、有没有漏行？—— 断线重连要按游标续读。
+ * 于是 `--events` 在**不改老形状**的前提下补三样：
+ *   v            契约版本，与 `--contract` 的 contractVersion 同一个数
+ *   seq          单次进程内单调递增的行号（从 1 开始）
+ *   session_id   一旦拿到就每行都带（老形状只在 turn_end / result 带）
+ * 沿用老形状已有的约定：**每轮一定以 result 或 error 收尾**。
+ *
+ * ⚠️ `--events` 与 `--stream` 的输出**形状不同**，别混用：
+ *   老消费者继续用 `--stream`（逐字节不变）；新客户端用 `--stream --events`。
+ *   两条路径共用 streamEventPayload()，靠测试钉住「字段集只差 v / seq」。
+ */
+
+// eventSink 事件出口。enabled=false 时输出与历史形状逐字节一致。
+type eventSink struct {
+	w       io.Writer
+	engine  string
+	enabled bool
+
+	mu      sync.Mutex
+	seq     int
+	session string
+}
+
+func newEventSink(w io.Writer, engine string, enabled bool) *eventSink {
+	return &eventSink{w: w, engine: engine, enabled: enabled}
+}
+
+// Enabled 是否处于 `--events` 形态。控制通道的应答只在它下面输出（老形状不认新事件类型）。
+func (s *eventSink) Enabled() bool { return s.enabled }
+
+// setSession 记住会话 id（拿到之后后续每行都带）。
+func (s *eventSink) setSession(id string) {
+	if id == "" {
+		return
+	}
+	s.mu.Lock()
+	s.session = id
+	s.mu.Unlock()
+}
+
+// nextSeq 取下一个行号（调用方不要再持锁调它）。
+func (s *eventSink) nextSeq() int {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.seq++
+	return s.seq
+}
+
+// sessionID 当前已知的会话 id。
+func (s *eventSink) sessionID() string {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.session
+}
+
+func (s *eventSink) writeLine(b []byte) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	_, err := fmt.Fprintln(s.w, string(b))
+	return err
+}
+
+// event 输出一行事件。
+//
+// 老形态（未开 --events）：payload 原样一行，与历史输出逐字节一致。
+// 新形态：payload 的字段集不变，外层补 v / seq（以及已知的 session_id）。
+// 只在新形态下走一次「marshal → 加字段 → marshal」的往返 —— 它是客户端路径，
+// 每行多一次解析换「两个形状永不漂」是划算的。
+func (s *eventSink) event(payload any) error {
+	b, err := json.Marshal(payload)
+	if err != nil {
+		return err
+	}
+	if !s.enabled {
+		return s.writeLine(b)
+	}
+	var m map[string]any
+	if err := json.Unmarshal(b, &m); err != nil {
+		return err
+	}
+	return s.eventAttrs(m)
+}
+
+// eventAttrs 输出一行带 envelope 的新形态事件（attrs 至少要有 type）。
+func (s *eventSink) eventAttrs(attrs map[string]any) error {
+	if !s.enabled {
+		return nil
+	}
+	seq := s.nextSeq()
+	env := make(map[string]any, len(attrs)+3)
+	for k, v := range attrs {
+		env[k] = v
+	}
+	env["v"] = agent.ContractVersion
+	env["seq"] = seq
+	if sess := s.sessionID(); sess != "" {
+		if _, ok := env["session_id"]; !ok {
+			env["session_id"] = sess
+		}
+	}
+	b, err := json.Marshal(env)
+	if err != nil {
+		return err
+	}
+	return s.writeLine(b)
+}
+
+// stream 输出一条引擎流式事件。
+//
+// 未开 --events 时直接走老写入函数（逐字节不变）；开了才补 v / seq。
+// 两条路径共用 streamEventPayload()，字段集因此不可能漂。
+func (s *eventSink) stream(ev agent.StreamEvent) error {
+	s.setSession(ev.SessionID)
+	if !s.enabled {
+		return writeStreamEventJSON(s.w, ev)
+	}
+	return s.event(streamEventPayload(ev))
+}
+
+// ready 握手行：新形态的第一行，告诉客户端「谁在跑、契约版本是多少」。
+// 只在 `--events` 下输出 —— 老消费者不认识它。
+func (s *eventSink) ready(model string) error {
+	if !s.enabled {
+		return nil
+	}
+	attrs := map[string]any{"type": "ready", "engine": s.engine}
+	if model != "" {
+		attrs["model"] = model
+	}
+	return s.eventAttrs(attrs)
+}
+
+// notice 输出一条 core 自己产生的事件（不是引擎增量）：
+// pong / interrupted / stopped / answered / answer_queued / control_error。
+// 只在 `--events` 下输出，老形状不注入新类型。
+func (s *eventSink) notice(kind string, attrs map[string]any) error {
+	if !s.enabled {
+		return nil
+	}
+	if attrs == nil {
+		attrs = map[string]any{}
+	}
+	attrs["type"] = kind
+	return s.eventAttrs(attrs)
+}
+
+// streamEventPayload 流式事件的 wire 形状 —— `--stream` 与 `--stream --events` 共用。
+// 两边的字段集必须只差 v / seq，test 里有专门的防漂断言。
+func streamEventPayload(ev agent.StreamEvent) any {
+	return struct {
+		Type      string            `json:"type"`
+		Text      string            `json:"text"`
+		Name      string            `json:"name,omitempty"`
+		ID        string            `json:"id,omitempty"`
+		ToolKind  string            `json:"tool_kind,omitempty"`
+		SessionID string            `json:"session_id,omitempty"`
+		Ask       *agent.AskRequest `json:"ask,omitempty"`
+	}{
+		Type:      string(ev.Kind),
+		Text:      ev.Text,
+		Name:      ev.Name,
+		ID:        ev.ID,
+		ToolKind:  toolKindOfEvent(ev),
+		SessionID: ev.SessionID,
+		Ask:       ev.Ask,
+	}
+}
+
+/* toolKindOfEvent 事件携带的工具子形态（2026-09-29 新增，见 agent/toolkind.go）。
+ *
+ * 只有**工具调用**事件带它：渲染层据此选卡（命令 / 文件变更 / 网页检索 / MCP /
+ * 子代理 / 提问 / 通用），不再靠工具名猜 —— 一处判定、两个界面共用。
+ *
+ * ⚠️ 工具**结果**事件不给：它的 Name 字段放的是「关联的 tool_use.id」（见 StreamEvent
+ * 的注释），拿它去判形态只会把 id 当成工具名。结果的形态由它配上的那张卡承担。
+ * ⚠️ 非工具事件一律空串 → `omitempty` 把它从 wire 上省掉，老消费者的字段集不受影响。 */
+func toolKindOfEvent(ev agent.StreamEvent) string {
+	if ev.Kind != agent.KindToolUse {
+		return ""
+	}
+	return agent.ToolKindFor(ev.Name, ev.Text)
+}