@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-3LOY6YZI.js

@@ -0,0 +1,852 @@
+import {
+  reportTransportDecision,
+  selectProviderExecutor
+} from "./chunk-JYXS47FQ.js";
+import {
+  createRetryOptions,
+  withRetry
+} from "./chunk-4QKP6I4C.js";
+import {
+  clampAttemptTimeoutToDeadline
+} from "./chunk-GWHGTG37.js";
+import {
+  metadata
+} from "./chunk-WEIUS5NT.js";
+import {
+  createReportedCostAccumulator
+} from "./chunk-WEI3ZDZH.js";
+import {
+  resolveProviderStreamingEnabled
+} from "./chunk-67YRJPJO.js";
+import {
+  TMUX_COMPLETION_SIGNAL_GRACE_MS,
+  createLineDelimitedTmuxCompletionSignal,
+  executeProviderCommand
+} from "./chunk-633XZ7UF.js";
+import {
+  resolveConfiguredProviderExecutionTransport
+} from "./chunk-C3DH3NCY.js";
+import {
+  safeJsonParse
+} from "./chunk-XJ2E7YEJ.js";
+import {
+  writeFileAtomic
+} from "./chunk-XCOIBNET.js";
+import {
+  PROVIDER_CATALOG_SHA256,
+  ProviderRegistry,
+  detectSourceBaseDrift,
+  getRefreshOverlayOperatorNotice,
+  opencodeInventoryContext,
+  readEffectiveRefreshOverlay,
+  resolveSharedRefreshPaths
+} from "./chunk-QJ6OEH4K.js";
+import {
+  findProjectRoot,
+  resolveProvidersConfigPath
+} from "./chunk-35J4NE6S.js";
+import {
+  ProviderExecutionError
+} from "./chunk-RRC5BL7B.js";
+import {
+  processIsAlive
+} from "./chunk-MT2WAIR3.js";
+import {
+  getUserCacheDir
+} from "./chunk-56WPYDJH.js";
+import {
+  debugLog,
+  getExecutionContext
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/providers/opencode/output-adapter.ts
+function asRecord(value) {
+  return value && typeof value === "object" ? value : void 0;
+}
+function accrueOptional(total, add) {
+  return add === void 0 ? total : (total ?? 0) + add;
+}
+function readNumberField(record, keys) {
+  for (const key of keys) {
+    const value = record?.[key];
+    if (typeof value === "number") return value;
+    if (typeof value === "string") {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed)) return parsed;
+    }
+  }
+  return void 0;
+}
+function parseJsonObjectsFromStream(stream) {
+  const objects = [];
+  let start = -1;
+  let depth = 0;
+  let inString = false;
+  let escaping = false;
+  for (let index = 0; index < stream.length; index++) {
+    const char = stream[index];
+    if (start === -1) {
+      if (char === "{") {
+        start = index;
+        depth = 1;
+        inString = false;
+        escaping = false;
+      }
+      continue;
+    }
+    if (inString) {
+      if (escaping) {
+        escaping = false;
+      } else if (char === "\\") {
+        escaping = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === "{") {
+      depth++;
+      continue;
+    }
+    if (char === "}") {
+      depth--;
+      if (depth === 0) {
+        objects.push({ raw: stream.slice(start, index + 1), start, end: index + 1 });
+        start = -1;
+      }
+    }
+  }
+  return objects;
+}
+var OPENCODE_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "error",
+  "message",
+  "result",
+  "step_finish",
+  "step-finish",
+  "step_start",
+  "step-start",
+  "text",
+  "tool",
+  "tool_use",
+  "usage"
+]);
+function isOpencodeEventEnvelope(evt) {
+  const type = typeof evt.type === "string" ? evt.type : void 0;
+  const event = typeof evt.event === "string" ? evt.event : void 0;
+  const partType = readStringField(asRecord(evt.part), ["type"]);
+  return type !== void 0 && OPENCODE_EVENT_TYPES.has(type) || event !== void 0 && OPENCODE_EVENT_TYPES.has(event) || partType !== void 0 && OPENCODE_EVENT_TYPES.has(partType) || "sessionID" in evt || "messageID" in evt || "providerID" in evt || "modelID" in evt;
+}
+function extractUnstructuredOpencodeStdout(stdout) {
+  let cursor = 0;
+  let residual = "";
+  for (const candidate of parseJsonObjectsFromStream(stdout)) {
+    try {
+      const evt = safeJsonParse(candidate.raw, {
+        context: "OpenCode raw stdout event",
+        debug: false
+      });
+      if (!isOpencodeEventEnvelope(evt)) continue;
+      residual += stdout.slice(cursor, candidate.start);
+      cursor = candidate.end;
+    } catch {
+    }
+  }
+  return residual + stdout.slice(cursor);
+}
+function extractTextFromContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  let aggregate = "";
+  for (const item of content) {
+    if (typeof item === "string") {
+      aggregate += item;
+      continue;
+    }
+    const record = asRecord(item);
+    if (!record) continue;
+    if (typeof record.text === "string") {
+      aggregate += record.text;
+      continue;
+    }
+    if (typeof record.content === "string") {
+      aggregate += record.content;
+      continue;
+    }
+    if (typeof record.value === "string") {
+      aggregate += record.value;
+    }
+  }
+  return aggregate;
+}
+function extractTextFromEvent(evt) {
+  if (typeof evt.text === "string") return evt.text;
+  if (typeof evt.delta === "string") return evt.delta;
+  if (typeof evt.message === "string") return evt.message;
+  if (typeof evt.output === "string") return evt.output;
+  if (typeof evt.content === "string") return evt.content;
+  const contentText = extractTextFromContent(evt.content);
+  if (contentText) return contentText;
+  const part = asRecord(evt.part);
+  if (typeof part?.text === "string") return part.text;
+  if (typeof part?.content === "string") return part.content;
+  const partContentText = extractTextFromContent(part?.content);
+  if (partContentText) return partContentText;
+  const data = asRecord(evt.data);
+  if (!data) return "";
+  if (typeof data.text === "string") return data.text;
+  if (typeof data.message === "string") return data.message;
+  if (typeof data.content === "string") return data.content;
+  if (typeof data.output === "string") return data.output;
+  return extractTextFromContent(data.content);
+}
+function readStringField(record, keys) {
+  for (const key of keys) {
+    const value = record?.[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function extractDirectErrorMessage(errorRecord) {
+  if (!errorRecord) return void 0;
+  return readStringField(errorRecord, ["message", "error", "detail", "description"]) ?? readStringField(asRecord(errorRecord.data), ["message", "error", "detail", "description"]);
+}
+function extractErrorMessage(errorRecord) {
+  if (!errorRecord) return void 0;
+  const direct = extractDirectErrorMessage(errorRecord);
+  if (direct) return direct;
+  const ownKeys = Object.keys(errorRecord);
+  const informativeKeys = ownKeys.filter((k) => k !== "type");
+  if (informativeKeys.length === 0) return void 0;
+  try {
+    const encoded = JSON.stringify(errorRecord);
+    return encoded === "{}" ? void 0 : encoded;
+  } catch {
+    return void 0;
+  }
+}
+function isStepFinishEvent(evt) {
+  const evtType = typeof evt.type === "string" ? evt.type : void 0;
+  const evtEvent = typeof evt.event === "string" ? evt.event : void 0;
+  const part = asRecord(evt.part);
+  const partType = typeof part?.type === "string" ? part.type : void 0;
+  return evtType === "step_finish" || evtType === "step-finish" || evtEvent === "step_finish" || evtEvent === "step-finish" || partType === "step-finish" || partType === "step_finish";
+}
+function extractStepFinishReason(evt) {
+  if (!isStepFinishEvent(evt)) return void 0;
+  const part = asRecord(evt.part);
+  return readStringField(evt, ["reason", "finish_reason", "finishReason"]) ?? readStringField(part, ["reason", "finish_reason", "finishReason"]) ?? readStringField(asRecord(evt.data), ["reason", "finish_reason", "finishReason"]);
+}
+var OPENCODE_CONTINUATION_FINISH_REASONS = /* @__PURE__ */ new Set([
+  "tool-calls",
+  "tool_calls",
+  "tool-call",
+  "tool_call",
+  "tool_use",
+  "tool-use"
+]);
+function isOpencodeTerminalEvent(evt) {
+  const record = asRecord(evt);
+  if (!record) return false;
+  if (!isStepFinishEvent(record)) return false;
+  const reason = extractStepFinishReason(record);
+  if (reason === void 0) return true;
+  return !OPENCODE_CONTINUATION_FINISH_REASONS.has(reason.trim().toLowerCase());
+}
+function opencodeLineConcludes(line) {
+  const trimmed = line.trim();
+  if (trimmed[0] !== "{") return false;
+  const evt = safeJsonParse(trimmed, {
+    context: "OpenCode tmux completion-signal event",
+    debug: false
+  });
+  return isOpencodeTerminalEvent(evt);
+}
+function createOpencodeTmuxCompletionSignal() {
+  return createLineDelimitedTmuxCompletionSignal(opencodeLineConcludes);
+}
+function classifyRetryableError(message, errorType) {
+  const text = `${errorType ?? ""}
+${message}`.toLowerCase();
+  if (/auth|unauthorized|forbidden|invalid[_ -]?api[_ -]?key|not[_ -]?found|no-route/.test(text)) {
+    return false;
+  }
+  return /timeout|temporar|unavailable|overload|rate[_ -]?limit|serviceunavailable|gateway|provider_unavailable/.test(
+    text
+  );
+}
+function extractErrorEvent(evt) {
+  const stepFinishReason = extractStepFinishReason(evt);
+  if (stepFinishReason === "length" || stepFinishReason === "content-filter") {
+    return {
+      message: stepFinishReason === "length" ? "OpenCode stopped because the model context length was exhausted." : "OpenCode stopped because the response was blocked by a content filter.",
+      type: "step_finish",
+      errorType: stepFinishReason,
+      retryable: false,
+      raw: evt
+    };
+  }
+  const evtType = typeof evt.type === "string" ? evt.type : void 0;
+  const dataRecord = asRecord(evt.data);
+  const explicitError = evt.error ?? dataRecord?.error;
+  const explicitErrorRecord = asRecord(explicitError) ?? (typeof explicitError === "string" && explicitError.trim().length > 0 ? { message: explicitError.trim() } : void 0);
+  const errorRecord = evtType === "error" ? explicitErrorRecord ?? dataRecord ?? evt : explicitErrorRecord;
+  const eventMessage = evtType === "error" ? extractTextFromEvent(evt) : void 0;
+  const message = extractDirectErrorMessage(errorRecord) ?? (eventMessage || extractErrorMessage(errorRecord));
+  if (evtType !== "error" && !message) return void 0;
+  const errorType = readStringField(errorRecord, ["error_type", "errorType", "type", "code", "status"]) ?? readStringField(asRecord(errorRecord?.data), [
+    "error_type",
+    "errorType",
+    "type",
+    "code",
+    "status"
+  ]) ?? readStringField(asRecord(errorRecord?.metadata), [
+    "error_type",
+    "errorType",
+    "type",
+    "code",
+    "status"
+  ]) ?? readStringField(asRecord(asRecord(errorRecord?.data)?.metadata), [
+    "error_type",
+    "errorType",
+    "type",
+    "code",
+    "status"
+  ]);
+  if (evtType === "error" && !message && (!errorType || errorType === evtType)) return void 0;
+  const normalizedMessage = message ?? "OpenCode reported an error event";
+  return {
+    message: normalizedMessage,
+    ...evtType ? { type: evtType } : {},
+    ...errorType ? { errorType } : {},
+    retryable: classifyRetryableError(normalizedMessage, errorType),
+    raw: evt
+  };
+}
+function parseOpencodeProviderOutput(stdout, stderr) {
+  let text = "";
+  let structuredEventCount = 0;
+  let tokenUsage;
+  const reportedCost = createReportedCostAccumulator();
+  let resolvedModel;
+  let servedRoute;
+  const errorEvents = [];
+  const detectedSubAgentTypes = /* @__PURE__ */ new Set();
+  let subAgentInvocationCount = 0;
+  let firstAgentUsed;
+  const seenJsonEvents = /* @__PURE__ */ new Set();
+  for (const stream of [stdout, stderr]) {
+    for (const candidate of parseJsonObjectsFromStream(stream)) {
+      const trimmed = candidate.raw.trim();
+      if (!trimmed.startsWith("{")) continue;
+      try {
+        const evt = safeJsonParse(trimmed, {
+          context: "OpenCode JSONL event",
+          debug: false
+        });
+        const canonicalEvent = JSON.stringify(evt);
+        if (seenJsonEvents.has(canonicalEvent)) continue;
+        seenJsonEvents.add(canonicalEvent);
+        structuredEventCount++;
+        const evtType = evt.type;
+        const evtEvent = evt.event;
+        if (evtType !== "error") {
+          const eventText = extractTextFromEvent(evt);
+          if (eventText) {
+            text += eventText;
+          }
+        }
+        const trustedTelemetryEvent = evtType === "message" || evtType === "step_finish" || evtType === "step-finish" || evtType === "result" || evtType === "usage" || evtEvent === "step_finish" || evtEvent === "step-finish";
+        const errorEvent = extractErrorEvent(evt);
+        if (errorEvent) {
+          errorEvents.push(errorEvent);
+        }
+        const part = asRecord(evt.part);
+        if (evtType === "tool_use" && part?.tool === "task") {
+          const state = asRecord(part?.state);
+          const input = asRecord(state?.input);
+          const agentType = (typeof input?.subagent_type === "string" ? input.subagent_type : void 0) ?? (typeof input?.agent_type === "string" ? input.agent_type : void 0) ?? (typeof input?.agent === "string" ? input.agent : void 0);
+          if (agentType) {
+            detectedSubAgentTypes.add(agentType);
+            subAgentInvocationCount++;
+            firstAgentUsed ??= agentType;
+          }
+        }
+        if (trustedTelemetryEvent && (!resolvedModel || !servedRoute)) {
+          const data = asRecord(evt.data);
+          const usageRecord = asRecord(evt.usage);
+          const providerId = (typeof evt.providerID === "string" ? evt.providerID : void 0) ?? (typeof data?.providerID === "string" ? data.providerID : void 0) ?? (typeof usageRecord?.providerID === "string" ? usageRecord.providerID : void 0);
+          if (providerId?.trim()) servedRoute ??= providerId.trim();
+          const candidateModel = (typeof evt.model === "string" ? evt.model : void 0) ?? (typeof data?.model === "string" ? data.model : void 0) ?? (typeof usageRecord?.model === "string" ? usageRecord.model : void 0) ?? (typeof evt.modelID === "string" ? evt.modelID : void 0) ?? (typeof data?.modelID === "string" ? data.modelID : void 0) ?? (typeof usageRecord?.modelID === "string" ? usageRecord.modelID : void 0);
+          if (candidateModel && !resolvedModel) {
+            resolvedModel = providerId && !candidateModel.includes("/") ? `${providerId}/${candidateModel}` : candidateModel;
+          }
+        }
+        const usage = trustedTelemetryEvent ? asRecord(evt.usage) ?? asRecord(evt.tokens) ?? asRecord(part?.usage) ?? asRecord(part?.tokens) ?? asRecord(asRecord(evt.data)?.usage) ?? asRecord(asRecord(evt.data)?.tokens) : void 0;
+        let callUsage;
+        if (usage) {
+          const inputTokens = readNumberField(usage, [
+            "input_tokens",
+            "inputTokens",
+            "prompt_tokens",
+            "input"
+          ]);
+          const outputTokens = readNumberField(usage, [
+            "output_tokens",
+            "outputTokens",
+            "completion_tokens",
+            "output"
+          ]);
+          if (inputTokens !== void 0 || outputTokens !== void 0) {
+            const cache = asRecord(usage.cache);
+            const reasoningTokens = readNumberField(usage, ["reasoning"]);
+            const cachedInputTokens = readNumberField(cache, ["read"]);
+            const cacheCreationInputTokens = readNumberField(cache, ["write"]);
+            callUsage = {
+              inputTokens: inputTokens ?? 0,
+              outputTokens: outputTokens ?? 0,
+              ...cachedInputTokens !== void 0 ? { cachedInputTokens } : {},
+              ...cacheCreationInputTokens !== void 0 ? { cacheCreationInputTokens } : {}
+            };
+            const cachedTotal = accrueOptional(tokenUsage?.cachedInputTokens, cachedInputTokens);
+            const cacheCreationTotal = accrueOptional(
+              tokenUsage?.cacheCreationInputTokens,
+              cacheCreationInputTokens
+            );
+            const reasoningTotal = accrueOptional(tokenUsage?.reasoningTokens, reasoningTokens);
+            tokenUsage = {
+              inputTokens: (tokenUsage?.inputTokens ?? 0) + (inputTokens ?? 0),
+              outputTokens: (tokenUsage?.outputTokens ?? 0) + (outputTokens ?? 0),
+              ...cachedTotal !== void 0 ? { cachedInputTokens: cachedTotal } : {},
+              ...cacheCreationTotal !== void 0 ? { cacheCreationInputTokens: cacheCreationTotal } : {},
+              ...reasoningTotal !== void 0 ? { reasoningTokens: reasoningTotal } : {}
+            };
+          }
+        }
+        const cost = trustedTelemetryEvent ? readNumberField(evt, ["cost", "total_cost", "cost_usd", "totalCostUsd"]) ?? readNumberField(part, ["cost", "total_cost", "cost_usd", "totalCostUsd"]) ?? readNumberField(usage, ["cost", "total_cost", "cost_usd", "totalCostUsd"]) : void 0;
+        reportedCost.add(cost, callUsage);
+      } catch {
+      }
+    }
+  }
+  return {
+    text,
+    tokenUsage,
+    // OpenCode prices runs from its own catalog and emits 0 for unpriced models;
+    // each call is checked on its own, so one unknown call makes the run unknown.
+    totalCostUsd: reportedCost.total(),
+    resolvedModel,
+    ...servedRoute ? { servedRoute } : {},
+    agentUsed: firstAgentUsed,
+    subAgentInvocations: subAgentInvocationCount || void 0,
+    subAgentTypes: detectedSubAgentTypes.size > 0 ? [...detectedSubAgentTypes] : void 0,
+    structuredEventCount,
+    ...errorEvents.length > 0 ? { errorEvents } : {}
+  };
+}
+
+// src/core/providers/opencode/bootstrap.ts
+import { readFileSync as readFileSync2, statSync } from "fs";
+import * as fs2 from "fs/promises";
+import { homedir } from "os";
+import * as path2 from "path";
+
+// src/core/providers/refresh/freshness.ts
+import * as fs from "fs";
+import * as path from "path";
+function resolveProjectRoot(configPath) {
+  const configDir = path.dirname(configPath);
+  return path.basename(configDir) === "config" && path.basename(path.dirname(configDir)) === ".build-project" ? path.dirname(path.dirname(configDir)) : path.dirname(configPath);
+}
+function latestCommittedRefreshEvidence(providerId, auditPath) {
+  try {
+    const lines = fs.readFileSync(auditPath, "utf8").trim().split("\n").filter(Boolean);
+    for (let index = lines.length - 1; index >= 0; index--) {
+      const entry = JSON.parse(lines[index]);
+      if (entry.kind === "overlay") continue;
+      const provider = entry.providers?.find(
+        (candidate) => candidate.providerId === providerId && candidate.ok && candidate.source
+      );
+      if (!provider?.source) continue;
+      const timestamp = Date.parse(entry.timestamp ?? "");
+      if (Number.isFinite(timestamp)) return { timestamp, source: provider.source };
+    }
+  } catch {
+  }
+  return void 0;
+}
+function acceptedOverlayRefreshEvidence(providerId, projectRoot) {
+  try {
+    const { disposition } = readEffectiveRefreshOverlay(projectRoot, {
+      expectedBaseCatalogDigest: PROVIDER_CATALOG_SHA256,
+      sourceBaseDrift: detectSourceBaseDrift()
+    });
+    if (disposition.status !== "ready") return void 0;
+    const slices = disposition.overlay.providers[providerId]?.slices;
+    const candidates = [slices?.models, slices?.pricing].flatMap((slice) => {
+      if (!slice) return [];
+      const timestamp = Date.parse(slice.fetchedAt);
+      return Number.isFinite(timestamp) ? [{ timestamp, source: slice.source }] : [];
+    });
+    return candidates.sort((left, right) => right.timestamp - left.timestamp)[0];
+  } catch {
+    return void 0;
+  }
+}
+function getProviderRefreshEvidence(providerId, options = {}) {
+  const configPath = path.resolve(
+    options.configPath ?? resolveProvidersConfigPath({ cwd: options.projectRoot ?? process.cwd() })
+  );
+  const projectRoot = options.projectRoot ?? resolveProjectRoot(configPath);
+  const overlayEvidence = acceptedOverlayRefreshEvidence(providerId, projectRoot);
+  if (overlayEvidence) return overlayEvidence;
+  const auditEvidence = latestCommittedRefreshEvidence(providerId, resolveSharedRefreshPaths().auditLogFile) ?? latestCommittedRefreshEvidence(
+    providerId,
+    path.join(projectRoot, ".build-project", "logs", "provider-refresh.jsonl")
+  );
+  if (auditEvidence) return auditEvidence;
+  try {
+    const registry = ProviderRegistry.load(options.configPath, projectRoot);
+    const config = ProviderRegistry.getProviderConfig(providerId, registry);
+    const meta = config.pricing?._meta;
+    const lastUpdate = meta?.last_pricing_update;
+    if (typeof lastUpdate === "string") {
+      const parsed = Date.parse(lastUpdate);
+      if (Number.isFinite(parsed)) return { timestamp: parsed, source: "pricing-only" };
+    }
+  } catch {
+  }
+  return void 0;
+}
+function getProviderSliceAgeMs(providerId, options = {}) {
+  const evidence = getProviderRefreshEvidence(providerId, options);
+  return evidence ? Math.max(0, (options.now ?? Date.now()) - evidence.timestamp) : void 0;
+}
+function formatCacheAge(ageMs) {
+  const hours = ageMs / 36e5;
+  if (hours < 1) return "<1h";
+  if (hours < 48) return `${Math.round(hours)}h`;
+  return `${Math.round(hours / 24)}d`;
+}
+function isFetchedAtFresh(fetchedAt, ttlMs, now = Date.now()) {
+  return typeof fetchedAt === "number" && Number.isFinite(fetchedAt) && Number.isFinite(ttlMs) && ttlMs >= 0 && now - fetchedAt < ttlMs;
+}
+function getFetchedAtAgeMs(fetchedAt, now = Date.now()) {
+  if (typeof fetchedAt !== "number" || !Number.isFinite(fetchedAt)) return void 0;
+  return Math.max(0, now - fetchedAt);
+}
+function getProjectRefreshOverlayNotice(projectRoot) {
+  const root = projectRoot ?? findProjectRoot(process.cwd()) ?? process.cwd();
+  const refresh = readEffectiveRefreshOverlay(root, {
+    expectedBaseCatalogDigest: PROVIDER_CATALOG_SHA256,
+    sourceBaseDrift: detectSourceBaseDrift()
+  });
+  return getRefreshOverlayOperatorNotice(
+    refresh.path,
+    PROVIDER_CATALOG_SHA256,
+    detectSourceBaseDrift()
+  );
+}
+
+// src/core/providers/opencode/bootstrap.ts
+var OPENCODE_MODELS_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var OPENCODE_MODEL_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._/:-]*$/;
+function isOpencodeBunInstallFailure(error) {
+  const haystack = `${error.message}
+${error.stderr ?? ""}
+${error.stdout ?? ""}`;
+  return /BunInstallFailedError/i.test(haystack) || /\bbun\b.*\binstall\b/i.test(haystack);
+}
+function makeRetryableBootstrapError(error, providerName, operation) {
+  return new ProviderExecutionError(`${providerName} ${operation} failed (bootstrap race)`, {
+    retryable: true,
+    exitCode: error.exitCode,
+    reason: error.reason ?? "bootstrap_install",
+    stderr: error.stderr,
+    stdout: error.stdout,
+    // The public fields above may already be truncated, and a stream size must
+    // never be re-derived from a truncated string. Forward the structured sizes.
+    streamBytes: { stdout: error.stdoutBytes, stderr: error.stderrBytes }
+  });
+}
+var LOCK_HEARTBEAT_INTERVAL_MS = 3e4;
+function resolveOpencodeBootstrapAttemptTimeoutMs(timeoutMs, deadlineMs) {
+  return clampAttemptTimeoutToDeadline(
+    timeoutMs,
+    deadlineMs,
+    () => new ProviderExecutionError("OpenCode bootstrap deadline exceeded before attempt start.", {
+      retryable: false,
+      reason: "deadline_exhausted"
+    })
+  );
+}
+function startLockHeartbeat(lockFile) {
+  return setInterval(() => {
+    const now = /* @__PURE__ */ new Date();
+    void fs2.utimes(lockFile, now, now).catch(() => {
+    });
+  }, LOCK_HEARTBEAT_INTERVAL_MS);
+}
+function parseWarmupLockPayload(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function isProcessAlive(pid) {
+  return Number.isInteger(pid) && (pid ?? 0) > 0 && processIsAlive(pid);
+}
+async function acquireLockFile(lockFile, options) {
+  const start = Date.now();
+  await fs2.mkdir(path2.dirname(lockFile), { recursive: true });
+  while (Date.now() - start < options.timeoutMs) {
+    try {
+      await fs2.writeFile(
+        lockFile,
+        JSON.stringify({
+          pid: process.pid,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          host: process.env.HOSTNAME ?? process.env.COMPUTERNAME ?? "unknown"
+        }),
+        { flag: "wx" }
+      );
+      return;
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST") throw error;
+      try {
+        const stat2 = await fs2.stat(lockFile);
+        if (Date.now() - stat2.mtimeMs > options.staleMs) {
+          const payload = parseWarmupLockPayload(
+            await fs2.readFile(lockFile, "utf8").catch(() => "")
+          );
+          const sameHost = payload?.host === void 0 || payload.host === (process.env.HOSTNAME ?? process.env.COMPUTERNAME ?? "unknown");
+          if (!sameHost || !isProcessAlive(payload?.pid)) {
+            await fs2.unlink(lockFile).catch(() => {
+            });
+            continue;
+          }
+        }
+      } catch {
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, 100));
+    }
+  }
+  throw new Error(
+    `Failed to acquire OpenCode warmup lock within ${options.timeoutMs}ms: ${lockFile}`
+  );
+}
+async function releaseLockFile(lockFile) {
+  await fs2.unlink(lockFile).catch(() => {
+  });
+}
+var MODELS_CACHE_FILENAME = "models.json";
+var cachedModelsSnapshot = null;
+function resolveOpencodeModelsCacheDir(scope) {
+  if (typeof scope === "string") return scope;
+  if (scope?.cacheDir) return scope.cacheDir;
+  const context = getExecutionContext();
+  const env = scope?.env ?? { ...process.env, ...context.envOverrides };
+  return path2.join(
+    getUserCacheDir(env, env.HOME?.trim() || homedir()),
+    "opencode",
+    opencodeInventoryContext(scope?.projectRoot ?? context.repoRoot, env)
+  );
+}
+function sanitizeOpencodeModelIds(modelIds) {
+  const seen = /* @__PURE__ */ new Set();
+  const sanitized = [];
+  for (const raw of modelIds) {
+    if (typeof raw !== "string") continue;
+    const id = raw.trim();
+    if (id.length >= 2 && id.length <= 128 && OPENCODE_MODEL_ID_PATTERN.test(id) && /[/-]/.test(id) && !seen.has(id)) {
+      seen.add(id);
+      sanitized.push(id);
+    }
+  }
+  return sanitized;
+}
+function rememberModelsSnapshot(cachePath, mtimeMs, modelIds, fetchedAt) {
+  cachedModelsSnapshot = { cachePath, mtimeMs, modelIds, fetchedAt };
+}
+function readModelsCacheFromDisk(cachePath) {
+  try {
+    const stat2 = statSync(cachePath);
+    if (cachedModelsSnapshot && cachedModelsSnapshot.cachePath === cachePath && cachedModelsSnapshot.mtimeMs === stat2.mtimeMs) {
+      return {
+        modelIds: cachedModelsSnapshot.modelIds,
+        fetchedAt: cachedModelsSnapshot.fetchedAt,
+        mtimeMs: stat2.mtimeMs
+      };
+    }
+    const raw = readFileSync2(cachePath, "utf-8");
+    const entry = JSON.parse(raw);
+    if (!Array.isArray(entry?.modelIds)) {
+      return null;
+    }
+    const modelIds = sanitizeOpencodeModelIds(entry.modelIds);
+    const fetchedAt = typeof entry.fetchedAt === "number" && Number.isFinite(entry.fetchedAt) ? entry.fetchedAt : void 0;
+    rememberModelsSnapshot(cachePath, stat2.mtimeMs, modelIds, fetchedAt);
+    return { modelIds, fetchedAt, mtimeMs: stat2.mtimeMs };
+  } catch {
+    return null;
+  }
+}
+function getCachedOpencodeModelIds(scope) {
+  const cachePath = path2.join(resolveOpencodeModelsCacheDir(scope), MODELS_CACHE_FILENAME);
+  const cached = readModelsCacheFromDisk(cachePath);
+  if (cached) return cached.modelIds;
+  if (cachedModelsSnapshot?.cachePath === cachePath) {
+    cachedModelsSnapshot = null;
+  }
+  return [];
+}
+function getOpencodeModelsCacheInfo(scope, now = Date.now()) {
+  const cachePath = path2.join(resolveOpencodeModelsCacheDir(scope), MODELS_CACHE_FILENAME);
+  const cached = readModelsCacheFromDisk(cachePath);
+  const fetchedAt = cached?.fetchedAt;
+  const ageMs = getFetchedAtAgeMs(fetchedAt, now);
+  return {
+    cachePath,
+    modelIds: cached?.modelIds ?? [],
+    fetchedAt,
+    ageMs,
+    stale: !isFetchedAtFresh(fetchedAt, OPENCODE_MODELS_CACHE_TTL_MS, now)
+  };
+}
+async function persistOpencodeModelsCache(modelIds, options) {
+  const sanitized = sanitizeOpencodeModelIds(modelIds);
+  const cacheDir = resolveOpencodeModelsCacheDir(options);
+  await fs2.mkdir(cacheDir, { recursive: true });
+  const cachePath = path2.join(cacheDir, MODELS_CACHE_FILENAME);
+  const lockFile = path2.join(cacheDir, "warmup.lock");
+  const fetchedAt = options?.fetchedAt ?? Date.now();
+  const cacheEntry = { modelIds: sanitized, fetchedAt };
+  let heartbeat;
+  if (!options?.alreadyLocked) {
+    await acquireLockFile(lockFile, { timeoutMs: 6e4, staleMs: 10 * 6e4 });
+    heartbeat = startLockHeartbeat(lockFile);
+  }
+  try {
+    await writeFileAtomic(cachePath, JSON.stringify(cacheEntry, null, 2));
+    const stat2 = await fs2.stat(cachePath);
+    rememberModelsSnapshot(cachePath, stat2.mtimeMs, sanitized, fetchedAt);
+    return sanitized;
+  } finally {
+    if (heartbeat) clearInterval(heartbeat);
+    if (!options?.alreadyLocked) {
+      await releaseLockFile(lockFile);
+    }
+  }
+}
+async function executeOpencodeCommandWithBootstrapRetry(options) {
+  const runningUnderVitest = Boolean(process.env.VITEST || process.env.VITEST_WORKER_ID) || process.env.NODE_ENV === "test" || process.argv.some((arg) => arg.includes("vitest"));
+  const budgetRemaining = options.retryBudget?.remaining;
+  const defaultMaxAttempts = budgetRemaining !== void 0 ? Math.max(1, Math.min(3, budgetRemaining)) : 3;
+  const maxAttempts = typeof options.maxAttempts === "number" && Number.isFinite(options.maxAttempts) ? Math.max(1, Math.min(3, Math.floor(options.maxAttempts))) : defaultMaxAttempts;
+  let pendingRetryError;
+  const retry = createRetryOptions({
+    providerName: options.metadata.name,
+    operation: options.operation,
+    maxAttempts,
+    initialDelayMs: runningUnderVitest ? 10 : 1e3,
+    maxDelayMs: 15e3,
+    backoffMultiplier: 2,
+    retryBudget: options.retryBudget,
+    abortSignal: options.abortSignal,
+    deadlineMs: options.deadlineMs,
+    minimumAttemptTimeMs: Math.min(options.timeout, 3e4),
+    onRetry: (attempt2, error) => {
+      pendingRetryError = error;
+      if (!runningUnderVitest && attempt2 >= 1 && error instanceof ProviderExecutionError) {
+        debugLog(
+          `[OpenCode] ${options.operation} retry ${attempt2 + 1}/${retry.maxAttempts}: ${error.message}`
+        );
+      }
+    }
+  });
+  const providerId = options.metadata.id ?? metadata.id;
+  const { execute, decision } = await selectProviderExecutor({
+    provider: providerId,
+    requested: options.executionTransport,
+    configured: resolveConfiguredProviderExecutionTransport(providerId, options.workingDir).value,
+    env: options.env,
+    executionIntent: options.executionIntent,
+    readOnlyWorkingDir: options.readOnlyWorkingDir,
+    headless: executeProviderCommand,
+    onDecision: (decision2) => reportTransportDecision(providerId, decision2, debugLog)
+  });
+  const wantsTmuxCompletionSignal = decision.resolved === "tmux-exec";
+  let attempt = 0;
+  const result = await withRetry(async () => {
+    attempt++;
+    if (attempt > 1 && options.beforeRetryAttempt) {
+      await options.beforeRetryAttempt(pendingRetryError);
+    }
+    const args = attempt > 1 ? [...options.args, "--print-logs", "--log-level", "ERROR"] : [...options.args];
+    const runnerMetadata = {
+      ...options.metadata,
+      installCommand: options.metadata.installCommand ?? metadata.installCommand
+    };
+    try {
+      const streamOutput = resolveProviderStreamingEnabled(options.env);
+      const tmuxCompletionSignal = wantsTmuxCompletionSignal ? createOpencodeTmuxCompletionSignal() : void 0;
+      return await execute({
+        command: options.command,
+        args,
+        workingDir: options.workingDir,
+        env: options.env,
+        input: options.input,
+        stdinMode: options.input === void 0 ? "ignore" : "pipe",
+        timeout: resolveOpencodeBootstrapAttemptTimeoutMs(options.timeout, options.deadlineMs),
+        extraWritePaths: options.extraWritePaths,
+        readOnlyWorkingDir: options.readOnlyWorkingDir,
+        providerInternalSandboxBypass: options.providerInternalSandboxBypass,
+        idleWarnMs: options.idleWarnMs,
+        idleKillMs: options.idleKillMs,
+        onData: options.onData,
+        onErrorData: options.onErrorData,
+        onStdoutChunk: options.onStdoutChunk,
+        onStderrChunk: options.onStderrChunk,
+        onActivity: options.onActivity,
+        onFirstOutput: options.onFirstOutput,
+        abortSignal: options.abortSignal,
+        metadata: runnerMetadata,
+        ...streamOutput ? { streamOutput: true } : {},
+        ...tmuxCompletionSignal ? {
+          completionSignal: tmuxCompletionSignal,
+          completionSignalGraceMs: TMUX_COMPLETION_SIGNAL_GRACE_MS
+        } : {}
+      });
+    } catch (error) {
+      if (error instanceof ProviderExecutionError && isOpencodeBunInstallFailure(error)) {
+        throw makeRetryableBootstrapError(error, options.metadata.name, options.operation);
+      }
+      throw error;
+    }
+  }, retry);
+  return result.result;
+}
+
+export {
+  getProviderRefreshEvidence,
+  getProviderSliceAgeMs,
+  formatCacheAge,
+  getProjectRefreshOverlayNotice,
+  extractUnstructuredOpencodeStdout,
+  parseOpencodeProviderOutput,
+  resolveOpencodeModelsCacheDir,
+  getCachedOpencodeModelIds,
+  getOpencodeModelsCacheInfo,
+  persistOpencodeModelsCache,
+  executeOpencodeCommandWithBootstrapRetry
+};
+//# sourceMappingURL=chunk-3LOY6YZI.js.map