reeval 0.0.1

package/dist/src-Cmp-7YrD.js

@@ -0,0 +1,1136 @@
+import { posix } from "node:path";
+import { Readable } from "node:stream";
+import { HarnessCapabilityUnsupportedError, commonTool, harnessSessionDataDirectoryPath, harnessStateDirectoryPath } from "@ai-sdk/harness";
+import { generateSandboxCredentialPlaceholder, isHarnessAuthenticationEnvironment, resolveSandboxHomeDir, shellQuote, warnCredentialBrokeringUnavailable, writeSkills } from "@ai-sdk/harness/utils";
+import { tool } from "@ai-sdk/provider-utils";
+import { createInterface } from "node:readline";
+import { z } from "zod";
+//#region ../harness-cursor-sdk/src/cursor-sdk-auth.ts
+/** The only credential the adapter uses: a Cursor user or service-account API key. */
+const CURSOR_SDK_CREDENTIAL_ENV = "CURSOR_API_KEY";
+/** Cursor's public API: the model catalog and `GET /v1/agents/{id}/usage`. Called from the host. */
+const CURSOR_API_URL = "https://api.cursor.com";
+/**
+* The SDK looks the model up in this catalog instead of calling `GET api.cursor.com/v1/models`
+* with the API key. The adapter fetches it on the host, so the sandbox never needs that host.
+*/
+const CURSOR_SDK_MODEL_CATALOG_ENV = "CURSOR_SDK_LOCAL_MODEL_CATALOG_JSON";
+function resolveCursorSdkCredentials(auth = "auto", hostEnv = process.env) {
+	if (auth !== "auto" && !isHarnessAuthenticationEnvironment(auth)) throw new Error(`Cursor SDK auth must be 'auto' or an environment object such as { ${CURSOR_SDK_CREDENTIAL_ENV}: '…' } (got ${JSON.stringify(auth)})`);
+	const apiKey = (auth === "auto" ? hostEnv : auth)[CURSOR_SDK_CREDENTIAL_ENV];
+	if (!apiKey) throw new Error(`${CURSOR_SDK_CREDENTIAL_ENV} isn't set, so the Cursor SDK can't authenticate. It needs a Cursor user or service-account API key.`);
+	return { apiKey };
+}
+/**
+* The one request the SDK sends the API key on (checked with @cursor/sdk 1.0.32): it trades
+* the key for session tokens, which it sends everywhere else. The same endpoint the Cursor CLI
+* uses, so a gateway that brokers the CLI brokers the SDK unchanged.
+*/
+function cursorSdkEndpoints() {
+	return [{
+		host: "api2.cursor.sh",
+		path: { exact: "/auth/exchange_user_api_key" },
+		method: ["POST"]
+	}];
+}
+/** Swaps the sandbox's placeholder for the real key on the key exchange, and nowhere else. */
+function createCursorSdkRequestTransformations({ credentials, placeholder, headers }) {
+	const [exchange] = cursorSdkEndpoints();
+	return [{
+		match: {
+			host: exchange.host,
+			path: exchange.path,
+			method: [...exchange.method],
+			headers: [{
+				key: { exact: "Authorization" },
+				value: { exact: `Bearer ${placeholder}` }
+			}]
+		},
+		transform: { headers: { Authorization: `Bearer ${credentials.apiKey}` } }
+	}, ...headers && Object.keys(headers).length > 0 ? [{
+		match: { host: exchange.host },
+		transform: { headers: { ...headers } }
+	}] : []];
+}
+const catalogs = /* @__PURE__ */ new Map();
+/** `GET /v1/models` with the real key, on the host, once per key and process. */
+function fetchCursorModelCatalog(credentials, options = {}) {
+	const baseUrl = (options.baseUrl ?? "https://api.cursor.com").replace(/\/+$/, "");
+	const cacheKey = `${baseUrl} ${credentials.apiKey}`;
+	let pending = catalogs.get(cacheKey);
+	if (!pending) {
+		pending = (async () => {
+			const res = await (options.fetch ?? fetch)(`${baseUrl}/v1/models`, {
+				headers: { Authorization: `Bearer ${credentials.apiKey}` },
+				...options.signal ? { signal: options.signal } : {}
+			});
+			if (!res.ok) throw new Error(`Cursor's model catalog request failed: HTTP ${res.status}`);
+			const body = await res.json();
+			const items = Array.isArray(body) ? body : body.items;
+			if (!Array.isArray(items)) throw new Error("Cursor's model catalog has no items");
+			return items;
+		})();
+		pending.catch(() => catalogs.delete(cacheKey));
+		catalogs.set(cacheKey, pending);
+	}
+	return pending;
+}
+/** The catalog entries for `model` (by id or alias), or the whole catalog if none match. */
+function catalogFor(catalog, model) {
+	if (!model) return catalog;
+	const match = catalog.filter((m) => m.id === model || m.aliases?.includes(model));
+	return match.length > 0 ? match : catalog;
+}
+//#endregion
+//#region ../harness-cursor-sdk/src/cursor-sdk-bootstrap.ts
+/** The SDK build the bootstrap installs. Bump it, then check the stream and endpoints still hold. */
+const CURSOR_SDK_VERSION = "1.0.32";
+/**
+* Built-in tools whose calls never reach the stream at {@link CURSOR_SDK_VERSION}: Cursor's
+* backend sends them, but the SDK's interaction-update converter maps `webSearchToolCall` and
+* `webFetchToolCall` to null, so neither `run.stream()` nor `onDelta` / `onStep` sees them. The
+* agent's stored conversation (`Agent.messages.list`) keeps them, with args, results and times,
+* so the runner reports them from there after each turn, as `tool_call` events marked
+* `recovered`. When it can't, the turn's `harnessMetadata.cursorSdk.unreportedTools` lists them.
+*/
+const CURSOR_SDK_RECOVERED_TOOLS = {
+	webSearchToolCall: "webSearch",
+	webFetchToolCall: "webFetch"
+};
+/**
+* The web calls in `Agent.messages.list()`'s messages (as JSON), wherever they're nested: each is
+* a `ToolCall` whose oneof key is in `recovered`. The runner embeds this function's source.
+*/
+function storedWebCalls(value, recovered = CURSOR_SDK_RECOVERED_TOOLS, found = []) {
+	if (Array.isArray(value)) for (const v of value) storedWebCalls(v, recovered, found);
+	else if (value && typeof value === "object") {
+		const o = value;
+		for (const [key, name] of Object.entries(recovered)) if (o[key] && typeof o.toolCallId === "string") found.push({
+			name,
+			id: o.toolCallId,
+			at: o,
+			call: o[key]
+		});
+		for (const v of Object.values(o)) storedWebCalls(v, recovered, found);
+	}
+	return found;
+}
+/**
+* What's wrong with the stored conversation's web calls, by the fields the runner reads: each
+* call's `toolCallId`, `startedAtMs` and `completedAtMs`, its `args` (`url` for a fetch,
+* `searchTerm` for a search) and a `result` with `success` or `error`; and any web tool key the
+* runner doesn't know (a renamed `webFetchToolCall` would otherwise just find nothing). Empty when
+* the shape is as the runner expects. The runner embeds this function's source, and reports what
+* it finds as the turn's unreported tools, with this message.
+*/
+function storedShapeProblems(value, calls, recovered = CURSOR_SDK_RECOVERED_TOOLS) {
+	const problems = [];
+	const unknown = /* @__PURE__ */ new Set();
+	const walk = (v) => {
+		if (Array.isArray(v)) for (const x of v) walk(x);
+		else if (v && typeof v === "object") for (const [k, x] of Object.entries(v)) {
+			if (/^web\w*ToolCall$/.test(k) && !(k in recovered)) unknown.add(k);
+			walk(x);
+		}
+	};
+	walk(value);
+	for (const k of unknown) problems.push(`an unknown web tool call key ${k}`);
+	const target = {
+		webFetch: "url",
+		webSearch: "searchTerm"
+	};
+	for (const c of calls) {
+		const at = `${c.name} ${c.id}`;
+		const epoch = (x) => x !== void 0 && x !== null && !Number.isNaN(Number(x));
+		if (!epoch(c.at.startedAtMs)) problems.push(`${at}: no startedAtMs`);
+		if (!epoch(c.at.completedAtMs)) problems.push(`${at}: no completedAtMs`);
+		const args = c.call?.args;
+		const field = target[c.name];
+		if (!args || typeof args !== "object") problems.push(`${at}: no args`);
+		else if (field && typeof args[field] !== "string") problems.push(`${at}: args has no ${field}`);
+		const result = c.call?.result;
+		if (!result || typeof result !== "object" || !("success" in result || "error" in result)) problems.push(`${at}: result has neither success nor error`);
+	}
+	return problems;
+}
+/** Relative to the harness state directory, `$HOME/.ai-sdk-harness`. */
+const CURSOR_SDK_BOOTSTRAP_DIR = ".harness-bootstrap/cursor-sdk";
+/** The runner's path relative to the bootstrap directory. */
+const CURSOR_SDK_RUNNER_PATH = "runner.mjs";
+/**
+* The SDK needs Node 22.13; routing its requests through `HTTPS_PROXY` (`NODE_USE_ENV_PROXY`)
+* needs 22.21, and a sandbox that brokers the key has no other way out.
+*/
+const CURSOR_SDK_MIN_NODE = "22.21.0";
+/** The file the adapter writes once a turn's request is complete, so the runner never reads half. */
+const cursorSdkTurnReady = (turn) => `turn-${turn}.ready`;
+/**
+* Runs a session's turns in the sandbox, one process for as long as it lives: it waits for each
+* turn's request (`turn-<n>.json`, then `turn-<n>.ready`) in the session directory, creates the
+* agent on the first (or resumes it by id from its JSONL store), sends the prompt and prints one
+* JSON line per event on stdout, then a `result` line. The agent stays loaded between turns, so a
+* follow-up turn skips Node's start, the SDK's import and the resume. The SDK logs to stdout, so
+* everything but those lines goes to stderr.
+*/
+const CURSOR_SDK_RUNNER = `// A local Cursor SDK agent's turns, as NDJSON on stdout.
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { setTimeout as sleep } from 'node:timers/promises'
+
+const write = process.stdout.write.bind(process.stdout)
+process.stdout.write = process.stderr.write.bind(process.stderr)
+const out = (line) => write(\`\${JSON.stringify(line)}\\n\`)
+const dir = process.argv[2]
+let n = Number(process.argv[3] ?? 1)
+
+let sdk
+try {
+  sdk = await import('@cursor/sdk')
+} catch (error) {
+  out({ type: 'error', turn: n, message: \`The Cursor SDK didn't load: \${error?.message ?? error}\` })
+  process.exit(1)
+}
+const { Agent, Cursor, JsonlLocalAgentStore } = sdk
+
+// Over HTTP/2 the agent's stream connects directly, ignoring HTTPS_PROXY; over HTTP/1.1 it
+// goes through the proxy like every other request.
+Cursor.configure({ local: { useHttp1ForAgent: true } })
+
+const RECOVERED = ${JSON.stringify(CURSOR_SDK_RECOVERED_TOOLS)}
+const storedWebCalls = ${storedWebCalls.toString()}
+const storedShapeProblems = ${storedShapeProblems.toString()}
+const epochMs = (v) => (v === undefined || v === null || Number.isNaN(Number(v)) ? undefined : Number(v))
+// As JSON: in memory they're protobuf messages, whose oneofs are { case, value }.
+const listMessages = async (turn) =>
+  JSON.parse(JSON.stringify(await Agent.messages.list(agent.agentId, { cwd: turn.cwd, store })))
+
+let agent
+let run
+let store
+let stopping = false
+const stop = () => {
+  stopping = true
+  if (run) void run.cancel().catch(() => {})
+  else process.exit(130)
+}
+process.on('SIGTERM', stop)
+process.on('SIGINT', stop)
+
+for (; !stopping; n++) {
+  while (!existsSync(join(dir, \`turn-\${n}.ready\`))) await sleep(15)
+  const turn = JSON.parse(readFileSync(join(dir, \`turn-\${n}.json\`), 'utf8'))
+  const prompt = readFileSync(turn.promptFile, 'utf8')
+  const started = Date.now()
+  try {
+    if (!agent) {
+      store = new JsonlLocalAgentStore(turn.storeDir)
+      const options = {
+        apiKey: process.env.CURSOR_API_KEY,
+        ...(turn.model ? { model: turn.model } : {}),
+        local: {
+          cwd: turn.cwd,
+          store,
+          settingSources: turn.settingSources,
+          ...(turn.sandbox ? { sandboxOptions: { enabled: true } } : {}),
+        },
+        ...(turn.mcpServers ? { mcpServers: turn.mcpServers } : {}),
+      }
+      agent = turn.agentId ? await Agent.resume(turn.agentId, options) : await Agent.create(options)
+    }
+    out({ type: 'init', turn: n, agentId: agent.agentId, model: agent.model, sdkVersion: turn.sdkVersion })
+    // Stored messages are updated in place, so earlier turns' calls are told apart by id.
+    const before = await listMessages(turn).then(
+      (m) => new Set(storedWebCalls(m, RECOVERED).map((c) => c.id)),
+      () => undefined,
+    )
+    run = await agent.send(prompt)
+    const streamed = new Set()
+    for await (const event of run.stream()) {
+      if (event.type === 'tool_call') streamed.add(event.call_id)
+      out({ type: 'event', event })
+    }
+    const result = await run.wait()
+    try {
+      if (before === undefined) throw new Error('the stored conversation could not be read before the turn')
+      const messages = await listMessages(turn)
+      const calls = storedWebCalls(messages, RECOVERED)
+      const problems = storedShapeProblems(messages, calls.filter((c) => !before.has(c.id)), RECOVERED)
+      if (problems.length) throw new Error(\`the stored conversation's shape changed (@cursor/sdk \${turn.sdkVersion ?? '?'}): \${problems.join('; ')}\`)
+      for (const c of calls.filter((c) => !before.has(c.id) && !streamed.has(c.id))) {
+        const { toolCallId, ...args } = c.call.args ?? {}
+        const base = { type: 'tool_call', agent_id: agent.agentId, run_id: result.id, call_id: c.id, name: c.name, args }
+        out({ type: 'event', recovered: 'Agent.messages.list', event: { ...base, status: 'running', started_at_ms: epochMs(c.at.startedAtMs) } })
+        const r = c.call.result
+        const failed = !r?.success
+        out({
+          type: 'event',
+          recovered: 'Agent.messages.list',
+          event: {
+            ...base,
+            status: failed ? 'error' : 'completed',
+            result: failed ? { status: 'error', error: r?.error ?? r ?? 'no result' } : { status: 'success', value: r.success },
+            started_at_ms: epochMs(c.at.startedAtMs),
+            completed_at_ms: epochMs(c.at.completedAtMs),
+          },
+        })
+      }
+    } catch (error) {
+      out({ type: 'unreported', turn: n, tools: Object.values(RECOVERED), message: String(error?.message ?? error) })
+    }
+    out({
+      type: 'result',
+      turn: n,
+      agentId: agent.agentId,
+      runId: result.id,
+      requestId: result.requestId,
+      status: result.status,
+      result: result.result,
+      error: result.error,
+      model: result.model,
+      durationMs: result.durationMs ?? Date.now() - started,
+      usage: result.usage,
+    })
+  } catch (error) {
+    out({
+      type: 'error',
+      turn: n,
+      message: String(error?.message ?? error),
+      name: error?.name,
+      code: error?.code,
+      status: error?.status,
+    })
+    // The next turn starts from the store, not from an agent in an unknown state.
+    await agent?.[Symbol.asyncDispose]?.().catch(() => {})
+    agent = undefined
+  } finally {
+    run = undefined
+  }
+}
+await agent?.[Symbol.asyncDispose]?.().catch(() => {})
+process.exit(130)
+`;
+/** Checks Node, then installs the pinned SDK (and its platform package) next to the runner. */
+function cursorSdkInstallScript(version = CURSOR_SDK_VERSION) {
+	return `set -eu
+node -e 'const [a,b]=process.versions.node.split(".").map(Number);const [x,y]="${CURSOR_SDK_MIN_NODE}".split(".").map(Number);if(a<x||(a===x&&b<y)){console.error("The Cursor SDK harness needs Node ${CURSOR_SDK_MIN_NODE} or later (found "+process.versions.node+")");process.exit(1)}'
+cat > package.json <<'JSON'
+{ "private": true, "type": "module", "dependencies": { "@cursor/sdk": "${version}" } }
+JSON
+npm install --omit=dev --no-audit --no-fund --loglevel=error
+node -e 'import("@cursor/sdk").then(() => console.log("@cursor/sdk ${version}"))'
+`;
+}
+async function getCursorSdkBootstrap() {
+	return {
+		harnessId: "cursor-sdk",
+		bootstrapDir: CURSOR_SDK_BOOTSTRAP_DIR,
+		files: [{
+			path: `${CURSOR_SDK_BOOTSTRAP_DIR}/install.sh`,
+			content: cursorSdkInstallScript()
+		}, {
+			path: `${CURSOR_SDK_BOOTSTRAP_DIR}/${CURSOR_SDK_RUNNER_PATH}`,
+			content: CURSOR_SDK_RUNNER
+		}],
+		commands: [{ command: "sh install.sh" }]
+	};
+}
+//#endregion
+//#region ../harness-cursor-sdk/src/cursor-sdk-tools.ts
+const native = (nativeName, title, toolUseKind) => ({
+	...tool({
+		title,
+		inputSchema: z.looseObject({})
+	}),
+	nativeName,
+	...toolUseKind ? { toolUseKind } : {}
+});
+const CURSOR_SDK_BUILTIN_TOOLS = {
+	bash: {
+		...commonTool("bash", {
+			nativeName: "shell",
+			toolUseKind: "bash",
+			inputSchema: z.looseObject({ command: z.string() })
+		}),
+		title: "Terminal"
+	},
+	read: {
+		...tool({
+			title: "Read",
+			inputSchema: z.looseObject({ path: z.string() })
+		}),
+		nativeName: "read",
+		toolUseKind: "readonly"
+	},
+	edit: {
+		...tool({
+			title: "Edit",
+			inputSchema: z.looseObject({ path: z.string() })
+		}),
+		nativeName: "edit",
+		toolUseKind: "edit"
+	},
+	write: {
+		...tool({
+			title: "Write",
+			inputSchema: z.looseObject({ path: z.string() })
+		}),
+		nativeName: "write",
+		toolUseKind: "edit"
+	},
+	delete: {
+		...tool({
+			title: "Delete",
+			inputSchema: z.looseObject({ path: z.string() })
+		}),
+		nativeName: "delete",
+		toolUseKind: "edit"
+	},
+	glob: {
+		...commonTool("glob", {
+			nativeName: "glob",
+			toolUseKind: "readonly",
+			inputSchema: z.looseObject({ pattern: z.string() })
+		}),
+		title: "Find"
+	},
+	grep: {
+		...commonTool("grep", {
+			nativeName: "grep",
+			toolUseKind: "readonly",
+			inputSchema: z.looseObject({
+				pattern: z.string(),
+				path: z.string().optional()
+			})
+		}),
+		title: "grep"
+	},
+	ls: native("ls", "List", "readonly"),
+	webSearch: {
+		...commonTool("webSearch", {
+			nativeName: "webSearch",
+			toolUseKind: "readonly",
+			inputSchema: z.looseObject({ query: z.string() })
+		}),
+		title: "Web Search"
+	},
+	webFetch: {
+		...tool({
+			title: "Fetch",
+			inputSchema: z.looseObject({ url: z.string() })
+		}),
+		nativeName: "webFetch",
+		toolUseKind: "readonly"
+	},
+	mcp: native("mcp", "MCP"),
+	task: native("task", "Task"),
+	semSearch: native("semSearch", "Semantic Search", "readonly"),
+	updateTodos: native("updateTodos", "Update TODOs"),
+	readTodos: native("readTodos", "Read TODOs", "readonly"),
+	readLints: native("readLints", "Read Lints", "readonly")
+};
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+const str = (value) => typeof value === "string" ? value : void 0;
+const BY_NATIVE_NAME = new Map(Object.entries(CURSOR_SDK_BUILTIN_TOOLS).map(([key, t]) => [t.nativeName ?? key, key]));
+/** Maps an SDK `tool_call` to its catalog name, adding the common-schema fields it implies. */
+function projectToolCall(nativeName, args) {
+	const a = record(args);
+	const common = (toolName, extra = {}) => ({
+		toolName,
+		nativeName,
+		input: {
+			...a,
+			...extra
+		},
+		dynamic: false
+	});
+	switch (nativeName) {
+		case "shell": return common("bash", { command: str(a.command) ?? "" });
+		case "glob": return common("glob", { pattern: str(a.globPattern) ?? str(a.pattern) ?? "" });
+		case "grep": return common("grep", { pattern: str(a.pattern) ?? "" });
+		case "webSearch": return common("webSearch", { query: str(a.searchTerm) ?? str(a.query) ?? "" });
+	}
+	const key = BY_NATIVE_NAME.get(nativeName);
+	return key ? common(key) : {
+		toolName: nativeName,
+		nativeName,
+		input: { ...a },
+		dynamic: true
+	};
+}
+/**
+* An SDK tool result is `{ status: 'success', value }` or `{ status: 'error', error }`. The
+* value is passed on as is, except shell output, which becomes its text (as the ACP adapter
+* reports it), and MCP content, which is flattened to text parts.
+*/
+function projectToolResult(toolName, status, result) {
+	const r = record(result);
+	if (status === "error" || r.status !== void 0 && r.status !== "success") {
+		const error = str(r.error) ?? str(record(r.error).message) ?? str(record(r.value).error) ?? (result === void 0 ? `${toolName} failed` : JSON.stringify(result));
+		return {
+			output: error,
+			error
+		};
+	}
+	const value = r.status === "success" ? r.value : result;
+	if (toolName === "bash") {
+		const v = record(value);
+		const stdout = str(v.stdout) ?? "";
+		const stderr = str(v.stderr) ?? "";
+		return { output: stderr ? `${stdout}${stdout.endsWith("\n") || !stdout ? "" : "\n"}${stderr}` : stdout };
+	}
+	if (toolName === "mcp") {
+		const content = record(value).content;
+		if (Array.isArray(content)) return { output: content.map((c) => {
+			const text = record(record(c).text).text ?? record(c).text;
+			return typeof text === "string" ? {
+				type: "text",
+				text
+			} : c;
+		}) };
+	}
+	return { output: value ?? "" };
+}
+//#endregion
+//#region ../harness-cursor-sdk/src/cursor-sdk-stream.ts
+/** Parts that are a step's content, as opposed to the stream's framing. */
+const isContent = (part) => ![
+	"raw",
+	"stream-start",
+	"finish",
+	"finish-step",
+	"error"
+].includes(part.type);
+/** Maps the SDK's counts onto the AI SDK's usage shape, keeping the original under `raw`. */
+function toUsage(usage) {
+	if (!usage) return {
+		inputTokens: {
+			total: void 0,
+			noCache: void 0,
+			cacheRead: void 0,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: void 0,
+			text: void 0,
+			reasoning: void 0
+		}
+	};
+	const noCache = usage.inputTokens;
+	const cacheRead = usage.cacheReadTokens;
+	const cacheWrite = usage.cacheWriteTokens;
+	const output = usage.outputTokens;
+	const reasoning = usage.reasoningTokens;
+	return {
+		inputTokens: {
+			total: noCache === void 0 ? void 0 : noCache + (cacheRead ?? 0) + (cacheWrite ?? 0),
+			noCache,
+			cacheRead,
+			cacheWrite
+		},
+		outputTokens: {
+			total: output,
+			text: output !== void 0 && reasoning !== void 0 ? output - reasoning : void 0,
+			reasoning
+		},
+		raw: { ...usage }
+	};
+}
+/** The model as one id, with its parameters: `composer-2.5[fast=false]`. */
+function modelLabel(model) {
+	if (!model?.id) return void 0;
+	const params = model.params ?? [];
+	return params.length ? `${model.id}[${params.map((p) => `${p.id}=${p.value}`).join(",")}]` : model.id;
+}
+const FINISH = {
+	finished: "stop",
+	error: "error",
+	cancelled: "other"
+};
+/** `webFetch <url>` or `webSearch <query>` for a web tool call, else undefined. */
+function webKey(e) {
+	const p = projectToolCall(e.name ?? "", e.args);
+	if (p.toolName !== "webFetch" && p.toolName !== "webSearch") return void 0;
+	const target = p.input.url ?? p.input.query;
+	return typeof target === "string" ? `${p.toolName} ${target}` : void 0;
+}
+/**
+* Turns the runner's NDJSON for one turn into harness stream parts, in order. Text and
+* thinking arrive as deltas; a thinking event with `thinking_duration_ms` ends its block.
+* Each tool call is reported `running` (maybe more than once) and then `completed` or `error`.
+*/
+var CursorSdkStreamTranslator = class {
+	agentId;
+	/** The last `result` line, for callers that want the SDK's own record of the run. */
+	result;
+	started = false;
+	/** True once the turn's `result` or `error` line (or {@link end}) closed it. */
+	finished = false;
+	sawText = false;
+	block = 0;
+	openText;
+	openReasoning;
+	openTools = /* @__PURE__ */ new Map();
+	/** Calls already reported, so a late duplicate `completed` doesn't open a second one. */
+	seen = /* @__PURE__ */ new Set();
+	/** Web calls the stream itself reported, by id and by tool and target. */
+	streamedWeb = /* @__PURE__ */ new Set();
+	/**
+	* The turn's `usage` event, held until its result line: the runner reports the calls it
+	* recovers after it, and HarnessAgent refuses content after a step's `finish-step`.
+	*/
+	stepUsage;
+	/** Whether the open step has content, which HarnessAgent needs closed before `finish`. */
+	stepHasContent = false;
+	/** Built-in tools this turn may have used with no `tool_call` reported. */
+	unreportedTools = [];
+	workDir;
+	/**
+	* `workDir`: the agent's workspace. Tool paths under it are reported relative to it, as the
+	* ACP adapter reports them; the SDK reports them absolute.
+	*/
+	constructor(options = {}) {
+		this.agentId = options.agentId;
+		this.workDir = options.workDir?.replace(/\/+$/, "");
+	}
+	relative(input) {
+		const prefix = this.workDir ? `${this.workDir}/` : void 0;
+		if (!prefix || typeof input.path !== "string" || !input.path.startsWith(prefix)) return input;
+		return {
+			...input,
+			path: input.path.slice(prefix.length)
+		};
+	}
+	/** Parts for one stdout line. Lines that aren't runner lines are passed through as raw. */
+	push(line) {
+		const trimmed = line.trim();
+		if (!trimmed) return [];
+		let parsed;
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch {
+			return [{
+				type: "raw",
+				rawValue: { unparsed: trimmed }
+			}];
+		}
+		if (this.finished) return [{
+			type: "raw",
+			rawValue: parsed
+		}];
+		const parts = [];
+		switch (parsed.type) {
+			case "init":
+				this.agentId = parsed.agentId ?? this.agentId;
+				this.start(parts, modelLabel(parsed.model));
+				break;
+			case "event":
+				this.start(parts);
+				this.event(parts, parsed.event ?? { type: "unknown" }, parsed.recovered !== void 0);
+				break;
+			case "result":
+				this.start(parts);
+				this.finish(parts, parsed);
+				break;
+			case "error":
+				this.start(parts);
+				this.fail(parts, parsed.message, parsed.code ?? parsed.name ?? "error");
+				break;
+			case "unreported": this.unreportedTools = [.../* @__PURE__ */ new Set([...this.unreportedTools, ...parsed.tools ?? []])];
+		}
+		parts.push({
+			type: "raw",
+			rawValue: parsed
+		});
+		if (parts.some(isContent)) this.stepHasContent = true;
+		return parts;
+	}
+	/** Closes the turn when the runner ends without a result (killed, crashed, aborted). */
+	end(options) {
+		if (this.finished) return [];
+		const parts = [];
+		this.start(parts);
+		this.closeTools(parts, options.aborted ? "aborted" : "interrupted");
+		this.closeBlocks(parts);
+		this.closeStep(parts);
+		if (!options.aborted) {
+			const detail = options.stderr?.trim();
+			parts.push({
+				type: "error",
+				error: /* @__PURE__ */ new Error(`The Cursor SDK runner exited with code ${options.exitCode} before reporting a result${detail ? `: ${detail}` : ""}`)
+			});
+		}
+		this.finished = true;
+		parts.push({
+			type: "finish",
+			finishReason: options.aborted ? {
+				unified: "other",
+				raw: "aborted"
+			} : {
+				unified: "error",
+				raw: `exit ${options.exitCode}`
+			},
+			totalUsage: toUsage(void 0),
+			harnessMetadata: this.unrecovered()
+		});
+		return parts;
+	}
+	start(parts, modelId) {
+		if (this.started) return;
+		this.started = true;
+		parts.push({
+			type: "stream-start",
+			...modelId ? { modelId } : {}
+		});
+	}
+	closeText(parts) {
+		if (this.openText) parts.push({
+			type: "text-end",
+			id: this.openText
+		});
+		this.openText = void 0;
+	}
+	closeReasoning(parts) {
+		if (this.openReasoning) parts.push({
+			type: "reasoning-end",
+			id: this.openReasoning
+		});
+		this.openReasoning = void 0;
+	}
+	closeBlocks(parts) {
+		this.closeText(parts);
+		this.closeReasoning(parts);
+	}
+	closeTools(parts, why) {
+		for (const [toolCallId, call] of this.openTools) parts.push({
+			type: "tool-result",
+			toolCallId,
+			toolName: call.toolName,
+			result: `${call.toolName} ${why}`,
+			isError: true,
+			...call.dynamic ? { dynamic: true } : {}
+		});
+		this.openTools.clear();
+	}
+	event(parts, e, recovered = false) {
+		this.agentId ??= e.agent_id;
+		switch (e.type) {
+			case "thinking":
+				if (e.text) {
+					this.closeText(parts);
+					if (!this.openReasoning) {
+						this.openReasoning = `reasoning-${++this.block}`;
+						parts.push({
+							type: "reasoning-start",
+							id: this.openReasoning
+						});
+					}
+					parts.push({
+						type: "reasoning-delta",
+						id: this.openReasoning,
+						delta: e.text
+					});
+				}
+				if (e.thinking_duration_ms !== void 0) this.closeReasoning(parts);
+				return;
+			case "assistant": {
+				const text = (e.message?.content ?? []).filter((c) => c.type === "text" && typeof c.text === "string").map((c) => c.text).join("");
+				if (!text) return;
+				this.closeReasoning(parts);
+				if (!this.openText) {
+					this.openText = `text-${++this.block}`;
+					parts.push({
+						type: "text-start",
+						id: this.openText
+					});
+				}
+				this.sawText = true;
+				parts.push({
+					type: "text-delta",
+					id: this.openText,
+					delta: text
+				});
+				return;
+			}
+			case "tool_call": {
+				const id = e.call_id;
+				if (!id) return;
+				const web = webKey(e);
+				if (recovered) {
+					if (this.streamedWeb.has(id) || web && this.streamedWeb.has(web)) return;
+				} else if (web) {
+					this.streamedWeb.add(id);
+					this.streamedWeb.add(web);
+				}
+				const status = e.status ?? "running";
+				let call = this.openTools.get(id);
+				if (!call) {
+					if (status !== "running" && this.seen.has(id)) return;
+					this.closeBlocks(parts);
+					const projected = projectToolCall(e.name ?? "unknown", e.args);
+					call = {
+						toolName: projected.toolName,
+						dynamic: projected.dynamic
+					};
+					this.openTools.set(id, call);
+					this.seen.add(id);
+					parts.push({
+						type: "tool-call",
+						toolCallId: id,
+						toolName: projected.toolName,
+						input: JSON.stringify(this.relative(projected.input)),
+						providerExecuted: true,
+						...projected.dynamic ? { dynamic: true } : {},
+						...projected.toolName !== projected.nativeName ? { nativeName: projected.nativeName } : {}
+					});
+				}
+				if (status === "running") return;
+				this.openTools.delete(id);
+				const { output, error } = projectToolResult(call.toolName, status, e.result);
+				parts.push({
+					type: "tool-result",
+					toolCallId: id,
+					toolName: call.toolName,
+					result: output,
+					...error !== void 0 ? { isError: true } : {},
+					...call.dynamic ? { dynamic: true } : {}
+				});
+				return;
+			}
+			case "usage":
+				this.closeBlocks(parts);
+				this.stepUsage = e.usage ?? {};
+				return;
+		}
+	}
+	finish(parts, r) {
+		this.result = r;
+		this.agentId = r.agentId ?? this.agentId;
+		this.closeTools(parts, "unfinished");
+		if (!this.sawText && r.result) {
+			parts.push({
+				type: "text-start",
+				id: "text-result"
+			});
+			parts.push({
+				type: "text-delta",
+				id: "text-result",
+				delta: r.result
+			});
+			parts.push({
+				type: "text-end",
+				id: "text-result"
+			});
+		}
+		this.closeBlocks(parts);
+		this.closeStep(parts, r.usage);
+		const status = r.status ?? "unknown";
+		if (status !== "finished" && status !== "cancelled") parts.push({
+			type: "error",
+			error: new Error(r.error?.message || `The Cursor SDK run ended with status ${status}`)
+		});
+		this.finished = true;
+		parts.push({
+			type: "finish",
+			finishReason: {
+				unified: FINISH[status] ?? "other",
+				raw: status
+			},
+			totalUsage: toUsage(r.usage),
+			harnessMetadata: { cursorSdk: {
+				...r.agentId ? { agentId: r.agentId } : {},
+				...r.runId ? { runId: r.runId } : {},
+				...r.requestId ? { requestId: r.requestId } : {},
+				...r.model ? { model: r.model } : {},
+				...r.durationMs !== void 0 ? { durationMs: r.durationMs } : {},
+				...r.usage ? { usage: { ...r.usage } } : {},
+				...this.unreportedTools.length ? { unreportedTools: [...this.unreportedTools] } : {}
+			} }
+		});
+	}
+	fail(parts, message, raw) {
+		this.closeTools(parts, "interrupted");
+		this.closeBlocks(parts);
+		this.closeStep(parts);
+		parts.push({
+			type: "error",
+			error: new Error(message)
+		});
+		this.finished = true;
+		parts.push({
+			type: "finish",
+			finishReason: {
+				unified: "error",
+				raw
+			},
+			totalUsage: toUsage(void 0),
+			harnessMetadata: this.unrecovered()
+		});
+	}
+	/** The turn's one step, with the `usage` event's counts, else the result's when it has them. */
+	closeStep(parts, resultUsage) {
+		const usage = this.stepUsage ?? resultUsage;
+		if (!usage && !this.stepHasContent && !parts.some(isContent)) return;
+		parts.push({
+			type: "finish-step",
+			finishReason: usage ? {
+				unified: "stop",
+				raw: this.stepUsage ? "turn-ended" : "result"
+			} : {
+				unified: "other",
+				raw: "interrupted"
+			},
+			usage: toUsage(usage)
+		});
+		this.stepUsage = void 0;
+		this.stepHasContent = false;
+	}
+	/** A turn that ended before its result never had its web calls recovered. */
+	unrecovered() {
+		return { cursorSdk: { unreportedTools: Object.values(CURSOR_SDK_RECOVERED_TOOLS) } };
+	}
+};
+//#endregion
+//#region ../harness-cursor-sdk/src/cursor-sdk-harness.ts
+const CURSOR_SDK_HARNESS_ID = "cursor-sdk";
+/** Where harness-placed skills go, under `~/` (the SDK's `user` layer reads `~/.agents/skills`). */
+const CURSOR_SDK_HOME_SKILLS_DIR = ".agents/skills";
+const lifecycleData = z.object({ agentId: z.string().nullable() });
+function promptText(prompt, instructions) {
+	const content = typeof prompt === "string" ? prompt : prompt.content;
+	const text = typeof content === "string" ? content : content.map((part) => {
+		if (part.type !== "text") throw new HarnessCapabilityUnsupportedError({
+			message: `The Cursor SDK adapter takes text prompts only (got a ${part.type} part)`,
+			harnessId: CURSOR_SDK_HARNESS_ID
+		});
+		return part.text;
+	}).join("\n");
+	if (!instructions) return text;
+	return [
+		"<session-guidance>",
+		"This block is operating guidance from the harness, not user-authored content.",
+		"<instructions>",
+		instructions,
+		"</instructions>",
+		"</session-guidance>",
+		text
+	].join("\n");
+}
+const unsupported = (what) => new HarnessCapabilityUnsupportedError({
+	message: `The Cursor SDK adapter has no ${what}`,
+	harnessId: CURSOR_SDK_HARNESS_ID
+});
+const lines = (stream) => createInterface({
+	input: Readable.fromWeb(stream),
+	crlfDelay: Infinity
+});
+function startRunner(proc) {
+	let stderr = "";
+	const drained = (async () => {
+		for await (const line of lines(proc.stderr)) stderr = `${stderr}${line}\n`.slice(-4e3);
+	})().catch(() => {});
+	const runner = {
+		proc,
+		stdout: lines(proc.stdout)[Symbol.asyncIterator](),
+		stderr: async () => {
+			await Promise.race([drained, new Promise((r) => setTimeout(r, 1e3).unref())]);
+			return stderr;
+		},
+		exited: false
+	};
+	Promise.resolve(proc.wait()).then(() => runner.exited = true, () => runner.exited = true);
+	return runner;
+}
+const canBroker = (sandbox) => "addRequestTransformations" in sandbox && typeof sandbox.addRequestTransformations === "function";
+/**
+* Cursor's agent through the Cursor TypeScript SDK's local runtime, as an AI SDK harness. The
+* agent loop runs in a Node process in the sandbox that lives across the session's turns (a new
+* one resumes the agent by id from a JSONL store), so its tools act on the sandbox's files;
+* inference is Cursor's hosted models. The SDK reports token usage for every turn.
+*/
+function createCursorSdk(settings = {}) {
+	return {
+		specificationVersion: "harness-v1",
+		harnessId: CURSOR_SDK_HARNESS_ID,
+		builtinTools: CURSOR_SDK_BUILTIN_TOOLS,
+		lifecycleStateSchema: lifecycleData,
+		getBootstrap: getCursorSdkBootstrap,
+		doStart: (options) => startSession(settings, options)
+	};
+}
+async function startSession(settings, options) {
+	const { sandboxSession: sandbox, sessionWorkDir, sessionId, abortSignal } = options;
+	const credentials = resolveCursorSdkCredentials(settings.auth);
+	let sandboxKey = credentials.apiKey;
+	if (canBroker(sandbox)) {
+		sandboxKey = generateSandboxCredentialPlaceholder();
+		await sandbox.addRequestTransformations(createCursorSdkRequestTransformations({
+			credentials,
+			placeholder: sandboxKey,
+			...options.headers ? { headers: options.headers } : {}
+		}));
+	} else if (settings.requireCredentialBrokering) throw new Error(`The sandbox can't broker ${CURSOR_SDK_CREDENTIAL_ENV} (it has no request transformations), and requireCredentialBrokering is set, so the key stays out of it.`);
+	else warnCredentialBrokeringUnavailable({
+		environment: { [CURSOR_SDK_CREDENTIAL_ENV]: credentials.apiKey },
+		forwardedEnvironment: { [CURSOR_SDK_CREDENTIAL_ENV]: sandboxKey },
+		credentialEnvironmentVariables: [CURSOR_SDK_CREDENTIAL_ENV]
+	});
+	const catalogSetting = settings.modelCatalog ?? "fetch";
+	const catalog = catalogSetting === "fetch" ? await fetchCursorModelCatalog(credentials, abortSignal ? { signal: abortSignal } : {}) : catalogSetting === false ? void 0 : [...catalogSetting];
+	const home = await resolveSandboxHomeDir({
+		sandbox,
+		abortSignal
+	});
+	const stateDir = harnessStateDirectoryPath({ sandboxHomeDir: home });
+	const runnerPath = posix.join(stateDir, CURSOR_SDK_BOOTSTRAP_DIR, CURSOR_SDK_RUNNER_PATH);
+	const sessionDir = harnessSessionDataDirectoryPath({
+		stateDirectory: stateDir,
+		sessionId
+	});
+	const storeDir = posix.join(sessionDir, "agent-store");
+	const resumed = lifecycleData.safeParse(options.resumeFrom?.data);
+	let agentId = resumed.success ? resumed.data.agentId : null;
+	let turns = 0;
+	let runner;
+	let ended = false;
+	const state = () => ({
+		type: "resume-session",
+		harnessId: CURSOR_SDK_HARNESS_ID,
+		specificationVersion: "harness-v1",
+		data: { agentId }
+	});
+	const stopRunner = async () => {
+		const r = runner;
+		runner = void 0;
+		await r?.proc.kill();
+	};
+	const stop = async () => {
+		ended = true;
+		await stopRunner();
+	};
+	return {
+		sessionId,
+		isResume: options.resumeFrom !== void 0,
+		async doPromptTurn(turn) {
+			if (ended) throw new Error("This Cursor SDK session has ended");
+			if (turn.tools.length > 0) throw unsupported("host-executed tools");
+			if (turn.responseFormat?.type === "json") throw unsupported("structured output");
+			const n = ++turns;
+			await writeSkills({
+				sandbox,
+				homePath: home,
+				skillsDir: CURSOR_SDK_HOME_SKILLS_DIR,
+				skills: turn.skills,
+				...turn.abortSignal ? { abortSignal: turn.abortSignal } : {}
+			});
+			const promptFile = posix.join(sessionDir, `prompt-${n}.txt`);
+			await sandbox.writeTextFile({
+				path: promptFile,
+				content: promptText(turn.prompt, turn.instructions),
+				abortSignal: turn.abortSignal
+			});
+			const model = turn.model ? withParams(turn.model, settings.modelParams, catalog) : void 0;
+			const turnFile = posix.join(sessionDir, `turn-${n}.json`);
+			await sandbox.writeTextFile({
+				path: turnFile,
+				content: JSON.stringify({
+					cwd: sessionWorkDir,
+					storeDir,
+					promptFile,
+					agentId: agentId ?? void 0,
+					model,
+					settingSources: settings.settingSources ?? ["project", "user"],
+					sandbox: settings.sdkSandbox === true,
+					sdkVersion: CURSOR_SDK_VERSION,
+					...settings.mcpServers && Object.keys(settings.mcpServers).length > 0 ? { mcpServers: settings.mcpServers } : {}
+				}),
+				abortSignal: turn.abortSignal
+			});
+			await sandbox.writeTextFile({
+				path: posix.join(sessionDir, cursorSdkTurnReady(n)),
+				content: "",
+				abortSignal: turn.abortSignal
+			});
+			if (runner?.exited) runner = void 0;
+			if (!runner) {
+				const env = {
+					...settings.env,
+					[CURSOR_SDK_CREDENTIAL_ENV]: sandboxKey,
+					...catalog ? { [CURSOR_SDK_MODEL_CATALOG_ENV]: JSON.stringify(catalogFor(catalog, turn.model)) } : {}
+				};
+				runner = startRunner(await sandbox.spawn({
+					command: `exec node ${shellQuote(runnerPath)} ${shellQuote(sessionDir)} ${n}`,
+					workingDirectory: sessionWorkDir,
+					env
+				}));
+			}
+			const current = runner;
+			const translator = new CursorSdkStreamTranslator({
+				agentId: agentId ?? void 0,
+				workDir: sessionWorkDir
+			});
+			const emit = (parts) => {
+				for (const part of parts) turn.emit(part);
+			};
+			const onAbort = () => void stopRunner();
+			if (turn.abortSignal?.aborted) onAbort();
+			turn.abortSignal?.addEventListener("abort", onAbort, { once: true });
+			return {
+				submitToolResult: () => Promise.reject(unsupported("host-executed tools")),
+				done: (async () => {
+					try {
+						while (!translator.finished) {
+							const next = await current.stdout.next();
+							if (next.done) break;
+							emit(translator.push(next.value));
+						}
+						if (!translator.finished) {
+							if (runner === current) runner = void 0;
+							const { exitCode } = await current.proc.wait();
+							emit(translator.end({
+								exitCode,
+								stderr: await current.stderr(),
+								aborted: turn.abortSignal?.aborted === true
+							}));
+						}
+					} finally {
+						turn.abortSignal?.removeEventListener("abort", onAbort);
+						agentId = translator.agentId ?? agentId;
+					}
+				})()
+			};
+		},
+		doCompact: () => Promise.reject(unsupported("manual compaction")),
+		doContinueTurn: () => Promise.reject(unsupported("turn continuation")),
+		doSuspendTurn: () => Promise.reject(unsupported("turn suspension")),
+		async doDetach() {
+			await stop();
+			return state();
+		},
+		async doStop() {
+			await stop();
+			return state();
+		},
+		doDestroy: stop
+	};
+}
+/**
+* The model with every parameter set: the ones given, then the rest from the catalog's default
+* variant (the SDK's own choice for an unset parameter), so nothing is left for the SDK to pick.
+*/
+function withParams(id, given, catalog) {
+	const entry = catalog?.find((m) => m.id === id || m.aliases?.includes(id));
+	const variants = Array.isArray(entry?.variants) ? entry.variants : [];
+	const fallback = (variants.find((v) => v.isDefault) ?? variants[0])?.params ?? [];
+	const params = [...Object.entries(given ?? {}).map(([pid, value]) => ({
+		id: pid,
+		value
+	})), ...fallback.filter((p) => !given || !(p.id in given))];
+	return params.length ? {
+		id,
+		params
+	} : { id };
+}
+//#endregion
+export { createCursorSdkRequestTransformations as C, resolveCursorSdkCredentials as E, catalogFor as S, fetchCursorModelCatalog as T, storedShapeProblems as _, toUsage as a, CURSOR_SDK_CREDENTIAL_ENV as b, projectToolResult as c, CURSOR_SDK_RECOVERED_TOOLS as d, CURSOR_SDK_RUNNER as f, getCursorSdkBootstrap as g, cursorSdkInstallScript as h, CursorSdkStreamTranslator as i, CURSOR_SDK_BOOTSTRAP_DIR as l, CURSOR_SDK_VERSION as m, CURSOR_SDK_HOME_SKILLS_DIR as n, CURSOR_SDK_BUILTIN_TOOLS as o, CURSOR_SDK_RUNNER_PATH as p, createCursorSdk as r, projectToolCall as s, CURSOR_SDK_HARNESS_ID as t, CURSOR_SDK_MIN_NODE as u, storedWebCalls as v, cursorSdkEndpoints as w, CURSOR_SDK_MODEL_CATALOG_ENV as x, CURSOR_API_URL as y };
+
+//# sourceMappingURL=src-Cmp-7YrD.js.map