@magnusekdahl/parallix 1.2.0 → 1.3.0

package/lib/agents/opencode.js

@@ -1,43 +1,48 @@
-const { spawnAndTee } = require('../core/spawn-tee');
-const { extractOpencodeTelemetryFromExport } = require('./opencode-telemetry');
-const { captureOpencodeExport } = require('./opencode-export');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOpencodeInvocation = buildOpencodeInvocation;
+exports.extractOpencodeSessionId = extractOpencodeSessionId;
+exports.resolveOpencodeCommand = resolveOpencodeCommand;
+exports.startOpencodeAgent = startOpencodeAgent;
+exports.isSpuriousOpencodeExit = isSpuriousOpencodeExit;
+exports.isTransientOpencodeFailure = isTransientOpencodeFailure;
+exports.isHardOpencodeFailure = isHardOpencodeFailure;
+exports.shouldRetryOpencodeFailure = shouldRetryOpencodeFailure;
+exports.__setSpawnAndTeeForTest = __setSpawnAndTeeForTest;
+exports.__setExportCaptureForTest = __setExportCaptureForTest;
+exports.__setSessionsForTest = __setSessionsForTest;
+exports.__setJsonFormatSupportForTest = __setJsonFormatSupportForTest;
+exports.__setJsonFormatDetectForTest = __setJsonFormatDetectForTest;
+const spawn_tee_js_1 = require("../core/spawn-tee.js");
+const opencode_telemetry_js_1 = require("./opencode-telemetry.js");
+const opencode_export_js_1 = require("./opencode-export.js");
+const limit_hit_js_1 = require("./limit-hit.js");
+// tools/sessions and core/subagent-limit are still CJS (not converted in this
+// wave); require keeps them untyped (any) without pulling non-included .js into
+// the typecheck program.
 const sessions = require('../tools/sessions');
-const { detectLimitHit } = require('./limit-hit');
 const { buildSubagentLimitPrefix } = require('../core/subagent-limit');
-
 // Injectable I/O for tests. Production uses the real spawn-tee / export capture.
-/** @type {Function} */
-let _spawnAndTee = spawnAndTee;
-/** @type {Function} */
-let _captureExport = captureOpencodeExport;
-/** @type {object} */
+let _spawnAndTee = spawn_tee_js_1.spawnAndTee;
+let _captureExport = opencode_export_js_1.captureOpencodeExport;
 let _sessions = sessions;
-
 // Test hooks: override the launcher's I/O without touching the public signature.
-/** @param {Function} fn */
-function __setSpawnAndTeeForTest(fn) { _spawnAndTee = fn || spawnAndTee; }
-/** @param {Function} fn */
-function __setExportCaptureForTest(fn) { _captureExport = fn || captureOpencodeExport; }
-/** @param {object} mod */
+function __setSpawnAndTeeForTest(fn) { _spawnAndTee = fn || spawn_tee_js_1.spawnAndTee; }
+function __setExportCaptureForTest(fn) { _captureExport = fn || opencode_export_js_1.captureOpencodeExport; }
 function __setSessionsForTest(mod) { _sessions = mod || sessions; }
-
 // Test hook: override the cached feature-detect for `--format json` support.
 // Set to true/false to force inclusion/exclusion of the flag regardless of
 // the real binary.  Pass null to reset to the live detect.
-/** @param {boolean|null} val */
 function __setJsonFormatSupportForTest(val) {
-  _jsonFormatSupported = val;
-  _jsonFormatDetectFn = null;
+    _jsonFormatSupported = val;
+    _jsonFormatDetectFn = null;
 }
-
 // Test hook: inject a feature-detect function for tests.  This replaces the
 // live shell-out with a stubbed function, making tests hermetic.
-/** @param {Function} fn */
 function __setJsonFormatDetectForTest(fn) {
-  _jsonFormatDetectFn = fn;
-  _jsonFormatSupported = null;  // invalidate cache so the detect fn runs
+    _jsonFormatDetectFn = fn;
+    _jsonFormatSupported = null; // invalidate cache so the detect fn runs
 }
-
 // Session-id recovery for telemetry. After session completion `opencode export`
 // is invoked to extract token-usage data (see opencode-telemetry.js), so the
 // session id MUST be recoverable from the launcher's stdout. Stats hooks in
@@ -53,100 +58,99 @@ function __setJsonFormatDetectForTest(fn) {
 //      so this field is always present.
 const OPENCODE_SESSION_ID_RE = /opencode\s+-s\s+(ses_\S+)/i;
 const OPENCODE_JSON_SESSION_ID_RE = /"sessionID"\s*:\s*"(ses_[^"]+)"/;
-
-/** @param {string} stdout */
 function extractOpencodeSessionId(stdout) {
-  if (!stdout) {return null;}
-  const footer = OPENCODE_SESSION_ID_RE.exec(stdout);
-  if (footer) {return footer[1];}
-  const json = OPENCODE_JSON_SESSION_ID_RE.exec(stdout);
-  return json ? json[1] : null;
+    if (!stdout) {
+        return null;
+    }
+    const footer = OPENCODE_SESSION_ID_RE.exec(stdout);
+    if (footer) {
+        return footer[1];
+    }
+    const json = OPENCODE_JSON_SESSION_ID_RE.exec(stdout);
+    return json ? json[1] : null;
 }
-
 // Cached feature-detect for `--format json` support. Set to `false` only when
 // a real invocation proves the flag is rejected (older opencode versions).
 // Tests can inject a canned result via __setJsonFormatSupportForTest.
-/** @type {boolean | null} */
 let _jsonFormatSupported = null;
-
 // Injectable feature-detect function for tests.  When set, checkJsonFormatSupport()
 // calls this function instead of shelling out, making tests hermetic.
-/** @type {Function | null} */
 let _jsonFormatDetectFn = null;
-
 function resolveOpencodeCommand() {
-  return 'opencode';
+    return 'opencode';
 }
-
 // Lightweight feature-detect: try `opencode --format json --help`.
 // Returns true if the flag is accepted (exit 0 or non-zero for unrelated reasons),
 // false if the flag itself is rejected ("unrecognized" / "unknown option").
 // Results are cached so the check runs at most once in production.
 // Tests can inject a canned result via __setJsonFormatSupportForTest.
 function checkJsonFormatSupport() {
-  if (_jsonFormatSupported !== null) {return _jsonFormatSupported;}
-  if (_jsonFormatDetectFn) {
-    _jsonFormatSupported = _jsonFormatDetectFn();
-    return _jsonFormatSupported;
-  }
-  try {
-    const { spawnSync } = require('node:child_process');
-    const result = spawnSync('opencode', ['--format', 'json', '--help'], {
-      timeout: 3000,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    const stderr = (result.stderr && result.stderr.toString()) || '';
-    const combined = stderr;
-    // Flag rejected → fallback to legacy invocation.
-    if (/unrecognized|unknown option|no such option|invalid option/i.test(combined)) {
-      _jsonFormatSupported = false;
-      return false;
+    if (_jsonFormatSupported !== null) {
+        return _jsonFormatSupported;
+    }
+    if (_jsonFormatDetectFn) {
+        _jsonFormatSupported = _jsonFormatDetectFn();
+        return _jsonFormatSupported;
+    }
+    try {
+        const { spawnSync } = require('node:child_process');
+        const result = spawnSync('opencode', ['--format', 'json', '--help'], {
+            timeout: 3000,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const stderr = (result.stderr && result.stderr.toString()) || '';
+        const combined = stderr;
+        // Flag rejected → fallback to legacy invocation.
+        if (/unrecognized|unknown option|no such option|invalid option/i.test(combined)) {
+            _jsonFormatSupported = false;
+            return false;
+        }
+        _jsonFormatSupported = true;
+        return true;
+    }
+    catch (_) {
+        // ENOENT or other spawn errors → assume legacy (no JSON flag).
+        _jsonFormatSupported = false;
+        return false;
     }
-    _jsonFormatSupported = true;
-    return true;
-  } catch (_) {
-    // ENOENT or other spawn errors → assume legacy (no JSON flag).
-    _jsonFormatSupported = false;
-    return false;
-  }
 }
-
-/**
- * @param {{ prompt: string, worktree: string, env?: object, resume?: boolean, sessionId?: string | null, model?: string | null, preferJson?: boolean }} opts
- */
 function buildOpencodeInvocation({ prompt, worktree, env, resume = false, sessionId = null, model = null, preferJson = true }) {
-  // `--format json` makes opencode stream NDJSON events that each carry a
-  // "sessionID":"ses_..." field. opencode v2.0.0's default `run` output no
-  // longer prints the "Continue  opencode -s ses_..." footer, so JSON is the
-  // only reliable way to recover the session id needed for `opencode export`
-  // telemetry capture (task-1339).
-  //
-  // Compatibility guard: feature-detect the flag on first call; older opencode
-  // versions that reject `--format json` will silently fall back to the legacy
-  // invocation, preserving launch behaviour at the cost of telemetry.
-  const useJson = preferJson && checkJsonFormatSupport();
-  const args = ['run', '--pure', '--dangerously-skip-permissions'];
-  if (useJson) {args.push('--format', 'json');}
-  if (model) {args.push('-m', model);}
-  // Only resume when the marker explicitly says so (resume=true).
-  // sessionId from a stale cross-family marker must be ignored when resume=false.
-  if (resume && sessionId) {
-    args.push('-s', sessionId);
-  } else if (resume) {
-    args.push('--continue');
-  }
-  args.push(prompt);
-  return {
-    command: resolveOpencodeCommand(),
-    args,
-    options: {
-      stdio: 'inherit',
-      cwd: worktree,
-      env: { ...process.env, ...env }
+    // `--format json` makes opencode stream NDJSON events that each carry a
+    // "sessionID":"ses_..." field. opencode v2.0.0's default `run` output no
+    // longer prints the "Continue  opencode -s ses_..." footer, so JSON is the
+    // only reliable way to recover the session id needed for `opencode export`
+    // telemetry capture (task-1339).
+    //
+    // Compatibility guard: feature-detect the flag on first call; older opencode
+    // versions that reject `--format json` will silently fall back to the legacy
+    // invocation, preserving launch behaviour at the cost of telemetry.
+    const useJson = preferJson && checkJsonFormatSupport();
+    const args = ['run', '--pure', '--dangerously-skip-permissions'];
+    if (useJson) {
+        args.push('--format', 'json');
+    }
+    if (model) {
+        args.push('-m', model);
+    }
+    // Only resume when the marker explicitly says so (resume=true).
+    // sessionId from a stale cross-family marker must be ignored when resume=false.
+    if (resume && sessionId) {
+        args.push('-s', sessionId);
+    }
+    else if (resume) {
+        args.push('--continue');
     }
-  };
+    args.push(prompt);
+    return {
+        command: resolveOpencodeCommand(),
+        args,
+        options: {
+            stdio: 'inherit',
+            cwd: worktree,
+            env: { ...process.env, ...env }
+        }
+    };
 }
-
 // Transient custom/vLLM backend failures that opencode surfaces as a non-zero
 // exit. These are recoverable: the same prompt frequently succeeds on a second
 // attempt, so the launcher retries once in-family before agents.js reroutes to a
@@ -154,242 +158,196 @@ function buildOpencodeInvocation({ prompt, worktree, env, resume = false, sessio
 // detectLimitHit() in agents.js owns that accounting (lib/agents/limit-hit.js).
 // Hard errors (model-not-found, auth, ENOENT/EACCES) are never retried.
 const TRANSIENT_OPENCODE_PATTERNS = [
-  /\bECONNRESET\b/i,
-  /\bECONNREFUSED\b/i,
-  /\bETIMEDOUT\b/i,
-  /\bENETUNREACH\b/i,
-  /\bENOTFOUND\b/i,
-  /\bEAI_AGAIN\b/i,
-  /\bEPIPE\b/i,
-  /socket hang ?up/i,
-  /\bfetch failed\b/i,
-  /network (?:error|timeout)/i,
-  /connection (?:error|reset|closed|refused|timed? ?out)/i,
-  /\b(?:502|503|504|529)\b/,
-  /\bbad gateway\b/i,
-  /\bservice (?:is )?unavailable\b/i,
-  /\bgateway time-?out\b/i,
-  /\b(?:server |api |model )?overloaded\b/i,
-  /\btemporarily unavailable\b/i,
-  /\bplease (?:try|retry) again\b/i,
-  /\bretry[- ]after\b/i,
+    /\bECONNRESET\b/i,
+    /\bECONNREFUSED\b/i,
+    /\bETIMEDOUT\b/i,
+    /\bENETUNREACH\b/i,
+    /\bENOTFOUND\b/i,
+    /\bEAI_AGAIN\b/i,
+    /\bEPIPE\b/i,
+    /socket hang ?up/i,
+    /\bfetch failed\b/i,
+    /network (?:error|timeout)/i,
+    /connection (?:error|reset|closed|refused|timed? ?out)/i,
+    /\b(?:502|503|504|529)\b/,
+    /\bbad gateway\b/i,
+    /\bservice (?:is )?unavailable\b/i,
+    /\bgateway time-?out\b/i,
+    /\b(?:server |api |model )?overloaded\b/i,
+    /\btemporarily unavailable\b/i,
+    /\bplease (?:try|retry) again\b/i,
+    /\bretry[- ]after\b/i,
 ];
-
 // Hard, non-retryable failures: retrying cannot help and only wastes time/quota.
 const HARD_OPENCODE_PATTERNS = [
-  /\bmodel not found\b/i,
-  /\bno such model\b/i,
-  /\bunknown model\b/i,
-  /\binvalid (?:api )?key\b/i,
-  /\b401\b[^\n]*\bunauthorized\b/i,
-  /\bauthentication (?:failed|error)\b/i,
+    /\bmodel not found\b/i,
+    /\bno such model\b/i,
+    /\bunknown model\b/i,
+    /\binvalid (?:api )?key\b/i,
+    /\b401\b[^\n]*\bunauthorized\b/i,
+    /\bauthentication (?:failed|error)\b/i,
 ];
-
-/**
- * @param {{stdout?: string, stderr?: string}} result
- */
 function failureText(result) {
-  return `${(result && result.stdout) || ''}\n${(result && result.stderr) || ''}`;
+    return `${(result && result.stdout) || ''}\n${(result && result.stderr) || ''}`;
 }
-
-/**
- * @param {{stdout?: string, stderr?: string, error?: {code?: string}}} result
- */
 function isHardOpencodeFailure(result) {
-  if (!result) {return false;}
-  if (result.error && (result.error.code === 'ENOENT' || result.error.code === 'EACCES')) {return true;}
-  const text = failureText(result);
-  return HARD_OPENCODE_PATTERNS.some((re) => re.test(text));
+    if (!result) {
+        return false;
+    }
+    if (result.error && (result.error.code === 'ENOENT' || result.error.code === 'EACCES')) {
+        return true;
+    }
+    const text = failureText(result);
+    return HARD_OPENCODE_PATTERNS.some((re) => re.test(text));
 }
-
 // Opencode v2.0.0 JSON-mode sometimes exits with code 1 during post-run
 // cleanup (race closing the stdout pipe, EPIPE, or draining pending events).
 // When the transcript contains a valid "reason":"stop" completion event and
 // no "type":"error" event, the exit is spurious – the agent actually
 // completed successfully. See opencode issues #31446 and #33653.
-/**
- * @param {{status?: number, stdout?: string, stderr?: string}} result
- */
 function isSpuriousOpencodeExit(result) {
-  if (!result || result.status !== 1) {return false;}
-  const text = failureText(result);
-  const hasStop = /"reason"\s*:\s*"stop"/.test(text);
-  const hasError = /"type"\s*:\s*"error"/.test(text);
-  return hasStop && !hasError;
+    if (!result || result.status !== 1) {
+        return false;
+    }
+    const text = failureText(result);
+    const hasStop = /"reason"\s*:\s*"stop"/.test(text);
+    const hasError = /"type"\s*:\s*"error"/.test(text);
+    return hasStop && !hasError;
 }
-
-/**
- * @param {{stdout?: string, stderr?: string, error?: {code?: string}, signal?: string, status?: number}} result
- */
 function isTransientOpencodeFailure(result) {
-  if (!result) {return false;}
-  const text = failureText(result);
-  return TRANSIENT_OPENCODE_PATTERNS.some((re) => re.test(text));
+    if (!result) {
+        return false;
+    }
+    const text = failureText(result);
+    return TRANSIENT_OPENCODE_PATTERNS.some((re) => re.test(text));
 }
-
 // Decide whether a failed opencode run should be retried once in-family.
 // Only genuine non-zero exits carrying a transient backend signature qualify;
 // clean exits, spawn errors (ENOENT/EACCES), killing signals, limit-hits, and
 // hard errors never retry — so real failures still surface to the reroute loop.
-/** @param {{stdout?: string, stderr?: string, status?: number | null, signal?: string | null, error?: {code?: string}, sessionId?: string | null}} result */
 function shouldRetryOpencodeFailure(result) {
-  if (!result) {return false;}
-  if (result.error && (result.error.code === 'ENOENT' || result.error.code === 'EACCES')) {return false;}
-  if (result.signal) {return false;}
-  if (!(typeof result.status === 'number' && result.status !== 0)) {return false;}
-  if (detectLimitHit({
-    agent: 'custom',
-    stdout: result.stdout,
-    stderr: result.stderr,
-    status: result.status,
-    signal: result.signal,
-    error: result.error,
-  })) {return false;}
-  if (isHardOpencodeFailure(result)) {return false;}
-  return isTransientOpencodeFailure(/** @type {any} */(result));
+    if (!result) {
+        return false;
+    }
+    if (result.error && (result.error.code === 'ENOENT' || result.error.code === 'EACCES')) {
+        return false;
+    }
+    if (result.signal) {
+        return false;
+    }
+    if (!(typeof result.status === 'number' && result.status !== 0)) {
+        return false;
+    }
+    if ((0, limit_hit_js_1.detectLimitHit)({
+        agent: 'custom',
+        stdout: result.stdout,
+        stderr: result.stderr,
+        status: result.status,
+        signal: result.signal,
+        error: result.error,
+    })) {
+        return false;
+    }
+    if (isHardOpencodeFailure(result)) {
+        return false;
+    }
+    return isTransientOpencodeFailure(result);
 }
-
-/**
- * @param {{ prompt: string, worktree: string, env?: object, resume?: boolean, sessionId?: string | null, model?: string | null, teeOptions?: object, slug?: string | null, role?: string | null, maxTransientRetries?: number }} opts
- */
-function startOpencodeAgent({
-  prompt,
-  worktree,
-  env,
-  resume = false,
-  sessionId = null,
-  model = null,
-  teeOptions = {},
-  slug = null,
-  role = null,
-  maxTransientRetries = 1
-}) {
-  // Prepend the subagent-limit advisory prefix to the prompt.
-  // When maxParallel is unset/null/zero the prefix is empty (no-op).
-  const subagentPrefix = buildSubagentLimitPrefix();
-  const injectedPrompt = subagentPrefix + prompt;
-
-  /**
-   * @param {{stdout?: string, stderr?: string}} result
-   */
-  function isStaleSessionResult(result) {
-    if (!result) {return false;}
-    const stderr = result.stderr || '';
-    const stdout = result.stdout || '';
-    return stderr.includes('Session not found') || stdout.includes('Session not found');
-  }
-
-  /**
-   * @param {{command: string, args: string[], options?: object}} invocation
-   */
-  function runInvocation(invocation) {
-    const spawnOptions = { ...invocation.options, ...teeOptions };
-    return _spawnAndTee(invocation.command, invocation.args, spawnOptions);
-  }
-
-  /**
-   * @param {{command: string, args: string[], options?: object}} invocation
-   */
-  async function runInvocationWithRetry(invocation) {
-    let attempts = 0;
-    let result = await runInvocation(invocation);
-    while (attempts < maxTransientRetries && shouldRetryOpencodeFailure(result)) {
-      attempts += 1;
-      result = await runInvocation(invocation);
+function startOpencodeAgent({ prompt, worktree, env, resume = false, sessionId = null, model = null, teeOptions = {}, slug = null, role = null, maxTransientRetries = 1 }) {
+    // Prepend the subagent-limit advisory prefix to the prompt.
+    // When maxParallel is unset/null/zero the prefix is empty (no-op).
+    const subagentPrefix = buildSubagentLimitPrefix();
+    const injectedPrompt = subagentPrefix + prompt;
+    function isStaleSessionResult(result) {
+        if (!result) {
+            return false;
+        }
+        const stderr = result.stderr || '';
+        const stdout = result.stdout || '';
+        return stderr.includes('Session not found') || stdout.includes('Session not found');
     }
-    if (result) {result.transientRetries = attempts;}
-    return result;
-  }
-
-  // Detect whether `--format json` was rejected at runtime (e.g. older opencode
-  // that wasn't caught by the feature-detect).  If so, retry the invocation
-  // without the flag so the prompt still runs (telemetry will be lost but the
-  // agent won't fail outright).
-  /**
-   * @param {{stdout?: string, stderr?: string}} result
-   */
-  function isJsonFlagError(result) {
-    if (!result) {return false;}
-    const text = failureText(result);
-    return (/\bunrecognized option\b|\bunknown option\b|\bno such option\b|\binvalid option\b|\bunrecognized flag\b|\bunknown flag\b/i).test(text);
-  }
-
-  /**
-   * @param {{stdout?: string, sessionId?: string, telemetry?: object, model?: string, provider?: string, transientRetries?: number, _jsonFallback?: boolean}} result
-   */
-  async function processResult(result) {
-    if (result && result.stdout) {
-      result.sessionId = extractOpencodeSessionId(result.stdout) || undefined;
+    function runInvocation(invocation) {
+        const spawnOptions = { ...invocation.options, ...teeOptions };
+        return _spawnAndTee(invocation.command, invocation.args, spawnOptions);
     }
-    if (result && result.sessionId) {
-      try {
-        const exportJson = await _captureExport(result.sessionId, { worktree, env });
-        if (exportJson) {
-          const telemetry = extractOpencodeTelemetryFromExport(exportJson, model || undefined);
-          if (telemetry) {
-            /** @type {any} */(result).telemetry = telemetry;
-            if (/** @type {any} */(telemetry).model) {/** @type {any} */(result).model = /** @type {any} */(telemetry).model;}
-            if (/** @type {any} */(telemetry).provider) {/** @type {any} */(result).provider = /** @type {any} */(telemetry).provider;}
-          }
+    async function runInvocationWithRetry(invocation) {
+        let attempts = 0;
+        let result = await runInvocation(invocation);
+        while (attempts < maxTransientRetries && shouldRetryOpencodeFailure(result)) {
+            attempts += 1;
+            result = await runInvocation(invocation);
+        }
+        if (result) {
+            result.transientRetries = attempts;
         }
-      } catch (_) {
         return result;
-      }
     }
-    return result;
-  }
-
-  /**
-   * @param {{command: string, args: string[], options?: object}} invocation
-   */
-  async function runWithJsonFallback(invocation) {
-    let result = await runInvocationWithRetry(invocation);
-    // Runtime fallback: if the first invocation used --format json but the
-    // binary rejected it, retry without the flag so the prompt still executes.
-    if (isJsonFlagError(result) && invocation.args.includes('--format')) {
-      const legacyInv = buildOpencodeInvocation({
-        prompt: injectedPrompt, worktree, env, resume, sessionId, model, preferJson: false,
-      });
-      result = await runInvocationWithRetry(legacyInv);
-      // Mark that we fell back so callers know telemetry may be absent.
-      if (result) {result._jsonFallback = true;}
+    // Detect whether `--format json` was rejected at runtime (e.g. older opencode
+    // that wasn't caught by the feature-detect).  If so, retry the invocation
+    // without the flag so the prompt still runs (telemetry will be lost but the
+    // agent won't fail outright).
+    function isJsonFlagError(result) {
+        if (!result) {
+            return false;
+        }
+        const text = failureText(result);
+        return (/\bunrecognized option\b|\bunknown option\b|\bno such option\b|\binvalid option\b|\bunrecognized flag\b|\bunknown flag\b/i).test(text);
     }
-    return result;
-  }
-
-  /**
-   * @param {{command: string, args: string[], options?: object}} invocation
-   */
-  async function staleSessionHandler(invocation) {
-    let result = await runWithJsonFallback(invocation);
-    if (isStaleSessionResult(result) && worktree && resume) {
-      try {
-        /** @type {any} */(_sessions).clearSession(worktree, slug || '', role || '');
-      } catch (_) { /* best-effort */ }
-      const freshInv = buildOpencodeInvocation({ prompt: injectedPrompt, worktree, env, resume: false, sessionId: null, model });
-      result = await runWithJsonFallback(freshInv);
+    async function processResult(result) {
+        if (result && result.stdout) {
+            result.sessionId = extractOpencodeSessionId(result.stdout) || undefined;
+        }
+        if (result && result.sessionId) {
+            try {
+                const exportJson = await _captureExport(result.sessionId, { worktree, env });
+                if (exportJson) {
+                    const telemetry = (0, opencode_telemetry_js_1.extractOpencodeTelemetryFromExport)(exportJson, model || undefined);
+                    if (telemetry) {
+                        result.telemetry = telemetry;
+                        if (telemetry.model) {
+                            result.model = telemetry.model;
+                        }
+                        if (telemetry.provider) {
+                            result.provider = telemetry.provider;
+                        }
+                    }
+                }
+            }
+            catch (_) {
+                return result;
+            }
+        }
+        return result;
+    }
+    async function runWithJsonFallback(invocation) {
+        let result = await runInvocationWithRetry(invocation);
+        // Runtime fallback: if the first invocation used --format json but the
+        // binary rejected it, retry without the flag so the prompt still executes.
+        if (isJsonFlagError(result) && invocation.args.includes('--format')) {
+            const legacyInv = buildOpencodeInvocation({
+                prompt: injectedPrompt, worktree, env, resume, sessionId, model, preferJson: false,
+            });
+            result = await runInvocationWithRetry(legacyInv);
+            // Mark that we fell back so callers know telemetry may be absent.
+            if (result) {
+                result._jsonFallback = true;
+            }
+        }
+        return result;
+    }
+    async function staleSessionHandler(invocation) {
+        let result = await runWithJsonFallback(invocation);
+        if (isStaleSessionResult(result) && worktree && resume) {
+            try {
+                _sessions.clearSession(worktree, slug || '', role || '');
+            }
+            catch (_) { /* best-effort */ }
+            const freshInv = buildOpencodeInvocation({ prompt: injectedPrompt, worktree, env, resume: false, sessionId: null, model });
+            result = await runWithJsonFallback(freshInv);
+        }
+        return processResult(result);
     }
-    return processResult(result);
-  }
-
-  const invocation = buildOpencodeInvocation({ prompt: injectedPrompt, worktree, env, resume, sessionId, model });
-  const resultPromise = staleSessionHandler(invocation);
-
-  return { invocation, resultPromise };
+    const invocation = buildOpencodeInvocation({ prompt: injectedPrompt, worktree, env, resume, sessionId, model });
+    const resultPromise = staleSessionHandler(invocation);
+    return { invocation, resultPromise };
 }
-
-module.exports = {
-  buildOpencodeInvocation,
-  extractOpencodeSessionId,
-  resolveOpencodeCommand,
-  startOpencodeAgent,
-  isSpuriousOpencodeExit,
-  isTransientOpencodeFailure,
-  isHardOpencodeFailure,
-  shouldRetryOpencodeFailure,
-  __setSpawnAndTeeForTest,
-  __setExportCaptureForTest,
-  __setSessionsForTest,
-  __setJsonFormatSupportForTest,
-  __setJsonFormatDetectForTest,
-};