@parall/agent-core 1.30.0 → 1.32.0

package/src/index.ts

@@ -1,12 +1,23 @@
-export * from "./types.js";
-export * from "./session-state.js";
-export * from "./routing.js";
-export * from "./event-format.js";
-export * from "./prompt-fragments.js";
-export * from "./bridge-workspace.js";
-export * from "./dispatch-adapter.js";
-export { createLogger, childLogger } from "./logger.js";
-export * from "./gateway-base.js";
-export * from "./platform-config.js";
-export { writeSkillFiles, buildSkillReferences, SKILLS } from "./skills/index.js";
-export type { SkillMeta } from "./skills/index.js";
+export * from './provider-config.js';
+export * from './types.js';
+export * from './session-state.js';
+export * from './routing.js';
+export * from './event-format.js';
+export * from './prompt-fragments.js';
+export * from './bridge-workspace.js';
+export * from './dispatch-adapter.js';
+export { createLogger, childLogger } from './logger.js';
+export * from './gateway-base.js';
+export * from './platform-config.js';
+export { writeSkillFiles, buildSkillReferences, SKILLS } from './skills/index.js';
+export type { SkillMeta } from './skills/index.js';
+export {
+  initAgentTelemetry,
+  createOtelLogger,
+  runWithSessionKey,
+  startDispatchSpan,
+  endDispatchSpan,
+  recordDispatchMetric,
+  recordMissingReply,
+} from './telemetry.js';
+export type { TelemetryHandle } from './telemetry.js';

package/src/internal/attachment-input.ts

@@ -1,12 +1,12 @@
-import { execSync } from "node:child_process";
-import { constants, type Dirent, type Stats } from "node:fs";
-import * as fsSync from "node:fs";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import type { DispatchContext, GatewayLogger } from "../dispatch-adapter.js";
-import { formatBytes, renderLocalAttachmentSection } from "../prompt-fragments.js";
-import type { LocalAttachmentResult, PreparedLocalImage } from "../prompt-fragments.js";
-import type { ParallEvent } from "../types.js";
+import { execSync } from 'node:child_process';
+import { constants, type Dirent, type Stats } from 'node:fs';
+import * as fsSync from 'node:fs';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import type { DispatchContext, GatewayLogger } from '../dispatch-adapter.js';
+import { formatBytes, renderLocalAttachmentSection } from '../prompt-fragments.js';
+import type { LocalAttachmentResult, PreparedLocalImage } from '../prompt-fragments.js';
+import type { ParallEvent } from '../types.js';
 
 // Re-export so external consumers (codex-agent, claude-agent) keep importing
 // via the internal/attachment-input subpath. The canonical definition lives
@@ -50,11 +50,11 @@ export const DEFAULT_ATTACHMENT_TTL_MS = 24 * 60 * 60 * 1000;
 export const DEFAULT_MAINTENANCE_COOLDOWN_MS = 60 * 1000;
 
 const SUPPORTED_IMAGE_MIME_TYPES = new Set([
-  "image/png",
-  "image/jpeg",
-  "image/jpg",
-  "image/webp",
-  "image/gif",
+  'image/png',
+  'image/jpeg',
+  'image/jpg',
+  'image/webp',
+  'image/gif',
 ]);
 
 // Process-global state — correct under the current "one gateway per agent"
@@ -72,11 +72,16 @@ export async function prepareLocalImageAttachments(
   opts: LocalAttachmentOptions,
 ): Promise<LocalAttachmentResult> {
   const attachments = event.attachments ?? [];
-  const imageAttachments = attachments.filter((att) => SUPPORTED_IMAGE_MIME_TYPES.has(att.mimeType.toLowerCase()));
+  const imageAttachments = attachments.filter((att) =>
+    SUPPORTED_IMAGE_MIME_TYPES.has(att.mimeType.toLowerCase()),
+  );
   if (imageAttachments.length === 0) return { images: [], notes: [] };
 
   const maxTotalImageBytes = opts.maxTotalImageBytes ?? DEFAULT_MAX_TOTAL_IMAGE_BYTES;
-  const totalDeclaredBytes = imageAttachments.reduce((sum, att) => sum + Math.max(0, att.fileSize), 0);
+  const totalDeclaredBytes = imageAttachments.reduce(
+    (sum, att) => sum + Math.max(0, att.fileSize),
+    0,
+  );
   if (totalDeclaredBytes > maxTotalImageBytes) {
     return {
       images: [],
@@ -107,15 +112,12 @@ export async function prepareLocalImageAttachments(
   // (one pass per cooldown window) and run it off the dispatch path. The
   // cache cap is best-effort, not a hard ceiling — cooldown drift is fine.
   const maintenanceCooldownMs = opts.maintenanceCooldownMs ?? DEFAULT_MAINTENANCE_COOLDOWN_MS;
-  const maintenancePromise = scheduleAttachmentMaintenance(
-    rootDir,
-    {
-      ttlMs: opts.attachmentTtlMs ?? DEFAULT_ATTACHMENT_TTL_MS,
-      maxBytes: opts.maxCacheBytes ?? DEFAULT_ATTACHMENT_CACHE_MAX_BYTES,
-      cooldownMs: maintenanceCooldownMs,
-      log: opts.log,
-    },
-  );
+  const maintenancePromise = scheduleAttachmentMaintenance(rootDir, {
+    ttlMs: opts.attachmentTtlMs ?? DEFAULT_ATTACHMENT_TTL_MS,
+    maxBytes: opts.maxCacheBytes ?? DEFAULT_ATTACHMENT_CACHE_MAX_BYTES,
+    cooldownMs: maintenanceCooldownMs,
+    log: opts.log,
+  });
   if (maintenanceCooldownMs === 0 && maintenancePromise) {
     // Sync-mode for tests that need deterministic prune ordering relative to
     // active-dispatch tracking. Production paths leave this on the background.
@@ -150,7 +152,9 @@ export async function prepareLocalImageAttachments(
         try {
           await fetchFresh();
         } catch (err) {
-          opts.log?.warn?.(`agent-core: failed to prepare local image attachment ${att.id}: ${String(err)}`);
+          opts.log?.warn?.(
+            `agent-core: failed to prepare local image attachment ${att.id}: ${String(err)}`,
+          );
           notes.push(`[Image attachment unavailable locally: prll://${sanitizeMeta(att.id)}]`);
           continue;
         }
@@ -167,7 +171,9 @@ export async function prepareLocalImageAttachments(
         try {
           await fetchFresh();
         } catch (err) {
-          opts.log?.warn?.(`agent-core: failed to re-download corrupted cache for ${att.id}: ${String(err)}`);
+          opts.log?.warn?.(
+            `agent-core: failed to re-download corrupted cache for ${att.id}: ${String(err)}`,
+          );
           notes.push(`[Image attachment unavailable locally: prll://${sanitizeMeta(att.id)}]`);
           continue;
         }
@@ -176,7 +182,9 @@ export async function prepareLocalImageAttachments(
 
       if (!mimeOk) {
         await removeLocalFileIfInside(localPath, rootDir);
-        notes.push(`[Image attachment unavailable locally: prll://${sanitizeMeta(att.id)} (downloaded content does not match ${sanitizeMeta(att.mimeType)})]`);
+        notes.push(
+          `[Image attachment unavailable locally: prll://${sanitizeMeta(att.id)} (downloaded content does not match ${sanitizeMeta(att.mimeType)})]`,
+        );
         continue;
       }
 
@@ -195,10 +203,7 @@ export async function prepareLocalImageAttachments(
   }
 }
 
-export function appendLocalAttachmentRefs(
-  body: string,
-  result: LocalAttachmentResult,
-): string {
+export function appendLocalAttachmentRefs(body: string, result: LocalAttachmentResult): string {
   const section = renderLocalAttachmentSection(result);
   return section ? `${body}\n\n${section}` : body;
 }
@@ -230,7 +235,7 @@ export function pinLocalAttachmentPaths(images: PreparedLocalImage[]): () => voi
 }
 
 function attachmentRootDir(workspaceDir: string): string {
-  return path.join(path.resolve(workspaceDir), ".parall", "attachments");
+  return path.join(path.resolve(workspaceDir), '.parall', 'attachments');
 }
 
 /**
@@ -241,17 +246,17 @@ function attachmentRootDir(workspaceDir: string): string {
  */
 export function ensureLocalAttachmentGitExclude(workingDirectory: string): void {
   try {
-    const rel = execSync("git rev-parse --git-path info/exclude", {
+    const rel = execSync('git rev-parse --git-path info/exclude', {
       cwd: workingDirectory,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
     }).trim();
     const excludePath = path.isAbsolute(rel) ? rel : path.join(workingDirectory, rel);
     fsSync.mkdirSync(path.dirname(excludePath), { recursive: true });
-    const existing = fsSync.existsSync(excludePath) ? fsSync.readFileSync(excludePath, "utf8") : "";
-    if (existing.split(/\r?\n/).some((line) => line.trim() === ".parall/")) return;
-    const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
-    fsSync.appendFileSync(excludePath, `${prefix}.parall/\n`, "utf8");
+    const existing = fsSync.existsSync(excludePath) ? fsSync.readFileSync(excludePath, 'utf8') : '';
+    if (existing.split(/\r?\n/).some((line) => line.trim() === '.parall/')) return;
+    const prefix = existing.length > 0 && !existing.endsWith('\n') ? '\n' : '';
+    fsSync.appendFileSync(excludePath, `${prefix}.parall/\n`, 'utf8');
   } catch {
     // Best-effort only. A missing exclude entry should not block dispatch.
   }
@@ -308,7 +313,7 @@ function scheduleAttachmentMaintenance(
 
 async function ensureAttachmentRootDir(workspaceDir: string): Promise<string> {
   const workspaceRoot = path.resolve(workspaceDir);
-  const parallDir = path.join(workspaceRoot, ".parall");
+  const parallDir = path.join(workspaceRoot, '.parall');
   const rootDir = attachmentRootDir(workspaceRoot);
 
   await fs.mkdir(workspaceRoot, { recursive: true });
@@ -334,17 +339,21 @@ async function ensurePathIsNotSymlink(filePath: string): Promise<void> {
       throw new Error(`refusing to use symlinked attachment path ${filePath}`);
     }
   } catch (err) {
-    if ((err as NodeJS.ErrnoException)?.code === "ENOENT") return;
+    if ((err as NodeJS.ErrnoException)?.code === 'ENOENT') return;
     throw err;
   }
 }
 
 function isPathInside(childPath: string, parentPath: string): boolean {
   const rel = path.relative(parentPath, childPath);
-  return rel === "" || (!!rel && !rel.startsWith("..") && !path.isAbsolute(rel));
+  return rel === '' || (!!rel && !rel.startsWith('..') && !path.isAbsolute(rel));
 }
 
-async function existingUsableFile(filePath: string, expectedSize: number, rootDir: string): Promise<boolean> {
+async function existingUsableFile(
+  filePath: string,
+  expectedSize: number,
+  rootDir: string,
+): Promise<boolean> {
   try {
     const stat = await localFileStatInsideRoot(filePath, rootDir);
     return stat.isFile() && stat.size > 0 && (expectedSize <= 0 || stat.size === expectedSize);
@@ -437,7 +446,11 @@ async function openLocalTempFileInsideRoot(filePath: string, rootDir: string) {
   }
 }
 
-async function assertLocalFileIdentity(filePath: string, rootDir: string, expected: Stats): Promise<void> {
+async function assertLocalFileIdentity(
+  filePath: string,
+  rootDir: string,
+  expected: Stats,
+): Promise<void> {
   const stat = await localFileStatInsideRoot(filePath, rootDir);
   if (!sameFileIdentity(stat, expected)) {
     throw new Error(`attachment file changed during validation: ${filePath}`);
@@ -475,24 +488,26 @@ async function cleanupOldAttachmentFiles(
   }
 
   const cutoff = Date.now() - ttlMs;
-  await Promise.all(entries.map(async (entry) => {
-    if (!entry.isDirectory()) return;
-    const fullPath = path.join(rootDir, entry.name);
-    try {
-      if (preserveDirs?.has(path.resolve(fullPath))) return;
-      // lstat (not stat) for consistency with the symlink-hardened download
-      // path: if a racing local writer swapped the dir entry for a symlink
-      // between readdir and now, we don't want fs.rm to follow it and delete
-      // outside the attachment root.
-      const stat = await fs.lstat(fullPath);
-      if (!stat.isDirectory()) return;
-      if (stat.mtimeMs < cutoff) {
-        await fs.rm(fullPath, { recursive: true, force: true });
+  await Promise.all(
+    entries.map(async (entry) => {
+      if (!entry.isDirectory()) return;
+      const fullPath = path.join(rootDir, entry.name);
+      try {
+        if (preserveDirs?.has(path.resolve(fullPath))) return;
+        // lstat (not stat) for consistency with the symlink-hardened download
+        // path: if a racing local writer swapped the dir entry for a symlink
+        // between readdir and now, we don't want fs.rm to follow it and delete
+        // outside the attachment root.
+        const stat = await fs.lstat(fullPath);
+        if (!stat.isDirectory()) return;
+        if (stat.mtimeMs < cutoff) {
+          await fs.rm(fullPath, { recursive: true, force: true });
+        }
+      } catch (err) {
+        log?.warn?.(`agent-core: failed to clean attachment temp dir ${fullPath}: ${String(err)}`);
       }
-    } catch (err) {
-      log?.warn?.(`agent-core: failed to clean attachment temp dir ${fullPath}: ${String(err)}`);
-    }
-  }));
+    }),
+  );
 }
 
 async function pruneAttachmentCache(
@@ -596,7 +611,7 @@ async function downloadAttachmentToFile(
   } catch {
     throw new Error(`invalid attachment URL`);
   }
-  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+  if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
     throw new Error(`refusing attachment URL with scheme ${parsed.protocol}`);
   }
 
@@ -612,7 +627,7 @@ async function downloadAttachmentToFile(
       throw new Error(`${res.status} ${res.statusText}`);
     }
     // Content-Length is only an early-exit hint; the stream byte counter below is authoritative.
-    const contentLength = parseContentLength(res.headers.get("content-length"));
+    const contentLength = parseContentLength(res.headers.get('content-length'));
     if (contentLength !== undefined && contentLength > maxBytes) {
       throw new Error(`download would exceed ${formatBytes(maxBytes)} remaining turn limit`);
     }
@@ -649,7 +664,7 @@ async function writeResponseToFileWithLimit(
   rootDir: string,
 ): Promise<number> {
   if (maxBytes <= 0) {
-    throw new Error("download would exceed turn limit");
+    throw new Error('download would exceed turn limit');
   }
 
   const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
@@ -716,26 +731,30 @@ function localFileName(attachmentId: string, fileName: string, mimeType: string)
 
 function extensionForMime(mimeType: string): string {
   switch (mimeType.toLowerCase()) {
-    case "image/jpeg":
-    case "image/jpg":
-      return ".jpg";
-    case "image/webp":
-      return ".webp";
-    case "image/gif":
-      return ".gif";
-    case "image/png":
+    case 'image/jpeg':
+    case 'image/jpg':
+      return '.jpg';
+    case 'image/webp':
+      return '.webp';
+    case 'image/gif':
+      return '.gif';
+    case 'image/png':
     default:
-      return ".png";
+      return '.png';
   }
 }
 
 function sanitizePathSegment(value: string): string {
-  const safe = value.replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^_+|_+$/g, "");
-  if (!safe || /^\.+$/.test(safe)) return "attachment";
+  const safe = value.replace(/[^A-Za-z0-9._-]+/g, '_').replace(/^_+|_+$/g, '');
+  if (!safe || /^\.+$/.test(safe)) return 'attachment';
   return safe;
 }
 
-async function downloadedFileMatchesImageMime(filePath: string, mimeType: string, rootDir: string): Promise<boolean> {
+async function downloadedFileMatchesImageMime(
+  filePath: string,
+  mimeType: string,
+  rootDir: string,
+): Promise<boolean> {
   const file = await openLocalFileInsideRoot(filePath, rootDir);
   try {
     const buffer = Buffer.alloc(16);
@@ -748,38 +767,47 @@ async function downloadedFileMatchesImageMime(filePath: string, mimeType: string
 
 function imageHeaderMatches(bytes: Buffer, mimeType: string): boolean {
   switch (mimeType.toLowerCase()) {
-    case "image/png":
-      return bytes.length >= 8
-        && bytes[0] === 0x89
-        && bytes[1] === 0x50
-        && bytes[2] === 0x4e
-        && bytes[3] === 0x47
-        && bytes[4] === 0x0d
-        && bytes[5] === 0x0a
-        && bytes[6] === 0x1a
-        && bytes[7] === 0x0a;
-    case "image/jpeg":
-    case "image/jpg":
+    case 'image/png':
+      return (
+        bytes.length >= 8 &&
+        bytes[0] === 0x89 &&
+        bytes[1] === 0x50 &&
+        bytes[2] === 0x4e &&
+        bytes[3] === 0x47 &&
+        bytes[4] === 0x0d &&
+        bytes[5] === 0x0a &&
+        bytes[6] === 0x1a &&
+        bytes[7] === 0x0a
+      );
+    case 'image/jpeg':
+    case 'image/jpg':
       return bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff;
-    case "image/gif":
-      return bytes.length >= 6
-        && (bytes.subarray(0, 6).toString("ascii") === "GIF87a"
-          || bytes.subarray(0, 6).toString("ascii") === "GIF89a");
-    case "image/webp":
-      return bytes.length >= 12
-        && bytes.subarray(0, 4).toString("ascii") === "RIFF"
-        && bytes.subarray(8, 12).toString("ascii") === "WEBP";
+    case 'image/gif':
+      return (
+        bytes.length >= 6 &&
+        (bytes.subarray(0, 6).toString('ascii') === 'GIF87a' ||
+          bytes.subarray(0, 6).toString('ascii') === 'GIF89a')
+      );
+    case 'image/webp':
+      return (
+        bytes.length >= 12 &&
+        bytes.subarray(0, 4).toString('ascii') === 'RIFF' &&
+        bytes.subarray(8, 12).toString('ascii') === 'WEBP'
+      );
     default:
       return false;
   }
 }
 
 function isAbortError(err: unknown): boolean {
-  return err instanceof DOMException && err.name === "AbortError";
+  return err instanceof DOMException && err.name === 'AbortError';
 }
 
 function sanitizeMeta(value: string): string {
-  return value.replace(/[\r\n]+/g, " ").replace(/[[\]|]/g, " ").trim();
+  return value
+    .replace(/[\r\n]+/g, ' ')
+    .replace(/[[\]|]/g, ' ')
+    .trim();
 }
 
 function parseContentLength(value: string | null): number | undefined {
@@ -788,4 +816,3 @@ function parseContentLength(value: string | null): number | undefined {
   if (!Number.isFinite(n) || n < 0) return undefined;
   return n;
 }
-

package/src/logger.ts

@@ -1,4 +1,4 @@
-import type { GatewayLogger } from "./dispatch-adapter.js";
+import type { GatewayLogger } from './dispatch-adapter.js';
 
 export function createLogger(prefix: string): GatewayLogger {
   return {

package/src/platform-config.ts

@@ -1,7 +1,7 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ParallClient, PlatformConfigResponse } from "@parall/sdk";
-import type { GatewayLogger } from "./dispatch-adapter.js";
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { ParallClient, PlatformConfigResponse } from '@parall/sdk';
+import type { GatewayLogger } from './dispatch-adapter.js';
 
 export interface PlatformDefaults {
   model: string | null;
@@ -19,8 +19,49 @@ export interface PlatformManagementProfile {
   model_management?: string | null;
 }
 
-export function isPlatformManagedProfile(profile: PlatformManagementProfile | null | undefined): boolean {
-  return profile?.machine_id != null || profile?.model_management === "platform";
+export function isPlatformManagedProfile(
+  profile: PlatformManagementProfile | null | undefined,
+): boolean {
+  return profile?.machine_id != null || profile?.model_management === 'platform';
+}
+
+/**
+ * Whether the platform-delivered model should be treated as an operator
+ * OVERRIDE (beats env) rather than a FLOOR (loses to env). True only when the
+ * profile is platform-managed AND not explicitly self-managed: legacy hosted
+ * profiles (model_management=null, resolved to platform server-side) are
+ * overrides; local self agents — whose delivered model is a catalog floor —
+ * are not. Pass the result as `resolveRuntimeModel`'s first argument. Keeping
+ * this derivation in one place avoids drift across the bridges' (re)config
+ * sites where the subtle null-hosted-vs-explicit-self distinction matters.
+ */
+export function isPlatformModelOverride(
+  profile: PlatformManagementProfile | null | undefined,
+): boolean {
+  return isPlatformManagedProfile(profile) && profile?.model_management !== 'self';
+}
+
+/**
+ * Resolve the model a runtime should launch with. Precedence:
+ *   1. platform operator override (only when the agent is platform-managed)
+ *   2. env/runtime config (PRLL_CLAUDE_MODEL / PRLL_CODEX_MODEL)
+ *   3. server-delivered model floor (applies even when model_management=self)
+ *
+ * The floor (3) is what makes self-hosted + Parall-proxy agents work: the
+ * server now delivers `agents.defaults.model` whenever the route is the
+ * catalog-gated Parall proxy, so the CLI never falls back to its built-in
+ * default (which can outrun the catalog and get rejected). Returns null when
+ * no model is resolved, so the bridge omits `--model` and lets the CLI / own
+ * login pick — the correct behavior for runtime_auth / custom routes, where
+ * the server delivers no floor.
+ */
+export function resolveRuntimeModel(
+  isOperatorOverride: boolean,
+  platformModel: string | null,
+  configModel: string | null | undefined,
+): string | undefined {
+  const operatorOverride = isOperatorOverride ? platformModel : null;
+  return operatorOverride ?? configModel ?? platformModel ?? undefined;
 }
 
 interface PlatformModelDef {
@@ -34,7 +75,7 @@ interface CachedPlatformConfig {
   fetchedAt: string;
 }
 
-const CACHE_FILENAME = "parall-platform-config.json";
+const CACHE_FILENAME = 'parall-platform-config.json';
 const SUPPORTED_SCHEMA_VERSION = 1;
 
 function cachePath(stateDir: string): string {
@@ -43,7 +84,7 @@ function cachePath(stateDir: string): string {
 
 function loadCache(stateDir: string): CachedPlatformConfig | null {
   try {
-    const raw = fs.readFileSync(cachePath(stateDir), "utf-8");
+    const raw = fs.readFileSync(cachePath(stateDir), 'utf-8');
     return JSON.parse(raw) as CachedPlatformConfig;
   } catch {
     return null;
@@ -59,7 +100,7 @@ function saveCache(stateDir: string, response: PlatformConfigResponse): void {
   const filePath = cachePath(stateDir);
   const tmpPath = `${filePath}.tmp`;
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(tmpPath, JSON.stringify(cached, null, 2), "utf-8");
+  fs.writeFileSync(tmpPath, JSON.stringify(cached, null, 2), 'utf-8');
   fs.renameSync(tmpPath, filePath);
 }
 
@@ -69,7 +110,7 @@ function runtimeModelName(
   config: Record<string, unknown>,
 ): string | null {
   const runtime = runtimeType?.trim();
-  if (!runtime || runtime === "openclaw") return canonicalModel;
+  if (!runtime || runtime === 'openclaw') return canonicalModel;
 
   const models = (config.models ?? {}) as Record<string, unknown>;
   const providers = (models.providers ?? {}) as Record<string, unknown>;
@@ -78,7 +119,7 @@ function runtimeModelName(
   const match = catalog.find((model) => model.id === canonicalModel);
   const runtimeNames = (match?.runtime_names ?? {}) as Record<string, unknown>;
   const runtimeName = runtimeNames[runtime];
-  return typeof runtimeName === "string" && runtimeName ? runtimeName : null;
+  return typeof runtimeName === 'string' && runtimeName ? runtimeName : null;
 }
 
 function extractDefaults(config: Record<string, unknown>, runtimeType?: string): PlatformDefaults {
@@ -86,13 +127,13 @@ function extractDefaults(config: Record<string, unknown>, runtimeType?: string):
   const defaults = (agents.defaults ?? {}) as Record<string, unknown>;
 
   let model: string | null = null;
-  if (typeof defaults.model === "string" && defaults.model) {
-    const canonicalModel = defaults.model.replace(/^parall\//, "");
+  if (typeof defaults.model === 'string' && defaults.model) {
+    const canonicalModel = defaults.model.replace(/^parall\//, '');
     model = runtimeModelName(canonicalModel, runtimeType, config);
   }
 
   let thinkingEffort: string | null = null;
-  if (typeof defaults.thinking_effort === "string" && defaults.thinking_effort) {
+  if (typeof defaults.thinking_effort === 'string' && defaults.thinking_effort) {
     thinkingEffort = defaults.thinking_effort;
   }
 
@@ -124,7 +165,9 @@ export function createPlatformConfigManager(opts: {
         fresh = await client.getPlatformConfig(cachedVersion);
       } catch (err) {
         if (cached) {
-          log?.warn(`platform config fetch failed, using cached version ${cachedVersion}: ${String(err)}`);
+          log?.warn(
+            `platform config fetch failed, using cached version ${cachedVersion}: ${String(err)}`,
+          );
           return currentDefaults;
         }
         log?.warn(`platform config fetch failed and no cache available: ${String(err)}`);
@@ -136,7 +179,9 @@ export function createPlatformConfigManager(opts: {
       }
 
       if (fresh.schema_version !== undefined && fresh.schema_version > SUPPORTED_SCHEMA_VERSION) {
-        log?.warn(`platform config schema_version ${fresh.schema_version} > supported (${SUPPORTED_SCHEMA_VERSION}), keeping current`);
+        log?.warn(
+          `platform config schema_version ${fresh.schema_version} > supported (${SUPPORTED_SCHEMA_VERSION}), keeping current`,
+        );
         return currentDefaults;
       }