@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-CJHRFSNY.js

@@ -0,0 +1,924 @@
+import {
+  metadata
+} from "./chunk-3FLXLLB7.js";
+import {
+  reportTransportDecision,
+  selectProviderExecutor
+} from "./chunk-R2ZYWNW3.js";
+import {
+  resolveConfiguredProviderExecutionTransport
+} from "./chunk-IZZK3H6I.js";
+import {
+  resolveProviderStreamingEnabled
+} from "./chunk-HIO33P3G.js";
+import {
+  TMUX_COMPLETION_SIGNAL_GRACE_MS,
+  createLineDelimitedTmuxCompletionSignal,
+  executeProviderCommand
+} from "./chunk-SQZRPY23.js";
+import {
+  writeFileAtomic
+} from "./chunk-36PEBZAF.js";
+import {
+  createRetryOptions,
+  withRetry
+} from "./chunk-T6VPI2XP.js";
+import {
+  deriveOpencodePrefixes
+} from "./chunk-XT2ZQVTC.js";
+import {
+  safeJsonParse
+} from "./chunk-S54MKU6V.js";
+import {
+  ProviderExecutionError
+} from "./chunk-LUVKFFWR.js";
+import {
+  PROVIDER_CATALOG_SHA256,
+  ProviderRegistry,
+  getRefreshOverlayOperatorNotice,
+  resolveRefreshOverlayDisposition
+} from "./chunk-AT4TNPWW.js";
+import {
+  findProjectRoot,
+  resolveProvidersConfigPath
+} from "./chunk-L6OM4A22.js";
+import {
+  debugLog,
+  isDebugMode
+} from "./chunk-EJGCZGUF.js";
+
+// src/core/providers/opencode/output-adapter.ts
+function asRecord(value) {
+  return value && typeof value === "object" ? value : void 0;
+}
+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(stream.slice(start, index + 1));
+        start = -1;
+      }
+    }
+  }
+  return objects;
+}
+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 extractErrorMessage(errorRecord) {
+  if (!errorRecord) return void 0;
+  const direct = readStringField(errorRecord, ["message", "error", "detail", "description"]) ?? readStringField(asRecord(errorRecord.data), ["message", "error", "detail", "description"]);
+  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/.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") {
+    return {
+      message: "OpenCode stopped because the model context length was exhausted.",
+      type: "step_finish",
+      errorType: "length",
+      retryable: false,
+      raw: evt
+    };
+  }
+  const evtType = typeof evt.type === "string" ? evt.type : void 0;
+  const errorRecord = asRecord(evt.error) ?? asRecord(evt.data) ?? (evtType === "error" ? evt : void 0);
+  const message = extractErrorMessage(errorRecord) ?? (evtType === "error" ? extractTextFromEvent(evt) : void 0);
+  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;
+  let totalCostUsd;
+  let resolvedModel;
+  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.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 eventText = extractTextFromEvent(evt);
+        if (eventText) {
+          text += eventText;
+        }
+        const evtType = evt.type;
+        const evtEvent = evt.event;
+        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) {
+          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);
+          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 = 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;
+        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) {
+            tokenUsage = {
+              inputTokens: (tokenUsage?.inputTokens ?? 0) + (inputTokens ?? 0),
+              outputTokens: (tokenUsage?.outputTokens ?? 0) + (outputTokens ?? 0)
+            };
+          }
+        }
+        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;
+        if (cost !== void 0) {
+          totalCostUsd = (totalCostUsd ?? 0) + cost;
+        }
+      } catch {
+      }
+    }
+  }
+  return {
+    text,
+    tokenUsage,
+    totalCostUsd,
+    resolvedModel,
+    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)) === ".poetic" ? 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, overlayPath) {
+  try {
+    const disposition = resolveRefreshOverlayDisposition(fs.readFileSync(overlayPath, "utf8"), {
+      expectedBaseCatalogDigest: PROVIDER_CATALOG_SHA256
+    });
+    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,
+    path.join(projectRoot, ".poetic", "cache", "model-update", "refresh-overlay.json")
+  );
+  if (overlayEvidence) return overlayEvidence;
+  const auditEvidence = latestCommittedRefreshEvidence(
+    providerId,
+    path.join(projectRoot, ".poetic", "logs", "provider-refresh.jsonl")
+  );
+  if (auditEvidence) return auditEvidence;
+  try {
+    const registry = ProviderRegistry.load(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();
+  return getRefreshOverlayOperatorNotice(
+    path.join(root, ".poetic", "cache", "model-update", "refresh-overlay.json"),
+    PROVIDER_CATALOG_SHA256
+  );
+}
+
+// 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;
+var OPENCODE_BOOTSTRAP_DEADLINE_SAFETY_BUFFER_MS = 5e3;
+function resolveOpencodeBootstrapAttemptTimeoutMs(timeoutMs, deadlineMs) {
+  if (deadlineMs == null) {
+    return timeoutMs;
+  }
+  const remainingMs = deadlineMs - Date.now() - OPENCODE_BOOTSTRAP_DEADLINE_SAFETY_BUFFER_MS;
+  if (remainingMs <= 0) {
+    throw new ProviderExecutionError("OpenCode bootstrap deadline exceeded before attempt start.", {
+      retryable: false,
+      reason: "deadline_exhausted"
+    });
+  }
+  return Math.max(1, Math.min(timeoutMs, remainingMs));
+}
+function sanitizeVersionForFilename(version) {
+  const sanitized = version.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/\.\.+/g, ".").replace(/^-+|-+$/g, "").replace(/^\.+/, "").slice(0, 80);
+  return sanitized || "unknown";
+}
+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) {
+  if (!Number.isInteger(pid) || (pid ?? 0) <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (error.code === "EPERM") {
+      return true;
+    }
+    return false;
+  }
+}
+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(cacheDir) {
+  return cacheDir ?? path2.join(homedir(), ".poetic", "cache", "opencode");
+}
+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(cacheDir) {
+  const cachePath = path2.join(resolveOpencodeModelsCacheDir(cacheDir), MODELS_CACHE_FILENAME);
+  const cached = readModelsCacheFromDisk(cachePath);
+  if (cached) return cached.modelIds;
+  if (cachedModelsSnapshot?.cachePath === cachePath) {
+    cachedModelsSnapshot = null;
+  }
+  return [];
+}
+function getOpencodeModelsCacheInfo(cacheDir, now = Date.now()) {
+  const cachePath = path2.join(resolveOpencodeModelsCacheDir(cacheDir), 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?.cacheDir);
+  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 ensureOpencodeWarm(options) {
+  const runningUnderVitest = Boolean(process.env.VITEST || process.env.VITEST_WORKER_ID) || process.env.NODE_ENV === "test" || process.argv.some((arg) => arg.includes("vitest"));
+  if (runningUnderVitest && process.env.POETIC_OPENCODE_WARMUP_FORCE !== "1") return;
+  const cacheDir = resolveOpencodeModelsCacheDir(options.cacheDir);
+  await fs2.mkdir(cacheDir, { recursive: true });
+  const lockFile = path2.join(cacheDir, "warmup.lock");
+  const versionFile = path2.join(cacheDir, "version.txt");
+  let cachedVersion = "";
+  try {
+    const raw = await fs2.readFile(versionFile, "utf-8");
+    cachedVersion = raw.trim();
+  } catch {
+  }
+  let version = "";
+  try {
+    const result = await executeProviderCommand({
+      command: options.command,
+      args: [...options.prefixArgs ?? [], "--version"],
+      workingDir: options.workingDir,
+      stdinMode: "ignore",
+      timeout: Math.min(options.timeoutMs ?? 1e4, 1e4),
+      metadata: {
+        id: metadata.id,
+        name: metadata.name,
+        installCommand: metadata.installCommand,
+        authHint: metadata.authHint,
+        docsPath: metadata.docsPath,
+        docsAnchor: metadata.docsAnchor
+      }
+    });
+    version = (result.stdout ?? "").trim();
+    if (version && version !== cachedVersion) {
+      await writeFileAtomic(versionFile, version).catch(() => {
+      });
+    }
+  } catch {
+    version = cachedVersion;
+  }
+  if (!version) {
+    return;
+  }
+  const sentinel = path2.join(cacheDir, `warm-${sanitizeVersionForFilename(version)}.json`);
+  const sentinelReady = await fs2.access(sentinel).then(() => true).catch(() => false);
+  if (sentinelReady) {
+    return;
+  }
+  await acquireLockFile(lockFile, { timeoutMs: 6e4, staleMs: 10 * 6e4 });
+  const heartbeat = startLockHeartbeat(lockFile);
+  try {
+    const sentinelReadyAfterLock = await fs2.access(sentinel).then(() => true).catch(() => false);
+    if (!sentinelReadyAfterLock) {
+      await executeProviderCommand({
+        command: options.command,
+        args: [...options.prefixArgs ?? [], "auth", "list"],
+        workingDir: options.workingDir,
+        stdinMode: "ignore",
+        timeout: Math.min(options.timeoutMs ?? 2e4, 2e4),
+        metadata: {
+          id: metadata.id,
+          name: metadata.name,
+          installCommand: metadata.installCommand,
+          authHint: metadata.authHint,
+          docsPath: metadata.docsPath,
+          docsAnchor: metadata.docsAnchor
+        }
+      });
+      await writeFileAtomic(
+        sentinel,
+        JSON.stringify({ version, warmedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)
+      ).catch(() => {
+      });
+    }
+  } finally {
+    clearInterval(heartbeat);
+    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;
+}
+
+// src/core/providers/opencode/model-canonicalizer.ts
+var KNOWN_OPENCODE_PREFIXES = /* @__PURE__ */ new Set([
+  "openrouter",
+  "opencode",
+  "opencode-go",
+  "amazon-bedrock",
+  "zai-coding-plan",
+  "zai-coding",
+  "anthropic",
+  "openai",
+  "google",
+  "fireworks",
+  "deepseek",
+  "mistral",
+  "groq",
+  "together",
+  "xai",
+  "perplexity",
+  "cohere"
+]);
+function buildEffectivePrefixes(cachedModelIds) {
+  if (!cachedModelIds || cachedModelIds.length === 0) {
+    return KNOWN_OPENCODE_PREFIXES;
+  }
+  const effective = new Set(KNOWN_OPENCODE_PREFIXES);
+  for (const prefix of deriveOpencodePrefixes(cachedModelIds)) {
+    effective.add(prefix);
+  }
+  return effective;
+}
+function canonicalizeOpencodeModelId(model, cachedModelIds) {
+  const slashCount = (model.match(/\//g) || []).length;
+  if (slashCount === 0) return model;
+  const openrouterCandidate = slashCount === 1 && cachedModelIds?.includes(`openrouter/${model}`) ? `openrouter/${model}` : void 0;
+  const exactCachedMatch = cachedModelIds?.includes(model);
+  const effectivePrefixes = buildEffectivePrefixes(cachedModelIds);
+  const firstSegment = model.split("/")[0]?.toLowerCase();
+  if (firstSegment && effectivePrefixes.has(firstSegment)) {
+    if (exactCachedMatch) {
+      return model;
+    }
+    if (firstSegment !== "openrouter" && openrouterCandidate) {
+      if (isDebugMode()) {
+        console.debug(
+          `[opencode-model] Preferring canonical OpenRouter model: ${model} \u2192 ${openrouterCandidate}`
+        );
+      }
+      return openrouterCandidate;
+    }
+    if (slashCount === 1 && firstSegment === "openrouter" && cachedModelIds && cachedModelIds.length > 0) {
+      const isInCache = cachedModelIds.includes(model);
+      const has3SegmentVariant = cachedModelIds.some((id) => id.startsWith(`${model}/`));
+      if (!isInCache && !has3SegmentVariant) {
+        if (isDebugMode()) {
+          debugLog(
+            `[opencode-model] WARNING: Model '${model}' may fail OpenCode resolution due to upstream bug. OpenCode splits 2-segment IDs and looks up just '${model.split("/")[1]}' in the provider dict. If the model is keyed by the full ID '${model}' in OpenCode's catalog, this will fail. Consider using a 3-segment form if available, or report this to OpenCode maintainers.`
+          );
+        }
+      }
+    }
+    return model;
+  }
+  if (cachedModelIds?.includes(model)) return model;
+  if (slashCount >= 2) return model;
+  if (openrouterCandidate) {
+    if (isDebugMode()) {
+      console.debug(`[opencode-model] Auto-prefixing model: ${model} \u2192 ${openrouterCandidate}`);
+    }
+    return openrouterCandidate;
+  }
+  return model;
+}
+
+export {
+  getProviderRefreshEvidence,
+  getProviderSliceAgeMs,
+  formatCacheAge,
+  getProjectRefreshOverlayNotice,
+  parseOpencodeProviderOutput,
+  getCachedOpencodeModelIds,
+  getOpencodeModelsCacheInfo,
+  persistOpencodeModelsCache,
+  ensureOpencodeWarm,
+  executeOpencodeCommandWithBootstrapRetry,
+  canonicalizeOpencodeModelId
+};
+//# sourceMappingURL=chunk-CJHRFSNY.js.map