@obversa/engine-opencode-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1305 @@
+import { realpathSync, mkdirSync, mkdtempSync, rmSync, readdirSync, statSync, existsSync } from 'fs';
+import { tmpdir, userInfo } from 'os';
+import { isAbsolute, join, dirname, delimiter, relative, sep } from 'path';
+import { isDeepStrictEqual } from 'util';
+import { modelIdentity, canonicalJson, engineSelection, EngineError, EngineIncompleteResultError, validateIncompleteResultEvidence, cloneFrozenJson, classifyEngineFailure, validateAgentResult, assertReadAccess, reportedUsage } from '@obversa/api';
+import { attemptEnvironment, DEFAULT_OWNED_COMMAND_LIMITS, ownedCommandIdentity, scrubCapture, resolveCommandExecutable, runOwnedCommand, OwnedCommandError, retryAfterHeaderToMs } from '@obversa/core/command';
+
+// src/opencode-cli.ts
+var SUPPORTED_VERSION = "1.18.23";
+var VERSION_TIMEOUT_MS = 1e4;
+var VERSION_TEARDOWN_MS = 1e3;
+var VERSION_OUTPUT_BYTES = 4096;
+var OPENCODE_VERSION = /^\d+\.\d+\.\d+$/u;
+var CONTROL_CHARACTER = /[\u0000-\u001f\u007f]/u;
+var STRUCTURED_RESULT_MARKER = "OBVERSA_STRUCTURED_RESULT_V1\n";
+var CONFIG_INTERPOLATION = /\{(?:env|file):/u;
+var STEP_FINISH_REASONS = /* @__PURE__ */ new Set([
+  "stop",
+  "length",
+  "tool-calls",
+  "content-filter",
+  "error",
+  "unknown"
+]);
+var BASE_SYSTEM_PROMPT = "Execute one isolated Obversa node attempt. Follow only this system prompt and the user prompt. Use only the declared tools and permissions.";
+var STRUCTURED_RESULT_INSTRUCTION = [
+  "Your final answer must be one completed text part beginning with exactly:",
+  "OBVERSA_STRUCTURED_RESULT_V1",
+  "After that marker and one newline, write exactly one JSON value and nothing else."
+].join("\n");
+var CAPABILITIES = /* @__PURE__ */ new Set([
+  "read",
+  "edit",
+  "glob",
+  "grep",
+  "bash",
+  "task",
+  "todowrite",
+  "webfetch",
+  "websearch"
+]);
+var FILESYSTEM_CAPABILITIES = /* @__PURE__ */ new Set([
+  "read",
+  "edit",
+  "glob",
+  "grep",
+  "bash"
+]);
+var WRITE_CAPABILITIES = /* @__PURE__ */ new Set(["edit", "bash"]);
+var PATTERN_PERMISSIONS = /* @__PURE__ */ new Set([
+  "read",
+  "edit",
+  "glob",
+  "grep",
+  "bash",
+  "task"
+]);
+var PERMISSION_NAMES = /* @__PURE__ */ new Map([
+  ["read", "read"],
+  ["edit", "edit"],
+  ["write", "edit"],
+  ["applypatch", "edit"],
+  ["glob", "glob"],
+  ["grep", "grep"],
+  ["bash", "bash"],
+  ["task", "task"],
+  ["todowrite", "todowrite"],
+  ["webfetch", "webfetch"],
+  ["websearch", "websearch"]
+]);
+function opencode(modelName, options) {
+  const selected = model(modelName);
+  const { modelFamily } = modelIdentity(selected.value);
+  return {
+    engine: new OpenCodeCliEngine({
+      executable: options.executable,
+      version: SUPPORTED_VERSION,
+      identity: { provider: selected.provider, modelFamily }
+    }),
+    identity: {
+      adapter: "opencode-cli",
+      provider: selected.provider,
+      modelFamily,
+      model: selected.value,
+      tools: options.tools ?? ["read", "grep"]
+    }
+  };
+}
+function text(value, field) {
+  if (typeof value !== "string" || value.length === 0 || value !== value.trim() || CONTROL_CHARACTER.test(value)) {
+    throw new TypeError(
+      `${field} must be a non-empty trimmed string without control characters`
+    );
+  }
+  return value;
+}
+function nullableText(value, field) {
+  return value === null ? null : text(value, field);
+}
+function object(value, field) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError(`${field} must be an object`);
+  }
+  return value;
+}
+function safeInteger(value, field) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError(`${field} must be a non-negative safe integer`);
+  }
+  return value;
+}
+function safeSum(left, right) {
+  const result = left + right;
+  return Number.isSafeInteger(result) ? result : void 0;
+}
+function model(value) {
+  const checked = text(value, "OpenCode request model");
+  const slash = checked.indexOf("/");
+  if (slash < 1 || slash === checked.length - 1 || checked.includes(" ") || checked.indexOf("/", slash + 1) !== -1) {
+    throw new TypeError("OpenCode request model must use provider/model format");
+  }
+  if (CONFIG_INTERPOLATION.test(checked)) {
+    throw new TypeError(
+      "OpenCode request model must not carry config interpolation tokens {env:...} or {file:...}"
+    );
+  }
+  const derived = modelIdentity(checked);
+  if (derived.provider === void 0) {
+    throw new TypeError("OpenCode request model must use provider/model format");
+  }
+  return Object.freeze({ value: checked, provider: derived.provider });
+}
+function providerForModel(selectedModel, identity) {
+  const asserted = nullableText(identity.provider, "OpenCode provider");
+  if (asserted !== null && asserted !== selectedModel.provider) {
+    throw new TypeError(
+      `OpenCode provider identity ${asserted} does not match model provider ${selectedModel.provider}`
+    );
+  }
+  return selectedModel.provider;
+}
+function familyForModel(selectedModel, identity) {
+  const asserted = nullableText(identity.modelFamily, "OpenCode model family");
+  const derived = modelIdentity(selectedModel.value).modelFamily;
+  if (asserted !== null && asserted !== derived) {
+    throw new TypeError(
+      `OpenCode model family identity ${asserted} does not match model family ${derived}`
+    );
+  }
+  return derived;
+}
+function selectedEnvironment(raw) {
+  const selected = {};
+  for (const [name, value] of Object.entries(raw ?? {})) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(name)) {
+      throw new TypeError(`OpenCode environment name ${name} is invalid`);
+    }
+    if (typeof value !== "string" || value.includes("\0")) {
+      throw new TypeError(
+        `OpenCode environment value ${name} must be a string without NUL`
+      );
+    }
+    if (name === "HOME" || name === "TMPDIR" || name.startsWith("XDG_") || name.startsWith("OPENCODE_")) {
+      throw new TypeError(`OpenCode environment cannot replace ${name}`);
+    }
+    selected[name] = value;
+  }
+  return Object.freeze(selected);
+}
+function authValue(value) {
+  if (value === void 0) return Object.freeze({});
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new TypeError("OpenCode auth must be a provider-keyed object");
+  }
+  const checked = cloneFrozenJson(value);
+  for (const [provider, rawEntry] of Object.entries(checked)) {
+    text(provider, "OpenCode auth provider");
+    const entry = object(rawEntry, `OpenCode auth entry ${provider}`);
+    if (entry.type === "wellknown") {
+      throw new TypeError("OpenCode wellknown auth is not isolated");
+    }
+    if (entry.type === "api") {
+      for (const field of Object.keys(entry)) {
+        if (!["type", "key", "metadata"].includes(field)) {
+          throw new TypeError(`OpenCode api auth field ${field} is not supported`);
+        }
+      }
+      if (typeof entry.key !== "string") {
+        throw new TypeError("OpenCode api auth key must be a string");
+      }
+      if (entry.metadata !== void 0) {
+        const metadata = object(
+          entry.metadata,
+          `OpenCode api auth metadata ${provider}`
+        );
+        if (Object.values(metadata).some((item) => typeof item !== "string")) {
+          throw new TypeError("OpenCode api auth metadata values must be strings");
+        }
+      }
+      continue;
+    }
+    if (entry.type === "oauth") {
+      for (const field of Object.keys(entry)) {
+        if (![
+          "type",
+          "refresh",
+          "access",
+          "expires",
+          "accountId",
+          "enterpriseUrl"
+        ].includes(field)) {
+          throw new TypeError(`OpenCode oauth auth field ${field} is not supported`);
+        }
+      }
+      if (typeof entry.refresh !== "string" || typeof entry.access !== "string") {
+        throw new TypeError("OpenCode oauth auth tokens must be strings");
+      }
+      safeInteger(entry.expires, "OpenCode oauth auth expiry");
+      for (const field of ["accountId", "enterpriseUrl"]) {
+        if (entry[field] !== void 0 && typeof entry[field] !== "string") {
+          throw new TypeError(`OpenCode oauth auth ${field} must be a string`);
+        }
+      }
+      continue;
+    }
+    throw new TypeError(`OpenCode auth type ${String(entry.type)} is not supported`);
+  }
+  return checked;
+}
+function managedConfigSources(extraDirectories = []) {
+  const systemDirectory = process.platform === "darwin" ? "/Library/Application Support/opencode" : process.platform === "win32" ? "C:\\ProgramData\\opencode" : "/etc/opencode";
+  const directories = [systemDirectory, ...extraDirectories];
+  const sources = directories.flatMap((directory) => [
+    join(directory, "opencode.json"),
+    join(directory, "opencode.jsonc")
+  ]);
+  if (process.platform === "darwin") {
+    let user = "user";
+    try {
+      user = userInfo().username || user;
+    } catch {
+    }
+    sources.push(
+      join(
+        "/Library/Managed Preferences",
+        user,
+        "ai.opencode.managed.plist"
+      ),
+      "/Library/Managed Preferences/ai.opencode.managed.plist"
+    );
+  }
+  return Object.freeze(sources);
+}
+function findManagedConfig(sources) {
+  return sources.find((candidate) => existsSync(candidate));
+}
+function assertNoManagedConfig(sources) {
+  const source = findManagedConfig(sources);
+  if (source !== void 0) {
+    throw new TypeError(`managed OpenCode config is not isolated: ${source}`);
+  }
+}
+function assertNoProjectInstructions(workspace, capabilities) {
+  if (!capabilities.some((capability) => FILESYSTEM_CAPABILITIES.has(capability))) {
+    return;
+  }
+  const instructionNames = /* @__PURE__ */ new Set(["agents.md", "claude.md", "context.md"]);
+  const pending = [{ directory: workspace, root: true }];
+  const visited = /* @__PURE__ */ new Set();
+  while (pending.length > 0) {
+    const { directory, root } = pending.pop();
+    let resolvedDirectory;
+    let entries;
+    try {
+      resolvedDirectory = realpathSync(directory);
+      if (visited.has(resolvedDirectory)) continue;
+      visited.add(resolvedDirectory);
+      entries = readdirSync(resolvedDirectory, { withFileTypes: true });
+    } catch (error) {
+      throw new TypeError(
+        `OpenCode could not inspect project instructions under ${directory}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    for (const entry of entries) {
+      const path = join(resolvedDirectory, entry.name);
+      if (!root && instructionNames.has(entry.name.toLowerCase())) {
+        throw new TypeError(
+          `OpenCode project instruction ${path} is not isolated`
+        );
+      }
+      if (entry.isSymbolicLink()) {
+        let target;
+        let directoryTarget;
+        try {
+          target = realpathSync(path);
+          directoryTarget = statSync(target).isDirectory();
+        } catch (error) {
+          throw new TypeError(
+            `OpenCode could not inspect project symlink ${path}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        const pathFromWorkspace = relative(workspace, target);
+        if (pathFromWorkspace === ".." || pathFromWorkspace.startsWith(`..${sep}`) || isAbsolute(pathFromWorkspace)) {
+          throw new TypeError(
+            `OpenCode symlink ${path} resolves outside the workspace`
+          );
+        }
+        if (directoryTarget) {
+          if (target === workspace) {
+            throw new TypeError(
+              `OpenCode symlink ${path} resolves to the workspace root`
+            );
+          }
+          pending.push({ directory: target, root: false });
+        }
+      } else if (entry.isDirectory()) {
+        pending.push({ directory: path, root: false });
+      }
+    }
+  }
+}
+function authRedactions(value) {
+  const redactions = {
+    OPENCODE_AUTH_CONTENT: canonicalJson(value)
+  };
+  const pending = [value];
+  let index = 0;
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (typeof current === "string") {
+      redactions[`OPENCODE_AUTH_VALUE_${index}`] = current;
+      index += 1;
+    } else if (Array.isArray(current)) {
+      pending.push(...current);
+    } else if (typeof current === "object" && current !== null) {
+      pending.push(...Object.values(current));
+    }
+  }
+  return Object.freeze(redactions);
+}
+function scrubExactValues(raw, redactions) {
+  const values = [...new Set(Object.values(redactions))].filter((value) => value.length > 0).sort((left, right) => right.length - left.length);
+  let result = raw;
+  for (const value of values) result = result.split(value).join("[redacted]");
+  return result;
+}
+function requestedCapabilities(request) {
+  assertReadAccess(request);
+  const capabilities = engineSelection({
+    adapter: "opencode-cli",
+    capabilities: request.tools ?? []
+  }).capabilities;
+  for (const capability of capabilities) {
+    if (!CAPABILITIES.has(capability)) {
+      throw new TypeError(
+        `OpenCode cannot represent capability ${capability}`
+      );
+    }
+  }
+  if (request.leaf !== false && capabilities.includes("task")) {
+    throw new TypeError("OpenCode leaf attempts cannot expose task");
+  }
+  const workspaceMode = request.workspaceMode ?? "none";
+  if (workspaceMode !== "write" && capabilities.includes("task")) {
+    throw new TypeError(`OpenCode workspace mode ${workspaceMode} cannot expose task capability`);
+  }
+  if (workspaceMode === "none") {
+    const unsafe = capabilities.find(
+      (capability) => FILESYSTEM_CAPABILITIES.has(capability)
+    );
+    if (unsafe !== void 0) {
+      throw new TypeError(
+        `OpenCode workspace mode none cannot expose capability ${unsafe}`
+      );
+    }
+  }
+  if (workspaceMode === "read") {
+    const unsafe = capabilities.find(
+      (capability) => WRITE_CAPABILITIES.has(capability)
+    );
+    if (unsafe !== void 0) {
+      throw new TypeError(
+        `OpenCode read-only workspace cannot expose capability ${unsafe}`
+      );
+    }
+    if (!capabilities.some((capability) => ["read", "glob", "grep"].includes(capability))) {
+      throw new TypeError("OpenCode read workspace requires a file-reading capability");
+    }
+  }
+  if (workspaceMode !== "none" && workspaceMode !== "read" && workspaceMode !== "write") {
+    throw new TypeError("OpenCode workspace mode must be none, read, or write");
+  }
+  return capabilities;
+}
+function permissionRule(raw) {
+  const checked = text(raw, "OpenCode permission rule");
+  const match = /^([A-Za-z][A-Za-z0-9_]*)(?:\(([^\u0000-\u001f\u007f]+)\))?$/u.exec(checked);
+  if (!match) {
+    throw new TypeError(`OpenCode cannot represent permission rule ${checked}`);
+  }
+  const permission = PERMISSION_NAMES.get(match[1].toLowerCase());
+  if (permission === void 0) {
+    throw new TypeError(`OpenCode cannot represent permission rule ${checked}`);
+  }
+  return Object.freeze({ permission, pattern: match[2] ?? null });
+}
+function permissions(request) {
+  const capabilities = requestedCapabilities(request);
+  const toolValues = { "*": false };
+  for (const capability of capabilities) toolValues[capability] = true;
+  const permissionValues = { "*": "deny" };
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of request.allowedTools ?? []) {
+    if (seen.has(raw)) throw new TypeError("allowedTools must be unique");
+    seen.add(raw);
+    const rule = permissionRule(raw);
+    if (rule.pattern !== null && !PATTERN_PERMISSIONS.has(rule.permission)) {
+      throw new TypeError(
+        `OpenCode permission ${rule.permission} does not accept patterns`
+      );
+    }
+    if (!capabilities.includes(rule.permission)) {
+      throw new TypeError(
+        `OpenCode permission ${raw} has no declared ${rule.permission} capability`
+      );
+    }
+    if (rule.pattern === null) {
+      if (Object.hasOwn(permissionValues, rule.permission)) {
+        throw new TypeError(
+          `OpenCode permission ${rule.permission} has overlapping rules`
+        );
+      }
+      permissionValues[rule.permission] = "allow";
+      continue;
+    }
+    const current = permissionValues[rule.permission];
+    if (typeof current === "string") {
+      throw new TypeError(
+        `OpenCode permission ${rule.permission} has overlapping rules`
+      );
+    }
+    const patterns = current === void 0 ? { "*": "deny" } : { ...current };
+    if (Object.hasOwn(patterns, rule.pattern)) {
+      throw new TypeError(`OpenCode permission rule ${raw} is duplicated`);
+    }
+    patterns[rule.pattern] = "allow";
+    permissionValues[rule.permission] = patterns;
+  }
+  return Object.freeze({
+    capabilities,
+    tools: cloneFrozenJson(toolValues),
+    permission: cloneFrozenJson(permissionValues)
+  });
+}
+function trustedSystemPrompt(request) {
+  let prompt;
+  if (request.systemMode === "replace") {
+    if (request.system === void 0) {
+      throw new TypeError("OpenCode system replacement requires system text");
+    }
+    prompt = request.system;
+  } else {
+    prompt = request.system === void 0 ? BASE_SYSTEM_PROMPT : `${BASE_SYSTEM_PROMPT}
+
+${request.system}`;
+  }
+  if (request.jsonSchema !== void 0) {
+    prompt = `${prompt}
+
+${STRUCTURED_RESULT_INSTRUCTION}`;
+  }
+  return prompt;
+}
+function configFor(request, selectedModel, built) {
+  const agent = {
+    mode: "primary",
+    model: selectedModel.value,
+    prompt: trustedSystemPrompt(request),
+    tools: built.tools,
+    permission: built.permission
+  };
+  return cloneFrozenJson({
+    share: "disabled",
+    autoupdate: false,
+    snapshot: false,
+    model: selectedModel.value,
+    small_model: selectedModel.value,
+    enabled_providers: [selectedModel.provider],
+    default_agent: "build",
+    plugin: [],
+    instructions: [],
+    mcp: {},
+    lsp: false,
+    formatter: false,
+    tools: built.tools,
+    permission: built.permission,
+    agent: { build: agent }
+  });
+}
+function serializedConfig(value) {
+  const encoded = JSON.stringify(value);
+  if (CONFIG_INTERPOLATION.test(encoded)) {
+    throw new TypeError(
+      "OpenCode config interpolation tokens {env:...} and {file:...} are not allowed"
+    );
+  }
+  return encoded;
+}
+function buildOpenCodeInvocation(request, options, rawDirectory) {
+  if (typeof request.cwd !== "string" || !isAbsolute(request.cwd)) {
+    throw new TypeError("OpenCode request cwd must be an absolute path");
+  }
+  if (request.memory !== void 0) {
+    throw new TypeError("OpenCode CLI does not bridge Obversa memory");
+  }
+  if (request.env !== void 0 && Object.keys(request.env).length > 0) {
+    throw new TypeError(
+      "OpenCode request environment is not allowed; select values in the constructor environment"
+    );
+  }
+  if (!isAbsolute(rawDirectory)) {
+    throw new TypeError("OpenCode isolation directory must be an absolute path");
+  }
+  if (typeof options.executable !== "string" || !isAbsolute(options.executable)) {
+    throw new TypeError("OpenCode executable must be an absolute path");
+  }
+  if (options.version !== SUPPORTED_VERSION) {
+    throw new TypeError(`OpenCode CLI version must be ${SUPPORTED_VERSION}`);
+  }
+  const selectedModel = model(request.model);
+  providerForModel(selectedModel, options.identity);
+  familyForModel(selectedModel, options.identity);
+  const built = permissions(request);
+  if (built.capabilities.includes("websearch") && selectedModel.provider !== "opencode" && selectedModel.provider !== "opencode-go") {
+    throw new TypeError(
+      `OpenCode provider ${selectedModel.provider} cannot expose websearch`
+    );
+  }
+  const directory = realpathSync(rawDirectory);
+  const home = join(directory, "home");
+  const dataHome = join(directory, "xdg-data");
+  const configHome = join(directory, "xdg-config");
+  const cacheHome = join(directory, "xdg-cache");
+  const stateHome = join(directory, "xdg-state");
+  const temporary = join(directory, "tmp");
+  for (const path2 of [home, dataHome, configHome, cacheHome, stateHome, temporary]) {
+    mkdirSync(path2, { recursive: true, mode: 448 });
+  }
+  const selected = selectedEnvironment(options.environment);
+  const auth = authValue(options.auth);
+  const config = configFor(request, selectedModel, built);
+  const configContent = serializedConfig(config);
+  const attempt = attemptEnvironment({ ...request, env: void 0 }) ?? {};
+  const path = selected.PATH ?? [
+    dirname(process.execPath),
+    dirname(options.executable),
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin"
+  ].filter((value, index, values) => values.indexOf(value) === index).join(delimiter);
+  const environment = Object.freeze({
+    ...selected,
+    ...attempt,
+    PATH: path,
+    HOME: home,
+    XDG_DATA_HOME: dataHome,
+    XDG_CONFIG_HOME: configHome,
+    XDG_CACHE_HOME: cacheHome,
+    XDG_STATE_HOME: stateHome,
+    TMPDIR: temporary,
+    OPENCODE_CONFIG_DIR: join(configHome, "opencode"),
+    OPENCODE_CONFIG_CONTENT: configContent,
+    OPENCODE_AUTH_CONTENT: canonicalJson(auth),
+    OPENCODE_DISABLE_PROJECT_CONFIG: "1",
+    OPENCODE_PURE: "1",
+    OPENCODE_DISABLE_DEFAULT_PLUGINS: "1",
+    OPENCODE_DISABLE_EXTERNAL_SKILLS: "1",
+    OPENCODE_DISABLE_CLAUDE_CODE: "1",
+    OPENCODE_DISABLE_AUTOUPDATE: "1",
+    OPENCODE_DISABLE_LSP_DOWNLOAD: "1",
+    OPENCODE_DISABLE_SHARE: "1"
+  });
+  return Object.freeze({
+    args: Object.freeze([
+      "run",
+      "--format",
+      "json",
+      "--pure",
+      "--model",
+      selectedModel.value,
+      "--dir",
+      request.cwd
+    ]),
+    stdin: request.prompt,
+    environment,
+    configDirectory: configHome
+  });
+}
+function partKey(part) {
+  return `${part.sessionID}/${part.messageID}/${part.id}`;
+}
+function consumePart(raw, expectedType, wrapperSessionId, accumulator) {
+  const part = object(raw, `OpenCode ${expectedType} part`);
+  const id = text(part.id, `OpenCode ${expectedType} part id`);
+  const sessionId = text(
+    part.sessionID,
+    `OpenCode ${expectedType} part sessionID`
+  );
+  text(part.messageID, `OpenCode ${expectedType} part messageID`);
+  if (part.type !== expectedType) {
+    throw new TypeError(
+      `OpenCode ${expectedType} wrapper contained ${String(part.type)} part`
+    );
+  }
+  if (sessionId !== wrapperSessionId) {
+    throw new TypeError("OpenCode part session did not match its wrapper session");
+  }
+  const key = partKey({ ...part, id });
+  const encoded = canonicalJson(part);
+  const prior = accumulator.seenParts.get(key);
+  if (prior !== void 0) {
+    if (prior !== encoded) {
+      throw new TypeError(`OpenCode emitted conflicting duplicate part ${key}`);
+    }
+    return null;
+  }
+  accumulator.seenParts.set(key, encoded);
+  return part;
+}
+function consumeUsage(part, accumulator) {
+  try {
+    const tokens = object(part.tokens, "OpenCode step tokens");
+    const cache = object(tokens.cache, "OpenCode step cache tokens");
+    const input = safeInteger(tokens.input, "OpenCode input tokens");
+    const output = safeInteger(tokens.output, "OpenCode output tokens");
+    const reasoning = safeInteger(tokens.reasoning, "OpenCode reasoning tokens");
+    const cacheRead = safeInteger(cache.read, "OpenCode cache read tokens");
+    const cacheWrite = safeInteger(cache.write, "OpenCode cache write tokens");
+    const inputWithRead = safeSum(input, cacheRead);
+    const inputTotal = inputWithRead === void 0 ? void 0 : safeSum(inputWithRead, cacheWrite);
+    const outputTotal = safeSum(output, reasoning);
+    const nextInput = inputTotal === void 0 ? void 0 : safeSum(accumulator.inputTokens, inputTotal);
+    const nextOutput = outputTotal === void 0 ? void 0 : safeSum(accumulator.outputTokens, outputTotal);
+    const nextRead = safeSum(accumulator.cacheReadInputTokens, cacheRead);
+    const nextWrite = safeSum(accumulator.cacheCreationInputTokens, cacheWrite);
+    if (nextInput === void 0 || nextOutput === void 0 || nextRead === void 0 || nextWrite === void 0) {
+      throw new TypeError("OpenCode usage totals overflowed");
+    }
+    accumulator.inputTokens = nextInput;
+    accumulator.outputTokens = nextOutput;
+    accumulator.cacheReadInputTokens = nextRead;
+    accumulator.cacheCreationInputTokens = nextWrite;
+    accumulator.stepCount += 1;
+  } catch {
+    accumulator.usageValid = false;
+  }
+}
+function consumeLine(line, accumulator, onEvent, structured, capabilities) {
+  if (line.trim().length === 0 || accumulator.protocolError !== null) return;
+  try {
+    const frame = object(JSON.parse(line), "OpenCode stream frame");
+    const type = text(frame.type, "OpenCode stream frame type");
+    safeInteger(frame.timestamp, "OpenCode stream frame timestamp");
+    const sessionId = text(frame.sessionID, "OpenCode stream frame sessionID");
+    if (accumulator.sessionId === null) accumulator.sessionId = sessionId;
+    if (accumulator.sessionId !== sessionId) {
+      throw new TypeError("OpenCode stream changed session identity");
+    }
+    accumulator.frames.push(cloneFrozenJson(frame));
+    if (type === "error") {
+      if (accumulator.terminalError !== null) {
+        throw new TypeError("OpenCode emitted more than one terminal error");
+      }
+      accumulator.terminalError = object(frame.error, "OpenCode stream error");
+      return;
+    }
+    if (type === "text") {
+      const part = consumePart(frame.part, "text", sessionId, accumulator);
+      if (part === null) return;
+      const value = typeof part.text === "string" ? part.text : (() => {
+        throw new TypeError("OpenCode text part text must be a string");
+      })();
+      const time = object(part.time, "OpenCode text part time");
+      safeInteger(time.end, "OpenCode text part end time");
+      accumulator.text.push({ text: value });
+      if (!structured || !value.includes(STRUCTURED_RESULT_MARKER)) {
+        onEvent({ type: "text", delta: value });
+      }
+      return;
+    }
+    if (type === "reasoning") {
+      const part = consumePart(frame.part, "reasoning", sessionId, accumulator);
+      if (part === null) return;
+      if (typeof part.text !== "string") {
+        throw new TypeError("OpenCode reasoning part text must be a string");
+      }
+      onEvent({ type: "thinking", delta: part.text });
+      return;
+    }
+    if (type === "tool_use") {
+      const part = consumePart(frame.part, "tool", sessionId, accumulator);
+      if (part === null) return;
+      const name = text(part.tool, "OpenCode tool name");
+      const capability = name === "write" || name === "apply_patch" ? "edit" : name;
+      if (!capabilities.includes(capability)) {
+        throw new TypeError(`OpenCode emitted undeclared tool ${name}`);
+      }
+      const state = object(part.state, "OpenCode tool state");
+      if (state.status !== "completed" && state.status !== "error") {
+        throw new TypeError("OpenCode tool terminal state must be completed or error");
+      }
+      onEvent({ type: "tool", name, phase: "use" });
+      onEvent({ type: "tool", name, phase: "result" });
+      return;
+    }
+    if (type === "step_start") {
+      consumePart(frame.part, "step-start", sessionId, accumulator);
+      return;
+    }
+    if (type === "step_finish") {
+      const part = consumePart(frame.part, "step-finish", sessionId, accumulator);
+      if (part !== null) {
+        const reason = text(part.reason, "OpenCode step reason");
+        if (!STEP_FINISH_REASONS.has(reason)) {
+          throw new TypeError(`OpenCode step reason ${reason} is invalid`);
+        }
+        accumulator.stopReason = reason;
+        consumeUsage(part, accumulator);
+      }
+      return;
+    }
+    throw new TypeError(`OpenCode emitted unsupported event type ${type}`);
+  } catch (error) {
+    accumulator.protocolError = error instanceof Error ? error : new Error(String(error));
+  }
+}
+function resultParts(accumulator) {
+  return Object.freeze(accumulator.text.map(
+    (part, index, values) => Object.freeze({
+      kind: "assistant",
+      text: part.text,
+      final: index === values.length - 1
+    })
+  ));
+}
+function usage(accumulator) {
+  if (!accumulator.usageValid || accumulator.stepCount === 0) {
+    return Object.freeze({ kind: "unknown" });
+  }
+  return reportedUsage({
+    inputTokens: accumulator.inputTokens,
+    outputTokens: accumulator.outputTokens,
+    ...accumulator.cacheCreationInputTokens === 0 ? {} : {
+      cacheCreationInputTokens: accumulator.cacheCreationInputTokens
+    },
+    ...accumulator.cacheReadInputTokens === 0 ? {} : { cacheReadInputTokens: accumulator.cacheReadInputTokens }
+  });
+}
+function errorMessage(raw) {
+  const data = typeof raw.data === "object" && raw.data !== null ? object(raw.data, "OpenCode error data") : Object.freeze({});
+  const detail = typeof data.message === "string" ? data.message : typeof data.responseBody === "string" ? data.responseBody : typeof raw.name === "string" ? raw.name : "OpenCode failed";
+  return detail;
+}
+function nativeFailure(raw) {
+  const name = typeof raw.name === "string" ? raw.name : "";
+  const data = typeof raw.data === "object" && raw.data !== null ? object(raw.data, "OpenCode error data") : Object.freeze({});
+  const status = Number.isSafeInteger(data.statusCode) ? data.statusCode : void 0;
+  const detail = errorMessage(raw);
+  const responseBody = typeof data.responseBody === "string" ? data.responseBody : "";
+  if (name === "ProviderAuthError") return "auth";
+  if (name === "APIError" && status === 401) {
+    if (/CreditsError|no payment|insufficient balance/iu.test(responseBody)) {
+      return "billing";
+    }
+    if (/MonthlyLimitError/iu.test(responseBody)) return "quota";
+    if (/UserLimitError/iu.test(responseBody)) return "rate-limit";
+    if (/ModelError/iu.test(responseBody)) return "model-unavailable";
+  }
+  if (status === 401) return "auth";
+  if (name === "MessageAbortedError") return "aborted";
+  if (status === 402) return "billing";
+  if (status === 404) return "model-unavailable";
+  if (status === 408) return "timeout";
+  if (status === 429) {
+    if (/credit balance|insufficient funds|out of credits|exhausted credit/iu.test(detail)) {
+      return "billing";
+    }
+    const classified = classifyEngineFailure(new Error(detail));
+    return classified === "billing" || classified === "quota" ? classified : "rate-limit";
+  }
+  if (status !== void 0 && status >= 500) return "transient";
+  return classifyEngineFailure(new Error(detail));
+}
+function header(raw, name) {
+  const data = typeof raw.data === "object" && raw.data !== null ? object(raw.data, "OpenCode error data") : void 0;
+  const headers = data !== void 0 && typeof data.responseHeaders === "object" && data.responseHeaders !== null ? object(data.responseHeaders, "OpenCode response headers") : void 0;
+  if (headers === void 0) return void 0;
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === name && typeof value === "string") return value;
+  }
+  return void 0;
+}
+function resetAtHeader(value) {
+  if (value === void 0) return void 0;
+  const trimmed = value.trim();
+  if (/^\d+$/u.test(trimmed)) {
+    const numeric = Number(trimmed);
+    if (!Number.isSafeInteger(numeric)) return void 0;
+    const milliseconds = numeric < 1e10 ? numeric * 1e3 : numeric;
+    return Number.isSafeInteger(milliseconds) ? milliseconds : void 0;
+  }
+  const parsed = Date.parse(trimmed);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function nativeLimitHints(raw) {
+  if (raw === null) return Object.freeze({});
+  const retryAfterMs = retryAfterHeaderToMs(header(raw, "retry-after"));
+  const resetAt = resetAtHeader(
+    header(raw, "x-ratelimit-reset") ?? header(raw, "x-rate-limit-reset")
+  );
+  return Object.freeze({
+    ...retryAfterMs === void 0 ? {} : { retryAfterMs },
+    ...resetAt === void 0 ? {} : { resetAt }
+  });
+}
+function loopError(kind, message, hints = {}) {
+  return new EngineError({ kind, message, ...hints });
+}
+function typedFailureMessage(kind, detail) {
+  const label = kind === "auth" ? "authentication failed" : kind === "billing" ? "payment required" : kind === "model-unavailable" ? "model unavailable" : kind === "rate-limit" ? "rate limit reached" : kind === "quota" ? "quota reached" : kind === "transient" ? "service unavailable" : kind === "timeout" ? "timed out" : kind === "aborted" ? "aborted" : kind === "invalid-config" ? "invalid configuration" : "failed";
+  return `OpenCode ${label}: ${detail}`;
+}
+function transportFailure(kind, message, exitCode) {
+  return Object.freeze({ kind, message, exitCode });
+}
+var OpenCodeCliEngine = class {
+  name = "opencode-cli";
+  #executable;
+  #version;
+  #identity;
+  #environment;
+  #auth;
+  #authRedactions;
+  #options;
+  #versionObservation;
+  constructor(options) {
+    if (typeof options.executable !== "string" || !isAbsolute(options.executable)) {
+      throw new TypeError("OpenCode executable must be an absolute path");
+    }
+    this.#executable = text(options.executable, "OpenCode executable");
+    if (options.version !== SUPPORTED_VERSION) {
+      throw new TypeError(`OpenCode CLI version must be ${SUPPORTED_VERSION}`);
+    }
+    this.#version = options.version;
+    const checked = engineSelection({
+      adapter: "opencode-cli",
+      adapterVersion: this.#version,
+      provider: nullableText(options.identity.provider, "OpenCode provider"),
+      modelFamily: nullableText(
+        options.identity.modelFamily,
+        "OpenCode model family"
+      )
+    });
+    this.#identity = Object.freeze({
+      provider: checked.provider,
+      modelFamily: checked.modelFamily
+    });
+    this.#environment = selectedEnvironment(options.environment);
+    this.#auth = authValue(options.auth);
+    this.#authRedactions = authRedactions(this.#auth);
+    const managedConfigDirectories = Object.freeze([
+      ...options.managedConfigDirectories ?? []
+    ]);
+    this.#options = Object.freeze({
+      executable: this.#executable,
+      version: this.#version,
+      identity: this.#identity,
+      ...Object.keys(this.#environment).length === 0 ? {} : { environment: this.#environment },
+      ...Object.keys(this.#auth).length === 0 ? {} : { auth: this.#auth },
+      ...managedConfigDirectories.length === 0 ? {} : { managedConfigDirectories }
+    });
+  }
+  async admit(request, signal, expectedSelection) {
+    if (signal.aborted) throw loopError("aborted", "OpenCode admission was aborted before start");
+    let normalized;
+    let selected;
+    try {
+      assertNoManagedConfig(managedConfigSources(this.#options.managedConfigDirectories));
+      const selectedModel = model(request.model);
+      const selectedProvider = providerForModel(selectedModel, this.#identity);
+      const selectedFamily = familyForModel(selectedModel, this.#identity);
+      const capabilities = requestedCapabilities({ ...request, prompt: "" });
+      if (typeof request.cwd !== "string" || !isAbsolute(request.cwd)) {
+        throw new TypeError("OpenCode request cwd must be an absolute path");
+      }
+      const cwd = realpathSync(request.cwd);
+      assertNoProjectInstructions(cwd, capabilities);
+      normalized = { ...request, cwd, prompt: "" };
+      const timeout = request.timeoutMs ?? DEFAULT_OWNED_COMMAND_LIMITS.timeoutMs;
+      const grace = request.timeoutGraceMs ?? DEFAULT_OWNED_COMMAND_LIMITS.teardownGraceMs;
+      const output = request.maxOutputBytes ?? DEFAULT_OWNED_COMMAND_LIMITS.maxOutputBytes;
+      const memory = request.maxMemoryBytes ?? DEFAULT_OWNED_COMMAND_LIMITS.maxMemoryBytes;
+      if (!Number.isSafeInteger(timeout) || timeout < 1 || timeout > 2147483647 || !Number.isSafeInteger(grace) || grace < 0 || grace > 2147483647 - timeout || !Number.isSafeInteger(output) || output < 0 || !Number.isSafeInteger(memory) || memory < 1) {
+        throw new TypeError("OpenCode request command limits are invalid");
+      }
+      ownedCommandIdentity({
+        adapter: "opencode-cli",
+        runId: request.attempt?.runId,
+        leafId: request.attempt?.leafId,
+        attemptId: request.attempt?.attemptId
+      });
+      selected = engineSelection({
+        adapter: "opencode-cli",
+        adapterVersion: this.#version,
+        provider: selectedProvider,
+        modelFamily: selectedFamily,
+        model: selectedModel.value,
+        executable: this.#executable,
+        capabilities
+      });
+      if (expectedSelection !== void 0 && !isDeepStrictEqual(engineSelection(expectedSelection), selected)) {
+        throw new TypeError("OpenCode expected selection does not match its configured path and request");
+      }
+      let validationDirectory;
+      try {
+        validationDirectory = mkdtempSync(join(tmpdir(), "lines-opencode-admission-"));
+      } catch {
+        throw loopError(
+          "unknown",
+          "OpenCode admission temporary configuration could not be created"
+        );
+      }
+      let validationFailed = false;
+      let validationFailure;
+      try {
+        buildOpenCodeInvocation(normalized, this.#options, validationDirectory);
+      } catch (error) {
+        validationFailed = true;
+        validationFailure = error instanceof TypeError || error instanceof EngineError ? error : loopError(
+          "unknown",
+          "OpenCode admission temporary configuration could not be prepared"
+        );
+      }
+      try {
+        rmSync(validationDirectory, { recursive: true, force: true });
+      } catch {
+        if (!validationFailed) {
+          throw loopError(
+            "unknown",
+            "OpenCode admission temporary configuration could not be removed"
+          );
+        }
+      }
+      if (validationFailed) throw validationFailure;
+    } catch (error) {
+      if (error instanceof EngineError) throw error;
+      const diagnostic = error instanceof Error ? error.message : "invalid request";
+      throw loopError("invalid-config", scrubCapture(
+        scrubExactValues(diagnostic, { ...this.#authRedactions, ...this.#environment }),
+        { ...this.#environment },
+        700
+      ));
+    }
+    try {
+      resolveCommandExecutable(this.#executable);
+    } catch {
+      throw loopError("missing-cli", "OpenCode configured executable is missing or not runnable");
+    }
+    const version = await (this.#versionObservation ??= this.#observeVersion(normalized, signal).catch((error) => {
+      this.#versionObservation = void 0;
+      throw error;
+    }));
+    if (signal.aborted) throw loopError("aborted", "OpenCode admission was aborted");
+    return engineSelection({ ...selected, adapterVersion: version });
+  }
+  async #observeVersion(request, signal) {
+    let directory;
+    try {
+      directory = mkdtempSync(join(tmpdir(), "lines-opencode-version-"));
+    } catch {
+      throw loopError(
+        "unknown",
+        "OpenCode version temporary configuration could not be created"
+      );
+    }
+    let version;
+    let versionFailed = false;
+    let versionFailure;
+    try {
+      const invocation = buildOpenCodeInvocation(request, this.#options, directory);
+      assertNoManagedConfig(managedConfigSources(this.#options.managedConfigDirectories));
+      const command = await runOwnedCommand({
+        executable: this.#executable,
+        args: ["--version"],
+        cwd: request.cwd,
+        env: invocation.environment,
+        inheritParentEnv: false,
+        stdin: "",
+        ...ownedCommandIdentity({
+          adapter: "opencode-cli",
+          runId: request.attempt?.runId,
+          leafId: request.attempt?.leafId,
+          attemptId: request.attempt?.attemptId
+        }),
+        timeoutMs: Math.min(request.timeoutMs ?? VERSION_TIMEOUT_MS, VERSION_TIMEOUT_MS),
+        teardownGraceMs: Math.min(request.timeoutGraceMs ?? VERSION_TEARDOWN_MS, VERSION_TEARDOWN_MS),
+        maxOutputBytes: Math.min(request.maxOutputBytes ?? VERSION_OUTPUT_BYTES, VERSION_OUTPUT_BYTES),
+        maxMemoryBytes: request.maxMemoryBytes ?? DEFAULT_OWNED_COMMAND_LIMITS.maxMemoryBytes
+      }, signal);
+      if (command.aborted || signal.aborted) throw loopError("aborted", "OpenCode version check was aborted");
+      if (command.timedOut) throw loopError("timeout", "OpenCode version check timed out");
+      if (command.exitCode !== 0) throw loopError("invalid-config", "OpenCode version command did not succeed");
+      const observed = new TextDecoder().decode(command.stdout).trim();
+      if (!OPENCODE_VERSION.test(observed)) {
+        throw loopError("invalid-config", "OpenCode returned an unsupported version format");
+      }
+      if (observed !== SUPPORTED_VERSION) {
+        throw loopError("invalid-config", "OpenCode observed version does not match its supported version");
+      }
+      version = observed;
+    } catch (error) {
+      versionFailed = true;
+      versionFailure = error;
+    }
+    try {
+      rmSync(directory, { recursive: true, force: true });
+    } catch {
+      if (!versionFailed) {
+        throw loopError(
+          "unknown",
+          "OpenCode version temporary configuration could not be removed"
+        );
+      }
+    }
+    if (versionFailed) {
+      const error = versionFailure;
+      if (error instanceof EngineError) throw error;
+      if (signal.aborted) throw loopError("aborted", "OpenCode version check was aborted");
+      if (error instanceof OwnedCommandError) {
+        if (error.code === "INVALID_EXECUTABLE") {
+          throw loopError("missing-cli", "OpenCode configured executable could not start");
+        }
+        if (error.code === "SPAWN_FAILED") {
+          try {
+            resolveCommandExecutable(this.#executable);
+          } catch {
+            throw loopError("missing-cli", "OpenCode configured executable is missing or not runnable");
+          }
+          throw loopError("unknown", "OpenCode version process could not start");
+        }
+        if (error.code === "OUTPUT_LIMIT" || error.code === "INVALID_COMMAND") {
+          throw loopError("invalid-config", "OpenCode version command exceeded or rejected its limits");
+        }
+      }
+      if (error instanceof TypeError) {
+        throw loopError("invalid-config", "OpenCode version configuration is invalid");
+      }
+      throw loopError("unknown", "OpenCode version check could not complete");
+    }
+    return version;
+  }
+  async run(request, onEvent, signal) {
+    if (signal.aborted) {
+      throw loopError("aborted", "OpenCode attempt was aborted before start");
+    }
+    const { prompt: _prompt, ...staticRequest } = request;
+    const requested = await this.admit(staticRequest, signal);
+    const capabilities = requested.capabilities;
+    if (typeof request.cwd !== "string" || !isAbsolute(request.cwd)) {
+      throw new TypeError("OpenCode request cwd must be an absolute path");
+    }
+    const cwd = realpathSync(request.cwd);
+    assertNoProjectInstructions(cwd, capabilities);
+    const normalized = { ...request, cwd };
+    const directory = mkdtempSync(join(tmpdir(), "lines-opencode-"));
+    const accumulator = {
+      frames: [],
+      seenParts: /* @__PURE__ */ new Map(),
+      text: [],
+      sessionId: null,
+      protocolError: null,
+      terminalError: null,
+      stopReason: null,
+      stepCount: 0,
+      usageValid: true,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheCreationInputTokens: 0,
+      cacheReadInputTokens: 0
+    };
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const parserAbort = new AbortController();
+    const commandSignal = AbortSignal.any([signal, parserAbort.signal]);
+    const structured = request.jsonSchema !== void 0;
+    const scrub = (value) => scrubCapture(
+      scrubExactValues(value, {
+        ...this.#authRedactions,
+        ...this.#environment
+      }),
+      { ...this.#environment },
+      700
+    );
+    const owner = ownedCommandIdentity({
+      adapter: "opencode-cli",
+      runId: request.attempt?.runId,
+      leafId: request.attempt?.leafId,
+      attemptId: request.attempt?.attemptId
+    });
+    const startedAt = Date.now();
+    try {
+      const invocation = buildOpenCodeInvocation(
+        normalized,
+        this.#options,
+        directory
+      );
+      assertNoManagedConfig(managedConfigSources(this.#options.managedConfigDirectories));
+      const command = await runOwnedCommand({
+        executable: this.#executable,
+        args: invocation.args,
+        cwd,
+        env: invocation.environment,
+        inheritParentEnv: false,
+        stdin: invocation.stdin,
+        ...owner,
+        ...DEFAULT_OWNED_COMMAND_LIMITS,
+        timeoutMs: request.timeoutMs ?? DEFAULT_OWNED_COMMAND_LIMITS.timeoutMs,
+        teardownGraceMs: request.timeoutGraceMs ?? DEFAULT_OWNED_COMMAND_LIMITS.teardownGraceMs,
+        maxOutputBytes: request.maxOutputBytes ?? DEFAULT_OWNED_COMMAND_LIMITS.maxOutputBytes,
+        maxMemoryBytes: request.maxMemoryBytes ?? DEFAULT_OWNED_COMMAND_LIMITS.maxMemoryBytes
+      }, commandSignal, {
+        onStdout(chunk) {
+          buffer += decoder.decode(chunk, { stream: true });
+          let newline;
+          while ((newline = buffer.indexOf("\n")) >= 0) {
+            consumeLine(
+              buffer.slice(0, newline),
+              accumulator,
+              onEvent,
+              structured,
+              capabilities
+            );
+            buffer = buffer.slice(newline + 1);
+            if (accumulator.protocolError !== null) {
+              parserAbort.abort();
+              return;
+            }
+          }
+        }
+      });
+      buffer += decoder.decode();
+      if (buffer.trim().length > 0) {
+        consumeLine(buffer, accumulator, onEvent, structured, capabilities);
+      }
+      if (accumulator.protocolError !== null) {
+        throw loopError(
+          "invalid-config",
+          `OpenCode returned an invalid JSON protocol: ${scrub(accumulator.protocolError.message)}`
+        );
+      }
+      const aborted = command.aborted || signal.aborted;
+      if (aborted && accumulator.stopReason !== "stop") {
+        throw loopError("aborted", "OpenCode attempt was aborted");
+      }
+      const stderr = scrub(new TextDecoder().decode(command.stderr));
+      const nativeKind = accumulator.terminalError === null ? void 0 : nativeFailure(accumulator.terminalError);
+      const nativeMessage = accumulator.terminalError === null ? "" : scrub(errorMessage(accumulator.terminalError));
+      const failed = aborted || command.timedOut || command.exitCode !== 0 || accumulator.terminalError !== null;
+      const parts = resultParts(accumulator);
+      if (accumulator.stopReason === "error" || accumulator.stopReason === "content-filter") {
+        throw loopError(
+          "unknown",
+          `OpenCode ended with ${accumulator.stopReason}`
+        );
+      }
+      if (accumulator.stopReason === "length") {
+        const measuredUsage2 = usage(accumulator);
+        const effective2 = requested;
+        onEvent({
+          type: "usage",
+          usage: measuredUsage2,
+          model: effective2.model ?? "unknown"
+        });
+        throw new EngineIncompleteResultError(
+          "OpenCode output ended at the token limit",
+          validateIncompleteResultEvidence({
+            parts,
+            usage: measuredUsage2,
+            requested,
+            effective: effective2,
+            stopReason: "length",
+            ...failed ? {
+              transportFailure: transportFailure(
+                command.timedOut ? "timeout" : nativeKind ?? classifyEngineFailure(new Error(stderr)),
+                nativeMessage || stderr || "OpenCode transport failed",
+                command.exitCode
+              )
+            } : {},
+            raw: cloneFrozenJson(accumulator.frames)
+          })
+        );
+      }
+      const markedFinal = accumulator.stopReason === "stop";
+      if (!markedFinal) {
+        if (!failed) {
+          throw loopError(
+            "invalid-config",
+            "OpenCode completed without a final step"
+          );
+        }
+        const kind = command.timedOut ? "timeout" : nativeKind ?? classifyEngineFailure(new Error(stderr));
+        throw loopError(
+          kind,
+          typedFailureMessage(
+            kind,
+            nativeMessage || stderr || "incomplete result"
+          ),
+          nativeLimitHints(accumulator.terminalError)
+        );
+      }
+      if (parts.length === 0) {
+        if (failed) {
+          const kind = command.timedOut ? "timeout" : nativeKind ?? classifyEngineFailure(new Error(stderr));
+          throw loopError(
+            kind,
+            typedFailureMessage(
+              kind,
+              nativeMessage || stderr || "OpenCode produced no result text"
+            ),
+            nativeLimitHints(accumulator.terminalError)
+          );
+        }
+        const measuredUsage2 = usage(accumulator);
+        const effective2 = requested;
+        onEvent({
+          type: "usage",
+          usage: measuredUsage2,
+          model: effective2.model ?? "unknown"
+        });
+        throw new EngineIncompleteResultError(
+          "OpenCode completed without a final text part",
+          validateIncompleteResultEvidence({
+            parts,
+            usage: measuredUsage2,
+            requested,
+            effective: effective2,
+            stopReason: "stop",
+            raw: cloneFrozenJson(accumulator.frames)
+          })
+        );
+      }
+      const measuredUsage = usage(accumulator);
+      const effective = requested;
+      onEvent({
+        type: "usage",
+        usage: measuredUsage,
+        model: effective.model ?? "unknown"
+      });
+      const late = request.timeoutMs !== void 0 && Date.now() - startedAt > request.timeoutMs;
+      const failureKind = aborted ? "aborted" : command.timedOut ? "timeout" : nativeKind ?? classifyEngineFailure(new Error(stderr));
+      const transportMessage = nativeMessage || stderr || "OpenCode transport failed after its final result";
+      return validateAgentResult({
+        parts,
+        usage: measuredUsage,
+        requested,
+        effective,
+        ...accumulator.stopReason === null ? {} : { stopReason: accumulator.stopReason },
+        ...failed ? {
+          transportFailure: transportFailure(
+            failureKind,
+            transportMessage,
+            command.exitCode
+          )
+        } : late ? {
+          transportFailure: transportFailure(
+            "timeout",
+            "OpenCode result arrived after the soft timeout",
+            command.exitCode
+          )
+        } : {},
+        raw: cloneFrozenJson(accumulator.frames)
+      });
+    } catch (error) {
+      if (error instanceof OwnedCommandError && error.code === "INVALID_EXECUTABLE") {
+        throw loopError("missing-cli", "OpenCode configured executable could not start");
+      }
+      if (error instanceof OwnedCommandError && error.code === "SPAWN_FAILED") {
+        try {
+          resolveCommandExecutable(this.#executable);
+        } catch {
+          throw loopError("missing-cli", "OpenCode configured executable is missing or not runnable");
+        }
+        throw loopError("unknown", "OpenCode model process could not start");
+      }
+      throw error;
+    } finally {
+      rmSync(directory, { recursive: true, force: true });
+    }
+  }
+};
+
+export { OpenCodeCliEngine, buildOpenCodeInvocation, opencode };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map