@the-open-engine/zeroshot 6.30.2 → 6.31.1

package/scripts/omp/runtime-lock.js

@@ -0,0 +1,232 @@
+'use strict';
+
+const crypto = require('crypto');
+const {
+  BUN_PACKAGE_INTEGRITY,
+  BUN_PACKAGE_NAME,
+  BUN_PLATFORM_ASSET_INTEGRITIES,
+  BUN_RUNTIME_VERSION,
+  OMP_NATIVE_PACKAGE_INTEGRITY,
+  OMP_NATIVE_PACKAGE_NAME,
+  OMP_NATIVE_PLATFORM_ASSET_INTEGRITIES,
+  OMP_NATIVE_PLATFORM_PACKAGES,
+  OMP_PACKAGE_NAME,
+  OMP_SDK_PACKAGE_INTEGRITY,
+  OMP_SDK_VERSION,
+} = require('./runtime-identities');
+
+function packageTarballUrl(packageName, version) {
+  const tarballName = packageName.slice(packageName.lastIndexOf('/') + 1);
+  return `https://registry.npmjs.org/${packageName}/-/${tarballName}-${version}.tgz`;
+}
+
+function assertLockedPackage(
+  packageLock,
+  packageName,
+  identity,
+  lockfileName = 'package-lock.json'
+) {
+  const { version, integrity, optional = false } = identity;
+  const locked = packageLock.packages?.[`node_modules/${packageName}`];
+  if (!locked) throw new Error(`${lockfileName} is missing ${packageName}`);
+  if (locked.version !== version) {
+    throw new Error(
+      `${lockfileName} ${packageName} version drift: expected ${version}, got ${
+        locked.version || 'unknown'
+      }`
+    );
+  }
+  if (locked.resolved !== packageTarballUrl(packageName, version)) {
+    throw new Error(`${lockfileName} ${packageName} tarball identity drift`);
+  }
+  if (locked.integrity !== integrity) {
+    throw new Error(`${lockfileName} ${packageName} integrity drift`);
+  }
+  if (optional && locked.optional !== true) {
+    throw new Error(`${lockfileName} ${packageName} must remain an optional platform asset`);
+  }
+  return locked;
+}
+
+function publishAllowlistIncludes(files, relativePath) {
+  const normalizedPath = relativePath.replaceAll('\\', '/').replace(/^\.\//, '');
+  return (files || []).some((entry) => {
+    const normalizedEntry = String(entry).replaceAll('\\', '/').replace(/^\.\//, '');
+    if (normalizedEntry.endsWith('/')) return normalizedPath.startsWith(normalizedEntry);
+    return normalizedEntry === normalizedPath;
+  });
+}
+
+function assertReleaseIdentity(condition, message) {
+  if (!condition) throw new Error(message);
+}
+function lockfileDigest(lockfile) {
+  return crypto.createHash('sha256').update(JSON.stringify(lockfile)).digest('hex');
+}
+function sourceDigest(source) {
+  return crypto.createHash('sha256').update(source).digest('hex');
+}
+
+function runtimeClosureDigest(lockfile) {
+  const packages = Object.fromEntries(
+    Object.entries(lockfile.packages || {})
+      .filter(([packagePath, metadata]) => packagePath === '' || metadata.dev !== true)
+      .map(([packagePath, metadata]) => {
+        if (packagePath !== '') return [packagePath, metadata];
+        const runtimeRoot = { ...metadata };
+        delete runtimeRoot.devDependencies;
+        return [packagePath, runtimeRoot];
+      })
+  );
+  return lockfileDigest({
+    lockfileVersion: lockfile.lockfileVersion,
+    requires: lockfile.requires,
+    packages,
+  });
+}
+
+function assertRootSpecs(packageJson, lockfile, lockfileName) {
+  const root = lockfile.packages?.[''];
+  assertReleaseIdentity(root, `${lockfileName} root package metadata is missing`);
+  assertReleaseIdentity(
+    packageJson.name === root.name,
+    `package.json and ${lockfileName} root package names must match`
+  );
+  assertReleaseIdentity(
+    packageJson.version === root.version,
+    `package.json and ${lockfileName} root package versions must match`
+  );
+  for (const field of ['dependencies', 'optionalDependencies', 'devDependencies']) {
+    assertReleaseIdentity(
+      lockfileDigest(packageJson[field] || {}) === lockfileDigest(root[field] || {}),
+      `${lockfileName} root ${field} must exactly match package.json`
+    );
+  }
+  return root;
+}
+
+function validatePinnedRuntimeLock(packageJson, lockfile, lockfileName) {
+  assertReleaseIdentity(
+    lockfile.lockfileVersion === 3,
+    `OMP SDK release assets require ${lockfileName} lockfileVersion 3`
+  );
+  const rootLock = assertRootSpecs(packageJson, lockfile, lockfileName);
+
+  for (const [packageName, version] of [
+    [OMP_PACKAGE_NAME, OMP_SDK_VERSION],
+    [BUN_PACKAGE_NAME, BUN_RUNTIME_VERSION],
+  ]) {
+    assertReleaseIdentity(
+      packageJson.dependencies?.[packageName] === version,
+      `package.json must pin ${packageName} exactly to ${version}`
+    );
+    assertReleaseIdentity(
+      rootLock.dependencies?.[packageName] === version,
+      `${lockfileName} root must pin ${packageName} exactly to ${version}`
+    );
+  }
+
+  const ompLock = assertLockedPackage(
+    lockfile,
+    OMP_PACKAGE_NAME,
+    {
+      version: OMP_SDK_VERSION,
+      integrity: OMP_SDK_PACKAGE_INTEGRITY,
+    },
+    lockfileName
+  );
+  assertReleaseIdentity(
+    ompLock.bin?.omp === 'dist/cli.js',
+    `${lockfileName} OMP SDK binary metadata drift`
+  );
+  assertReleaseIdentity(
+    ompLock.engines?.bun === '>=1.3.14',
+    `${lockfileName} OMP SDK Bun engine metadata drift`
+  );
+
+  const nativeLock = assertLockedPackage(
+    lockfile,
+    OMP_NATIVE_PACKAGE_NAME,
+    {
+      version: OMP_SDK_VERSION,
+      integrity: OMP_NATIVE_PACKAGE_INTEGRITY,
+    },
+    lockfileName
+  );
+  assertReleaseIdentity(
+    nativeLock.engines?.bun === '>=1.3.14',
+    `${lockfileName} OMP native Bun engine metadata drift`
+  );
+  const expectedNativePlatformNames = Object.values(OMP_NATIVE_PLATFORM_PACKAGES).sort();
+  const lockedNativePlatformNames = Object.keys(nativeLock.optionalDependencies || {}).sort();
+  assertReleaseIdentity(
+    lockfileDigest(expectedNativePlatformNames) === lockfileDigest(lockedNativePlatformNames),
+    `${lockfileName} OMP native platform asset set drift`
+  );
+  for (const packageName of expectedNativePlatformNames) {
+    assertReleaseIdentity(
+      nativeLock.optionalDependencies[packageName] === OMP_SDK_VERSION,
+      `${lockfileName} OMP natives must pin ${packageName} exactly`
+    );
+    assertLockedPackage(
+      lockfile,
+      packageName,
+      {
+        version: OMP_SDK_VERSION,
+        integrity: OMP_NATIVE_PLATFORM_ASSET_INTEGRITIES[packageName],
+        optional: true,
+      },
+      lockfileName
+    );
+  }
+
+  const bunLock = assertLockedPackage(
+    lockfile,
+    BUN_PACKAGE_NAME,
+    {
+      version: BUN_RUNTIME_VERSION,
+      integrity: BUN_PACKAGE_INTEGRITY,
+    },
+    lockfileName
+  );
+  assertReleaseIdentity(
+    bunLock.bin?.bun === 'bin/bun.exe',
+    `${lockfileName} Bun binary metadata drift`
+  );
+  assertReleaseIdentity(
+    bunLock.bin?.bunx === 'bin/bunx.exe',
+    `${lockfileName} Bunx binary metadata drift`
+  );
+
+  const expectedBunPlatformNames = Object.keys(BUN_PLATFORM_ASSET_INTEGRITIES).sort();
+  const lockedBunPlatformNames = Object.keys(bunLock.optionalDependencies || {}).sort();
+  assertReleaseIdentity(
+    lockfileDigest(expectedBunPlatformNames) === lockfileDigest(lockedBunPlatformNames),
+    `${lockfileName} Bun platform asset set drift`
+  );
+  for (const packageName of expectedBunPlatformNames) {
+    assertReleaseIdentity(
+      bunLock.optionalDependencies[packageName] === BUN_RUNTIME_VERSION,
+      `${lockfileName} Bun wrapper must pin ${packageName} exactly`
+    );
+    assertLockedPackage(
+      lockfile,
+      packageName,
+      {
+        version: BUN_RUNTIME_VERSION,
+        integrity: BUN_PLATFORM_ASSET_INTEGRITIES[packageName],
+        optional: true,
+      },
+      lockfileName
+    );
+  }
+}
+
+module.exports = {
+  assertReleaseIdentity,
+  lockfileDigest,
+  publishAllowlistIncludes,
+  runtimeClosureDigest,
+  sourceDigest,
+  validatePinnedRuntimeLock,
+};

package/scripts/omp/runtime-release.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const {
+  BUN_PLATFORM_PACKAGES,
+  BUN_RUNTIME_VERSION,
+  HOST_SDK_PLATFORM_KEYS,
+  HOST_SUPERVISOR_RELATIVE_PATH,
+  OMP_NATIVE_PLATFORM_PACKAGES,
+  OMP_SDK_VERSION,
+  REQUIRED_OMP_SDK_SOURCES,
+} = require('./runtime-identities');
+const {
+  assertReleaseIdentity,
+  lockfileDigest,
+  publishAllowlistIncludes,
+  runtimeClosureDigest,
+  sourceDigest,
+  validatePinnedRuntimeLock,
+} = require('./runtime-lock');
+
+function validateOmpSdkReleaseAssets(packageJson, packageLock, options = {}) {
+  const packageShrinkwrap = options.packageShrinkwrap;
+  assertReleaseIdentity(packageJson, 'OMP SDK release assets require package.json');
+  assertReleaseIdentity(packageLock, 'OMP SDK release assets require package-lock.json');
+  assertReleaseIdentity(
+    packageShrinkwrap,
+    'OMP SDK release assets require published npm-shrinkwrap.json'
+  );
+
+  validatePinnedRuntimeLock(packageJson, packageLock, 'package-lock.json');
+  validatePinnedRuntimeLock(packageJson, packageShrinkwrap, 'npm-shrinkwrap.json');
+
+  assertReleaseIdentity(
+    packageJson.ompSdkHostContainment?.supervisor ===
+      HOST_SUPERVISOR_RELATIVE_PATH.replaceAll('\\', '/') &&
+      packageJson.ompSdkHostContainment?.protocolVersion === 1 &&
+      lockfileDigest(packageJson.ompSdkHostContainment?.platforms || []) ===
+        lockfileDigest([...HOST_SDK_PLATFORM_KEYS]),
+    'package.json OMP SDK host containment identity drift'
+  );
+  const packageLockRuntimeDigest = runtimeClosureDigest(packageLock);
+  const shrinkwrapRuntimeDigest = runtimeClosureDigest(packageShrinkwrap);
+  assertReleaseIdentity(
+    packageLockRuntimeDigest === shrinkwrapRuntimeDigest,
+    'npm-shrinkwrap.json runtime closure identity must exactly match package-lock.json'
+  );
+  const packageLockIdentityDigest = lockfileDigest(packageLock);
+  const shrinkwrapIdentityDigest = lockfileDigest(packageShrinkwrap);
+  assertReleaseIdentity(
+    packageLockIdentityDigest === shrinkwrapIdentityDigest,
+    'npm-shrinkwrap.json digest must exactly match package-lock.json'
+  );
+  const packageLockDigest = options.packageLockSource
+    ? sourceDigest(options.packageLockSource)
+    : packageLockIdentityDigest;
+  const shrinkwrapDigest = options.packageShrinkwrapSource
+    ? sourceDigest(options.packageShrinkwrapSource)
+    : shrinkwrapIdentityDigest;
+  assertReleaseIdentity(
+    packageLockDigest === shrinkwrapDigest,
+    'published npm-shrinkwrap.json byte digest must exactly match package-lock.json'
+  );
+  assertReleaseIdentity(
+    publishAllowlistIncludes(packageJson.files, 'npm-shrinkwrap.json'),
+    'package.json publish allowlist excludes npm-shrinkwrap.json'
+  );
+
+  const supportedPlatformKeys = [...HOST_SDK_PLATFORM_KEYS].sort();
+  assertReleaseIdentity(
+    supportedPlatformKeys.every(
+      (key) =>
+        BUN_PLATFORM_PACKAGES[key] !== undefined && OMP_NATIVE_PLATFORM_PACKAGES[key] !== undefined
+    ),
+    'Host OMP SDK runtime platform set must be covered by pinned Bun and OMP native assets'
+  );
+
+  const sourceFiles = options.sourceFiles;
+  assertReleaseIdentity(
+    Array.isArray(sourceFiles),
+    'OMP SDK release source file identities are required'
+  );
+  for (const sourceFile of REQUIRED_OMP_SDK_SOURCES) {
+    assertReleaseIdentity(
+      sourceFiles.includes(sourceFile),
+      `OMP SDK release source is missing: ${sourceFile}`
+    );
+    assertReleaseIdentity(
+      publishAllowlistIncludes(packageJson.files, sourceFile),
+      `package.json publish allowlist excludes ${sourceFile}`
+    );
+  }
+
+  return Object.freeze({
+    bunPlatformPackages: Object.freeze(Object.values(BUN_PLATFORM_PACKAGES).sort()),
+    bunVersion: BUN_RUNTIME_VERSION,
+    ompNativePlatformPackages: Object.freeze(Object.values(OMP_NATIVE_PLATFORM_PACKAGES).sort()),
+    ompVersion: OMP_SDK_VERSION,
+    runtimeClosureSha256: packageLockRuntimeDigest,
+    shrinkwrapSha256: shrinkwrapDigest,
+    sourceFiles: REQUIRED_OMP_SDK_SOURCES,
+    supportedPlatforms: Object.freeze(supportedPlatformKeys),
+  });
+}
+
+module.exports = { validateOmpSdkReleaseAssets };

package/scripts/omp/runtime.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const {
+  HOST_SUPERVISOR_RELATIVE_PATH,
+  BUN_PACKAGE_NAME,
+  BUN_PLATFORM_PACKAGES,
+  BUN_RUNTIME_VERSION,
+  OMP_NATIVE_PACKAGE_NAME,
+  OMP_NATIVE_PLATFORM_PACKAGES,
+  OMP_PACKAGE_NAME,
+  OMP_SDK_VERSION,
+  REQUIRED_OMP_SDK_SOURCES,
+  SIDECAR_RELATIVE_PATH,
+  assertPackageIdentity,
+  resolveOmpSdkRuntime,
+} = require('./runtime-identities');
+const { validateOmpSdkReleaseAssets } = require('./runtime-release');
+
+module.exports = {
+  HOST_SUPERVISOR_RELATIVE_PATH,
+  BUN_PACKAGE_NAME,
+  BUN_PLATFORM_PACKAGES,
+  BUN_RUNTIME_VERSION,
+  OMP_NATIVE_PACKAGE_NAME,
+  OMP_NATIVE_PLATFORM_PACKAGES,
+  OMP_PACKAGE_NAME,
+  OMP_SDK_VERSION,
+  REQUIRED_OMP_SDK_SOURCES,
+  SIDECAR_RELATIVE_PATH,
+  assertPackageIdentity,
+  resolveOmpSdkRuntime,
+  validateOmpSdkReleaseAssets,
+};

package/scripts/omp/sidecar.ts

@@ -0,0 +1,124 @@
+#!/usr/bin/env bun
+
+import { closeSync, promises as fs } from 'node:fs';
+
+import {
+  OMP_SDK_BACKEND_VERSION,
+  OMP_SDK_BUN_VERSION,
+  OMP_SDK_MAX_REQUEST_BYTES,
+  parseOmpSdkProtocolFrame,
+  type OmpSdkErrorCategory,
+  type OmpSdkErrorCode,
+  type OmpSdkProtocolFrame,
+} from '../../src/agent-cli-provider/omp/sdk-protocol';
+import {
+  executeOmpSdkSidecar,
+  serializeOmpSdkFrame,
+} from '../../src/agent-cli-provider/omp/sdk-sidecar';
+
+function safeError(
+  runId: string,
+  code: OmpSdkErrorCode,
+  category: OmpSdkErrorCategory
+): OmpSdkProtocolFrame {
+  return parseOmpSdkProtocolFrame({
+    protocolVersion: 1,
+    type: 'error',
+    runId,
+    backend: { id: 'omp-sdk', version: OMP_SDK_BACKEND_VERSION },
+    runtime: { name: 'bun', version: OMP_SDK_BUN_VERSION },
+    error: { code, category, retryable: false, redacted: true },
+  });
+}
+
+function runIdFrom(value: unknown): string {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return 'unknown';
+  const runId = (value as Record<string, unknown>).runId;
+  return typeof runId === 'string' &&
+    /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(runId) &&
+    Buffer.byteLength(runId) <= 128
+    ? runId
+    : 'unknown';
+}
+
+async function assertPrivateRequest(requestPath: string): Promise<void> {
+  const stat = await fs.stat(requestPath);
+  if (
+    !stat.isFile() ||
+    stat.size <= 0 ||
+    stat.size > OMP_SDK_MAX_REQUEST_BYTES ||
+    (stat.mode & 0o077) !== 0
+  ) {
+    throw new Error('invalid private request file');
+  }
+}
+
+const originalConsole = {
+  debug: console.debug,
+  error: console.error,
+  info: console.info,
+  log: console.log,
+  warn: console.warn,
+};
+const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+const originalStderrWrite = process.stderr.write.bind(process.stderr);
+process.stdout.write = (() => true) as typeof process.stdout.write;
+process.stderr.write = (() => true) as typeof process.stderr.write;
+console.debug = () => undefined;
+console.error = () => undefined;
+console.info = () => undefined;
+console.log = () => undefined;
+console.warn = () => undefined;
+
+const abortController = new AbortController();
+const abort = (): void => abortController.abort();
+process.once('SIGINT', abort);
+process.once('SIGTERM', abort);
+
+let frame: OmpSdkProtocolFrame;
+let requestPath: string | undefined;
+let request: unknown;
+let removeRequest = false;
+async function main(): Promise<void> {
+  try {
+    if (process.argv.length !== 3) throw new Error('one request path is required');
+    requestPath = process.argv[2];
+    if (requestPath === undefined) throw new Error('request path is required');
+    await assertPrivateRequest(requestPath);
+    removeRequest = true;
+    request = JSON.parse(await fs.readFile(requestPath, 'utf8')) as unknown;
+    frame = await executeOmpSdkSidecar(request, { signal: abortController.signal });
+  } catch {
+    try {
+      closeSync(3);
+    } catch {
+      // The credential channel may already have been consumed and closed.
+    }
+    frame = safeError(runIdFrom(request), 'invalid-request', 'request');
+  }
+
+  if (requestPath !== undefined && removeRequest) {
+    try {
+      await fs.unlink(requestPath);
+    } catch {
+      frame = safeError(runIdFrom(request), 'cleanup-error', 'cleanup');
+    }
+  }
+  process.removeListener('SIGINT', abort);
+  process.removeListener('SIGTERM', abort);
+  if (abortController.signal.aborted) {
+    frame = safeError(runIdFrom(request), 'cancelled', 'cancelled');
+  }
+
+  console.debug = originalConsole.debug;
+  console.error = originalConsole.error;
+  console.info = originalConsole.info;
+  console.log = originalConsole.log;
+  console.warn = originalConsole.warn;
+  process.stdout.write = originalStdoutWrite as typeof process.stdout.write;
+  process.stderr.write = originalStderrWrite as typeof process.stderr.write;
+  originalStdoutWrite(serializeOmpSdkFrame(frame));
+  process.exitCode = frame.type === 'result' ? 0 : 1;
+}
+
+void main();

package/scripts/opcore-introduced-check.js

@@ -190,12 +190,17 @@ function normalizeBaselineRename(baseline, change) {
   fs.mkdirSync(path.dirname(target), { recursive: true });
   fs.renameSync(source, target);
 }
+function applyBaselineDeletion(baseline, change) {
+  if (change.kind !== 'D') return;
+  fs.rmSync(safePath(baseline, change.path), { recursive: true, force: true });
+}
 
 function createRequest(repo, baseline, changes, options) {
   const overlays = [];
   const files = [];
   for (const change of changes) {
     normalizeBaselineRename(baseline, change);
+    applyBaselineDeletion(baseline, change);
     if (change.kind === 'D') {
       continue;
     }

package/scripts/release-preflight.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const https = require('https');
 const { execFileSync } = require('child_process');
+const { REQUIRED_OMP_SDK_SOURCES, validateOmpSdkReleaseAssets } = require('./omp/runtime');
 
 const RELEASE_ORDER = ['patch', 'minor', 'major'];
 const REQUIRED_PLUGINS = [
@@ -218,9 +219,25 @@ async function releaseSignal() {
 async function main() {
   const packageJson = readJson('package.json');
   const pluginNames = validateReleaseConfig(packageJson);
+  const packageLockSource = fs.readFileSync('package-lock.json');
+  const packageLock = JSON.parse(packageLockSource);
+  const packageShrinkwrapSource = fs.existsSync('npm-shrinkwrap.json')
+    ? fs.readFileSync('npm-shrinkwrap.json')
+    : null;
+  const packageShrinkwrap = packageShrinkwrapSource ? JSON.parse(packageShrinkwrapSource) : null;
+  const sourceFiles = REQUIRED_OMP_SDK_SOURCES.filter((sourceFile) => fs.existsSync(sourceFile));
+  const runtimeAssets = validateOmpSdkReleaseAssets(packageJson, packageLock, {
+    packageLockSource,
+    packageShrinkwrap,
+    packageShrinkwrapSource,
+    sourceFiles,
+  });
   const signal = await releaseSignal();
 
   console.log(`Effective release plugins: ${pluginNames.join(', ')}`);
+  console.log(`Published runtime closure SHA-256: ${runtimeAssets.runtimeClosureSha256}`);
+  console.log(`Published shrinkwrap SHA-256: ${runtimeAssets.shrinkwrapSha256}`);
+  console.log(`Supported OMP SDK platforms: ${runtimeAssets.supportedPlatforms.join(', ')}`);
   console.log(`Latest release tag: ${signal.latestTag}`);
   console.log(`Commits since tag: ${signal.commitCount}`);
   if (signal.prTitle) console.log(`Release PR title: ${signal.prTitle}`);
@@ -241,8 +258,10 @@ if (require.main === module) {
 }
 
 module.exports = {
+  REQUIRED_OMP_SDK_SOURCES,
   analyzeMessage,
   maxReleaseType,
   releaseTypeForMessages,
+  validateOmpSdkReleaseAssets,
   validateReleaseConfig,
 };

package/src/agent-cli-provider/adapters/acp.ts

@@ -1,4 +1,5 @@
 import { appendJsonSchemaPrompt } from '../schema';
+import { snapshotDelta } from '../assistant-stream';
 import { contractError } from '../contract-errors';
 import {
   getArray,
@@ -64,10 +65,7 @@ const DEFAULT_LEVEL_MAPPING: Readonly<Record<ModelLevel, LevelModelSpec>> = {
   level3: { rank: 3, model: null },
 };
 
-function detectCliFeatures(
-  meta: AcpAdapterMetadata,
-  helpText?: string | null
-): AcpCliFeatures {
+function detectCliFeatures(meta: AcpAdapterMetadata, helpText?: string | null): AcpCliFeatures {
   const help = helpText ?? '';
   const unknown = !help;
   return {
@@ -183,17 +181,13 @@ function thinkingSnapshots(state: ProviderParserState): Map<string, string> {
   return state.assistantThinkingByMessageId;
 }
 
-function toolCalls(state: ProviderParserState): Map<string, { name: string | null | undefined; input: unknown }> {
+function toolCalls(
+  state: ProviderParserState
+): Map<string, { name: string | null | undefined; input: unknown }> {
   if (!state.toolCalls) state.toolCalls = new Map();
   return state.toolCalls;
 }
 
-function snapshotDelta(previous: string, current: string): string | null {
-  if (!current || previous === current) return null;
-  if (current.startsWith(previous)) return current.slice(previous.length) || null;
-  return current;
-}
-
 function resolveChunkSnapshot(previous: string, chunk: string): string {
   if (!previous) return chunk;
   if (!chunk || previous === chunk) return previous;
@@ -270,7 +264,9 @@ function parseAssistantChunk(
   const textByMessageId = textSnapshots(state);
   const thinkingByMessageId = thinkingSnapshots(state);
   const nextText = options.textTypes ? joinTextBlocks(content, options.textTypes) : null;
-  const nextThinking = options.thinkingTypes ? joinTextBlocks(content, options.thinkingTypes) : null;
+  const nextThinking = options.thinkingTypes
+    ? joinTextBlocks(content, options.thinkingTypes)
+    : null;
 
   const events: OutputEvent[] = [];
   if (nextText !== null) {
@@ -331,8 +327,7 @@ function parseToolCallUpdate(
     update.rawOutput ?? update.output ?? update.partialResult ?? update.content ?? update.result;
   if (content === undefined) return null;
   const status = getOptionalString(update, 'status');
-  const isError =
-    getBoolean(update, 'isError') ?? (status === 'failed' || status === 'cancelled');
+  const isError = getBoolean(update, 'isError') ?? (status === 'failed' || status === 'cancelled');
   return {
     type: 'tool_result',
     toolId,
@@ -361,7 +356,7 @@ function resultFromStopReason(
     type: 'result',
     success,
     result: success ? resultText : null,
-    error: success ? null : explicitError ?? stopReason ?? 'ACP prompt failed.',
+    error: success ? null : (explicitError ?? stopReason ?? 'ACP prompt failed.'),
     ...(state.usage?.inputTokens === undefined ? {} : { inputTokens: state.usage.inputTokens }),
     ...(state.usage?.outputTokens === undefined ? {} : { outputTokens: state.usage.outputTokens }),
     ...(state.usage?.cacheReadInputTokens === undefined
@@ -414,7 +409,10 @@ function parseSessionUpdate(
   return null;
 }
 
-function parseRpcObject(parsed: Record<string, unknown>, state: ProviderParserState): ProviderParseResult {
+function parseRpcObject(
+  parsed: Record<string, unknown>,
+  state: ProviderParserState
+): ProviderParseResult {
   const method = getOptionalString(parsed, 'method');
   if (method === 'session/update') {
     const params = getRecord(parsed, 'params') ?? {};
@@ -430,7 +428,10 @@ function parseRpcObject(parsed: Record<string, unknown>, state: ProviderParserSt
   return null;
 }
 
-function parseEvent(line: string, state: ProviderParserState): OutputEvent | readonly OutputEvent[] | null {
+function parseEvent(
+  line: string,
+  state: ProviderParserState
+): OutputEvent | readonly OutputEvent[] | null {
   const parsed = tryParseJson(line);
   if (!isRecord(parsed)) return null;
   return parseRpcObject(parsed, state);