reeval 0.0.1

package/dist/src-D8KYzxBX.js

@@ -0,0 +1,793 @@
+import { posix } from "node:path";
+import { Readable } from "node:stream";
+import { HarnessCapabilityUnsupportedError, commonTool, harnessSessionDataDirectoryPath, harnessStateDirectoryPath } from "@ai-sdk/harness";
+import { createCredentialRequestTransformation, generateSandboxCredentialPlaceholder, isHarnessAuthenticationEnvironment, resolveSandboxHomeDir, shellQuote, warnCredentialBrokeringUnavailable, writeInstructions, writeSkills } from "@ai-sdk/harness/utils";
+import { tool } from "@ai-sdk/provider-utils";
+import { createInterface } from "node:readline";
+import { z } from "zod";
+//#region ../harness-antigravity/src/antigravity-auth.ts
+/** The only credential the adapter uses: a Gemini API key, for the CLI's `gemini` provider. */
+const ANTIGRAVITY_CREDENTIAL_ENV = "GEMINI_API_KEY";
+/** Overrides where the CLI sends Gemini API requests (and so where the key is brokered). */
+const ANTIGRAVITY_BASE_URL_ENV = "GOOGLE_GEMINI_BASE_URL";
+const GEMINI_API_URL = "https://generativelanguage.googleapis.com";
+/** The header the CLI sends the key in. It never puts the key in the query string. */
+const GEMINI_API_KEY_HEADER = "x-goog-api-key";
+function resolveAntigravityCredentials(auth = "auto", hostEnv = process.env) {
+	if (auth !== "auto" && !isHarnessAuthenticationEnvironment(auth)) throw new Error(`Antigravity auth must be 'auto' or an environment object such as { ${ANTIGRAVITY_CREDENTIAL_ENV}: '…' } (got ${JSON.stringify(auth)})`);
+	const env = auth === "auto" ? hostEnv : auth;
+	const apiKey = env[ANTIGRAVITY_CREDENTIAL_ENV];
+	if (!apiKey) throw new Error(`${ANTIGRAVITY_CREDENTIAL_ENV} isn't set, so the Antigravity CLI can't authenticate. It needs a Gemini API key (Google AI Studio).`);
+	const baseUrl = env[ANTIGRAVITY_BASE_URL_ENV];
+	return {
+		apiKey,
+		...baseUrl ? { baseUrl } : {}
+	};
+}
+/**
+* Swaps the sandbox's placeholder for the real key on requests to the Gemini API's host (under
+* the base URL's path, when it has one). The rule is host-wide on purpose: a gateway that also
+* enforces {@link antigravityEndpoints} can then refuse, loudly, a placeholder sent anywhere else.
+*/
+function createAntigravityRequestTransformations({ credentials, placeholder, headers }) {
+	return [createCredentialRequestTransformation({
+		matchUrl: credentials.baseUrl ?? "https://generativelanguage.googleapis.com",
+		matchHeaders: { [GEMINI_API_KEY_HEADER]: placeholder },
+		transformHeaders: {
+			...headers,
+			[GEMINI_API_KEY_HEADER]: credentials.apiKey
+		}
+	})];
+}
+//#endregion
+//#region ../harness-antigravity/src/antigravity-bootstrap.ts
+/** The CLI build the bootstrap installs. Bump it with both checksums from the release. */
+const ANTIGRAVITY_CLI_VERSION = "1.2.11";
+const ANTIGRAVITY_CLI_SHA256 = {
+	x64: "c91c62c5e6fa954f5a7e1d7b9ad417d749db4aa60a4ba0b3d604dec1b645d190",
+	arm64: "01513bc61f9592353045ba801ebb407fbccb8984fcbfde591bc6b681b24e92bc"
+};
+/** Relative to the harness state directory, `$HOME/.ai-sdk-harness`. */
+const ANTIGRAVITY_BOOTSTRAP_DIR = ".harness-bootstrap/antigravity";
+/** The CLI's path relative to the bootstrap directory. */
+const ANTIGRAVITY_CLI_PATH = "bin/agy";
+const RELEASES = "https://github.com/google-antigravity/antigravity-cli/releases/download";
+/**
+* Downloads the pinned release for the sandbox's architecture, checks its sha256 and unpacks
+* the single `antigravity` binary as `bin/agy`. The binary needs glibc (Debian, Ubuntu).
+*/
+function antigravityInstallScript(version = ANTIGRAVITY_CLI_VERSION) {
+	return `set -eu
+case "$(uname -m)" in
+  x86_64|amd64) arch=x64; sha=${ANTIGRAVITY_CLI_SHA256.x64} ;;
+  aarch64|arm64) arch=arm64; sha=${ANTIGRAVITY_CLI_SHA256.arm64} ;;
+  *) echo "The Antigravity CLI has no Linux build for $(uname -m)" >&2; exit 1 ;;
+esac
+curl -fsSL --retry 3 -o agy.tar.gz "${RELEASES}/${version}/agy_cli_linux_$arch.tar.gz"
+echo "$sha  agy.tar.gz" | sha256sum -c - >/dev/null
+rm -rf bin && mkdir bin
+tar -xzf agy.tar.gz -C bin
+mv bin/antigravity bin/agy
+chmod 755 bin/agy
+rm agy.tar.gz
+`;
+}
+async function getAntigravityBootstrap() {
+	return {
+		harnessId: "antigravity",
+		bootstrapDir: ANTIGRAVITY_BOOTSTRAP_DIR,
+		files: [{
+			path: `${ANTIGRAVITY_BOOTSTRAP_DIR}/install.sh`,
+			content: antigravityInstallScript()
+		}],
+		commands: [{ command: "sh install.sh" }]
+	};
+}
+//#endregion
+//#region ../harness-antigravity/src/antigravity-command.ts
+/**
+* `allow-all` skips every approval. The CLI can't ask in print mode, so anything it would ask
+* about is declined: `allow-edits` still edits (`accept-edits`) and `allow-reads` plans only.
+*/
+const PERMISSION_FLAGS = {
+	"allow-all": ["--dangerously-skip-permissions"],
+	"allow-edits": ["--mode", "accept-edits"],
+	"allow-reads": ["--mode", "plan"]
+};
+/**
+* One headless turn: NDJSON events on stdout, the workspace added explicitly (without it, print
+* mode can write into a scratch directory), slash commands off so a prompt starting with `/` is
+* sent as text, and no print timeout (the caller owns cancellation). `-p` comes last.
+*/
+function buildAntigravityCommand(o) {
+	const args = [
+		"--output-format",
+		"stream-json",
+		"--add-dir",
+		o.workDir,
+		"--disable-slash-commands",
+		"--print-timeout",
+		"0",
+		...o.model ? ["--model", o.model] : [],
+		...o.effort ? ["--effort", o.effort] : [],
+		...PERMISSION_FLAGS[o.permissionMode ?? "allow-all"],
+		...o.conversationId ? ["--conversation", o.conversationId] : [],
+		...o.jsonSchemaFile ? ["--json-schema", o.jsonSchemaFile] : []
+	];
+	return `exec ${[o.cli, ...args].map(shellQuote).join(" ")} -p "$(cat ${shellQuote(o.promptFile)})"`;
+}
+//#endregion
+//#region ../harness-antigravity/src/antigravity-tools.ts
+const native = (nativeName, title, toolUseKind) => ({
+	...tool({
+		title,
+		inputSchema: z.looseObject({})
+	}),
+	nativeName,
+	...toolUseKind ? { toolUseKind } : {}
+});
+const ANTIGRAVITY_BUILTIN_TOOLS = {
+	bash: {
+		...commonTool("bash", {
+			nativeName: "run_command",
+			toolUseKind: "bash",
+			inputSchema: z.looseObject({
+				command: z.string(),
+				Cwd: z.string().optional()
+			})
+		}),
+		title: "Run Command"
+	},
+	read: {
+		...commonTool("read", {
+			nativeName: "view_file",
+			toolUseKind: "readonly",
+			inputSchema: z.looseObject({ file_path: z.string() })
+		}),
+		title: "View File"
+	},
+	write: {
+		...commonTool("write", {
+			nativeName: "write_to_file",
+			toolUseKind: "edit",
+			inputSchema: z.looseObject({
+				file_path: z.string(),
+				content: z.string().optional()
+			})
+		}),
+		title: "Write File"
+	},
+	edit: {
+		...commonTool("edit", {
+			nativeName: "replace_file_content",
+			toolUseKind: "edit",
+			inputSchema: z.looseObject({
+				file_path: z.string(),
+				old_string: z.string().optional(),
+				new_string: z.string().optional()
+			})
+		}),
+		title: "Edit File"
+	},
+	grep: {
+		...commonTool("grep", {
+			nativeName: "grep_search",
+			toolUseKind: "readonly",
+			inputSchema: z.looseObject({
+				pattern: z.string(),
+				path: z.string().optional()
+			})
+		}),
+		title: "Grep Search"
+	},
+	glob: {
+		...commonTool("glob", {
+			nativeName: "find_by_name",
+			toolUseKind: "readonly",
+			inputSchema: z.looseObject({ pattern: z.string() })
+		}),
+		title: "Find By Name"
+	},
+	webSearch: {
+		...commonTool("webSearch", {
+			nativeName: "search_web",
+			toolUseKind: "readonly",
+			inputSchema: z.looseObject({ query: z.string() })
+		}),
+		title: "Search Web"
+	},
+	webFetch: {
+		...tool({
+			title: "Read URL",
+			inputSchema: z.looseObject({ url: z.string() })
+		}),
+		nativeName: "read_url_content",
+		toolUseKind: "readonly"
+	},
+	list_dir: native("list_dir", "List Directory", "readonly"),
+	command_status: native("command_status", "Command Status", "readonly"),
+	send_command_input: native("send_command_input", "Send Command Input", "bash"),
+	call_mcp_tool: native("call_mcp_tool", "Call MCP Tool"),
+	generate_image: native("generate_image", "Generate Image"),
+	invoke_subagent: native("invoke_subagent", "Invoke Subagent"),
+	browser_subagent: native("browser_subagent", "Browser Subagent"),
+	notebook_edit: native("notebook_edit", "Edit Notebook", "edit"),
+	ask_question: native("ask_question", "Ask Question")
+};
+const str = (value) => typeof value === "string" ? value : void 0;
+/** Native edit tools that all surface as `edit`, since the key must be unique. */
+const EDIT_TOOLS = /* @__PURE__ */ new Set([
+	"replace_file_content",
+	"multi_replace_file_content",
+	"sed_file"
+]);
+const BY_NATIVE_NAME = new Map(Object.entries(ANTIGRAVITY_BUILTIN_TOOLS).map(([key, t]) => [t.nativeName ?? key, key]));
+/** Maps a native tool call to its catalog name, adding the common-schema fields it implies. */
+function projectToolCall(nativeName, parameters = {}) {
+	const p = parameters;
+	const common = (toolName, extra) => ({
+		toolName,
+		nativeName,
+		input: {
+			...p,
+			...extra
+		},
+		dynamic: false
+	});
+	if (EDIT_TOOLS.has(nativeName)) return common("edit", { file_path: str(p.TargetFile) ?? str(p.AbsolutePath) ?? "" });
+	const server = str(p.ServerName);
+	const mcpTool = str(p.ToolName);
+	if (nativeName === "call_mcp_tool" && server && mcpTool) return {
+		toolName: `mcp__${server}__${mcpTool}`,
+		nativeName,
+		input: { ...p },
+		dynamic: true
+	};
+	switch (nativeName) {
+		case "run_command": return common("bash", { command: str(p.CommandLine) ?? str(p.command) ?? "" });
+		case "view_file": return common("read", { file_path: str(p.AbsolutePath) ?? str(p.TargetFile) ?? "" });
+		case "write_to_file": return common("write", { file_path: str(p.TargetFile) ?? "" });
+		case "grep_search": return common("grep", {
+			pattern: str(p.Query) ?? str(p.Pattern) ?? str(p.query) ?? "",
+			...str(p.SearchPath) ? { path: p.SearchPath } : {}
+		});
+		case "find_by_name": return common("glob", { pattern: str(p.Pattern) ?? str(p.pattern) ?? "" });
+		case "search_web": return common("webSearch", { query: str(p.query) ?? str(p.Query) ?? "" });
+		case "read_url_content": return common("webFetch", { url: str(p.Url) ?? str(p.url) ?? "" });
+	}
+	const key = BY_NATIVE_NAME.get(nativeName);
+	return key ? {
+		toolName: key,
+		nativeName,
+		input: { ...p },
+		dynamic: false
+	} : {
+		toolName: nativeName,
+		nativeName,
+		input: { ...p },
+		dynamic: true
+	};
+}
+//#endregion
+//#region ../harness-antigravity/src/antigravity-stream.ts
+/** Maps the CLI's counts onto the AI SDK's usage shape, keeping the original under `raw`. */
+function toUsage(usage) {
+	const noCache = usage?.input_tokens;
+	const cacheRead = usage?.cache_read_tokens;
+	const output = usage?.output_tokens;
+	const reasoning = usage?.thinking_tokens;
+	return {
+		inputTokens: {
+			total: noCache !== void 0 ? noCache + (cacheRead ?? 0) : void 0,
+			noCache,
+			cacheRead,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: output,
+			text: output !== void 0 && reasoning !== void 0 ? output - reasoning : void 0,
+			reasoning
+		},
+		...usage ? { raw: { ...usage } } : {}
+	};
+}
+const FINISH = {
+	SUCCESS: "stop",
+	ERROR: "error"
+};
+const TERMINAL_TOOL_STATES = /* @__PURE__ */ new Set([
+	"DONE",
+	"ERROR",
+	"CANCELED",
+	"CANCELLED"
+]);
+/**
+* Turns one `agy` process's NDJSON into harness stream parts, in order. The CLI reports no
+* tool-call ids, so a call is identified by its conversation and step index.
+*/
+var AntigravityStreamTranslator = class {
+	conversationId;
+	started = false;
+	finished = false;
+	sawText = false;
+	/**
+	* The reply step being streamed, held until agy moves on: an `error_message` step next means its
+	* model call failed (agy retries it), so its partial text isn't the reply.
+	*/
+	reply;
+	/**
+	* A model call agy reported failed, held until it's known whether agy retried it (another step
+	* follows) or gave up (the result, whose error is the turn's).
+	*/
+	failure;
+	retried = false;
+	openTools = /* @__PURE__ */ new Map();
+	pendingStep;
+	stepUsage = false;
+	turn;
+	constructor(options) {
+		this.turn = options.turn;
+		this.conversationId = options.conversationId;
+	}
+	/** Parts for one stdout line. Lines that aren't JSON events are passed through as raw. */
+	push(line) {
+		const trimmed = line.trim();
+		if (!trimmed) return [];
+		let event;
+		try {
+			event = JSON.parse(trimmed);
+		} catch {
+			return [{
+				type: "raw",
+				rawValue: { unparsed: trimmed }
+			}];
+		}
+		if (this.finished) return [{
+			type: "raw",
+			rawValue: event
+		}];
+		const parts = [];
+		if (event.event === "init") {
+			this.conversationId = event.conversation_id ?? this.conversationId;
+			this.start(parts, event.init?.model);
+		} else if (event.event === "step_update" && event.step_update) {
+			this.start(parts);
+			this.step(parts, event.step_update);
+		} else if (event.event === "result") {
+			this.start(parts);
+			this.result(parts, event.result ?? {});
+		}
+		parts.push({
+			type: "raw",
+			rawValue: event
+		});
+		return parts;
+	}
+	/** Closes the turn when the process ends without a `result` (killed, crashed, aborted). */
+	end(options) {
+		if (this.finished) return [];
+		const parts = [];
+		this.start(parts);
+		for (const call of this.openTools.values()) parts.push(this.toolResult(call, `${call.nativeName} ${options.aborted ? "aborted" : "interrupted"}`));
+		this.openTools.clear();
+		this.closeBlocks(parts);
+		if (!options.aborted) {
+			const detail = options.stderr?.trim();
+			parts.push({
+				type: "error",
+				error: /* @__PURE__ */ new Error(`The Antigravity CLI 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)
+		});
+		return parts;
+	}
+	start(parts, modelId) {
+		if (this.started) return;
+		this.started = true;
+		parts.push({
+			type: "stream-start",
+			...modelId ? { modelId } : {}
+		});
+	}
+	id(step) {
+		return `agy-${this.conversationId ?? `turn${this.turn}`}-${step}`;
+	}
+	toolResult(call, error, output = "") {
+		return {
+			type: "tool-result",
+			toolCallId: call.toolCallId,
+			toolName: call.toolName,
+			result: error ?? output,
+			...error !== void 0 ? { isError: true } : {},
+			...call.dynamic ? { dynamic: true } : {}
+		};
+	}
+	flushStep(parts, next) {
+		if (!this.pendingStep) return;
+		parts.push({
+			type: "finish-step",
+			finishReason: {
+				unified: next,
+				raw: "agent_response"
+			},
+			usage: toUsage(this.pendingStep)
+		});
+		this.pendingStep = void 0;
+	}
+	closeBlocks(parts) {
+		this.settleReply(parts);
+		this.settleFailure(parts, false);
+		this.flushStep(parts, "stop");
+	}
+	/** The held reply stood: its text goes out, and its usage ends its step. */
+	settleReply(parts) {
+		const r = this.reply;
+		if (!r) return;
+		this.reply = void 0;
+		if (r.deltas.length) {
+			this.flushStep(parts, "stop");
+			const id = `text-${r.index}`;
+			parts.push({
+				type: "text-start",
+				id
+			});
+			for (const delta of r.deltas) parts.push({
+				type: "text-delta",
+				id,
+				delta
+			});
+			parts.push({
+				type: "text-end",
+				id
+			});
+			this.sawText = true;
+		}
+		if (r.usage) {
+			this.flushStep(parts, "stop");
+			this.pendingStep = r.usage;
+			this.stepUsage = true;
+		}
+	}
+	/** A model call agy reports failed (`error_message`): its partial text isn't the reply. */
+	failReply(parts) {
+		this.settleFailure(parts, true);
+		const usage = this.reply?.usage;
+		this.reply = void 0;
+		this.failure = usage ? { usage } : {};
+	}
+	/**
+	* The held failure's step, with the tokens it spent: failed (`error`) if agy retried the call,
+	* else ended plainly, since the result's error already fails the turn.
+	*/
+	settleFailure(parts, retried) {
+		const f = this.failure;
+		if (!f) return;
+		this.failure = void 0;
+		this.flushStep(parts, "stop");
+		if (retried) this.retried = true;
+		if (!retried && !f.usage) return;
+		if (f.usage) this.stepUsage = true;
+		parts.push({
+			type: "finish-step",
+			finishReason: {
+				unified: retried ? "error" : "other",
+				raw: "error_message"
+			},
+			usage: toUsage(f.usage)
+		});
+	}
+	step(parts, s) {
+		const index = s.step_index ?? -1;
+		this.conversationId ??= s.conversation_id;
+		if (s.step_type === "agent_response") {
+			this.settleFailure(parts, true);
+			if (this.reply && this.reply.index !== index) this.settleReply(parts);
+			this.reply ??= {
+				index,
+				deltas: []
+			};
+			if (s.text_delta) this.reply.deltas.push(s.text_delta);
+			if (s.state !== "ACTIVE" && s.usage) this.reply.usage = s.usage;
+			return;
+		}
+		if (s.step_type === "error_message") {
+			this.failReply(parts);
+			return;
+		}
+		this.settleReply(parts);
+		if (s.step_type !== "user_input") this.settleFailure(parts, true);
+		if (s.step_type === "tool") {
+			this.flushStep(parts, "tool-calls");
+			const info = s.tool_info ?? {};
+			const nativeName = info.name ?? s.tool_name ?? "unknown";
+			let call = this.openTools.get(index);
+			if (!call) {
+				const projected = projectToolCall(nativeName, info.parameters);
+				call = {
+					...projected,
+					toolCallId: this.id(index)
+				};
+				this.openTools.set(index, call);
+				parts.push({
+					type: "tool-call",
+					toolCallId: call.toolCallId,
+					toolName: call.toolName,
+					input: JSON.stringify(projected.input),
+					providerExecuted: true,
+					...call.dynamic ? { dynamic: true } : {},
+					...call.toolName !== nativeName ? { nativeName } : {}
+				});
+			}
+			if (s.state && TERMINAL_TOOL_STATES.has(s.state)) {
+				this.openTools.delete(index);
+				const failed = s.state !== "DONE" || info.error !== void 0;
+				parts.push(this.toolResult(call, failed ? info.error?.message ?? `${nativeName} ${s.state.toLowerCase()}` : void 0, info.output ?? ""));
+			}
+		}
+	}
+	result(parts, r) {
+		this.conversationId = r.conversation_id || this.conversationId;
+		this.settleReply(parts);
+		if (!this.sawText && !this.retried && !this.failure && r.response) {
+			parts.push({
+				type: "text-start",
+				id: "text-result"
+			});
+			parts.push({
+				type: "text-delta",
+				id: "text-result",
+				delta: r.response
+			});
+			parts.push({
+				type: "text-end",
+				id: "text-result"
+			});
+		}
+		this.closeBlocks(parts);
+		if (!this.stepUsage && r.usage) parts.push({
+			type: "finish-step",
+			finishReason: {
+				unified: "stop",
+				raw: "result"
+			},
+			usage: toUsage(r.usage)
+		});
+		const status = r.status ?? "UNKNOWN";
+		if (status !== "SUCCESS") parts.push({
+			type: "error",
+			error: new Error(r.error || `The Antigravity CLI ended the turn with status ${status}`)
+		});
+		this.finished = true;
+		parts.push({
+			type: "finish",
+			finishReason: {
+				unified: FINISH[status] ?? "other",
+				raw: status
+			},
+			totalUsage: toUsage(r.usage),
+			...r.structured_output !== void 0 ? { harnessMetadata: { antigravity: { structuredOutput: r.structured_output } } } : {}
+		});
+	}
+};
+//#endregion
+//#region ../harness-antigravity/src/antigravity-harness.ts
+const ANTIGRAVITY_HARNESS_ID = "antigravity";
+/** Where the CLI reads home skills (1.2.11; its docs' `~/.gemini/antigravity-cli/skills` isn't read). */
+const ANTIGRAVITY_HOME_SKILLS_DIR = ".gemini/config/skills";
+/** Always-on global rules; `instructions` are appended here. */
+const ANTIGRAVITY_INSTRUCTIONS_FILE = ".gemini/GEMINI.md";
+const ANTIGRAVITY_MCP_CONFIG_FILE = ".gemini/config/mcp_config.json";
+const ANTIGRAVITY_SETTINGS_FILE = ".gemini/antigravity-cli/settings.json";
+const lifecycleData = z.object({ conversationId: z.string().nullable() });
+function promptText(prompt) {
+	if (typeof prompt === "string") return prompt;
+	const { content } = prompt;
+	if (typeof content === "string") return content;
+	return content.map((part) => {
+		if (part.type !== "text") throw new HarnessCapabilityUnsupportedError({
+			message: `The Antigravity CLI takes text prompts only (got a ${part.type} part)`,
+			harnessId: ANTIGRAVITY_HARNESS_ID
+		});
+		return part.text;
+	}).join("\n");
+}
+const unsupported = (what) => new HarnessCapabilityUnsupportedError({
+	message: `The Antigravity CLI's print mode has no ${what}`,
+	harnessId: ANTIGRAVITY_HARNESS_ID
+});
+const lines = (stream) => createInterface({
+	input: Readable.fromWeb(stream),
+	crlfDelay: Infinity
+});
+async function tail(stream, max = 4e3) {
+	let text = "";
+	for await (const line of lines(stream)) text = `${text}${line}\n`.slice(-max);
+	return text;
+}
+const canBroker = (sandbox) => "addRequestTransformations" in sandbox && typeof sandbox.addRequestTransformations === "function";
+/**
+* The Antigravity CLI (`agy`) as an AI SDK harness. It has no ACP mode, so each turn is one
+* `agy -p … --output-format stream-json` process, resumed with `--conversation`, and its NDJSON
+* is translated into harness stream parts. Only a Gemini API key authenticates it.
+*/
+function createAntigravity(settings = {}) {
+	return {
+		specificationVersion: "harness-v1",
+		harnessId: ANTIGRAVITY_HARNESS_ID,
+		builtinTools: ANTIGRAVITY_BUILTIN_TOOLS,
+		lifecycleStateSchema: lifecycleData,
+		getBootstrap: getAntigravityBootstrap,
+		doStart: (options) => startSession(settings, options)
+	};
+}
+async function startSession(settings, options) {
+	const { sandboxSession: sandbox, sessionWorkDir, sessionId, abortSignal } = options;
+	const credentials = resolveAntigravityCredentials(settings.auth);
+	let sandboxKey = credentials.apiKey;
+	if (canBroker(sandbox)) {
+		sandboxKey = generateSandboxCredentialPlaceholder();
+		await sandbox.addRequestTransformations(createAntigravityRequestTransformations({
+			credentials,
+			placeholder: sandboxKey,
+			...options.headers ? { headers: options.headers } : {}
+		}));
+	} else if (settings.requireCredentialBrokering) throw new Error(`The sandbox can't broker ${ANTIGRAVITY_CREDENTIAL_ENV} (it has no request transformations), and requireCredentialBrokering is set, so the key stays out of it.`);
+	else warnCredentialBrokeringUnavailable({
+		environment: { [ANTIGRAVITY_CREDENTIAL_ENV]: credentials.apiKey },
+		forwardedEnvironment: { [ANTIGRAVITY_CREDENTIAL_ENV]: sandboxKey },
+		credentialEnvironmentVariables: [ANTIGRAVITY_CREDENTIAL_ENV]
+	});
+	const home = await resolveSandboxHomeDir({
+		sandbox,
+		abortSignal
+	});
+	const stateDir = harnessStateDirectoryPath({ sandboxHomeDir: home });
+	const cli = posix.join(stateDir, ANTIGRAVITY_BOOTSTRAP_DIR, ANTIGRAVITY_CLI_PATH);
+	const sessionDir = harnessSessionDataDirectoryPath({
+		stateDirectory: stateDir,
+		sessionId
+	});
+	const write = (file, content) => sandbox.writeTextFile({
+		path: posix.join(home, file),
+		content,
+		abortSignal
+	});
+	await write(ANTIGRAVITY_SETTINGS_FILE, `${JSON.stringify({
+		enableTelemetry: false,
+		...settings.settings,
+		modelProvider: "gemini"
+	}, null, 2)}\n`);
+	if (settings.mcpServers && Object.keys(settings.mcpServers).length > 0) await write(ANTIGRAVITY_MCP_CONFIG_FILE, `${JSON.stringify({ mcpServers: settings.mcpServers }, null, 2)}\n`);
+	const env = {
+		...settings.env,
+		[ANTIGRAVITY_CREDENTIAL_ENV]: sandboxKey,
+		AGY_CLI_DISABLE_AUTO_UPDATE: "true",
+		...credentials.baseUrl ? { [ANTIGRAVITY_BASE_URL_ENV]: credentials.baseUrl } : {}
+	};
+	const resumed = lifecycleData.safeParse(options.resumeFrom?.data);
+	let conversationId = resumed.success ? resumed.data.conversationId : null;
+	let turns = 0;
+	let running;
+	let ended = false;
+	const state = () => ({
+		type: "resume-session",
+		harnessId: ANTIGRAVITY_HARNESS_ID,
+		specificationVersion: "harness-v1",
+		data: { conversationId }
+	});
+	const stop = async () => {
+		ended = true;
+		await running?.kill();
+		running = void 0;
+	};
+	return {
+		sessionId,
+		isResume: options.resumeFrom !== void 0,
+		async doPromptTurn(turn) {
+			if (ended) throw new Error("This Antigravity session has ended");
+			if (turn.tools.length > 0) throw unsupported("host-executed tools");
+			const n = ++turns;
+			await writeSkills({
+				sandbox,
+				homePath: home,
+				skillsDir: ANTIGRAVITY_HOME_SKILLS_DIR,
+				skills: turn.skills,
+				...turn.abortSignal ? { abortSignal: turn.abortSignal } : {}
+			});
+			await writeInstructions({
+				sandbox,
+				homePath: home,
+				instructionsFile: ANTIGRAVITY_INSTRUCTIONS_FILE,
+				...turn.instructions !== void 0 ? { instructions: turn.instructions } : {},
+				...turn.abortSignal ? { abortSignal: turn.abortSignal } : {}
+			});
+			const promptFile = posix.join(sessionDir, `prompt-${n}.txt`);
+			await sandbox.writeTextFile({
+				path: promptFile,
+				content: promptText(turn.prompt),
+				abortSignal: turn.abortSignal
+			});
+			let jsonSchemaFile;
+			if (turn.responseFormat?.type === "json" && turn.responseFormat.schema) {
+				jsonSchemaFile = posix.join(sessionDir, `schema-${n}.json`);
+				await sandbox.writeTextFile({
+					path: jsonSchemaFile,
+					content: JSON.stringify(turn.responseFormat.schema),
+					abortSignal: turn.abortSignal
+				});
+			}
+			const command = buildAntigravityCommand({
+				cli,
+				workDir: sessionWorkDir,
+				promptFile,
+				model: turn.model,
+				effort: settings.effort,
+				permissionMode: options.permissionMode,
+				conversationId: conversationId ?? void 0,
+				jsonSchemaFile
+			});
+			const translator = new AntigravityStreamTranslator({
+				turn: n,
+				conversationId: conversationId ?? void 0
+			});
+			const emit = (parts) => {
+				for (const part of parts) turn.emit(part);
+			};
+			const proc = await sandbox.spawn({
+				command,
+				workingDirectory: sessionWorkDir,
+				env,
+				...turn.abortSignal ? { abortSignal: turn.abortSignal } : {}
+			});
+			running = proc;
+			const onAbort = () => void proc.kill();
+			turn.abortSignal?.addEventListener("abort", onAbort, { once: true });
+			return {
+				submitToolResult: () => Promise.reject(unsupported("host-executed tools")),
+				done: (async () => {
+					const stderr = tail(proc.stderr).catch(() => "");
+					try {
+						for await (const line of lines(proc.stdout)) emit(translator.push(line));
+						const { exitCode } = await proc.wait();
+						emit(translator.end({
+							exitCode,
+							stderr: await stderr,
+							aborted: turn.abortSignal?.aborted === true
+						}));
+					} finally {
+						turn.abortSignal?.removeEventListener("abort", onAbort);
+						if (running === proc) running = void 0;
+						conversationId = translator.conversationId ?? conversationId;
+					}
+				})()
+			};
+		},
+		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
+	};
+}
+//#endregion
+export { resolveAntigravityCredentials as C, createAntigravityRequestTransformations as S, getAntigravityBootstrap as _, ANTIGRAVITY_SETTINGS_FILE as a, GEMINI_API_KEY_HEADER as b, toUsage as c, buildAntigravityCommand as d, ANTIGRAVITY_BOOTSTRAP_DIR as f, antigravityInstallScript as g, ANTIGRAVITY_CLI_VERSION as h, ANTIGRAVITY_MCP_CONFIG_FILE as i, ANTIGRAVITY_BUILTIN_TOOLS as l, ANTIGRAVITY_CLI_SHA256 as m, ANTIGRAVITY_HOME_SKILLS_DIR as n, createAntigravity as o, ANTIGRAVITY_CLI_PATH as p, ANTIGRAVITY_INSTRUCTIONS_FILE as r, AntigravityStreamTranslator as s, ANTIGRAVITY_HARNESS_ID as t, projectToolCall as u, ANTIGRAVITY_BASE_URL_ENV as v, GEMINI_API_URL as x, ANTIGRAVITY_CREDENTIAL_ENV as y };
+
+//# sourceMappingURL=src-D8KYzxBX.js.map