reeval 0.0.1

package/dist/dist-BZXYHN2X.js

@@ -0,0 +1,1673 @@
+import { l as ownFileURL } from "./root-CFDjpWuc.js";
+import { dirname, join, posix, resolve } from "path";
+import { HARNESS_V1_BUILTIN_TOOLS, HarnessCapabilityUnsupportedError, commonTool, harnessSessionDataDirectoryPath, harnessStateDirectoryPath, harnessV1BridgeInboundCommandSchemas, harnessV1BridgeOutboundMessageSchema, harnessV1BridgeStartBaseSchema, harnessV1DiagnosticFromBridgeFrame } from "@ai-sdk/harness";
+import { SandboxChannel, applyCredentialForwarding, classifyDiskLog, createBridgeErrorHandler, createBridgeStartupError, createBridgeToken, createCredentialRequestTransformation, createReadBridgeAsset, createSandboxCredentialEnvironment, drainBridgeProcessStream, experimental_createBridgeUserMessageSubmitter, forwardBridgeProcessStream, getAiGatewayAuthFromEnv, getRestrictedSandboxSession, isAccessTokenExpiringSoon, isHarnessAuthenticationEnvironment, isMacOS, markBridgeStarting, readMacOSKeychainPassword, refreshOAuthAccessToken, resolveSandboxHomeDir, shellQuote, shouldResolveNativeSubscription, sleep, waitForBridgeReady, warnCredentialBrokeringUnavailable, withBridgeToken, writeSkills } from "@ai-sdk/harness/utils";
+import { isRecord, safeParseJSON, tool } from "@ai-sdk/provider-utils";
+import { WebSocket } from "ws";
+import { z } from "zod/v4";
+import { execFileSync } from "child_process";
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
+//#region ../../node_modules/.pnpm/@ai-sdk+harness-claude-code@1.0.128_patch_hash=5d1c985cccfd5adf255e05536c0c2bf570cb49aa_cafe426571bfb8cfcbbfa8ad488f9b8a/node_modules/@ai-sdk/harness-claude-code/dist/index.js
+var readBridgeAsset = createReadBridgeAsset({
+	"package.json": ownFileURL("dist/bridge/package.json"),
+	"pnpm-lock.yaml": ownFileURL("dist/bridge/pnpm-lock.yaml"),
+	"pnpm-workspace.yaml": ownFileURL("dist/bridge/pnpm-workspace.yaml"),
+	"index.mjs": ownFileURL("dist/bridge/index.mjs")
+});
+var CLAUDE_CODE_BOOTSTRAP_DIR = ".harness-bootstrap/claude-code";
+var cachedBootstrap;
+async function getClaudeCodeBootstrap() {
+	if (cachedBootstrap != null) return cachedBootstrap;
+	const [pkg, lock, workspace, bridge] = await Promise.all([
+		readBridgeAsset("package.json"),
+		readBridgeAsset("pnpm-lock.yaml"),
+		readBridgeAsset("pnpm-workspace.yaml"),
+		readBridgeAsset("index.mjs")
+	]);
+	cachedBootstrap = {
+		harnessId: "claude-code",
+		bootstrapDir: CLAUDE_CODE_BOOTSTRAP_DIR,
+		files: [
+			{
+				path: `${CLAUDE_CODE_BOOTSTRAP_DIR}/package.json`,
+				content: pkg
+			},
+			{
+				path: `${CLAUDE_CODE_BOOTSTRAP_DIR}/pnpm-lock.yaml`,
+				content: lock
+			},
+			{
+				path: `${CLAUDE_CODE_BOOTSTRAP_DIR}/pnpm-workspace.yaml`,
+				content: workspace
+			},
+			{
+				path: `${CLAUDE_CODE_BOOTSTRAP_DIR}/bridge.mjs`,
+				content: bridge
+			}
+		],
+		commands: [{ command: "pnpm install --frozen-lockfile --store-dir .pnpm-store" }, { command: "./node_modules/.bin/claude --version" }]
+	};
+	return cachedBootstrap;
+}
+var CLAUDE_CODE_CREDENTIAL_ENVIRONMENT_VARIABLES = [
+	"AI_GATEWAY_API_KEY",
+	"ANTHROPIC_API_KEY",
+	"ANTHROPIC_AUTH_TOKEN",
+	"CLAUDE_CODE_OAUTH_TOKEN"
+];
+function createClaudeCodeRequestTransformations({ env: environment, sandboxEnv: sandboxEnvironment, auth: authenticationMode }) {
+	const matchUrl = authenticationMode === "ai-gateway" ? environment.ANTHROPIC_BASE_URL : environment.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com";
+	const transformations = [];
+	if (environment.ANTHROPIC_API_KEY != null && sandboxEnvironment.ANTHROPIC_API_KEY != null) transformations.push(createCredentialRequestTransformation({
+		matchUrl,
+		matchHeaders: { "x-api-key": sandboxEnvironment.ANTHROPIC_API_KEY },
+		transformHeaders: { "x-api-key": environment.ANTHROPIC_API_KEY }
+	}));
+	if (environment.ANTHROPIC_AUTH_TOKEN != null && sandboxEnvironment.ANTHROPIC_AUTH_TOKEN != null) transformations.push(createCredentialRequestTransformation({
+		matchUrl,
+		matchHeaders: { Authorization: `Bearer ${sandboxEnvironment.ANTHROPIC_AUTH_TOKEN}` },
+		transformHeaders: { Authorization: `Bearer ${environment.ANTHROPIC_AUTH_TOKEN}` }
+	}));
+	return transformations;
+}
+function resolveClaudeCodeEnv(auth, processEnv = process.env, options = {}) {
+	const suppliedEnvironment = isHarnessAuthenticationEnvironment(auth);
+	const authenticationEnvironment = suppliedEnvironment ? auth : processEnv;
+	const readApiKey = suppliedEnvironment || auth === "direct" ? () => void 0 : options.readApiKeyHelper ?? readApiKeyHelper;
+	if (auth === "direct") return pickAnthropic({
+		processEnv: authenticationEnvironment,
+		readApiKey
+	});
+	const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({ env: authenticationEnvironment });
+	if (auth === "ai-gateway" || gatewayAuthFromEnv.apiKey) return pickGateway({ gatewayAuthFromEnv });
+	return pickAnthropic({
+		processEnv: authenticationEnvironment,
+		readApiKey
+	});
+}
+function resolveClaudeCodeAuthenticationMode(auth, processEnv = process.env) {
+	if (isHarnessAuthenticationEnvironment(auth)) return getAiGatewayAuthFromEnv({ env: auth }).apiKey ? "ai-gateway" : "direct";
+	if (auth === "direct") return "direct";
+	if (auth === "ai-gateway") return "ai-gateway";
+	return getAiGatewayAuthFromEnv({ env: processEnv }).apiKey ? "ai-gateway" : "direct";
+}
+function pickAnthropic({ processEnv, readApiKey }) {
+	const env = {};
+	const helperKey = readApiKey();
+	const apiKey = processEnv.ANTHROPIC_API_KEY ?? helperKey;
+	const authToken = processEnv.ANTHROPIC_AUTH_TOKEN ?? helperKey;
+	const oauthToken = processEnv.CLAUDE_CODE_OAUTH_TOKEN;
+	if (apiKey) env.ANTHROPIC_API_KEY = apiKey;
+	if (authToken) env.ANTHROPIC_AUTH_TOKEN = authToken;
+	if (oauthToken) env.CLAUDE_CODE_OAUTH_TOKEN = oauthToken;
+	const baseUrl = processEnv.ANTHROPIC_BASE_URL;
+	if (baseUrl) env.ANTHROPIC_BASE_URL = baseUrl;
+	return env;
+}
+function readApiKeyHelper() {
+	const home = homedir();
+	if (!home) return void 0;
+	let raw;
+	try {
+		raw = readFileSync(join(home, ".claude", "settings.json"), "utf8");
+	} catch {
+		return;
+	}
+	let settings;
+	try {
+		settings = JSON.parse(raw);
+	} catch {
+		return;
+	}
+	const command = settings.apiKeyHelper;
+	if (typeof command !== "string" || command.length === 0) return void 0;
+	try {
+		const trimmed = execFileSync("sh", ["-c", command], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+		return trimmed.length > 0 ? trimmed : void 0;
+	} catch {
+		return;
+	}
+}
+function pickGateway({ gatewayAuthFromEnv }) {
+	const apiKey = gatewayAuthFromEnv.apiKey;
+	const baseUrl = gatewayAuthFromEnv.baseUrl;
+	const env = {};
+	if (apiKey) {
+		env.AI_GATEWAY_API_KEY = apiKey;
+		env.ANTHROPIC_API_KEY = apiKey;
+	}
+	env.AI_GATEWAY_BASE_URL = baseUrl;
+	env.ANTHROPIC_BASE_URL = baseUrl;
+	return env;
+}
+var CLAUDE_TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+var CLAUDE_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+function createClaudeCodeSubscriptionRequestTransformations({ env: environment, sandboxEnv: sandboxEnvironment, auth: authenticationMode }) {
+	if (environment.CLAUDE_CODE_OAUTH_TOKEN == null || sandboxEnvironment.CLAUDE_CODE_OAUTH_TOKEN == null) return [];
+	return [createCredentialRequestTransformation({
+		matchUrl: authenticationMode === "ai-gateway" ? environment.ANTHROPIC_BASE_URL : environment.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com",
+		matchHeaders: { Authorization: `Bearer ${sandboxEnvironment.CLAUDE_CODE_OAUTH_TOKEN}` },
+		transformHeaders: { Authorization: `Bearer ${environment.CLAUDE_CODE_OAUTH_TOKEN}` }
+	})];
+}
+async function resolveClaudeCodeAuthentication({ auth, processEnv = process.env, options = {}, readSubscription = readClaudeCodeSubscription }) {
+	const environmentWithoutHelper = resolveClaudeCodeEnv(auth, processEnv, { readApiKeyHelper: () => void 0 });
+	if (isHarnessAuthenticationEnvironment(auth)) return environmentWithoutHelper;
+	if (!shouldResolveNativeSubscription({
+		auth,
+		env: environmentWithoutHelper,
+		hasDirectCredential: environmentWithoutHelper.ANTHROPIC_API_KEY != null || environmentWithoutHelper.ANTHROPIC_AUTH_TOKEN != null || environmentWithoutHelper.CLAUDE_CODE_OAUTH_TOKEN != null
+	})) return environmentWithoutHelper;
+	return await readSubscription() ?? resolveClaudeCodeEnv(auth, processEnv, options);
+}
+async function readClaudeCodeSubscription({ env = process.env, homeDirectory = homedir(), platform = process.platform, fetch } = {}) {
+	const configDirectory = resolve(env.CLAUDE_CONFIG_DIR ?? join(homeDirectory, ".claude"));
+	const stored = await readClaudeCredentialStore({
+		credentialPath: join(configDirectory, ".credentials.json"),
+		homeDirectory,
+		configDirectory,
+		platform
+	});
+	if (stored == null) return void 0;
+	const oauth = getClaudeOAuthCredential({ value: stored.value });
+	if (oauth == null) return void 0;
+	const { accessToken, refreshToken, expiresAt } = oauth;
+	let resolvedAccessToken = accessToken;
+	if (isAccessTokenExpiringSoon({ expiresAt })) {
+		const refreshed = await refreshOAuthAccessToken({
+			tokenUrl: CLAUDE_TOKEN_URL,
+			clientId: CLAUDE_CLIENT_ID,
+			refreshToken,
+			requestFormat: "json",
+			...fetch == null ? {} : { fetch }
+		});
+		resolvedAccessToken = refreshed.accessToken;
+		await stored.write({
+			...stored.value,
+			claudeAiOauth: {
+				...oauth,
+				accessToken: refreshed.accessToken,
+				refreshToken: refreshed.refreshToken ?? refreshToken,
+				expiresAt: refreshed.expiresAt
+			}
+		});
+	}
+	return {
+		CLAUDE_CODE_OAUTH_TOKEN: resolvedAccessToken,
+		ANTHROPIC_BASE_URL: "https://api.anthropic.com"
+	};
+}
+async function readClaudeCredentialStore({ credentialPath, homeDirectory, configDirectory, platform }) {
+	const text = await readFile(credentialPath, "utf8").catch(() => void 0);
+	if (text != null) {
+		const value2 = await parseClaudeCredentialFile(text);
+		if (value2 != null && getClaudeOAuthCredential({ value: value2 }) != null) return {
+			value: value2,
+			write: (updated) => writeClaudeCredentialFile({
+				credentialPath,
+				value: updated
+			})
+		};
+	}
+	if (!isMacOS(platform)) return void 0;
+	if (configDirectory !== resolve(join(homeDirectory, ".claude"))) return;
+	const service = "Claude Code-credentials";
+	const keychainText = await readMacOSKeychainPassword({
+		service,
+		account: process.env.USER ?? ""
+	});
+	if (keychainText == null) return void 0;
+	const value = await parseClaudeCredentialFile(keychainText);
+	if (value == null) return void 0;
+	return {
+		value,
+		write: async (updated) => {
+			execFileSync("/usr/bin/security", [
+				"add-generic-password",
+				"-U",
+				"-s",
+				service,
+				"-a",
+				process.env.USER ?? "",
+				"-w",
+				JSON.stringify(updated)
+			], { stdio: "ignore" });
+		}
+	};
+}
+function getClaudeOAuthCredential({ value }) {
+	const oauth = value.claudeAiOauth;
+	if (!isRecord(oauth) || typeof oauth.accessToken !== "string" || typeof oauth.refreshToken !== "string" || typeof oauth.expiresAt !== "number") return;
+	return oauth;
+}
+async function parseClaudeCredentialFile(text) {
+	const parsed = await safeParseJSON({ text });
+	return parsed.success && isRecord(parsed.value) ? parsed.value : void 0;
+}
+async function writeClaudeCredentialFile({ credentialPath, value }) {
+	await mkdir(dirname(credentialPath), { recursive: true });
+	const temporaryPath = `${credentialPath}.${process.pid}.tmp`;
+	await writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+	await chmod(temporaryPath, 384);
+	await rename(temporaryPath, credentialPath);
+}
+var outboundMessageSchema = harnessV1BridgeOutboundMessageSchema;
+var thinkingDisplaySchema = z.enum(["summarized", "omitted"]).optional();
+var thinkingSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("adaptive"),
+		display: thinkingDisplaySchema
+	}),
+	z.object({
+		type: z.literal("enabled"),
+		display: thinkingDisplaySchema
+	}),
+	z.object({ type: z.literal("disabled") })
+]);
+var startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
+	instructions: z.string().optional(),
+	thinking: thinkingSchema,
+	effort: z.enum([
+		"low",
+		"medium",
+		"high",
+		"xhigh",
+		"max"
+	]).optional(),
+	maxTurns: z.number().optional(),
+	env: z.record(z.string(), z.string()).optional(),
+	skills: z.array(z.string()).optional(),
+	mcpServers: z.record(z.string(), z.unknown()).optional(),
+	continue: z.boolean().optional(),
+	resumeSessionId: z.string().optional()
+});
+z.discriminatedUnion("type", [startMessageSchema, ...harnessV1BridgeInboundCommandSchemas]);
+var CLAUDE_CODE_CLIENT_APP = `ai-sdk/harness-claude-code/1.0.128`;
+var listMcpResourcesInputSchema = z.object({ server: z.string().optional() });
+var readMcpResourceInputSchema = z.object({
+	server: z.string(),
+	uri: z.string()
+});
+var structuredTeamMessageSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("shutdown_request"),
+		reason: z.string().optional()
+	}),
+	z.object({
+		type: z.literal("shutdown_response"),
+		request_id: z.string(),
+		approve: z.boolean(),
+		reason: z.string().optional()
+	}),
+	z.object({
+		type: z.literal("plan_approval_response"),
+		request_id: z.string(),
+		approve: z.boolean(),
+		feedback: z.string().optional()
+	})
+]);
+var CLAUDE_CODE_BUILTIN_TOOLS = {
+	read: commonTool("read", {
+		nativeName: "Read",
+		toolUseKind: "readonly",
+		description: "Read file contents (text, image, PDF, notebook)",
+		inputSchema: z.object({
+			file_path: z.string(),
+			offset: z.number().optional(),
+			limit: z.number().optional(),
+			pages: z.string().optional()
+		})
+	}),
+	write: commonTool("write", {
+		nativeName: "Write",
+		toolUseKind: "edit",
+		description: "Overwrite or create a file at an absolute path",
+		inputSchema: z.object({
+			file_path: z.string(),
+			content: z.string()
+		})
+	}),
+	edit: commonTool("edit", {
+		nativeName: "Edit",
+		toolUseKind: "edit",
+		description: "Edit a file by exact string replacement",
+		inputSchema: z.object({
+			file_path: z.string(),
+			old_string: z.string(),
+			new_string: z.string(),
+			replace_all: z.boolean().optional()
+		})
+	}),
+	bash: commonTool("bash", {
+		nativeName: "Bash",
+		toolUseKind: "bash",
+		description: "Execute a shell command, optionally in background",
+		inputSchema: z.object({
+			command: z.string(),
+			timeout: z.number().optional(),
+			description: z.string().optional(),
+			run_in_background: z.boolean().optional(),
+			dangerouslyDisableSandbox: z.boolean().optional()
+		})
+	}),
+	glob: commonTool("glob", {
+		nativeName: "Glob",
+		toolUseKind: "readonly",
+		description: "Fast file-pattern search using glob syntax",
+		inputSchema: z.object({
+			pattern: z.string(),
+			path: z.string().optional()
+		})
+	}),
+	grep: commonTool("grep", {
+		nativeName: "Grep",
+		toolUseKind: "readonly",
+		description: "Regex search over file contents via ripgrep",
+		inputSchema: z.object({
+			pattern: z.string(),
+			path: z.string().optional(),
+			glob: z.string().optional(),
+			output_mode: z.enum([
+				"content",
+				"files_with_matches",
+				"count"
+			]).optional(),
+			"-B": z.number().optional(),
+			"-A": z.number().optional(),
+			"-C": z.number().optional(),
+			context: z.number().optional(),
+			"-n": z.boolean().optional(),
+			"-i": z.boolean().optional(),
+			"-o": z.boolean().optional(),
+			type: z.string().optional(),
+			head_limit: z.number().optional(),
+			offset: z.number().optional(),
+			multiline: z.boolean().optional()
+		})
+	}),
+	webSearch: commonTool("webSearch", {
+		nativeName: "WebSearch",
+		toolUseKind: "readonly",
+		description: "Issue web search queries with optional domain filters",
+		inputSchema: z.object({
+			query: z.string(),
+			allowed_domains: z.array(z.string()).optional(),
+			blocked_domains: z.array(z.string()).optional()
+		})
+	}),
+	WebFetch: tool({
+		description: "Fetch a URL and run a prompt against its content",
+		inputSchema: z.object({
+			url: z.string(),
+			prompt: z.string()
+		})
+	}),
+	NotebookEdit: tool({
+		description: "Edit, insert, or delete a Jupyter notebook cell",
+		inputSchema: z.object({
+			notebook_path: z.string(),
+			new_source: z.string(),
+			cell_id: z.string().optional(),
+			cell_type: z.enum(["code", "markdown"]).optional(),
+			edit_mode: z.enum([
+				"replace",
+				"insert",
+				"delete"
+			]).optional()
+		})
+	}),
+	TodoWrite: tool({
+		description: "Replace the session todo list",
+		inputSchema: z.object({ todos: z.array(z.object({
+			content: z.string(),
+			status: z.enum([
+				"pending",
+				"in_progress",
+				"completed"
+			]),
+			activeForm: z.string()
+		})) })
+	}),
+	Agent: tool({
+		description: "Spawn a subagent with a task",
+		inputSchema: z.object({
+			description: z.string(),
+			prompt: z.string(),
+			subagent_type: z.string().optional(),
+			model: z.enum([
+				"sonnet",
+				"opus",
+				"haiku"
+			]).optional(),
+			run_in_background: z.boolean().optional(),
+			name: z.string().optional(),
+			team_name: z.string().optional(),
+			mode: z.enum([
+				"acceptEdits",
+				"auto",
+				"bypassPermissions",
+				"default",
+				"dontAsk",
+				"plan"
+			]).optional(),
+			isolation: z.literal("worktree").optional()
+		})
+	}),
+	TaskCreate: tool({
+		description: "Create a task in the session-local task list",
+		inputSchema: z.object({
+			subject: z.string(),
+			description: z.string(),
+			activeForm: z.string().optional(),
+			metadata: z.record(z.string(), z.unknown()).optional()
+		})
+	}),
+	TaskGet: tool({
+		description: "Retrieve a task by id",
+		inputSchema: z.object({ taskId: z.string() })
+	}),
+	TaskUpdate: tool({
+		description: "Update fields of an existing task",
+		inputSchema: z.object({
+			taskId: z.string(),
+			subject: z.string().optional(),
+			description: z.string().optional(),
+			activeForm: z.string().optional(),
+			status: z.union([z.enum([
+				"pending",
+				"in_progress",
+				"completed"
+			]), z.literal("deleted")]).optional(),
+			addBlocks: z.array(z.string()).optional(),
+			addBlockedBy: z.array(z.string()).optional(),
+			owner: z.string().optional(),
+			metadata: z.record(z.string(), z.unknown()).optional()
+		})
+	}),
+	TaskList: tool({
+		description: "Return all tasks in the session-local task list",
+		inputSchema: z.object({})
+	}),
+	TaskStop: tool({
+		description: "Stop a running background task by id",
+		inputSchema: z.object({
+			task_id: z.string().optional(),
+			shell_id: z.string().optional()
+		})
+	}),
+	TaskOutput: tool({
+		description: "Poll for output from a background task",
+		inputSchema: z.object({
+			task_id: z.string(),
+			block: z.boolean(),
+			timeout: z.number()
+		})
+	}),
+	Monitor: {
+		...tool({
+			description: "Run and monitor a shell command or WebSocket",
+			inputSchema: z.object({
+				description: z.string().optional(),
+				timeout_ms: z.number().optional(),
+				persistent: z.boolean().optional(),
+				command: z.string().optional(),
+				ws: z.object({
+					url: z.string(),
+					protocols: z.array(z.string()).optional()
+				}).optional()
+			})
+		}),
+		toolUseKind: "bash"
+	},
+	ListMcpResources: {
+		...tool({
+			description: "List resources available from MCP servers",
+			inputSchema: listMcpResourcesInputSchema
+		}),
+		toolUseKind: "readonly"
+	},
+	ListMcpResourcesTool: {
+		...tool({
+			description: "List resources available from MCP servers",
+			inputSchema: listMcpResourcesInputSchema
+		}),
+		toolUseKind: "readonly"
+	},
+	ReadMcpResource: {
+		...tool({
+			description: "Read a specific MCP resource by URI",
+			inputSchema: readMcpResourceInputSchema
+		}),
+		toolUseKind: "readonly"
+	},
+	ReadMcpResourceTool: {
+		...tool({
+			description: "Read a specific MCP resource by URI",
+			inputSchema: readMcpResourceInputSchema
+		}),
+		toolUseKind: "readonly"
+	},
+	ReadMcpResourceDirTool: {
+		...tool({
+			description: "List direct children of an MCP directory resource",
+			inputSchema: readMcpResourceInputSchema
+		}),
+		toolUseKind: "readonly"
+	},
+	RefreshMcpTools: {
+		...tool({
+			description: "Refresh tools from one or all connected MCP servers",
+			inputSchema: z.object({ server: z.string().optional() })
+		}),
+		toolUseKind: "readonly"
+	},
+	ExitPlanMode: tool({
+		description: "Exit plan mode with optional permission approvals",
+		inputSchema: z.looseObject({ allowedPrompts: z.array(z.object({
+			tool: z.literal("Bash"),
+			prompt: z.string()
+		})).optional() })
+	}),
+	EnterPlanMode: {
+		...tool({
+			description: "Enter plan mode",
+			inputSchema: z.object({})
+		}),
+		toolUseKind: "readonly"
+	},
+	EnterWorktree: tool({
+		description: "Create or enter an isolated git worktree",
+		inputSchema: z.object({
+			name: z.string().optional(),
+			path: z.string().optional()
+		})
+	}),
+	ExitWorktree: tool({
+		description: "Exit the current worktree session",
+		inputSchema: z.object({
+			action: z.enum(["keep", "remove"]),
+			discard_changes: z.boolean().optional()
+		})
+	}),
+	askUserQuestions: {
+		...HARNESS_V1_BUILTIN_TOOLS.askUserQuestions,
+		nativeName: "AskUserQuestion",
+		toolUseKind: "readonly"
+	},
+	Skill: {
+		...tool({
+			description: "Activate a skill by name",
+			inputSchema: z.object({
+				skill: z.string(),
+				args: z.string().optional()
+			})
+		}),
+		toolUseKind: "readonly"
+	},
+	ToolSearch: tool({
+		description: "Search deferred MCP / catalog tools so the model can load them on demand",
+		inputSchema: z.object({
+			query: z.string(),
+			max_results: z.number().optional()
+		})
+	}),
+	Artifact: {
+		...tool({
+			description: "Publish or list claude.ai artifacts",
+			inputSchema: z.object({
+				action: z.enum(["publish", "list"]).optional(),
+				file_path: z.string().optional(),
+				favicon: z.string().optional(),
+				limit: z.number().optional(),
+				scope: z.enum([
+					"mine",
+					"shared",
+					"all"
+				]).optional(),
+				title: z.string().optional(),
+				description: z.string().optional(),
+				label: z.string().optional(),
+				url: z.string().optional(),
+				force: z.boolean().optional()
+			})
+		}),
+		toolUseKind: "edit"
+	},
+	CronCreate: {
+		...tool({
+			description: "Schedule a recurring or one-shot prompt",
+			inputSchema: z.object({
+				cron: z.string(),
+				prompt: z.string(),
+				recurring: z.boolean().optional(),
+				durable: z.boolean().optional()
+			})
+		}),
+		toolUseKind: "edit"
+	},
+	CronDelete: {
+		...tool({
+			description: "Delete a scheduled prompt by id",
+			inputSchema: z.object({ id: z.string() })
+		}),
+		toolUseKind: "edit"
+	},
+	CronList: {
+		...tool({
+			description: "List scheduled prompts for the current session",
+			inputSchema: z.object({})
+		}),
+		toolUseKind: "readonly"
+	},
+	DesignSync: {
+		...tool({
+			description: "Read or update claude.ai Design projects",
+			inputSchema: z.object({
+				method: z.enum([
+					"list_projects",
+					"get_project",
+					"list_files",
+					"get_file",
+					"finalize_plan",
+					"write_files",
+					"delete_files",
+					"register_assets",
+					"unregister_assets",
+					"create_project",
+					"report_validate"
+				]),
+				projectId: z.string().optional(),
+				path: z.string().optional(),
+				writes: z.array(z.string()).max(256).optional(),
+				deletes: z.array(z.string()).max(256).optional(),
+				planId: z.string().optional(),
+				files: z.array(z.object({
+					path: z.string(),
+					localPath: z.string().optional(),
+					data: z.string().optional(),
+					encoding: z.literal("base64").optional(),
+					mimeType: z.string().optional()
+				})).max(256).optional(),
+				paths: z.array(z.string()).max(256).optional(),
+				name: z.string().optional(),
+				assets: z.array(z.object({
+					name: z.string(),
+					path: z.string(),
+					subtitle: z.string().optional(),
+					viewport: z.object({
+						width: z.number(),
+						height: z.number().optional()
+					}).optional(),
+					group: z.string().optional()
+				})).max(256).optional(),
+				localDir: z.string().optional(),
+				counts: z.object({
+					total: z.number(),
+					bad: z.number(),
+					thin: z.number(),
+					variantsIdentical: z.number(),
+					iterations: z.number()
+				}).optional()
+			})
+		}),
+		toolUseKind: "edit"
+	},
+	LSP: {
+		...tool({
+			description: "Query a language server for code intelligence",
+			inputSchema: z.object({
+				operation: z.enum([
+					"goToDefinition",
+					"findReferences",
+					"hover",
+					"documentSymbol",
+					"workspaceSymbol",
+					"goToImplementation",
+					"prepareCallHierarchy",
+					"incomingCalls",
+					"outgoingCalls"
+				]),
+				filePath: z.string(),
+				line: z.number().int().positive(),
+				character: z.number().int().positive(),
+				query: z.string().optional()
+			})
+		}),
+		toolUseKind: "readonly"
+	},
+	PowerShell: {
+		...tool({
+			description: "Execute a PowerShell command, optionally in background",
+			inputSchema: z.object({
+				command: z.string(),
+				timeout: z.number().optional(),
+				description: z.string().optional(),
+				run_in_background: z.boolean().optional(),
+				dangerouslyDisableSandbox: z.boolean().optional()
+			})
+		}),
+		toolUseKind: "bash"
+	},
+	PushNotification: {
+		...tool({
+			description: "Send a notification for proactive or scheduled work",
+			inputSchema: z.object({
+				message: z.string(),
+				status: z.literal("proactive")
+			})
+		}),
+		toolUseKind: "edit"
+	},
+	RemoteTrigger: {
+		...tool({
+			description: "List, manage, or run a claude.ai Routine trigger",
+			inputSchema: z.object({
+				action: z.enum([
+					"list",
+					"get",
+					"create",
+					"update",
+					"run"
+				]),
+				trigger_id: z.string().optional(),
+				body: z.record(z.string(), z.unknown()).optional()
+			})
+		}),
+		toolUseKind: "edit"
+	},
+	ReportFindings: {
+		...tool({
+			description: "Return verified code-review findings",
+			inputSchema: z.object({
+				level: z.enum([
+					"low",
+					"medium",
+					"high",
+					"xhigh",
+					"max"
+				]).optional(),
+				findings: z.array(z.object({
+					file: z.string(),
+					line: z.number().optional(),
+					summary: z.string(),
+					short_summary: z.string().optional(),
+					failure_scenario: z.string(),
+					category: z.string().optional(),
+					verdict: z.enum(["CONFIRMED", "PLAUSIBLE"]).optional(),
+					outcome: z.enum([
+						"fixed",
+						"skipped",
+						"no_change_needed"
+					]).optional()
+				})).max(32)
+			})
+		}),
+		toolUseKind: "readonly"
+	},
+	ScheduleWakeup: {
+		...tool({
+			description: "Schedule or stop the next iteration of a dynamic loop",
+			inputSchema: z.object({
+				delaySeconds: z.number().optional(),
+				reason: z.string().optional(),
+				prompt: z.string().optional(),
+				stop: z.boolean().optional()
+			})
+		}),
+		toolUseKind: "edit"
+	},
+	SendMessage: {
+		...tool({
+			description: "Send a plain-text or protocol message to another agent",
+			inputSchema: z.object({
+				to: z.string(),
+				summary: z.string().max(200).optional(),
+				message: z.union([z.string(), structuredTeamMessageSchema])
+			})
+		}),
+		toolUseKind: "edit"
+	},
+	SendUserFile: {
+		...tool({
+			description: "Send one or more files to the user",
+			inputSchema: z.object({
+				files: z.union([z.string(), z.array(z.string()).min(1)]),
+				caption: z.string().optional(),
+				status: z.enum(["normal", "proactive"]),
+				display: z.enum(["render", "attach"]).optional()
+			})
+		}),
+		toolUseKind: "readonly"
+	},
+	ShareOnboardingGuide: {
+		...tool({
+			description: "Create, update, inspect, or delete an onboarding guide",
+			inputSchema: z.object({
+				mode: z.enum([
+					"check",
+					"update",
+					"create",
+					"delete"
+				]).optional(),
+				short_code: z.string().regex(/^[A-Za-z0-9_-]{1,64}$/).optional()
+			})
+		}),
+		toolUseKind: "edit"
+	},
+	WaitForMcpServers: {
+		...tool({
+			description: "Wait for MCP servers that are still connecting",
+			inputSchema: z.object({ servers: z.array(z.string()).optional() })
+		}),
+		toolUseKind: "readonly"
+	},
+	Workflow: {
+		...tool({
+			description: "Run or resume a dynamic multi-agent workflow",
+			inputSchema: z.object({
+				script: z.string().optional(),
+				name: z.string().optional(),
+				description: z.string().optional(),
+				title: z.string().optional(),
+				args: z.record(z.string(), z.unknown()).optional(),
+				scriptPath: z.string().optional(),
+				resumeFromRunId: z.string().optional()
+			})
+		}),
+		toolUseKind: "edit"
+	}
+};
+var claudeCodeBridgeCoordsSchema = z.object({
+	port: z.number(),
+	token: z.string(),
+	lastSeenEventId: z.number(),
+	sandboxId: z.string().optional()
+});
+var claudeCodeResumeStateSchema = z.looseObject({
+	bridge: claudeCodeBridgeCoordsSchema.optional(),
+	sandboxCredentialEnvironment: z.record(z.string(), z.string()).optional(),
+	/**
+	* The exact Claude conversation to rehydrate on resume. Written by the
+	* adapter on `doStop()`/`doDetach()`/`doSuspendTurn()` from the session id
+	* the bridge observed, so a resume names the conversation instead of
+	* relying on the SDK's `continue` flag — "most recent thread in this
+	* workdir" — which silently picks the wrong one once a second thread
+	* exists there. Hosts that captured the id themselves (it is surfaced as
+	* `harnessMetadata['claude-code'].sessionId` on `finish` parts) may also
+	* set it explicitly.
+	*/
+	claudeSessionId: z.string().optional()
+});
+function createClaudeCode(settings = {}) {
+	if (settings.mcpServers != null && Object.prototype.hasOwnProperty.call(settings.mcpServers, "harness-tools")) throw new Error("Claude Code MCP server name \"harness-tools\" is reserved for HarnessAgent tools.");
+	const thinking = settings.thinking ?? {
+		type: "adaptive",
+		display: "summarized"
+	};
+	return {
+		specificationVersion: "harness-v1",
+		harnessId: "claude-code",
+		builtinTools: CLAUDE_CODE_BUILTIN_TOOLS,
+		supportsBuiltinToolApprovals: true,
+		supportsBuiltinToolFiltering: true,
+		lifecycleStateSchema: claudeCodeResumeStateSchema,
+		getBootstrap: getClaudeCodeBootstrap,
+		doStart: async (startOpts) => {
+			const sandboxSession = startOpts.sandboxSession;
+			const toolSafeSandboxSession = getRestrictedSandboxSession(sandboxSession);
+			const sandboxId = "id" in sandboxSession ? sandboxSession.id : void 0;
+			validateBasicSandboxSettings({
+				sandboxSession,
+				port: settings.port,
+				portEndpoint: settings.portEndpoint
+			});
+			if (settings.mintBridgeToken != null && sandboxId == null) throw new HarnessCapabilityUnsupportedError({
+				harnessId: "claude-code",
+				message: "The Claude Code harness cannot use `mintBridgeToken` with a sandbox session that does not expose an id."
+			});
+			const lifecycleState = startOpts.continueFrom ?? startOpts.resumeFrom;
+			const isResume = lifecycleState != null;
+			const isContinue = startOpts.continueFrom != null;
+			const resumeData = isResume ? lifecycleState?.data : void 0;
+			const coords = resumeData?.bridge;
+			const authenticationMode = resolveClaudeCodeAuthenticationMode(settings.auth);
+			const resolvedAuthEnvironment = await resolveClaudeCodeAuthentication({ auth: settings.auth });
+			const claudeEnvironment = {
+				...resolvedAuthEnvironment,
+				...resolvedAuthEnvironment.AI_GATEWAY_BASE_URL ? { CLAUDE_AGENT_SDK_CLIENT_APP: CLAUDE_CODE_CLIENT_APP } : {},
+				...settings.env,
+				...startOpts.headers != null ? { ANTHROPIC_CUSTOM_HEADERS: Object.entries(startOpts.headers).map(([name, value]) => `${name}: ${value}`).join("\n") } : {}
+			};
+			let sandboxClaudeEnvironment = claudeEnvironment;
+			let sandboxCredentialEnvironment;
+			if ("addRequestTransformations" in sandboxSession && sandboxSession.addRequestTransformations != null) {
+				sandboxCredentialEnvironment = resumeData?.sandboxCredentialEnvironment ?? await createSandboxCredentialEnvironment({
+					environment: claudeEnvironment,
+					credentialEnvironmentVariables: CLAUDE_CODE_CREDENTIAL_ENVIRONMENT_VARIABLES,
+					credentialForwarding: settings.credentialForwarding
+				});
+				sandboxClaudeEnvironment = {
+					...claudeEnvironment,
+					...sandboxCredentialEnvironment
+				};
+				const transformationSources = {
+					env: claudeEnvironment,
+					sandboxEnv: sandboxClaudeEnvironment,
+					auth: authenticationMode
+				};
+				const requestTransformations = [...createClaudeCodeRequestTransformations(transformationSources), ...createClaudeCodeSubscriptionRequestTransformations(transformationSources)];
+				if (requestTransformations.length > 0) await sandboxSession.addRequestTransformations(requestTransformations);
+			} else {
+				sandboxClaudeEnvironment = await applyCredentialForwarding({
+					environment: sandboxClaudeEnvironment,
+					credentialEnvironmentVariables: CLAUDE_CODE_CREDENTIAL_ENVIRONMENT_VARIABLES,
+					credentialForwarding: settings.credentialForwarding
+				});
+				warnCredentialBrokeringUnavailable({
+					environment: claudeEnvironment,
+					forwardedEnvironment: sandboxClaudeEnvironment,
+					credentialEnvironmentVariables: CLAUDE_CODE_CREDENTIAL_ENVIRONMENT_VARIABLES
+				});
+			}
+			const sandboxHomeDir = await resolveSandboxHomeDir({
+				sandbox: toolSafeSandboxSession,
+				abortSignal: startOpts.abortSignal
+			});
+			const stateDir = harnessStateDirectoryPath({ sandboxHomeDir });
+			const bootstrapDir = posix.resolve(stateDir, CLAUDE_CODE_BOOTSTRAP_DIR);
+			const resumeSessionId = resumeData?.claudeSessionId;
+			const workDir = startOpts.sessionWorkDir;
+			const bridgeStateDir = `${harnessSessionDataDirectoryPath({
+				stateDirectory: stateDir,
+				sessionId: startOpts.sessionId
+			})}/bridge`;
+			const timeoutMs = settings.startupTimeoutMs ?? 12e4;
+			const report = startOpts.observability?.report;
+			const onDiagnostic = report ? (frame) => report(harnessV1DiagnosticFromBridgeFrame(frame, {
+				sessionId: startOpts.sessionId,
+				timestamp: Date.now()
+			})) : void 0;
+			const onBridgeError = createBridgeErrorHandler({
+				harnessId: "claude-code",
+				sessionId: startOpts.sessionId
+			});
+			let supportsUserMessageResponses = false;
+			const buildConnect = (endpoint2) => async ({ abortSignal }) => {
+				return openBridgeWebSocket({
+					endpoint: endpoint2,
+					timeoutMs,
+					abortSignal,
+					onHello: (supportsResponses) => {
+						supportsUserMessageResponses = supportsResponses;
+					}
+				});
+			};
+			if (coords) try {
+				const endpoint2 = await resolveBridgeEndpoint({
+					sandboxSession,
+					override: settings.portEndpoint,
+					port: coords.port
+				});
+				const attachEndpoint = withBridgeToken({
+					endpoint: endpoint2,
+					token: coords.token
+				});
+				const attachChannel = new SandboxChannel({
+					connect: buildConnect(attachEndpoint),
+					outboundSchema: outboundMessageSchema,
+					initialLastSeenEventId: coords.lastSeenEventId,
+					onDiagnostic,
+					onBridgeError,
+					reconnect: settings.reconnect
+				});
+				const finishListenerAttachment2 = isContinue ? attachChannel.beginListenerAttachment() : void 0;
+				try {
+					await attachChannel.open(isContinue ? { resume: true } : void 0);
+				} catch (error) {
+					finishListenerAttachment2?.();
+					throw error;
+				}
+				return createSession({
+					sessionId: startOpts.sessionId,
+					channel: attachChannel,
+					finishListenerAttachment: finishListenerAttachment2,
+					...resumeSessionId ? { resumeSessionId } : {},
+					proc: void 0,
+					maxTurns: settings.maxTurns,
+					env: sandboxClaudeEnvironment,
+					thinking,
+					effort: settings.effort,
+					isResume: true,
+					continueOnFirstPrompt: false,
+					rerunContinue: false,
+					bridgePort: coords.port,
+					bridgeToken: coords.token,
+					sandboxId,
+					sandboxCredentialEnvironment,
+					debug: startOpts.observability?.debug,
+					permissionMode: startOpts.permissionMode,
+					builtinToolFiltering: startOpts.builtinToolFiltering,
+					sandbox: toolSafeSandboxSession,
+					sandboxHomeDir,
+					mcpServers: settings.mcpServers,
+					supportsUserMessageResponses: () => supportsUserMessageResponses
+				});
+			} catch {}
+			let respawnStrategy = isResume ? "rerun" : void 0;
+			if (coords && isContinue) {
+				const logRaw = await Promise.resolve(toolSafeSandboxSession.readTextFile({
+					path: `${bridgeStateDir}/event-log.ndjson`,
+					abortSignal: startOpts.abortSignal
+				})).catch(() => null);
+				if (await classifyDiskLog(logRaw) === "replay") respawnStrategy = "replay";
+			}
+			const port = resolveBridgePort({
+				sandboxSession,
+				override: settings.port
+			});
+			const token = settings.mintBridgeToken == null ? createBridgeToken() : settings.mintBridgeToken(sandboxId);
+			const env = {
+				BRIDGE_CHANNEL_TOKEN: token,
+				BRIDGE_WS_PORT: String(port),
+				...respawnStrategy === "replay" ? { BRIDGE_REPLAY_FROM_DISK: "1" } : {}
+			};
+			if (respawnStrategy === void 0) await toolSafeSandboxSession.run({
+				command: `mkdir -p ${shellQuote(workDir)} ${shellQuote(bridgeStateDir)}`,
+				abortSignal: startOpts.abortSignal
+			});
+			await markBridgeStarting({
+				sandbox: toolSafeSandboxSession,
+				bridgeStateDir,
+				bridgeType: "claude-code",
+				abortSignal: startOpts.abortSignal
+			});
+			const proc = await toolSafeSandboxSession.spawn({
+				command: `node ${shellQuote(`${bootstrapDir}/bridge.mjs`)} --workdir ${shellQuote(workDir)} --bridge-state-dir ${shellQuote(bridgeStateDir)}`,
+				env,
+				abortSignal: startOpts.abortSignal
+			});
+			const bridgeStartupStderr = [];
+			const bridgeStartupStderrDone = forwardBridgeProcessStream({
+				stream: proc.stderr,
+				streamName: "stderr",
+				source: "claude-code",
+				collectTail: bridgeStartupStderr
+			});
+			const { port: boundPort } = await waitForBridgeReady({
+				proc,
+				sandbox: toolSafeSandboxSession,
+				bridgeStateDir,
+				bridgeType: "claude-code",
+				timeoutMs,
+				abortSignal: startOpts.abortSignal,
+				createTimeoutError: ({ proc: proc2, stdoutTail }) => createBridgeStartupError({
+					message: "claude-code bridge did not become ready in time.",
+					proc: proc2,
+					stdoutTail,
+					stderrTail: bridgeStartupStderr,
+					stderrDone: bridgeStartupStderrDone
+				}),
+				createExitError: ({ proc: proc2, stdoutTail }) => createBridgeStartupError({
+					message: "claude-code bridge exited before becoming ready.",
+					proc: proc2,
+					stdoutTail,
+					stderrTail: bridgeStartupStderr,
+					stderrDone: bridgeStartupStderrDone
+				})
+			});
+			drainBridgeProcessStream(proc.stdout);
+			const endpoint = await resolveBridgeEndpoint({
+				sandboxSession,
+				override: settings.portEndpoint,
+				port: boundPort
+			});
+			const bridgeEndpoint = withBridgeToken({
+				endpoint,
+				token
+			});
+			const channel = new SandboxChannel({
+				connect: buildConnect(bridgeEndpoint),
+				outboundSchema: outboundMessageSchema,
+				onDiagnostic,
+				onBridgeError,
+				reconnect: settings.reconnect,
+				...respawnStrategy === "replay" ? { initialLastSeenEventId: coords?.lastSeenEventId ?? 0 } : {}
+			});
+			const finishListenerAttachment = respawnStrategy === "replay" ? channel.beginListenerAttachment() : void 0;
+			try {
+				await channel.open(respawnStrategy === "replay" ? { resume: true } : void 0);
+			} catch (error) {
+				finishListenerAttachment?.();
+				throw error;
+			}
+			return createSession({
+				sessionId: startOpts.sessionId,
+				channel,
+				finishListenerAttachment,
+				proc,
+				maxTurns: settings.maxTurns,
+				env: sandboxClaudeEnvironment,
+				thinking,
+				effort: settings.effort,
+				isResume: respawnStrategy !== void 0,
+				continueOnFirstPrompt: respawnStrategy !== void 0,
+				...resumeSessionId ? { resumeSessionId } : {},
+				rerunContinue: respawnStrategy === "rerun",
+				bridgePort: boundPort,
+				bridgeToken: token,
+				sandboxId,
+				sandboxCredentialEnvironment,
+				debug: startOpts.observability?.debug,
+				permissionMode: startOpts.permissionMode,
+				builtinToolFiltering: startOpts.builtinToolFiltering,
+				sandbox: toolSafeSandboxSession,
+				sandboxHomeDir,
+				mcpServers: settings.mcpServers,
+				supportsUserMessageResponses: () => supportsUserMessageResponses
+			});
+		}
+	};
+}
+function resolveBridgePort({ sandboxSession, override }) {
+	if (override !== void 0) return override;
+	if ("ports" in sandboxSession && sandboxSession.ports.length > 0) return sandboxSession.ports[0];
+	throw new HarnessCapabilityUnsupportedError({
+		harnessId: "claude-code",
+		message: "The claude-code harness needs a TCP port exposed by the sandbox. Create the sandbox with `ports: [<port>]` or pass `createClaudeCode({ port })`."
+	});
+}
+function validateBasicSandboxSettings({ sandboxSession, port, portEndpoint }) {
+	if ("getPortEndpoint" in sandboxSession) return;
+	if (port == null) throw new HarnessCapabilityUnsupportedError({
+		harnessId: "claude-code",
+		message: "The Claude Code harness requires an explicit `port` when using a basic sandbox session."
+	});
+	if (portEndpoint == null) throw new HarnessCapabilityUnsupportedError({
+		harnessId: "claude-code",
+		message: "The Claude Code harness requires an explicit `portEndpoint` when using a basic sandbox session."
+	});
+}
+async function resolveBridgeEndpoint({ sandboxSession, override, port }) {
+	if (override != null) return override;
+	if ("getPortEndpoint" in sandboxSession) return sandboxSession.getPortEndpoint({
+		port,
+		protocol: "ws"
+	});
+	throw new HarnessCapabilityUnsupportedError({
+		harnessId: "claude-code",
+		message: "The Claude Code harness requires an explicit `portEndpoint` when using a basic sandbox session."
+	});
+}
+function openWebSocketAndWaitForBridgeHello({ endpoint, openTimeoutMs, getHelloTimeoutMs, abortSignal, onHello }) {
+	return new Promise((resolve2, reject) => {
+		const abortReason = () => abortSignal.reason ?? /* @__PURE__ */ new Error("WebSocket connection aborted");
+		if (abortSignal.aborted) {
+			reject(abortReason());
+			return;
+		}
+		const ws = new WebSocket(endpoint.url, { headers: endpoint.headers == null ? void 0 : { ...endpoint.headers } });
+		let opened = false;
+		let sawBridgeHello = false;
+		let settled = false;
+		let openTimer;
+		let helloTimer;
+		let onAbort;
+		const cleanup = ({ keepTerminationListeners = false } = {}) => {
+			if (openTimer) clearTimeout(openTimer);
+			if (helloTimer) clearTimeout(helloTimer);
+			ws.off("open", onOpen);
+			ws.off("message", onMessage);
+			if (onAbort != null) abortSignal.removeEventListener("abort", onAbort);
+			if (!keepTerminationListeners) {
+				ws.off("close", onClose);
+				ws.off("error", onError);
+			}
+		};
+		const settle = (err) => {
+			if (settled) return;
+			settled = true;
+			if (err) {
+				cleanup({ keepTerminationListeners: true });
+				try {
+					ws.terminate();
+				} catch {
+					cleanup();
+				}
+				reject(err);
+			} else {
+				cleanup();
+				resolve2(ws);
+			}
+		};
+		const tryResolve = () => {
+			if (opened && sawBridgeHello) settle();
+		};
+		const startHelloTimer = () => {
+			if (helloTimer) return;
+			const helloTimeoutMs = getHelloTimeoutMs();
+			helloTimer = setTimeout(() => settle(/* @__PURE__ */ new Error(`claude-code bridge did not send bridge-hello within ${helloTimeoutMs}ms`)), helloTimeoutMs);
+			helloTimer.unref?.();
+		};
+		const onOpen = () => {
+			opened = true;
+			if (openTimer) {
+				clearTimeout(openTimer);
+				openTimer = void 0;
+			}
+			startHelloTimer();
+			tryResolve();
+		};
+		const onMessage = (raw) => {
+			(async () => {
+				const parsed = await safeParseJSON({ text: webSocketMessageToString(raw) });
+				if (!parsed.success || settled) return;
+				const value = parsed.value;
+				if (typeof value === "object" && value !== null && !Array.isArray(value) && value.type === "bridge-hello") {
+					const capabilities = value.capabilities;
+					onHello(capabilities?.experimental_userMessageResponses === true);
+					sawBridgeHello = true;
+					tryResolve();
+				}
+			})();
+		};
+		const onClose = () => {
+			settle(/* @__PURE__ */ new Error("claude-code bridge closed before sending bridge-hello"));
+			cleanup();
+		};
+		const onError = (err) => settle(err);
+		onAbort = () => settle(abortReason());
+		openTimer = setTimeout(() => settle(/* @__PURE__ */ new Error(`WebSocket open timed out after ${openTimeoutMs}ms`)), openTimeoutMs);
+		openTimer.unref?.();
+		ws.on("open", onOpen);
+		ws.on("message", onMessage);
+		ws.on("close", onClose);
+		ws.on("error", onError);
+		abortSignal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+async function openBridgeWebSocket({ endpoint, timeoutMs, abortSignal, onHello }) {
+	const deadline = Date.now() + timeoutMs;
+	let attempt = 0;
+	let lastError;
+	while (!abortSignal.aborted && Date.now() < deadline) {
+		attempt++;
+		try {
+			const remaining = Math.max(1, deadline - Date.now());
+			return await openWebSocketAndWaitForBridgeHello({
+				endpoint,
+				openTimeoutMs: Math.min(1e4, remaining),
+				getHelloTimeoutMs: () => Math.min(5e3, Math.max(1, deadline - Date.now())),
+				abortSignal,
+				onHello
+			});
+		} catch (err) {
+			if (abortSignal.aborted) throw abortSignal.reason ?? /* @__PURE__ */ new Error("WebSocket connection aborted");
+			lastError = err;
+			const remaining = deadline - Date.now();
+			if (remaining <= 0) break;
+			await sleep({
+				ms: Math.min(250 * attempt, 1e3, remaining),
+				abortSignal
+			});
+		}
+	}
+	if (abortSignal.aborted) throw abortSignal.reason ?? /* @__PURE__ */ new Error("WebSocket connection aborted");
+	throw new Error(`claude-code bridge did not complete WebSocket handshake within ${timeoutMs}ms after ${attempt} attempt(s). Last error: ${formatUnknownError(lastError)}`);
+}
+function webSocketMessageToString(raw) {
+	if (typeof raw === "string") return raw;
+	if (Buffer.isBuffer(raw)) return raw.toString("utf8");
+	if (Array.isArray(raw)) return Buffer.concat(raw).toString("utf8");
+	if (raw instanceof ArrayBuffer) return Buffer.from(raw).toString("utf8");
+	if (ArrayBuffer.isView(raw)) return Buffer.from(raw.buffer, raw.byteOffset, raw.byteLength).toString("utf8");
+	return String(raw);
+}
+function formatUnknownError(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+function createSession({ sessionId, channel, finishListenerAttachment, proc, maxTurns, env, thinking, effort, isResume, continueOnFirstPrompt, resumeSessionId, rerunContinue, bridgePort, bridgeToken, sandboxId, sandboxCredentialEnvironment, debug, permissionMode, builtinToolFiltering, sandbox, sandboxHomeDir, mcpServers, supportsUserMessageResponses }) {
+	let stopped = false;
+	let stopPromise;
+	let pendingResumeFlag = continueOnFirstPrompt;
+	let lastClaudeSessionId = resumeSessionId;
+	const wireTurn = (turnOpts) => {
+		let pendingResolve;
+		let pendingReject;
+		const done = new Promise((resolve2, reject) => {
+			pendingResolve = resolve2;
+			pendingReject = reject;
+		});
+		const userMessageSubmitter = supportsUserMessageResponses() ? experimental_createBridgeUserMessageSubmitter({
+			send: (message) => channel.send(message),
+			onResponse: (listener) => channel.on("user-message-response", listener),
+			onReconnect: (listener) => channel.onReconnect(listener)
+		}) : void 0;
+		const unsubs = [];
+		const forward = (event) => {
+			try {
+				turnOpts.emit(event);
+			} catch {}
+		};
+		let isSettled = false;
+		const settleSuccess = () => {
+			if (isSettled) return;
+			isSettled = true;
+			userMessageSubmitter?.close();
+			for (const u of unsubs) u();
+			pendingResolve();
+		};
+		const settleError = (err) => {
+			if (isSettled) return;
+			isSettled = true;
+			userMessageSubmitter?.close(err);
+			for (const u of unsubs) u();
+			pendingReject(err);
+		};
+		for (const type of [
+			"stream-start",
+			"text-start",
+			"text-delta",
+			"text-end",
+			"reasoning-start",
+			"reasoning-delta",
+			"reasoning-end",
+			"tool-input-start",
+			"tool-input-delta",
+			"tool-input-end",
+			"tool-call",
+			"tool-approval-request",
+			"tool-result",
+			"finish-step",
+			"compaction",
+			"raw"
+		]) unsubs.push(channel.on(type, (msg) => {
+			forward(msg);
+		}));
+		unsubs.push(channel.on("finish", (msg) => {
+			const metadata = msg.harnessMetadata?.["claude-code"]?.sessionId;
+			if (typeof metadata === "string" && metadata.length > 0) lastClaudeSessionId = metadata;
+			forward(msg);
+			settleSuccess();
+		}));
+		unsubs.push(channel.on("error", (msg) => {
+			forward(msg);
+			settleError(msg.error);
+		}));
+		finishListenerAttachment?.();
+		finishListenerAttachment = void 0;
+		const onClose = (_code, reason) => {
+			if (isSettled) return;
+			if (reason === "suspended") {
+				settleSuccess();
+				return;
+			}
+			settleError(/* @__PURE__ */ new Error("claude-code bridge closed before the turn finished."));
+		};
+		channel.onClose(onClose);
+		const onAbort = () => {
+			if (isSettled) return;
+			try {
+				channel.send({ type: "abort" });
+			} catch {}
+			settleError(turnOpts.abortSignal?.reason ?? new DOMException("Aborted", "AbortError"));
+		};
+		if (turnOpts.abortSignal) {
+			if (turnOpts.abortSignal.aborted) onAbort();
+			else turnOpts.abortSignal.addEventListener("abort", onAbort, { once: true });
+		}
+		return {
+			submitToolResult: async (input) => {
+				channel.send({
+					type: "tool-result",
+					toolCallId: input.toolCallId,
+					output: input.output,
+					isError: input.isError,
+					...input.toolResult !== void 0 ? { toolResult: input.toolResult } : {}
+				});
+			},
+			submitToolApproval: async (input) => {
+				channel.send({
+					type: "tool-approval-response",
+					approvalId: input.approvalId,
+					approved: input.approved,
+					reason: input.reason
+				});
+			},
+			...userMessageSubmitter == null ? {} : { submitUserMessage: async (text) => {
+				await userMessageSubmitter.submit(text);
+			} },
+			done
+		};
+	};
+	const prepareTurn = async (turnOpts) => {
+		if (turnOpts.responseFormat?.type === "json" && turnOpts.responseFormat.schema == null) throw new HarnessCapabilityUnsupportedError({
+			message: "Harness 'claude-code' requires a JSON schema for structured output.",
+			harnessId: "claude-code"
+		});
+		await writeSkills({
+			sandbox,
+			homePath: sandboxHomeDir,
+			skillsDir: ".claude/skills",
+			skills: turnOpts.skills,
+			abortSignal: turnOpts.abortSignal,
+			invalidSkillNameMessage: ({ name }) => `Invalid Claude Code skill name: ${name}`,
+			invalidSkillFilePathMessage: ({ skillName, filePath }) => `Invalid Claude Code skill file path for ${skillName}: ${filePath}`,
+			trailingNewline: true
+		});
+		return wireTurn({
+			emit: turnOpts.emit,
+			abortSignal: turnOpts.abortSignal
+		});
+	};
+	return {
+		sessionId,
+		isResume,
+		doPromptTurn: async (promptOpts) => {
+			const control = await prepareTurn(promptOpts);
+			if (promptOpts.abortSignal?.aborted) return control;
+			const startMessage = {
+				type: "start",
+				prompt: extractUserText(promptOpts.prompt),
+				tools: (promptOpts.tools ?? []).map((t) => ({
+					name: t.name,
+					description: t.description,
+					inputSchema: t.inputSchema
+				})),
+				...promptOpts.responseFormat == null ? {} : { responseFormat: promptOpts.responseFormat },
+				...promptOpts.instructions ? { instructions: promptOpts.instructions } : {},
+				model: promptOpts.model,
+				maxTurns,
+				...env !== void 0 ? { env } : {},
+				thinking,
+				...effort !== void 0 ? { effort } : {},
+				...promptOpts.skills.length > 0 ? { skills: promptOpts.skills.map((skill) => skill.name) } : {},
+				...mcpServers == null ? {} : { mcpServers },
+				...permissionMode ? { permissionMode } : {},
+				...builtinToolFiltering ? { builtinToolFiltering } : {},
+				...debug ? { debug } : {},
+				...lastClaudeSessionId ? { resumeSessionId: lastClaudeSessionId } : pendingResumeFlag ? { continue: true } : {}
+			};
+			pendingResumeFlag = false;
+			channel.send(startMessage);
+			return control;
+		},
+		doContinueTurn: async (continueOpts) => {
+			const control = await prepareTurn(continueOpts);
+			if (rerunContinue && !continueOpts.abortSignal?.aborted) {
+				pendingResumeFlag = false;
+				channel.send({
+					type: "start",
+					prompt: "Continue.",
+					tools: (continueOpts.tools ?? []).map((t) => ({
+						name: t.name,
+						description: t.description,
+						inputSchema: t.inputSchema
+					})),
+					...continueOpts.responseFormat == null ? {} : { responseFormat: continueOpts.responseFormat },
+					...continueOpts.instructions ? { instructions: continueOpts.instructions } : {},
+					model: continueOpts.model,
+					maxTurns,
+					...env !== void 0 ? { env } : {},
+					thinking,
+					...effort !== void 0 ? { effort } : {},
+					...continueOpts.skills.length > 0 ? { skills: continueOpts.skills.map((skill) => skill.name) } : {},
+					...mcpServers == null ? {} : { mcpServers },
+					...permissionMode ? { permissionMode } : {},
+					...builtinToolFiltering ? { builtinToolFiltering } : {},
+					...debug ? { debug } : {},
+					...lastClaudeSessionId ? { resumeSessionId: lastClaudeSessionId } : { continue: true }
+				});
+			}
+			return control;
+		},
+		doCompact: async (customInstructions) => {
+			const text = customInstructions && customInstructions.trim() ? `/compact ${customInstructions.trim()}` : "/compact";
+			channel.send({
+				type: "user-message",
+				text
+			});
+		},
+		doDetach: async () => {
+			if (stopped) throw new Error(`claude-code session ${sessionId} is already stopped; cannot detach.`);
+			stopped = true;
+			const lastSeenEventId = await channel.suspend();
+			return {
+				type: "resume-session",
+				harnessId: "claude-code",
+				specificationVersion: "harness-v1",
+				data: {
+					...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment },
+					bridge: {
+						port: bridgePort,
+						token: bridgeToken,
+						lastSeenEventId,
+						...sandboxId == null ? {} : { sandboxId }
+					},
+					...lastClaudeSessionId ? { claudeSessionId: lastClaudeSessionId } : {}
+				}
+			};
+		},
+		doDestroy: async () => {
+			if (stopped) return stopPromise;
+			stopped = true;
+			stopPromise = (async () => {
+				channel.beginClose();
+				try {
+					if (!channel.isClosed()) channel.send({ type: "destroy" });
+				} catch {}
+				let stopTimer;
+				try {
+					if (proc) await Promise.race([proc.wait(), new Promise((resolve2) => {
+						stopTimer = setTimeout(resolve2, 5e3);
+						stopTimer.unref?.();
+					})]);
+				} finally {
+					if (stopTimer) clearTimeout(stopTimer);
+					try {
+						await proc?.kill();
+					} catch {}
+					channel.close();
+				}
+			})();
+			return stopPromise;
+		},
+		doStop: async () => {
+			if (stopped) throw new Error(`claude-code session ${sessionId} is already stopped; cannot stop.`);
+			stopped = true;
+			channel.beginClose();
+			const data = channel.isClosed() ? {} : await new Promise((resolve2, reject) => {
+				const timer = setTimeout(() => {
+					unsub();
+					reject(/* @__PURE__ */ new Error(`claude-code session ${sessionId} did not reply to stop within 5s.`));
+				}, 5e3);
+				timer.unref?.();
+				const unsub = channel.on("bridge-stop", (msg) => {
+					clearTimeout(timer);
+					unsub();
+					resolve2(msg.data);
+				});
+				try {
+					channel.send({ type: "stop" });
+				} catch (err) {
+					clearTimeout(timer);
+					unsub();
+					reject(err);
+				}
+			});
+			let stopTimer;
+			try {
+				if (proc) await Promise.race([proc.wait(), new Promise((resolve2) => {
+					stopTimer = setTimeout(resolve2, 5e3);
+					stopTimer.unref?.();
+				})]);
+			} finally {
+				if (stopTimer) clearTimeout(stopTimer);
+				try {
+					await proc?.kill();
+				} catch {}
+				channel.close();
+			}
+			const lifecycleData = data != null && typeof data === "object" && !Array.isArray(data) ? { ...data } : {};
+			return {
+				type: "resume-session",
+				harnessId: "claude-code",
+				specificationVersion: "harness-v1",
+				data: {
+					...lastClaudeSessionId ? { claudeSessionId: lastClaudeSessionId } : {},
+					...lifecycleData,
+					...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment }
+				}
+			};
+		},
+		doSuspendTurn: async () => {
+			if (stopped) throw new Error(`claude-code session ${sessionId} is stopped; cannot suspend.`);
+			stopped = true;
+			const lastSeenEventId = await channel.suspend();
+			return {
+				type: "continue-turn",
+				harnessId: "claude-code",
+				specificationVersion: "harness-v1",
+				data: {
+					...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment },
+					bridge: {
+						port: bridgePort,
+						token: bridgeToken,
+						lastSeenEventId,
+						...sandboxId == null ? {} : { sandboxId }
+					},
+					...lastClaudeSessionId ? { claudeSessionId: lastClaudeSessionId } : {}
+				}
+			};
+		}
+	};
+}
+function extractUserText(prompt) {
+	if (typeof prompt === "string") return prompt;
+	const { content } = prompt;
+	if (typeof content === "string") return content;
+	const parts = [];
+	for (const part of content) {
+		if (part.type !== "text") throw new HarnessCapabilityUnsupportedError({
+			harnessId: "claude-code",
+			message: `The claude-code harness does not yet support user message parts of type '${part.type}'. Pass a string or a user message whose content contains only text parts.`
+		});
+		parts.push(part.text);
+	}
+	return parts.join("\n\n");
+}
+createClaudeCode();
+//#endregion
+export { createClaudeCode };
+
+//# sourceMappingURL=dist-BZXYHN2X.js.map