@xiaoso/dsh-tool-plus 0.1.16 → 0.1.17-beta.0

package/lib/cursor-D-XZYDf_.mjs

@@ -1,4544 +0,0 @@
-import { installBunShim as __installBunShim } from "./bun-shim.mjs";
-__installBunShim();
-import { n as fs_promises_shim_exports } from "./fs-promises-shim-B2YFWkcd.mjs";
-import { C as warn, M as truncate, N as $env, _ as parseStreamingJson, b as debug, g as parseJsonWithRepair, v as parseStreamingJsonThrottled } from "./src-AELUUb5U.mjs";
-import { _ as AbortError, c as finalize, h as MissingApiKeyError, r as ValidationError, s as ProviderResponseError } from "./error-O63pC8zg.mjs";
-import { A as toolWireSchema, C as kStreamingLastParseLen, I as sanitizeSchemaForCursor, S as kStreamingEnvelopeId, b as kStreamingBlockIndex, g as clearStreamingPartialJson, o as normalizeSystemPrompts, s as normalizeToolCallId, v as kCursorExecResolved, w as kStreamingPartialJson, x as kStreamingBlockKind } from "./utils-cZX3f_Ls.mjs";
-import { t as sanitizeText } from "./sanitize-text-BCf5KmCf.mjs";
-import { n as isRecord$1 } from "./type-guards-CttAANEx.mjs";
-import { n as classifyModel, r as collapseVariantId } from "./taxonomy-DSIM99rS.mjs";
-import { n as getProxyForUrl, t as connectProxiedSocket } from "./proxy-DxvCQOCA.mjs";
-import { n as THINKING_EFFORTS } from "./effort-BdtQMN-_.mjs";
-import { t as calculateCost } from "./models-DnXMYGcJ.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-BKEtb45Y.mjs";
-import { n as isRequestDebugEnabled, t as createRequestDebugSession } from "./request-debug-BwPOqN_j.mjs";
-import { i as fromBinary, n as decodeJsonValue, o as toBinary, r as encodeJsonValue, t as create } from "./protobuf-BMgDYu_U.mjs";
-import { $ as ForceBackgroundSubagentResultSchema, $n as SubagentResultSchema, $t as PiFindExecSuccessSchema, A as CursorRuleTypeGlobalSchema, An as RequestContextSuccessSchema, At as McpRejectedSchema, B as ExaFetchRequestResponseSchema, Bn as ShellResultSchema, Bt as McpToolNotFoundSchema, C as ConversationStateStructureSchema, Cn as ReadRejectedSchema, Ct as LsResultSchema, D as CreatePlanRequestResponseSchema, Dn as RecordScreenResultSchema, Dt as McpArgsSchema, E as CreatePlanErrorSchema, En as RecordScreenFailureSchema, Et as McpApprovedSchema, F as DeleteSuccessSchema, Fn as SelectedImageSchema, Ft as McpSuccessSchema, G as ExecClientMessageSchema, Gn as ShellStreamStdoutSchema, Gt as PiBashExecResultSchema, H as ExaSearchRequestResponseSchema, Hn as ShellStreamSchema, Ht as McpToolResultSchema, I as DiagnosticsErrorSchema, In as SetBlobResultSchema, It as McpTextContentSchema, J as ExecuteHookResponseSchema, Jn as SmartModeClassifierResultSchema, Jt as PiEditExecRejectedSchema, K as ExecClientStreamCloseSchema, Kn as ShellSuccessSchema, Kt as PiBashExecSuccessSchema, L as DiagnosticsRejectedSchema, Ln as ShellAllowlistPrecheckResultSchema, Lt as McpToolCallSchema, M as DeleteErrorSchema, Mn as RequestedModel_ModelParameterbytesSchema, Mt as McpStateExecResultSchema, N as DeleteRejectedSchema, Nn as ResumeActionSchema, Nt as McpStateServerSchema, O as CreatePlanResultSchema, On as RequestContextResultSchema, Ot as McpErrorSchema, P as DeleteResultSchema, Pn as SelectedContextSchema, Pt as McpStateSuccessSchema, Q as ForceBackgroundShellResultSchema, Qn as SubagentErrorSchema, Qt as PiFindExecResultSchema, R as DiagnosticsResultSchema, Rn as ShellFailureSchema, Rt as McpToolDefinitionSchema, S as ConversationSearchResultSchema, Sn as ReadMcpResourceSuccessSchema, St as LsRejectedSchema, T as ConversationTurnStructureSchema, Tn as ReadSuccessSchema, Tt as McpAllowlistPrecheckResultSchema, U as ExaSearchRequestResponse_ApprovedSchema, Un as ShellStreamStartSchema, Ut as ModelDetailsSchema, V as ExaFetchRequestResponse_ApprovedSchema, Vn as ShellStreamExitSchema, Vt as McpToolResultContentItemSchema, W as ExecClientControlMessageSchema, Wn as ShellStreamStderrSchema, Wt as PiBashExecErrorSchema, X as FetchErrorSchema, Xn as SubagentAwaitNotFoundSchema, Xt as PiEditExecSuccessSchema, Y as ExecuteHookResultSchema, Yn as StopRequestResponseSchema, Yt as PiEditExecResultSchema, Z as FetchResultSchema, Zn as SubagentAwaitResultSchema, Zt as PiFindExecErrorSchema, _ as ClientHeartbeatSchema, _n as PreToolUseRequestResponseSchema, _r as WriteShellStdinResultSchema, _t as ListMcpResourcesExecResult_McpResourceSchema, a as AgentRunRequestSchema, an as PiLsExecSuccessSchema, ar as ToolCallSchema, at as GrepCountResultSchema, b as ConversationActionSchema, bn as ReadMcpResourceExecResultSchema, bt as LsDirectoryTreeNode_FileSchema, c as AgentStoreConflictResultSchema, cn as PiReadExecSuccessSchema, cr as WebFetchAllowlistPrecheckResultSchema, ct as GrepFileMatchSchema, d as AskQuestionResultSchema, dn as PiWriteExecRejectedSchema, dr as WebSearchRequestResponseSchema, dt as GrepSuccessSchema, en as PiGrepExecErrorSchema, er as SubagentStartRequestResponseSchema, et as GetBlobResultSchema, f as AssistantMessageSchema, fn as PiWriteExecResultSchema, fr as WebSearchRequestResponse_ApprovedSchema, ft as GrepUnionResultSchema, g as CanvasDiagnosticsResultSchema, gn as PreCompactRequestResponseSchema, gr as WriteShellStdinErrorSchema, gt as ListMcpResourcesExecResultSchema, h as CanvasDiagnosticsErrorSchema, hn as PostToolUseRequestResponseSchema, hr as WriteResultSchema, ht as ListMcpResourcesErrorSchema, i as AgentConversationTurnStructureSchema, in as PiLsExecResultSchema, ir as ThinkingMessageSchema, it as GrepContentResultSchema, j as CursorRuleTypeSchema, jn as RequestedModelSchema, jt as McpResultSchema, k as CursorRuleSchema, kn as RequestContextSchema, kt as McpImageContentSchema, l as AskQuestionInteractionResponseSchema, ln as PiTruncationSchema, lr as WebFetchRequestResponseSchema, lt as GrepFilesResultSchema, m as BeforeSubmitPromptRequestResponseSchema, mn as PostToolUseFailureRequestResponseSchema, mr as WriteRejectedSchema, mt as KvClientMessageSchema, n as AfterAgentThoughtRequestResponseSchema, nn as PiGrepExecSuccessSchema, nr as SwitchModeRequestResponseSchema, o as AgentServerMessageSchema, on as PiReadExecErrorSchema, or as UserMessageActionSchema, ot as GrepErrorSchema, p as BackgroundShellSpawnResultSchema, pn as PiWriteExecSuccessSchema, pr as WriteErrorSchema, pt as InteractionResponseSchema, q as ExecClientThrowSchema, qn as SmartModeClassifierErrorSchema, qt as PiEditExecErrorSchema, r as AgentClientMessageSchema, rn as PiLsExecErrorSchema, rr as SwitchModeRequestResponse_RejectedSchema, rt as GrepContentMatchSchema, s as AgentStoreConflictErrorSchema, sn as PiReadExecResultSchema, sr as UserMessageSchema, st as GrepFileCountSchema, t as AfterAgentResponseRequestResponseSchema, tn as PiGrepExecResultSchema, tr as SubagentStopRequestResponseSchema, u as AskQuestionRejectedSchema, un as PiWriteExecErrorSchema, ur as WebFetchRequestResponse_ApprovedSchema, ut as GrepResultSchema, v as ComputerUseErrorSchema, vn as ReadErrorSchema, vr as WriteSuccessSchema, vt as ListMcpResourcesSuccessSchema, w as ConversationStepSchema, wn as ReadResultSchema, wt as LsSuccessSchema, x as ConversationSearchErrorSchema, xn as ReadMcpResourceNotFoundSchema, xt as LsErrorSchema, y as ComputerUseResultSchema, yn as ReadMcpResourceErrorSchema, yt as LsDirectoryTreeNodeSchema, z as DiagnosticsSuccessSchema, zn as ShellRejectedSchema, zt as McpToolErrorSchema } from "./cursor-proto-Cr_WEMuv.mjs";
-import { t as deterministicUuid } from "./deterministic-id-CUEIMSqR.mjs";
-import * as path$1 from "node:path";
-import { createHash } from "node:crypto";
-import http2 from "node:http2";
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/providers/connect-error-detail.ts
-/**
-* Connect-protocol end-stream error formatting.
-*
-* A Connect end-of-stream trailer carries an error object of the shape
-* code / message / details. Some backends collapse the useful part into a
-* generic message (for example just "Error"), which previously surfaced
-* verbatim as "Connect error invalid_argument: Error" — an unactionable
-* string that hid both the failing argument and which transport produced it
-* (Refs #4813). This module keeps the existing "Connect error code: message"
-* prefix byte-for-byte and appends what the trailer actually contained:
-* typed detail entries are summarized, and when the message is generic the
-* remaining trailer fields are appended (truncated) so the server's real
-* rejection is visible in logs and bug reports.
-*/
-/** Messages that carry no diagnostic content on their own. */
-const GENERIC_CONNECT_ERROR_MESSAGES = /* @__PURE__ */ new Set([
-	"",
-	"error",
-	"unknown",
-	"unknown error",
-	"internal",
-	"internal error"
-]);
-/** Upper bound for appended trailer context so errors stay log-line sized. */
-const MAX_EXTRA_DETAIL_CHARS = 400;
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function safeJson(value) {
-	try {
-		return (typeof value === "string" ? value : JSON.stringify(value)) || void 0;
-	} catch {
-		return;
-	}
-}
-/**
-* Summarizes Connect error detail entries (objects with type / value / debug
-* fields per the Connect JSON error model). Returns undefined when nothing
-* usable is present.
-*/
-function summarizeConnectErrorDetails(details) {
-	if (!Array.isArray(details) || details.length === 0) return void 0;
-	const parts = [];
-	for (const entry of details) {
-		if (!isRecord(entry)) continue;
-		const type = typeof entry.type === "string" && entry.type ? entry.type : void 0;
-		const debug = entry.debug !== void 0 ? safeJson(entry.debug) : void 0;
-		const value = entry.value !== void 0 ? safeJson(entry.value) : void 0;
-		const diagnostic = debug ?? value;
-		if (type && diagnostic) parts.push(`${type}: ${diagnostic}`);
-		else if (type) parts.push(type);
-		else if (diagnostic) parts.push(diagnostic);
-	}
-	if (parts.length === 0) return void 0;
-	return truncate(parts.join("; "), MAX_EXTRA_DETAIL_CHARS);
-}
-/**
-* Formats a Connect end-stream error object into a diagnosable message.
-* The "Connect error code: message" prefix is preserved exactly; detail
-* entries are appended when present, and when the message itself is generic
-* the remaining trailer fields are inlined so the error names what the
-* server actually sent instead of a bare "Error".
-*/
-function formatConnectEndStreamError(error) {
-	const record = isRecord(error) ? error : {};
-	const code = typeof record.code === "string" && record.code ? record.code : "unknown";
-	const message = typeof record.message === "string" ? record.message : "";
-	const detail = summarizeConnectErrorDetails(record.details);
-	const parts = [`Connect error ${code}: ${message || "Unknown error"}`];
-	if (detail) parts.push(`[details: ${detail}]`);
-	else if (GENERIC_CONNECT_ERROR_MESSAGES.has(message.trim().toLowerCase())) {
-		const extras = {};
-		for (const [key, value] of Object.entries(record)) {
-			if (key === "code" || key === "message") continue;
-			extras[key] = value;
-		}
-		const raw = Object.keys(extras).length > 0 ? safeJson(extras) : void 0;
-		if (raw && raw !== "{}") parts.push(`[trailer: ${truncate(raw, MAX_EXTRA_DETAIL_CHARS)}]`);
-	}
-	return parts.join(" ");
-}
-//#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/providers/cursor-external-tool-handoff.md
-var cursor_external_tool_handoff_default = "Tool call received and handed off to the external client for execution. Do not retry or call it again; end the turn. The result will be provided in the next request.\n";
-//#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/providers/cursor-pi-args.ts
-/**
-* Translate a Pi frame's args into the local tool kwargs that run it.
-*
-* Shared deliberately by three consumers: the provider synthesizes a display
-* block from these, the coding-agent bridge executes with them, and the legacy
-* pi shim performs the identical translation for the old wire. Separate
-* hand-rolled copies drift, and the drift is invisible — the transcript shows
-* one operation while a different one runs.
-*
-* Kept apart from `cursor/exec-modern.ts` on purpose: these are pure
-* string/path functions with no protobuf coupling, while that module pulls in
-* the generated cursor protobuf graph. The legacy shim is
-* compiled into the bundled virtual module registry, so importing it from a
-* nested path would drag the whole exec implementation in with it — and
-* `./providers/*` is a single-segment wildcard export that cannot serve a
-* nested specifier under bunfs (issue #3442).
-*
-* Every `optional int32` here is presence-sensitive: `0` is a supplied value,
-* not "unset", so it must never be folded into a default.
-*/
-/**
-* A `pi_read` range composed onto the path as `read`'s inline `:raw:N+K`
-* selector.
-*
-* `read` exposes no range kwargs, so an uncomposed range reads the whole file.
-* `offset` is a 1-indexed start clamped like the reference's
-* `Math.max(0, offset - 1)` over 0-indexed lines; `limit` is a line count.
-* `null` marks a present `limit: 0` — zero lines, which no selector expresses
-* and which must not degrade into a whole-file read.
-*
-* The range is `raw` because a plain `:N+K` deliberately pads with one leading
-* and three trailing context lines: helpful for a human reading a snippet,
-* wrong for a caller that asked for exactly `limit` lines from `offset`. The
-* wire result is an opaque `output` string, so the hashline and line-number
-* gutter that `raw` also drops carry nothing the frame's contract needs.
-* A range-free read keeps the ordinary form — whole-file reads want them.
-*/
-function piReadPath(readPath, offset, limit) {
-	if (limit !== void 0 && Math.floor(limit) <= 0) return null;
-	const start = offset !== void 0 ? Math.max(1, Math.floor(offset)) : void 0;
-	const count = limit !== void 0 ? Math.floor(limit) : void 0;
-	if (start === void 0 && count === void 0) return readPath;
-	const base = readPath.split(":").some((chunk) => chunk.toLowerCase() === "raw") ? readPath : `${readPath}:raw`;
-	if (start === void 0) return `${base}:1+${count}`;
-	return count === void 0 ? `${base}:${start}-` : `${base}:${start}+${count}`;
-}
-const READ_RANGE_CHUNK_RE = /^L?(\d+)(?:(\.\.|[-+])L?(\d+)?)?$/i;
-function isReadRangeList(value) {
-	return value.split(",").every((chunk) => {
-		const match = READ_RANGE_CHUNK_RE.exec(chunk);
-		if (!match) return false;
-		const start = Number.parseInt(match[1], 10);
-		if (start < 1) return false;
-		const separator = match[2];
-		if (!separator) return true;
-		const end = match[3] ? Number.parseInt(match[3], 10) : void 0;
-		if (separator === "+") return end !== void 0 && end >= 1;
-		return end === void 0 || end >= start;
-	});
-}
-/**
-* Whether a read path ends in an OMP line selector, including compound `raw`
-* forms. Cursor uses this only to describe the operation already executed by
-* the coding-agent read tool; the selector remains embedded in the path.
-*/
-function piReadPathHasRange(readPath) {
-	const chunks = readPath.split(":");
-	const last = chunks.at(-1);
-	if (last && isReadRangeList(last)) return true;
-	if (last?.toLowerCase() !== "raw") return false;
-	const preceding = chunks.at(-2);
-	return preceding !== void 0 && isReadRangeList(preceding);
-}
-/**
-* Force a Cursor exec read onto `read`'s verbatim `:raw` selector.
-*
-* Native `editToolCall` (StrReplace) materializes via `readArgs` then
-* `writeArgs`. The server treats the read result as file bytes and writes
-* them back. A hashline-formatted native read (`[path#TAG]` + `LINE:`
-* prefixes) poisons that cycle: the write would persist the markup.
-* `:raw` is the existing selector that drops both. A path that already
-* carries `raw` is left alone; a range-only selector gets `raw` inserted
-* so the range still applies without the gutter.
-*/
-function cursorRawReadPath(readPath) {
-	const chunks = readPath.split(":");
-	if (chunks.some((chunk) => chunk.toLowerCase() === "raw")) return readPath;
-	if (piReadPathHasRange(readPath)) {
-		const last = chunks.pop();
-		return `${chunks.join(":")}:raw:${last}`;
-	}
-	return `${readPath}:raw`;
-}
-/**
-* Path the edit-owned materialization read should execute.
-*
-* Range is composed first (`piReadPath` already uses `:raw` for a range),
-* then a whole-file path is forced onto `:raw`. The caller must drop
-* `offset`/`limit` after this so the bridge's `piReadPath` cannot append a
-* second `:raw` onto the already-composed selector.
-*/
-function cursorEditOwnedReadPath(readPath, offset, limit) {
-	const ranged = piReadPath(readPath, offset, limit);
-	if (ranged === null) return null;
-	return cursorRawReadPath(ranged);
-}
-/**
-* The same range as {@link piReadPath}, rendered for a transcript block rather
-* than for execution.
-*
-* Differs only at `limit: 0`, where `piReadPath` returns `null` because no
-* selector reads zero lines and the frame is answered with empty output
-* directly. The block still has to say so: falling back to the bare path there
-* would record a whole-file read whose result is empty, which is the widest
-* possible gap between what a rebuilt transcript shows and what happened.
-* `+0` is never executed — it exists to be read.
-*/
-function piReadDisplayPath(readPath, offset, limit) {
-	const composed = piReadPath(readPath, offset, limit);
-	if (composed !== null) return composed;
-	return `${readPath}:raw:${offset !== void 0 ? Math.max(1, Math.floor(offset)) : 1}+0`;
-}
-/**
-* A legacy `grep` frame's pagination `offset` as the local tool's file `skip`.
-*
-* `grep` paginates by file and reports "use skip=N for the next page" in that
-* same unit, so the offset maps across directly. A present `0` means "start at
-* the beginning", which is the unskipped search rather than a skip of zero.
-*
-* Shared because both the executing bridge and the provider's transcript
-* synthesis need it: a block showing an unskipped search beside a result from
-* a later file window misreports what was searched.
-*/
-function piGrepSkip(offset) {
-	return offset !== void 0 && offset > 0 ? Math.floor(offset) : void 0;
-}
-/**
-* Join a Pi frame's optional `path` with the `glob`/`pattern` it scopes.
-*
-* The local `grep`/`glob` tools take one combined path spec. An absolute
-* pattern ignores the path, and an absent or `.` path leaves the pattern
-* standing alone rather than building a `./`- or `//`-prefixed spec.
-*
-* Uses `node:path` rather than string surgery so Windows absolutes (`C:\…`,
-* UNC) are recognised and separators stay normalized.
-*/
-function piJoinPath(basePath, pattern) {
-	if (path$1.isAbsolute(pattern)) return pattern;
-	if (!basePath || basePath === ".") return pattern;
-	return path$1.join(basePath, pattern);
-}
-/**
-* The path a `pi_ls` frame lists.
-*
-* The frame's `limit` is deliberately NOT mapped. It caps directory *entries*
-* (the reference does a flat `readdir` and slices the entry array), while the
-* local `read` tool renders a depth-2 tree with per-directory caps and elision
-* summaries and applies a selector as a *rendered line* slice. Nested rows,
-* headers and "N more" lines all count toward that slice, so `:1+K` would cap
-* a different unit while looking honored — worse than leaving it unset, which
-* at least reports the local listing's own truncation faithfully.
-*/
-function piLsPath(basePath) {
-	return basePath || ".";
-}
-/** Escape a literal string so the regex-only local `grep` tool matches it verbatim. */
-function piEscapeRegexLiteral(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-/** Clamp a present `optional int32` result cap the way the reference does; `undefined` stays unset. */
-function piLimit(limit) {
-	return limit === void 0 ? void 0 : Math.max(1, Math.floor(limit));
-}
-/**
-* A `pi_bash` frame's timeout as the local `bash` tool's kwarg.
-*
-* Presence-sensitive like every other `optional int32` here, and unusually
-* load-bearing: `bash` documents `timeout: 0` as "disables the command
-* deadline", so folding a supplied `0` into `undefined` applies the 300s
-* default and kills exactly the long-running command that asked not to be.
-* Negative values have no local meaning and fall back to the default.
-*/
-function piTimeout(timeout) {
-	return timeout !== void 0 && timeout >= 0 ? timeout : void 0;
-}
-/**
-* Drop keys whose value is `undefined` so optional local-tool kwargs stay
-* absent rather than present-as-undefined.
-*
-* The Cursor exec bridge historically wrote forms like
-* `cwd: workingDirectory || undefined` and
-* `case: caseInsensitive === true ? false : undefined`. ArkType rejects a
-* present `undefined` on an optional field (`was undefined`) even though
-* omitting the key is valid — which flooded Cursor sessions with bash/grep
-* validation errors for otherwise fine frames.
-*/
-function omitUndefinedArgs(args) {
-	const out = {};
-	for (const key of Object.keys(args)) {
-		const value = args[key];
-		if (value !== void 0) out[key] = value;
-	}
-	return out;
-}
-//#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/providers/cursor/exec-modern.ts
-/**
-* Proto builders for the modern Cursor CLI exec frames (`ExecServerMessage`
-* 27-31, 36-38, 40-55).
-*
-* Split out of `cursor.ts` because these are pure `create(...)` shapes with no
-* transport, stream, or block-state coupling: the dispatcher decides *which*
-* answer a frame gets, this module knows *what* that answer looks like on the
-* wire. Every builder returns a result whose oneof case is set — an
-* `ExecClientMessage` carrying a result with an unset oneof is a fake success
-* the server reads as "the tool ran and produced nothing".
-*/
-/** Flatten a tool result's content into the single `output` string the Pi frames carry. */
-function piOutputText(toolResult) {
-	return toolResult.content.map((item) => item.type === "text" ? item.text : `[${item.mimeType} image]`).join("\n");
-}
-/**
-* Read one field off a tool result's `details` bag, or off a nested object
-* inside it.
-*
-* `details` is `unknown` by design — every tool ships its own shape — so each
-* read is narrowed rather than asserted, and the caller decides what a value of
-* the wrong type means.
-*/
-function bagValue(bag, key) {
-	if (!bag || typeof bag !== "object" || !(key in bag)) return void 0;
-	return Reflect.get(bag, key);
-}
-/**
-* A positive integer count from `details`, or `undefined`.
-*
-* The Pi frames model their limit counters as `optional uint32`: zero means
-* "the limit was reached at zero results", so a missing, non-numeric, or
-* non-positive value must stay unset rather than be sent as 0.
-*/
-function detailCount(toolResult, key) {
-	return positiveCount(bagValue(toolResult.details, key));
-}
-function positiveCount(value) {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : void 0;
-}
-/**
-* The entry cap a listing hit, from either shape a local tool records it in.
-*
-* `glob` sets a flat `details.resultLimitReached` alongside the structured
-* meta; `read` — which serves `pi_ls` — records the cap only through
-* `OutputMeta` at `details.meta.limits.resultLimit.reached`. Reading just the
-* flat field dropped `entry_limit_reached` for every real listing, so Cursor
-* received clipped output with no incompleteness signal.
-*/
-function resultLimitReached(toolResult) {
-	const flat = detailCount(toolResult, "resultLimitReached");
-	if (flat !== void 0) return flat;
-	return positiveCount(bagValue(bagValue(bagValue(bagValue(toolResult.details, "meta"), "limits"), "resultLimit"), "reached"));
-}
-/**
-* Translate a local tool's truncation summary into `PiTruncation`.
-*
-* Two shapes reach here. `read`/`grep` set `details.truncation`
-* (`TruncationResult`), which carries an explicit `truncated` boolean. `bash`
-* sets `details.meta.truncation` (`TruncationMeta`), which has **no** such
-* flag — its presence *is* the signal, and requiring the boolean silently
-* dropped every Bash truncation, handing Cursor clipped output with no notice
-* that it was clipped.
-*
-* Returns `undefined` when nothing was truncated: the field is `optional` on
-* every Pi success message, and emitting a zeroed `PiTruncation` would tell the
-* server the output was trimmed to nothing.
-*/
-function piTruncation(toolResult) {
-	const direct = bagValue(toolResult.details, "truncation");
-	const truncation = direct !== void 0 ? direct : bagValue(bagValue(toolResult.details, "meta"), "truncation");
-	if (truncation === void 0 || truncation === null) return void 0;
-	const flag = bagValue(truncation, "truncated");
-	if (flag !== void 0 && flag !== true) return void 0;
-	const truncatedBy = bagValue(truncation, "truncatedBy");
-	const totalLines = bagValue(truncation, "totalLines");
-	const outputLines = bagValue(truncation, "outputLines");
-	const outputBytes = bagValue(truncation, "outputBytes");
-	return create(PiTruncationSchema, {
-		truncated: true,
-		truncatedBy: typeof truncatedBy === "string" ? truncatedBy : "",
-		totalLines: typeof totalLines === "number" ? totalLines : 0,
-		outputLines: typeof outputLines === "number" ? outputLines : 0,
-		outputBytes: typeof outputBytes === "number" ? outputBytes : 0,
-		firstLineExceedsLimit: bagValue(truncation, "firstLineExceedsLimit") === true,
-		lastLinePartial: bagValue(truncation, "lastLinePartial") === true
-	});
-}
-function buildPiReadResult(toolResult) {
-	const text = piOutputText(toolResult);
-	if (toolResult.isError) return buildPiReadError(text || "Read failed");
-	return create(PiReadExecResultSchema, { result: {
-		case: "success",
-		value: create(PiReadExecSuccessSchema, {
-			output: text,
-			truncation: piTruncation(toolResult)
-		})
-	} });
-}
-function buildPiReadError(error) {
-	return create(PiReadExecResultSchema, { result: {
-		case: "error",
-		value: create(PiReadExecErrorSchema, { error })
-	} });
-}
-function buildPiBashResult(toolResult) {
-	const text = piOutputText(toolResult);
-	const truncation = piTruncation(toolResult);
-	if (toolResult.isError) return create(PiBashExecResultSchema, { result: {
-		case: "error",
-		value: create(PiBashExecErrorSchema, {
-			error: text || "Command failed",
-			truncation
-		})
-	} });
-	return create(PiBashExecResultSchema, { result: {
-		case: "success",
-		value: create(PiBashExecSuccessSchema, {
-			output: text,
-			truncation
-		})
-	} });
-}
-function buildPiBashError(error) {
-	return create(PiBashExecResultSchema, { result: {
-		case: "error",
-		value: create(PiBashExecErrorSchema, { error })
-	} });
-}
-/**
-* `PiEditExecSuccess` requires `diff` and `patch` alongside `output`. The local
-* `edit` tool reports them under `details`; when it does not, the strings stay
-* empty rather than being faked from the output text.
-*/
-function buildPiEditResult(toolResult) {
-	const text = piOutputText(toolResult);
-	if (toolResult.isError) return buildPiEditError(text || "Edit failed");
-	const diff = bagValue(toolResult.details, "diff");
-	const patch = bagValue(toolResult.details, "patch");
-	return create(PiEditExecResultSchema, { result: {
-		case: "success",
-		value: create(PiEditExecSuccessSchema, {
-			output: text,
-			diff: typeof diff === "string" ? diff : "",
-			patch: typeof patch === "string" ? patch : "",
-			firstChangedLine: detailCount(toolResult, "firstChangedLine")
-		})
-	} });
-}
-function buildPiEditError(error) {
-	return create(PiEditExecResultSchema, { result: {
-		case: "error",
-		value: create(PiEditExecErrorSchema, { error })
-	} });
-}
-/**
-* A refusal is not an execution failure: `PiEditExecResult` models them as
-* separate variants, and answering a denied call with `error` reads as "the
-* edit ran and broke", which invites a retry of an operation that was never
-* permitted.
-*/
-function buildPiEditRejected(reason) {
-	return create(PiEditExecResultSchema, { result: {
-		case: "rejected",
-		value: create(PiEditExecRejectedSchema, { reason })
-	} });
-}
-function buildPiWriteResult(toolResult) {
-	const text = piOutputText(toolResult);
-	if (toolResult.isError) return buildPiWriteError(text || "Write failed");
-	return create(PiWriteExecResultSchema, { result: {
-		case: "success",
-		value: create(PiWriteExecSuccessSchema, { output: text })
-	} });
-}
-function buildPiWriteError(error) {
-	return create(PiWriteExecResultSchema, { result: {
-		case: "error",
-		value: create(PiWriteExecErrorSchema, { error })
-	} });
-}
-/** Same variant split as {@link buildPiEditRejected}. */
-function buildPiWriteRejected(reason) {
-	return create(PiWriteExecResultSchema, { result: {
-		case: "rejected",
-		value: create(PiWriteExecRejectedSchema, { reason })
-	} });
-}
-function buildPiGrepResult(toolResult) {
-	const text = piOutputText(toolResult);
-	if (toolResult.isError) return buildPiGrepError(text || "Grep failed");
-	const matchLimitReached = detailCount(toolResult, "perFileLimitReached");
-	return create(PiGrepExecResultSchema, { result: {
-		case: "success",
-		value: create(PiGrepExecSuccessSchema, {
-			output: text,
-			truncation: piTruncation(toolResult) ?? grepInternalCapTruncation(toolResult, text, matchLimitReached),
-			matchLimitReached,
-			linesTruncated: bagValue(toolResult.details, "linesTruncated") === true
-		})
-	} });
-}
-/**
-* The one grep cap that reaches Cursor through no other field.
-*
-* `GrepTool` folds every cap into the flat `details.truncated`, but only
-* populates `details.truncation` when the output text itself was trimmed and
-* `perFileLimitReached` when a per-file or explicit total cap fired. Its native
-* backend's own ceiling (`INTERNAL_TOTAL_CAP`) sets neither, so a search that
-* hit it answered as an unqualified success over incomplete results — the one
-* failure mode a caller cannot detect and cannot retry around.
-*
-* Only consulted once the specific signals came back empty, so a cap that did
-* report itself is never restated. `totalLines` stays 0: the flat flag says
-* that results were dropped, not how many there were.
-*/
-function grepInternalCapTruncation(toolResult, text, matchLimitReached) {
-	if (matchLimitReached !== void 0) return void 0;
-	if (bagValue(toolResult.details, "truncated") !== true) return void 0;
-	return create(PiTruncationSchema, {
-		truncated: true,
-		truncatedBy: "matches",
-		totalLines: 0,
-		outputLines: text ? text.split("\n").length : 0,
-		outputBytes: Buffer.byteLength(text, "utf-8"),
-		firstLineExceedsLimit: false,
-		lastLinePartial: false
-	});
-}
-function buildPiGrepError(error) {
-	return create(PiGrepExecResultSchema, { result: {
-		case: "error",
-		value: create(PiGrepExecErrorSchema, { error })
-	} });
-}
-function buildPiFindResult(toolResult) {
-	const text = piOutputText(toolResult);
-	if (toolResult.isError) return buildPiFindError(text || "Find failed");
-	return create(PiFindExecResultSchema, { result: {
-		case: "success",
-		value: create(PiFindExecSuccessSchema, {
-			output: text,
-			truncation: piTruncation(toolResult),
-			resultLimitReached: resultLimitReached(toolResult)
-		})
-	} });
-}
-function buildPiFindError(error) {
-	return create(PiFindExecResultSchema, { result: {
-		case: "error",
-		value: create(PiFindExecErrorSchema, { error })
-	} });
-}
-function buildPiLsResult(toolResult) {
-	const text = piOutputText(toolResult);
-	if (toolResult.isError) return buildPiLsError(text || "Ls failed");
-	return create(PiLsExecResultSchema, { result: {
-		case: "success",
-		value: create(PiLsExecSuccessSchema, {
-			output: text,
-			truncation: piTruncation(toolResult),
-			entryLimitReached: resultLimitReached(toolResult)
-		})
-	} });
-}
-function buildPiLsError(error) {
-	return create(PiLsExecResultSchema, { result: {
-		case: "error",
-		value: create(PiLsExecErrorSchema, { error })
-	} });
-}
-/**
-* Answer `mcpStateExecArgs` (frame 36) from the catalog already advertised in
-* `RequestContext.tools`.
-*
-* This client hosts no MCP servers of its own: every forwarded tool is a local
-* pi-agent tool published under a synthetic `providerIdentifier`. Regrouping
-* the same list keeps the server's view of "which servers exist and what do
-* they expose" consistent with what it was told at context time, instead of
-* claiming zero servers while tool calls for them keep arriving.
-*
-* `serverIdentifiers` filters the answer when the server asks about specific
-* servers. `kickOnly` is a restart request — there is nothing to restart, so it
-* is answered with the same state rather than an error.
-*/
-function buildMcpStateResult(tools, serverIdentifiers) {
-	const byProvider = /* @__PURE__ */ new Map();
-	for (const tool of tools) {
-		const identifier = tool.providerIdentifier;
-		const existing = byProvider.get(identifier);
-		if (existing) existing.push(tool);
-		else byProvider.set(identifier, [tool]);
-	}
-	const wanted = serverIdentifiers.length > 0 ? new Set(serverIdentifiers) : void 0;
-	const servers = [];
-	for (const [identifier, serverTools] of byProvider) {
-		if (wanted && !wanted.has(identifier)) continue;
-		servers.push(create(McpStateServerSchema, {
-			serverName: identifier,
-			serverIdentifier: identifier,
-			tools: serverTools,
-			status: "connected"
-		}));
-	}
-	return create(McpStateExecResultSchema, { result: {
-		case: "success",
-		value: create(McpStateSuccessSchema, { servers })
-	} });
-}
-/**
-* Build the neutral response for a hook query: the matching response case with
-* every field unset.
-*
-* This client runs no Cursor hooks, and every field of every response variant
-* is `optional` — so an empty response of the right case means "no hook had
-* anything to say", which is exactly true. It is NOT the unset-oneof fake
-* success: the case itself is set, only the payload is empty.
-*
-* `ExecuteHookRequest` and `ExecuteHookResponse` are parallel oneofs whose case
-* names line up, but the two unions are unrelated to the compiler: a `switch`
-* is what makes each pairing individually type-checked, and it forces a
-* deliberate branch when a future regen adds a request case.
-*
-* Returns `null` for a request case this build does not model, which the
-* dispatcher answers with `ExecClientThrow` rather than guessing a case.
-*/
-function buildNeutralHookResult(request) {
-	let response;
-	switch (request?.request.case) {
-		case "preCompact":
-			response = create(ExecuteHookResponseSchema, { response: {
-				case: "preCompact",
-				value: create(PreCompactRequestResponseSchema, {})
-			} });
-			break;
-		case "subagentStart":
-			response = create(ExecuteHookResponseSchema, { response: {
-				case: "subagentStart",
-				value: create(SubagentStartRequestResponseSchema, {})
-			} });
-			break;
-		case "subagentStop":
-			response = create(ExecuteHookResponseSchema, { response: {
-				case: "subagentStop",
-				value: create(SubagentStopRequestResponseSchema, {})
-			} });
-			break;
-		case "preToolUse":
-			response = create(ExecuteHookResponseSchema, { response: {
-				case: "preToolUse",
-				value: create(PreToolUseRequestResponseSchema, {})
-			} });
-			break;
-		case "postToolUse":
-			response = create(ExecuteHookResponseSchema, { response: {
-				case: "postToolUse",
-				value: create(PostToolUseRequestResponseSchema, {})
-			} });
-			break;
-		case "postToolUseFailure":
-			response = create(ExecuteHookResponseSchema, { response: {
-				case: "postToolUseFailure",
-				value: create(PostToolUseFailureRequestResponseSchema, {})
-			} });
-			break;
-		case "beforeSubmitPrompt":
-			response = create(ExecuteHookResponseSchema, { response: {
-				case: "beforeSubmitPrompt",
-				value: create(BeforeSubmitPromptRequestResponseSchema, {})
-			} });
-			break;
-		case "afterAgentResponse":
-			response = create(ExecuteHookResponseSchema, { response: {
-				case: "afterAgentResponse",
-				value: create(AfterAgentResponseRequestResponseSchema, {})
-			} });
-			break;
-		case "afterAgentThought":
-			response = create(ExecuteHookResponseSchema, { response: {
-				case: "afterAgentThought",
-				value: create(AfterAgentThoughtRequestResponseSchema, {})
-			} });
-			break;
-		case "stop":
-			response = create(ExecuteHookResponseSchema, { response: {
-				case: "stop",
-				value: create(StopRequestResponseSchema, {})
-			} });
-			break;
-		default: return null;
-	}
-	return create(ExecuteHookResultSchema, { response });
-}
-//#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/providers/cursor/interaction-query.ts
-const NOT_IMPLEMENTED_SUFFIX$1 = "not implemented by this client";
-function frameConnectMessage$1(data, flags = 0) {
-	const frame = Buffer.alloc(5 + data.length);
-	frame[0] = flags;
-	frame.writeUInt32BE(data.length, 1);
-	frame.set(data, 5);
-	return frame;
-}
-function isProtoUnknownField(value) {
-	if (!value || typeof value !== "object") return false;
-	if (!("no" in value) || !("wireType" in value) || !("data" in value)) return false;
-	return typeof value.no === "number" && typeof value.wireType === "number" && value.data instanceof Uint8Array;
-}
-function protoUnknownFields$1(message) {
-	if (!("$unknown" in message) || !Array.isArray(message.$unknown)) return [];
-	return message.$unknown.filter(isProtoUnknownField);
-}
-function attachUnknownApprovedField(response, fieldNo) {
-	const bag = response;
-	const field = {
-		no: fieldNo,
-		wireType: 2,
-		data: new Uint8Array([
-			2,
-			10,
-			0
-		])
-	};
-	const existing = bag.$unknown;
-	if (Array.isArray(existing)) {
-		existing.push(field);
-		return;
-	}
-	bag.$unknown = [field];
-}
-function log$1(type, subtype, data) {
-	if (!$env.DEBUG_CURSOR) return;
-	const dataStr = ($env.DEBUG_CURSOR === "2" || $env.DEBUG_CURSOR === "verbose") && data ? ` ${JSON.stringify(data)?.slice(0, 500)}` : "";
-	console.error(`[CURSOR] ${type}${subtype ? `: ${subtype}` : ""}${dataStr}`);
-}
-function sendInteractionResponse(h2Request, queryId, result) {
-	const response = create(InteractionResponseSchema, {
-		id: queryId,
-		result
-	});
-	const clientMessage = create(AgentClientMessageSchema, { message: {
-		case: "interactionResponse",
-		value: response
-	} });
-	h2Request.write(frameConnectMessage$1(toBinary(AgentClientMessageSchema, clientMessage)));
-	log$1("interactionResponse", result.case, { id: queryId });
-}
-function sendUnknownApprovedInteractionResponse(h2Request, queryId, fieldNo) {
-	const response = create(InteractionResponseSchema, { id: queryId });
-	attachUnknownApprovedField(response, fieldNo);
-	const clientMessage = create(AgentClientMessageSchema, { message: {
-		case: "interactionResponse",
-		value: response
-	} });
-	h2Request.write(frameConnectMessage$1(toBinary(AgentClientMessageSchema, clientMessage)));
-	log$1("interactionResponse", "unknownApproved", {
-		id: queryId,
-		field: fieldNo
-	});
-}
-/**
-* Answer a Cursor `interaction_query` so the Run RPC can continue.
-*
-* Hosted web search / Exa / unnamed permission gates (field 9 = WebFetch on
-* current Cursor builds) block the turn until the client writes an
-* `interaction_response`. Dropping the frame leaves the HTTP/2 stream alive
-* on heartbeats that are not semantic progress; the lazy idle watchdog then
-* aborts with "Provider stream stalled while waiting for the next event".
-*
-* Unsupported interactive queries are rejected so the server is not stranded.
-* VM setup is left unanswered rather than reporting a fake success.
-*/
-function handleInteractionQuery(query, h2Request) {
-	const queryCase = query.query.case;
-	log$1("interactionQuery", queryCase, query.query.value);
-	if (!queryCase) {
-		const unknown = protoUnknownFields$1(query).find((field) => field.wireType === 2 && field.no >= 2);
-		if (unknown) {
-			log$1("warn", "unknownInteractionQueryApproved", {
-				id: query.id,
-				field: unknown.no
-			});
-			sendUnknownApprovedInteractionResponse(h2Request, query.id, unknown.no);
-			return;
-		}
-		log$1("warn", "unknownInteractionQuery", { id: query.id });
-		return;
-	}
-	switch (queryCase) {
-		case "webSearchRequestQuery":
-			sendInteractionResponse(h2Request, query.id, {
-				case: "webSearchRequestResponse",
-				value: create(WebSearchRequestResponseSchema, { result: {
-					case: "approved",
-					value: create(WebSearchRequestResponse_ApprovedSchema, {})
-				} })
-			});
-			return;
-		case "exaSearchRequestQuery":
-			sendInteractionResponse(h2Request, query.id, {
-				case: "exaSearchRequestResponse",
-				value: create(ExaSearchRequestResponseSchema, { result: {
-					case: "approved",
-					value: create(ExaSearchRequestResponse_ApprovedSchema, {})
-				} })
-			});
-			return;
-		case "exaFetchRequestQuery":
-			sendInteractionResponse(h2Request, query.id, {
-				case: "exaFetchRequestResponse",
-				value: create(ExaFetchRequestResponseSchema, { result: {
-					case: "approved",
-					value: create(ExaFetchRequestResponse_ApprovedSchema, {})
-				} })
-			});
-			return;
-		case "webFetchRequestQuery":
-			sendInteractionResponse(h2Request, query.id, {
-				case: "webFetchRequestResponse",
-				value: create(WebFetchRequestResponseSchema, { result: {
-					case: "approved",
-					value: create(WebFetchRequestResponse_ApprovedSchema, {})
-				} })
-			});
-			return;
-		case "askQuestionInteractionQuery":
-			sendInteractionResponse(h2Request, query.id, {
-				case: "askQuestionInteractionResponse",
-				value: create(AskQuestionInteractionResponseSchema, { result: create(AskQuestionResultSchema, { result: {
-					case: "rejected",
-					value: create(AskQuestionRejectedSchema, { reason: `Interactive questions are ${NOT_IMPLEMENTED_SUFFIX$1}` })
-				} }) })
-			});
-			return;
-		case "switchModeRequestQuery":
-			sendInteractionResponse(h2Request, query.id, {
-				case: "switchModeRequestResponse",
-				value: create(SwitchModeRequestResponseSchema, { result: {
-					case: "rejected",
-					value: create(SwitchModeRequestResponse_RejectedSchema, { reason: `Mode switches are ${NOT_IMPLEMENTED_SUFFIX$1}` })
-				} })
-			});
-			return;
-		case "createPlanRequestQuery":
-			sendInteractionResponse(h2Request, query.id, {
-				case: "createPlanRequestResponse",
-				value: create(CreatePlanRequestResponseSchema, { result: create(CreatePlanResultSchema, { result: {
-					case: "error",
-					value: create(CreatePlanErrorSchema, { error: `Plan files are ${NOT_IMPLEMENTED_SUFFIX$1}` })
-				} }) })
-			});
-			return;
-		case "setupVmEnvironmentArgs":
-			log$1("warn", "unhandledInteractionQuery", {
-				queryCase,
-				id: query.id
-			});
-			return;
-		default: log$1("warn", "unhandledInteractionQuery", {
-			queryCase,
-			id: query.id
-		});
-	}
-}
-const CURSOR_CLIENT_VERSION = "cli-2026.07.23-e383d2b";
-/**
-* HTTP/1 connection-specific headers that HTTP/2 forbids. Node's `http2.request()`
-* throws `ERR_HTTP2_INVALID_CONNECTION_HEADERS` on these rather than dropping
-* them, so a caller sending one would kill the request outright.
-*/
-const HTTP2_FORBIDDEN_HEADERS = /* @__PURE__ */ new Set([
-	"connection",
-	"keep-alive",
-	"proxy-connection",
-	"transfer-encoding",
-	"upgrade",
-	"http2-settings"
-]);
-/**
-* Header names the Cursor request sets for itself. A caller copy in ANY casing
-* has to go: the spread below adds the fixed lower-case name regardless, and two
-* spellings of one field are a duplicate rather than an override.
-*/
-const CURSOR_RESERVED_HEADERS = /* @__PURE__ */ new Set([
-	"content-type",
-	"connect-protocol-version",
-	"te",
-	"authorization",
-	"x-ghost-mode",
-	"x-cursor-client-version",
-	"x-cursor-client-type",
-	"x-request-id",
-	"host",
-	"content-length"
-]);
-/**
-* Reduce caller-supplied headers to what this HTTP/2 request can legally carry.
-*
-* Everything is lower-cased, because HTTP/2 field names are lower-case and node
-* compares them that way. A caller `Authorization` next to the fixed
-* `authorization` does not lose to it, it DUPLICATES it, and node throws
-* `ERR_HTTP2_HEADER_SINGLE_VALUE` before the request goes out. Same for a `TE`
-* that is not `trailers`. Node throws on all three classes here rather than
-* ignoring them, so a miss turns a harmless header into a dead request.
-*/
-function sanitizeCursorCallerHeaders(headers) {
-	const sanitized = {};
-	for (const [name, value] of Object.entries(headers ?? {})) {
-		const field = name.toLowerCase();
-		if (field.startsWith(":")) continue;
-		if (HTTP2_FORBIDDEN_HEADERS.has(field)) continue;
-		if (CURSOR_RESERVED_HEADERS.has(field)) continue;
-		sanitized[field] = value;
-	}
-	return sanitized;
-}
-const CURSOR_PROXY_TUNNEL_TIMEOUT_MS = 3e4;
-/**
-* Text for a recognised frame this client answers with its own typed error
-* variant. Phrased as a client capability statement, not a tool failure: the
-* model reads it and should route around the capability, not retry the call.
-*/
-const NOT_IMPLEMENTED_SUFFIX = "not implemented by this client";
-/** Bare gRPC `resource_exhausted` end-streams (also inside a Connect error message). */
-const RESOURCE_EXHAUSTED_PATTERN = /resource.?exhausted/i;
-/** Model-resolution failures that can safely retry the exact discovery id before any server output. */
-const CURSOR_MODEL_NOT_FOUND_PATTERN = /^(?:Connect error not_found:|gRPC error 5:)/i;
-const NOT_IMPLEMENTED = `Not implemented by this client`;
-const conversationStateCache = /* @__PURE__ */ new Map();
-const conversationBlobStores = /* @__PURE__ */ new Map();
-const warnedCursorKimiK3ReplayMessages = /* @__PURE__ */ new Set();
-/**
-* Base conversation id → rotated wire id (#8345). Cursor's backend can pin a
-* per-conversation rejection (bare `resource_exhausted`, zero tokens) to one
-* conversationId forever. On such a failure the id is rotated and the next
-* attempt rebuilds a fresh conversation from `context` (no cached-state
-* migration). A failed rotation is not repeated, so real account exhaustion
-* is not hidden. After the rotated id completes a turn, a later poison of
-* that id is allowed to rotate again.
-*/
-const rotatedConversationIds = /* @__PURE__ */ new Map();
-const successfulRotatedConversationIds = /* @__PURE__ */ new Set();
-const freshRotatedConversationIds = /* @__PURE__ */ new Set();
-const CONNECT_END_STREAM_FLAG = 2;
-async function appendCursorDebugLog(entry) {
-	const logPath = $env.DEBUG_CURSOR_LOG;
-	if (!logPath) return;
-	try {
-		await fs_promises_shim_exports.appendFile(logPath, `${JSON.stringify(entry, debugReplacer)}\n`);
-	} catch {}
-}
-function log(type, subtype, data) {
-	if (!$env.DEBUG_CURSOR) return;
-	const normalizedData = data ? decodeLogData(data) : data;
-	const entry = {
-		ts: Date.now(),
-		type,
-		subtype,
-		data: normalizedData
-	};
-	const dataStr = ($env.DEBUG_CURSOR === "2" || $env.DEBUG_CURSOR === "verbose") && normalizedData ? ` ${JSON.stringify(normalizedData, debugReplacer)?.slice(0, 500)}` : "";
-	console.error(`[CURSOR] ${type}${subtype ? `: ${subtype}` : ""}${dataStr}`);
-	appendCursorDebugLog(entry);
-}
-function frameConnectMessage(data, flags = 0) {
-	const frame = Buffer.alloc(5 + data.length);
-	frame[0] = flags;
-	frame.writeUInt32BE(data.length, 1);
-	frame.set(data, 5);
-	return frame;
-}
-var ConnectEndStreamError = class extends ProviderResponseError {
-	diagnosticMessage;
-	constructor(classificationMessage, diagnosticMessage) {
-		super(classificationMessage, { kind: "envelope" });
-		this.diagnosticMessage = diagnosticMessage;
-	}
-};
-function parseConnectEndStream(data) {
-	try {
-		const error = JSON.parse(new TextDecoder().decode(data))?.error;
-		if (error) return new ConnectEndStreamError(`Connect error ${typeof error.code === "string" ? error.code : "unknown"}: ${typeof error.message === "string" ? error.message : "Unknown error"}`, formatConnectEndStreamError(error));
-		return null;
-	} catch {
-		return new ProviderResponseError("Failed to parse Connect end stream", { kind: "envelope" });
-	}
-}
-/**
-* Maps an opaque HTTP/2 negotiation failure into an actionable error.
-*
-* bun only opens an HTTP/2 session when TLS-ALPN negotiates `h2`. Behind a
-* TLS-intercepting proxy that strips ALPN (e.g. Zscaler), the handshake yields
-* no `h2` protocol and bun throws `ERR_HTTP2_ERROR: h2 is not supported`. The
-* Cursor run RPC is HTTP/2-only (the ALB rejects HTTP/1.1 with 464), so there
-* is no h1 fallback the way model discovery has one — the run simply cannot
-* proceed. Replace the opaque message with one that names the cause and points
-* at the `providers.cursor.baseUrl` workaround.
-*
-* Non-ALPN errors pass through untouched.
-*/
-function mapH2TransportError(error, baseUrl) {
-	const code = error?.code;
-	const message = error instanceof Error ? error.message : String(error);
-	if (code === "ERR_HTTP2_ERROR" && /h2 is not supported/i.test(message)) return new ProviderResponseError(`Cursor run transport could not negotiate HTTP/2 with ${baseUrl}: "h2 is not supported". This host serves the run RPC over HTTP/2 only, and the TLS handshake did not negotiate h2 via ALPN — typically an ALPN-stripping TLS-intercepting proxy (e.g. Zscaler). Front the provider with a local HTTP/2 bridge and set providers.cursor.baseUrl to it.`, {
-		provider: "cursor",
-		kind: "runtime",
-		cause: error
-	});
-	return error;
-}
-function debugBytes(bytes, asHex) {
-	if (asHex) return Buffer.from(bytes).toString("hex");
-	try {
-		const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-		if (/^[\x20-\x7E\s]*$/.test(text)) return text;
-	} catch {}
-	return Buffer.from(bytes).toString("hex");
-}
-function debugReplacer(key, value) {
-	if (value instanceof Uint8Array || value && typeof value === "object" && "type" in value && value.type === "Buffer") return debugBytes(value instanceof Uint8Array ? value : new Uint8Array(value.data), key === "blobId" || key === "blob_id" || key.endsWith("Id") || key.endsWith("_id"));
-	if (typeof value === "bigint") return value.toString();
-	return value;
-}
-function extractLogBytes(value) {
-	if (value instanceof Uint8Array) return value;
-	if (value && typeof value === "object" && "type" in value && value.type === "Buffer") {
-		const data = value.data;
-		if (Array.isArray(data)) return new Uint8Array(data);
-	}
-	return null;
-}
-function decodeMcpArgsForLog(args) {
-	if (!args) return;
-	let mutated = false;
-	const decoded = {};
-	for (const [key, value] of Object.entries(args)) {
-		const bytes = extractLogBytes(value);
-		if (bytes) {
-			decoded[key] = decodeMcpArgValue(bytes);
-			mutated = true;
-			continue;
-		}
-		const normalizedValue = decodeLogData(value);
-		decoded[key] = normalizedValue;
-		if (normalizedValue !== value) mutated = true;
-	}
-	return mutated ? decoded : args;
-}
-function decodeLogData(value) {
-	if (!value || typeof value !== "object") return value;
-	if (Array.isArray(value)) return value.map((entry) => decodeLogData(entry));
-	const record = value;
-	const typeName = record.$typeName;
-	const stripTypeName = typeof typeName === "string" && typeName.startsWith("agent.v1.");
-	if (typeName === "agent.v1.McpArgs") {
-		const decodedArgs = decodeMcpArgsForLog(record.args);
-		const base = stripTypeName ? omitTypeName(record) : record;
-		return decodedArgs ? {
-			...base,
-			args: decodedArgs
-		} : base;
-	}
-	if (typeName === "agent.v1.McpToolCall") {
-		const argsRecord = record.args;
-		const decodedArgs = decodeMcpArgsForLog(argsRecord?.args);
-		const base = stripTypeName ? omitTypeName(record) : record;
-		if (decodedArgs && argsRecord) return {
-			...base,
-			args: {
-				...argsRecord,
-				args: decodedArgs
-			}
-		};
-		return base;
-	}
-	let mutated = stripTypeName;
-	const decoded = {};
-	for (const [key, entry] of Object.entries(record)) {
-		if (stripTypeName && key === "$typeName") continue;
-		const normalizedEntry = decodeLogData(entry);
-		decoded[key] = normalizedEntry;
-		if (normalizedEntry !== entry) mutated = true;
-	}
-	return mutated ? decoded : record;
-}
-function omitTypeName(record) {
-	const { $typeName: _, ...rest } = record;
-	return rest;
-}
-function streamCursorWithWireMode(model, context, options, wireMode, timing) {
-	const stream = new AssistantMessageEventStream();
-	(async () => {
-		const startTime = timing?.startTime ?? performance.now();
-		let firstTokenTime;
-		const output = {
-			role: "assistant",
-			content: [],
-			api: "cursor-agent",
-			provider: model.provider,
-			model: model.id,
-			usage: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				totalTokens: 0,
-				cost: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					total: 0
-				}
-			},
-			stopReason: "stop",
-			timestamp: timing?.timestamp ?? Date.now()
-		};
-		const inFlightDispatches = /* @__PURE__ */ new Set();
-		let abortSettled;
-		const drainInFlightDispatches = async () => {
-			const signal = options?.signal;
-			while (inFlightDispatches.size > 0) {
-				if (signal?.aborted) return;
-				const settled = Promise.all(inFlightDispatches);
-				if (!signal) {
-					await settled;
-					continue;
-				}
-				abortSettled ??= new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
-				await Promise.race([settled, abortSettled]);
-			}
-		};
-		let h2Client = null;
-		let h2Request = null;
-		let heartbeatTimer = null;
-		let debugResponseLogPromise;
-		const h2Completion = Promise.withResolvers();
-		let h2Settled = false;
-		let sawTurnEnded = false;
-		let endStreamError = null;
-		let sawProgressOrSideEffect = false;
-		let openBlockState;
-		const settleH2 = (error) => {
-			if (h2Settled) return;
-			h2Settled = true;
-			if (error !== void 0) {
-				h2Completion.reject(error);
-				return;
-			}
-			if (endStreamError) {
-				h2Completion.reject(endStreamError);
-				return;
-			}
-			if (!sawTurnEnded) {
-				h2Completion.reject(new ProviderResponseError("Cursor stream ended before turnEnded", { kind: "incomplete-stream" }));
-				return;
-			}
-			h2Completion.resolve();
-		};
-		let baseConversationId;
-		let conversationId;
-		let usageState;
-		let serializedFallbackWireModelId;
-		try {
-			const apiKey = options?.apiKey;
-			if (!apiKey) throw new MissingApiKeyError(void 0, "Cursor API key (access token) is required");
-			baseConversationId = options?.conversationId ?? options?.sessionId ?? crypto.randomUUID();
-			conversationId = rotatedConversationIds.get(baseConversationId) ?? baseConversationId;
-			const rotatedFresh = freshRotatedConversationIds.has(conversationId);
-			const blobStore = conversationBlobStores.get(conversationId) ?? /* @__PURE__ */ new Map();
-			conversationBlobStores.set(conversationId, blobStore);
-			const cachedState = rotatedFresh ? void 0 : conversationStateCache.get(conversationId);
-			const builtRequest = await buildGrpcRequestForWireMode(model, context, options, {
-				conversationId,
-				blobStore,
-				conversationState: cachedState,
-				rotatedFresh
-			}, wireMode);
-			const { requestBytes, conversationState } = builtRequest;
-			serializedFallbackWireModelId = builtRequest.fallbackWireModelId;
-			conversationStateCache.set(conversationId, conversationState);
-			const requestContextTools = buildMcpToolDefinitions(context.tools, model.requiresCursorToolSchemaProjection === true);
-			const requestContextRules = buildCursorRequestContextRules(context.systemPrompt);
-			const baseUrl = model.baseUrl || "https://api2.cursor.sh";
-			const requestPath = "/agent.v1.AgentService/Run";
-			const requestHeaders = {
-				...sanitizeCursorCallerHeaders(options?.headers),
-				":method": "POST",
-				":path": requestPath,
-				"content-type": "application/connect+proto",
-				"connect-protocol-version": "1",
-				te: "trailers",
-				authorization: `Bearer ${apiKey}`,
-				"x-ghost-mode": "true",
-				"x-cursor-client-version": CURSOR_CLIENT_VERSION,
-				"x-cursor-client-type": "cli",
-				"x-request-id": crypto.randomUUID()
-			};
-			const debugSession = isRequestDebugEnabled() ? await createRequestDebugSession({
-				protocol: "http2",
-				method: "POST",
-				url: new URL(requestPath, baseUrl).toString(),
-				headers: requestHeaders,
-				bodyBase64: Buffer.from(requestBytes).toString("base64")
-			}) : void 0;
-			const proxyUrl = getProxyForUrl(model.provider, new URL(baseUrl));
-			if (proxyUrl) {
-				const tlsSocket = await connectProxiedSocket(proxyUrl, baseUrl, {
-					signal: options?.signal,
-					timeoutMs: CURSOR_PROXY_TUNNEL_TIMEOUT_MS
-				});
-				h2Client = http2.connect(baseUrl, { createConnection: () => tlsSocket });
-			} else h2Client = http2.connect(baseUrl);
-			h2Client.on("error", (error) => settleH2(mapH2TransportError(error, baseUrl)));
-			h2Request = h2Client.request(requestHeaders);
-			stream.push({
-				type: "start",
-				partial: output
-			});
-			let pendingBuffer = Buffer.alloc(0);
-			let currentTextBlock = null;
-			let currentThinkingBlock = null;
-			let currentToolCall = null;
-			const resolvedMcpToolCallIds = /* @__PURE__ */ new Set();
-			usageState = { sawTokenDelta: false };
-			const state = {
-				get currentTextBlock() {
-					return currentTextBlock;
-				},
-				get currentThinkingBlock() {
-					return currentThinkingBlock;
-				},
-				get currentToolCall() {
-					return currentToolCall;
-				},
-				openToolCalls: /* @__PURE__ */ new Map(),
-				resolvedMcpToolCallIds,
-				get firstTokenTime() {
-					return firstTokenTime;
-				},
-				setTextBlock: (b) => {
-					currentTextBlock = b;
-				},
-				setThinkingBlock: (b) => {
-					currentThinkingBlock = b;
-				},
-				setToolCall: (t) => {
-					currentToolCall = t;
-				},
-				setFirstTokenTime: () => {
-					if (!firstTokenTime) firstTokenTime = performance.now();
-				},
-				onTodoSnapshot: options?.execHandlers?.todoSync?.bind(options.execHandlers),
-				onToolResult: options?.onToolResult
-			};
-			openBlockState = state;
-			const onConversationCheckpoint = (checkpoint) => {
-				conversationStateCache.set(conversationId, checkpoint);
-			};
-			h2Request.on("response", (headers) => {
-				debugResponseLogPromise = debugSession?.openResponseLog(`HTTP/2 ${headers[":status"] ?? ""}`.trim(), headers);
-			});
-			h2Request.on("data", (chunk) => {
-				if (debugResponseLogPromise) debugResponseLogPromise.then((log) => {
-					log?.write(chunk);
-				});
-				pendingBuffer = pendingBuffer.length === 0 ? chunk : Buffer.concat([pendingBuffer, chunk]);
-				while (pendingBuffer.length >= 5) {
-					const flags = pendingBuffer[0];
-					const msgLen = pendingBuffer.readUInt32BE(1);
-					if (pendingBuffer.length < 5 + msgLen) break;
-					const messageBytes = pendingBuffer.subarray(5, 5 + msgLen);
-					pendingBuffer = pendingBuffer.subarray(5 + msgLen);
-					if (flags & CONNECT_END_STREAM_FLAG) {
-						const endError = parseConnectEndStream(messageBytes);
-						if (endError) {
-							endStreamError = endError;
-							h2Request?.close();
-						}
-						continue;
-					}
-					try {
-						const serverMessage = fromBinary(AgentServerMessageSchema, messageBytes);
-						const interactionCase = (serverMessage.message.case === "interactionUpdate" ? serverMessage.message.value : void 0)?.message?.case;
-						if (interactionCase !== "heartbeat") sawProgressOrSideEffect = true;
-						const isTurnEnded = interactionCase === "turnEnded";
-						const dispatch = handleServerMessage(serverMessage, output, stream, state, blobStore, h2Request, options?.execHandlers, options?.onToolResult, usageState, requestContextTools, requestContextRules, onConversationCheckpoint, options?.externalToolExecutor).catch((error) => {
-							log("error", "handleServerMessage", { error: String(error) });
-						});
-						inFlightDispatches.add(dispatch);
-						dispatch.finally(() => inFlightDispatches.delete(dispatch));
-						if (isTurnEnded) sawTurnEnded = true;
-					} catch (e) {
-						log("error", "parseServerMessage", { error: String(e) });
-					}
-				}
-			});
-			const sendHeartbeat = () => {
-				if (!h2Request || h2Request.closed) return;
-				const heartbeatMessage = create(AgentClientMessageSchema, { message: {
-					case: "clientHeartbeat",
-					value: create(ClientHeartbeatSchema, {})
-				} });
-				const heartbeatBytes = toBinary(AgentClientMessageSchema, heartbeatMessage);
-				h2Request.write(frameConnectMessage(heartbeatBytes));
-			};
-			const closeDebugLog = async () => {
-				await (await debugResponseLogPromise)?.close();
-			};
-			h2Request.on("trailers", (trailers) => {
-				const status = trailers["grpc-status"];
-				const msg = trailers["grpc-message"];
-				if (status && status !== "0" && !endStreamError) endStreamError = new ProviderResponseError(`gRPC error ${status}: ${decodeURIComponent(String(msg || ""))}`, { kind: "envelope" });
-			});
-			h2Request.on("end", () => {
-				closeDebugLog().then(() => settleH2()).catch((error) => settleH2(error));
-			});
-			h2Request.on("error", (error) => {
-				const mapped = mapH2TransportError(error, baseUrl);
-				closeDebugLog().finally(() => settleH2(mapped));
-			});
-			if (options?.signal) options.signal.addEventListener("abort", () => {
-				h2Request?.close();
-				closeDebugLog().finally(() => {
-					settleH2(new AbortError());
-				});
-			});
-			h2Request.write(frameConnectMessage(requestBytes));
-			heartbeatTimer = setInterval(sendHeartbeat, 5e3);
-			await h2Completion.promise;
-			if (conversationId && baseConversationId && conversationId !== baseConversationId) {
-				successfulRotatedConversationIds.add(conversationId);
-				freshRotatedConversationIds.delete(conversationId);
-			}
-			await drainInFlightDispatches();
-			endCurrentTextBlock(output, stream, state);
-			endCurrentThinkingBlock(output, stream, state);
-			flushOpenToolCalls(output, stream, state);
-			calculateCost(model, output.usage, output.timestamp);
-			output.duration = performance.now() - startTime;
-			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
-			stream.push({
-				type: "done",
-				reason: output.stopReason,
-				message: output
-			});
-			stream.end();
-		} catch (error) {
-			if ((wireMode === "normalized" && !sawProgressOrSideEffect && !options?.signal?.aborted && error instanceof Error && CURSOR_MODEL_NOT_FOUND_PATTERN.test(error.message) ? serializedFallbackWireModelId : void 0) !== void 0) {
-				if (heartbeatTimer) {
-					clearInterval(heartbeatTimer);
-					heartbeatTimer = null;
-				}
-				h2Request?.close();
-				h2Client?.close();
-				const fallbackStream = streamCursorWithWireMode(model, context, options, "discovered", {
-					startTime,
-					timestamp: output.timestamp
-				});
-				stream.forwardLocalWorkFrom(fallbackStream);
-				try {
-					for await (const event of fallbackStream) {
-						if (event.type === "start") continue;
-						stream.push(event);
-					}
-					const fallbackResult = await fallbackStream.result();
-					if (!stream.resultSettled) stream.end(fallbackResult);
-				} finally {
-					stream.forwardLocalWorkFrom(void 0);
-				}
-				return;
-			}
-			await drainInFlightDispatches();
-			if (openBlockState) {
-				endCurrentTextBlock(output, stream, openBlockState);
-				endCurrentThinkingBlock(output, stream, openBlockState);
-				flushOpenToolCalls(output, stream, openBlockState);
-			}
-			const result = await finalize(error, {
-				api: model.api,
-				signal: options?.signal
-			});
-			const currentRotated = baseConversationId === void 0 ? void 0 : rotatedConversationIds.get(baseConversationId);
-			const canRotate = currentRotated === void 0 || successfulRotatedConversationIds.has(currentRotated);
-			if (conversationId !== void 0 && baseConversationId !== void 0 && usageState !== void 0 && !usageState.sawTokenDelta && RESOURCE_EXHAUSTED_PATTERN.test(result.message) && canRotate) {
-				const rotated = crypto.randomUUID();
-				if (currentRotated) successfulRotatedConversationIds.delete(currentRotated);
-				rotatedConversationIds.set(baseConversationId, rotated);
-				freshRotatedConversationIds.add(rotated);
-				debug("cursor conversation rotated", {
-					base: baseConversationId,
-					from: conversationId,
-					to: rotated
-				});
-			}
-			output.stopReason = result.stopReason;
-			output.errorStatus = result.status;
-			output.errorId = result.id;
-			if (error instanceof ConnectEndStreamError) {
-				output.errorClassificationMessage = result.message;
-				output.errorMessage = error.diagnosticMessage;
-			} else output.errorMessage = result.message;
-			output.duration = performance.now() - startTime;
-			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
-			stream.push({
-				type: "error",
-				reason: output.stopReason,
-				error: output
-			});
-			stream.end();
-		} finally {
-			await (await debugResponseLogPromise)?.close();
-			if (heartbeatTimer) {
-				clearInterval(heartbeatTimer);
-				heartbeatTimer = null;
-			}
-			h2Request?.close();
-			h2Client?.close();
-		}
-	})();
-	return stream;
-}
-/** Streams a Cursor Agent turn, retrying a discovered effort id when its normalized wire id is unavailable. */
-const streamCursor = (model, context, options) => streamCursorWithWireMode(model, context, options, "normalized");
-function markCursorExecResolved(block) {
-	block[kCursorExecResolved] = true;
-}
-/** Exported for tests: drives one Cursor server message through the stream (exec waits mark the stream busy). */
-async function handleServerMessage(msg, output, stream, state, blobStore, h2Request, execHandlers, onToolResult, usageState, requestContextTools, requestContextRules = [], onConversationCheckpoint, externalToolExecutor = false) {
-	const msgCase = msg.message.case;
-	log("serverMessage", msgCase, msg.message.value);
-	if (msgCase === "interactionUpdate") processInteractionUpdate(msg.message.value, output, stream, state, usageState);
-	else if (msgCase === "kvServerMessage") handleKvServerMessage(msg.message.value, blobStore, h2Request);
-	else if (msgCase === "execServerMessage") await stream.trackLocalWork(handleExecServerMessage(msg.message.value, h2Request, execHandlers, onToolResult, requestContextTools, requestContextRules, output, stream, state, externalToolExecutor));
-	else if (msgCase === "interactionQuery") handleInteractionQuery(msg.message.value, h2Request);
-	else if (msgCase === "conversationCheckpointUpdate") handleConversationCheckpointUpdate(msg.message.value, output, usageState, onConversationCheckpoint);
-}
-function selectHostedFetchCall(toolCall) {
-	const oneof = toolCall?.tool;
-	if (oneof?.case === "fetchToolCall" || oneof?.case === "webFetchToolCall") return oneof.value;
-}
-function hostedFetchUnknown(toolCall) {
-	if (!toolCall) return false;
-	return protoUnknownFields(toolCall).some((field) => field.no === 37) || protoUnknownFields(toolCall.tool ?? {}).some((field) => field.no === 37);
-}
-function extractHttpUrlFromUnknown(message) {
-	for (const field of protoUnknownFields(message)) {
-		const match = new TextDecoder().decode(field.data).match(/https?:\/\/[^\x00-\x1f]+/);
-		if (match) return match[0];
-	}
-	const nested = message.tool;
-	return nested ? extractHttpUrlFromUnknown(nested) : void 0;
-}
-function describeHostedFetchResult(call) {
-	const result = call?.result?.result;
-	if (result?.case === "success") return {
-		text: result.value?.content || result.value?.url || "Fetched",
-		isError: false
-	};
-	if (result?.case === "error") return {
-		text: result.value?.error || "Fetch failed",
-		isError: true
-	};
-	return {
-		text: "Fetch completed",
-		isError: false
-	};
-}
-function protoUnknownFields(message) {
-	const raw = message.$unknown;
-	return Array.isArray(raw) ? raw : [];
-}
-function handleKvServerMessage(kvMsg, blobStore, h2Request) {
-	const kvCase = kvMsg.message.case;
-	if (kvCase === "getBlobArgs") {
-		const blobId = kvMsg.message.value.blobId;
-		const blobIdKey = Buffer.from(blobId).toString("hex");
-		const blobData = blobStore.get(blobIdKey);
-		const response = create(KvClientMessageSchema, {
-			id: kvMsg.id,
-			message: {
-				case: "getBlobResult",
-				value: create(GetBlobResultSchema, blobData ? { blobData } : {})
-			}
-		});
-		const kvClientMessage = create(AgentClientMessageSchema, { message: {
-			case: "kvClientMessage",
-			value: response
-		} });
-		const responseBytes = toBinary(AgentClientMessageSchema, kvClientMessage);
-		h2Request.write(frameConnectMessage(responseBytes));
-		log("kvClient", "getBlobResult", { blobId: blobIdKey.slice(0, 40) });
-	} else if (kvCase === "setBlobArgs") {
-		const { blobId, blobData } = kvMsg.message.value;
-		const blobIdKey = Buffer.from(blobId).toString("hex");
-		blobStore.set(blobIdKey, blobData);
-		const response = create(KvClientMessageSchema, {
-			id: kvMsg.id,
-			message: {
-				case: "setBlobResult",
-				value: create(SetBlobResultSchema, {})
-			}
-		});
-		const kvClientMessage = create(AgentClientMessageSchema, { message: {
-			case: "kvClientMessage",
-			value: response
-		} });
-		const responseBytes = toBinary(AgentClientMessageSchema, kvClientMessage);
-		h2Request.write(frameConnectMessage(responseBytes));
-		log("kvClient", "setBlobResult", { blobId: blobIdKey.slice(0, 40) });
-	}
-}
-function sendShellStreamEvent(h2Request, execMsg, event) {
-	sendExecClientMessage(h2Request, execMsg, "shellStream", create(ShellStreamSchema, { event }));
-}
-function sanitizeShellExecResult(execResult) {
-	const result = execResult.result;
-	if (!result) return execResult;
-	switch (result.case) {
-		case "success":
-		case "failure": {
-			const value = result.value;
-			return {
-				...execResult,
-				result: {
-					case: result.case,
-					value: {
-						...value,
-						stdout: value.stdout ? sanitizeText(value.stdout) : value.stdout,
-						stderr: value.stderr ? sanitizeText(value.stderr) : value.stderr
-					}
-				}
-			};
-		}
-		default: return execResult;
-	}
-}
-async function handleShellStreamArgs(args, execMsg, h2Request, execHandlers, onToolResult) {
-	const normalizedWorkingDirectory = args.workingDirectory || process.cwd();
-	const normalizedArgs = {
-		...args,
-		workingDirectory: normalizedWorkingDirectory
-	};
-	const startTs = performance.now();
-	log("shellStream", "start", {
-		command: args.command,
-		workingDirectory: normalizedWorkingDirectory,
-		execId: execMsg.execId,
-		hasExecHandlers: !!execHandlers,
-		hasShell: !!execHandlers?.shell,
-		hasShellStream: !!execHandlers?.shellStream
-	});
-	sendShellStreamEvent(h2Request, execMsg, {
-		case: "start",
-		value: create(ShellStreamStartSchema, {})
-	});
-	let stdoutBuffer = "";
-	let stderrBuffer = "";
-	const incompleteEscapeRegex = /\x1b(|\[|\[\d*|\[\?|\[\?\d*|\]\d*;?)$/;
-	const flushStdout = () => {
-		if (stdoutBuffer) {
-			let safeEnd = stdoutBuffer.length;
-			const match = stdoutBuffer.match(incompleteEscapeRegex);
-			if (match && match[0].length > 0) safeEnd = stdoutBuffer.length - match[0].length;
-			const toSend = stdoutBuffer.slice(0, safeEnd);
-			const remaining = stdoutBuffer.slice(safeEnd);
-			if (toSend) sendShellStreamEvent(h2Request, execMsg, {
-				case: "stdout",
-				value: create(ShellStreamStdoutSchema, { data: sanitizeText(toSend) })
-			});
-			stdoutBuffer = remaining;
-		}
-	};
-	const flushStderr = () => {
-		if (stderrBuffer) {
-			let safeEnd = stderrBuffer.length;
-			const match = stderrBuffer.match(incompleteEscapeRegex);
-			if (match && match[0].length > 0) safeEnd = stderrBuffer.length - match[0].length;
-			const toSend = stderrBuffer.slice(0, safeEnd);
-			const remaining = stderrBuffer.slice(safeEnd);
-			if (toSend) sendShellStreamEvent(h2Request, execMsg, {
-				case: "stderr",
-				value: create(ShellStreamStderrSchema, { data: sanitizeText(toSend) })
-			});
-			stderrBuffer = remaining;
-		}
-	};
-	let stdoutFlushTimer = null;
-	let stderrFlushTimer = null;
-	const scheduleStdoutFlush = () => {
-		if (!stdoutFlushTimer) stdoutFlushTimer = setTimeout(() => {
-			stdoutFlushTimer = null;
-			flushStdout();
-		}, 100);
-	};
-	const scheduleStderrFlush = () => {
-		if (!stderrFlushTimer) stderrFlushTimer = setTimeout(() => {
-			stderrFlushTimer = null;
-			flushStderr();
-		}, 100);
-	};
-	const streamCallbacks = {
-		onStdout(data) {
-			stdoutBuffer += data;
-			if (stdoutBuffer.includes("\n") || stdoutBuffer.length > 4096) {
-				if (stdoutFlushTimer) {
-					clearTimeout(stdoutFlushTimer);
-					stdoutFlushTimer = null;
-				}
-				flushStdout();
-			} else scheduleStdoutFlush();
-		},
-		onStderr(data) {
-			stderrBuffer += data;
-			if (stderrBuffer.includes("\n") || stderrBuffer.length > 4096) {
-				if (stderrFlushTimer) {
-					clearTimeout(stderrFlushTimer);
-					stderrFlushTimer = null;
-				}
-				flushStderr();
-			} else scheduleStderrFlush();
-		}
-	};
-	const streamHandler = execHandlers?.shellStream?.bind(execHandlers);
-	const batchHandler = execHandlers?.shell?.bind(execHandlers);
-	const { execResult } = await resolveExecHandler(args, streamHandler ? (shellArgs) => streamHandler(shellArgs, streamCallbacks) : batchHandler, onToolResult, (toolResult) => buildShellResultFromToolResult(normalizedArgs, toolResult), (reason) => buildShellRejectedResult(normalizedArgs.command, normalizedArgs.workingDirectory, reason), (error) => buildShellFailureResult(normalizedArgs.command, normalizedArgs.workingDirectory, error), {
-		toolCallId: args.toolCallId,
-		toolName: "bash"
-	});
-	const sendBufferedOutput = !streamHandler;
-	const sanitizedExecResult = sanitizeShellExecResult(execResult);
-	if (stdoutFlushTimer) clearTimeout(stdoutFlushTimer);
-	if (stderrFlushTimer) clearTimeout(stderrFlushTimer);
-	flushStdout();
-	flushStderr();
-	sendShellStreamExitFromResult(h2Request, execMsg, sanitizedExecResult, sendBufferedOutput);
-	sendExecClientMessage(h2Request, execMsg, "shellResult", sanitizedExecResult);
-	sendExecClientStreamClose(h2Request, execMsg);
-	log("shellStream", "done", { elapsed: performance.now() - startTs });
-}
-function sendShellStreamExitFromResult(h2Request, execMsg, execResult, sendBufferedOutput) {
-	const result = execResult.result;
-	switch (result.case) {
-		case "success": {
-			const value = result.value;
-			if (sendBufferedOutput) {
-				if (value.stdout) sendShellStreamEvent(h2Request, execMsg, {
-					case: "stdout",
-					value: create(ShellStreamStdoutSchema, { data: sanitizeText(value.stdout) })
-				});
-				if (value.stderr) sendShellStreamEvent(h2Request, execMsg, {
-					case: "stderr",
-					value: create(ShellStreamStderrSchema, { data: sanitizeText(value.stderr) })
-				});
-			}
-			sendShellStreamEvent(h2Request, execMsg, {
-				case: "exit",
-				value: create(ShellStreamExitSchema, {
-					code: value.exitCode,
-					cwd: value.workingDirectory,
-					aborted: false
-				})
-			});
-			return;
-		}
-		case "failure": {
-			const value = result.value;
-			if (sendBufferedOutput) {
-				if (value.stdout) sendShellStreamEvent(h2Request, execMsg, {
-					case: "stdout",
-					value: create(ShellStreamStdoutSchema, { data: sanitizeText(value.stdout) })
-				});
-				if (value.stderr) sendShellStreamEvent(h2Request, execMsg, {
-					case: "stderr",
-					value: create(ShellStreamStderrSchema, { data: sanitizeText(value.stderr) })
-				});
-			}
-			sendShellStreamEvent(h2Request, execMsg, {
-				case: "exit",
-				value: create(ShellStreamExitSchema, {
-					code: value.exitCode,
-					cwd: value.workingDirectory,
-					aborted: value.aborted,
-					abortReason: value.abortReason
-				})
-			});
-			return;
-		}
-		case "rejected":
-			sendShellStreamEvent(h2Request, execMsg, {
-				case: "rejected",
-				value: result.value
-			});
-			sendShellStreamEvent(h2Request, execMsg, {
-				case: "exit",
-				value: create(ShellStreamExitSchema, {
-					code: 1,
-					cwd: result.value.workingDirectory,
-					aborted: false
-				})
-			});
-			return;
-		case "timeout": {
-			const value = result.value;
-			sendShellStreamEvent(h2Request, execMsg, {
-				case: "stderr",
-				value: create(ShellStreamStderrSchema, { data: `Command timed out after ${value.timeoutMs}ms` })
-			});
-			sendShellStreamEvent(h2Request, execMsg, {
-				case: "exit",
-				value: create(ShellStreamExitSchema, {
-					code: 1,
-					cwd: value.workingDirectory,
-					aborted: true
-				})
-			});
-			return;
-		}
-		case "permissionDenied":
-			sendShellStreamEvent(h2Request, execMsg, {
-				case: "permissionDenied",
-				value: result.value
-			});
-			sendShellStreamEvent(h2Request, execMsg, {
-				case: "exit",
-				value: create(ShellStreamExitSchema, {
-					code: 1,
-					cwd: result.value.workingDirectory,
-					aborted: false
-				})
-			});
-			return;
-		default: return;
-	}
-}
-async function handleExecServerMessage(execMsg, h2Request, execHandlers, onToolResult, requestContextTools, requestContextRules, output, stream, state, externalToolExecutor) {
-	const execCase = execMsg.message.case;
-	log("exec", "dispatch", {
-		execCase,
-		execId: execMsg.execId,
-		hasHandlers: !!execHandlers
-	});
-	if (execCase === "requestContextArgs") {
-		const requestContext = create(RequestContextSchema, {
-			rules: requestContextRules,
-			repositoryInfo: [],
-			tools: requestContextTools,
-			gitRepos: [],
-			projectLayouts: [],
-			mcpInstructions: [],
-			fileContents: {},
-			customSubagents: []
-		});
-		sendExecClientMessage(h2Request, execMsg, "requestContextResult", create(RequestContextResultSchema, { result: {
-			case: "success",
-			value: create(RequestContextSuccessSchema, { requestContext })
-		} }));
-		log("execClient", "requestContextResult");
-		return;
-	}
-	if (!execCase) {
-		log("warn", "unknownExecVariant", {
-			id: execMsg.id,
-			execId: execMsg.execId
-		});
-		sendExecClientThrow(h2Request, execMsg, "Unknown exec message variant", "unknown_exec_variant");
-		return;
-	}
-	switch (execCase) {
-		case "readArgs": {
-			const args = execMsg.message.value;
-			if (!args.toolCallId) args.toolCallId = crypto.randomUUID();
-			const editOwned = isEditOwnedToolCallId(state, output, args.toolCallId);
-			const composed = editOwned ? cursorEditOwnedReadPath(args.path, args.offset, args.limit) : args.path;
-			const handlerArgs = editOwned ? composed === null ? args : {
-				...args,
-				path: composed,
-				offset: void 0,
-				limit: void 0
-			} : args;
-			if (!editOwned) synthesizeCursorExecToolCall(output, stream, state, args.toolCallId, "read", { path: piReadDisplayPath(args.path, args.offset, args.limit) });
-			const { execResult } = await resolveExecHandler(handlerArgs, execHandlers?.read?.bind(execHandlers), editOwned ? void 0 : onToolResult, (toolResult) => buildReadResultFromToolResult(args.path, toolResult, args.offset !== void 0 || args.limit !== void 0 || piReadPathHasRange(args.path)), (reason) => buildReadRejectedResult(args.path, reason), (error) => buildReadErrorResult(args.path, error), editOwned ? null : {
-				toolCallId: args.toolCallId,
-				toolName: "read"
-			});
-			sendExecClientMessage(h2Request, execMsg, "readResult", execResult);
-			return;
-		}
-		case "lsArgs": {
-			const args = execMsg.message.value;
-			if (!args.toolCallId) args.toolCallId = crypto.randomUUID();
-			synthesizeCursorExecToolCall(output, stream, state, args.toolCallId, "read", { path: args.path });
-			const { execResult } = await resolveExecHandler(args, execHandlers?.ls?.bind(execHandlers), onToolResult, (toolResult) => buildLsResultFromToolResult(args.path, toolResult), (reason) => buildLsRejectedResult(args.path, reason), (error) => buildLsErrorResult(args.path, error), {
-				toolCallId: args.toolCallId,
-				toolName: "read"
-			});
-			sendExecClientMessage(h2Request, execMsg, "lsResult", execResult);
-			return;
-		}
-		case "grepArgs": {
-			const args = execMsg.message.value;
-			if (!args.toolCallId) args.toolCallId = crypto.randomUUID();
-			const emptyPatternError = emptyGrepPatternRejection(args.pattern, args.glob);
-			if (emptyPatternError !== null) {
-				sendExecClientMessage(h2Request, execMsg, "grepResult", buildGrepErrorResult(emptyPatternError));
-				return;
-			}
-			const searchPath = args.glob ? `${args.path || "."}/${args.glob}` : args.path || ".";
-			synthesizeCursorExecToolCall(output, stream, state, args.toolCallId, "grep", {
-				pattern: args.pattern,
-				path: searchPath,
-				case: args.caseInsensitive === true ? false : void 0,
-				skip: piGrepSkip(args.offset)
-			});
-			const { execResult } = await resolveExecHandler(args, execHandlers?.grep?.bind(execHandlers), onToolResult, (toolResult) => buildGrepResultFromToolResult(args, toolResult), (reason) => buildGrepErrorResult(reason), (error) => buildGrepErrorResult(error), {
-				toolCallId: args.toolCallId,
-				toolName: "grep"
-			});
-			sendExecClientMessage(h2Request, execMsg, "grepResult", execResult);
-			return;
-		}
-		case "writeArgs": {
-			const args = execMsg.message.value;
-			if (!args.toolCallId) args.toolCallId = crypto.randomUUID();
-			const editOwned = isEditOwnedToolCallId(state, output, args.toolCallId);
-			const content = args.fileText ?? new TextDecoder().decode(args.fileBytes ?? /* @__PURE__ */ new Uint8Array());
-			if (!editOwned) synthesizeCursorExecToolCall(output, stream, state, args.toolCallId, "write", {
-				path: args.path,
-				content
-			});
-			const write = execHandlers?.write?.bind(execHandlers);
-			const { execResult } = await resolveExecHandler(args, write ? async (writeArgs) => {
-				const result = await write(writeArgs);
-				return editOwned ? remapExecHandlerToolName(result, "edit") : result;
-			} : void 0, onToolResult, (toolResult) => buildWriteResultFromToolResult({
-				path: args.path,
-				fileText: args.fileText,
-				fileBytes: args.fileBytes,
-				returnFileContentAfterWrite: args.returnFileContentAfterWrite
-			}, toolResult), (reason) => buildWriteRejectedResult(args.path, reason), (error) => buildWriteErrorResult(args.path, error), {
-				toolCallId: args.toolCallId,
-				toolName: editOwned ? "edit" : "write"
-			});
-			if (editOwned) markEditToolCallPaired(state, args.toolCallId);
-			sendExecClientMessage(h2Request, execMsg, "writeResult", execResult);
-			return;
-		}
-		case "deleteArgs": {
-			const args = execMsg.message.value;
-			if (!args.toolCallId) args.toolCallId = crypto.randomUUID();
-			synthesizeCursorExecToolCall(output, stream, state, args.toolCallId, "delete", { path: args.path });
-			const { execResult } = await resolveExecHandler(args, execHandlers?.delete?.bind(execHandlers), onToolResult, (toolResult) => buildDeleteResultFromToolResult(args.path, toolResult), (reason) => buildDeleteRejectedResult(args.path, reason), (error) => buildDeleteErrorResult(args.path, error), {
-				toolCallId: args.toolCallId,
-				toolName: "delete"
-			});
-			sendExecClientMessage(h2Request, execMsg, "deleteResult", execResult);
-			return;
-		}
-		case "shellArgs": {
-			const args = execMsg.message.value;
-			if (!args.toolCallId) args.toolCallId = crypto.randomUUID();
-			const normalizedArgs = {
-				...args,
-				workingDirectory: args.workingDirectory || process.cwd()
-			};
-			const shellTimeout = args.timeout && args.timeout > 0 ? args.timeout : void 0;
-			synthesizeCursorExecToolCall(output, stream, state, args.toolCallId, "bash", {
-				command: args.command,
-				cwd: args.workingDirectory || void 0,
-				timeout: shellTimeout
-			});
-			const { execResult } = await resolveExecHandler(args, execHandlers?.shell?.bind(execHandlers), onToolResult, (toolResult) => buildShellResultFromToolResult(normalizedArgs, toolResult), (reason) => buildShellRejectedResult(normalizedArgs.command, normalizedArgs.workingDirectory, reason), (error) => buildShellFailureResult(normalizedArgs.command, normalizedArgs.workingDirectory, error), {
-				toolCallId: args.toolCallId,
-				toolName: "bash"
-			});
-			sendExecClientMessage(h2Request, execMsg, "shellResult", sanitizeShellExecResult(execResult));
-			return;
-		}
-		case "shellStreamArgs": {
-			const args = execMsg.message.value;
-			if (!args.toolCallId) args.toolCallId = crypto.randomUUID();
-			const shellStreamTimeout = args.timeout && args.timeout > 0 ? args.timeout : void 0;
-			synthesizeCursorExecToolCall(output, stream, state, args.toolCallId, "bash", {
-				command: args.command,
-				cwd: args.workingDirectory || void 0,
-				timeout: shellStreamTimeout
-			});
-			await handleShellStreamArgs(args, execMsg, h2Request, execHandlers, onToolResult);
-			return;
-		}
-		case "backgroundShellSpawnArgs": {
-			const args = execMsg.message.value;
-			sendExecClientMessage(h2Request, execMsg, "backgroundShellSpawnResult", create(BackgroundShellSpawnResultSchema, { result: {
-				case: "rejected",
-				value: create(ShellRejectedSchema, {
-					command: args.command,
-					workingDirectory: args.workingDirectory,
-					reason: "Not implemented",
-					isReadonly: false
-				})
-			} }));
-			return;
-		}
-		case "writeShellStdinArgs":
-			sendExecClientMessage(h2Request, execMsg, "writeShellStdinResult", create(WriteShellStdinResultSchema, { result: {
-				case: "error",
-				value: create(WriteShellStdinErrorSchema, { error: "Not implemented" })
-			} }));
-			return;
-		case "fetchArgs": {
-			const args = execMsg.message.value;
-			sendExecClientMessage(h2Request, execMsg, "fetchResult", create(FetchResultSchema, { result: {
-				case: "error",
-				value: create(FetchErrorSchema, {
-					url: args.url,
-					error: "Not implemented"
-				})
-			} }));
-			return;
-		}
-		case "diagnosticsArgs": {
-			const args = execMsg.message.value;
-			if (!args.toolCallId) args.toolCallId = crypto.randomUUID();
-			synthesizeCursorExecToolCall(output, stream, state, args.toolCallId, "lsp", {
-				action: "diagnostics",
-				file: args.path
-			});
-			const { execResult } = await resolveExecHandler(args, execHandlers?.diagnostics?.bind(execHandlers), onToolResult, (toolResult) => buildDiagnosticsResultFromToolResult(args.path, toolResult), (reason) => buildDiagnosticsRejectedResult(args.path, reason), (error) => buildDiagnosticsErrorResult(args.path, error), {
-				toolCallId: args.toolCallId,
-				toolName: "lsp"
-			});
-			sendExecClientMessage(h2Request, execMsg, "diagnosticsResult", execResult);
-			return;
-		}
-		case "mcpArgs": {
-			const args = execMsg.message.value;
-			const mcpCall = decodeMcpCall(args);
-			if (mcpCall.approvalOnly) {
-				const approved = await execHandlers?.mcpApprovalPreflight?.(mcpCall) === true;
-				sendExecClientMessage(h2Request, execMsg, "mcpResult", create(McpResultSchema, { result: approved ? {
-					case: "approved",
-					value: create(McpApprovedSchema, {})
-				} : {
-					case: "rejected",
-					value: create(McpRejectedSchema, { reason: `Tool "${mcpCall.toolName || mcpCall.name}" is not approved to run without asking.` })
-				} }));
-				return;
-			}
-			if (execHandlers?.mcp) {
-				const existingBlock = output.content.find((block) => block.type === "toolCall" && block.id === mcpCall.toolCallId);
-				if (existingBlock) markCursorExecResolved(existingBlock);
-				else {
-					synthesizeCursorExecToolCall(output, stream, state, mcpCall.toolCallId, mcpCall.toolName || mcpCall.name, mcpCall.args);
-					state.resolvedMcpToolCallIds.add(mcpCall.toolCallId);
-				}
-			}
-			const { execResult } = await resolveExecHandler(mcpCall, execHandlers?.mcp?.bind(execHandlers), onToolResult, (toolResult) => buildMcpResultFromToolResult(mcpCall, toolResult), (_reason) => externalToolExecutor && !execHandlers?.mcp ? buildMcpExternalHandoffResult() : buildMcpToolNotFoundResult(mcpCall), (error) => buildMcpErrorResult(error), execHandlers?.mcp ? {
-				toolCallId: mcpCall.toolCallId,
-				toolName: mcpCall.toolName
-			} : null);
-			sendExecClientMessage(h2Request, execMsg, "mcpResult", execResult);
-			return;
-		}
-		case "listMcpResourcesExecArgs": {
-			const args = execMsg.message.value;
-			let execResult;
-			const toolCallId = execHandlers?.listMcpResources ? crypto.randomUUID() : void 0;
-			if (toolCallId) synthesizeCursorExecToolCall(output, stream, state, toolCallId, "list_mcp_resources", { server: args.server });
-			try {
-				const resources = await execHandlers?.listMcpResources?.({ server: args.server }) ?? [];
-				execResult = create(ListMcpResourcesExecResultSchema, { result: {
-					case: "success",
-					value: create(ListMcpResourcesSuccessSchema, { resources: resources.map((resource) => create(ListMcpResourcesExecResult_McpResourceSchema, {
-						uri: resource.uri,
-						name: resource.name,
-						description: resource.description,
-						mimeType: resource.mimeType,
-						server: resource.server
-					})) })
-				} });
-			} catch (error) {
-				execResult = create(ListMcpResourcesExecResultSchema, { result: {
-					case: "error",
-					value: create(ListMcpResourcesErrorSchema, { error: error instanceof Error ? error.message : String(error) })
-				} });
-			}
-			if (toolCallId) {
-				const settled = execResult.result;
-				await pairSynthesizedExecResult(state, onToolResult, toolCallId, "list_mcp_resources", settled.case === "success" ? formatListedMcpResources(settled.value.resources) : settled.case === "error" ? settled.value.error || "Failed to list MCP resources" : settled.value?.reason ?? "Failed to list MCP resources", settled.case !== "success");
-			}
-			sendExecClientMessage(h2Request, execMsg, "listMcpResourcesExecResult", execResult);
-			return;
-		}
-		case "readMcpResourceExecArgs": {
-			const args = execMsg.message.value;
-			let execResult;
-			const toolCallId = execHandlers?.readMcpResource ? crypto.randomUUID() : void 0;
-			if (toolCallId) synthesizeCursorExecToolCall(output, stream, state, toolCallId, "read_mcp_resource", {
-				server: args.server,
-				uri: args.uri,
-				download_path: args.downloadPath
-			});
-			try {
-				const content = await execHandlers?.readMcpResource?.({
-					server: args.server,
-					uri: args.uri,
-					downloadPath: args.downloadPath
-				});
-				execResult = content ? create(ReadMcpResourceExecResultSchema, { result: {
-					case: "success",
-					value: create(ReadMcpResourceSuccessSchema, {
-						uri: content.uri,
-						name: content.name,
-						description: content.description,
-						mimeType: content.mimeType,
-						downloadPath: content.downloadPath,
-						content: content.downloadPath !== void 0 ? { case: void 0 } : content.text !== void 0 ? {
-							case: "text",
-							value: content.text
-						} : content.blob !== void 0 ? {
-							case: "blob",
-							value: content.blob
-						} : { case: void 0 }
-					})
-				} }) : create(ReadMcpResourceExecResultSchema, { result: {
-					case: "notFound",
-					value: create(ReadMcpResourceNotFoundSchema, { uri: args.uri })
-				} });
-			} catch (error) {
-				execResult = create(ReadMcpResourceExecResultSchema, { result: {
-					case: "error",
-					value: create(ReadMcpResourceErrorSchema, {
-						uri: args.uri,
-						error: error instanceof Error ? error.message : String(error)
-					})
-				} });
-			}
-			if (toolCallId) {
-				const settled = execResult.result;
-				let text;
-				switch (settled.case) {
-					case "success":
-						text = settled.value.downloadPath ? `Downloaded ${args.uri} to ${settled.value.downloadPath}` : `Read ${args.uri}`;
-						break;
-					case "notFound":
-						text = `No such resource: ${args.uri}`;
-						break;
-					case "rejected":
-						text = `Refused: ${settled.value.reason}`;
-						break;
-					default: text = settled.value?.error ?? `Failed to read ${args.uri}`;
-				}
-				await pairSynthesizedExecResult(state, onToolResult, toolCallId, "read_mcp_resource", text, settled.case !== "success");
-			}
-			sendExecClientMessage(h2Request, execMsg, "readMcpResourceExecResult", execResult);
-			return;
-		}
-		case "recordScreenArgs":
-			sendExecClientMessage(h2Request, execMsg, "recordScreenResult", create(RecordScreenResultSchema, { result: {
-				case: "failure",
-				value: create(RecordScreenFailureSchema, { error: NOT_IMPLEMENTED })
-			} }));
-			return;
-		case "computerUseArgs":
-			sendExecClientMessage(h2Request, execMsg, "computerUseResult", create(ComputerUseResultSchema, { result: {
-				case: "error",
-				value: create(ComputerUseErrorSchema, { error: NOT_IMPLEMENTED })
-			} }));
-			return;
-		case "piReadArgs": {
-			const args = execMsg.message.value;
-			const toolCallId = crypto.randomUUID();
-			synthesizeCursorExecToolCall(output, stream, state, toolCallId, "read", { path: piReadDisplayPath(args.path, args.offset, args.limit) });
-			const { execResult } = await resolveExecHandler({
-				args,
-				toolCallId
-			}, execHandlers?.piRead?.bind(execHandlers), onToolResult, buildPiReadResult, buildPiReadError, buildPiReadError, {
-				toolCallId,
-				toolName: "read"
-			});
-			sendExecClientMessage(h2Request, execMsg, "piReadResult", execResult);
-			return;
-		}
-		case "piBashArgs": {
-			const args = execMsg.message.value;
-			const toolCallId = crypto.randomUUID();
-			synthesizeCursorExecToolCall(output, stream, state, toolCallId, "bash", {
-				command: args.command,
-				timeout: piTimeout(args.timeout)
-			});
-			const { execResult } = await resolveExecHandler({
-				args,
-				toolCallId
-			}, execHandlers?.piBash?.bind(execHandlers), onToolResult, buildPiBashResult, buildPiBashError, buildPiBashError, {
-				toolCallId,
-				toolName: "bash"
-			});
-			sendExecClientMessage(h2Request, execMsg, "piBashResult", execResult);
-			return;
-		}
-		case "piEditArgs": {
-			const args = execMsg.message.value;
-			const toolCallId = crypto.randomUUID();
-			const firstEdit = args.edits[0];
-			synthesizeCursorExecToolCall(output, stream, state, toolCallId, "edit", {
-				path: args.path,
-				old_string: firstEdit?.oldText ?? "",
-				new_string: firstEdit?.newText ?? ""
-			});
-			const { execResult } = await resolveExecHandler({
-				args,
-				toolCallId
-			}, execHandlers?.piEdit?.bind(execHandlers), onToolResult, buildPiEditResult, buildPiEditRejected, buildPiEditError, {
-				toolCallId,
-				toolName: "edit"
-			});
-			sendExecClientMessage(h2Request, execMsg, "piEditResult", execResult);
-			return;
-		}
-		case "piWriteArgs": {
-			const args = execMsg.message.value;
-			const toolCallId = crypto.randomUUID();
-			synthesizeCursorExecToolCall(output, stream, state, toolCallId, "write", {
-				path: args.path,
-				content: args.content
-			});
-			const { execResult } = await resolveExecHandler({
-				args,
-				toolCallId
-			}, execHandlers?.piWrite?.bind(execHandlers), onToolResult, buildPiWriteResult, buildPiWriteRejected, buildPiWriteError, {
-				toolCallId,
-				toolName: "write"
-			});
-			sendExecClientMessage(h2Request, execMsg, "piWriteResult", execResult);
-			return;
-		}
-		case "piGrepArgs": {
-			const args = execMsg.message.value;
-			const toolCallId = crypto.randomUUID();
-			synthesizeCursorExecToolCall(output, stream, state, toolCallId, "grep", {
-				pattern: args.literal === true ? piEscapeRegexLiteral(args.pattern) : args.pattern,
-				path: args.glob ? piJoinPath(args.path, args.glob) : args.path || ".",
-				case: args.ignoreCase === true ? false : void 0,
-				context: args.context,
-				limit: piLimit(args.limit)
-			});
-			const { execResult } = await resolveExecHandler({
-				args,
-				toolCallId
-			}, execHandlers?.piGrep?.bind(execHandlers), onToolResult, buildPiGrepResult, buildPiGrepError, buildPiGrepError, {
-				toolCallId,
-				toolName: "grep"
-			});
-			sendExecClientMessage(h2Request, execMsg, "piGrepResult", execResult);
-			return;
-		}
-		case "piFindArgs": {
-			const args = execMsg.message.value;
-			const toolCallId = crypto.randomUUID();
-			synthesizeCursorExecToolCall(output, stream, state, toolCallId, "glob", {
-				path: piJoinPath(args.path, args.pattern),
-				limit: piLimit(args.limit)
-			});
-			const { execResult } = await resolveExecHandler({
-				args,
-				toolCallId
-			}, execHandlers?.piFind?.bind(execHandlers), onToolResult, buildPiFindResult, buildPiFindError, buildPiFindError, {
-				toolCallId,
-				toolName: "glob"
-			});
-			sendExecClientMessage(h2Request, execMsg, "piFindResult", execResult);
-			return;
-		}
-		case "piLsArgs": {
-			const args = execMsg.message.value;
-			const toolCallId = crypto.randomUUID();
-			synthesizeCursorExecToolCall(output, stream, state, toolCallId, "read", { path: piLsPath(args.path) });
-			const { execResult } = await resolveExecHandler({
-				args,
-				toolCallId
-			}, execHandlers?.piLs?.bind(execHandlers), onToolResult, buildPiLsResult, buildPiLsError, buildPiLsError, {
-				toolCallId,
-				toolName: "read"
-			});
-			sendExecClientMessage(h2Request, execMsg, "piLsResult", execResult);
-			return;
-		}
-		case "miniSweAgentBashArgs": {
-			const args = execMsg.message.value;
-			if (!args.toolCallId) args.toolCallId = crypto.randomUUID();
-			const normalizedArgs = {
-				...args,
-				workingDirectory: args.workingDirectory || process.cwd()
-			};
-			synthesizeCursorExecToolCall(output, stream, state, args.toolCallId, "bash", {
-				command: args.command,
-				cwd: args.workingDirectory || void 0,
-				timeout: args.timeout && args.timeout > 0 ? args.timeout : void 0
-			});
-			const { execResult } = await resolveExecHandler(normalizedArgs, execHandlers?.shell?.bind(execHandlers), onToolResult, (toolResult) => buildShellResultFromToolResult(normalizedArgs, toolResult), (reason) => buildShellRejectedResult(normalizedArgs.command, normalizedArgs.workingDirectory, reason), (error) => buildShellFailureResult(normalizedArgs.command, normalizedArgs.workingDirectory, error), {
-				toolCallId: args.toolCallId,
-				toolName: "bash"
-			});
-			sendExecClientMessage(h2Request, execMsg, "miniSweAgentBashResult", sanitizeShellExecResult(execResult));
-			return;
-		}
-		case "redactedReadArgs": {
-			const args = execMsg.message.value;
-			sendExecClientMessage(h2Request, execMsg, "redactedReadResult", buildReadErrorResult(args.path, "Secret redaction is not implemented by this client"));
-			return;
-		}
-		case "mcpStateExecArgs": {
-			const args = execMsg.message.value;
-			sendExecClientMessage(h2Request, execMsg, "mcpStateExecResult", buildMcpStateResult(requestContextTools, args.serverIdentifiers));
-			return;
-		}
-		case "executeHookArgs": {
-			const args = execMsg.message.value;
-			const execResult = buildNeutralHookResult(args.request);
-			if (!execResult) {
-				sendExecClientThrow(h2Request, execMsg, `Unsupported hook request: ${args.request?.request.case ?? "unset"}`, "unknown_hook_request");
-				return;
-			}
-			sendExecClientMessage(h2Request, execMsg, "executeHookResult", execResult);
-			return;
-		}
-		case "subagentArgs": {
-			const args = execMsg.message.value;
-			const execResult = create(SubagentResultSchema, { result: {
-				case: "error",
-				value: create(SubagentErrorSchema, { error: `Subagents are ${NOT_IMPLEMENTED_SUFFIX}` })
-			} });
-			log("exec", "subagentRejected", { subagentType: args.subagentType });
-			sendExecClientMessage(h2Request, execMsg, "subagentResult", execResult);
-			return;
-		}
-		case "subagentAwaitArgs": {
-			const args = execMsg.message.value;
-			sendExecClientMessage(h2Request, execMsg, "subagentAwaitResult", create(SubagentAwaitResultSchema, { result: {
-				case: "notFound",
-				value: create(SubagentAwaitNotFoundSchema, { agentId: args.agentId })
-			} }));
-			return;
-		}
-		case "forceBackgroundShellArgs":
-			sendExecClientMessage(h2Request, execMsg, "forceBackgroundShellResult", create(ForceBackgroundShellResultSchema, { status: 2 }));
-			return;
-		case "forceBackgroundSubagentArgs":
-			sendExecClientMessage(h2Request, execMsg, "forceBackgroundSubagentResult", create(ForceBackgroundSubagentResultSchema, { status: 2 }));
-			return;
-		case "smartModeClassifierArgs":
-			sendExecClientMessage(h2Request, execMsg, "smartModeClassifierResult", create(SmartModeClassifierResultSchema, { result: {
-				case: "error",
-				value: create(SmartModeClassifierErrorSchema, { error: `Smart-mode classification is ${NOT_IMPLEMENTED_SUFFIX}` })
-			} }));
-			return;
-		case "canvasDiagnosticsArgs": {
-			const args = execMsg.message.value;
-			sendExecClientMessage(h2Request, execMsg, "canvasDiagnosticsResult", create(CanvasDiagnosticsResultSchema, { result: {
-				case: "error",
-				value: create(CanvasDiagnosticsErrorSchema, {
-					path: args.path,
-					error: `Canvas diagnostics are ${NOT_IMPLEMENTED_SUFFIX}`
-				})
-			} }));
-			return;
-		}
-		case "shellAllowlistPrecheckArgs":
-			sendExecClientMessage(h2Request, execMsg, "shellAllowlistPrecheckResult", create(ShellAllowlistPrecheckResultSchema, { allowlisted: false }));
-			return;
-		case "mcpAllowlistPrecheckArgs":
-			sendExecClientMessage(h2Request, execMsg, "mcpAllowlistPrecheckResult", create(McpAllowlistPrecheckResultSchema, { allowlisted: false }));
-			return;
-		case "webFetchAllowlistPrecheckArgs":
-			sendExecClientMessage(h2Request, execMsg, "webFetchAllowlistPrecheckResult", create(WebFetchAllowlistPrecheckResultSchema, { allowlisted: false }));
-			return;
-		case "conversationSearchArgs": {
-			const args = execMsg.message.value;
-			const toolCallId = args.toolCallId || crypto.randomUUID();
-			const error = `Conversation search is ${NOT_IMPLEMENTED_SUFFIX}`;
-			synthesizeCursorExecToolCall(output, stream, state, toolCallId, "search_conversations", {
-				query: args.query,
-				limit: args.limit
-			});
-			await pairSynthesizedExecResult(state, onToolResult, toolCallId, "search_conversations", error);
-			sendExecClientMessage(h2Request, execMsg, "conversationSearchResult", create(ConversationSearchResultSchema, { result: {
-				case: "error",
-				value: create(ConversationSearchErrorSchema, { error })
-			} }));
-			return;
-		}
-		case "agentStoreConflictArgs":
-			sendExecClientMessage(h2Request, execMsg, "agentStoreConflictResult", create(AgentStoreConflictResultSchema, { result: {
-				case: "error",
-				value: create(AgentStoreConflictErrorSchema, { error: `Agent store conflicts are ${NOT_IMPLEMENTED_SUFFIX}` })
-			} }));
-			return;
-		case "gitDiffRequest":
-			sendExecClientThrow(h2Request, execMsg, `Git diff is ${NOT_IMPLEMENTED_SUFFIX}`, "exec_variant_unsupported");
-			return;
-		default:
-			log("warn", "unhandledExecMessage", { execCase });
-			sendExecClientThrow(h2Request, execMsg, `No handler for exec message of type ${execCase}`, "exec_variant_unsupported");
-	}
-}
-/**
-* Send one typed answer on the exec channel.
-*
-* `ExecClientMessage["message"]` is a discriminated union pairing each case
-* with its own result type, so the generic is keyed on the case: passing a
-* `ReadResult` under `"shellResult"` is a compile error rather than a wire
-* message the server rejects at runtime.
-*/
-function sendExecClientMessage(h2Request, execMsg, messageCase, value) {
-	const execClientMessage = create(ExecClientMessageSchema, {
-		id: execMsg.id,
-		execId: execMsg.execId,
-		message: {
-			case: messageCase,
-			value
-		}
-	});
-	const clientMessage = create(AgentClientMessageSchema, { message: {
-		case: "execClientMessage",
-		value: execClientMessage
-	} });
-	const responseBytes = toBinary(AgentClientMessageSchema, clientMessage);
-	h2Request.write(frameConnectMessage(responseBytes));
-	log("execClientMessage", messageCase, value);
-}
-/**
-* Fail one exec frame in band.
-*
-* `ExecClientThrow` is the protocol's failure channel for a frame that cannot
-* be answered at all — as opposed to a frame answered with its own typed error
-* variant, which means "the tool ran and failed". Cursor's own executor sends
-* exactly this for a frame no handler claims
-* (`agent-exec/dist/index.js`: `No handler found for server message of type …`
-* → `case: 'throw'` then `streamClose`), so the server already knows how to
-* recover from it: it surfaces the error to the model instead of blocking on a
-* reply that never comes.
-*
-* The alternative this replaces — writing an `ExecClientMessage` whose `message`
-* oneof is unset — is not a valid answer: the server sees a reply carrying no
-* result and cannot tell it apart from a malformed frame.
-*/
-function sendExecClientThrow(h2Request, execMsg, error, errorCode) {
-	const controlMessage = create(ExecClientControlMessageSchema, { message: {
-		case: "throw",
-		value: create(ExecClientThrowSchema, {
-			id: execMsg.id,
-			error,
-			errorCode
-		})
-	} });
-	const clientMessage = create(AgentClientMessageSchema, { message: {
-		case: "execClientControlMessage",
-		value: controlMessage
-	} });
-	h2Request.write(frameConnectMessage(toBinary(AgentClientMessageSchema, clientMessage)));
-	log("execClientControl", "throw", {
-		id: execMsg.id,
-		execId: execMsg.execId,
-		error,
-		errorCode
-	});
-	sendExecClientStreamClose(h2Request, execMsg);
-}
-function sendExecClientStreamClose(h2Request, execMsg) {
-	const closeMessage = create(ExecClientControlMessageSchema, { message: {
-		case: "streamClose",
-		value: create(ExecClientStreamCloseSchema, { id: execMsg.id })
-	} });
-	const clientMessage = create(AgentClientMessageSchema, { message: {
-		case: "execClientControlMessage",
-		value: closeMessage
-	} });
-	const responseBytes = toBinary(AgentClientMessageSchema, clientMessage);
-	h2Request.write(frameConnectMessage(responseBytes));
-	log("execClientControl", "streamClose", {
-		id: execMsg.id,
-		execId: execMsg.execId
-	});
-}
-/**
-* Exported for tests: verifies handler is invoked with correct `this` when passed as bound.
-*
-* Every exit pairs a `toolResult`. The synthesized block was already marked
-* `kCursorExecResolved` before this runs (`synthesizeCursorExecToolCall`), so
-* `agent-loop.ts` emits no placeholder for it: a path that returns without a
-* result leaves the call unpaired and `buildSessionContext` strips the whole
-* interaction on replay. The three result-less paths — no handler installed, a
-* handler that produced nothing, and a thrown handler — therefore synthesize
-* one from the same text the server sees in `execResult`.
-*
-* `pairing` is required so a new callsite cannot silently recreate the orphan,
-* and nullable for the one caller whose block is NOT pre-resolved: MCP without
-* an `mcp` handler, which `agent-loop.ts` runs locally and pairs itself.
-*/
-async function resolveExecHandler(args, handler, onToolResult, buildFromToolResult, buildRejected, buildError, pairing) {
-	const pair = async (text, isError) => {
-		if (!pairing) return void 0;
-		return await applyToolResultHandler({
-			role: "toolResult",
-			toolCallId: pairing.toolCallId,
-			toolName: pairing.toolName,
-			content: [{
-				type: "text",
-				text
-			}],
-			isError,
-			timestamp: Date.now()
-		}, onToolResult);
-	};
-	if (!handler) {
-		const reason = "Tool not available";
-		return {
-			execResult: buildRejected(reason),
-			toolResult: await pair(reason, true)
-		};
-	}
-	try {
-		const { execResult, toolResult } = splitExecHandlerResult(await handler(args));
-		const finalToolResult = await applyToolResultHandler(toolResult, onToolResult);
-		if (execResult) return {
-			execResult,
-			toolResult: finalToolResult ?? await pair(...describeExecResult(execResult))
-		};
-		if (finalToolResult) return {
-			execResult: buildFromToolResult(finalToolResult),
-			toolResult: finalToolResult
-		};
-		const reason = "Tool returned no result";
-		return {
-			execResult: buildRejected(reason),
-			toolResult: await pair(reason, true)
-		};
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		return {
-			execResult: buildError(message),
-			toolResult: await pair(message, true)
-		};
-	}
-}
-/**
-* Derive the transcript state of an exec result the SDK handler returned in the
-* R-only form, which carries no `toolResult` to copy it from.
-*
-* Every exec result in `agent.proto` is a `oneof result` whose success variant
-* is named `success` — the rest (`error`, `rejected`, `file_not_found`,
-* `permission_denied`, `invalid_file`, ...) are failures. Recording those as a
-* successful call would show the user a green entry for a call Cursor was told
-* failed. The variant's own `error`/`reason` text is the same string the server
-* receives, so it is reused verbatim as the transcript body.
-*
-* MCP is the one shape where `success` is not enough: `McpSuccess.is_error`
-* carries an application-level tool failure inside the success variant
-* (`agent.proto:2058`), mirroring the MCP spec's own `isError`. The transport
-* succeeded, the tool did not — so the entry must be a failure, and its text
-* comes from the payload's own content rather than a placeholder.
-*/
-function describeExecResult(execResult) {
-	const result = execResult?.result;
-	const variant = result?.case;
-	if (variant === "success") {
-		const success = result?.value;
-		if (!success?.isError) return ["Tool produced no transcript result", false];
-		return [mcpContentToText(success.content) || "MCP tool reported an error", true];
-	}
-	if (!variant) return ["Tool produced no transcript result", false];
-	const value = result?.value;
-	return [value?.error || value?.reason || `Tool call ${variant}`, true];
-}
-/**
-* Flatten `McpSuccess.content` into transcript text. Image items carry no text
-* to surface, so only the text variant contributes; an all-image failure falls
-* back to the caller's generic message.
-*/
-function mcpContentToText(content) {
-	if (!Array.isArray(content)) return "";
-	const parts = [];
-	for (const item of content) {
-		const inner = item?.content;
-		if (inner?.case === "text" && inner.value?.text) parts.push(inner.value.text);
-	}
-	return parts.join("\n");
-}
-function splitExecHandlerResult(result) {
-	if (isToolResultMessage(result)) return { toolResult: result };
-	if (result && typeof result === "object") {
-		const record = result;
-		if ("execResult" in record) {
-			const { execResult, toolResult } = record;
-			return {
-				execResult,
-				toolResult
-			};
-		}
-		if ("toolResult" in record && !isToolResultMessage(record)) {
-			const { result: execResult, toolResult } = record;
-			return {
-				execResult,
-				toolResult
-			};
-		}
-		if ("result" in record && !("$typeName" in record)) {
-			const { result: execResult, toolResult } = record;
-			return {
-				execResult,
-				toolResult
-			};
-		}
-	}
-	return { execResult: result };
-}
-function isToolResultMessage(value) {
-	return !!value && typeof value === "object" && value.role === "toolResult";
-}
-async function applyToolResultHandler(toolResult, onToolResult) {
-	if (!toolResult || !onToolResult) return toolResult;
-	return await onToolResult(toolResult) ?? toolResult;
-}
-function toolResultToText(toolResult) {
-	return toolResult.content.map((item) => item.type === "text" ? item.text : `[${item.mimeType} image]`).join("\n");
-}
-/**
-* The catalog as the paired transcript result records it.
-*
-* Cursor receives every resource's identity on the wire, but rebuilt history is
-* serialized from this local result — so recording only a count leaves the
-* model, one reload later, aware that it once saw N resources and unable to
-* name any of them. The URI is what a follow-up `read_mcp_resource` needs, so
-* it leads; name and mime type follow only when the server supplied them.
-*/
-function formatListedMcpResources(resources) {
-	if (resources.length === 0) return "No MCP resources available";
-	const lines = resources.map((resource) => {
-		const qualifiers = [resource.name, resource.mimeType].filter((part) => !!part).join(", ");
-		const server = resource.server ? `[${resource.server}] ` : "";
-		return qualifiers ? `- ${server}${resource.uri} (${qualifiers})` : `- ${server}${resource.uri}`;
-	});
-	return [`Listed ${resources.length} MCP resource(s):`, ...lines].join("\n");
-}
-function toolResultWasTruncated(toolResult) {
-	if (!toolResult.details || typeof toolResult.details !== "object") return false;
-	return !!toolResult.details.truncation?.truncated;
-}
-function toolResultDetailBoolean(toolResult, key) {
-	if (!toolResult.details || typeof toolResult.details !== "object") return false;
-	const value = toolResult.details[key];
-	return typeof value === "boolean" ? value : false;
-}
-/**
-* The file's own line count, when the tool recorded one.
-*
-* Read results expose the source-wide count directly when known. Older tool
-* results carry it at `details.meta.truncation.totalLines`; the flat
-* `details.truncation.totalLines` counts from a window's start and is
-* deliberately not consulted here.
-*/
-function readTotalLinesFromDetails(toolResult) {
-	const details = toolResult.details;
-	if (!details || typeof details !== "object") return void 0;
-	const direct = "totalLines" in details ? details.totalLines : void 0;
-	if (typeof direct === "number" && Number.isFinite(direct)) return direct;
-	const meta = "meta" in details ? details.meta : void 0;
-	if (!meta || typeof meta !== "object") return void 0;
-	const truncation = "truncation" in meta ? meta.truncation : void 0;
-	if (!truncation || typeof truncation !== "object") return void 0;
-	const totalLines = "totalLines" in truncation ? truncation.totalLines : void 0;
-	return typeof totalLines === "number" && Number.isFinite(totalLines) ? totalLines : void 0;
-}
-function readFileSizeFromDetails(toolResult) {
-	const details = toolResult.details;
-	if (!details || typeof details !== "object" || !("fileSize" in details)) return void 0;
-	const { fileSize } = details;
-	return typeof fileSize === "number" && Number.isSafeInteger(fileSize) && fileSize >= 0 ? fileSize : void 0;
-}
-function buildReadResultFromToolResult(path, toolResult, rangeApplied = false) {
-	const text = toolResultToText(toolResult);
-	if (toolResult.isError) return buildReadErrorResult(path, text || "Read failed");
-	const totalLines = readTotalLinesFromDetails(toolResult) ?? (rangeApplied ? 0 : text ? text.split("\n").length : 0);
-	return create(ReadResultSchema, { result: {
-		case: "success",
-		value: create(ReadSuccessSchema, {
-			path,
-			totalLines,
-			fileSize: BigInt(readFileSizeFromDetails(toolResult) ?? Buffer.byteLength(text, "utf-8")),
-			truncated: toolResultWasTruncated(toolResult),
-			output: {
-				case: "content",
-				value: text
-			},
-			rangeApplied
-		})
-	} });
-}
-function buildReadErrorResult(path, error) {
-	return create(ReadResultSchema, { result: {
-		case: "error",
-		value: create(ReadErrorSchema, {
-			path,
-			error
-		})
-	} });
-}
-function buildReadRejectedResult(path, reason) {
-	return create(ReadResultSchema, { result: {
-		case: "rejected",
-		value: create(ReadRejectedSchema, {
-			path,
-			reason
-		})
-	} });
-}
-function buildWriteResultFromToolResult(args, toolResult) {
-	const text = toolResultToText(toolResult);
-	if (toolResult.isError) return buildWriteErrorResult(args.path, text || "Write failed");
-	const fileText = args.fileText ?? "";
-	const fileSize = args.fileBytes?.length ?? Buffer.byteLength(fileText, "utf-8");
-	const linesCreated = fileText ? fileText.split("\n").length : 0;
-	return create(WriteResultSchema, { result: {
-		case: "success",
-		value: create(WriteSuccessSchema, {
-			path: args.path,
-			linesCreated,
-			fileSize,
-			fileContentAfterWrite: args.returnFileContentAfterWrite ? fileText : void 0
-		})
-	} });
-}
-function buildWriteErrorResult(path, error) {
-	return create(WriteResultSchema, { result: {
-		case: "error",
-		value: create(WriteErrorSchema, {
-			path,
-			error
-		})
-	} });
-}
-function buildWriteRejectedResult(path, reason) {
-	return create(WriteResultSchema, { result: {
-		case: "rejected",
-		value: create(WriteRejectedSchema, {
-			path,
-			reason
-		})
-	} });
-}
-function buildDeleteResultFromToolResult(path, toolResult) {
-	const text = toolResultToText(toolResult);
-	if (toolResult.isError) return buildDeleteErrorResult(path, text || "Delete failed");
-	return create(DeleteResultSchema, { result: {
-		case: "success",
-		value: create(DeleteSuccessSchema, {
-			path,
-			deletedFile: path,
-			fileSize: BigInt(0),
-			prevContent: ""
-		})
-	} });
-}
-function buildDeleteErrorResult(path, error) {
-	return create(DeleteResultSchema, { result: {
-		case: "error",
-		value: create(DeleteErrorSchema, {
-			path,
-			error
-		})
-	} });
-}
-function buildDeleteRejectedResult(path, reason) {
-	return create(DeleteResultSchema, { result: {
-		case: "rejected",
-		value: create(DeleteRejectedSchema, {
-			path,
-			reason
-		})
-	} });
-}
-function buildShellResultFromToolResult(args, toolResult) {
-	const output = toolResultToText(toolResult);
-	if (toolResult.isError) return buildShellFailureResult(args.command, args.workingDirectory, output || "Shell failed");
-	return create(ShellResultSchema, { result: {
-		case: "success",
-		value: create(ShellSuccessSchema, {
-			command: args.command,
-			workingDirectory: args.workingDirectory,
-			exitCode: 0,
-			signal: "",
-			stdout: output,
-			stderr: "",
-			executionTime: 0
-		})
-	} });
-}
-function buildShellFailureResult(command, workingDirectory, error) {
-	return create(ShellResultSchema, { result: {
-		case: "failure",
-		value: create(ShellFailureSchema, {
-			command,
-			workingDirectory,
-			exitCode: 1,
-			signal: "",
-			stdout: "",
-			stderr: error,
-			executionTime: 0,
-			aborted: false
-		})
-	} });
-}
-function buildShellRejectedResult(command, workingDirectory, reason) {
-	return create(ShellResultSchema, { result: {
-		case: "rejected",
-		value: create(ShellRejectedSchema, {
-			command,
-			workingDirectory,
-			reason,
-			isReadonly: false
-		})
-	} });
-}
-function buildLsResultFromToolResult(path, toolResult) {
-	const text = toolResultToText(toolResult);
-	if (toolResult.isError) return buildLsErrorResult(path, text || "Ls failed");
-	const rootPath = path || ".";
-	const entries = text.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("["));
-	const childrenDirs = [];
-	const childrenFiles = [];
-	for (const entry of entries) {
-		const name = entry.split(" (")[0];
-		if (name.endsWith("/")) {
-			const dirName = name.slice(0, -1);
-			childrenDirs.push(create(LsDirectoryTreeNodeSchema, {
-				absPath: `${rootPath.replace(/\/$/, "")}/${dirName}`,
-				childrenDirs: [],
-				childrenFiles: [],
-				childrenWereProcessed: false,
-				fullSubtreeExtensionCounts: {},
-				numFiles: 0
-			}));
-		} else childrenFiles.push(create(LsDirectoryTreeNode_FileSchema, { name }));
-	}
-	const root = create(LsDirectoryTreeNodeSchema, {
-		absPath: rootPath,
-		childrenDirs,
-		childrenFiles,
-		childrenWereProcessed: true,
-		fullSubtreeExtensionCounts: {},
-		numFiles: childrenFiles.length
-	});
-	return create(LsResultSchema, { result: {
-		case: "success",
-		value: create(LsSuccessSchema, { directoryTreeRoot: root })
-	} });
-}
-function buildLsErrorResult(path, error) {
-	return create(LsResultSchema, { result: {
-		case: "error",
-		value: create(LsErrorSchema, {
-			path,
-			error
-		})
-	} });
-}
-function buildLsRejectedResult(path, reason) {
-	return create(LsResultSchema, { result: {
-		case: "rejected",
-		value: create(LsRejectedSchema, {
-			path,
-			reason
-		})
-	} });
-}
-function buildGrepResultFromToolResult(args, toolResult) {
-	const text = toolResultToText(toolResult);
-	if (toolResult.isError) return buildGrepErrorResult(text || "Grep failed");
-	const outputMode = args.outputMode || "content";
-	const clientTruncated = toolResultDetailBoolean(toolResult, "truncated");
-	const lines = text.split("\n").map((line) => line.trimEnd()).filter((line) => line.length > 0 && !line.startsWith("[") && !line.toLowerCase().startsWith("no matches"));
-	const workspaceKey = args.path || ".";
-	let unionResult;
-	if (outputMode === "files_with_matches") {
-		const files = lines;
-		unionResult = create(GrepUnionResultSchema, { result: {
-			case: "files",
-			value: create(GrepFilesResultSchema, {
-				files,
-				totalFiles: files.length,
-				clientTruncated,
-				ripgrepTruncated: false,
-				offsetApplied: args.offset
-			})
-		} });
-	} else if (outputMode === "count") {
-		const counts = lines.map((line) => {
-			const separatorIndex = line.lastIndexOf(":");
-			if (separatorIndex === -1) return null;
-			const file = line.slice(0, separatorIndex);
-			const count = Number.parseInt(line.slice(separatorIndex + 1), 10);
-			if (!file || Number.isNaN(count)) return null;
-			return create(GrepFileCountSchema, {
-				file,
-				count
-			});
-		}).filter((entry) => entry !== null);
-		const totalMatches = counts.reduce((sum, entry) => sum + entry.count, 0);
-		unionResult = create(GrepUnionResultSchema, { result: {
-			case: "count",
-			value: create(GrepCountResultSchema, {
-				counts,
-				totalFiles: counts.length,
-				totalMatches,
-				clientTruncated,
-				ripgrepTruncated: false,
-				offsetApplied: args.offset
-			})
-		} });
-	} else {
-		const matchMap = /* @__PURE__ */ new Map();
-		let totalMatchedLines = 0;
-		for (const line of lines) {
-			const matchLine = line.match(/^(.+?):(\d+):\s?(.*)$/);
-			const contextLine = line.match(/^(.+?)-(\d+)-\s?(.*)$/);
-			const match = matchLine ?? contextLine;
-			if (!match) continue;
-			const [, file, lineNumber, content] = match;
-			const isContextLine = Boolean(contextLine);
-			const list = matchMap.get(file) ?? [];
-			list.push({
-				line: Number(lineNumber),
-				content,
-				isContextLine
-			});
-			matchMap.set(file, list);
-			if (!isContextLine) totalMatchedLines += 1;
-		}
-		const matches = Array.from(matchMap.entries()).map(([file, matches]) => create(GrepFileMatchSchema, {
-			file,
-			matches: matches.map((entry) => create(GrepContentMatchSchema, {
-				lineNumber: entry.line,
-				content: entry.content,
-				contentTruncated: false,
-				isContextLine: entry.isContextLine
-			}))
-		}));
-		const totalLines = matches.reduce((sum, entry) => sum + entry.matches.length, 0);
-		unionResult = create(GrepUnionResultSchema, { result: {
-			case: "content",
-			value: create(GrepContentResultSchema, {
-				matches,
-				totalLines,
-				totalMatchedLines,
-				clientTruncated,
-				ripgrepTruncated: false,
-				offsetApplied: args.offset
-			})
-		} });
-	}
-	return create(GrepResultSchema, { result: {
-		case: "success",
-		value: create(GrepSuccessSchema, {
-			pattern: args.pattern,
-			path: args.path || "",
-			outputMode,
-			workspaceResults: { [workspaceKey]: unionResult }
-		})
-	} });
-}
-function buildGrepErrorResult(error) {
-	return create(GrepResultSchema, { result: {
-		case: "error",
-		value: create(GrepErrorSchema, { error })
-	} });
-}
-/**
-* Reject a Cursor exec-channel `grepArgs` frame whose `pattern` is empty or
-* whitespace-only. Returns an actionable error message when the pattern is
-* unusable (with a `glob`-aware hint when the model likely meant to list
-* files), or `null` when the pattern is valid and grep should run.
-*
-* Exported for tests. Cursor's model sometimes sends `pattern=""` together
-* with a non-empty `glob`, expecting grep to enumerate matching files; the
-* downstream coding-agent `grep` tool rejects that with a bare "Pattern must
-* not be empty", which the TUI renders as `?` in the tool preview (issue
-* #4574). Handling it at the Cursor exec dispatch keeps the synthesized
-* `toolCall` block off the persisted assistant message and gives the model a
-* specific recovery hint.
-*/
-function emptyGrepPatternRejection(pattern, glob) {
-	if (pattern && pattern.trim().length > 0) return null;
-	if (glob && glob.length > 0) return `grep pattern is required (received an empty pattern). To list files matching "${glob}", pass a non-empty regex (e.g. ".") and set path to that glob, or use the ls/read tool instead.`;
-	return "grep pattern is required (received an empty pattern).";
-}
-function buildDiagnosticsResultFromToolResult(path, toolResult) {
-	const text = toolResultToText(toolResult);
-	if (toolResult.isError) return buildDiagnosticsErrorResult(path, text || "Diagnostics failed");
-	return create(DiagnosticsResultSchema, { result: {
-		case: "success",
-		value: create(DiagnosticsSuccessSchema, {
-			path,
-			diagnostics: [],
-			totalDiagnostics: 0
-		})
-	} });
-}
-function buildDiagnosticsErrorResult(_path, error) {
-	return create(DiagnosticsResultSchema, { result: {
-		case: "error",
-		value: create(DiagnosticsErrorSchema, { error })
-	} });
-}
-function buildDiagnosticsRejectedResult(path, reason) {
-	return create(DiagnosticsResultSchema, { result: {
-		case: "rejected",
-		value: create(DiagnosticsRejectedSchema, {
-			path,
-			reason
-		})
-	} });
-}
-function parseToolArgsJson(text) {
-	const trimmed = text.trim();
-	if (!trimmed) return text;
-	try {
-		return parseJsonWithRepair(trimmed);
-	} catch {
-		return text;
-	}
-}
-function decodeMcpArgValue(value) {
-	try {
-		const jsonValue = decodeJsonValue(value);
-		if (typeof jsonValue === "string") {
-			const first = jsonValue.trimStart()[0];
-			return first === "{" || first === "[" || first === "\"" ? parseToolArgsJson(jsonValue) : jsonValue;
-		}
-		return jsonValue;
-	} catch {}
-	return parseToolArgsJson(new TextDecoder().decode(value));
-}
-function decodeMcpArgsMap(args) {
-	if (!args) return;
-	const decoded = {};
-	for (const [key, value] of Object.entries(args)) decoded[key] = decodeMcpArgValue(value);
-	return decoded;
-}
-function decodeMcpCall(args) {
-	const decodedArgs = {};
-	for (const [key, value] of Object.entries(args.args ?? {})) decodedArgs[key] = decodeMcpArgValue(value);
-	return {
-		name: args.name,
-		providerIdentifier: args.providerIdentifier,
-		toolName: args.toolName || args.name,
-		toolCallId: args.toolCallId,
-		args: decodedArgs,
-		rawArgs: args.args ?? {},
-		approvalOnly: args.smartModeApprovalOnly === true
-	};
-}
-/**
-* Map Cursor's `TodoStatus` enum (agent.proto) onto the local todo statuses.
-*
-* `TODO_STATUS_CANCELLED` (4) maps to `abandoned` rather than collapsing to
-* `pending`, which would resurrect a task the model explicitly cancelled.
-*/
-function mapTodoStatusValue(status) {
-	switch (status) {
-		case 2: return "in_progress";
-		case 3: return "completed";
-		case 4: return "abandoned";
-		default: return "pending";
-	}
-}
-function selectTodoCalls(toolCall) {
-	const oneof = toolCall.tool;
-	if (oneof?.case === "updateTodosToolCall") return { update: oneof.value };
-	if (oneof?.case === "readTodosToolCall") return { read: oneof.value };
-	return {
-		update: toolCall.updateTodosToolCall,
-		read: toolCall.readTodosToolCall
-	};
-}
-function mapTodoSnapshot(todos) {
-	return todos.map((todo) => ({
-		content: typeof todo.content === "string" ? todo.content : "",
-		status: mapTodoStatusValue(typeof todo.status === "number" ? todo.status : void 0)
-	}));
-}
-/**
-* `ToolCall.tool` is a protobuf oneof: a wire-decoded message exposes the
-* variant as `{ case, value }` and NEVER as a flattened `mcpToolCall`
-* property. Reading the flat property alone is what made native todo calls
-* invisible on the wire while hand-shaped test fixtures kept passing, so MCP
-* goes through the same selector. The flat fallback is kept for those fixtures.
-*/
-function selectMcpCall(toolCall) {
-	const oneof = toolCall?.tool;
-	if (oneof?.case === "mcpToolCall") return oneof.value;
-	return toolCall?.mcpToolCall;
-}
-/**
-* Same oneof-first selector as MCP: a wire-decoded `ToolCall` exposes
-* `editToolCall` only as `{ case: "editToolCall", value }`.
-*/
-function selectEditCall(toolCall) {
-	const oneof = toolCall?.tool;
-	if (oneof?.case === "editToolCall") return oneof.value;
-	return toolCall?.editToolCall;
-}
-function selectEditStreamDelta(update) {
-	const oneof = update.toolCallDelta?.delta;
-	if (oneof?.case === "editToolCallDelta") return oneof.value?.streamContentDelta;
-	return update.toolCallDelta?.editToolCallDelta?.streamContentDelta;
-}
-function rememberEditOwnedToolCall(state, toolCall, envelopeId) {
-	if (!state.editOwnedToolCallIds) state.editOwnedToolCallIds = /* @__PURE__ */ new Set();
-	const ids = state.editOwnedToolCallIds;
-	if (envelopeId) ids.add(envelopeId);
-	if (toolCall?.toolCallId) ids.add(toolCall.toolCallId);
-}
-function isEditOwnedToolCallId(state, output, toolCallId) {
-	if (state.editOwnedToolCallIds?.has(toolCallId)) return true;
-	return output.content.some((block) => block.type === "toolCall" && block.id === toolCallId && block.name === "edit");
-}
-function stringToolArg(args, key) {
-	const value = args?.[key];
-	return typeof value === "string" ? value : void 0;
-}
-function markEditToolCallPaired(state, toolCallId) {
-	if (!state.pairedEditToolCallIds) state.pairedEditToolCallIds = /* @__PURE__ */ new Set();
-	state.pairedEditToolCallIds.add(toolCallId);
-}
-/**
-* `EditToolCall.result` is an `EditResult` message whose own oneof is also
-* named `result`. The discriminator is `result.result.case`, same nesting as
-* `describeConnectScmResult` / the todo extractors.
-*/
-function describeEditResult(toolCall) {
-	const oneof = selectEditCall(toolCall)?.result?.result;
-	const variant = oneof?.case;
-	const value = oneof?.value;
-	if (variant === "success") return {
-		text: value?.message || value?.path || "Edited",
-		isError: false
-	};
-	if (variant === "error") return {
-		text: value?.modelVisibleError || value?.error || "Edit failed",
-		isError: true
-	};
-	if (variant === "rejected") return {
-		text: value?.reason || "Edit rejected",
-		isError: true
-	};
-	if (variant === "fileNotFound") return {
-		text: value?.path ? `File not found: ${value.path}` : "File not found",
-		isError: true
-	};
-	if (variant === "readPermissionDenied") return {
-		text: value?.path ? `Read permission denied: ${value.path}` : "Read permission denied",
-		isError: true
-	};
-	if (variant === "writePermissionDenied") return {
-		text: value?.error || (value?.path ? `Write permission denied: ${value.path}` : "Write permission denied"),
-		isError: true
-	};
-	return {
-		text: "Edit reported no result",
-		isError: true
-	};
-}
-function remapExecHandlerToolName(result, toolName) {
-	if (isToolResultMessage(result)) return {
-		...result,
-		toolName
-	};
-	if (result && typeof result === "object" && "toolResult" in result) {
-		const record = result;
-		if (record.toolResult && record.result !== void 0) return {
-			result: record.result,
-			toolResult: {
-				...record.toolResult,
-				toolName
-			}
-		};
-		if (record.toolResult) return {
-			...record.toolResult,
-			toolName
-		};
-	}
-	return result;
-}
-/**
-* Open (or refresh) the single `edit` transcript block for a native StrReplace
-* `editToolCall`. Materialization reads/writes reuse this id and must not
-* synthesize their own blocks.
-*/
-function openOrUpdateEditBlock(output, stream, state, toolCall, envelopeId) {
-	const edit = selectEditCall(toolCall);
-	if (!edit && toolCall?.tool?.case !== "editToolCall") return void 0;
-	rememberEditOwnedToolCall(state, toolCall, envelopeId);
-	const id = toolCall?.toolCallId || envelopeId;
-	if (!id) return void 0;
-	const nextArgs = omitUndefinedArgs({
-		path: edit?.args?.path,
-		stream_content: edit?.args?.streamContent
-	});
-	const existing = output.content.find((block) => block.type === "toolCall" && block.id === id);
-	if (existing) {
-		existing.arguments = {
-			...existing.arguments,
-			...nextArgs
-		};
-		return existing;
-	}
-	endCurrentTextBlock(output, stream, state);
-	endCurrentThinkingBlock(output, stream, state);
-	const block = {
-		type: "toolCall",
-		id,
-		name: "edit",
-		arguments: nextArgs,
-		[kStreamingBlockIndex]: output.content.length,
-		[kStreamingBlockKind]: "cursor-edit",
-		[kStreamingEnvelopeId]: envelopeId || void 0,
-		[kCursorExecResolved]: true
-	};
-	output.content.push(block);
-	retainStreamedCall(state, block, envelopeId);
-	stream.push({
-		type: "toolcall_start",
-		contentIndex: output.content.length - 1,
-		partial: output
-	});
-	return block;
-}
-/**
-* The streamed `ToolCall` variants whose block the exec channel owns.
-*
-* Each of these is announced on the interaction stream AND dispatched as its
-* own `ExecServerMessage` frame — the Pi family (45-51), plus the two MCP
-* resource frames — so the block is synthesized once, by the exec handler,
-* which is the side that has the result.
-*
-* `connect_scm` is deliberately NOT here: `ExecServerMessage` has no
-* connect-SCM case at all (field 44 is `git_diff_request`), so nothing on the
-* exec channel ever answers it and the streamed announcement is the only
-* signal. `search_conversations` is not here either: frame 53 answers it, but
-* it carries its own `tool_call_id` on the streamed envelope and pairs there,
-* so the exec branch does not synthesize a block for it.
-*/
-const EXEC_OWNED_TOOL_CALL_CASES = /* @__PURE__ */ new Set([
-	"piReadToolCall",
-	"piBashToolCall",
-	"piEditToolCall",
-	"piWriteToolCall",
-	"piGrepToolCall",
-	"piFindToolCall",
-	"piLsToolCall",
-	"listMcpResourcesToolCall",
-	"readMcpResourceToolCall"
-]);
-function isExecOwnedToolCall(toolCall) {
-	const variant = toolCall?.tool?.case;
-	return variant !== void 0 && EXEC_OWNED_TOOL_CALL_CASES.has(variant);
-}
-/**
-* Retain a freshly opened streamed tool-call block.
-*
-* Keyed by the interaction envelope's `call_id`, which is the only key every
-* `ToolCall*Update` for that call shares. The block's own `id` is deliberately
-* not the key: MCP, Pi and connect-SCM blocks are filed under the id carried
-* inside the call's `args`, because that is what the exec channel pairs its
-* result under and what the transcript files the visible block under.
-*
-* `currentToolCall` is still set, as the fallback for frames that carry no
-* `call_id` (proto3-optional, and unset on what older builds send).
-*/
-/**
-* Close every tool-call block still open when the stream ends.
-*
-* Not just the last one started: with interleaved calls several can be open at
-* once, and an unclosed block leaves its live card animating and its call
-* unpaired.
-*
-* Only blocks fed by a streamed argument buffer get reparsed. Todo,
-* connect-SCM and MCP-settled frames arrive with complete `arguments` and
-* never set the partial buffer; `parseStreamingJson(undefined)` returns `{}`,
-* so reparsing unconditionally would erase the arguments of every such block
-* caught open by a truncated stream.
-*
-* Server-owned blocks are also paired here. `connect-scm` and `todo` are
-* stamped {@link kCursorExecResolved} the moment they open, so `agent-loop.ts`
-* synthesizes no placeholder for them and only their `toolCallCompleted` frame
-* pairs a result. A transport that closes before that frame would leave the
-* call unpaired, and `buildSessionContext` strips a dangling call from every
-* rebuilt transcript — the interaction disappears. An interrupted result is
-* emitted instead.
-*
-* MCP blocks are excluded even when resolved: the exec dispatch that marked
-* them owns their result, and `drainInFlightDispatches` awaits it before this
-* runs, so pairing here would duplicate one against the same `toolCallId`.
-*/
-function flushOpenToolCalls(output, stream, state) {
-	const openBlocks = new Set(state.openToolCalls.values());
-	if (state.currentToolCall) openBlocks.add(state.currentToolCall);
-	for (const block of openBlocks) {
-		const idx = output.content.indexOf(block);
-		const partialJson = block[kStreamingPartialJson];
-		if (partialJson !== void 0) {
-			block.arguments = parseStreamingJson(partialJson);
-			clearStreamingPartialJson(block);
-		}
-		const kind = block[kStreamingBlockKind];
-		if (kind === "connect-scm" || kind === "todo" || kind === "cursor-edit") {
-			if (!(kind === "cursor-edit" && state.pairedEditToolCallIds?.has(block.id))) state.onToolResult?.({
-				role: "toolResult",
-				toolCallId: block.id,
-				toolName: block.name,
-				content: [{
-					type: "text",
-					text: "The connection to Cursor closed before this call completed."
-				}],
-				isError: true,
-				timestamp: Date.now()
-			});
-		}
-		stream.push({
-			type: "toolcall_end",
-			contentIndex: idx,
-			toolCall: block,
-			partial: output
-		});
-	}
-	state.openToolCalls.clear();
-	state.setToolCall(null);
-}
-function retainStreamedCall(state, block, envelopeId) {
-	if (envelopeId) state.openToolCalls.set(envelopeId, block);
-	state.setToolCall(block);
-}
-/**
-* The open block a streamed update addresses, or `null` to ignore the update.
-*
-* Cursor interleaves calls: `start A, start B, complete A` is legal, so the
-* update must reach block A even though B opened last. An id naming no open
-* block is ignored rather than misapplied — settling the wrong block would pair
-* it with another call's result.
-*
-* A missing id falls back to the current block: the correlation key is
-* optional, and dropping those updates would strand a block stamped
-* {@link kCursorExecResolved}, which nothing else settles and whose whole
-* interaction is then stripped from every rebuilt transcript.
-*/
-function resolveStreamedCall(state, envelopeId) {
-	if (!envelopeId) return state.currentToolCall;
-	const keyed = state.openToolCalls.get(envelopeId);
-	if (keyed) return keyed;
-	const current = state.currentToolCall;
-	return current && current[kStreamingEnvelopeId] === void 0 ? current : null;
-}
-/** Release a settled block from both the keyed map and the current slot. */
-function releaseStreamedCall(state, block) {
-	const envelopeId = block[kStreamingEnvelopeId];
-	if (envelopeId) state.openToolCalls.delete(envelopeId);
-	if (state.currentToolCall === block) state.setToolCall(null);
-}
-/**
-* The streamed `connect_scm_tool_call` variant, if this update carries one.
-*
-* Same oneof-vs-flattened handling as {@link selectMcpCall}: a wire-decoded
-* `ToolCall` exposes its variant as `{ case, value }`, while hand-shaped test
-* fixtures use the flat property.
-*/
-function selectConnectScmCall(toolCall) {
-	const oneof = toolCall?.tool;
-	if (oneof?.case === "connectScmToolCall") return oneof.value;
-	return toolCall?.connectScmToolCall;
-}
-/** The repository a connect-SCM call targets, across the `target` oneof. */
-function selectConnectScmRepository(call) {
-	const target = call?.args?.target;
-	if (target?.case === "github") return target.value?.repository;
-	return call?.args?.github?.repository;
-}
-/**
-* Render a settled `ConnectScmResult` as the text of its paired tool result.
-*
-* Returns `isError` because the three outcomes are not interchangeable: only
-* `success` means the repository was connected, and reporting a rejection as
-* success would tell the model to proceed against a repo it cannot reach.
-*/
-function describeConnectScmResult(call) {
-	const result = call?.result?.result;
-	switch (result?.case) {
-		case "success": return {
-			text: "SCM connected",
-			isError: false
-		};
-		case "error": return {
-			text: result.value?.error || "SCM connection failed",
-			isError: true
-		};
-		case "rejected": return {
-			text: result.value?.reason || "SCM connection rejected",
-			isError: true
-		};
-		default: return {
-			text: "SCM connection reported no result",
-			isError: true
-		};
-	}
-}
-/**
-* Extract the authoritative full todo list from a completed native todo call.
-*
-* Cursor owns this list server-side: `update_todos` / `read_todos` are resolved
-* remotely and the settled state rides on the tool call's `result`, never on
-* the exec channel (`ExecServerMessage` has no todo case). Only
-* `result.success.todos` is authoritative — the request `args` may differ from
-* what the server actually stored after a merge or normalization, and on
-* `UpdateTodosError` nothing was stored at all.
-*
-* A `read_todos` call carrying `status_filter` / `id_filter` (agent.proto
-* `ReadTodosArgs`) returns a SUBSET, not the list, and its `total_count`
-* reports the full size. Mirroring a partial response would delete every task
-* it omitted, so filtered and short reads are refused here. An empty read is
-* refused too: proto3 defaults unset `total_count` to 0, so `todos=[]` cannot
-* be told from a missing count.
-*
-* A snapshot whose rows are not unique by content is refused for a different
-* reason: Cursor keys todos by `id`, the local list is keyed by content, and
-* the collision is unrepresentable rather than merely partial.
-*
-* Returns `null` when no usable full snapshot is available, which the caller
-* MUST treat as "leave local state untouched".
-*/
-function extractTodoSnapshot(toolCall) {
-	const { update, read } = selectTodoCalls(toolCall);
-	if (read && ((read.args?.statusFilter?.length ?? 0) > 0 || (read.args?.idFilter?.length ?? 0) > 0)) return null;
-	const call = update ?? read;
-	if (!call) return null;
-	const result = call.result?.result;
-	if (result?.case !== "success") return null;
-	const todos = result.value?.todos;
-	if (!todos) return null;
-	const totalCount = result.value?.totalCount;
-	if (typeof totalCount === "number" && totalCount !== todos.length) return null;
-	if (read && todos.length === 0) return null;
-	const mapped = mapTodoSnapshot(todos);
-	if (mapped.some((todo) => todo.content.length === 0)) return null;
-	const seen = /* @__PURE__ */ new Set();
-	for (const todo of mapped) {
-		if (seen.has(todo.content)) return null;
-		seen.add(todo.content);
-	}
-	const finished = /* @__PURE__ */ new Set();
-	for (const todo of todos) {
-		const status = mapTodoStatusValue(typeof todo.status === "number" ? todo.status : void 0);
-		if (todo.id && (status === "completed" || status === "abandoned")) finished.add(todo.id);
-	}
-	for (const todo of todos) for (const dependency of todo.dependencies ?? []) if (!finished.has(dependency)) return null;
-	return {
-		todos: mapped,
-		merged: result.value?.wasMerge === true
-	};
-}
-/**
-* Error text when the server itself rejected the call.
-*
-* Distinct from {@link extractTodoSnapshot} returning `null`: a filtered read, a
-* truncated or empty one (proto3 cannot tell unset `total_count` from zero), or
-* a snapshot the local model cannot represent are all benign refusals (the call
-* succeeded, we just decline to mirror it), whereas an `UpdateTodosError` /
-* `ReadTodosError` is a real failure that must not replay as a successful no-op.
-*/
-function extractTodoError(toolCall) {
-	const { update, read } = selectTodoCalls(toolCall);
-	const result = (update ?? read)?.result?.result;
-	if (result?.case !== "error") return null;
-	const error = result.value?.error;
-	return typeof error === "string" && error.length > 0 ? error : "Todo operation failed";
-}
-/** Args echoed onto the synthesized display block, for rendering only. */
-function buildTodoDisplayArgs(toolCall) {
-	const args = selectTodoCalls(toolCall).update?.args;
-	return {
-		todos: args?.todos ? mapTodoSnapshot(args.todos) : [],
-		merge: args?.merge === true ? true : void 0
-	};
-}
-/**
-* Paired result for a server-resolved native todo call.
-*
-* The bridge never runs a local `todo` tool for these, so nothing else would
-* produce a `toolResult` for the block — and `buildSessionContext` strips any
-* `toolCall` left unpaired, taking the interaction out of every rebuilt
-* transcript.
-*
-* Three outcomes, kept distinct: a server error replays as a failure, a benign
-* refusal (a filtered, truncated, or empty read, or a snapshot the local model
-* cannot represent) replays as `"Todo snapshot not mirrored"`, and a settled
-* snapshot replays as its summary. Collapsing the first into the second would
-* hide the failure and let downstream lifecycle logic treat it as success. The
-* refusal text must not say `"No todo changes"`: an `update_todos` the server
-* accepted may still be declined locally, and that is not "no changes".
-*/
-function buildTodoToolResult(toolCallId, snapshot, error) {
-	return {
-		role: "toolResult",
-		toolCallId,
-		toolName: "todo",
-		content: [{
-			type: "text",
-			text: error ?? (snapshot ? formatTodoSnapshotSummary(snapshot.todos) : "Todo snapshot not mirrored")
-		}],
-		isError: error !== null,
-		timestamp: Date.now()
-	};
-}
-function formatTodoSnapshotSummary(todos) {
-	if (todos.length === 0) return "No todos";
-	return `${todos.filter((todo) => todo.status === "completed").length}/${todos.length} tasks completed`;
-}
-function buildMcpResultFromToolResult(_mcpCall, toolResult) {
-	if (toolResult.isError) return buildMcpErrorResult(toolResultToText(toolResult) || "MCP tool failed");
-	const content = toolResult.content.map((item) => {
-		if (item.type === "image") return create(McpToolResultContentItemSchema, { content: {
-			case: "image",
-			value: create(McpImageContentSchema, {
-				data: Uint8Array.from(Buffer.from(item.data, "base64")),
-				mimeType: item.mimeType
-			})
-		} });
-		return create(McpToolResultContentItemSchema, { content: {
-			case: "text",
-			value: create(McpTextContentSchema, { text: item.text })
-		} });
-	});
-	return create(McpResultSchema, { result: {
-		case: "success",
-		value: create(McpSuccessSchema, {
-			content,
-			isError: false
-		})
-	} });
-}
-const MCP_EXTERNAL_HANDOFF_MESSAGE = cursor_external_tool_handoff_default.trim();
-function buildMcpExternalHandoffResult() {
-	return create(McpResultSchema, { result: {
-		case: "success",
-		value: create(McpSuccessSchema, {
-			content: [create(McpToolResultContentItemSchema, { content: {
-				case: "text",
-				value: create(McpTextContentSchema, { text: MCP_EXTERNAL_HANDOFF_MESSAGE })
-			} })],
-			isError: false
-		})
-	} });
-}
-function buildMcpToolNotFoundResult(mcpCall) {
-	return create(McpResultSchema, { result: {
-		case: "toolNotFound",
-		value: create(McpToolNotFoundSchema, {
-			name: mcpCall.toolName,
-			availableTools: []
-		})
-	} });
-}
-function buildMcpErrorResult(error) {
-	return create(McpResultSchema, { result: {
-		case: "error",
-		value: create(McpErrorSchema, { error })
-	} });
-}
-/**
-* Merge the decoded completion-frame `McpArgs` map into the args assembled
-* from streamed `args_text_delta` snapshots.
-*
-* The completion frame is authoritative for the scalars it carries — but it
-* can omit oversized parameters entirely and can downgrade a structured value
-* to its raw string fallback when `decodeMcpArgValue` cannot parse it as
-* JSON. Overwriting the streamed args wholesale therefore loses data (e.g.
-* the task tool's `tasks` array on multi-subagent dispatches, issue #2615).
-*
-* Rules per key:
-* - completion key absent  → keep the streamed value.
-* - completion is a string while the streamed value is structured (object or
-*   array) → keep the streamed value (the completion frame downgraded it).
-* - otherwise               → completion wins.
-*/
-function mergeCursorMcpToolCallArgs(streamed, completion) {
-	const merged = { ...streamed };
-	if (!completion) return merged;
-	for (const [key, completionValue] of Object.entries(completion)) {
-		const streamedValue = merged[key];
-		if (typeof completionValue === "string" && streamedValue !== null && typeof streamedValue === "object") continue;
-		merged[key] = completionValue;
-	}
-	return merged;
-}
-function endCurrentTextBlock(output, stream, state) {
-	const block = state.currentTextBlock;
-	if (!block) return;
-	const idx = output.content.indexOf(block);
-	stream.push({
-		type: "text_end",
-		contentIndex: idx,
-		content: block.text,
-		partial: output
-	});
-	state.setTextBlock(null);
-}
-function endCurrentThinkingBlock(output, stream, state) {
-	const block = state.currentThinkingBlock;
-	if (!block) return;
-	const idx = output.content.indexOf(block);
-	stream.push({
-		type: "thinking_end",
-		contentIndex: idx,
-		content: block.thinking,
-		partial: output
-	});
-	state.setThinkingBlock(null);
-}
-/**
-* Synthesize a completed `toolCall` content block for a Cursor exec-channel
-* native tool (`shell`, `read`, `write`, `grep`, `ls`, `delete`, `diagnostics`)
-* or for an MCP exec frame whose corresponding interaction block is absent.
-*
-* Args arrive complete on the exec message, so the block opens and closes in
-* one step — no partial-JSON streaming path. Without this the persisted
-* assistant message carries only text/thinking blocks, and on replay the
-* following `toolResult` messages have no matching `toolCall.id` in
-* `renderSessionContext`, so they render beneath the final answer or disappear.
-*
-* The block is stamped with {@link kCursorExecResolved} so the shared
-* `agent-loop.ts` execution pass skips it — Cursor's server-driven exec
-* channel already ran the tool via the bridge and buffered the result, so
-* treating this block as runnable would re-execute the same side-effecting
-* tool a second time.
-*
-* Exported for tests to exercise ordering with adjacent text/thinking blocks.
-*/
-function synthesizeCursorExecToolCall(output, stream, state, toolCallId, toolName, args) {
-	endCurrentTextBlock(output, stream, state);
-	endCurrentThinkingBlock(output, stream, state);
-	const block = {
-		type: "toolCall",
-		id: toolCallId,
-		name: toolName,
-		arguments: omitUndefinedArgs(args),
-		[kStreamingBlockIndex]: output.content.length,
-		[kStreamingBlockKind]: "cursor-exec",
-		[kCursorExecResolved]: true
-	};
-	output.content.push(block);
-	const idx = output.content.length - 1;
-	stream.push({
-		type: "toolcall_start",
-		contentIndex: idx,
-		partial: output
-	});
-	stream.push({
-		type: "toolcall_end",
-		contentIndex: idx,
-		toolCall: block,
-		partial: output
-	});
-}
-/**
-* Pair a `toolResult` for a synthesized block the client answered itself,
-* without ever consulting a handler.
-*
-* {@link resolveExecHandler} does this for every frame backed by a local tool.
-* Frames answered from a fixed verdict — no handler, no local execution — still
-* need the pair for the same reason: the block was stamped
-* {@link kCursorExecResolved}, so `agent-loop.ts` emits no placeholder for it
-* and `buildSessionContext` strips an unpaired call, taking the whole
-* interaction out of every rebuilt transcript.
-*
-* `isError` defaults true because most such verdicts are refusals; the MCP
-* resource frames run locally and can genuinely succeed, and a success filed
-* as an error would render as a failed call in every rebuilt transcript.
-*/
-async function pairSynthesizedExecResult(state, onToolResult, toolCallId, toolName, text, isError = true) {
-	const synthesized = {
-		role: "toolResult",
-		toolCallId,
-		toolName,
-		content: [{
-			type: "text",
-			text
-		}],
-		isError,
-		timestamp: Date.now()
-	};
-	const sink = onToolResult ?? state.onToolResult;
-	if (!sink) return;
-	await sink(synthesized);
-}
-/** Exported for tests: drives one Cursor interaction update through the streaming state machine. */
-function processInteractionUpdate(update, output, stream, state, usageState) {
-	const updateCase = update.message?.case;
-	log("interactionUpdate", updateCase, update.message?.value);
-	if (updateCase === "textDelta") {
-		state.setFirstTokenTime();
-		const delta = update.message.value.text || "";
-		if (!state.currentTextBlock) {
-			const block = {
-				type: "text",
-				text: "",
-				[kStreamingBlockIndex]: output.content.length
-			};
-			output.content.push(block);
-			state.setTextBlock(block);
-			stream.push({
-				type: "text_start",
-				contentIndex: output.content.length - 1,
-				partial: output
-			});
-		}
-		state.currentTextBlock.text += delta;
-		const idx = output.content.indexOf(state.currentTextBlock);
-		stream.push({
-			type: "text_delta",
-			contentIndex: idx,
-			delta,
-			partial: output
-		});
-	} else if (updateCase === "thinkingDelta") {
-		state.setFirstTokenTime();
-		const delta = update.message.value.text || "";
-		if (!state.currentThinkingBlock) {
-			const block = {
-				type: "thinking",
-				thinking: "",
-				[kStreamingBlockIndex]: output.content.length
-			};
-			output.content.push(block);
-			state.setThinkingBlock(block);
-			stream.push({
-				type: "thinking_start",
-				contentIndex: output.content.length - 1,
-				partial: output
-			});
-		}
-		state.currentThinkingBlock.thinking += delta;
-		const idx = output.content.indexOf(state.currentThinkingBlock);
-		stream.push({
-			type: "thinking_delta",
-			contentIndex: idx,
-			delta,
-			partial: output
-		});
-	} else if (updateCase === "thinkingCompleted") endCurrentThinkingBlock(output, stream, state);
-	else if (updateCase === "toolCallStarted" && selectConnectScmCall(update.message.value.toolCall)) {
-		endCurrentTextBlock(output, stream, state);
-		endCurrentThinkingBlock(output, stream, state);
-		const scmCall = selectConnectScmCall(update.message.value.toolCall);
-		const repository = selectConnectScmRepository(scmCall);
-		const block = {
-			type: "toolCall",
-			id: scmCall?.args?.toolCallId || update.message.value.callId || crypto.randomUUID(),
-			name: "connect_scm",
-			arguments: repository ? {
-				owner: repository.owner,
-				repo: repository.repo
-			} : {},
-			[kStreamingBlockIndex]: output.content.length,
-			[kStreamingBlockKind]: "connect-scm",
-			[kStreamingEnvelopeId]: update.message.value.callId || void 0,
-			[kCursorExecResolved]: true
-		};
-		output.content.push(block);
-		retainStreamedCall(state, block, update.message.value.callId);
-		stream.push({
-			type: "toolcall_start",
-			contentIndex: output.content.length - 1,
-			partial: output
-		});
-	} else if (updateCase === "toolCallStarted" && isExecOwnedToolCall(update.message.value.toolCall)) {
-		endCurrentTextBlock(output, stream, state);
-		endCurrentThinkingBlock(output, stream, state);
-		log("exec", "streamedToolCallOwnedByExec", { case: update.message.value.toolCall?.tool?.case });
-	} else if (updateCase === "toolCallStarted") {
-		endCurrentTextBlock(output, stream, state);
-		endCurrentThinkingBlock(output, stream, state);
-		const toolCall = update.message.value.toolCall;
-		if (toolCall) {
-			const mcpCall = selectMcpCall(toolCall);
-			if (mcpCall) {
-				const args = mcpCall.args || {};
-				const id = args.toolCallId || crypto.randomUUID();
-				const resolvedByExec = state.resolvedMcpToolCallIds.delete(id);
-				if (resolvedByExec && output.content.some((block) => block.type === "toolCall" && block.id === id)) return;
-				const block = {
-					type: "toolCall",
-					id,
-					name: args.toolName || args.name || "",
-					arguments: decodeMcpArgsMap(args.args) ?? {},
-					[kStreamingBlockIndex]: output.content.length,
-					[kStreamingBlockKind]: "mcp",
-					[kStreamingEnvelopeId]: update.message.value.callId || void 0
-				};
-				if (resolvedByExec) markCursorExecResolved(block);
-				output.content.push(block);
-				retainStreamedCall(state, block, update.message.value.callId);
-				stream.push({
-					type: "toolcall_start",
-					contentIndex: output.content.length - 1,
-					partial: output
-				});
-				return;
-			}
-			const todoCalls = selectTodoCalls(toolCall);
-			if (todoCalls.update || todoCalls.read) {
-				const block = {
-					type: "toolCall",
-					id: update.message.value.callId || crypto.randomUUID(),
-					name: "todo",
-					arguments: buildTodoDisplayArgs(toolCall),
-					[kStreamingBlockIndex]: output.content.length,
-					[kStreamingBlockKind]: "todo",
-					[kStreamingEnvelopeId]: update.message.value.callId || void 0,
-					[kCursorExecResolved]: true
-				};
-				output.content.push(block);
-				retainStreamedCall(state, block, update.message.value.callId);
-				stream.push({
-					type: "toolcall_start",
-					contentIndex: output.content.length - 1,
-					partial: output
-				});
-				return;
-			}
-			const fetchCall = selectHostedFetchCall(toolCall);
-			if (fetchCall || hostedFetchUnknown(toolCall)) {
-				const url = fetchCall?.args?.url || extractHttpUrlFromUnknown(toolCall);
-				const block = {
-					type: "toolCall",
-					id: fetchCall?.args?.toolCallId || update.message.value.callId || crypto.randomUUID(),
-					name: "web_fetch",
-					arguments: url ? { url } : {},
-					[kStreamingBlockIndex]: output.content.length,
-					[kStreamingBlockKind]: "web-fetch",
-					[kStreamingEnvelopeId]: update.message.value.callId || void 0,
-					[kCursorExecResolved]: true
-				};
-				output.content.push(block);
-				retainStreamedCall(state, block, update.message.value.callId);
-				stream.push({
-					type: "toolcall_start",
-					contentIndex: output.content.length - 1,
-					partial: output
-				});
-				return;
-			}
-			openOrUpdateEditBlock(output, stream, state, toolCall, update.message.value.callId);
-		}
-	} else if (updateCase === "toolCallDelta" || updateCase === "partialToolCall") {
-		const value = update.message.value;
-		if (updateCase === "partialToolCall" && value.toolCall) openOrUpdateEditBlock(output, stream, state, value.toolCall, value.callId);
-		const editDelta = selectEditStreamDelta(value);
-		if (editDelta) {
-			const target = resolveStreamedCall(state, value.callId);
-			if (target?.[kStreamingBlockKind] === "cursor-edit") {
-				const current = stringToolArg(target.arguments, "stream_content") ?? "";
-				target.arguments = {
-					...target.arguments,
-					stream_content: current + editDelta
-				};
-				const idx = output.content.indexOf(target);
-				stream.push({
-					type: "toolcall_delta",
-					contentIndex: idx,
-					delta: editDelta,
-					partial: output
-				});
-				return;
-			}
-		}
-		const target = resolveStreamedCall(state, value.callId);
-		if (target?.[kStreamingBlockKind] === "mcp") {
-			const snapshot = update.message.value.argsTextDelta || "";
-			const current = target[kStreamingPartialJson] ?? "";
-			const chunk = snapshot.startsWith(current) ? snapshot.slice(current.length) : snapshot;
-			if (chunk.length === 0) return;
-			const nextBuffer = current + chunk;
-			target[kStreamingPartialJson] = nextBuffer;
-			const throttled = parseStreamingJsonThrottled(nextBuffer, target[kStreamingLastParseLen] ?? 0);
-			if (throttled) {
-				target.arguments = throttled.value;
-				target[kStreamingLastParseLen] = throttled.parsedLen;
-			}
-			const idx = output.content.indexOf(target);
-			stream.push({
-				type: "toolcall_delta",
-				contentIndex: idx,
-				delta: chunk,
-				partial: output
-			});
-		}
-	} else if (updateCase === "toolCallCompleted") {
-		const settled = resolveStreamedCall(state, update.message.value.callId);
-		if (settled) {
-			const toolCall = update.message.value.toolCall;
-			if (settled[kStreamingBlockKind] === "mcp") {
-				const partial = settled[kStreamingPartialJson];
-				if (partial) settled.arguments = parseStreamingJson(partial);
-				const decodedArgs = decodeMcpArgsMap(selectMcpCall(toolCall)?.args?.args);
-				settled.arguments = mergeCursorMcpToolCallArgs(settled.arguments, decodedArgs);
-			} else if (settled[kStreamingBlockKind] === "connect-scm") {
-				const scmCall = selectConnectScmCall(toolCall);
-				const repository = selectConnectScmRepository(scmCall);
-				if (repository) settled.arguments = {
-					owner: repository.owner,
-					repo: repository.repo
-				};
-				const { text, isError } = describeConnectScmResult(scmCall);
-				state.onToolResult?.({
-					role: "toolResult",
-					toolCallId: settled.id,
-					toolName: "connect_scm",
-					content: [{
-						type: "text",
-						text
-					}],
-					isError,
-					timestamp: Date.now()
-				});
-			} else if (settled[kStreamingBlockKind] === "web-fetch") {
-				const fetchCall = selectHostedFetchCall(toolCall);
-				const url = fetchCall?.args?.url || extractHttpUrlFromUnknown(toolCall ?? {});
-				if (url) settled.arguments = { url };
-				const { text, isError } = describeHostedFetchResult(fetchCall);
-				state.onToolResult?.({
-					role: "toolResult",
-					toolCallId: settled.id,
-					toolName: "web_fetch",
-					content: [{
-						type: "text",
-						text
-					}],
-					isError,
-					timestamp: Date.now()
-				});
-			} else if (settled[kStreamingBlockKind] === "todo") {
-				const snapshot = toolCall ? extractTodoSnapshot(toolCall) : null;
-				const error = toolCall ? extractTodoError(toolCall) : null;
-				if (snapshot) settled.arguments = {
-					todos: snapshot.todos,
-					merged: snapshot.merged
-				};
-				let persisted;
-				let hostError = null;
-				try {
-					persisted = state.onTodoSnapshot?.(snapshot, settled.id, error) ?? void 0;
-				} catch (callbackError) {
-					hostError = callbackError instanceof Error ? callbackError.message : String(callbackError);
-					log("error", "onTodoSnapshot", { error: hostError });
-				}
-				state.onToolResult?.(persisted ?? buildTodoToolResult(settled.id, snapshot, hostError ?? error));
-			} else if (settled[kStreamingBlockKind] === "cursor-edit") {
-				const edit = selectEditCall(toolCall);
-				if (edit?.args) settled.arguments = omitUndefinedArgs({
-					...settled.arguments,
-					path: edit.args.path ?? stringToolArg(settled.arguments, "path"),
-					stream_content: edit.args.streamContent ?? stringToolArg(settled.arguments, "stream_content")
-				});
-				if (!state.pairedEditToolCallIds?.has(settled.id)) {
-					const { text, isError } = describeEditResult(toolCall);
-					state.onToolResult?.({
-						role: "toolResult",
-						toolCallId: settled.id,
-						toolName: "edit",
-						content: [{
-							type: "text",
-							text
-						}],
-						isError,
-						timestamp: Date.now()
-					});
-				}
-			}
-			const idx = output.content.indexOf(settled);
-			clearStreamingPartialJson(settled);
-			stream.push({
-				type: "toolcall_end",
-				contentIndex: idx,
-				toolCall: settled,
-				partial: output
-			});
-			releaseStreamedCall(state, settled);
-		}
-	} else if (updateCase === "turnEnded") {
-		output.stopReason = "stop";
-		if (classifyModel("cursor", output.model).family === "k3" && !output.content.some((item) => item.type === "thinking" && item.thinking.length > 0)) warn("Cursor kimi-k3 turn completed without thinking blocks; persisted history will replay this turn without reasoning", {
-			model: output.model,
-			messageTimestamp: output.timestamp
-		});
-	} else if (updateCase === "tokenDelta") {
-		const tokenDelta = update.message.value;
-		usageState.sawTokenDelta = true;
-		output.usage.output += tokenDelta.tokens || 0;
-		output.usage.totalTokens = output.usage.input + output.usage.output;
-	}
-}
-function handleConversationCheckpointUpdate(checkpoint, output, usageState, onConversationCheckpoint) {
-	onConversationCheckpoint?.(checkpoint);
-	if (usageState.sawTokenDelta) return;
-	const usedTokens = checkpoint.tokenDetails?.usedTokens ?? 0;
-	if (usedTokens <= 0) return;
-	if (output.usage.contextTokens !== usedTokens) output.usage.contextTokens = usedTokens;
-}
-function createBlobId(data) {
-	return new Uint8Array(createHash("sha256").update(data).digest());
-}
-function storeCursorBlob(blobStore, data) {
-	const blobId = createBlobId(data);
-	blobStore.set(Buffer.from(blobId).toString("hex"), data);
-	return blobId;
-}
-/**
-* Cursor AgentService reconstructs the model prompt from `requestContext.rules`,
-* not from the client-supplied `rootPromptMessagesJson` system blobs. Map each
-* OMP system-prompt entry to a global CursorRule so always-apply rules survive
-* that reconstruction.
-*/
-function buildCursorRequestContextRules(systemPrompt) {
-	return normalizeSystemPrompts(systemPrompt).map((content, index) => create(CursorRuleSchema, {
-		fullPath: `/omp/system-prompt/${index}.mdc`,
-		content,
-		source: 2,
-		type: create(CursorRuleTypeSchema, { type: {
-			case: "global",
-			value: create(CursorRuleTypeGlobalSchema, {})
-		} })
-	}));
-}
-/**
-* Local tools Cursor already drives natively over the exec channel, so
-* advertising them again as MCP tools would give the model two ways to call the
-* same thing.
-*
-* `lsp` is deliberately NOT here. The native `diagnosticsArgs` frame covers
-* exactly one of the tool's actions (`action: "diagnostics"`); the rest —
-* `definition`, `references`, `rename`, `code_actions`, `hover`,
-* `implementation`, `type_definition`, `symbols`, ... — have no native frame at
-* all, so filtering the whole tool out hid every one of them from the model.
-*/
-const CURSOR_NATIVE_TOOL_NAMES = /* @__PURE__ */ new Set([
-	"bash",
-	"read",
-	"write",
-	"delete",
-	"ls",
-	"grep",
-	"todo"
-]);
-function isJsonValue(value) {
-	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
-	if (typeof value === "number") return Number.isFinite(value);
-	if (Array.isArray(value)) return value.every(isJsonValue);
-	if (!isRecord$1(value)) return false;
-	for (const key in value) if (!isJsonValue(value[key])) return false;
-	return true;
-}
-function buildMcpToolDefinitions(tools, requiresCursorToolSchemaProjection = false) {
-	if (!tools || tools.length === 0) return [];
-	const advertisedTools = tools.filter((tool) => !CURSOR_NATIVE_TOOL_NAMES.has(tool.name));
-	if (advertisedTools.length === 0) return [];
-	const writeTool = tools.find((tool) => tool.name === "write");
-	return (writeTool ? [...advertisedTools, writeTool] : advertisedTools).map((tool) => {
-		const wireSchema = toolWireSchema(tool);
-		const jsonSchema = requiresCursorToolSchemaProjection ? sanitizeSchemaForCursor(wireSchema) : wireSchema;
-		const schemaValue = jsonSchema !== null && !Array.isArray(jsonSchema) && isJsonValue(jsonSchema) ? jsonSchema : {
-			type: "object",
-			properties: {},
-			required: []
-		};
-		const inputSchema = encodeJsonValue(schemaValue);
-		return create(McpToolDefinitionSchema, {
-			name: tool.name,
-			description: tool.description || "",
-			providerIdentifier: "pi-agent",
-			toolName: tool.name,
-			inputSchema
-		});
-	});
-}
-/**
-* Extract text content from a user or developer message.
-*/
-function extractUserMessageText(msg) {
-	if (msg.role !== "user" && msg.role !== "developer") return "";
-	const content = msg.content;
-	if (typeof content === "string") return content.trim();
-	return content.filter((c) => c.type === "text").map((c) => c.text).join("\n").trim();
-}
-function hasUserMessageImages(msg) {
-	return (msg.role === "user" || msg.role === "developer") && Array.isArray(msg.content) && msg.content.some((item) => item.type === "image");
-}
-function buildCursorRootPromptContent(content) {
-	if (typeof content === "string") {
-		const text = content.trim();
-		return text ? [{
-			type: "text",
-			text
-		}] : [];
-	}
-	const parts = [];
-	for (const item of content) if (item.type === "text") {
-		const text = item.text.trim();
-		if (text) parts.push({
-			type: "text",
-			text
-		});
-	} else parts.push({
-		type: "image",
-		image: `data:${item.mimeType};base64,${item.data}`,
-		mediaType: item.mimeType
-	});
-	return parts;
-}
-function cursorUserContentKey(content) {
-	if (typeof content === "string") return content.trim();
-	const hash = createHash("sha256");
-	for (const item of content) {
-		hash.update(item.type);
-		if (item.type === "text") hash.update(item.text);
-		else {
-			hash.update(item.mimeType);
-			hash.update(item.data);
-		}
-	}
-	return hash.digest("hex");
-}
-function canReplayCursorThinking(msg, targetModelId) {
-	return targetModelId !== void 0 && classifyModel("cursor", targetModelId).family === "k3" && msg.api === "cursor-agent" && msg.provider === "cursor" && msg.model === targetModelId;
-}
-function buildCursorAssistantContent(msg, targetModelId) {
-	const content = [];
-	const replayThinking = canReplayCursorThinking(msg, targetModelId);
-	for (const item of msg.content) if (item.type === "text") {
-		if (item.text) content.push({
-			type: "text",
-			text: item.text
-		});
-	} else if (item.type === "thinking") {
-		if (replayThinking && item.thinking) content.push({
-			type: "reasoning",
-			text: item.thinking,
-			providerOptions: { cursor: { modelName: msg.model } },
-			...item.thinkingSignature ? { signature: item.thinkingSignature } : {}
-		});
-	} else if (item.type === "toolCall") content.push({
-		type: "tool-call",
-		toolCallId: normalizeToolCallId(item.id),
-		toolName: item.name,
-		args: normalizeCursorMcpArguments(item.arguments)
-	});
-	return content;
-}
-function assertCursorKimiK3HistoryReplayable(messages, activeUserMessageIndex, targetModelId) {
-	if (!targetModelId || classifyModel("cursor", targetModelId).family !== "k3") return;
-	const historyEnd = activeUserMessageIndex >= 0 ? activeUserMessageIndex : messages.length;
-	const missingThinkingTurns = [];
-	const newlyWarnedKeys = [];
-	let assistantTurn = 0;
-	for (let i = 0; i < historyEnd; i++) {
-		const msg = messages[i];
-		if (msg.role !== "assistant") continue;
-		assistantTurn++;
-		if (!(msg.api === "cursor-agent" && msg.provider === "cursor" && msg.model === targetModelId)) throw new ValidationError(`Cursor ${targetModelId} cannot continue history from a different model (${msg.provider}/${msg.model}); start a new session.`);
-		if (msg.content.some((item) => item.type === "thinking" && item.thinking.length > 0)) continue;
-		const warningKey = `${msg.api}\0${msg.provider}\0${msg.model}\0${msg.timestamp}`;
-		if (warnedCursorKimiK3ReplayMessages.has(warningKey)) continue;
-		missingThinkingTurns.push(assistantTurn);
-		newlyWarnedKeys.push(warningKey);
-	}
-	if (missingThinkingTurns.length === 0) return;
-	for (const key of newlyWarnedKeys) warnedCursorKimiK3ReplayMessages.add(key);
-	warn(`Cursor kimi-k3 history contains same-model assistant turn(s) ${missingThinkingTurns.join(", ")} without thinking blocks; replaying those spans without reasoning may make generation less stable`, {
-		model: targetModelId,
-		assistantTurns: missingThinkingTurns
-	});
-}
-/**
-* Index of the last user/developer message in `messages`, or -1 if none.
-* Used to exclude the current user turn from history builders — it goes in
-* `ConversationActionSchema.userMessageAction`, not in history structures.
-*/
-function findLastUserMessageIndex(messages) {
-	for (let i = messages.length - 1; i >= 0; i--) {
-		const role = messages[i].role;
-		if (role === "user" || role === "developer") return i;
-	}
-	return -1;
-}
-/**
-* Build `ConversationStateStructure.rootPromptMessagesJson` blob IDs for the
-* system prompt plus prior conversation history, as JSON blobs matching
-* Cursor's internal Vercel-AI-SDK-shaped message format.
-*
-* Cursor's server uses `rootPromptMessagesJson` (not `turns[]`) to build the
-* actual model prompt. `turns[]` is UI/display metadata. Without populating
-* this field, multi-turn conversations lose prior context — the model sees
-* only an empty placeholder where historical user turns should be.
-* The active user message is excluded because it is sent in the action.
-*/
-/**
-* Build one Cursor system-message JSON blob per ordered system prompt. Emitting separate blobs
-* (rather than a single `\n\n`-joined string) lets Cursor's blob cache hit independently per
-* entry: changing only the last prompt does not invalidate earlier blob ids, so the prefix
-* up to the changed prompt remains cached on the server side.
-*
-* When no system prompts are provided, returns a single default greeting so we never emit
-* an empty `rootPromptMessagesJson` head.
-*/
-function buildCursorSystemPromptJsons(systemPrompt) {
-	const systemPrompts = normalizeSystemPrompts(systemPrompt);
-	if (systemPrompts.length === 0) return [JSON.stringify({
-		role: "system",
-		content: "You are a helpful assistant."
-	})];
-	return systemPrompts.map((content) => JSON.stringify({
-		role: "system",
-		content
-	}));
-}
-function collectCursorToolHistory(messages, historyEnd) {
-	const toolResults = /* @__PURE__ */ new Map();
-	const pairedToolCallIds = /* @__PURE__ */ new Set();
-	for (let index = 0; index < historyEnd; index++) {
-		const message = messages[index];
-		if (message.role === "toolResult") toolResults.set(message.toolCallId, message);
-		else if (message.role === "assistant") {
-			for (const item of message.content) if (item.type === "toolCall") pairedToolCallIds.add(item.id);
-		}
-	}
-	return {
-		toolResults,
-		pairedToolCallIds
-	};
-}
-function cursorOrphanToolResultText(result) {
-	return `${result.isError ? "[Tool Error]" : "[Tool Result]"}\n${toolResultToText(result) || "(empty result)"}`;
-}
-function buildRootPromptMessagesJson(messages, systemPromptIds, blobStore, activeUserMessageIndex = findLastUserMessageIndex(messages), targetModelId) {
-	assertCursorKimiK3HistoryReplayable(messages, activeUserMessageIndex, targetModelId);
-	const { pairedToolCallIds } = collectCursorToolHistory(messages, activeUserMessageIndex >= 0 ? activeUserMessageIndex : messages.length);
-	const entries = [...systemPromptIds];
-	const pushJson = (obj) => {
-		const bytes = new TextEncoder().encode(JSON.stringify(obj));
-		entries.push(storeCursorBlob(blobStore, bytes));
-	};
-	for (let i = 0; i < messages.length; i++) {
-		if (i === activeUserMessageIndex) break;
-		const msg = messages[i];
-		if (msg.role === "user" || msg.role === "developer") {
-			const content = buildCursorRootPromptContent(msg.content);
-			if (content.length === 0) continue;
-			pushJson({
-				role: "user",
-				content
-			});
-		} else if (msg.role === "assistant") {
-			const content = buildCursorAssistantContent(msg, targetModelId);
-			if (content.length === 0) continue;
-			pushJson({
-				role: "assistant",
-				content
-			});
-		} else if (msg.role === "toolResult") {
-			if (!pairedToolCallIds.has(msg.toolCallId)) {
-				pushJson({
-					role: "assistant",
-					content: [{
-						type: "text",
-						text: cursorOrphanToolResultText(msg)
-					}]
-				});
-				continue;
-			}
-			const toolCallId = normalizeToolCallId(msg.toolCallId);
-			pushJson({
-				role: "tool",
-				id: toolCallId,
-				content: [{
-					type: "tool-result",
-					toolName: msg.toolName,
-					toolCallId,
-					result: toolResultToText(msg),
-					...msg.isError ? { isError: true } : {}
-				}]
-			});
-		}
-	}
-	return entries;
-}
-function normalizeCursorMcpArgument(value, seen) {
-	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
-	if (typeof value === "number") return Number.isFinite(value) ? value : null;
-	if (typeof value !== "object") return void 0;
-	if (seen.has(value)) return void 0;
-	seen.add(value);
-	try {
-		if (Array.isArray(value)) return value.map((item) => normalizeCursorMcpArgument(item, seen) ?? null);
-		if (!isRecord$1(value)) return void 0;
-		const normalized = Object.create(null);
-		for (const key in value) {
-			if (!Object.hasOwn(value, key)) continue;
-			const normalizedItem = normalizeCursorMcpArgument(value[key], seen);
-			if (normalizedItem !== void 0) normalized[key] = normalizedItem;
-		}
-		return normalized;
-	} finally {
-		seen.delete(value);
-	}
-}
-function normalizeCursorMcpArguments(args) {
-	const normalized = Object.create(null);
-	const seen = /* @__PURE__ */ new Set();
-	for (const name in args) {
-		if (!Object.hasOwn(args, name)) continue;
-		const normalizedValue = normalizeCursorMcpArgument(args[name], seen);
-		if (normalizedValue !== void 0) normalized[name] = normalizedValue;
-	}
-	return normalized;
-}
-function encodeCursorMcpArguments(toolCall) {
-	const encoded = Object.create(null);
-	const normalized = normalizeCursorMcpArguments(toolCall.arguments);
-	for (const name in normalized) encoded[name] = encodeJsonValue(normalized[name]);
-	return encoded;
-}
-function createCursorMcpResult(result) {
-	if (result.isError) return create(McpToolResultSchema, { result: {
-		case: "error",
-		value: create(McpToolErrorSchema, { error: toolResultToText(result) })
-	} });
-	return create(McpToolResultSchema, { result: {
-		case: "success",
-		value: create(McpSuccessSchema, { content: result.content.map((item) => item.type === "text" ? create(McpToolResultContentItemSchema, { content: {
-			case: "text",
-			value: create(McpTextContentSchema, { text: item.text })
-		} }) : create(McpToolResultContentItemSchema, { content: {
-			case: "image",
-			value: create(McpImageContentSchema, {
-				data: Uint8Array.from(Buffer.from(item.data, "base64")),
-				mimeType: item.mimeType
-			})
-		} })) })
-	} });
-}
-function createCursorToolCallStep(toolCall, result) {
-	const toolCallId = normalizeToolCallId(toolCall.id);
-	const mcpCall = create(McpToolCallSchema, {
-		args: create(McpArgsSchema, {
-			name: toolCall.name,
-			args: encodeCursorMcpArguments(toolCall),
-			toolCallId,
-			providerIdentifier: "pi-agent",
-			toolName: toolCall.name
-		}),
-		...result ? { result: createCursorMcpResult(result) } : {}
-	});
-	return create(ConversationStepSchema, { message: {
-		case: "toolCall",
-		value: create(ToolCallSchema, {
-			tool: {
-				case: "mcpToolCall",
-				value: mcpCall
-			},
-			toolCallId
-		})
-	} });
-}
-/**
-* Convert context.messages to Cursor's ConversationTurnStructure blob IDs.
-* Groups messages into turns: each turn is a user message followed by the assistant's response.
-* Excludes the active user message (which goes in the action).
-*
-* Each `AgentConversationTurnStructure.user_message`, `steps[]`, and the outer
-* `ConversationStateStructure.turns[]` entry is a blob ID into `blobStore`.
-*/
-function buildConversationTurns(messages, blobStore, activeUserMessageIndex = findLastUserMessageIndex(messages), targetModelId) {
-	const turns = [];
-	const { toolResults, pairedToolCallIds } = collectCursorToolHistory(messages, activeUserMessageIndex >= 0 ? activeUserMessageIndex : messages.length);
-	let i = 0;
-	while (i < messages.length) {
-		const msg = messages[i];
-		if (msg.role !== "user" && msg.role !== "developer") {
-			i++;
-			continue;
-		}
-		if (i === activeUserMessageIndex) break;
-		const userText = extractUserMessageText(msg);
-		if (userText.length === 0 && !hasUserMessageImages(msg)) {
-			i++;
-			continue;
-		}
-		const userMessage = createCursorUserMessage(msg.content, userText, deterministicUuid(`u:${turns.length}:${cursorUserContentKey(msg.content)}`));
-		const userMessageBlobId = storeCursorBlob(blobStore, toBinary(UserMessageSchema, userMessage));
-		const stepBlobIds = [];
-		i++;
-		while (i < messages.length && messages[i].role !== "user" && messages[i].role !== "developer") {
-			const stepMsg = messages[i];
-			if (stepMsg.role === "assistant") for (const item of stepMsg.content) {
-				let step;
-				if (item.type === "text") {
-					if (!item.text) continue;
-					step = create(ConversationStepSchema, { message: {
-						case: "assistantMessage",
-						value: create(AssistantMessageSchema, { text: item.text })
-					} });
-				} else if (item.type === "thinking") {
-					if (!item.thinking || !canReplayCursorThinking(stepMsg, targetModelId)) continue;
-					step = create(ConversationStepSchema, { message: {
-						case: "thinkingMessage",
-						value: create(ThinkingMessageSchema, { text: item.thinking })
-					} });
-				} else if (item.type === "toolCall") step = createCursorToolCallStep(item, toolResults.get(item.id));
-				else continue;
-				stepBlobIds.push(storeCursorBlob(blobStore, toBinary(ConversationStepSchema, step)));
-			}
-			else if (stepMsg.role === "toolResult" && !pairedToolCallIds.has(stepMsg.toolCallId)) {
-				const step = create(ConversationStepSchema, { message: {
-					case: "assistantMessage",
-					value: create(AssistantMessageSchema, { text: cursorOrphanToolResultText(stepMsg) })
-				} });
-				stepBlobIds.push(storeCursorBlob(blobStore, toBinary(ConversationStepSchema, step)));
-			}
-			i++;
-		}
-		const agentTurn = create(AgentConversationTurnStructureSchema, {
-			userMessage: userMessageBlobId,
-			steps: stepBlobIds
-		});
-		const turn = create(ConversationTurnStructureSchema, { turn: {
-			case: "agentConversationTurn",
-			value: agentTurn
-		} });
-		turns.push(storeCursorBlob(blobStore, toBinary(ConversationTurnStructureSchema, turn)));
-	}
-	return turns;
-}
-function createCursorUserMessage(content, text, messageId = crypto.randomUUID()) {
-	const images = typeof content === "string" ? [] : extractImages(content);
-	return create(UserMessageSchema, {
-		text,
-		messageId,
-		...images.length > 0 ? { selectedContext: create(SelectedContextSchema, { selectedImages: images }) } : {}
-	});
-}
-function extractImages(content) {
-	return content.filter((item) => item.type === "image").map((image) => create(SelectedImageSchema, {
-		uuid: crypto.randomUUID(),
-		mimeType: image.mimeType,
-		dataOrBlobId: {
-			case: "data",
-			value: Uint8Array.from(Buffer.from(image.data, "base64"))
-		}
-	}));
-}
-/**
-* Resolve the Cursor Run wire model id and its parameter list.
-*
-* Cursor's `GetUsableModels` lists reasoning models as per-effort sibling
-* slugs (`gpt-5.4-mini-low`, `gpt-5.6-sol-high`), and OMP copies those ids 1:1.
-* The Run endpoint rejects a sibling slug as the wire `model_id` with
-* `resource_exhausted` (errorId 528384); the official `cursor-agent` splits the
-* slug into its base model id plus a `reasoning` effort parameter. Mirror that
-* for OpenAI-family ids: split the tier with the compiled catalog policy
-* (`collapseVariantId`, KDL suffix/lane rules) and emit
-* `{ id: "reasoning", value: <effort> }`. The off tier (`-none`) is a sibling
-* slug too, so it normalizes to the bare (lane-preserving) base with no
-* reasoning parameter instead of going out raw.
-*
-* Non-OpenAI ids pass through unchanged — Cursor-native ids (`composer-*`,
-* `cursor-grok-*`, `default`) carry no effort suffix, and Claude/other siblings
-* need additional parameters (`thinking`, `context`) whose per-model values are
-* not exposed by the decoded `GetUsableModels` schema, so guessing them would
-* re-trigger 528384.
-*/
-function resolveCursorWireModel(model, requestModelId, wireMode = "normalized") {
-	const wireModelId = requestModelId ?? model.requestModelId ?? model.id;
-	if (wireMode === "discovered") return {
-		modelId: wireModelId,
-		parameters: []
-	};
-	const collapsed = collapseVariantId("cursor", wireModelId);
-	const effort = collapsed.effort;
-	const base = effort !== void 0 ? collapsed.logicalId : void 0;
-	if (effort !== void 0 && base && classifyModel("cursor", base).class === "openai") {
-		if (effort === "off") return {
-			modelId: base,
-			parameters: []
-		};
-		if (THINKING_EFFORTS.includes(effort)) return {
-			modelId: base,
-			parameters: [create(RequestedModel_ModelParameterbytesSchema, {
-				id: "reasoning",
-				value: collapsed.effort
-			})]
-		};
-	}
-	if (wireModelId === "composer-2.5") return {
-		modelId: wireModelId,
-		parameters: [create(RequestedModel_ModelParameterbytesSchema, {
-			id: "fast",
-			value: "false"
-		})]
-	};
-	return {
-		modelId: wireModelId,
-		parameters: []
-	};
-}
-async function buildGrpcRequestForWireMode(model, context, options, state, wireMode) {
-	const blobStore = state.blobStore;
-	const systemPromptIds = buildCursorSystemPromptJsons(context.systemPrompt).map((json) => storeCursorBlob(blobStore, new TextEncoder().encode(json)));
-	const lastUserMessageIndex = findLastUserMessageIndex(context.messages);
-	let activeUserMessageIndex = context.messages.length - 1;
-	const activeMessage = context.messages[activeUserMessageIndex];
-	let activeUserMessage = activeMessage?.role === "user" || activeMessage?.role === "developer" ? activeMessage : void 0;
-	if (state.rotatedFresh && !activeUserMessage && lastUserMessageIndex >= 0) {
-		activeUserMessageIndex = lastUserMessageIndex;
-		const lastUser = context.messages[lastUserMessageIndex];
-		if (lastUser.role === "user" || lastUser.role === "developer") activeUserMessage = lastUser;
-	}
-	let userContent;
-	let userText = "";
-	let hasUserImages = false;
-	if (activeUserMessage?.role === "user" || activeUserMessage?.role === "developer") {
-		userContent = activeUserMessage.content;
-		if (typeof userContent === "string") userText = userContent.trim();
-		else {
-			userText = extractText(userContent);
-			hasUserImages = hasImages(userContent);
-		}
-	}
-	const action = create(ConversationActionSchema, { action: userContent && (userText.trim().length > 0 || hasUserImages) ? {
-		case: "userMessageAction",
-		value: create(UserMessageActionSchema, { userMessage: createCursorUserMessage(userContent, userText) })
-	} : {
-		case: "resumeAction",
-		value: create(ResumeActionSchema, {})
-	} });
-	const turns = buildConversationTurns(context.messages, blobStore, activeUserMessage ? activeUserMessageIndex : -1, model.id);
-	const rootPromptMessagesJson = buildRootPromptMessagesJson(context.messages, systemPromptIds, blobStore, activeUserMessage ? activeUserMessageIndex : -1, model.id);
-	const cachedPromptHead = state.conversationState?.rootPromptMessagesJson?.slice(0, systemPromptIds.length) ?? [];
-	const hasMatchingPrompt = cachedPromptHead.length === systemPromptIds.length && systemPromptIds.every((id, idx) => Buffer.from(cachedPromptHead[idx]).equals(id));
-	const baseState = state.conversationState && hasMatchingPrompt ? state.conversationState : create(ConversationStateStructureSchema, {
-		rootPromptMessagesJson: systemPromptIds,
-		turns: [],
-		todos: [],
-		pendingToolCalls: [],
-		previousWorkspaceUris: [],
-		fileStates: {},
-		fileStatesV2: {},
-		summaryArchives: [],
-		turnTimings: [],
-		subagentStates: {},
-		selfSummaryCount: 0,
-		readPaths: []
-	});
-	const conversationState = create(ConversationStateStructureSchema, {
-		...baseState,
-		rootPromptMessagesJson,
-		turns
-	});
-	const { modelId: wireModelId, parameters: wireParameters } = resolveCursorWireModel(model, options?.wireModelId, wireMode);
-	const cursorMaxMode = model.cursorMaxMode === true;
-	const modelDetails = create(ModelDetailsSchema, {
-		modelId: wireModelId,
-		displayModelId: model.id,
-		displayName: model.name,
-		...cursorMaxMode ? { maxMode: true } : void 0
-	});
-	const requestedModel = create(RequestedModelSchema, {
-		modelId: wireModelId,
-		maxMode: cursorMaxMode,
-		parameters: wireParameters
-	});
-	let runRequest = create(AgentRunRequestSchema, {
-		conversationState,
-		action,
-		modelDetails,
-		requestedModel,
-		conversationId: state.conversationId
-	});
-	if (options?.customSystemPrompt) runRequest.customSystemPrompt = options.customSystemPrompt;
-	const replacementRequest = await options?.onPayload?.(runRequest, model);
-	if (replacementRequest !== void 0) runRequest = replacementRequest;
-	const discoveredWireModelId = options?.wireModelId ?? model.requestModelId ?? model.id;
-	const serializedParameters = runRequest.requestedModel?.parameters;
-	const fallbackWireModelId = wireMode === "normalized" && wireParameters.length > 0 && wireModelId !== discoveredWireModelId && runRequest.requestedModel?.modelId === wireModelId && runRequest.modelDetails?.modelId === wireModelId && serializedParameters?.length === wireParameters.length && serializedParameters.every((parameter, index) => {
-		const expected = wireParameters[index];
-		return expected !== void 0 && parameter.id === expected.id && parameter.value === expected.value;
-	}) ? discoveredWireModelId : void 0;
-	const clientMessage = create(AgentClientMessageSchema, { message: {
-		case: "runRequest",
-		value: runRequest
-	} });
-	const requestBytes = toBinary(AgentClientMessageSchema, clientMessage);
-	const toolNames = context.tools?.map((tool) => tool.name) ?? [];
-	const detail = $env.DEBUG_CURSOR === "2" ? ` ${JSON.stringify(clientMessage.message.value, debugReplacer, 2)?.slice(0, 2e3)}` : "";
-	log("info", "builtRunRequest", {
-		bytes: requestBytes.length,
-		tools: toolNames.length,
-		toolNames: toolNames.slice(0, 20),
-		detail: detail || void 0
-	});
-	return {
-		requestBytes,
-		blobStore,
-		conversationState,
-		fallbackWireModelId
-	};
-}
-function hasImages(content) {
-	return content.some((item) => item.type === "image");
-}
-function extractText(content) {
-	return content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
-}
-//#endregion
-export { streamCursor };