@foldrun/core 2.4.0 → 2.6.0

package/src/provider-health.ts

@@ -21,7 +21,7 @@
 import { accountModelBlock } from "./model-credential.ts";
 import fs from "node:fs";
 import path from "node:path";
-import matter from "gray-matter";
+import { configMatter } from "./matter.ts";
 import { getSecret } from "./secrets.ts";
 import { noteSecretUse, healthKey } from "./secret-health.ts";
 import { accountDir, workspaceDir, listWorkspaces, listAgents, parseProvider, type ProviderSpec } from "./store.ts";
@@ -205,7 +205,7 @@ function cheapestModel(spec: ProviderSpec): string {
 
 function frontmatterOf(file: string): Record<string, unknown> {
   try {
-    return (matter(fs.readFileSync(file, "utf8")).data ?? {}) as Record<string, unknown>;
+    return (configMatter(fs.readFileSync(file, "utf8")).data ?? {}) as Record<string, unknown>;
   } catch {
     return {};
   }

package/src/providers.ts

@@ -54,6 +54,11 @@ export interface ProviderPreset {
    *  Off means the translator drops thinking rather than send a parameter
    *  the endpoint would reject. */
   reasoningEffort?: boolean;
+  /** Whether the endpoint takes `prompt_cache_key` — a hint that requests
+   *  with the same key share a prompt prefix, so its cache can be routed
+   *  to. Only set where the parameter is documented; an endpoint that does
+   *  not know it may refuse the request. */
+  promptCacheKey?: boolean;
   /** One line a person should read before relying on it. */
   note?: string;
   /** A tool loop was driven through this endpoint from this runtime. */
@@ -427,7 +432,7 @@ export const PROVIDERS: readonly ProviderPreset[] = [
 
   // ------------------------------------------- Chat-Completions, translated
   { name: "openai", title: "OpenAI", format: "openai", baseUrl: "https://api.openai.com/v1", auth: "bearer", verified: true,
-    maxTokensParam: "max_completion_tokens", reasoningEffort: true,
+    maxTokensParam: "max_completion_tokens", reasoningEffort: true, promptCacheKey: true,
     note: "Reached over Chat Completions, which OpenAI keeps supporting; the Responses API is not spoken here, so a reasoning model's reasoning does not carry across tool calls." , search: "openai" },
   { name: "gemini", title: "Google Gemini", format: "openai", baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai", auth: "bearer",
     note: "Google's OpenAI-compatible route. Unknown parameters are ignored silently; reasoning cannot be switched off on the newest models." },
@@ -435,7 +440,7 @@ export const PROVIDERS: readonly ProviderPreset[] = [
     maxTokensParam: "max_completion_tokens", reasoningEffort: true },
   { name: "groq", title: "Groq", format: "openai", baseUrl: "https://api.groq.com/openai/v1", auth: "bearer",
     maxTokensParam: "max_completion_tokens", reasoningEffort: true },
-  { name: "mistral", title: "Mistral", format: "openai", baseUrl: "https://api.mistral.ai/v1", auth: "bearer" },
+  { name: "mistral", title: "Mistral", format: "openai", baseUrl: "https://api.mistral.ai/v1", auth: "bearer", promptCacheKey: true },
   { name: "together", title: "Together AI", format: "openai", baseUrl: "https://api.together.ai/v1", auth: "bearer" },
   { name: "cerebras", title: "Cerebras", format: "openai", baseUrl: "https://api.cerebras.ai/v1", auth: "bearer",
     maxTokensParam: "max_completion_tokens", reasoningEffort: true },

package/src/run-container.ts

@@ -18,6 +18,7 @@
 // The runner image bundles @foldrun/core itself, so the driver runs the same
 // executeStep the server would — one implementation, two homes.
 
+import type { PeerInfo } from "./operator.ts";
 import { isHookRecord, type HookRecord } from "./hooks.ts";
 import fs from "node:fs";
 import os from "node:os";
@@ -25,9 +26,9 @@ import path from "node:path";
 import crypto from "node:crypto";
 import { spawn, spawnSync } from "node:child_process";
 import type { McpServerConfig } from "@anthropic-ai/claude-agent-sdk";
-import { isPlatformPath, type ApiSpec, type Effort } from "./store.ts";
+import { CAPTURE_CAP, isPlatformPath, type ApiSpec, type Effort, type ModelCall } from "./store.ts";
 import { divertedSummary, isDivertedPath, overlayTestWrites } from "./test-mode.ts";
-import type { EventExtra, ExecUsage } from "./step-exec.ts";
+import type { CallIo, EventExtra, ExecUsage } from "./step-exec.ts";
 import type { TokenPrice } from "./catalog.ts";
 import { isFileValue, fileContent } from "./secrets.ts";
 import { safeTenantSegment, systemInstallSh, SYSTEM_FROM_INPUT_SH, INSTALL_SOCKET, type RuntimeSpec } from "./runtime.ts";
@@ -72,11 +73,16 @@ export interface ContainerStepInput {
   budgetNote?: string;
   price?: TokenPrice | null;
   verify?: string;
+  /** The model `verify: judge:` grades with (the workspace's `judge:`). */
+  judgeModel?: string;
+  judgeEffort?: string;
   /** `output: json` — checked inside, where the reply is. */
   output?: "json";
   /** `schema:` and `max_turns:`, resolved host-side — see ExecOptions. */
   schema?: Record<string, unknown> | boolean;
   maxTurns?: number;
+  /** `capture:` resolved host-side (FOL-54 step 4) — see ExecOptions. */
+  capture?: "metadata" | "full";
   /** `limits:` resolved host-side, and the SDK-name → foldrun-name map the
    *  count reads (limits.ts) — enforced in the pod by the same hook. */
   limits?: Record<string, number>;
@@ -93,6 +99,10 @@ export interface ContainerStepInput {
   desks?: RunDigest[];
   /** tools: [ask] — ask_person, and how long it may wait for an answer. */
   ask?: { timeoutSec: number };
+  /** tools: [peers] — this step's agent and the other steps of its
+   *  parallel group, gathered host-side at launch. The driver rebuilds the
+   *  colleagues' tools in here over the lease's /peers door. */
+  peers?: { self: string; siblings: PeerInfo[] };
   /** A Chat-Completions provider: the driver starts the runtime's translator
    *  on loopback and points the SDK at it. Null or absent: the env's
    *  ANTHROPIC_BASE_URL is spoken to directly. */
@@ -549,7 +559,8 @@ export function runtimeCacheMount(
 
 // ---------- the runner image ----------
 
-const DRIVER = `// The runner container's entrypoint. Reads one step, executes it with the
+/** The runner container's entrypoint, as JS text: written into the image as driver.mjs, so it must be plain JS — a TypeScript cast here broke every step on v2026.10.21.5 (tests/run-container.test.ts checks it). */
+export const DRIVER = `// The runner container's entrypoint. Reads one step, executes it with the
 // same core the server uses, speaks JSONL on stdout, exits.
 import fs from "node:fs";
 const input = JSON.parse(fs.readFileSync("/opt/runner/job/input.json", "utf8"));
@@ -614,7 +625,7 @@ try {
   const { buildScriptTools } = await import("@foldrun/core/script-tools");
   const { buildConsultTools } = await import("@foldrun/core/agent-tools");
   const { buildSearchTools, buildHistoryTools, buildDeskTools } = await import("@foldrun/core/context-tools");
-  const { httpChannel, buildAskTool, inboxReader } = await import("@foldrun/core/operator");
+  const { httpChannel, buildAskTool, buildPeerTools, inboxReader } = await import("@foldrun/core/operator");
   const { startTranslator } = await import("@foldrun/core/translator");
   const { prepareRuntime } = await import("@foldrun/core/runtime");
   const { materializeFileSecrets } = await import("@foldrun/core/secret-files");
@@ -678,11 +689,18 @@ try {
   // A long result is kept in a file only when the agent can read it back.
   // (tool-output.ts canReadBack, inlined: the driver imports core by subpath.)
   const keepIn = { dir: agentDir, readable: () => (input.allowed ?? []).some((t) => t === "Read" || t === "Grep") };
-  const api = buildApiTools("", input.apis, undefined, { env, missing: [] }, keepIn);
+  // A declared secret named like a model variable crosses as
+  // FOLDRUN_DECLARED_<NAME> (runner.ts, FOL-19): the model keeps its own
+  // settings, and the agent's API and script tools and verify: get the value
+  // back under the name it declared. Built here, after the runtime and any
+  // mid-step install have added their paths to env.
+  const toolEnv = { ...env };
+  for (const [k, v] of Object.entries(env)) if (k.startsWith("FOLDRUN_DECLARED_")) toolEnv[k.slice("FOLDRUN_DECLARED_".length)] = v;
+  const api = buildApiTools("", input.apis, undefined, { env: toolEnv, missing: [] }, keepIn);
   const script = buildScriptTools(
     agentDir,
     input.scripts,
-    { ...env, ...runtime.env },
+    toolEnv,
     "/library/scripts",
     runtime.interpreters,
     null,
@@ -705,6 +723,7 @@ try {
   // ask_person when tools: [ask], and the run's inbox after every tool call.
   const channel = httpChannel(env.FOLDRUN_EGRESS);
   const ask = input.ask ? buildAskTool({ channel, timeoutSec: input.ask.timeoutSec, emit }) : { server: null };
+  const peers = input.peers ? buildPeerTools({ channel, self: input.peers.self, siblings: input.peers.siblings, emit }) : { server: null };
   const inbox = channel ? inboxReader(channel, emit) : undefined;
 
   mark("tools");
@@ -726,6 +745,7 @@ try {
       ...(history.server ? { foldrun_history: history.server } : {}),
       ...(desks.server ? { foldrun_desks: desks.server } : {}),
       ...(ask.server ? { foldrun_ask: ask.server } : {}),
+      ...(peers.server ? { foldrun_peers: peers.server } : {}),
       ...(install.server ? { foldrun_install: install.server } : {}),
       ...input.mcpServers,
     },
@@ -737,10 +757,13 @@ try {
     budgetNote: input.budgetNote,
     price: input.price,
     verify: input.verify,
-    verifyEnv: env,
+    verifyEnv: toolEnv,
+    ...(typeof input.judgeModel === "string" ? { judgeModel: input.judgeModel } : {}),
+    ...(typeof input.judgeEffort === "string" ? { judgeEffort: input.judgeEffort } : {}),
     output: input.output,
     schema: input.schema,
     maxTurns: input.maxTurns,
+    ...(input.capture === "metadata" || input.capture === "full" ? { capture: input.capture } : {}),
     ...(input.limits && Object.keys(input.limits).length ? { limits: input.limits, toolOwners: input.toolOwners ?? {} } : {}),
     ...(input.hookNames?.length ? { hookNames: input.hookNames, hookBase: input.hookBase ?? {} } : {}),
     // Slim browsing: the platform put this step on the slim image to browse
@@ -1190,9 +1213,47 @@ export function buildFailureSummary(log: string, opts: { tail?: number; maxLines
 
 // ---------- running one step ----------
 
+const num = (v: unknown) => (typeof v === "number" && Number.isFinite(v) && v >= 0 ? v : 0);
+
+/** A tool call's content from the sandbox, as far as it is well-formed and
+ *  within the cap; anything else is dropped (FOL-54 step 4). */
+function callIoOf(v: unknown): CallIo | null {
+  if (!v || typeof v !== "object") return null;
+  const o = v as Record<string, unknown>;
+  // The cap plus the slack the runner masks inside before it cuts.
+  const text = (x: unknown) => (typeof x === "string" ? x.slice(0, CAPTURE_CAP + 4096) : undefined);
+  const io: CallIo = {
+    ...(text(o.input) !== undefined ? { input: text(o.input) } : {}),
+    ...(text(o.output) !== undefined ? { output: text(o.output) } : {}),
+    ...(typeof o.inputChars === "number" ? { inputChars: num(o.inputChars) } : {}),
+    ...(typeof o.outputChars === "number" ? { outputChars: num(o.outputChars) } : {}),
+    ...(o.truncated === true ? { truncated: true } : {}),
+  };
+  return io.input !== undefined || io.output !== undefined ? io : null;
+}
+
+/** One model call from the sandbox, well-formed or dropped. */
+function modelCallOf(v: unknown): ModelCall | null {
+  if (!v || typeof v !== "object") return null;
+  const o = v as Record<string, unknown>;
+  const t = (o.tokens ?? {}) as Record<string, unknown>;
+  if (typeof o.id !== "string" || !o.id || o.id.length > 128 || typeof o.at !== "string" || Number.isNaN(Date.parse(o.at))) return null;
+  return {
+    id: o.id,
+    n: Math.max(1, Math.floor(num(o.n))),
+    at: o.at,
+    ms: num(o.ms),
+    ...(typeof o.model === "string" ? { model: o.model.slice(0, 128) } : {}),
+    ...(typeof o.stop === "string" ? { stop: o.stop.slice(0, 64) } : {}),
+    tokens: { input: num(t.input), output: num(t.output), cacheRead: num(t.cacheRead), cacheWrite: num(t.cacheWrite) },
+    tools: Math.floor(num(o.tools)),
+    ...(typeof o.subagent === "string" && /^[a-z0-9-]{1,64}$/.test(o.subagent) ? { subagent: o.subagent } : {}),
+  };
+}
+
 export function parseDriverLine(
   line: string,
-): { e: "event"; type: "text" | "tool" | "info" | "error"; text: string; call?: string; ms?: number; err?: boolean; bytes?: number; operator?: OperatorEvent; subagent?: string; check?: boolean; hook?: HookRecord } | { e: "done" } & ContainerStepOutcome | null {
+): { e: "event"; type: "text" | "tool" | "info" | "error"; text: string; call?: string; ms?: number; err?: boolean; bytes?: number; operator?: OperatorEvent; subagent?: string; check?: boolean; hook?: HookRecord; io?: CallIo; turn?: ModelCall; inCall?: string; responding?: true } | { e: "done" } & ContainerStepOutcome | null {
   const trimmed = line.trim();
   if (!trimmed.startsWith("{")) return null;
   try {
@@ -1210,6 +1271,10 @@ export function parseDriverLine(
         ...(typeof parsed.subagent === "string" && /^[a-z0-9-]{1,64}$/.test(parsed.subagent) ? { subagent: parsed.subagent } : {}),
         ...(parsed.check === true ? { check: true } : {}),
         ...(isHookRecord(parsed.hook) ? { hook: parsed.hook } : {}),
+        ...(callIoOf(parsed.io) ? { io: callIoOf(parsed.io)! } : {}),
+        ...(typeof parsed.inCall === "string" && parsed.inCall.length <= 128 ? { inCall: parsed.inCall } : {}),
+        ...(modelCallOf(parsed.turn) ? { turn: modelCallOf(parsed.turn)! } : {}),
+        ...(parsed.responding === true ? { responding: true as const } : {}),
       };
     }
     if (parsed.e === "done") {
@@ -1299,6 +1364,10 @@ export interface RunInContainerArgs {
    *  without it, "stop" could only mean "stop after this step", and a
    *  browser step has fifteen minutes left to spend. */
   runId?: string;
+  /** Whether a person has stopped the run, read from the record. A step that
+   *  waits for room before its sandbox exists asks this, since there is no
+   *  sandbox yet for the stop to destroy. */
+  stopRequested?: () => boolean;
   /** The reservation class — which limits this step's sandbox holds. */
   size?: "small" | "large" | "heavy";
   /** Re-attach to a sandbox a previous driver started, instead of creating