dsh-agy-link 0.2.9 → 0.3.1

package/README.md

@@ -145,7 +145,8 @@ Bring **Google Antigravity models into DeepSeek Harness (DSH)** — chat, thinki
 | Capability | Description |
 | ---- | ---- |
 | 🔌 **A model route, not a proxy** | Registers the `antigravity` provider in DSH's model config; pick any Antigravity model (Gemini / Claude / GPT-OSS) from the `/model` picker |
-| 🌊 **Full streaming** | Text, thinking (reasoning), and agy tool activity (annotated reasoning blocks) mapped onto DSH's native chunk protocol |
+| 🌊 **Full streaming** | Text, thinking (reasoning), and token usage mapped onto DSH's native chunk protocol |
+| 🃏 **Native tool cards (v0.3)** | agy's tool activity renders with DSH's own tool-card UI — terminal cards for `run_command`, inline diffs for file writes — via the internal `agy_tool` mirror riding the real agent loop |
 | 🔗 **Session continuity** | Each DSH session binds to a native agy conversation (`--conversation`); multi-turn context rides agy history instead of re-sending everything |
 | 📊 **Token usage** | Input/output/thinking/cache tokens surface in DSH usage accounting |
 | ⚙️ **Settings status** | DSH Settings → Antigravity page shows agy connection/login/workspace/bindings/last-run state |
@@ -222,7 +223,7 @@ DSH-side tools and permissions are unaffected — this only governs what the spa
 
 ## 🧩 How it works
 
-One DSH model call = one short-lived `agy -p --output-format stream-json` process. The NDJSON event stream is parsed, normalized, and mapped to DSH StreamChunks: thinking → reasoning blocks, text → text blocks, tool activity → annotated reasoning blocks, and the result envelope → usage + finish. Conversation ids come from the stream itself, with a conversations-directory snapshot diff as fallback. **No reverse-engineered database scraping, no protobuf decoding, no token-file access** — only the official unmodified agy binary is spawned.
+One DSH turn = one short-lived `agy -p --output-format stream-json` process. The NDJSON event stream is parsed, normalized, and recorded. Spans of that recording are mapped to DSH StreamChunks — thinking → reasoning blocks, text → text blocks, result envelope → usage + finish — and each **completed agy tool step cuts the span** with a `tool-calls` finish addressed to the internal `agy_tool` mirror. DSH's agent loop dispatches the mirror (it instantly replays the recorded output), writes real `tool/call` + `tool/result` session events, and re-calls the provider to continue the run — so tool activity renders with DSH's **native tool-card UI** (terminal cards, diffs, read/search icons) instead of text annotations. Conversation ids come from the stream itself, with a conversations-directory snapshot diff as fallback. **No reverse-engineered database scraping, no protobuf decoding, no token-file access** — only the official unmodified agy binary is spawned.
 
 ## 📋 What it cannot do (honest list)
 

package/dist/index.js

@@ -1,12 +1,12 @@
 import { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
 import { accessSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { LlmAdapter, LlmError } from "@deepseek-ai/dsh-llm";
+import { CallId, LlmAdapter, LlmError } from "@deepseek-ai/dsh-llm";
+import { randomBytes, randomUUID } from "node:crypto";
 import { mkdir, mkdtemp, readFile, readdir, rm, stat, unlink, writeFile } from "node:fs/promises";
-import { execFileSync, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import { createServer } from "node:http";
-import { randomBytes } from "node:crypto";
 import { fileURLToPath } from "node:url";
 //#region src/common/types.ts
 const PROVIDER_ID = "antigravity";
@@ -178,7 +178,7 @@ function readJson(file) {
 function readOverrides(file = overridesPath()) {
 	return readJson(file);
 }
-function asString(v) {
+function asString$1(v) {
 	return typeof v === "string" ? v : void 0;
 }
 function asBool(v) {
@@ -207,11 +207,11 @@ function resolveConfig(entry, env = process.env, overrides = readOverrides()) {
 	const cfg = {
 		...base,
 		enabled: asBool(get("enabled")) ?? base.enabled,
-		agyBin: asString(get("agyBin")) ?? base.agyBin,
+		agyBin: asString$1(get("agyBin")) ?? base.agyBin,
 		extraArgs: Array.isArray(get("extraArgs")) ? get("extraArgs").filter((x) => typeof x === "string") : base.extraArgs,
 		permissionMode: asMode(get("permissionMode")) ?? base.permissionMode,
-		defaultModel: asString(get("defaultModel")) ?? base.defaultModel,
-		defaultEffort: asString(get("defaultEffort")) ?? base.defaultEffort,
+		defaultModel: asString$1(get("defaultModel")) ?? base.defaultModel,
+		defaultEffort: asString$1(get("defaultEffort")) ?? base.defaultEffort,
 		timeoutMs: asNum(get("timeoutMs")) ?? base.timeoutMs,
 		maxConcurrent: asNum(get("maxConcurrent")) ?? base.maxConcurrent,
 		contextWindowDefault: asNum(get("contextWindowDefault")) ?? base.contextWindowDefault,
@@ -221,15 +221,15 @@ function resolveConfig(entry, env = process.env, overrides = readOverrides()) {
 		modelsCacheTtlMs: asNum(get("modelsCacheTtlMs")) ?? base.modelsCacheTtlMs,
 		allowAuxiliary: asBool(get("allowAuxiliary")) ?? base.allowAuxiliary,
 		compactionMaxChars: asNum(get("compactionMaxChars")) ?? base.compactionMaxChars,
-		workspaceRoot: asString(get("workspaceRoot")) ?? base.workspaceRoot,
+		workspaceRoot: asString$1(get("workspaceRoot")) ?? base.workspaceRoot,
 		fallbackModels: Array.isArray(get("fallbackModels")) ? get("fallbackModels").filter((x) => !!x && typeof x === "object" && typeof x.id === "string") : base.fallbackModels,
 		askTool: asBool(get("askTool")) ?? base.askTool,
-		mediaDir: asString(get("mediaDir")) ?? base.mediaDir,
+		mediaDir: asString$1(get("mediaDir")) ?? base.mediaDir,
 		mediaTtlMs: asNum(get("mediaTtlMs")) ?? base.mediaTtlMs,
 		mediaMaxBytes: asNum(get("mediaMaxBytes")) ?? base.mediaMaxBytes,
 		mediaMaxImages: asNum(get("mediaMaxImages")) ?? base.mediaMaxImages,
 		mcpBridge: asBool(get("mcpBridge")) ?? base.mcpBridge,
-		mcpToolAllowlist: asString(get("mcpToolAllowlist")) ?? base.mcpToolAllowlist
+		mcpToolAllowlist: asString$1(get("mcpToolAllowlist")) ?? base.mcpToolAllowlist
 	};
 	if (env.DSH_AGY_ENABLED !== void 0) cfg.enabled = asBool(env.DSH_AGY_ENABLED) ?? cfg.enabled;
 	if (env.DSH_AGY_BIN) cfg.agyBin = env.DSH_AGY_BIN;
@@ -300,31 +300,158 @@ function diffConversations(before, dir = defaultConversationsDir()) {
 	};
 }
 //#endregion
-//#region src/host/mapper.ts
-function briefArgs(args) {
-	if (args === void 0 || args === null) return "";
-	try {
-		const s = typeof args === "string" ? args : JSON.stringify(args);
-		return s.length > 300 ? s.slice(0, 300) + "..." : s;
-	} catch {
-		return String(args).slice(0, 120);
+//#region src/host/recording.ts
+const waiters = Symbol("waiters");
+/** One agy run's append-only event log plus its settlement state. */
+var RunRecording = class {
+	runId;
+	events = [];
+	settled = false;
+	failure = null;
+	resultConversationId = null;
+	[waiters] = /* @__PURE__ */ new Set();
+	constructor(runId = randomUUID()) {
+		this.runId = runId;
+	}
+	/** Append one pump event and wake every span consumer. */
+	append(ev) {
+		if (this.settled) return;
+		this.events.push(ev);
+		if (ev.kind === "result") this.resultConversationId = ev.conversationId ?? null;
+		this.wake();
+	}
+	/** Settle the recording: no further events will arrive. */
+	settle(failure) {
+		if (this.settled) return;
+		this.settled = true;
+		this.failure = failure;
+		this.wake();
+	}
+	wake() {
+		for (const w of this[waiters]) w();
+		this[waiters].clear();
+	}
+	get isSettled() {
+		return this.settled;
+	}
+	/** Terminal failure, when the run ended without a consumable result. */
+	get failureInfo() {
+		return this.failure;
+	}
+	/** Conversation id from the result envelope, once seen. */
+	get conversationId() {
+		return this.resultConversationId;
+	}
+	/** Whether a result event (ok or error-with-response) was recorded. */
+	get hasResult() {
+		return this.resultConversationId !== null || this.events.some((e) => e.kind === "result");
+	}
+	/** The last result envelope's finish-relevant projection, when one arrived. */
+	getResultEvent() {
+		for (let i = this.events.length - 1; i >= 0; i--) {
+			const ev = this.events[i];
+			if (ev !== void 0 && ev.kind === "result") return {
+				ok: ev.ok,
+				response: ev.response
+			};
+		}
+		return null;
 	}
-}
-function defaultAnnounce(name, args) {
-	const brief = briefArgs(args);
-	return brief === "" ? "[agy tool: " + name + "]\n" : "[agy tool: " + name + "] " + brief + "\n";
-}
-function defaultOutput(output) {
-	if (output === void 0 || output === null) return null;
-	let s;
-	try {
-		s = typeof output === "string" ? output : JSON.stringify(output);
-	} catch {
-		s = String(output);
+	/** Event at an absolute index (bounds-checked). */
+	eventAt(index) {
+		return this.events[index];
+	}
+	/** Number of recorded events so far. */
+	get length() {
+		return this.events.length;
 	}
-	if (s === "") return null;
-	return "-> " + (s.length > 2048 ? s.slice(0, 2048) + "... (+" + (s.length - 2048) + " chars)" : s) + "\n";
+	/**
+	* Whether any assistant-visible text streamed before (not including) the
+	* given index. Carried into each span's mapper so the result-envelope
+	* fallback never duplicates text earlier spans already streamed.
+	*/
+	sawTextBefore(index) {
+		for (let i = 0; i < Math.min(index, this.events.length); i++) {
+			const ev = this.events[i];
+			if (ev !== void 0 && ev.kind === "step" && ev.stepKind === "text" && ev.text !== "") return true;
+		}
+		return false;
+	}
+	/**
+	* Yield events at or after `from`, waiting for the pump while the run is
+	* live. The iterator ends once every recorded event was yielded AND the
+	* recording settled — spans then inspect failureInfo to finish or fail.
+	*/
+	async *eventsFrom(from) {
+		let cursor = from;
+		for (;;) {
+			while (cursor < this.events.length) {
+				yield this.events[cursor];
+				cursor++;
+			}
+			if (this.settled) return;
+			await new Promise((resolve) => {
+				this[waiters].add(resolve);
+			});
+		}
+	}
+	/**
+	* Recorded tool step for a mirror-tool call: the event at `eventIndex` must
+	* be the completed tool step the callId was minted from.
+	*/
+	toolEventAt(eventIndex) {
+		const ev = this.events[eventIndex];
+		if (ev === void 0 || ev.kind !== "step" || ev.stepKind !== "tool" || !ev.tool) return null;
+		return ev.tool;
+	}
+};
+/** Prefix every mirrored agy tool callId carries; continuation detection key. */
+const AGY_CALL_PREFIX = "agytc-";
+/** Mint the callId for one recorded tool event. */
+function mirrorCallId(runId, eventIndex) {
+	return AGY_CALL_PREFIX + runId + "-" + String(eventIndex);
+}
+/** Parse a callId back into its run coordinates; null when not ours. */
+function parseMirrorCallId(callId) {
+	if (!callId.startsWith("agytc-")) return null;
+	const rest = callId.slice(6);
+	const idx = rest.lastIndexOf("-");
+	if (idx <= 0) return null;
+	const runId = rest.slice(0, idx);
+	const n = Number(rest.slice(idx + 1));
+	if (!Number.isSafeInteger(n) || n < 0) return null;
+	return {
+		runId,
+		eventIndex: n
+	};
 }
+const MAX_RETAINED_RUNS = 8;
+/** Bounded registry keeping the most recent runs for continuation spans. */
+var RunRegistry = class {
+	runs = /* @__PURE__ */ new Map();
+	create() {
+		const rec = new RunRecording();
+		this.remember(rec);
+		return rec;
+	}
+	remember(rec) {
+		this.runs.set(rec.runId, rec);
+		while (this.runs.size > MAX_RETAINED_RUNS) {
+			const oldest = this.runs.keys().next().value;
+			if (oldest === void 0) break;
+			this.runs.delete(oldest);
+		}
+	}
+	get(runId) {
+		return this.runs.get(runId);
+	}
+	/** Drop a settled run early (called when its final span finished stop). */
+	forget(runId) {
+		this.runs.delete(runId);
+	}
+};
+//#endregion
+//#region src/host/mapper.ts
 function usageFromRaw(raw) {
 	const usage = {
 		inputTokens: raw.input_tokens ?? 0,
@@ -348,12 +475,13 @@ var EventMapper = class {
 	openType = null;
 	openAcc = "";
 	emittedByKey = /* @__PURE__ */ new Map();
-	toolPhaseSeen = /* @__PURE__ */ new Set();
+	announcedTools = /* @__PURE__ */ new Set();
 	thinkingAnnounced = /* @__PURE__ */ new Set();
-	sawTextStep = false;
+	sawTextStep;
 	finished = false;
-	constructor(opts = {}) {
+	constructor(opts) {
 		this.opts = opts;
+		this.sawTextStep = opts.initialSawText === true;
 	}
 	/** Whether a terminal finish chunk has been emitted. */
 	get isFinished() {
@@ -403,7 +531,12 @@ var EventMapper = class {
 			text: delta
 		};
 	}
-	*map(ev) {
+	/**
+	* Map one event. `absIndex` is the event's position in the run recording;
+	* it mints the mirror callId and is what continuation detection parses
+	* back out of the DSH message list.
+	*/
+	*map(ev, absIndex) {
 		if (this.finished) return;
 		if (ev.kind === "init") return;
 		if (ev.kind === "garbage") return;
@@ -447,29 +580,48 @@ var EventMapper = class {
 				return;
 			}
 			if (ev.stepKind === "tool" && ev.tool) {
-				yield* this.ensureBlock("text");
-				const announceKey = ev.stepKey + ":a";
-				if (!this.toolPhaseSeen.has(announceKey)) {
-					this.toolPhaseSeen.add(announceKey);
-					const line = (this.opts.announce ?? defaultAnnounce)(ev.tool.name, ev.tool.args);
-					const d = this.appendDelta("🔧 " + line);
-					if (d) yield d;
-				}
-				const outKey = ev.stepKey + ":o";
-				const errKey = ev.stepKey + ":e";
-				if (ev.tool.error !== void 0 && !this.toolPhaseSeen.has(errKey)) {
-					this.toolPhaseSeen.add(errKey);
-					const d = this.appendDelta("⚠ [agy tool error: " + ev.tool.name + "] " + ev.tool.error + "\n");
-					if (d) yield d;
-				}
-				if (ev.tool.output !== void 0 && !this.toolPhaseSeen.has(outKey)) {
-					this.toolPhaseSeen.add(outKey);
-					const rendered = this.opts.toolOutput ? this.opts.toolOutput(ev.tool.name, ev.tool.args, ev.tool.output) : defaultOutput(ev.tool.output);
-					if (rendered !== null) {
-						const d = this.appendDelta(rendered);
-						if (d) yield d;
+				if (!(ev.tool.output !== void 0 || ev.tool.error !== void 0)) return;
+				if (this.announcedTools.has(ev.stepKey)) return;
+				this.announcedTools.add(ev.stepKey);
+				if (!this.opts.cutOnTool) return;
+				const close = this.closeOpen();
+				if (close) yield close;
+				const idx = this.blockIdx;
+				const input = ev.tool.args === void 0 ? {} : { input: ev.tool.args };
+				const argumentsJson = JSON.stringify({
+					run: this.opts.runId,
+					step: absIndex,
+					tool: ev.tool.name,
+					...input
+				});
+				yield {
+					type: "block-start",
+					index: idx,
+					blockType: "tool-call"
+				};
+				yield {
+					type: "block-end",
+					index: idx,
+					block: {
+						type: "tool-call",
+						id: CallId(mirrorCallId(this.opts.runId, absIndex)),
+						name: "agy_tool",
+						arguments: argumentsJson
 					}
-				}
+				};
+				this.blockIdx++;
+				yield {
+					type: "usage",
+					usage: {
+						inputTokens: 0,
+						outputTokens: 0
+					}
+				};
+				yield {
+					type: "finish",
+					reason: { kind: "tool-calls" }
+				};
+				this.finished = true;
 				return;
 			}
 			return;
@@ -1551,6 +1703,32 @@ var AgyAdapter = class extends LlmAdapter {
 		if (isAux && !cfg.allowAuxiliary) throw new LlmError("auxiliary calls are disabled for the antigravity route (allowAuxiliary: false)", Err.AUX_DISABLED);
 		const sessionKey = options.sessionId !== void 0 ? String(options.sessionId) : "";
 		const workspaceRoot = cfg.workspaceRoot !== "" ? cfg.workspaceRoot : this.deps.sessionCwd?.(sessionKey) || process.cwd();
+		const continuation = detectContinuation(options.messages);
+		if (continuation !== null) {
+			const rec = this.deps.runs.get(continuation.runId);
+			if (rec === void 0) {
+				yield {
+					type: "usage",
+					usage: {
+						inputTokens: 0,
+						outputTokens: 0
+					}
+				};
+				yield {
+					type: "finish",
+					reason: {
+						kind: "error",
+						failure: {
+							message: "agy run " + continuation.runId + " is no longer available (server restarted?) — please resend your message",
+							code: Err.AGY_ERROR
+						}
+					}
+				};
+				return;
+			}
+			yield* this.driveSpan(rec, continuation.eventIndex + 1, true);
+			return;
+		}
 		const catalog = this.deps.catalog.get();
 		const model = options.model;
 		const entry = findEntry(catalog, model);
@@ -1620,11 +1798,9 @@ var AgyAdapter = class extends LlmAdapter {
 			if (prompt.trim() === "") throw new LlmError("request carries no user text or images to forward to agy", Err.AGY_ERROR);
 		} else if (prompt.trim() === "") throw new LlmError("request carries no user text to forward to agy", Err.AGY_ERROR);
 		const before = snapshotConversations();
-		const toolOutput = this.deps.toolOutput;
-		const mapper = new EventMapper({ toolOutput: toolOutput ? (name, args, output) => toolOutput(name, args, output, workspaceRoot) : void 0 });
+		const rec = this.deps.runs.create();
 		const parser = new StreamJsonParser();
 		this.deps.onParser?.(parser);
-		const queue = new ChunkQueue();
 		let streamCid = null;
 		const args = this.buildArgs({
 			prompt,
@@ -1655,7 +1831,7 @@ var AgyAdapter = class extends LlmAdapter {
 					for (const ev of parser.feed(line + "\n")) {
 						if (ev.kind === "init" && ev.conversationId) streamCid = ev.conversationId;
 						if (ev.kind === "result" && ev.conversationId !== "") streamCid = ev.conversationId;
-						for (const ch of mapper.map(ev)) queue.push(ch);
+						rec.append(ev);
 					}
 				}
 			});
@@ -1668,10 +1844,12 @@ var AgyAdapter = class extends LlmAdapter {
 			releaseOnce();
 			for (const ev of parser.flush()) {
 				if (ev.kind === "result" && ev.conversationId !== "") streamCid = ev.conversationId;
-				for (const ch of mapper.map(ev)) queue.push(ch);
+				rec.append(ev);
 			}
 			const diffed = diffConversations(before).conversationId;
 			const conversationId = streamCid ?? diffed;
+			const r = rec.getResultEvent();
+			const consumable = r !== null && (r.ok || r.response !== "");
 			let failure = null;
 			if (outcome.aborted) failure = {
 				kind: "aborted",
@@ -1688,7 +1866,7 @@ var AgyAdapter = class extends LlmAdapter {
 				code: Err.AUTH,
 				message: "agy is not signed in — run /agy auth (or run agy once in a terminal) to login"
 			};
-			else if (!mapper.isFinished) {
+			else if (!consumable) {
 				if (outcome.code !== 0) failure = {
 					kind: "error",
 					code: Err.PROCESS_EXIT,
@@ -1705,7 +1883,7 @@ var AgyAdapter = class extends LlmAdapter {
 					message: "agy produced no result event (" + parser.stats.garbage + " unparseable lines)"
 				};
 			}
-			if (failure !== null) for (const ch of mapper.emitFailure(failure.kind, failure.code, failure.message)) queue.push(ch);
+			rec.settle(failure);
 			if (!isAux && sessionKey !== "" && failure === null) {
 				const finalId = binding !== void 0 ? binding.conversationId : conversationId;
 				if (finalId) this.deps.store.set(sessionKey, {
@@ -1721,15 +1899,63 @@ var AgyAdapter = class extends LlmAdapter {
 				durationMs: outcome.durationMs,
 				model
 			});
-			queue.close();
 		})().catch((err) => {
 			releaseOnce();
-			for (const ch of mapper.emitFailure("error", Err.PROCESS_EXIT, "internal error: " + brief(String(err)))) queue.push(ch);
-			queue.close();
+			rec.settle({
+				kind: "error",
+				code: Err.PROCESS_EXIT,
+				message: "internal error: " + brief(String(err))
+			});
 		});
+		yield* this.driveSpan(rec, 0, !isAux);
+	}
+	/**
+	* Stream one span of a recording: map events from `from` until the mapper
+	* finishes (tool-calls cut or result stop), then let the queue drain. When
+	* the recording settles without a consumable result, surface its failure
+	* as this span's terminal chunk — the turn ends exactly like a native
+	* provider error.
+	*/
+	async *driveSpan(rec, from, cutOnTool) {
+		const queue = new ChunkQueue();
+		(async () => {
+			const mapper = new EventMapper({
+				runId: rec.runId,
+				cutOnTool,
+				initialSawText: rec.sawTextBefore(from)
+			});
+			let i = from;
+			try {
+				for await (const ev of rec.eventsFrom(from)) {
+					for (const ch of mapper.map(ev, i)) queue.push(ch);
+					i++;
+					if (mapper.isFinished) break;
+				}
+				if (!mapper.isFinished) {
+					const f = rec.failureInfo;
+					if (f !== null) for (const ch of mapper.emitFailure(f.kind, f.code, f.message)) queue.push(ch);
+					else for (const ch of mapper.emitFailure("error", Err.INVALID_OUTPUT, "agy stream ended without a result event")) queue.push(ch);
+				}
+			} catch (err) {
+				for (const ch of mapper.emitFailure("error", Err.PROCESS_EXIT, "internal error: " + brief(String(err)))) queue.push(ch);
+			}
+			queue.close();
+		})();
 		yield* queue.drain();
 	}
 };
+/**
+* Detect a continuation span: the request's LAST message is the tool result
+* of one of our mirrored agy tool calls. Its callId encodes the recording
+* run and the event index to resume after.
+*/
+function detectContinuation(messages) {
+	const last = messages[messages.length - 1];
+	if (last === void 0 || last.role !== "user") return null;
+	const src = last.source;
+	if (src === void 0 || src.kind !== "tool" || typeof src.callId !== "string") return null;
+	return parseMirrorCallId(src.callId);
+}
 //#endregion
 //#region src/host/oneshot.ts
 /** Per-file inline cap; larger files are truncated. */
@@ -2395,73 +2621,220 @@ function writeDoctorReport(deps) {
 	return file;
 }
 //#endregion
-//#region src/host/diff-render.ts
-const FILE_KEYS = [
-	"file_path",
-	"filePath",
-	"path",
-	"file",
-	"filename",
-	"target_file",
-	"absolute_path"
-];
-function pickFile(args) {
-	if (!args || typeof args !== "object") return null;
-	const o = args;
-	for (const k of FILE_KEYS) {
-		const v = o[k];
-		if (typeof v === "string" && v !== "") return v;
+//#region src/host/mirror-tool.ts
+const MIRROR_TOOL_NAME = "agy_tool";
+/** agy serializes some tool args as a JSON string; presenters get an object. */
+function toolInput(args) {
+	const raw = args.input;
+	if (raw === void 0 || raw === null) return {};
+	if (typeof raw === "object") return raw;
+	if (typeof raw === "string") try {
+		const parsed = JSON.parse(raw);
+		return typeof parsed === "object" && parsed !== null ? parsed : { value: parsed };
+	} catch {
+		return { value: raw };
 	}
-	return null;
+	return { value: raw };
 }
-function looksLikeEditTool(name) {
-	const n = name.toLowerCase();
-	return n.includes("write") || n.includes("edit") || n.includes("replace") || n.includes("str_replace");
+function asString(v) {
+	return typeof v === "string" ? v : void 0;
 }
-function renderToolActivity(name, args, output, cwd) {
-	const parts = [];
-	if (looksLikeEditTool(name)) {
-		const file = pickFile(args);
-		if (file) {
-			const diff = gitDiff(file, cwd);
-			if (diff !== null) parts.push("[agy edit: " + file + "]\n" + diff);
+/** Native pending-card projection for one mirrored agy tool call. */
+function presentMirrorCall(args) {
+	const a = args;
+	const name = typeof a?.tool === "string" ? a.tool : "";
+	const input = toolInput(a);
+	switch (name) {
+		case "run_command":
+		case "bash":
+		case "execute_command": return {
+			card: "terminal",
+			title: asString(input.command) ?? asString(input.cmd) ?? JSON.stringify(input),
+			...asString(input.description) !== void 0 ? { description: asString(input.description) } : {},
+			...asString(input.cwd) !== void 0 ? { cwd: asString(input.cwd) } : {}
+		};
+		case "write_to_file":
+		case "write_file":
+		case "create_file": {
+			const path = asString(input.path) ?? asString(input.file_path) ?? asString(input.filename) ?? "file";
+			const content = asString(input.content) ?? "";
+			return {
+				card: "diff",
+				title: "Write " + path,
+				diffs: [{
+					path,
+					oldText: null,
+					newText: content
+				}],
+				locations: [{ path }]
+			};
+		}
+		case "edit_file":
+		case "replace_in_file":
+		case "edit": {
+			const path = asString(input.path) ?? asString(input.file_path) ?? "file";
+			const newText = asString(input.new_string) ?? asString(input.newText) ?? asString(input.content) ?? "";
+			const oldText = asString(input.old_string) ?? asString(input.oldText) ?? null;
+			return {
+				card: "diff",
+				title: "Edit " + path,
+				diffs: [{
+					path,
+					oldText,
+					newText
+				}],
+				locations: [{ path }]
+			};
+		}
+		case "read_file":
+		case "view_file":
+		case "read":
+		case "open_file": {
+			const path = asString(input.path) ?? asString(input.file_path) ?? asString(input.filename) ?? "";
+			const offset = typeof input.offset === "number" ? input.offset : void 0;
+			return {
+				card: "generic",
+				title: "Read " + path,
+				kind: "read",
+				...path !== "" ? { locations: [{
+					path,
+					...offset !== void 0 ? { line: offset + 1 } : {}
+				}] } : {}
+			};
 		}
+		case "find_by_name":
+		case "glob":
+		case "search_files":
+		case "search":
+		case "search_file_content":
+		case "grep": {
+			const q = asString(input.pattern) ?? asString(input.query) ?? asString(input.regex) ?? "";
+			return {
+				card: "generic",
+				title: q !== "" ? "Search " + q : "Search",
+				kind: "search"
+			};
+		}
+		case "list_dir":
+		case "ls": {
+			const path = asString(input.path) ?? asString(input.directory) ?? "";
+			return {
+				card: "generic",
+				title: path !== "" ? "List " + path : "List directory"
+			};
+		}
+		case "delete_file":
+		case "remove_file":
+		case "rm": return {
+			card: "generic",
+			title: "Delete " + (asString(input.path) ?? asString(input.file_path) ?? ""),
+			kind: "delete"
+		};
+		default: return {
+			card: "generic",
+			title: name !== "" ? name : "agy tool",
+			rawInput: input
+		};
 	}
-	if (output !== void 0 && output !== null) {
-		let s;
-		try {
-			s = typeof output === "string" ? output : JSON.stringify(output);
-		} catch {
-			s = String(output);
+}
+/** Native completed-card projection for one mirrored agy tool call. */
+function presentMirrorResult(args, result) {
+	const a = args;
+	const name = typeof a?.tool === "string" ? a.tool : "";
+	const text = resultText$1(result.content);
+	switch (name) {
+		case "run_command":
+		case "bash":
+		case "execute_command": return {
+			card: "terminal",
+			output: text
+		};
+		case "write_to_file":
+		case "write_file":
+		case "create_file":
+		case "edit_file":
+		case "replace_in_file":
+		case "edit": {
+			const call = presentMirrorCall(args);
+			return {
+				card: "diff",
+				diffs: call !== void 0 && call.card === "diff" ? call.diffs : []
+			};
 		}
-		if (s !== "") parts.push("-> " + (s.length > 2048 ? s.slice(0, 2048) + "..." : s));
+		default: return {
+			card: "generic",
+			content: [{
+				type: "text",
+				text: clip(text, 4e3)
+			}]
+		};
 	}
-	return parts.length === 0 ? null : parts.join("\n") + "\n";
 }
-function gitDiff(file, cwd) {
-	try {
-		const out = execFileSync("git", [
-			"-C",
-			cwd,
-			"diff",
-			"HEAD",
-			"--",
-			file
-		], {
-			encoding: "utf8",
-			timeout: 5e3,
-			maxBuffer: 1e6,
-			stdio: [
-				"ignore",
-				"pipe",
-				"ignore"
-			]
-		});
-		if (out.trim() === "") return null;
-		return out.split("\n").slice(0, 100).join("\n");
-	} catch {
-		return null;
+function resultText$1(content) {
+	const parts = [];
+	for (const b of Array.isArray(content) ? content : []) {
+		const blk = b;
+		if (blk && blk.type === "text" && typeof blk.text === "string") parts.push(blk.text);
 	}
+	return parts.join("\n");
+}
+function clip(s, max) {
+	return s.length > max ? s.slice(0, max) + "… (+" + (s.length - max) + " chars)" : s;
+}
+function defineAgyMirrorTool(deps) {
+	return defineTool({
+		name: MIRROR_TOOL_NAME,
+		description: "Internal to the dsh-agy-link bridge: replays one tool activity recorded from a Google Antigravity (agy) CLI run so it renders as a native tool card and rides the agent loop. Emitted automatically by the antigravity provider — do not call it directly.",
+		parameters: {
+			run: {
+				type: "string",
+				required: true,
+				description: "Recording run id."
+			},
+			step: {
+				type: "number",
+				required: true,
+				description: "Recorded event index of the tool step."
+			},
+			tool: {
+				type: "string",
+				required: true,
+				description: "agy tool name that ran."
+			},
+			input: {
+				type: "json",
+				description: "agy tool arguments as recorded."
+			}
+		},
+		output: {
+			schema: { type: "string" },
+			render: (_args, value) => [{
+				type: "text",
+				text: value
+			}]
+		},
+		presentCall: (args) => presentMirrorCall(args),
+		presentResult: (args, result) => presentMirrorResult(args, result),
+		async execute(args, exec) {
+			exec.signal;
+			const runId = typeof args.run === "string" ? args.run : "";
+			const step = typeof args.step === "number" ? args.step : -1;
+			typeof args.tool === "string" && args.tool;
+			const rec = deps.runs.get(runId);
+			if (rec === void 0) throw new Error("agy_tool: no recorded agy run \"" + runId + "\" — this tool only replays bridge-recorded activity");
+			const t = rec.toolEventAt(step);
+			if (t === null) throw new Error("agy_tool: event " + step + " of run " + runId + " is not a completed tool step");
+			if (t.error !== void 0) throw new Error("agy tool " + t.name + " failed: " + t.error);
+			const out = t.output;
+			if (out === void 0 || out === null) return "";
+			if (typeof out === "string") return out;
+			try {
+				return JSON.stringify(out, null, 2);
+			} catch {
+				return String(out);
+			}
+		}
+	});
 }
 //#endregion
 //#region src/host/sessions.ts
@@ -2753,6 +3126,7 @@ function apply(ctx, entryConfig = {}) {
 		};
 	}, getConfig().fallbackModels, 3e5);
 	const auth = new AuthHelper(bin);
+	const runs = new RunRegistry();
 	const adapter = new AgyAdapter({
 		getConfig,
 		catalog,
@@ -2760,10 +3134,7 @@ function apply(ctx, entryConfig = {}) {
 		bin,
 		acquire: () => semaphore.acquire(),
 		log,
-		toolOutput: (name, args, output, cwd) => {
-			const ws = getConfig().workspaceRoot;
-			return renderToolActivity(name, args, output, cwd ?? (ws !== "" ? ws : process.cwd()));
-		},
+		runs,
 		sessionCwd: (sessionId) => {
 			return ctx.get("sessions")?.get(sessionId)?.header?.cwd;
 		},
@@ -2861,6 +3232,18 @@ function apply(ctx, entryConfig = {}) {
 		}
 	};
 	syncAskTool();
+	const mirrorToolDispose = { current: null };
+	const syncMirrorTool = () => {
+		const want = getConfig().enabled && bin() !== null;
+		if (want && mirrorToolDispose.current === null && toolsSvc) {
+			const reg = toolsSvc.register(defineAgyMirrorTool({ runs }));
+			mirrorToolDispose.current = typeof reg === "function" ? reg : null;
+		} else if (!want && mirrorToolDispose.current !== null) {
+			mirrorToolDispose.current();
+			mirrorToolDispose.current = null;
+		}
+	};
+	syncMirrorTool();
 	const registerRoutes = (webServer) => {
 		const disposers = [];
 		const reg = (route) => {
@@ -2979,6 +3362,7 @@ function apply(ctx, entryConfig = {}) {
 					}
 					setOverride(key, body.value);
 					syncAskTool();
+					syncMirrorTool();
 					sendJson(res, 200, {
 						ok: true,
 						key,
@@ -3075,6 +3459,7 @@ function apply(ctx, entryConfig = {}) {
 	ctx.effect(() => {
 		auth.dispose();
 		if (askToolDispose.current !== null) askToolDispose.current();
+		if (mirrorToolDispose.current !== null) mirrorToolDispose.current();
 		bridgeState.restore?.();
 		bridgeState.bridge?.close();
 		return () => void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-agy-link",
-  "version": "0.2.9",
+  "version": "0.3.1",
   "description": "Google Antigravity (agy CLI) models for DeepSeek Harness — stream Gemini/Claude/GPT-OSS subscriptions into DSH with thinking, tool activity, token usage and in-GUI Google OAuth login.",
   "type": "module",
   "license": "MIT",