@parall/parall 1.31.0 → 1.32.0

package/src/config-manager.ts

@@ -1,7 +1,7 @@
-import type { ParallClient } from "@parall/sdk";
-import type { PlatformConfigResponse } from "@parall/sdk";
-import * as fs from "node:fs";
-import * as path from "node:path";
+import type { ParallClient } from '@parall/sdk';
+import type { PlatformConfigResponse } from '@parall/sdk';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 
 interface CachedPlatformConfig {
   version: string;
@@ -17,7 +17,7 @@ interface ConfigManagerOpts {
   log?: { info: (msg: string) => void; warn: (msg: string) => void; error: (msg: string) => void };
 }
 
-const CACHE_FILENAME = "parall-platform-config.json";
+const CACHE_FILENAME = 'parall-platform-config.json';
 
 /** Tool names are no longer registered — all operations go through CLI. */
 
@@ -27,7 +27,7 @@ function cachePath(stateDir: string): string {
 
 function loadCachedConfig(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;
@@ -43,13 +43,14 @@ function saveCachedConfig(stateDir: string, config: PlatformConfigResponse): voi
   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);
 }
 
 /**
  * Deep-merge platform config into an existing openclaw.json file.
- * Only overwrites `models.providers.parall` and `agents.defaults` sections;
+ * Only overwrites `models.providers.parall`, `models.providers["parall-anthropic"]`,
+ * and `agents.defaults` sections;
  * all other keys (user customizations, other providers) are preserved.
  */
 function applyToOpenClawConfig(
@@ -59,47 +60,74 @@ function applyToOpenClawConfig(
 ): void {
   let existing: Record<string, unknown> = {};
   try {
-    const raw = fs.readFileSync(configPath, "utf-8");
+    const raw = fs.readFileSync(configPath, 'utf-8');
     existing = JSON.parse(raw) as Record<string, unknown>;
   } catch {
     // File doesn't exist or is invalid — start fresh
   }
 
-  // Deep-merge models.providers.parall (preserve existing fields, overlay platform, inject credentials)
+  // Deep-merge models.providers for all Parall-managed providers
+  // (preserve existing fields, overlay platform, inject credentials).
   const models = (existing.models ?? {}) as Record<string, unknown>;
   const providers = (models.providers ?? {}) as Record<string, unknown>;
-  const existingParall = (providers.parall ?? {}) as Record<string, unknown>;
   const platformModels = (platformConfig.models ?? {}) as Record<string, unknown>;
   const platformProviders = (platformModels.providers ?? {}) as Record<string, unknown>;
-  const platformParall = (platformProviders.parall ?? {}) as Record<string, unknown>;
 
   // Only forward keys OpenClaw's model schema recognizes — its strict Zod
   // validation rejects unrecognized keys and skips the entire config reload.
-  const OPENCLAW_MODEL_KEYS = new Set(["id", "name", "contextWindow", "maxTokens"]);
-  if (Array.isArray(platformParall.models)) {
-    platformParall.models = (platformParall.models as Record<string, unknown>[]).map((m) => {
-      const cleaned: Record<string, unknown> = {};
-      for (const [k, v] of Object.entries(m)) {
-        if (OPENCLAW_MODEL_KEYS.has(k)) {
-          cleaned[k] = v;
+  const OPENCLAW_MODEL_KEYS = new Set(['id', 'name', 'contextWindow', 'maxTokens']);
+
+  // Parall-managed providers: overlay when present in the platform payload.
+  // parall-anthropic is deleted when absent (rollback safety — stale provider
+  // would route to anthropic-messages transport that older servers can't auth).
+  // parall is never deleted — it's the core provider; a malformed/empty
+  // response should not wipe out the agent's only LLM access.
+  const PARALL_MANAGED_PROVIDERS = ['parall', 'parall-anthropic'] as const;
+  for (const providerName of PARALL_MANAGED_PROVIDERS) {
+    const rawProvider = platformProviders[providerName];
+    const platformProvider =
+      rawProvider && typeof rawProvider === 'object' && !Array.isArray(rawProvider)
+        ? (rawProvider as Record<string, unknown>)
+        : null;
+    if (!platformProvider) {
+      if (providerName !== 'parall') delete providers[providerName];
+      continue;
+    }
+
+    if (Array.isArray(platformProvider.models)) {
+      platformProvider.models = (platformProvider.models as Record<string, unknown>[]).map((m) => {
+        const cleaned: Record<string, unknown> = {};
+        for (const [k, v] of Object.entries(m)) {
+          if (OPENCLAW_MODEL_KEYS.has(k)) {
+            cleaned[k] = v;
+          }
         }
-      }
-      return cleaned;
-    });
+        return cleaned;
+      });
+    }
+
+    providers[providerName] = {
+      ...((providers[providerName] ?? {}) as Record<string, unknown>),
+      ...platformProvider,
+      apiKey: credentials.api_key,
+    };
   }
 
-  providers.parall = {
-    ...existingParall,
-    ...platformParall,
-    apiKey: credentials.api_key,
-  };
   models.providers = providers;
   existing.models = models;
 
   // Strip keys OpenClaw doesn't recognize from agents.defaults — platform-only
   // keys like thinking_effort are consumed by agent-core's PlatformConfigManager.
   // See: OpenClaw agents.defaults config schema.
-  const OPENCLAW_AGENTS_DEFAULTS_KEYS = new Set(["model", "compaction", "memorySearch"]);
+  const OPENCLAW_AGENTS_DEFAULTS_KEYS = new Set(['model', 'compaction', 'memorySearch']);
+  // `model` is platform-sourced (delivered only on the catalog-gated Parall
+  // route) — it must NOT be carried over from the existing file, otherwise a
+  // stale `parall/...` model survives a switch to runtime_auth (the server then
+  // omits agents.defaults entirely) and the runtime keeps using the Parall
+  // provider. compaction / memorySearch are operator-tunable, so preserve those
+  // across applies; model is re-sourced from the platform overlay below or
+  // dropped when the platform sends none.
+  const OPENCLAW_PRESERVE_KEYS = new Set(['compaction', 'memorySearch']);
 
   // Unconditionally sanitize existing defaults to self-heal already-poisoned
   // openclaw.json files (e.g. mode=self agents that were poisoned while in
@@ -108,7 +136,7 @@ function applyToOpenClawConfig(
   const existingDefaults = (agents.defaults ?? {}) as Record<string, unknown>;
   const cleanedExisting: Record<string, unknown> = {};
   for (const [k, v] of Object.entries(existingDefaults)) {
-    if (OPENCLAW_AGENTS_DEFAULTS_KEYS.has(k)) {
+    if (OPENCLAW_PRESERVE_KEYS.has(k)) {
       cleanedExisting[k] = v;
     }
   }
@@ -119,7 +147,7 @@ function applyToOpenClawConfig(
   if (
     rawDefaults !== undefined &&
     rawDefaults !== null &&
-    typeof rawDefaults === "object" &&
+    typeof rawDefaults === 'object' &&
     !Array.isArray(rawDefaults)
   ) {
     const raw = rawDefaults as Record<string, unknown>;
@@ -130,6 +158,19 @@ function applyToOpenClawConfig(
     }
   }
 
+  // Bidirectional model rewrite for parall-anthropic. Gate on the fresh
+  // platform payload so rollback self-heals without manual intervention.
+  if (typeof cleanedExisting.model === 'string') {
+    const model = cleanedExisting.model as string;
+    if (platformProviders['parall-anthropic']) {
+      const fwd = model.match(/^parall\/(anthropic\/.+)$/);
+      if (fwd) cleanedExisting.model = `parall-anthropic/${fwd[1]}`;
+    } else {
+      const rev = model.match(/^parall-anthropic\/(anthropic\/.+)$/);
+      if (rev) cleanedExisting.model = `parall/${rev[1]}`;
+    }
+  }
+
   agents.defaults = cleanedExisting;
   existing.agents = agents;
 
@@ -138,7 +179,7 @@ function applyToOpenClawConfig(
   // Atomic write
   const tmpPath = `${configPath}.tmp`;
   fs.mkdirSync(path.dirname(configPath), { recursive: true });
-  fs.writeFileSync(tmpPath, JSON.stringify(existing, null, 2), "utf-8");
+  fs.writeFileSync(tmpPath, JSON.stringify(existing, null, 2), 'utf-8');
   fs.renameSync(tmpPath, configPath);
 }
 
@@ -159,7 +200,9 @@ export async function fetchAndApplyPlatformConfig(opts: ConfigManagerOpts): Prom
   } catch (err) {
     // Fetch failed — fall through to use cache
     if (cached) {
-      log?.warn(`platform config fetch failed, using cached version ${cached.version}: ${String(err)}`);
+      log?.warn(
+        `platform config fetch failed, using cached version ${cached.version}: ${String(err)}`,
+      );
       applyToOpenClawConfig(configPath, cached.config, credentials);
       return;
     }
@@ -170,7 +213,7 @@ export async function fetchAndApplyPlatformConfig(opts: ConfigManagerOpts): Prom
 
   // 3. 304 — config unchanged
   if (fresh === null) {
-    log?.info("platform config unchanged (304)");
+    log?.info('platform config unchanged (304)');
     if (cached) {
       applyToOpenClawConfig(configPath, cached.config, credentials);
     }
@@ -180,7 +223,9 @@ export async function fetchAndApplyPlatformConfig(opts: ConfigManagerOpts): Prom
   // 4. Validate schema compatibility before accepting
   const SUPPORTED_SCHEMA_VERSION = 1;
   if (fresh.schema_version !== undefined && fresh.schema_version > SUPPORTED_SCHEMA_VERSION) {
-    log?.error(`platform config schema_version ${fresh.schema_version} is newer than supported (${SUPPORTED_SCHEMA_VERSION}), keeping current config`);
+    log?.error(
+      `platform config schema_version ${fresh.schema_version} is newer than supported (${SUPPORTED_SCHEMA_VERSION}), keeping current config`,
+    );
     if (cached) {
       applyToOpenClawConfig(configPath, cached.config, credentials);
     }

package/src/fork.ts

@@ -7,10 +7,10 @@
 // branch point, the fork falls back to the current on-disk leaf — which
 // may include partial in-flight state.
 
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as crypto from "node:crypto";
-import { CURRENT_SESSION_VERSION, SessionManager } from "./oc-session.js";
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { CURRENT_SESSION_VERSION, SessionManager } from './oc-session.js';
 
 export type ForkSessionResult = {
   sessionKey: string;
@@ -25,26 +25,33 @@ type SessionStoreEntry = {
 };
 
 function readStoreEntry(sessionsDir: string, sessionKey: string): SessionStoreEntry | null {
-  const storeFile = path.join(sessionsDir, "sessions.json");
+  const storeFile = path.join(sessionsDir, 'sessions.json');
   try {
-    const store = JSON.parse(fs.readFileSync(storeFile, "utf-8")) as Record<string, SessionStoreEntry>;
+    const store = JSON.parse(fs.readFileSync(storeFile, 'utf-8')) as Record<
+      string,
+      SessionStoreEntry
+    >;
     return store[sessionKey] ?? store[sessionKey.toLowerCase()] ?? null;
   } catch {
     return null;
   }
 }
 
-function writeStoreEntry(sessionsDir: string, sessionKey: string, entry: SessionStoreEntry): boolean {
-  const storeFile = path.join(sessionsDir, "sessions.json");
+function writeStoreEntry(
+  sessionsDir: string,
+  sessionKey: string,
+  entry: SessionStoreEntry,
+): boolean {
+  const storeFile = path.join(sessionsDir, 'sessions.json');
   try {
     let store: Record<string, SessionStoreEntry> = {};
     try {
-      store = JSON.parse(fs.readFileSync(storeFile, "utf-8"));
+      store = JSON.parse(fs.readFileSync(storeFile, 'utf-8'));
     } catch {
       // Empty or missing — start fresh.
     }
     store[sessionKey.toLowerCase()] = entry;
-    fs.writeFileSync(storeFile, JSON.stringify(store, null, 2), { encoding: "utf-8" });
+    fs.writeFileSync(storeFile, JSON.stringify(store, null, 2), { encoding: 'utf-8' });
     return true;
   } catch {
     return false;
@@ -52,12 +59,12 @@ function writeStoreEntry(sessionsDir: string, sessionKey: string, entry: Session
 }
 
 function deleteStoreEntry(sessionsDir: string, sessionKey: string): void {
-  const storeFile = path.join(sessionsDir, "sessions.json");
+  const storeFile = path.join(sessionsDir, 'sessions.json');
   try {
-    const store = JSON.parse(fs.readFileSync(storeFile, "utf-8")) as Record<string, unknown>;
+    const store = JSON.parse(fs.readFileSync(storeFile, 'utf-8')) as Record<string, unknown>;
     delete store[sessionKey];
     delete store[sessionKey.toLowerCase()];
-    fs.writeFileSync(storeFile, JSON.stringify(store, null, 2), { encoding: "utf-8" });
+    fs.writeFileSync(storeFile, JSON.stringify(store, null, 2), { encoding: 'utf-8' });
   } catch {
     // Best-effort cleanup.
   }
@@ -83,7 +90,7 @@ export function resolveTranscriptFile(sessionsDir: string, sessionKey: string):
 
   try {
     const files = fs.readdirSync(sessionsDir);
-    const match = files.find((file) => file.includes(entry.sessionId!) && file.endsWith(".jsonl"));
+    const match = files.find((file) => file.includes(entry.sessionId!) && file.endsWith('.jsonl'));
     return match ? path.join(sessionsDir, match) : null;
   } catch {
     return null;
@@ -139,13 +146,10 @@ export function forkOrchestratorSession(opts: {
       // Fallback: no leaf node — create a header-only fork file manually.
       sessionId = crypto.randomUUID();
       const timestamp = new Date().toISOString();
-      const fileTimestamp = timestamp.replace(/[:.]/g, "-");
-      sessionFile = path.join(
-        manager.getSessionDir(),
-        `${fileTimestamp}_${sessionId}.jsonl`,
-      );
+      const fileTimestamp = timestamp.replace(/[:.]/g, '-');
+      sessionFile = path.join(manager.getSessionDir(), `${fileTimestamp}_${sessionId}.jsonl`);
       const header = {
-        type: "session",
+        type: 'session',
         version: CURRENT_SESSION_VERSION,
         id: sessionId,
         timestamp,
@@ -153,9 +157,9 @@ export function forkOrchestratorSession(opts: {
         parentSession: transcriptFile,
       };
       fs.writeFileSync(sessionFile, `${JSON.stringify(header)}\n`, {
-        encoding: "utf-8",
+        encoding: 'utf-8',
         mode: 0o600,
-        flag: "wx",
+        flag: 'wx',
       });
     }