@ai-sdk/harness-opencode 1.0.134 → 1.0.136

package/dist/index.js

@@ -1,2064 +1,1629 @@
-// src/opencode-harness.ts
-import path from "path";
-import {
-  commonTool,
-  HARNESS_V1_BUILTIN_TOOLS,
-  HarnessCapabilityUnsupportedError as HarnessCapabilityUnsupportedError2,
-  harnessV1DiagnosticFromBridgeFrame,
-  harnessStateDirectoryPath,
-  harnessSessionDataDirectoryPath
-} from "@ai-sdk/harness";
-import {
-  applyCredentialForwarding,
-  classifyDiskLog,
-  createSandboxCredentialEnvironment,
-  createBridgeToken,
-  experimental_createBridgeUserMessageSubmitter,
-  createBridgeErrorHandler,
-  createBridgeStartupError,
-  drainBridgeProcessStream,
-  forwardBridgeProcessStream,
-  getRestrictedSandboxSession,
-  markBridgeStarting,
-  resolveSandboxHomeDir,
-  SandboxChannel,
-  shellQuote,
-  warnCredentialBrokeringUnavailable,
-  waitForBridgeReady,
-  withBridgeToken,
-  writeSkills
-} from "@ai-sdk/harness/utils";
-import {
-  safeParseJSON as safeParseJSON2,
-  tool
-} from "@ai-sdk/provider-utils";
+import path, { dirname, join } from "node: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, drainBridgeProcessStream, experimental_createBridgeUserMessageSubmitter, forwardBridgeProcessStream, getAiGatewayAuthFromEnv, getRestrictedSandboxSession, isAccessTokenExpiringSoon, isHarnessAuthenticationEnvironment, isWindows, markBridgeStarting, parseJwtPayload, refreshOAuthAccessToken, resolveSandboxCredentialEnvironment, resolveSandboxHomeDir, shellQuote, waitForBridgeReady, warnCredentialBrokeringUnavailable, withBridgeToken, writeSkills } from "@ai-sdk/harness/utils";
+import { isRecord, safeParseJSON, tool } from "@ai-sdk/provider-utils";
 import { WebSocket } from "ws";
-import { z as z2 } from "zod/v4";
-
-// src/opencode-bootstrap.ts
-import { createReadBridgeAsset } from "@ai-sdk/harness/utils";
-var readBridgeAsset = createReadBridgeAsset({
-  "package.json": new URL("./bridge/package.json", import.meta.url),
-  "pnpm-lock.yaml": new URL("./bridge/pnpm-lock.yaml", import.meta.url),
-  "pnpm-workspace.yaml": new URL(
-    "./bridge/pnpm-workspace.yaml",
-    import.meta.url
-  ),
-  "index.mjs": new URL("./bridge/index.mjs", import.meta.url),
-  "host-tool-mcp.mjs": new URL("./bridge/host-tool-mcp.mjs", import.meta.url)
+import { z } from "zod/v4";
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+//#region src/opencode-bootstrap.ts
+const readBridgeAsset = createReadBridgeAsset({
+	"package.json": new URL("./bridge/package.json", import.meta.url),
+	"pnpm-lock.yaml": new URL("./bridge/pnpm-lock.yaml", import.meta.url),
+	"pnpm-workspace.yaml": new URL("./bridge/pnpm-workspace.yaml", import.meta.url),
+	"index.mjs": new URL("./bridge/index.mjs", import.meta.url),
+	"host-tool-mcp.mjs": new URL("./bridge/host-tool-mcp.mjs", import.meta.url)
 });
-var OPENCODE_BOOTSTRAP_DIR = ".harness-bootstrap/opencode";
-var cachedBootstrap;
+const OPENCODE_BOOTSTRAP_DIR = ".harness-bootstrap/opencode";
+let cachedBootstrap;
 async function getOpenCodeBootstrap() {
-  if (cachedBootstrap != null) return cachedBootstrap;
-  const [pkg, lock, workspace, bridge, hostToolMcp] = await Promise.all([
-    readBridgeAsset("package.json"),
-    readBridgeAsset("pnpm-lock.yaml"),
-    readBridgeAsset("pnpm-workspace.yaml"),
-    readBridgeAsset("index.mjs"),
-    readBridgeAsset("host-tool-mcp.mjs")
-  ]);
-  cachedBootstrap = {
-    harnessId: "opencode",
-    bootstrapDir: OPENCODE_BOOTSTRAP_DIR,
-    files: [
-      { path: `${OPENCODE_BOOTSTRAP_DIR}/package.json`, content: pkg },
-      { path: `${OPENCODE_BOOTSTRAP_DIR}/pnpm-lock.yaml`, content: lock },
-      {
-        path: `${OPENCODE_BOOTSTRAP_DIR}/pnpm-workspace.yaml`,
-        content: workspace
-      },
-      { path: `${OPENCODE_BOOTSTRAP_DIR}/bridge.mjs`, content: bridge },
-      {
-        path: `${OPENCODE_BOOTSTRAP_DIR}/host-tool-mcp.mjs`,
-        content: hostToolMcp
-      }
-    ],
-    commands: [
-      {
-        command: "pnpm install --frozen-lockfile --store-dir .pnpm-store"
-      },
-      {
-        command: "./node_modules/.bin/opencode --version"
-      }
-    ]
-  };
-  return cachedBootstrap;
+	if (cachedBootstrap != null) return cachedBootstrap;
+	const [pkg, lock, workspace, bridge, hostToolMcp] = await Promise.all([
+		readBridgeAsset("package.json"),
+		readBridgeAsset("pnpm-lock.yaml"),
+		readBridgeAsset("pnpm-workspace.yaml"),
+		readBridgeAsset("index.mjs"),
+		readBridgeAsset("host-tool-mcp.mjs")
+	]);
+	cachedBootstrap = {
+		harnessId: "opencode",
+		bootstrapDir: OPENCODE_BOOTSTRAP_DIR,
+		files: [
+			{
+				path: `${OPENCODE_BOOTSTRAP_DIR}/package.json`,
+				content: pkg
+			},
+			{
+				path: `${OPENCODE_BOOTSTRAP_DIR}/pnpm-lock.yaml`,
+				content: lock
+			},
+			{
+				path: `${OPENCODE_BOOTSTRAP_DIR}/pnpm-workspace.yaml`,
+				content: workspace
+			},
+			{
+				path: `${OPENCODE_BOOTSTRAP_DIR}/bridge.mjs`,
+				content: bridge
+			},
+			{
+				path: `${OPENCODE_BOOTSTRAP_DIR}/host-tool-mcp.mjs`,
+				content: hostToolMcp
+			}
+		],
+		commands: [{ command: "pnpm install --frozen-lockfile --store-dir .pnpm-store" }, { command: "./node_modules/.bin/opencode --version" }]
+	};
+	return cachedBootstrap;
 }
-
-// src/opencode-auth.ts
-import {
-  createCredentialRequestTransformation,
-  getAiGatewayAuthFromEnv,
-  isHarnessAuthenticationEnvironment
-} from "@ai-sdk/harness/utils";
-var OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE = "AI_SDK_OPENCODE_NATIVE_ACCESS_TOKEN";
-var OPENCODE_CREDENTIAL_ENVIRONMENT_VARIABLES = [
-  "AI_GATEWAY_API_KEY",
-  "OPENAI_API_KEY",
-  "ANTHROPIC_API_KEY",
-  "ANTHROPIC_AUTH_TOKEN",
-  "GOOGLE_GENERATIVE_AI_API_KEY",
-  "XAI_API_KEY",
-  "GITHUB_TOKEN",
-  "GITHUB_COPILOT_TOKEN",
-  "POE_API_KEY",
-  "OPENCODE_API_KEY",
-  "GITLAB_TOKEN",
-  OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE
+//#endregion
+//#region src/opencode-auth.ts
+const OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE = "AI_SDK_OPENCODE_NATIVE_ACCESS_TOKEN";
+const OPENCODE_CREDENTIAL_ENVIRONMENT_VARIABLES = [
+	"AI_GATEWAY_API_KEY",
+	"OPENAI_API_KEY",
+	"ANTHROPIC_API_KEY",
+	"ANTHROPIC_AUTH_TOKEN",
+	"GOOGLE_GENERATIVE_AI_API_KEY",
+	"XAI_API_KEY",
+	"GITHUB_TOKEN",
+	"GITHUB_COPILOT_TOKEN",
+	"POE_API_KEY",
+	"OPENCODE_API_KEY",
+	"GITLAB_TOKEN",
+	OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE
 ];
-var NON_GOOGLE_DIRECT_CREDENTIAL_ENVIRONMENT_VARIABLES = [
-  "OPENAI_API_KEY",
-  "ANTHROPIC_API_KEY",
-  "ANTHROPIC_AUTH_TOKEN",
-  "XAI_API_KEY",
-  "GITHUB_TOKEN",
-  "GITHUB_COPILOT_TOKEN",
-  "POE_API_KEY",
-  "OPENCODE_API_KEY",
-  "GITLAB_TOKEN"
+const NON_GOOGLE_DIRECT_CREDENTIAL_ENVIRONMENT_VARIABLES = [
+	"OPENAI_API_KEY",
+	"ANTHROPIC_API_KEY",
+	"ANTHROPIC_AUTH_TOKEN",
+	"XAI_API_KEY",
+	"GITHUB_TOKEN",
+	"GITHUB_COPILOT_TOKEN",
+	"POE_API_KEY",
+	"OPENCODE_API_KEY",
+	"GITLAB_TOKEN"
 ];
-function createOpenCodeRequestTransformations({
-  env: environment,
-  sandboxEnv: sandboxEnvironment,
-  auth: authenticationMode
-}) {
-  switch (authenticationMode) {
-    case "ai-gateway":
-      return environment.AI_GATEWAY_API_KEY && sandboxEnvironment.AI_GATEWAY_API_KEY ? [
-        createCredentialRequestTransformation({
-          matchUrl: environment.AI_GATEWAY_BASE_URL,
-          matchHeaders: {
-            "x-api-key": sandboxEnvironment.AI_GATEWAY_API_KEY
-          },
-          transformHeaders: {
-            Authorization: `Bearer ${environment.AI_GATEWAY_API_KEY}`
-          }
-        }),
-        createCredentialRequestTransformation({
-          matchUrl: environment.AI_GATEWAY_BASE_URL,
-          matchHeaders: {
-            Authorization: `Bearer ${sandboxEnvironment.AI_GATEWAY_API_KEY}`
-          },
-          transformHeaders: {
-            Authorization: `Bearer ${environment.AI_GATEWAY_API_KEY}`
-          }
-        })
-      ] : [];
-    case "openai":
-      return environment.OPENAI_API_KEY && sandboxEnvironment.OPENAI_API_KEY ? [
-        createCredentialRequestTransformation({
-          matchUrl: environment.OPENAI_BASE_URL ?? "https://api.openai.com/v1",
-          matchHeaders: {
-            Authorization: `Bearer ${sandboxEnvironment.OPENAI_API_KEY}`
-          },
-          transformHeaders: {
-            Authorization: `Bearer ${environment.OPENAI_API_KEY}`
-          }
-        })
-      ] : [];
-    case "anthropic": {
-      const matchUrl = 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;
-    }
-    case "google":
-      return environment.GOOGLE_GENERATIVE_AI_API_KEY && sandboxEnvironment.GOOGLE_GENERATIVE_AI_API_KEY ? [
-        createCredentialRequestTransformation({
-          matchUrl: "https://generativelanguage.googleapis.com",
-          matchHeaders: {
-            "x-goog-api-key": sandboxEnvironment.GOOGLE_GENERATIVE_AI_API_KEY
-          },
-          transformHeaders: {
-            "x-goog-api-key": environment.GOOGLE_GENERATIVE_AI_API_KEY
-          }
-        })
-      ] : [];
-    case "xai":
-      return createBearerTransformation({
-        environment,
-        sandboxEnvironment,
-        environmentVariableName: "XAI_API_KEY",
-        matchUrl: environment.XAI_BASE_URL ?? "https://api.x.ai/v1"
-      });
-    case "github-copilot":
-      return createBearerTransformation({
-        environment,
-        sandboxEnvironment,
-        environmentVariableName: environment.GITHUB_COPILOT_TOKEN != null ? "GITHUB_COPILOT_TOKEN" : "GITHUB_TOKEN",
-        matchUrl: "https://api.githubcopilot.com"
-      });
-    case "poe":
-      return createBearerTransformation({
-        environment,
-        sandboxEnvironment,
-        environmentVariableName: "POE_API_KEY",
-        matchUrl: "https://api.poe.com"
-      });
-    case "opencode-go":
-      return createBearerTransformation({
-        environment,
-        sandboxEnvironment,
-        environmentVariableName: "OPENCODE_API_KEY",
-        matchUrl: "https://opencode.ai/zen/go/v1"
-      });
-    case "gitlab":
-      return createBearerTransformation({
-        environment,
-        sandboxEnvironment,
-        environmentVariableName: "GITLAB_TOKEN",
-        matchUrl: environment.GITLAB_INSTANCE_URL ?? "https://gitlab.com"
-      });
-  }
+function createOpenCodeRequestTransformations({ env: environment, sandboxEnv: sandboxEnvironment, auth: authenticationMode }) {
+	switch (authenticationMode) {
+		case "ai-gateway": return environment.AI_GATEWAY_API_KEY && sandboxEnvironment.AI_GATEWAY_API_KEY ? [createCredentialRequestTransformation({
+			matchUrl: environment.AI_GATEWAY_BASE_URL,
+			matchHeaders: { "x-api-key": sandboxEnvironment.AI_GATEWAY_API_KEY },
+			transformHeaders: { Authorization: `Bearer ${environment.AI_GATEWAY_API_KEY}` }
+		}), createCredentialRequestTransformation({
+			matchUrl: environment.AI_GATEWAY_BASE_URL,
+			matchHeaders: { Authorization: `Bearer ${sandboxEnvironment.AI_GATEWAY_API_KEY}` },
+			transformHeaders: { Authorization: `Bearer ${environment.AI_GATEWAY_API_KEY}` }
+		})] : [];
+		case "openai": return environment.OPENAI_API_KEY && sandboxEnvironment.OPENAI_API_KEY ? [createCredentialRequestTransformation({
+			matchUrl: environment.OPENAI_BASE_URL ?? "https://api.openai.com/v1",
+			matchHeaders: { Authorization: `Bearer ${sandboxEnvironment.OPENAI_API_KEY}` },
+			transformHeaders: { Authorization: `Bearer ${environment.OPENAI_API_KEY}` }
+		})] : [];
+		case "anthropic": {
+			const matchUrl = 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;
+		}
+		case "google": return environment.GOOGLE_GENERATIVE_AI_API_KEY && sandboxEnvironment.GOOGLE_GENERATIVE_AI_API_KEY ? [createCredentialRequestTransformation({
+			matchUrl: "https://generativelanguage.googleapis.com",
+			matchHeaders: { "x-goog-api-key": sandboxEnvironment.GOOGLE_GENERATIVE_AI_API_KEY },
+			transformHeaders: { "x-goog-api-key": environment.GOOGLE_GENERATIVE_AI_API_KEY }
+		})] : [];
+		case "xai": return createBearerTransformation({
+			environment,
+			sandboxEnvironment,
+			environmentVariableName: "XAI_API_KEY",
+			matchUrl: environment.XAI_BASE_URL ?? "https://api.x.ai/v1"
+		});
+		case "github-copilot": return createBearerTransformation({
+			environment,
+			sandboxEnvironment,
+			environmentVariableName: environment.GITHUB_COPILOT_TOKEN != null ? "GITHUB_COPILOT_TOKEN" : "GITHUB_TOKEN",
+			matchUrl: "https://api.githubcopilot.com"
+		});
+		case "poe": return createBearerTransformation({
+			environment,
+			sandboxEnvironment,
+			environmentVariableName: "POE_API_KEY",
+			matchUrl: "https://api.poe.com"
+		});
+		case "opencode-go": return createBearerTransformation({
+			environment,
+			sandboxEnvironment,
+			environmentVariableName: "OPENCODE_API_KEY",
+			matchUrl: "https://opencode.ai/zen/go/v1"
+		});
+		case "gitlab": return createBearerTransformation({
+			environment,
+			sandboxEnvironment,
+			environmentVariableName: "GITLAB_TOKEN",
+			matchUrl: environment.GITLAB_INSTANCE_URL ?? "https://gitlab.com"
+		});
+	}
 }
-function resolveOpenCodeProvider({
-  model,
-  provider
-}) {
-  if (isDirectProvider(provider)) {
-    return provider;
-  }
-  if (model?.includes("/")) {
-    const [modelProvider] = model.split("/");
-    if (isDirectProvider(modelProvider)) {
-      return modelProvider;
-    }
-  }
-  return "anthropic";
+function resolveOpenCodeProvider({ model, provider }) {
+	if (isDirectProvider(provider)) return provider;
+	if (model?.includes("/")) {
+		const [modelProvider] = model.split("/");
+		if (isDirectProvider(modelProvider)) return modelProvider;
+	}
+	return "anthropic";
 }
-function resolveOpenCodeEnv({
-  auth,
-  model,
-  provider,
-  processEnv = process.env
-}) {
-  const suppliedEnvironment = isHarnessAuthenticationEnvironment(auth);
-  const authenticationEnvironment = suppliedEnvironment ? auth : processEnv;
-  const selectedProvider = resolveOpenCodeAuthenticationProvider({
-    auth,
-    model,
-    provider,
-    environment: authenticationEnvironment
-  });
-  if (selectedProvider === "openai" && auth === "openai" || selectedProvider === "anthropic" && auth === "anthropic") {
-    return pickDirectProvider({
-      provider: selectedProvider,
-      processEnv: authenticationEnvironment
-    });
-  }
-  const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({
-    env: authenticationEnvironment
-  });
-  if (auth === "ai-gateway" || gatewayAuthFromEnv.apiKey) {
-    return pickGateway({ gatewayAuthFromEnv });
-  }
-  return pickDirectProvider({
-    provider: selectedProvider,
-    processEnv: authenticationEnvironment
-  });
+function resolveOpenCodeEnv({ auth, model, provider, processEnv = process.env }) {
+	const authenticationEnvironment = isHarnessAuthenticationEnvironment(auth) ? auth : processEnv;
+	const selectedProvider = resolveOpenCodeAuthenticationProvider({
+		auth,
+		model,
+		provider,
+		environment: authenticationEnvironment
+	});
+	if (selectedProvider === "openai" && auth === "openai" || selectedProvider === "anthropic" && auth === "anthropic") return pickDirectProvider({
+		provider: selectedProvider,
+		processEnv: authenticationEnvironment
+	});
+	const gatewayAuthFromEnv = getAiGatewayAuthFromEnv({ env: authenticationEnvironment });
+	if (auth === "ai-gateway" || gatewayAuthFromEnv.apiKey) return pickGateway({ gatewayAuthFromEnv });
+	return pickDirectProvider({
+		provider: selectedProvider,
+		processEnv: authenticationEnvironment
+	});
 }
-function resolveOpenCodeAuthenticationMode({
-  auth,
-  model,
-  provider,
-  processEnv = process.env
-}) {
-  if (isHarnessAuthenticationEnvironment(auth)) {
-    return getAiGatewayAuthFromEnv({ env: auth }).apiKey ? "ai-gateway" : resolveOpenCodeAuthenticationProvider({
-      auth,
-      model,
-      provider,
-      environment: auth
-    });
-  }
-  const selectedProvider = resolveOpenCodeAuthenticationProvider({
-    auth,
-    model,
-    provider,
-    environment: processEnv
-  });
-  if (selectedProvider === "openai" && auth === "openai") {
-    return "openai";
-  }
-  if (selectedProvider === "anthropic" && auth === "anthropic") {
-    return "anthropic";
-  }
-  if (auth === "ai-gateway") {
-    return "ai-gateway";
-  }
-  if (getAiGatewayAuthFromEnv({ env: processEnv }).apiKey) {
-    return "ai-gateway";
-  }
-  return selectedProvider;
+function resolveOpenCodeAuthenticationMode({ auth, model, provider, processEnv = process.env }) {
+	if (isHarnessAuthenticationEnvironment(auth)) return getAiGatewayAuthFromEnv({ env: auth }).apiKey ? "ai-gateway" : resolveOpenCodeAuthenticationProvider({
+		auth,
+		model,
+		provider,
+		environment: auth
+	});
+	const selectedProvider = resolveOpenCodeAuthenticationProvider({
+		auth,
+		model,
+		provider,
+		environment: processEnv
+	});
+	if (selectedProvider === "openai" && auth === "openai") return "openai";
+	if (selectedProvider === "anthropic" && auth === "anthropic") return "anthropic";
+	if (auth === "ai-gateway") return "ai-gateway";
+	if (getAiGatewayAuthFromEnv({ env: processEnv }).apiKey) return "ai-gateway";
+	return selectedProvider;
 }
-function resolveOpenCodeAuthenticationProvider({
-  auth,
-  model,
-  provider,
-  environment
-}) {
-  const selectedProvider = resolveOpenCodeProvider({ model, provider });
-  if (model == null && provider == null && (auth === "anthropic" || auth === "openai")) {
-    return auth;
-  }
-  return model == null && provider == null && (environment.GOOGLE_GENERATIVE_AI_API_KEY?.length ?? 0) > 0 && !NON_GOOGLE_DIRECT_CREDENTIAL_ENVIRONMENT_VARIABLES.some(
-    (name) => (environment[name]?.length ?? 0) > 0
-  ) ? "google" : selectedProvider;
+function resolveOpenCodeAuthenticationProvider({ auth, model, provider, environment }) {
+	const selectedProvider = resolveOpenCodeProvider({
+		model,
+		provider
+	});
+	if (model == null && provider == null && (auth === "anthropic" || auth === "openai")) return auth;
+	return model == null && provider == null && (environment.GOOGLE_GENERATIVE_AI_API_KEY?.length ?? 0) > 0 && !NON_GOOGLE_DIRECT_CREDENTIAL_ENVIRONMENT_VARIABLES.some((name) => (environment[name]?.length ?? 0) > 0) ? "google" : selectedProvider;
 }
-function pickOpenAI({
-  processEnv
-}) {
-  const env = {};
-  const apiKey = processEnv.OPENAI_API_KEY;
-  if (apiKey) env.OPENAI_API_KEY = apiKey;
-  const baseUrl = processEnv.OPENAI_BASE_URL;
-  if (baseUrl) env.OPENAI_BASE_URL = baseUrl;
-  const organization = processEnv.OPENAI_ORGANIZATION;
-  if (organization) env.OPENAI_ORGANIZATION = organization;
-  const project = processEnv.OPENAI_PROJECT;
-  if (project) env.OPENAI_PROJECT = project;
-  return env;
+function pickOpenAI({ processEnv }) {
+	const env = {};
+	const apiKey = processEnv.OPENAI_API_KEY;
+	if (apiKey) env.OPENAI_API_KEY = apiKey;
+	const baseUrl = processEnv.OPENAI_BASE_URL;
+	if (baseUrl) env.OPENAI_BASE_URL = baseUrl;
+	const organization = processEnv.OPENAI_ORGANIZATION;
+	if (organization) env.OPENAI_ORGANIZATION = organization;
+	const project = processEnv.OPENAI_PROJECT;
+	if (project) env.OPENAI_PROJECT = project;
+	return env;
 }
-function pickAnthropic({
-  processEnv
-}) {
-  const env = {};
-  const apiKey = processEnv.ANTHROPIC_API_KEY;
-  if (apiKey) env.ANTHROPIC_API_KEY = apiKey;
-  const authToken = processEnv.ANTHROPIC_AUTH_TOKEN;
-  if (authToken) env.ANTHROPIC_AUTH_TOKEN = authToken;
-  const baseUrl = processEnv.ANTHROPIC_BASE_URL;
-  if (baseUrl) env.ANTHROPIC_BASE_URL = baseUrl;
-  return env;
+function pickAnthropic({ processEnv }) {
+	const env = {};
+	const apiKey = processEnv.ANTHROPIC_API_KEY;
+	if (apiKey) env.ANTHROPIC_API_KEY = apiKey;
+	const authToken = processEnv.ANTHROPIC_AUTH_TOKEN;
+	if (authToken) env.ANTHROPIC_AUTH_TOKEN = authToken;
+	const baseUrl = processEnv.ANTHROPIC_BASE_URL;
+	if (baseUrl) env.ANTHROPIC_BASE_URL = baseUrl;
+	return env;
 }
-function pickDirectProvider({
-  provider,
-  processEnv
-}) {
-  if (provider === "openai") return pickOpenAI({ processEnv });
-  if (provider === "anthropic") return pickAnthropic({ processEnv });
-  const names = provider === "google" ? ["GOOGLE_GENERATIVE_AI_API_KEY"] : provider === "xai" ? ["XAI_API_KEY", "XAI_BASE_URL"] : provider === "github-copilot" ? ["GITHUB_COPILOT_TOKEN", "GITHUB_TOKEN"] : provider === "poe" ? ["POE_API_KEY"] : provider === "opencode-go" ? ["OPENCODE_API_KEY"] : ["GITLAB_TOKEN", "GITLAB_INSTANCE_URL"];
-  return Object.fromEntries(
-    names.flatMap(
-      (name) => processEnv[name] == null ? [] : [[name, processEnv[name]]]
-    )
-  );
+function pickDirectProvider({ provider, processEnv }) {
+	if (provider === "openai") return pickOpenAI({ processEnv });
+	if (provider === "anthropic") return pickAnthropic({ processEnv });
+	return Object.fromEntries((provider === "google" ? ["GOOGLE_GENERATIVE_AI_API_KEY"] : provider === "xai" ? ["XAI_API_KEY", "XAI_BASE_URL"] : provider === "github-copilot" ? ["GITHUB_COPILOT_TOKEN", "GITHUB_TOKEN"] : provider === "poe" ? ["POE_API_KEY"] : provider === "opencode-go" ? ["OPENCODE_API_KEY"] : ["GITLAB_TOKEN", "GITLAB_INSTANCE_URL"]).flatMap((name) => processEnv[name] == null ? [] : [[name, processEnv[name]]]));
 }
-function hasOpenCodeCredential({
-  environment,
-  authenticationMode
-}) {
-  if (authenticationMode === "ai-gateway") {
-    return environment.AI_GATEWAY_API_KEY != null;
-  }
-  return Object.keys(environment).some(
-    (name) => name.endsWith("_API_KEY") || name.endsWith("_TOKEN") || name === "ANTHROPIC_AUTH_TOKEN"
-  );
+function hasOpenCodeCredential({ environment, authenticationMode }) {
+	if (authenticationMode === "ai-gateway") return environment.AI_GATEWAY_API_KEY != null;
+	return Object.keys(environment).some((name) => name.endsWith("_API_KEY") || name.endsWith("_TOKEN") || name === "ANTHROPIC_AUTH_TOKEN");
 }
-function createBearerTransformation({
-  environment,
-  sandboxEnvironment,
-  environmentVariableName,
-  matchUrl
-}) {
-  const credential = environment[environmentVariableName];
-  const sandboxCredential = sandboxEnvironment[environmentVariableName];
-  return credential == null || sandboxCredential == null ? [] : [
-    createCredentialRequestTransformation({
-      matchUrl,
-      matchHeaders: {
-        Authorization: `Bearer ${sandboxCredential}`
-      },
-      transformHeaders: { Authorization: `Bearer ${credential}` }
-    })
-  ];
+function createBearerTransformation({ environment, sandboxEnvironment, environmentVariableName, matchUrl }) {
+	const credential = environment[environmentVariableName];
+	const sandboxCredential = sandboxEnvironment[environmentVariableName];
+	return credential == null || sandboxCredential == null ? [] : [createCredentialRequestTransformation({
+		matchUrl,
+		matchHeaders: { Authorization: `Bearer ${sandboxCredential}` },
+		transformHeaders: { Authorization: `Bearer ${credential}` }
+	})];
 }
 function isDirectProvider(value) {
-  return value === "anthropic" || value === "openai" || value === "google" || value === "xai" || value === "github-copilot" || value === "poe" || value === "opencode-go" || value === "gitlab";
+	return value === "anthropic" || value === "openai" || value === "google" || value === "xai" || value === "github-copilot" || value === "poe" || value === "opencode-go" || value === "gitlab";
 }
-function pickGateway({
-  gatewayAuthFromEnv
-}) {
-  const env = {};
-  const apiKey = gatewayAuthFromEnv.apiKey;
-  if (apiKey) env.AI_GATEWAY_API_KEY = apiKey;
-  const baseUrl = toOpenCodeGatewayBaseUrl(gatewayAuthFromEnv.baseUrl);
-  env.AI_GATEWAY_BASE_URL = baseUrl;
-  return env;
+function pickGateway({ gatewayAuthFromEnv }) {
+	const env = {};
+	const apiKey = gatewayAuthFromEnv.apiKey;
+	if (apiKey) env.AI_GATEWAY_API_KEY = apiKey;
+	env.AI_GATEWAY_BASE_URL = toOpenCodeGatewayBaseUrl(gatewayAuthFromEnv.baseUrl);
+	return env;
 }
 function toOpenCodeGatewayBaseUrl(baseUrl) {
-  const trimmed = baseUrl.replace(/\/+$/, "");
-  return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
+	const trimmed = baseUrl.replace(/\/+$/, "");
+	return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
 }
-
-// src/opencode-subscription.ts
-import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
-import { homedir } from "os";
-import { dirname, join } from "path";
-import {
-  HarnessCapabilityUnsupportedError
-} from "@ai-sdk/harness";
-import {
-  createCredentialRequestTransformation as createCredentialRequestTransformation2,
-  isAccessTokenExpiringSoon,
-  isHarnessAuthenticationEnvironment as isHarnessAuthenticationEnvironment2,
-  isWindows,
-  parseJwtPayload,
-  refreshOAuthAccessToken
-} from "@ai-sdk/harness/utils";
-import { isRecord, safeParseJSON } from "@ai-sdk/provider-utils";
-var OPENAI_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
-var XAI_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828";
-var GITLAB_CLIENT_ID = "1d89f9fdb23ee96d4e603201f6861dab6e143c5c3c00469a018a2d94bdc03d4e";
-var GITLAB_AI_GATEWAY_URL = "https://cloud.gitlab.com";
-var GITLAB_ANTHROPIC_PROVIDER_ID = "ai-sdk-gitlab-anthropic";
-var GITLAB_OPENAI_CHAT_PROVIDER_ID = "ai-sdk-gitlab-openai-chat";
-var GITLAB_OPENAI_RESPONSES_PROVIDER_ID = "ai-sdk-gitlab-openai-responses";
-var OPEN_CODE_GITLAB_MODELS = {
-  "duo-chat-fable-5": {
-    providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
-    modelId: "claude-fable-5"
-  },
-  "duo-chat-opus-5": {
-    providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
-    modelId: "claude-opus-5"
-  },
-  "duo-chat-opus-4-8": {
-    providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
-    modelId: "claude-opus-4-8"
-  },
-  "duo-chat-opus-4-7": {
-    providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
-    modelId: "claude-opus-4-7"
-  },
-  "duo-chat-opus-4-6": {
-    providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
-    modelId: "claude-opus-4-6"
-  },
-  "duo-chat-sonnet-5": {
-    providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
-    modelId: "claude-sonnet-5"
-  },
-  "duo-chat-sonnet-4-6": {
-    providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
-    modelId: "claude-sonnet-4-6"
-  },
-  "duo-chat-opus-4-5": {
-    providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
-    modelId: "claude-opus-4-5-20251101"
-  },
-  "duo-chat-sonnet-4-5": {
-    providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
-    modelId: "claude-sonnet-4-5-20250929"
-  },
-  "duo-chat-haiku-4-5": {
-    providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
-    modelId: "claude-haiku-4-5-20251001"
-  },
-  "duo-chat-gpt-5-1": {
-    providerId: GITLAB_OPENAI_CHAT_PROVIDER_ID,
-    modelId: "gpt-5.1-2025-11-13"
-  },
-  "duo-chat-gpt-5-2": {
-    providerId: GITLAB_OPENAI_CHAT_PROVIDER_ID,
-    modelId: "gpt-5.2-2025-12-11"
-  },
-  "duo-chat-gpt-5-4": {
-    providerId: GITLAB_OPENAI_CHAT_PROVIDER_ID,
-    modelId: "gpt-5.4-2026-03-05"
-  },
-  "duo-chat-gpt-5-5": {
-    providerId: GITLAB_OPENAI_CHAT_PROVIDER_ID,
-    modelId: "gpt-5.5-2026-04-23"
-  },
-  "duo-chat-gpt-5-mini": {
-    providerId: GITLAB_OPENAI_CHAT_PROVIDER_ID,
-    modelId: "gpt-5-mini-2025-08-07"
-  },
-  "duo-chat-gpt-5-4-mini": {
-    providerId: GITLAB_OPENAI_CHAT_PROVIDER_ID,
-    modelId: "gpt-5.4-mini"
-  },
-  "duo-chat-gpt-5-4-nano": {
-    providerId: GITLAB_OPENAI_CHAT_PROVIDER_ID,
-    modelId: "gpt-5.4-nano"
-  },
-  "duo-chat-gpt-5-6-sol": {
-    providerId: GITLAB_OPENAI_RESPONSES_PROVIDER_ID,
-    modelId: "gpt-5.6-sol"
-  },
-  "duo-chat-gpt-5-6-terra": {
-    providerId: GITLAB_OPENAI_RESPONSES_PROVIDER_ID,
-    modelId: "gpt-5.6-terra"
-  },
-  "duo-chat-gpt-5-6-luna": {
-    providerId: GITLAB_OPENAI_RESPONSES_PROVIDER_ID,
-    modelId: "gpt-5.6-luna"
-  },
-  "duo-chat-gpt-5-codex": {
-    providerId: GITLAB_OPENAI_RESPONSES_PROVIDER_ID,
-    modelId: "gpt-5-codex"
-  },
-  "duo-chat-gpt-5-2-codex": {
-    providerId: GITLAB_OPENAI_RESPONSES_PROVIDER_ID,
-    modelId: "gpt-5.2-codex"
-  },
-  "duo-chat-gpt-5-3-codex": {
-    providerId: GITLAB_OPENAI_RESPONSES_PROVIDER_ID,
-    modelId: "gpt-5.3-codex"
-  },
-  "duo-workflow": { providerId: "workflow", modelId: "default" },
-  "duo-workflow-default": { providerId: "workflow", modelId: "default" },
-  "duo-workflow-sonnet-4-5": {
-    providerId: "workflow",
-    modelId: "anthropic/claude-sonnet-4-5-20250929"
-  },
-  "duo-workflow-sonnet-5": {
-    providerId: "workflow",
-    modelId: "claude_sonnet_5"
-  },
-  "duo-workflow-opus-5": {
-    providerId: "workflow",
-    modelId: "claude_opus_5"
-  },
-  "duo-workflow-sonnet-4-6": {
-    providerId: "workflow",
-    modelId: "claude_sonnet_4_6"
-  },
-  "duo-workflow-opus-4-5": {
-    providerId: "workflow",
-    modelId: "anthropic/claude-opus-4-5-20251101"
-  },
-  "duo-workflow-haiku-4-5": {
-    providerId: "workflow",
-    modelId: "claude_haiku_4_5_20251001"
-  },
-  "duo-workflow-opus-4-6": {
-    providerId: "workflow",
-    modelId: "claude_opus_4_6_20260205"
-  }
+//#endregion
+//#region src/opencode-subscription.ts
+const OPENAI_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+const XAI_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828";
+const GITLAB_CLIENT_ID = "1d89f9fdb23ee96d4e603201f6861dab6e143c5c3c00469a018a2d94bdc03d4e";
+const GITLAB_AI_GATEWAY_URL = "https://cloud.gitlab.com";
+const GITLAB_ANTHROPIC_PROVIDER_ID = "ai-sdk-gitlab-anthropic";
+const GITLAB_OPENAI_CHAT_PROVIDER_ID = "ai-sdk-gitlab-openai-chat";
+const GITLAB_OPENAI_RESPONSES_PROVIDER_ID = "ai-sdk-gitlab-openai-responses";
+const OPEN_CODE_GITLAB_MODELS = {
+	"duo-chat-fable-5": {
+		providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
+		modelId: "claude-fable-5"
+	},
+	"duo-chat-opus-5": {
+		providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
+		modelId: "claude-opus-5"
+	},
+	"duo-chat-opus-4-8": {
+		providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
+		modelId: "claude-opus-4-8"
+	},
+	"duo-chat-opus-4-7": {
+		providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
+		modelId: "claude-opus-4-7"
+	},
+	"duo-chat-opus-4-6": {
+		providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
+		modelId: "claude-opus-4-6"
+	},
+	"duo-chat-sonnet-5": {
+		providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
+		modelId: "claude-sonnet-5"
+	},
+	"duo-chat-sonnet-4-6": {
+		providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
+		modelId: "claude-sonnet-4-6"
+	},
+	"duo-chat-opus-4-5": {
+		providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
+		modelId: "claude-opus-4-5-20251101"
+	},
+	"duo-chat-sonnet-4-5": {
+		providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
+		modelId: "claude-sonnet-4-5-20250929"
+	},
+	"duo-chat-haiku-4-5": {
+		providerId: GITLAB_ANTHROPIC_PROVIDER_ID,
+		modelId: "claude-haiku-4-5-20251001"
+	},
+	"duo-chat-gpt-5-1": {
+		providerId: GITLAB_OPENAI_CHAT_PROVIDER_ID,
+		modelId: "gpt-5.1-2025-11-13"
+	},
+	"duo-chat-gpt-5-2": {
+		providerId: GITLAB_OPENAI_CHAT_PROVIDER_ID,
+		modelId: "gpt-5.2-2025-12-11"
+	},
+	"duo-chat-gpt-5-4": {
+		providerId: GITLAB_OPENAI_CHAT_PROVIDER_ID,
+		modelId: "gpt-5.4-2026-03-05"
+	},
+	"duo-chat-gpt-5-5": {
+		providerId: GITLAB_OPENAI_CHAT_PROVIDER_ID,
+		modelId: "gpt-5.5-2026-04-23"
+	},
+	"duo-chat-gpt-5-mini": {
+		providerId: GITLAB_OPENAI_CHAT_PROVIDER_ID,
+		modelId: "gpt-5-mini-2025-08-07"
+	},
+	"duo-chat-gpt-5-4-mini": {
+		providerId: GITLAB_OPENAI_CHAT_PROVIDER_ID,
+		modelId: "gpt-5.4-mini"
+	},
+	"duo-chat-gpt-5-4-nano": {
+		providerId: GITLAB_OPENAI_CHAT_PROVIDER_ID,
+		modelId: "gpt-5.4-nano"
+	},
+	"duo-chat-gpt-5-6-sol": {
+		providerId: GITLAB_OPENAI_RESPONSES_PROVIDER_ID,
+		modelId: "gpt-5.6-sol"
+	},
+	"duo-chat-gpt-5-6-terra": {
+		providerId: GITLAB_OPENAI_RESPONSES_PROVIDER_ID,
+		modelId: "gpt-5.6-terra"
+	},
+	"duo-chat-gpt-5-6-luna": {
+		providerId: GITLAB_OPENAI_RESPONSES_PROVIDER_ID,
+		modelId: "gpt-5.6-luna"
+	},
+	"duo-chat-gpt-5-codex": {
+		providerId: GITLAB_OPENAI_RESPONSES_PROVIDER_ID,
+		modelId: "gpt-5-codex"
+	},
+	"duo-chat-gpt-5-2-codex": {
+		providerId: GITLAB_OPENAI_RESPONSES_PROVIDER_ID,
+		modelId: "gpt-5.2-codex"
+	},
+	"duo-chat-gpt-5-3-codex": {
+		providerId: GITLAB_OPENAI_RESPONSES_PROVIDER_ID,
+		modelId: "gpt-5.3-codex"
+	},
+	"duo-workflow": {
+		providerId: "workflow",
+		modelId: "default"
+	},
+	"duo-workflow-default": {
+		providerId: "workflow",
+		modelId: "default"
+	},
+	"duo-workflow-sonnet-4-5": {
+		providerId: "workflow",
+		modelId: "anthropic/claude-sonnet-4-5-20250929"
+	},
+	"duo-workflow-sonnet-5": {
+		providerId: "workflow",
+		modelId: "claude_sonnet_5"
+	},
+	"duo-workflow-opus-5": {
+		providerId: "workflow",
+		modelId: "claude_opus_5"
+	},
+	"duo-workflow-sonnet-4-6": {
+		providerId: "workflow",
+		modelId: "claude_sonnet_4_6"
+	},
+	"duo-workflow-opus-4-5": {
+		providerId: "workflow",
+		modelId: "anthropic/claude-opus-4-5-20251101"
+	},
+	"duo-workflow-haiku-4-5": {
+		providerId: "workflow",
+		modelId: "claude_haiku_4_5_20251001"
+	},
+	"duo-workflow-opus-4-6": {
+		providerId: "workflow",
+		modelId: "claude_opus_4_6_20260205"
+	}
 };
-async function resolveOpenCodeAuthentication({
-  auth,
-  model,
-  provider,
-  processEnv = process.env,
-  readSubscription = readOpenCodeSubscription
-}) {
-  const environment = resolveOpenCodeEnv({
-    auth,
-    model,
-    provider,
-    processEnv
-  });
-  const authenticationMode = resolveOpenCodeAuthenticationMode({
-    auth,
-    model,
-    provider,
-    processEnv
-  });
-  if (isHarnessAuthenticationEnvironment2(auth) || auth === "ai-gateway" || authenticationMode === "ai-gateway" || hasOpenCodeCredential({ environment, authenticationMode })) {
-    return { environment, authenticationMode };
-  }
-  const subscription = await readSubscription({
-    providerId: authenticationMode,
-    env: processEnv
-  });
-  return subscription == null ? { environment, authenticationMode } : {
-    environment: {
-      ...environment,
-      [OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE]: subscription.accessToken
-    },
-    authenticationMode,
-    subscription
-  };
+async function resolveOpenCodeAuthentication({ auth, model, provider, processEnv = process.env, readSubscription = readOpenCodeSubscription }) {
+	const environment = resolveOpenCodeEnv({
+		auth,
+		model,
+		provider,
+		processEnv
+	});
+	const authenticationMode = resolveOpenCodeAuthenticationMode({
+		auth,
+		model,
+		provider,
+		processEnv
+	});
+	if (isHarnessAuthenticationEnvironment(auth) || auth === "ai-gateway" || authenticationMode === "ai-gateway" || hasOpenCodeCredential({
+		environment,
+		authenticationMode
+	})) return {
+		environment,
+		authenticationMode
+	};
+	const subscription = await readSubscription({
+		providerId: authenticationMode,
+		env: processEnv
+	});
+	return subscription == null ? {
+		environment,
+		authenticationMode
+	} : {
+		environment: {
+			...environment,
+			[OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE]: subscription.accessToken
+		},
+		authenticationMode,
+		subscription
+	};
 }
-async function readOpenCodeSubscription({
-  providerId,
-  env = process.env,
-  homeDirectory = homedir(),
-  platform = process.platform,
-  fetch
-}) {
-  if (!isSubscriptionProvider(providerId)) return void 0;
-  const stored = await readStore({ env, homeDirectory, platform });
-  if (stored == null) return void 0;
-  const candidate = stored.value[providerId];
-  if (!isRecord(candidate)) return void 0;
-  if (candidate.type === "api") {
-    return typeof candidate.key === "string" && candidate.key.length > 0 ? { providerId, accessToken: candidate.key } : void 0;
-  }
-  if (candidate.type !== "oauth") return void 0;
-  if (providerId === "opencode-go") return void 0;
-  const access = candidate.access;
-  const refresh = candidate.refresh;
-  const expires = candidate.expires;
-  if (typeof access !== "string" || typeof refresh !== "string" || typeof expires !== "number") {
-    return void 0;
-  }
-  if (providerId === "github-copilot") {
-    return {
-      providerId,
-      accessToken: refresh,
-      ...typeof candidate.enterpriseUrl === "string" ? { enterpriseUrl: candidate.enterpriseUrl } : {}
-    };
-  }
-  if (providerId === "poe") {
-    if (isAccessTokenExpiringSoon({ expiresAt: expires })) {
-      throw new Error(
-        "OpenCode Poe subscription API key is expiring soon. Run OpenCode login again."
-      );
-    }
-    return { providerId, accessToken: access };
-  }
-  let accessToken = access;
-  let accountId = typeof candidate.accountId === "string" ? candidate.accountId : providerId === "openai" ? await extractOpenAIAccountId(access) : void 0;
-  if (isAccessTokenExpiringSoon({ expiresAt: expires })) {
-    const refreshSettings = resolveRefreshSettings({
-      providerId,
-      candidate,
-      env
-    });
-    const refreshed = await refreshOAuthAccessToken({
-      ...refreshSettings,
-      refreshToken: refresh,
-      ...fetch == null ? {} : { fetch }
-    });
-    accessToken = refreshed.accessToken;
-    if (providerId === "openai") {
-      accountId = await extractOpenAIAccountId(refreshed.accessToken) ?? accountId;
-    }
-    stored.value[providerId] = {
-      ...candidate,
-      access: refreshed.accessToken,
-      refresh: refreshed.refreshToken ?? refresh,
-      expires: refreshed.expiresAt,
-      ...accountId == null ? {} : { accountId }
-    };
-    await stored.write?.(stored.value);
-  }
-  return {
-    providerId,
-    accessToken,
-    ...accountId == null ? {} : { accountId },
-    ...typeof candidate.enterpriseUrl === "string" ? { enterpriseUrl: candidate.enterpriseUrl } : {}
-  };
+async function readOpenCodeSubscription({ providerId, env = process.env, homeDirectory = homedir(), platform = process.platform, fetch }) {
+	if (!isSubscriptionProvider(providerId)) return void 0;
+	const stored = await readStore({
+		env,
+		homeDirectory,
+		platform
+	});
+	if (stored == null) return void 0;
+	const candidate = stored.value[providerId];
+	if (!isRecord(candidate)) return void 0;
+	if (candidate.type === "api") return typeof candidate.key === "string" && candidate.key.length > 0 ? {
+		providerId,
+		accessToken: candidate.key
+	} : void 0;
+	if (candidate.type !== "oauth") return void 0;
+	if (providerId === "opencode-go") return void 0;
+	const access = candidate.access;
+	const refresh = candidate.refresh;
+	const expires = candidate.expires;
+	if (typeof access !== "string" || typeof refresh !== "string" || typeof expires !== "number") return;
+	if (providerId === "github-copilot") return {
+		providerId,
+		accessToken: refresh,
+		...typeof candidate.enterpriseUrl === "string" ? { enterpriseUrl: candidate.enterpriseUrl } : {}
+	};
+	if (providerId === "poe") {
+		if (isAccessTokenExpiringSoon({ expiresAt: expires })) throw new Error("OpenCode Poe subscription API key is expiring soon. Run OpenCode login again.");
+		return {
+			providerId,
+			accessToken: access
+		};
+	}
+	let accessToken = access;
+	let accountId = typeof candidate.accountId === "string" ? candidate.accountId : providerId === "openai" ? await extractOpenAIAccountId(access) : void 0;
+	if (isAccessTokenExpiringSoon({ expiresAt: expires })) {
+		const refreshSettings = resolveRefreshSettings({
+			providerId,
+			candidate,
+			env
+		});
+		const refreshed = await refreshOAuthAccessToken({
+			...refreshSettings,
+			refreshToken: refresh,
+			...fetch == null ? {} : { fetch }
+		});
+		accessToken = refreshed.accessToken;
+		if (providerId === "openai") accountId = await extractOpenAIAccountId(refreshed.accessToken) ?? accountId;
+		stored.value[providerId] = {
+			...candidate,
+			access: refreshed.accessToken,
+			refresh: refreshed.refreshToken ?? refresh,
+			expires: refreshed.expiresAt,
+			...accountId == null ? {} : { accountId }
+		};
+		await stored.write?.(stored.value);
+	}
+	return {
+		providerId,
+		accessToken,
+		...accountId == null ? {} : { accountId },
+		...typeof candidate.enterpriseUrl === "string" ? { enterpriseUrl: candidate.enterpriseUrl } : {}
+	};
 }
-async function requestOpenCodeGitLabDirectAccess({
-  accessToken,
-  instanceUrl = "https://gitlab.com",
-  aiGatewayUrl = GITLAB_AI_GATEWAY_URL,
-  fetch: fetchImplementation = globalThis.fetch
-}) {
-  const response = await fetchImplementation(
-    `${instanceUrl.replace(/\/+$/, "")}/api/v4/ai/third_party_agents/direct_access`,
-    {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        feature_flags: { DuoAgentPlatformNext: true }
-      })
-    }
-  );
-  if (!response.ok) {
-    throw new Error(
-      `OpenCode GitLab direct access request failed with status ${response.status}.`
-    );
-  }
-  const parsed = await safeParseJSON({ text: await response.text() });
-  if (!parsed.success || !isRecord(parsed.value)) {
-    throw new Error("OpenCode GitLab direct access returned invalid JSON.");
-  }
-  const token = parsed.value.token;
-  const headers = parsed.value.headers;
-  if (typeof token !== "string" || token.length === 0 || !isRecord(headers) || Object.values(headers).some((value) => typeof value !== "string")) {
-    throw new Error(
-      "OpenCode GitLab direct access returned invalid credentials."
-    );
-  }
-  return {
-    accessToken: token,
-    headers,
-    aiGatewayUrl: aiGatewayUrl.replace(/\/+$/, "")
-  };
+async function requestOpenCodeGitLabDirectAccess({ accessToken, instanceUrl = "https://gitlab.com", aiGatewayUrl = GITLAB_AI_GATEWAY_URL, fetch: fetchImplementation = globalThis.fetch }) {
+	const response = await fetchImplementation(`${instanceUrl.replace(/\/+$/, "")}/api/v4/ai/third_party_agents/direct_access`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${accessToken}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify({ feature_flags: { DuoAgentPlatformNext: true } })
+	});
+	if (!response.ok) throw new Error(`OpenCode GitLab direct access request failed with status ${response.status}.`);
+	const parsed = await safeParseJSON({ text: await response.text() });
+	if (!parsed.success || !isRecord(parsed.value)) throw new Error("OpenCode GitLab direct access returned invalid JSON.");
+	const token = parsed.value.token;
+	const headers = parsed.value.headers;
+	if (typeof token !== "string" || token.length === 0 || !isRecord(headers) || Object.values(headers).some((value) => typeof value !== "string")) throw new Error("OpenCode GitLab direct access returned invalid credentials.");
+	return {
+		accessToken: token,
+		headers,
+		aiGatewayUrl: aiGatewayUrl.replace(/\/+$/, "")
+	};
 }
-function createOpenCodeGitLabSubscriptionRequestTransformations({
-  directAccess,
-  sandboxAccessToken
-}) {
-  const headers = Object.fromEntries(
-    Object.entries(directAccess.headers).filter(
-      ([name]) => name.toLowerCase() !== "authorization" && name.toLowerCase() !== "x-api-key"
-    )
-  );
-  const transformHeaders = {
-    ...headers,
-    Authorization: `Bearer ${directAccess.accessToken}`
-  };
-  return [
-    `${directAccess.aiGatewayUrl}/ai/v1/proxy/anthropic`,
-    `${directAccess.aiGatewayUrl}/ai/v1/proxy/openai/v1`
-  ].map(
-    (matchUrl) => createCredentialRequestTransformation2({
-      matchUrl,
-      matchHeaders: {
-        Authorization: `Bearer ${sandboxAccessToken}`
-      },
-      transformHeaders
-    })
-  );
+function createOpenCodeGitLabSubscriptionRequestTransformations({ directAccess, sandboxAccessToken }) {
+	const transformHeaders = {
+		...Object.fromEntries(Object.entries(directAccess.headers).filter(([name]) => name.toLowerCase() !== "authorization" && name.toLowerCase() !== "x-api-key")),
+		Authorization: `Bearer ${directAccess.accessToken}`
+	};
+	return [`${directAccess.aiGatewayUrl}/ai/v1/proxy/anthropic`, `${directAccess.aiGatewayUrl}/ai/v1/proxy/openai/v1`].map((matchUrl) => createCredentialRequestTransformation({
+		matchUrl,
+		matchHeaders: { Authorization: `Bearer ${sandboxAccessToken}` },
+		transformHeaders
+	}));
 }
-function createOpenCodeGitLabSubscriptionConfig({
-  openCodeConfig,
-  sandboxAccessToken,
-  aiGatewayUrl,
-  headers
-}) {
-  const providerOptions = headers == null ? {} : { headers };
-  const providers = {
-    [GITLAB_ANTHROPIC_PROVIDER_ID]: {
-      name: "GitLab Anthropic",
-      npm: "@ai-sdk/anthropic",
-      api: `${aiGatewayUrl}/ai/v1/proxy/anthropic/v1`,
-      options: { authToken: sandboxAccessToken, ...providerOptions },
-      models: createOpenCodeGitLabModels(GITLAB_ANTHROPIC_PROVIDER_ID)
-    },
-    [GITLAB_OPENAI_CHAT_PROVIDER_ID]: {
-      name: "GitLab OpenAI Chat",
-      npm: "@ai-sdk/openai-compatible",
-      api: `${aiGatewayUrl}/ai/v1/proxy/openai/v1`,
-      options: { apiKey: sandboxAccessToken, ...providerOptions },
-      models: createOpenCodeGitLabModels(GITLAB_OPENAI_CHAT_PROVIDER_ID)
-    },
-    [GITLAB_OPENAI_RESPONSES_PROVIDER_ID]: {
-      name: "GitLab OpenAI Responses",
-      npm: "@ai-sdk/openai",
-      api: `${aiGatewayUrl}/ai/v1/proxy/openai/v1`,
-      options: { apiKey: sandboxAccessToken, ...providerOptions },
-      models: createOpenCodeGitLabModels(GITLAB_OPENAI_RESPONSES_PROVIDER_ID)
-    }
-  };
-  const configuredProviders = isRecord(openCodeConfig?.provider) ? openCodeConfig.provider : {};
-  return {
-    ...openCodeConfig,
-    provider: { ...configuredProviders, ...providers }
-  };
+function createOpenCodeGitLabSubscriptionConfig({ openCodeConfig, sandboxAccessToken, aiGatewayUrl, headers }) {
+	const providerOptions = headers == null ? {} : { headers };
+	const providers = {
+		[GITLAB_ANTHROPIC_PROVIDER_ID]: {
+			name: "GitLab Anthropic",
+			npm: "@ai-sdk/anthropic",
+			api: `${aiGatewayUrl}/ai/v1/proxy/anthropic/v1`,
+			options: {
+				authToken: sandboxAccessToken,
+				...providerOptions
+			},
+			models: createOpenCodeGitLabModels(GITLAB_ANTHROPIC_PROVIDER_ID)
+		},
+		[GITLAB_OPENAI_CHAT_PROVIDER_ID]: {
+			name: "GitLab OpenAI Chat",
+			npm: "@ai-sdk/openai-compatible",
+			api: `${aiGatewayUrl}/ai/v1/proxy/openai/v1`,
+			options: {
+				apiKey: sandboxAccessToken,
+				...providerOptions
+			},
+			models: createOpenCodeGitLabModels(GITLAB_OPENAI_CHAT_PROVIDER_ID)
+		},
+		[GITLAB_OPENAI_RESPONSES_PROVIDER_ID]: {
+			name: "GitLab OpenAI Responses",
+			npm: "@ai-sdk/openai",
+			api: `${aiGatewayUrl}/ai/v1/proxy/openai/v1`,
+			options: {
+				apiKey: sandboxAccessToken,
+				...providerOptions
+			},
+			models: createOpenCodeGitLabModels(GITLAB_OPENAI_RESPONSES_PROVIDER_ID)
+		}
+	};
+	const configuredProviders = isRecord(openCodeConfig?.provider) ? openCodeConfig.provider : {};
+	return {
+		...openCodeConfig,
+		provider: {
+			...configuredProviders,
+			...providers
+		}
+	};
 }
-function resolveOpenCodeGitLabSubscriptionModel({
-  model,
-  provider
-}) {
-  if (model == null) {
-    if (provider === "gitlab") {
-      throw new HarnessCapabilityUnsupportedError({
-        harnessId: "opencode",
-        message: "Harness 'opencode' requires an explicit GitLab model when native GitLab subscription credentials are brokered."
-      });
-    }
-    return void 0;
-  }
-  const modelProvider = model.includes("/") ? model.split("/")[0] : provider;
-  if (modelProvider !== "gitlab") return model;
-  const modelId = model.includes("/") ? model.slice(model.indexOf("/") + 1) : model;
-  const mapping = OPEN_CODE_GITLAB_MODELS[modelId];
-  if (mapping == null) {
-    throw new HarnessCapabilityUnsupportedError({
-      harnessId: "opencode",
-      message: `Harness 'opencode' cannot broker native GitLab subscription credentials for unknown model '${modelId}'.`
-    });
-  }
-  if (mapping.providerId === "workflow") {
-    throw new HarnessCapabilityUnsupportedError({
-      harnessId: "opencode",
-      message: `Harness 'opencode' cannot broker native GitLab subscription credentials for workflow model '${modelId}' because it authenticates over WebSocket. Use a sandbox without credential brokering to use the credential-forwarding fallback.`
-    });
-  }
-  return `${mapping.providerId}/${modelId}`;
+function resolveOpenCodeGitLabSubscriptionModel({ model, provider }) {
+	if (model == null) {
+		if (provider === "gitlab") throw new HarnessCapabilityUnsupportedError({
+			harnessId: "opencode",
+			message: "Harness 'opencode' requires an explicit GitLab model when native GitLab subscription credentials are brokered."
+		});
+		return;
+	}
+	if ((model.includes("/") ? model.split("/")[0] : provider) !== "gitlab") return model;
+	const modelId = model.includes("/") ? model.slice(model.indexOf("/") + 1) : model;
+	const mapping = OPEN_CODE_GITLAB_MODELS[modelId];
+	if (mapping == null) throw new HarnessCapabilityUnsupportedError({
+		harnessId: "opencode",
+		message: `Harness 'opencode' cannot broker native GitLab subscription credentials for unknown model '${modelId}'.`
+	});
+	if (mapping.providerId === "workflow") throw new HarnessCapabilityUnsupportedError({
+		harnessId: "opencode",
+		message: `Harness 'opencode' cannot broker native GitLab subscription credentials for workflow model '${modelId}' because it authenticates over WebSocket. Use a sandbox without credential brokering to use the credential-forwarding fallback.`
+	});
+	return `${mapping.providerId}/${modelId}`;
 }
 function createOpenCodeGitLabModels(providerId) {
-  return Object.fromEntries(
-    Object.entries(OPEN_CODE_GITLAB_MODELS).flatMap(
-      ([id, model]) => model.providerId === providerId ? [[id, { id: model.modelId, name: id }]] : []
-    )
-  );
+	return Object.fromEntries(Object.entries(OPEN_CODE_GITLAB_MODELS).flatMap(([id, model]) => model.providerId === providerId ? [[id, {
+		id: model.modelId,
+		name: id
+	}]] : []));
 }
-function createOpenCodeSubscriptionAuthContent({
-  authentication,
-  accessToken
-}) {
-  const { providerId } = authentication;
-  const value = providerId === "opencode-go" ? { type: "api", key: accessToken } : {
-    type: "oauth",
-    access: accessToken,
-    refresh: providerId === "github-copilot" ? accessToken : "host-managed",
-    expires: Number.MAX_SAFE_INTEGER,
-    ...authentication.accountId == null ? {} : { accountId: authentication.accountId },
-    ...authentication.enterpriseUrl == null ? {} : { enterpriseUrl: authentication.enterpriseUrl }
-  };
-  return JSON.stringify({ [providerId]: value });
+function createOpenCodeSubscriptionAuthContent({ authentication, accessToken }) {
+	const { providerId } = authentication;
+	const value = providerId === "opencode-go" ? {
+		type: "api",
+		key: accessToken
+	} : {
+		type: "oauth",
+		access: accessToken,
+		refresh: providerId === "github-copilot" ? accessToken : "host-managed",
+		expires: Number.MAX_SAFE_INTEGER,
+		...authentication.accountId == null ? {} : { accountId: authentication.accountId },
+		...authentication.enterpriseUrl == null ? {} : { enterpriseUrl: authentication.enterpriseUrl }
+	};
+	return JSON.stringify({ [providerId]: value });
 }
-function createOpenCodeSubscriptionRequestTransformations({
-  authentication,
-  sandboxAccessToken
-}) {
-  const matchUrl = resolveRequestUrl(authentication);
-  const transformHeaders = {
-    Authorization: `Bearer ${authentication.accessToken}`,
-    ...authentication.providerId === "openai" && authentication.accountId ? { "ChatGPT-Account-Id": authentication.accountId } : {}
-  };
-  const transformations = [
-    createCredentialRequestTransformation2({
-      matchUrl,
-      matchHeaders: {
-        Authorization: `Bearer ${sandboxAccessToken}`
-      },
-      transformHeaders
-    })
-  ];
-  if (authentication.providerId === "poe" || authentication.providerId === "opencode-go") {
-    transformations.push(
-      createCredentialRequestTransformation2({
-        matchUrl,
-        matchHeaders: { "x-api-key": sandboxAccessToken },
-        transformHeaders: { "x-api-key": authentication.accessToken }
-      })
-    );
-  }
-  return transformations;
+function createOpenCodeSubscriptionRequestTransformations({ authentication, sandboxAccessToken }) {
+	const matchUrl = resolveRequestUrl(authentication);
+	const transformHeaders = {
+		Authorization: `Bearer ${authentication.accessToken}`,
+		...authentication.providerId === "openai" && authentication.accountId ? { "ChatGPT-Account-Id": authentication.accountId } : {}
+	};
+	const transformations = [createCredentialRequestTransformation({
+		matchUrl,
+		matchHeaders: { Authorization: `Bearer ${sandboxAccessToken}` },
+		transformHeaders
+	})];
+	if (authentication.providerId === "poe" || authentication.providerId === "opencode-go") transformations.push(createCredentialRequestTransformation({
+		matchUrl,
+		matchHeaders: { "x-api-key": sandboxAccessToken },
+		transformHeaders: { "x-api-key": authentication.accessToken }
+	}));
+	return transformations;
 }
-function resolveRefreshSettings({
-  providerId,
-  candidate,
-  env
-}) {
-  if (providerId === "openai") {
-    return {
-      tokenUrl: "https://auth.openai.com/oauth/token",
-      clientId: OPENAI_CLIENT_ID
-    };
-  }
-  if (providerId === "xai") {
-    return {
-      tokenUrl: "https://auth.x.ai/oauth2/token",
-      clientId: XAI_CLIENT_ID
-    };
-  }
-  const instanceUrl = (typeof candidate.enterpriseUrl === "string" ? candidate.enterpriseUrl : env.GITLAB_INSTANCE_URL) ?? "https://gitlab.com";
-  return {
-    tokenUrl: `${instanceUrl.replace(/\/+$/, "")}/oauth/token`,
-    clientId: env.GITLAB_OAUTH_CLIENT_ID ?? GITLAB_CLIENT_ID
-  };
+function resolveRefreshSettings({ providerId, candidate, env }) {
+	if (providerId === "openai") return {
+		tokenUrl: "https://auth.openai.com/oauth/token",
+		clientId: OPENAI_CLIENT_ID
+	};
+	if (providerId === "xai") return {
+		tokenUrl: "https://auth.x.ai/oauth2/token",
+		clientId: XAI_CLIENT_ID
+	};
+	return {
+		tokenUrl: `${((typeof candidate.enterpriseUrl === "string" ? candidate.enterpriseUrl : env.GITLAB_INSTANCE_URL) ?? "https://gitlab.com").replace(/\/+$/, "")}/oauth/token`,
+		clientId: env.GITLAB_OAUTH_CLIENT_ID ?? GITLAB_CLIENT_ID
+	};
 }
 function resolveRequestUrl(authentication) {
-  switch (authentication.providerId) {
-    case "openai":
-      return "https://chatgpt.com/backend-api/codex";
-    case "xai":
-      return "https://api.x.ai/v1";
-    case "github-copilot":
-      return authentication.enterpriseUrl == null ? "https://api.githubcopilot.com" : `https://copilot-api.${normalizeDomain(authentication.enterpriseUrl)}`;
-    case "poe":
-      return "https://api.poe.com";
-    case "opencode-go":
-      return "https://opencode.ai/zen/go/v1";
-    case "gitlab":
-      return authentication.enterpriseUrl ?? "https://gitlab.com";
-  }
+	switch (authentication.providerId) {
+		case "openai": return "https://chatgpt.com/backend-api/codex";
+		case "xai": return "https://api.x.ai/v1";
+		case "github-copilot": return authentication.enterpriseUrl == null ? "https://api.githubcopilot.com" : `https://copilot-api.${normalizeDomain(authentication.enterpriseUrl)}`;
+		case "poe": return "https://api.poe.com";
+		case "opencode-go": return "https://opencode.ai/zen/go/v1";
+		case "gitlab": return authentication.enterpriseUrl ?? "https://gitlab.com";
+	}
 }
 function normalizeDomain(value) {
-  try {
-    return new URL(value.includes("://") ? value : `https://${value}`).host;
-  } catch {
-    return value.replace(/^https?:\/\//, "").replace(/\/+$/, "");
-  }
+	try {
+		return new URL(value.includes("://") ? value : `https://${value}`).host;
+	} catch {
+		return value.replace(/^https?:\/\//, "").replace(/\/+$/, "");
+	}
 }
 async function extractOpenAIAccountId(accessToken) {
-  const payload = await parseJwtPayload({ token: accessToken });
-  const auth = payload?.["https://api.openai.com/auth"];
-  if (!isRecord(auth)) return void 0;
-  const accountId = auth.chatgpt_account_id;
-  return typeof accountId === "string" ? accountId : void 0;
+	const auth = (await parseJwtPayload({ token: accessToken }))?.["https://api.openai.com/auth"];
+	if (!isRecord(auth)) return void 0;
+	const accountId = auth.chatgpt_account_id;
+	return typeof accountId === "string" ? accountId : void 0;
 }
-async function readStore({
-  env,
-  homeDirectory,
-  platform
-}) {
-  if (env.OPENCODE_AUTH_CONTENT != null) {
-    const parsed2 = await safeParseJSON({ text: env.OPENCODE_AUTH_CONTENT });
-    return parsed2.success && isRecord(parsed2.value) ? { value: parsed2.value } : void 0;
-  }
-  const authPath = env.XDG_DATA_HOME != null ? join(env.XDG_DATA_HOME, "opencode", "auth.json") : isWindows(platform) ? join(homeDirectory, ".opencode", "auth.json") : join(homeDirectory, ".local", "share", "opencode", "auth.json");
-  const text = await readFile(authPath, "utf8").catch(() => void 0);
-  if (text == null) return void 0;
-  const parsed = await safeParseJSON({ text });
-  if (!parsed.success || !isRecord(parsed.value)) return void 0;
-  return {
-    value: parsed.value,
-    write: (value) => writeStore({ authPath, value })
-  };
+async function readStore({ env, homeDirectory, platform }) {
+	if (env.OPENCODE_AUTH_CONTENT != null) {
+		const parsed = await safeParseJSON({ text: env.OPENCODE_AUTH_CONTENT });
+		return parsed.success && isRecord(parsed.value) ? { value: parsed.value } : void 0;
+	}
+	const authPath = env.XDG_DATA_HOME != null ? join(env.XDG_DATA_HOME, "opencode", "auth.json") : isWindows(platform) ? join(homeDirectory, ".opencode", "auth.json") : join(homeDirectory, ".local", "share", "opencode", "auth.json");
+	const text = await readFile(authPath, "utf8").catch(() => void 0);
+	if (text == null) return void 0;
+	const parsed = await safeParseJSON({ text });
+	if (!parsed.success || !isRecord(parsed.value)) return void 0;
+	return {
+		value: parsed.value,
+		write: (value) => writeStore({
+			authPath,
+			value
+		})
+	};
 }
-async function writeStore({
-  authPath,
-  value
-}) {
-  await mkdir(dirname(authPath), { recursive: true });
-  const temporaryPath = `${authPath}.${process.pid}.tmp`;
-  await writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}
-`, {
-    mode: 384
-  });
-  await chmod(temporaryPath, 384);
-  await rename(temporaryPath, authPath);
+async function writeStore({ authPath, value }) {
+	await mkdir(dirname(authPath), { recursive: true });
+	const temporaryPath = `${authPath}.${process.pid}.tmp`;
+	await writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, { mode: 384 });
+	await chmod(temporaryPath, 384);
+	await rename(temporaryPath, authPath);
 }
 function isSubscriptionProvider(value) {
-  return value === "openai" || value === "xai" || value === "github-copilot" || value === "poe" || value === "opencode-go" || value === "gitlab";
+	return value === "openai" || value === "xai" || value === "github-copilot" || value === "poe" || value === "opencode-go" || value === "gitlab";
 }
-
-// src/opencode-bridge-protocol.ts
-import {
-  harnessV1BridgeInboundCommandSchemas,
-  harnessV1BridgeOutboundMessageSchema,
-  harnessV1BridgeReadySchema,
-  harnessV1BridgeStartBaseSchema
-} from "@ai-sdk/harness";
-import { z } from "zod/v4";
-var outboundMessageSchema = harnessV1BridgeOutboundMessageSchema;
-var startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
-  operation: z.enum(["prompt", "compact"]).optional(),
-  provider: z.string().optional(),
-  variant: z.string().optional(),
-  instructions: z.string().optional(),
-  skillsChanged: z.boolean().optional(),
-  resumeSessionId: z.string().optional(),
-  openCodeConfig: z.record(z.string(), z.unknown()).optional(),
-  mcpServers: z.record(z.string(), z.unknown()).optional(),
-  headers: z.record(z.string(), z.string()).optional()
+//#endregion
+//#region src/opencode-bridge-protocol.ts
+const outboundMessageSchema = harnessV1BridgeOutboundMessageSchema;
+const startMessageSchema = harnessV1BridgeStartBaseSchema.extend({
+	operation: z.enum(["prompt", "compact"]).optional(),
+	provider: z.string().optional(),
+	variant: z.string().optional(),
+	instructions: z.string().optional(),
+	skillsChanged: z.boolean().optional(),
+	resumeSessionId: z.string().optional(),
+	openCodeConfig: z.record(z.string(), z.unknown()).optional(),
+	mcpServers: z.record(z.string(), z.unknown()).optional(),
+	headers: z.record(z.string(), z.string()).optional()
 });
-var inboundMessageSchema = z.discriminatedUnion("type", [
-  startMessageSchema,
-  ...harnessV1BridgeInboundCommandSchemas
-]);
-
-// src/version.ts
-var VERSION = true ? "1.0.134" : "0.0.0-test";
-
-// src/opencode-harness.ts
-var OPENCODE_CLIENT_APP = `ai-sdk-harness-opencode/${VERSION}`;
-var optionalStringRecord = z2.record(z2.string(), z2.unknown()).optional();
-var OPENCODE_BUILTIN_TOOLS = {
-  askUserQuestions: {
-    ...HARNESS_V1_BUILTIN_TOOLS.askUserQuestions,
-    nativeName: "question",
-    toolUseKind: "readonly"
-  },
-  read: commonTool("read", {
-    nativeName: "view",
-    toolUseKind: "readonly",
-    description: "Read file contents",
-    inputSchema: z2.looseObject({
-      file_path: z2.string().optional(),
-      path: z2.string().optional()
-    })
-  }),
-  write: commonTool("write", {
-    nativeName: "write",
-    toolUseKind: "edit",
-    description: "Write content to a file",
-    inputSchema: z2.looseObject({
-      file_path: z2.string().optional(),
-      path: z2.string().optional(),
-      content: z2.string().optional()
-    })
-  }),
-  edit: commonTool("edit", {
-    nativeName: "edit",
-    toolUseKind: "edit",
-    description: "Edit a file by replacing text",
-    inputSchema: z2.looseObject({
-      file_path: z2.string().optional(),
-      path: z2.string().optional(),
-      old_string: z2.string().optional(),
-      new_string: z2.string().optional()
-    })
-  }),
-  bash: commonTool("bash", {
-    nativeName: "bash",
-    toolUseKind: "bash",
-    description: "Execute a shell command",
-    inputSchema: z2.looseObject({
-      command: z2.string().optional()
-    })
-  }),
-  glob: commonTool("glob", {
-    nativeName: "glob",
-    toolUseKind: "readonly",
-    description: "Find files matching a glob pattern",
-    inputSchema: z2.looseObject({
-      pattern: z2.string().optional(),
-      path: z2.string().optional()
-    })
-  }),
-  grep: commonTool("grep", {
-    nativeName: "grep",
-    toolUseKind: "readonly",
-    description: "Search file contents with regex",
-    inputSchema: z2.looseObject({
-      pattern: z2.string().optional(),
-      path: z2.string().optional()
-    })
-  }),
-  ls: tool({
-    description: "List directory contents",
-    inputSchema: z2.looseObject({
-      path: z2.string().optional()
-    })
-  }),
-  webfetch: tool({
-    description: "Fetch a URL",
-    inputSchema: z2.looseObject({
-      url: z2.string().optional(),
-      prompt: z2.string().optional()
-    })
-  }),
-  skill: tool({
-    description: "Load an OpenCode skill by name",
-    inputSchema: z2.looseObject({
-      name: z2.string().optional()
-    })
-  }),
-  todowrite: tool({
-    description: "Replace the OpenCode session todo list",
-    inputSchema: z2.looseObject({
-      todos: z2.array(
-        z2.looseObject({
-          content: z2.string().optional(),
-          status: z2.string().optional(),
-          priority: z2.string().optional()
-        })
-      ).optional()
-    })
-  }),
-  agent: tool({
-    description: "Run an OpenCode subagent",
-    inputSchema: z2.looseObject({
-      agent: z2.string().optional(),
-      prompt: z2.string().optional(),
-      description: z2.string().optional(),
-      metadata: optionalStringRecord
-    })
-  })
+z.discriminatedUnion("type", [startMessageSchema, ...harnessV1BridgeInboundCommandSchemas]);
+//#endregion
+//#region src/version.ts
+const VERSION = "1.0.136";
+//#endregion
+//#region src/opencode-harness.ts
+/**
+* Value to use in User-Agent and `x-client-app` headers.
+*/
+const OPENCODE_CLIENT_APP = `ai-sdk-harness-opencode/${VERSION}`;
+const optionalStringRecord = z.record(z.string(), z.unknown()).optional();
+const OPENCODE_BUILTIN_TOOLS = {
+	askUserQuestions: {
+		...HARNESS_V1_BUILTIN_TOOLS.askUserQuestions,
+		nativeName: "question",
+		toolUseKind: "readonly"
+	},
+	read: commonTool("read", {
+		nativeName: "view",
+		toolUseKind: "readonly",
+		description: "Read file contents",
+		inputSchema: z.looseObject({
+			file_path: z.string().optional(),
+			path: z.string().optional()
+		})
+	}),
+	write: commonTool("write", {
+		nativeName: "write",
+		toolUseKind: "edit",
+		description: "Write content to a file",
+		inputSchema: z.looseObject({
+			file_path: z.string().optional(),
+			path: z.string().optional(),
+			content: z.string().optional()
+		})
+	}),
+	edit: commonTool("edit", {
+		nativeName: "edit",
+		toolUseKind: "edit",
+		description: "Edit a file by replacing text",
+		inputSchema: z.looseObject({
+			file_path: z.string().optional(),
+			path: z.string().optional(),
+			old_string: z.string().optional(),
+			new_string: z.string().optional()
+		})
+	}),
+	bash: commonTool("bash", {
+		nativeName: "bash",
+		toolUseKind: "bash",
+		description: "Execute a shell command",
+		inputSchema: z.looseObject({ command: z.string().optional() })
+	}),
+	glob: commonTool("glob", {
+		nativeName: "glob",
+		toolUseKind: "readonly",
+		description: "Find files matching a glob pattern",
+		inputSchema: z.looseObject({
+			pattern: z.string().optional(),
+			path: z.string().optional()
+		})
+	}),
+	grep: commonTool("grep", {
+		nativeName: "grep",
+		toolUseKind: "readonly",
+		description: "Search file contents with regex",
+		inputSchema: z.looseObject({
+			pattern: z.string().optional(),
+			path: z.string().optional()
+		})
+	}),
+	ls: tool({
+		description: "List directory contents",
+		inputSchema: z.looseObject({ path: z.string().optional() })
+	}),
+	webfetch: tool({
+		description: "Fetch a URL",
+		inputSchema: z.looseObject({
+			url: z.string().optional(),
+			prompt: z.string().optional()
+		})
+	}),
+	skill: tool({
+		description: "Load an OpenCode skill by name",
+		inputSchema: z.looseObject({ name: z.string().optional() })
+	}),
+	todowrite: tool({
+		description: "Replace the OpenCode session todo list",
+		inputSchema: z.looseObject({ todos: z.array(z.looseObject({
+			content: z.string().optional(),
+			status: z.string().optional(),
+			priority: z.string().optional()
+		})).optional() })
+	}),
+	agent: tool({
+		description: "Run an OpenCode subagent",
+		inputSchema: z.looseObject({
+			agent: z.string().optional(),
+			prompt: z.string().optional(),
+			description: z.string().optional(),
+			metadata: optionalStringRecord
+		})
+	})
 };
-var openCodeBridgeCoordsSchema = z2.object({
-  port: z2.number(),
-  token: z2.string(),
-  lastSeenEventId: z2.number(),
-  sandboxId: z2.string().optional()
+const openCodeBridgeCoordsSchema = z.object({
+	port: z.number(),
+	token: z.string(),
+	lastSeenEventId: z.number(),
+	sandboxId: z.string().optional()
 });
-var openCodeResumeStateSchema = z2.object({
-  openCodeSessionId: z2.string().optional(),
-  bridge: openCodeBridgeCoordsSchema.optional(),
-  sandboxCredentialEnvironment: z2.record(z2.string(), z2.string()).optional()
+const openCodeResumeStateSchema = z.object({
+	openCodeSessionId: z.string().optional(),
+	bridge: openCodeBridgeCoordsSchema.optional(),
+	sandboxCredentialEnvironment: z.record(z.string(), z.string()).optional()
 });
 function createOpenCode(settings = {}) {
-  if (settings.mcpServers != null && Object.prototype.hasOwnProperty.call(settings.mcpServers, "harness-tools")) {
-    throw new Error(
-      'OpenCode MCP server name "harness-tools" is reserved for HarnessAgent tools.'
-    );
-  }
-  return {
-    specificationVersion: "harness-v1",
-    harnessId: "opencode",
-    builtinTools: OPENCODE_BUILTIN_TOOLS,
-    supportsBuiltinToolApprovals: true,
-    lifecycleStateSchema: openCodeResumeStateSchema,
-    getBootstrap: getOpenCodeBootstrap,
-    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 HarnessCapabilityUnsupportedError2({
-          harnessId: "opencode",
-          message: "The OpenCode 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 && typeof lifecycleState?.data === "object" ? lifecycleState.data : void 0;
-      const resumeSessionId = typeof resumeData?.openCodeSessionId === "string" && resumeData.openCodeSessionId.length > 0 ? resumeData.openCodeSessionId : void 0;
-      const coords = resumeData?.bridge;
-      const authentication = await resolveOpenCodeAuthentication({
-        auth: settings.auth,
-        provider: settings.provider
-      });
-      const authenticationMode = authentication.authenticationMode;
-      const resolvedAuthEnvironment = authentication.environment;
-      let resolvedOpenCodeConfig = settings.openCodeConfig;
-      let transformModel;
-      let gitLabSubscriptionBrokered = false;
-      let sandboxAuthEnvironment = resolvedAuthEnvironment;
-      let sandboxCredentialEnvironment;
-      let credentialsBrokered = false;
-      if ("addRequestTransformations" in sandboxSession && sandboxSession.addRequestTransformations != null) {
-        sandboxCredentialEnvironment = resumeData?.sandboxCredentialEnvironment ?? await createSandboxCredentialEnvironment({
-          environment: resolvedAuthEnvironment,
-          credentialEnvironmentVariables: OPENCODE_CREDENTIAL_ENVIRONMENT_VARIABLES,
-          credentialForwarding: settings.credentialForwarding
-        });
-        sandboxAuthEnvironment = {
-          ...resolvedAuthEnvironment,
-          ...sandboxCredentialEnvironment
-        };
-        const transformationSources = {
-          env: resolvedAuthEnvironment,
-          sandboxEnv: sandboxAuthEnvironment,
-          auth: authenticationMode
-        };
-        const sandboxSubscriptionAccessToken = sandboxAuthEnvironment[OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE];
-        let requestTransformations;
-        if (authentication.subscription?.providerId === "gitlab" && sandboxSubscriptionAccessToken != null) {
-          const directAccess = await requestOpenCodeGitLabDirectAccess({
-            accessToken: authentication.subscription.accessToken,
-            ...authentication.subscription.enterpriseUrl == null ? {} : { instanceUrl: authentication.subscription.enterpriseUrl },
-            ...process.env.GITLAB_AI_GATEWAY_URL == null ? {} : { aiGatewayUrl: process.env.GITLAB_AI_GATEWAY_URL }
-          });
-          requestTransformations = createOpenCodeGitLabSubscriptionRequestTransformations({
-            directAccess,
-            sandboxAccessToken: sandboxSubscriptionAccessToken
-          });
-          resolvedOpenCodeConfig = createOpenCodeGitLabSubscriptionConfig({
-            openCodeConfig: settings.openCodeConfig,
-            sandboxAccessToken: sandboxSubscriptionAccessToken,
-            aiGatewayUrl: directAccess.aiGatewayUrl,
-            ...startOpts.headers == null ? {} : { headers: startOpts.headers }
-          });
-          transformModel = (model) => resolveOpenCodeGitLabSubscriptionModel({
-            model,
-            provider: settings.provider
-          });
-          gitLabSubscriptionBrokered = true;
-        } else {
-          requestTransformations = authentication.subscription == null || sandboxSubscriptionAccessToken == null ? createOpenCodeRequestTransformations(transformationSources) : createOpenCodeSubscriptionRequestTransformations({
-            authentication: authentication.subscription,
-            sandboxAccessToken: sandboxSubscriptionAccessToken
-          });
-        }
-        if (requestTransformations.length > 0) {
-          await sandboxSession.addRequestTransformations(
-            requestTransformations
-          );
-        }
-        credentialsBrokered = true;
-      }
-      const sandboxHomeDir = await resolveSandboxHomeDir({
-        sandbox: toolSafeSandboxSession,
-        abortSignal: startOpts.abortSignal
-      });
-      const stateDir = harnessStateDirectoryPath({ sandboxHomeDir });
-      const bootstrapDir = path.posix.resolve(stateDir, OPENCODE_BOOTSTRAP_DIR);
-      const workDir = startOpts.sessionWorkDir;
-      const skillsDir = path.posix.join(sandboxHomeDir, ".agents", "skills");
-      const sessionDataDir = harnessSessionDataDirectoryPath({
-        stateDirectory: stateDir,
-        sessionId: startOpts.sessionId
-      });
-      const bridgeStateDir = `${sessionDataDir}/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: "opencode",
-        sessionId: startOpts.sessionId
-      });
-      if (coords) {
-        try {
-          const endpoint2 = await resolveBridgeEndpoint({
-            sandboxSession,
-            override: settings.portEndpoint,
-            port: coords.port
-          });
-          const attachEndpoint = withBridgeToken({
-            endpoint: endpoint2,
-            token: coords.token
-          });
-          let supportsUserMessageResponses2 = false;
-          const attachChannel = new SandboxChannel({
-            connect: ({ abortSignal }) => openWebSocket({
-              endpoint: attachEndpoint,
-              helloTimeoutMs: Math.min(timeoutMs, 5e3),
-              abortSignal,
-              onHello: (supported) => {
-                supportsUserMessageResponses2 = supported;
-              }
-            }),
-            outboundSchema: outboundMessageSchema,
-            initialLastSeenEventId: coords.lastSeenEventId,
-            onDiagnostic,
-            onBridgeError,
-            reconnect: settings.reconnect
-          });
-          await attachChannel.open(isContinue ? { resume: true } : void 0);
-          return createSession({
-            sessionId: startOpts.sessionId,
-            channel: attachChannel,
-            proc: void 0,
-            provider: settings.provider,
-            reasoningVariant: settings.reasoningVariant,
-            openCodeConfig: resolvedOpenCodeConfig,
-            mcpServers: settings.mcpServers,
-            headers: startOpts.headers,
-            openCodeSessionId: resumeSessionId,
-            isResume: true,
-            seedResumeSessionOnFirstPrompt: false,
-            rerunContinue: false,
-            bridgePort: coords.port,
-            bridgeToken: coords.token,
-            sandboxId,
-            sandboxCredentialEnvironment,
-            debug: startOpts.observability?.debug,
-            permissionMode: startOpts.permissionMode,
-            builtinToolFiltering: startOpts.builtinToolFiltering,
-            sandbox: toolSafeSandboxSession,
-            sandboxHomeDir,
-            transformModel,
-            supportsUserMessageResponses: () => supportsUserMessageResponses2
-          });
-        } 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 forwardedAuthEnvironment = credentialsBrokered ? sandboxAuthEnvironment : await applyCredentialForwarding({
-        environment: sandboxAuthEnvironment,
-        credentialEnvironmentVariables: OPENCODE_CREDENTIAL_ENVIRONMENT_VARIABLES,
-        credentialForwarding: settings.credentialForwarding
-      });
-      if (!credentialsBrokered) {
-        warnCredentialBrokeringUnavailable({
-          environment: resolvedAuthEnvironment,
-          forwardedEnvironment: forwardedAuthEnvironment,
-          credentialEnvironmentVariables: OPENCODE_CREDENTIAL_ENVIRONMENT_VARIABLES
-        });
-      }
-      const subscriptionAccessToken = forwardedAuthEnvironment[OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE];
-      const forwardableAuthEnvironment = Object.fromEntries(
-        Object.entries(forwardedAuthEnvironment).filter(
-          ([name]) => name !== OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE
-        )
-      );
-      const env = {
-        ...forwardableAuthEnvironment,
-        ...gitLabSubscriptionBrokered || authentication.subscription == null || subscriptionAccessToken == null ? {} : {
-          OPENCODE_AUTH_CONTENT: createOpenCodeSubscriptionAuthContent({
-            authentication: authentication.subscription,
-            accessToken: subscriptionAccessToken
-          })
-        },
-        AI_SDK_HARNESS_CLIENT_APP: OPENCODE_CLIENT_APP,
-        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: "opencode",
-        abortSignal: startOpts.abortSignal
-      });
-      const proc = await toolSafeSandboxSession.spawn({
-        command: `node ${shellQuote(`${bootstrapDir}/bridge.mjs`)} --workdir ${shellQuote(workDir)} --bridge-state-dir ${shellQuote(bridgeStateDir)} --bootstrap-dir ${shellQuote(bootstrapDir)} --skills-dir ${shellQuote(skillsDir)}`,
-        env,
-        abortSignal: startOpts.abortSignal
-      });
-      const stderrTail = [];
-      const bridgeStderrDone = forwardBridgeProcessStream({
-        stream: proc.stderr,
-        streamName: "stderr",
-        source: "opencode",
-        collectTail: stderrTail
-      });
-      const { port: boundPort } = await waitForBridgeReady({
-        proc,
-        sandbox: toolSafeSandboxSession,
-        bridgeStateDir,
-        bridgeType: "opencode",
-        timeoutMs,
-        abortSignal: startOpts.abortSignal,
-        createTimeoutError: ({ proc: proc2, stdoutTail }) => createBridgeStartupError({
-          message: "OpenCode bridge did not become ready in time.",
-          proc: proc2,
-          stdoutTail,
-          stderrTail,
-          stderrDone: bridgeStderrDone
-        }),
-        createExitError: ({ proc: proc2, stdoutTail }) => createBridgeStartupError({
-          message: "OpenCode bridge exited before becoming ready.",
-          proc: proc2,
-          stdoutTail,
-          stderrTail,
-          stderrDone: bridgeStderrDone
-        })
-      });
-      void drainBridgeProcessStream(proc.stdout);
-      const endpoint = await resolveBridgeEndpoint({
-        sandboxSession,
-        override: settings.portEndpoint,
-        port: boundPort
-      });
-      const bridgeEndpoint = withBridgeToken({ endpoint, token });
-      let supportsUserMessageResponses = false;
-      const channel = new SandboxChannel({
-        connect: ({ abortSignal }) => openWebSocket({
-          endpoint: bridgeEndpoint,
-          helloTimeoutMs: Math.min(timeoutMs, 5e3),
-          abortSignal,
-          onHello: (supported) => {
-            supportsUserMessageResponses = supported;
-          }
-        }),
-        outboundSchema: outboundMessageSchema,
-        onDiagnostic,
-        onBridgeError,
-        reconnect: settings.reconnect,
-        ...respawnStrategy === "replay" ? { initialLastSeenEventId: coords?.lastSeenEventId ?? 0 } : {}
-      });
-      await channel.open(
-        respawnStrategy === "replay" ? { resume: true } : void 0
-      );
-      return createSession({
-        sessionId: startOpts.sessionId,
-        channel,
-        proc,
-        provider: settings.provider,
-        reasoningVariant: settings.reasoningVariant,
-        openCodeConfig: resolvedOpenCodeConfig,
-        mcpServers: settings.mcpServers,
-        headers: startOpts.headers,
-        openCodeSessionId: resumeSessionId,
-        isResume: respawnStrategy !== void 0,
-        seedResumeSessionOnFirstPrompt: respawnStrategy !== void 0,
-        rerunContinue: respawnStrategy === "rerun",
-        bridgePort: boundPort,
-        bridgeToken: token,
-        sandboxId,
-        sandboxCredentialEnvironment,
-        debug: startOpts.observability?.debug,
-        permissionMode: startOpts.permissionMode,
-        builtinToolFiltering: startOpts.builtinToolFiltering,
-        sandbox: toolSafeSandboxSession,
-        sandboxHomeDir,
-        transformModel,
-        supportsUserMessageResponses: () => supportsUserMessageResponses
-      });
-    }
-  };
+	if (settings.mcpServers != null && Object.prototype.hasOwnProperty.call(settings.mcpServers, "harness-tools")) throw new Error("OpenCode MCP server name \"harness-tools\" is reserved for HarnessAgent tools.");
+	return {
+		specificationVersion: "harness-v1",
+		harnessId: "opencode",
+		builtinTools: OPENCODE_BUILTIN_TOOLS,
+		supportsBuiltinToolApprovals: true,
+		lifecycleStateSchema: openCodeResumeStateSchema,
+		getBootstrap: getOpenCodeBootstrap,
+		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: "opencode",
+				message: "The OpenCode 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 && typeof lifecycleState?.data === "object" ? lifecycleState.data : void 0;
+			const resumeSessionId = typeof resumeData?.openCodeSessionId === "string" && resumeData.openCodeSessionId.length > 0 ? resumeData.openCodeSessionId : void 0;
+			const coords = resumeData?.bridge;
+			const authentication = await resolveOpenCodeAuthentication({
+				auth: settings.auth,
+				provider: settings.provider
+			});
+			const authenticationMode = authentication.authenticationMode;
+			const resolvedAuthEnvironment = authentication.environment;
+			let resolvedOpenCodeConfig = settings.openCodeConfig;
+			let transformModel;
+			let gitLabSubscriptionBrokered = false;
+			let sandboxAuthEnvironment = resolvedAuthEnvironment;
+			let sandboxCredentialEnvironment;
+			let credentialsBrokered = false;
+			if ("addRequestTransformations" in sandboxSession && sandboxSession.addRequestTransformations != null) {
+				sandboxCredentialEnvironment = await resolveSandboxCredentialEnvironment({
+					environment: resolvedAuthEnvironment,
+					credentialEnvironmentVariables: OPENCODE_CREDENTIAL_ENVIRONMENT_VARIABLES,
+					credentialForwarding: settings.credentialForwarding,
+					previousSandboxCredentialEnvironment: resumeData?.sandboxCredentialEnvironment
+				});
+				sandboxAuthEnvironment = {
+					...resolvedAuthEnvironment,
+					...sandboxCredentialEnvironment
+				};
+				const transformationSources = {
+					env: resolvedAuthEnvironment,
+					sandboxEnv: sandboxAuthEnvironment,
+					auth: authenticationMode
+				};
+				const sandboxSubscriptionAccessToken = sandboxAuthEnvironment[OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE];
+				let requestTransformations;
+				if (authentication.subscription?.providerId === "gitlab" && sandboxSubscriptionAccessToken != null) {
+					const directAccess = await requestOpenCodeGitLabDirectAccess({
+						accessToken: authentication.subscription.accessToken,
+						...authentication.subscription.enterpriseUrl == null ? {} : { instanceUrl: authentication.subscription.enterpriseUrl },
+						...process.env.GITLAB_AI_GATEWAY_URL == null ? {} : { aiGatewayUrl: process.env.GITLAB_AI_GATEWAY_URL }
+					});
+					requestTransformations = createOpenCodeGitLabSubscriptionRequestTransformations({
+						directAccess,
+						sandboxAccessToken: sandboxSubscriptionAccessToken
+					});
+					resolvedOpenCodeConfig = createOpenCodeGitLabSubscriptionConfig({
+						openCodeConfig: settings.openCodeConfig,
+						sandboxAccessToken: sandboxSubscriptionAccessToken,
+						aiGatewayUrl: directAccess.aiGatewayUrl,
+						...startOpts.headers == null ? {} : { headers: startOpts.headers }
+					});
+					transformModel = (model) => resolveOpenCodeGitLabSubscriptionModel({
+						model,
+						provider: settings.provider
+					});
+					gitLabSubscriptionBrokered = true;
+				} else requestTransformations = authentication.subscription == null || sandboxSubscriptionAccessToken == null ? createOpenCodeRequestTransformations(transformationSources) : createOpenCodeSubscriptionRequestTransformations({
+					authentication: authentication.subscription,
+					sandboxAccessToken: sandboxSubscriptionAccessToken
+				});
+				if (requestTransformations.length > 0) await sandboxSession.addRequestTransformations(requestTransformations);
+				credentialsBrokered = true;
+			}
+			const sandboxHomeDir = await resolveSandboxHomeDir({
+				sandbox: toolSafeSandboxSession,
+				abortSignal: startOpts.abortSignal
+			});
+			const stateDir = harnessStateDirectoryPath({ sandboxHomeDir });
+			const bootstrapDir = path.posix.resolve(stateDir, OPENCODE_BOOTSTRAP_DIR);
+			const workDir = startOpts.sessionWorkDir;
+			const skillsDir = path.posix.join(sandboxHomeDir, ".agents", "skills");
+			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: "opencode",
+				sessionId: startOpts.sessionId
+			});
+			if (coords) try {
+				const endpoint = await resolveBridgeEndpoint({
+					sandboxSession,
+					override: settings.portEndpoint,
+					port: coords.port
+				});
+				const attachEndpoint = withBridgeToken({
+					endpoint,
+					token: coords.token
+				});
+				let supportsUserMessageResponses = false;
+				const attachChannel = new SandboxChannel({
+					connect: ({ abortSignal }) => openWebSocket({
+						endpoint: attachEndpoint,
+						helloTimeoutMs: Math.min(timeoutMs, 5e3),
+						abortSignal,
+						onHello: (supported) => {
+							supportsUserMessageResponses = supported;
+						}
+					}),
+					outboundSchema: outboundMessageSchema,
+					initialLastSeenEventId: coords.lastSeenEventId,
+					onDiagnostic,
+					onBridgeError,
+					reconnect: settings.reconnect
+				});
+				await attachChannel.open(isContinue ? { resume: true } : void 0);
+				return createSession({
+					sessionId: startOpts.sessionId,
+					channel: attachChannel,
+					proc: void 0,
+					provider: settings.provider,
+					reasoningVariant: settings.reasoningVariant,
+					openCodeConfig: resolvedOpenCodeConfig,
+					mcpServers: settings.mcpServers,
+					headers: startOpts.headers,
+					openCodeSessionId: resumeSessionId,
+					isResume: true,
+					seedResumeSessionOnFirstPrompt: false,
+					rerunContinue: false,
+					bridgePort: coords.port,
+					bridgeToken: coords.token,
+					sandboxId,
+					sandboxCredentialEnvironment,
+					debug: startOpts.observability?.debug,
+					permissionMode: startOpts.permissionMode,
+					builtinToolFiltering: startOpts.builtinToolFiltering,
+					sandbox: toolSafeSandboxSession,
+					sandboxHomeDir,
+					transformModel,
+					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 forwardedAuthEnvironment = credentialsBrokered ? sandboxAuthEnvironment : await applyCredentialForwarding({
+				environment: sandboxAuthEnvironment,
+				credentialEnvironmentVariables: OPENCODE_CREDENTIAL_ENVIRONMENT_VARIABLES,
+				credentialForwarding: settings.credentialForwarding
+			});
+			if (!credentialsBrokered) warnCredentialBrokeringUnavailable({
+				environment: resolvedAuthEnvironment,
+				forwardedEnvironment: forwardedAuthEnvironment,
+				credentialEnvironmentVariables: OPENCODE_CREDENTIAL_ENVIRONMENT_VARIABLES
+			});
+			const subscriptionAccessToken = forwardedAuthEnvironment[OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE];
+			const env = {
+				...Object.fromEntries(Object.entries(forwardedAuthEnvironment).filter(([name]) => name !== OPENCODE_SUBSCRIPTION_ACCESS_TOKEN_ENVIRONMENT_VARIABLE)),
+				...gitLabSubscriptionBrokered || authentication.subscription == null || subscriptionAccessToken == null ? {} : { OPENCODE_AUTH_CONTENT: createOpenCodeSubscriptionAuthContent({
+					authentication: authentication.subscription,
+					accessToken: subscriptionAccessToken
+				}) },
+				AI_SDK_HARNESS_CLIENT_APP: OPENCODE_CLIENT_APP,
+				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: "opencode",
+				abortSignal: startOpts.abortSignal
+			});
+			const proc = await toolSafeSandboxSession.spawn({
+				command: `node ${shellQuote(`${bootstrapDir}/bridge.mjs`)} --workdir ${shellQuote(workDir)} --bridge-state-dir ${shellQuote(bridgeStateDir)} --bootstrap-dir ${shellQuote(bootstrapDir)} --skills-dir ${shellQuote(skillsDir)}`,
+				env,
+				abortSignal: startOpts.abortSignal
+			});
+			const stderrTail = [];
+			const bridgeStderrDone = forwardBridgeProcessStream({
+				stream: proc.stderr,
+				streamName: "stderr",
+				source: "opencode",
+				collectTail: stderrTail
+			});
+			const { port: boundPort } = await waitForBridgeReady({
+				proc,
+				sandbox: toolSafeSandboxSession,
+				bridgeStateDir,
+				bridgeType: "opencode",
+				timeoutMs,
+				abortSignal: startOpts.abortSignal,
+				createTimeoutError: ({ proc, stdoutTail }) => createBridgeStartupError({
+					message: "OpenCode bridge did not become ready in time.",
+					proc,
+					stdoutTail,
+					stderrTail,
+					stderrDone: bridgeStderrDone
+				}),
+				createExitError: ({ proc, stdoutTail }) => createBridgeStartupError({
+					message: "OpenCode bridge exited before becoming ready.",
+					proc,
+					stdoutTail,
+					stderrTail,
+					stderrDone: bridgeStderrDone
+				})
+			});
+			drainBridgeProcessStream(proc.stdout);
+			const endpoint = await resolveBridgeEndpoint({
+				sandboxSession,
+				override: settings.portEndpoint,
+				port: boundPort
+			});
+			const bridgeEndpoint = withBridgeToken({
+				endpoint,
+				token
+			});
+			let supportsUserMessageResponses = false;
+			const channel = new SandboxChannel({
+				connect: ({ abortSignal }) => openWebSocket({
+					endpoint: bridgeEndpoint,
+					helloTimeoutMs: Math.min(timeoutMs, 5e3),
+					abortSignal,
+					onHello: (supported) => {
+						supportsUserMessageResponses = supported;
+					}
+				}),
+				outboundSchema: outboundMessageSchema,
+				onDiagnostic,
+				onBridgeError,
+				reconnect: settings.reconnect,
+				...respawnStrategy === "replay" ? { initialLastSeenEventId: coords?.lastSeenEventId ?? 0 } : {}
+			});
+			await channel.open(respawnStrategy === "replay" ? { resume: true } : void 0);
+			return createSession({
+				sessionId: startOpts.sessionId,
+				channel,
+				proc,
+				provider: settings.provider,
+				reasoningVariant: settings.reasoningVariant,
+				openCodeConfig: resolvedOpenCodeConfig,
+				mcpServers: settings.mcpServers,
+				headers: startOpts.headers,
+				openCodeSessionId: resumeSessionId,
+				isResume: respawnStrategy !== void 0,
+				seedResumeSessionOnFirstPrompt: respawnStrategy !== void 0,
+				rerunContinue: respawnStrategy === "rerun",
+				bridgePort: boundPort,
+				bridgeToken: token,
+				sandboxId,
+				sandboxCredentialEnvironment,
+				debug: startOpts.observability?.debug,
+				permissionMode: startOpts.permissionMode,
+				builtinToolFiltering: startOpts.builtinToolFiltering,
+				sandbox: toolSafeSandboxSession,
+				sandboxHomeDir,
+				transformModel,
+				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 HarnessCapabilityUnsupportedError2({
-    harnessId: "opencode",
-    message: "The OpenCode harness needs a TCP port exposed by the sandbox. Create the sandbox with `ports: [<port>]` or pass `createOpenCode({ port })`."
-  });
+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: "opencode",
+		message: "The OpenCode harness needs a TCP port exposed by the sandbox. Create the sandbox with `ports: [<port>]` or pass `createOpenCode({ port })`."
+	});
 }
-function validateBasicSandboxSettings({
-  sandboxSession,
-  port,
-  portEndpoint
-}) {
-  if ("getPortEndpoint" in sandboxSession) return;
-  if (port == null) {
-    throw new HarnessCapabilityUnsupportedError2({
-      harnessId: "opencode",
-      message: "The OpenCode harness requires an explicit `port` when using a basic sandbox session."
-    });
-  }
-  if (portEndpoint == null) {
-    throw new HarnessCapabilityUnsupportedError2({
-      harnessId: "opencode",
-      message: "The OpenCode harness requires an explicit `portEndpoint` when using a basic sandbox session."
-    });
-  }
+function validateBasicSandboxSettings({ sandboxSession, port, portEndpoint }) {
+	if ("getPortEndpoint" in sandboxSession) return;
+	if (port == null) throw new HarnessCapabilityUnsupportedError({
+		harnessId: "opencode",
+		message: "The OpenCode harness requires an explicit `port` when using a basic sandbox session."
+	});
+	if (portEndpoint == null) throw new HarnessCapabilityUnsupportedError({
+		harnessId: "opencode",
+		message: "The OpenCode 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 HarnessCapabilityUnsupportedError2({
-    harnessId: "opencode",
-    message: "The OpenCode 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: "opencode",
+		message: "The OpenCode harness requires an explicit `portEndpoint` when using a basic sandbox session."
+	});
 }
-function openWebSocket({
-  endpoint,
-  helloTimeoutMs,
-  abortSignal,
-  onHello
-}) {
-  return new Promise((resolve, reject) => {
-    const abortReason = () => abortSignal.reason ?? 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 receivedHello = false;
-    let settled = false;
-    let helloTimer;
-    let onAbort;
-    const cleanup = () => {
-      clearTimeout(helloTimer);
-      ws.off("open", onOpen);
-      ws.off("message", onMessage);
-      ws.off("close", onClose);
-      ws.off("error", onError);
-      if (onAbort != null) {
-        abortSignal.removeEventListener("abort", onAbort);
-      }
-    };
-    const settle = (error) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      if (error == null) {
-        resolve(ws);
-      } else {
-        const suppressError = () => {
-        };
-        const socketWithOnce = ws;
-        socketWithOnce.once?.("error", suppressError);
-        try {
-          ws.terminate();
-        } catch {
-          try {
-            ws.close();
-          } catch {
-          }
-        }
-        reject(error);
-      }
-    };
-    const tryResolve = () => {
-      if (opened && receivedHello) settle();
-    };
-    const onOpen = () => {
-      opened = true;
-      tryResolve();
-    };
-    const onMessage = (raw) => {
-      void (async () => {
-        const parsed = await safeParseJSON2({
-          text: webSocketMessageToString(raw)
-        });
-        if (!parsed.success) return;
-        const value = parsed.value;
-        if (typeof value !== "object" || value == null || Array.isArray(value) || value.type !== "bridge-hello") {
-          return;
-        }
-        const capabilities = value.capabilities;
-        onHello(capabilities?.experimental_userMessageResponses === true);
-        receivedHello = true;
-        tryResolve();
-      })();
-    };
-    const onClose = () => settle(new Error("OpenCode bridge closed before sending bridge-hello."));
-    const onError = (err) => {
-      settle(err);
-    };
-    onAbort = () => settle(abortReason());
-    ws.on("open", onOpen);
-    ws.on("message", onMessage);
-    ws.on("close", onClose);
-    ws.on("error", onError);
-    abortSignal.addEventListener("abort", onAbort, { once: true });
-    if (abortSignal.aborted) {
-      onAbort();
-      return;
-    }
-    helloTimer = setTimeout(
-      () => settle(
-        new Error(
-          `OpenCode bridge did not send bridge-hello within ${helloTimeoutMs}ms.`
-        )
-      ),
-      helloTimeoutMs
-    );
-    helloTimer.unref?.();
-  });
+function openWebSocket({ endpoint, helloTimeoutMs, abortSignal, onHello }) {
+	return new Promise((resolve, 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 receivedHello = false;
+		let settled = false;
+		let helloTimer;
+		let onAbort;
+		const cleanup = () => {
+			clearTimeout(helloTimer);
+			ws.off("open", onOpen);
+			ws.off("message", onMessage);
+			ws.off("close", onClose);
+			ws.off("error", onError);
+			if (onAbort != null) abortSignal.removeEventListener("abort", onAbort);
+		};
+		const settle = (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			if (error == null) resolve(ws);
+			else {
+				const suppressError = () => {};
+				ws.once?.("error", suppressError);
+				try {
+					ws.terminate();
+				} catch {
+					try {
+						ws.close();
+					} catch {}
+				}
+				reject(error);
+			}
+		};
+		const tryResolve = () => {
+			if (opened && receivedHello) settle();
+		};
+		const onOpen = () => {
+			opened = true;
+			tryResolve();
+		};
+		const onMessage = (raw) => {
+			(async () => {
+				const parsed = await safeParseJSON({ text: webSocketMessageToString(raw) });
+				if (!parsed.success) return;
+				const value = parsed.value;
+				if (typeof value !== "object" || value == null || Array.isArray(value) || value.type !== "bridge-hello") return;
+				const capabilities = value.capabilities;
+				onHello(capabilities?.experimental_userMessageResponses === true);
+				receivedHello = true;
+				tryResolve();
+			})();
+		};
+		const onClose = () => settle(/* @__PURE__ */ new Error("OpenCode bridge closed before sending bridge-hello."));
+		const onError = (err) => {
+			settle(err);
+		};
+		onAbort = () => settle(abortReason());
+		ws.on("open", onOpen);
+		ws.on("message", onMessage);
+		ws.on("close", onClose);
+		ws.on("error", onError);
+		abortSignal.addEventListener("abort", onAbort, { once: true });
+		if (abortSignal.aborted) {
+			onAbort();
+			return;
+		}
+		helloTimer = setTimeout(() => settle(/* @__PURE__ */ new Error(`OpenCode bridge did not send bridge-hello within ${helloTimeoutMs}ms.`)), helloTimeoutMs);
+		helloTimer.unref?.();
+	});
 }
 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);
+	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 createSession({
-  sessionId,
-  channel,
-  proc,
-  provider,
-  reasoningVariant,
-  openCodeConfig,
-  mcpServers,
-  headers,
-  openCodeSessionId,
-  isResume,
-  seedResumeSessionOnFirstPrompt,
-  rerunContinue,
-  bridgePort,
-  bridgeToken,
-  sandboxId,
-  sandboxCredentialEnvironment,
-  debug,
-  permissionMode,
-  builtinToolFiltering,
-  sandbox,
-  sandboxHomeDir,
-  transformModel,
-  supportsUserMessageResponses
-}) {
-  let stopped = false;
-  let stopPromise;
-  let latestOpenCodeSessionId = openCodeSessionId;
-  let pendingResumeSessionId = seedResumeSessionOnFirstPrompt ? openCodeSessionId : void 0;
-  let selectedModel;
-  let activeTurn = false;
-  const pendingCompactionParts = [];
-  channel.on("bridge-thread", (msg) => {
-    latestOpenCodeSessionId = msg.threadId;
-  });
-  const wireTurn = (turnOpts) => {
-    activeTurn = true;
-    let pendingResolve;
-    let pendingReject;
-    const done = new Promise((resolve, reject) => {
-      pendingResolve = resolve;
-      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 {
-      }
-    };
-    const eventTypes = [
-      "stream-start",
-      "text-start",
-      "text-delta",
-      "text-end",
-      "reasoning-start",
-      "reasoning-delta",
-      "reasoning-end",
-      "tool-call",
-      "tool-approval-request",
-      "tool-result",
-      "file-change",
-      "finish-step",
-      "compaction",
-      "raw"
-    ];
-    let isSettled = false;
-    const settleSuccess = () => {
-      if (isSettled) return;
-      isSettled = true;
-      activeTurn = false;
-      userMessageSubmitter?.close();
-      for (const u of unsubs) u();
-      pendingResolve();
-    };
-    const settleError = (err) => {
-      if (isSettled) return;
-      isSettled = true;
-      activeTurn = false;
-      userMessageSubmitter?.close(err);
-      for (const u of unsubs) u();
-      pendingReject(err);
-    };
-    for (const type of eventTypes) {
-      unsubs.push(
-        channel.on(type, (msg) => {
-          forward(msg);
-        })
-      );
-    }
-    unsubs.push(
-      channel.on("finish", (msg) => {
-        forward(msg);
-        settleSuccess();
-      })
-    );
-    unsubs.push(
-      channel.on("error", (msg) => {
-        forward(msg);
-        settleError(msg.error);
-      })
-    );
-    const onClose = (_code, reason) => {
-      if (isSettled) return;
-      if (reason === "suspended") {
-        settleSuccess();
-        return;
-      }
-      settleError(
-        new Error("OpenCode 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
-        });
-      }
-    }
-    while (pendingCompactionParts.length > 0) {
-      forward(pendingCompactionParts.shift());
-    }
-    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 startBase = (turnModel) => ({
-    model: transformModel == null ? turnModel : transformModel(turnModel),
-    provider,
-    ...reasoningVariant ? { variant: reasoningVariant } : {},
-    ...openCodeConfig == null ? {} : { openCodeConfig },
-    ...mcpServers == null ? {} : { mcpServers },
-    ...headers == null ? {} : { headers },
-    ...permissionMode ? { permissionMode } : {},
-    ...builtinToolFiltering ? { builtinToolFiltering } : {},
-    ...pendingResumeSessionId ? { resumeSessionId: pendingResumeSessionId } : latestOpenCodeSessionId ? { resumeSessionId: latestOpenCodeSessionId } : {},
-    ...debug ? { debug } : {}
-  });
-  const prepareTurn = async (opts) => {
-    if (opts.responseFormat?.type === "json" && opts.responseFormat.schema == null) {
-      throw new HarnessCapabilityUnsupportedError2({
-        message: "Harness 'opencode' requires a JSON schema for structured output.",
-        harnessId: "opencode"
-      });
-    }
-    const skillWriteResult = await writeSkills({
-      sandbox,
-      homePath: sandboxHomeDir,
-      skillsDir: ".agents/skills",
-      skills: opts.skills,
-      abortSignal: opts.abortSignal,
-      invalidSkillNameMessage: ({ name }) => `Invalid OpenCode skill name: ${name}`,
-      invalidSkillFilePathMessage: ({ skillName, filePath }) => `Invalid OpenCode skill file path for ${skillName}: ${filePath}`
-    });
-    const control = wireTurn({
-      emit: opts.emit,
-      abortSignal: opts.abortSignal
-    });
-    return { control, skillWriteResult };
-  };
-  return {
-    sessionId,
-    isResume,
-    doPromptTurn: async (promptOpts) => {
-      const { control, skillWriteResult } = await prepareTurn(promptOpts);
-      const turnModel = promptOpts.model ?? selectedModel;
-      if (turnModel) selectedModel = turnModel;
-      channel.send({
-        type: "start",
-        operation: "prompt",
-        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 } : {},
-        skillsChanged: skillWriteResult.changed,
-        ...startBase(turnModel)
-      });
-      pendingResumeSessionId = void 0;
-      return control;
-    },
-    doContinueTurn: async (continueOpts) => {
-      const { control, skillWriteResult } = await prepareTurn(continueOpts);
-      if (rerunContinue) {
-        const turnModel = continueOpts.model ?? selectedModel;
-        if (turnModel) selectedModel = turnModel;
-        channel.send({
-          type: "start",
-          operation: "prompt",
-          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 } : {},
-          skillsChanged: skillWriteResult.changed,
-          ...startBase(turnModel)
-        });
-        pendingResumeSessionId = void 0;
-      }
-      return control;
-    },
-    doCompact: async (customInstructions) => {
-      if (customInstructions?.trim()) {
-        throw new HarnessCapabilityUnsupportedError2({
-          harnessId: "opencode",
-          message: "Harness 'opencode' supports native manual compaction, but OpenCode does not expose custom compaction instructions through the supported API."
-        });
-      }
-      if (activeTurn) {
-        throw new HarnessCapabilityUnsupportedError2({
-          harnessId: "opencode",
-          message: "Harness 'opencode' supports manual compaction between turns; compacting during an active turn is not supported by the bridge transport."
-        });
-      }
-      await runCompactOperation({
-        channel,
-        model: transformModel == null ? selectedModel : transformModel(selectedModel),
-        provider,
-        permissionMode,
-        debug,
-        openCodeConfig,
-        mcpServers,
-        headers,
-        resumeSessionId: latestOpenCodeSessionId,
-        onCompaction: (part) => pendingCompactionParts.push(part)
-      });
-    },
-    doDetach: async () => {
-      if (stopped) {
-        throw new Error(
-          `OpenCode session ${sessionId} is already stopped; cannot detach.`
-        );
-      }
-      stopped = true;
-      const lastSeenEventId = await channel.suspend();
-      return {
-        type: "resume-session",
-        harnessId: "opencode",
-        specificationVersion: "harness-v1",
-        data: {
-          ...latestOpenCodeSessionId ? { openCodeSessionId: latestOpenCodeSessionId } : {},
-          ...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment },
-          bridge: {
-            port: bridgePort,
-            token: bridgeToken,
-            lastSeenEventId,
-            ...sandboxId == null ? {} : { sandboxId }
-          }
-        }
-      };
-    },
-    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((resolve) => {
-                stopTimer = setTimeout(resolve, 5e3);
-                stopTimer.unref?.();
-              })
-            ]);
-          }
-        } finally {
-          if (stopTimer) clearTimeout(stopTimer);
-          try {
-            await proc?.kill();
-          } catch {
-          }
-          channel.close();
-        }
-      })();
-      return stopPromise;
-    },
-    doStop: async () => {
-      if (stopped) {
-        throw new Error(
-          `OpenCode session ${sessionId} is already stopped; cannot stop.`
-        );
-      }
-      stopped = true;
-      channel.beginClose();
-      const data = channel.isClosed() ? {} : await new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-          unsub();
-          reject(
-            new Error(
-              `OpenCode session ${sessionId} did not reply to stop within 5s.`
-            )
-          );
-        }, 5e3);
-        timer.unref?.();
-        const unsub = channel.on("bridge-stop", (msg) => {
-          clearTimeout(timer);
-          unsub();
-          resolve(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((resolve) => {
-              stopTimer = setTimeout(resolve, 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 } : {};
-      const payload = {
-        type: "resume-session",
-        harnessId: "opencode",
-        specificationVersion: "harness-v1",
-        data: {
-          ...lifecycleData,
-          ...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment }
-        }
-      };
-      return payload;
-    },
-    doSuspendTurn: async () => {
-      if (stopped) {
-        throw new Error(
-          `OpenCode session ${sessionId} is stopped; cannot suspend.`
-        );
-      }
-      stopped = true;
-      const lastSeenEventId = await channel.suspend();
-      const payload = {
-        type: "continue-turn",
-        harnessId: "opencode",
-        specificationVersion: "harness-v1",
-        data: {
-          ...latestOpenCodeSessionId ? { openCodeSessionId: latestOpenCodeSessionId } : {},
-          ...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment },
-          bridge: {
-            port: bridgePort,
-            token: bridgeToken,
-            lastSeenEventId,
-            ...sandboxId == null ? {} : { sandboxId }
-          }
-        }
-      };
-      return payload;
-    }
-  };
+function createSession({ sessionId, channel, proc, provider, reasoningVariant, openCodeConfig, mcpServers, headers, openCodeSessionId, isResume, seedResumeSessionOnFirstPrompt, rerunContinue, bridgePort, bridgeToken, sandboxId, sandboxCredentialEnvironment, debug, permissionMode, builtinToolFiltering, sandbox, sandboxHomeDir, transformModel, supportsUserMessageResponses }) {
+	let stopped = false;
+	let stopPromise;
+	let latestOpenCodeSessionId = openCodeSessionId;
+	let pendingResumeSessionId = seedResumeSessionOnFirstPrompt ? openCodeSessionId : void 0;
+	let selectedModel;
+	let activeTurn = false;
+	const pendingCompactionParts = [];
+	channel.on("bridge-thread", (msg) => {
+		latestOpenCodeSessionId = msg.threadId;
+	});
+	const wireTurn = (turnOpts) => {
+		activeTurn = true;
+		let pendingResolve;
+		let pendingReject;
+		const done = new Promise((resolve, reject) => {
+			pendingResolve = resolve;
+			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 {}
+		};
+		const eventTypes = [
+			"stream-start",
+			"text-start",
+			"text-delta",
+			"text-end",
+			"reasoning-start",
+			"reasoning-delta",
+			"reasoning-end",
+			"tool-call",
+			"tool-approval-request",
+			"tool-result",
+			"file-change",
+			"finish-step",
+			"compaction",
+			"raw"
+		];
+		let isSettled = false;
+		const settleSuccess = () => {
+			if (isSettled) return;
+			isSettled = true;
+			activeTurn = false;
+			userMessageSubmitter?.close();
+			for (const u of unsubs) u();
+			pendingResolve();
+		};
+		const settleError = (err) => {
+			if (isSettled) return;
+			isSettled = true;
+			activeTurn = false;
+			userMessageSubmitter?.close(err);
+			for (const u of unsubs) u();
+			pendingReject(err);
+		};
+		for (const type of eventTypes) unsubs.push(channel.on(type, (msg) => {
+			forward(msg);
+		}));
+		unsubs.push(channel.on("finish", (msg) => {
+			forward(msg);
+			settleSuccess();
+		}));
+		unsubs.push(channel.on("error", (msg) => {
+			forward(msg);
+			settleError(msg.error);
+		}));
+		const onClose = (_code, reason) => {
+			if (isSettled) return;
+			if (reason === "suspended") {
+				settleSuccess();
+				return;
+			}
+			settleError(/* @__PURE__ */ new Error("OpenCode 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 });
+		}
+		while (pendingCompactionParts.length > 0) forward(pendingCompactionParts.shift());
+		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 startBase = (turnModel) => ({
+		model: transformModel == null ? turnModel : transformModel(turnModel),
+		provider,
+		...reasoningVariant ? { variant: reasoningVariant } : {},
+		...openCodeConfig == null ? {} : { openCodeConfig },
+		...mcpServers == null ? {} : { mcpServers },
+		...headers == null ? {} : { headers },
+		...permissionMode ? { permissionMode } : {},
+		...builtinToolFiltering ? { builtinToolFiltering } : {},
+		...pendingResumeSessionId ? { resumeSessionId: pendingResumeSessionId } : latestOpenCodeSessionId ? { resumeSessionId: latestOpenCodeSessionId } : {},
+		...debug ? { debug } : {}
+	});
+	const prepareTurn = async (opts) => {
+		if (opts.responseFormat?.type === "json" && opts.responseFormat.schema == null) throw new HarnessCapabilityUnsupportedError({
+			message: "Harness 'opencode' requires a JSON schema for structured output.",
+			harnessId: "opencode"
+		});
+		const skillWriteResult = await writeSkills({
+			sandbox,
+			homePath: sandboxHomeDir,
+			skillsDir: ".agents/skills",
+			skills: opts.skills,
+			abortSignal: opts.abortSignal,
+			invalidSkillNameMessage: ({ name }) => `Invalid OpenCode skill name: ${name}`,
+			invalidSkillFilePathMessage: ({ skillName, filePath }) => `Invalid OpenCode skill file path for ${skillName}: ${filePath}`
+		});
+		return {
+			control: wireTurn({
+				emit: opts.emit,
+				abortSignal: opts.abortSignal
+			}),
+			skillWriteResult
+		};
+	};
+	return {
+		sessionId,
+		isResume,
+		doPromptTurn: async (promptOpts) => {
+			const { control, skillWriteResult } = await prepareTurn(promptOpts);
+			const turnModel = promptOpts.model ?? selectedModel;
+			if (turnModel) selectedModel = turnModel;
+			channel.send({
+				type: "start",
+				operation: "prompt",
+				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 } : {},
+				skillsChanged: skillWriteResult.changed,
+				...startBase(turnModel)
+			});
+			pendingResumeSessionId = void 0;
+			return control;
+		},
+		doContinueTurn: async (continueOpts) => {
+			const { control, skillWriteResult } = await prepareTurn(continueOpts);
+			if (rerunContinue) {
+				const turnModel = continueOpts.model ?? selectedModel;
+				if (turnModel) selectedModel = turnModel;
+				channel.send({
+					type: "start",
+					operation: "prompt",
+					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 } : {},
+					skillsChanged: skillWriteResult.changed,
+					...startBase(turnModel)
+				});
+				pendingResumeSessionId = void 0;
+			}
+			return control;
+		},
+		doCompact: async (customInstructions) => {
+			if (customInstructions?.trim()) throw new HarnessCapabilityUnsupportedError({
+				harnessId: "opencode",
+				message: "Harness 'opencode' supports native manual compaction, but OpenCode does not expose custom compaction instructions through the supported API."
+			});
+			if (activeTurn) throw new HarnessCapabilityUnsupportedError({
+				harnessId: "opencode",
+				message: "Harness 'opencode' supports manual compaction between turns; compacting during an active turn is not supported by the bridge transport."
+			});
+			await runCompactOperation({
+				channel,
+				model: transformModel == null ? selectedModel : transformModel(selectedModel),
+				provider,
+				permissionMode,
+				debug,
+				openCodeConfig,
+				mcpServers,
+				headers,
+				resumeSessionId: latestOpenCodeSessionId,
+				onCompaction: (part) => pendingCompactionParts.push(part)
+			});
+		},
+		doDetach: async () => {
+			if (stopped) throw new Error(`OpenCode session ${sessionId} is already stopped; cannot detach.`);
+			stopped = true;
+			const lastSeenEventId = await channel.suspend();
+			return {
+				type: "resume-session",
+				harnessId: "opencode",
+				specificationVersion: "harness-v1",
+				data: {
+					...latestOpenCodeSessionId ? { openCodeSessionId: latestOpenCodeSessionId } : {},
+					...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment },
+					bridge: {
+						port: bridgePort,
+						token: bridgeToken,
+						lastSeenEventId,
+						...sandboxId == null ? {} : { sandboxId }
+					}
+				}
+			};
+		},
+		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((resolve) => {
+						stopTimer = setTimeout(resolve, 5e3);
+						stopTimer.unref?.();
+					})]);
+				} finally {
+					if (stopTimer) clearTimeout(stopTimer);
+					try {
+						await proc?.kill();
+					} catch {}
+					channel.close();
+				}
+			})();
+			return stopPromise;
+		},
+		doStop: async () => {
+			if (stopped) throw new Error(`OpenCode session ${sessionId} is already stopped; cannot stop.`);
+			stopped = true;
+			channel.beginClose();
+			const data = channel.isClosed() ? {} : await new Promise((resolve, reject) => {
+				const timer = setTimeout(() => {
+					unsub();
+					reject(/* @__PURE__ */ new Error(`OpenCode session ${sessionId} did not reply to stop within 5s.`));
+				}, 5e3);
+				timer.unref?.();
+				const unsub = channel.on("bridge-stop", (msg) => {
+					clearTimeout(timer);
+					unsub();
+					resolve(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((resolve) => {
+					stopTimer = setTimeout(resolve, 5e3);
+					stopTimer.unref?.();
+				})]);
+			} finally {
+				if (stopTimer) clearTimeout(stopTimer);
+				try {
+					await proc?.kill();
+				} catch {}
+				channel.close();
+			}
+			return {
+				type: "resume-session",
+				harnessId: "opencode",
+				specificationVersion: "harness-v1",
+				data: {
+					...data != null && typeof data === "object" && !Array.isArray(data) ? { ...data } : {},
+					...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment }
+				}
+			};
+		},
+		doSuspendTurn: async () => {
+			if (stopped) throw new Error(`OpenCode session ${sessionId} is stopped; cannot suspend.`);
+			stopped = true;
+			const lastSeenEventId = await channel.suspend();
+			return {
+				type: "continue-turn",
+				harnessId: "opencode",
+				specificationVersion: "harness-v1",
+				data: {
+					...latestOpenCodeSessionId ? { openCodeSessionId: latestOpenCodeSessionId } : {},
+					...sandboxCredentialEnvironment == null ? {} : { sandboxCredentialEnvironment },
+					bridge: {
+						port: bridgePort,
+						token: bridgeToken,
+						lastSeenEventId,
+						...sandboxId == null ? {} : { sandboxId }
+					}
+				}
+			};
+		}
+	};
 }
-async function runCompactOperation({
-  channel,
-  model,
-  provider,
-  permissionMode,
-  debug,
-  openCodeConfig,
-  mcpServers,
-  headers,
-  resumeSessionId,
-  onCompaction
-}) {
-  let pendingResolve;
-  let pendingReject;
-  const done = new Promise((resolve, reject) => {
-    pendingResolve = resolve;
-    pendingReject = reject;
-  });
-  const unsubs = [
-    channel.on("compaction", (msg) => onCompaction(msg)),
-    channel.on("finish", () => {
-      for (const u of unsubs) u();
-      pendingResolve();
-    }),
-    channel.on("error", (msg) => {
-      for (const u of unsubs) u();
-      pendingReject(msg.error);
-    })
-  ];
-  channel.send({
-    type: "start",
-    operation: "compact",
-    prompt: "",
-    tools: [],
-    model,
-    provider,
-    ...openCodeConfig == null ? {} : { openCodeConfig },
-    ...mcpServers == null ? {} : { mcpServers },
-    ...headers == null ? {} : { headers },
-    ...permissionMode ? { permissionMode } : {},
-    ...resumeSessionId ? { resumeSessionId } : {},
-    ...debug ? { debug } : {}
-  });
-  await done;
+async function runCompactOperation({ channel, model, provider, permissionMode, debug, openCodeConfig, mcpServers, headers, resumeSessionId, onCompaction }) {
+	let pendingResolve;
+	let pendingReject;
+	const done = new Promise((resolve, reject) => {
+		pendingResolve = resolve;
+		pendingReject = reject;
+	});
+	const unsubs = [
+		channel.on("compaction", (msg) => onCompaction(msg)),
+		channel.on("finish", () => {
+			for (const u of unsubs) u();
+			pendingResolve();
+		}),
+		channel.on("error", (msg) => {
+			for (const u of unsubs) u();
+			pendingReject(msg.error);
+		})
+	];
+	channel.send({
+		type: "start",
+		operation: "compact",
+		prompt: "",
+		tools: [],
+		model,
+		provider,
+		...openCodeConfig == null ? {} : { openCodeConfig },
+		...mcpServers == null ? {} : { mcpServers },
+		...headers == null ? {} : { headers },
+		...permissionMode ? { permissionMode } : {},
+		...resumeSessionId ? { resumeSessionId } : {},
+		...debug ? { debug } : {}
+	});
+	await done;
 }
 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 HarnessCapabilityUnsupportedError2({
-        harnessId: "opencode",
-        message: `The OpenCode 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");
+	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: "opencode",
+			message: `The OpenCode 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");
 }
+//#endregion
+//#region src/index.ts
+/**
+* Default `openCode` harness instance with no overrides. Equivalent to
+* `createOpenCode()`.
+*/
+const openCode = createOpenCode();
+//#endregion
+export { VERSION, createOpenCode, openCode };
 
-// src/index.ts
-var openCode = createOpenCode();
-export {
-  VERSION,
-  createOpenCode,
-  openCode
-};
 //# sourceMappingURL=index.js.map