@oh-my-pi/pi-coding-agent 15.10.0 → 15.10.2

package/src/eval/__tests__/llm-bridge.test.ts

@@ -4,6 +4,7 @@ import type { Api, AssistantMessage, Model } from "@oh-my-pi/pi-ai";
 import * as ai from "@oh-my-pi/pi-ai";
 import { Effort } from "@oh-my-pi/pi-ai";
 import { TempDir } from "@oh-my-pi/pi-utils";
+import { $ } from "bun";
 import type { ModelRegistry } from "../../config/model-registry";
 import { Settings } from "../../config/settings";
 import type { ToolSession } from "../../tools";
@@ -13,7 +14,7 @@ import { IdleTimeout } from "../idle-timeout";
 import { disposeAllVmContexts } from "../js/context-manager";
 import { executeJs } from "../js/executor";
 import { runEvalLlm } from "../llm-bridge";
-import { disposeAllKernelSessions, executePython } from "../py/executor";
+import { disposeAllKernelSessions, type PythonResult } from "../py/executor";
 
 function makeModel(provider: string, id: string, extra: Partial<Model<Api>> = {}): Model<Api> {
 	return {
@@ -57,6 +58,7 @@ function makeSession(opts: SessionOptions = {}): ToolSession {
 	const modelRegistry = {
 		getAvailable: () => opts.available ?? [SMOL, DEFAULT, SLOW],
 		getApiKey: async () => (opts.apiKey === undefined ? "test-key" : opts.apiKey),
+		resolver: () => async () => (opts.apiKey === undefined ? "test-key" : opts.apiKey),
 	} as unknown as ModelRegistry;
 	return {
 		settings,
@@ -96,6 +98,77 @@ function assistant(opts: {
 	};
 }
 
+async function runPythonLlmInSubprocess(options: { structured: boolean; tempDir: TempDir }): Promise<PythonResult> {
+	const repoRoot = path.resolve(import.meta.dir, "../../../..");
+	const scriptPath = path.join(options.tempDir.path(), "run-python-llm.ts");
+	const resultPath = path.join(options.tempDir.path(), "python-llm-result.json");
+	const aiPath = path.resolve(import.meta.dir, "../../../../ai/src/index.ts");
+	const executorPath = path.resolve(import.meta.dir, "../py/executor.ts");
+	const settingsPath = path.resolve(import.meta.dir, "../../config/settings.ts");
+	const code = options.structured
+		? 'import json\nprint(json.dumps(llm("hi", schema={"type": "object"})))'
+		: 'print(llm("hi", model="smol"))';
+	const responseContent = options.structured
+		? '[{ type: "toolCall", id: "tc-1", name: "respond", arguments: { ok: true } }]'
+		: '[{ type: "text", text: "hello from python" }]';
+	await Bun.write(
+		scriptPath,
+		`
+import { vi } from "bun:test";
+import * as ai from ${JSON.stringify(aiPath)};
+import { executePython } from ${JSON.stringify(executorPath)};
+import { Settings } from ${JSON.stringify(settingsPath)};
+
+const SMOL = {
+	id: "smol",
+	name: "smol",
+	api: "openai-responses",
+	provider: "p",
+	baseUrl: "https://example.test/v1",
+	reasoning: false,
+	input: ["text"],
+	cost: { input: 1, output: 1, cacheRead: 0, cacheWrite: 1 },
+	contextWindow: 128000,
+	maxTokens: 4096,
+};
+const settings = Settings.isolated({ "async.enabled": false, "task.isolation.mode": "none" });
+settings.setModelRole("smol", "p/smol");
+settings.setModelRole("slow", "p/slow");
+const session = {
+	settings,
+	modelRegistry: {
+		getAvailable: () => [SMOL],
+		getApiKey: async () => "test-key",
+		resolver: () => async () => "test-key",
+	},
+	getActiveModelString: () => "p/smol",
+};
+vi.spyOn(ai, "completeSimple").mockResolvedValue({
+	role: "assistant",
+	api: "openai-responses",
+	provider: "p",
+	model: "smol",
+	stopReason: "stop",
+	content: ${responseContent},
+});
+const result = await executePython(${JSON.stringify(code)}, {
+	cwd: ${JSON.stringify(options.tempDir.path())},
+	sessionId: ${JSON.stringify(`py-llm:${options.structured ? "struct" : "plain"}`)},
+	sessionFile: ${JSON.stringify(path.join(options.tempDir.path(), "session.jsonl"))},
+	toolSession: session,
+	kernelMode: "per-call",
+});
+await Bun.write(${JSON.stringify(resultPath)}, JSON.stringify(result));
+process.exit(0);
+`,
+	);
+	const child = await $`bun ${scriptPath}`.cwd(repoRoot).quiet().nothrow();
+	const stdout = child.stdout.toString();
+	const stderr = child.stderr.toString();
+	if (child.exitCode !== 0) throw new Error(stderr || stdout || `Python llm subprocess exited with ${child.exitCode}`);
+	return (await Bun.file(resultPath).json()) as PythonResult;
+}
+
 describe("runEvalLlm", () => {
 	afterEach(() => {
 		vi.restoreAllMocks();
@@ -133,6 +206,26 @@ describe("runEvalLlm", () => {
 		expect(result.details).toEqual({ model: "p/smol", tier: "smol", structured: false });
 	});
 
+	it("supplies a non-empty systemPrompt when system is omitted (codex 'Instructions are required' guard)", async () => {
+		// The openai-codex Responses transformer drops `instructions` when no
+		// system prompt is provided, and the remote endpoint then 400s with
+		// "Instructions are required". runEvalLlm must always carry a non-empty
+		// systemPrompt so `llm("…")` without a `system` argument works.
+		const spy = vi.spyOn(ai, "completeSimple").mockResolvedValue(assistant({ text: "ok" }));
+		await runEvalLlm({ prompt: "q", model: "smol" }, { session: makeSession() });
+		const ctx = spy.mock.calls[0]?.[1] as { systemPrompt?: string[] };
+		expect(ctx.systemPrompt).toBeDefined();
+		expect(ctx.systemPrompt?.length).toBeGreaterThan(0);
+		expect(ctx.systemPrompt?.[0]).toMatch(/.+/);
+	});
+
+	it("honors an explicit system prompt instead of overriding it", async () => {
+		const spy = vi.spyOn(ai, "completeSimple").mockResolvedValue(assistant({ text: "ok" }));
+		await runEvalLlm({ prompt: "q", model: "smol", system: "Be terse." }, { session: makeSession() });
+		const ctx = spy.mock.calls[0]?.[1] as { systemPrompt?: string[] };
+		expect(ctx.systemPrompt).toEqual(["Be terse."]);
+	});
+
 	it("forces a respond tool call and returns its arguments in structured mode", async () => {
 		const spy = vi
 			.spyOn(ai, "completeSimple")
@@ -290,38 +383,24 @@ describe("llm() through eval runtimes", () => {
 	});
 
 	it("exposes llm() in the Python runtime", async () => {
-		using tempDir = TempDir.createSync("@omp-eval-llm-py-");
-		const sessionFile = path.join(tempDir.path(), "session.jsonl");
-		const sessionId = `py-llm:${crypto.randomUUID()}`;
-		vi.spyOn(ai, "completeSimple").mockResolvedValue(assistant({ text: "hello from python" }));
-
-		const result = await executePython('print(llm("hi", model="smol"))', {
-			cwd: tempDir.path(),
-			sessionId,
-			sessionFile,
-			toolSession: makeSession(),
-		});
-
-		expect(result.exitCode).toBe(0);
-		expect(result.output.trim()).toBe("hello from python");
+		const tempDir = TempDir.createSync("@omp-eval-llm-py-");
+		try {
+			const result = await runPythonLlmInSubprocess({ structured: false, tempDir });
+			expect(result.exitCode).toBe(0);
+			expect(result.output.trim()).toBe("hello from python");
+		} finally {
+			tempDir.removeSync();
+		}
 	});
 
 	it("parses structured llm() output in the Python runtime", async () => {
-		using tempDir = TempDir.createSync("@omp-eval-llm-py-struct-");
-		const sessionFile = path.join(tempDir.path(), "session.jsonl");
-		const sessionId = `py-llm-struct:${crypto.randomUUID()}`;
-		vi.spyOn(ai, "completeSimple").mockResolvedValue(
-			assistant({ toolCall: { name: "respond", arguments: { ok: true } } }),
-		);
-
-		const result = await executePython('import json\nprint(json.dumps(llm("hi", schema={"type": "object"})))', {
-			cwd: tempDir.path(),
-			sessionId,
-			sessionFile,
-			toolSession: makeSession(),
-		});
-
-		expect(result.exitCode).toBe(0);
-		expect(JSON.parse(result.output.trim())).toEqual({ ok: true });
+		const tempDir = TempDir.createSync("@omp-eval-llm-py-struct-");
+		try {
+			const result = await runPythonLlmInSubprocess({ structured: true, tempDir });
+			expect(result.exitCode).toBe(0);
+			expect(JSON.parse(result.output.trim())).toEqual({ ok: true });
+		} finally {
+			tempDir.removeSync();
+		}
 	});
 });

package/src/eval/js/context-manager.ts

@@ -52,8 +52,14 @@ interface JsSession {
 
 const sessions = new Map<string, JsSession>();
 const startingSessions = new Map<string, Promise<JsSession>>();
-const resettingSessions = new Set<string>();
-const READY_TIMEOUT_MS_DEFAULT = 5_000;
+const resettingSessions = new Map<string, Promise<void>>();
+// Worker startup (module-graph import + WorkerCore construction) is infrastructure
+// cost, not user compute. Floor it independently of Bun's 5s default per-test timeout
+// so a slow cold-start under load isn't aborted mid-init — terminating a still-
+// initializing Bun worker triggers the same kind of terminate-race that motivates
+// avoiding `vm.runInContext` (see shared/indirect-eval.ts), here surfacing as a
+// SIGILL/SIGSEGV. Callers that pass a larger per-cell budget still dominate.
+const WORKER_INIT_TIMEOUT_MS = 15_000;
 
 export async function executeInVmContext(options: {
 	sessionKey: string;
@@ -67,17 +73,28 @@ export async function executeInVmContext(options: {
 	runState: VmRunState;
 }): Promise<{ value: unknown }> {
 	if (options.reset) {
-		if (resettingSessions.has(options.sessionKey)) {
-			throw new ToolError("JS context reset already in progress");
-		}
-		resettingSessions.add(options.sessionKey);
-		try {
-			await resetVmContext(options.sessionKey);
-		} finally {
-			resettingSessions.delete(options.sessionKey);
+		// Coalesce concurrent resets: an existing in-flight reset already
+		// produces a fresh context, so a follow-up `reset: true` cell should
+		// just wait for it rather than failing the user-visible call.
+		const inFlight = resettingSessions.get(options.sessionKey);
+		if (inFlight) await inFlight.catch(() => undefined);
+		else {
+			const resetPromise = resetVmContext(options.sessionKey);
+			resettingSessions.set(
+				options.sessionKey,
+				resetPromise.then(() => undefined),
+			);
+			try {
+				await resetPromise;
+			} finally {
+				resettingSessions.delete(options.sessionKey);
+			}
 		}
-	} else if (resettingSessions.has(options.sessionKey)) {
-		throw new ToolError("JS context reset in progress");
+	} else {
+		// Internal coordination: wait for any in-flight reset to settle and
+		// then run on the freshly-rebuilt context.
+		const inFlight = resettingSessions.get(options.sessionKey);
+		if (inFlight) await inFlight.catch(() => undefined);
 	}
 	const session = await acquireSession(
 		options.sessionKey,
@@ -191,9 +208,9 @@ async function acquireSession(sessionKey: string, snapshot: SessionSnapshot, tim
 			handleSessionMessage(session, msg);
 		});
 		try {
-			// Cold-start can exceed 5s on slow hosts. Let the caller's per-cell timeout dominate so
-			// users can grant more headroom when they raise `timeout` on a cell.
-			const readyTimeoutMs = Math.max(READY_TIMEOUT_MS_DEFAULT, timeoutMs ?? 0);
+			// Init headroom is the fixed infrastructure floor; the caller's per-cell timeout
+			// dominates when larger so users can grant more by raising `timeout` on a cell.
+			const readyTimeoutMs = Math.max(WORKER_INIT_TIMEOUT_MS, timeoutMs ?? 0);
 			await raceWithTimeout(readyPromise, readyTimeoutMs, "Timed out initializing JS eval worker");
 			worker.send({ type: "init", snapshot });
 			sessions.set(sessionKey, session);

package/src/eval/llm-bridge.ts

@@ -15,7 +15,13 @@ import { instrumentedCompleteSimple, resolveTelemetry } from "@oh-my-pi/pi-agent
 import { type Api, Effort, getSupportedEfforts, type Model, type Tool } from "@oh-my-pi/pi-ai";
 import * as z from "zod/v4";
 import { extractTextContent, extractToolCall, parseJsonPayload } from "../commit/utils";
-import { expandRoleAlias, formatModelString, resolveModelFromString } from "../config/model-resolver";
+
+import {
+	expandRoleAlias,
+	formatModelString,
+	getModelMatchPreferences,
+	resolveModelFromString,
+} from "../config/model-resolver";
 import type { ToolSession } from "../tools";
 import { ToolError } from "../tools/tool-errors";
 import { withBridgeTimeoutPause } from "./bridge-timeout";
@@ -64,7 +70,7 @@ function resolveTierModel(tier: LlmTier, session: ToolSession): Model<Api> | und
 	const available = modelRegistry.getAvailable();
 	if (available.length === 0) return undefined;
 
-	const matchPreferences = { usageOrder: session.settings.getStorage()?.getModelUsageOrder() };
+	const matchPreferences = getModelMatchPreferences(session.settings);
 	const resolve = (pattern: string | undefined): Model<Api> | undefined => {
 		if (!pattern) return undefined;
 		const expanded = expandRoleAlias(pattern, session.settings);
@@ -112,8 +118,9 @@ export async function runEvalLlm(args: unknown, options: EvalLlmBridgeOptions):
 		);
 	}
 
-	const apiKey = await options.session.modelRegistry?.getApiKey(model);
-	if (!apiKey) {
+	const registry = options.session.modelRegistry;
+	const apiKey = await registry?.getApiKey(model);
+	if (!registry || !apiKey) {
 		throw new ToolError(
 			`llm() has no API key for ${formatModelString(model)}. Configure credentials for this provider or choose another tier.`,
 		);
@@ -132,18 +139,27 @@ export async function runEvalLlm(args: unknown, options: EvalLlmBridgeOptions):
 
 	const telemetry = resolveTelemetry(options.session.getTelemetry?.(), options.session.getSessionId?.() ?? undefined);
 
+	// Some providers (notably openai-codex) require a non-empty `instructions`
+	// field on every Responses request and 400 with "Instructions are required"
+	// when it is missing. Fall back to a minimal default so `llm(prompt)` works
+	// without forcing every caller to pass a `system` prompt.
+	const systemPrompt = system ? [system] : ["You are a helpful assistant."];
+
 	// Suspend eval timeout accounting while the model request owns control. The
 	// timeout clock restarts once the bridge returns to the cell runtime.
 	const response = await withBridgeTimeoutPause(options.emitStatus, () =>
 		instrumentedCompleteSimple(
 			model,
 			{
-				systemPrompt: system ? [system] : undefined,
+				systemPrompt,
 				messages: [{ role: "user", content: [{ type: "text", text: prompt }], timestamp: Date.now() }],
 				tools,
 			},
 			{
-				apiKey,
+				apiKey: registry.resolver(model.provider, {
+					sessionId: options.session.getSessionId?.() ?? undefined,
+					baseUrl: model.baseUrl,
+				}),
 				signal: options.signal,
 				reasoning: reasoningForTier(tier, model),
 				toolChoice: schema ? { type: "tool", name: STRUCTURED_TOOL_NAME } : undefined,

package/src/eval/py/__tests__/prelude.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "bun:test";
+import { PYTHON_PRELUDE } from "../prelude";
+
+describe("python prelude", () => {
+	it("exposes read(path, offset?, limit?) with positional optional args", () => {
+		// The eval docs advertise `read(path, offset?=1, limit?=None)`. A
+		// keyword-only signature (`def read(path, *, offset=1, limit=None)`)
+		// makes `read("file", 10)` raise `TypeError: read() takes 1 positional
+		// argument but 2 were given`, which agents in the wild repeatedly hit.
+		// Lock the contract so the helper accepts both positional and keyword
+		// forms.
+		const match = PYTHON_PRELUDE.match(/def\s+read\(([^)]+)\)/);
+		expect(match).not.toBeNull();
+		const signature = match?.[1] ?? "";
+		expect(signature).not.toContain("*,");
+		expect(signature).toContain("offset");
+		expect(signature).toContain("limit");
+	});
+});

package/src/eval/py/executor.ts

@@ -126,7 +126,7 @@ interface PythonSession {
 
 const sessions = new Map<string, PythonSession>();
 const startingSessions = new Map<string, Promise<PythonSession>>();
-const resettingSessions = new Set<string>();
+const resettingSessions = new Map<string, Promise<void>>();
 
 function normalizeSessionCwd(cwd: string): string {
 	return path.resolve(cwd);
@@ -611,17 +611,29 @@ async function executeOnSession(code: string, cwd: string, options: PythonExecut
 		options.bridgeSessionId = sessionId;
 	}
 	if (options.reset) {
-		if (resettingSessions.has(sessionKey)) {
-			throw new Error("Python kernel reset already in progress");
-		}
-		resettingSessions.add(sessionKey);
-		try {
-			await resetSession(sessionKey);
-		} finally {
-			resettingSessions.delete(sessionKey);
+		// Coalesce concurrent resets: if another reset is in flight for this
+		// session, await it instead of throwing — the caller's intent ("start
+		// from a clean kernel") is satisfied once that reset settles.
+		const inFlight = resettingSessions.get(sessionKey);
+		if (inFlight) await inFlight.catch(() => undefined);
+		else {
+			const resetPromise = resetSession(sessionKey);
+			resettingSessions.set(
+				sessionKey,
+				resetPromise.then(() => undefined),
+			);
+			try {
+				await resetPromise;
+			} finally {
+				resettingSessions.delete(sessionKey);
+			}
 		}
-	} else if (resettingSessions.has(sessionKey)) {
-		throw new Error("Python kernel reset in progress");
+	} else {
+		// A reset already in progress is an internal coordination state, not a
+		// user-visible failure. Wait for it to clear, then proceed with the
+		// requested execution on the freshly-restarted kernel.
+		const inFlight = resettingSessions.get(sessionKey);
+		if (inFlight) await inFlight.catch(() => undefined);
 	}
 	const session = await acquireSession(sessionKey, sessionId, cwd, options);
 	if (options.signal?.aborted) {

package/src/eval/py/prelude.py

@@ -53,7 +53,7 @@ if "__omp_prelude_loaded__" not in globals():
         _emit_status("env", key=key, value=val, action="get")
         return val
 
-    def read(path: str | Path, *, offset: int = 1, limit: int | None = None) -> str:
+    def read(path: str | Path, offset: int = 1, limit: int | None = None) -> str:
         """Read file contents. offset/limit are 1-indexed line numbers."""
         p = Path(path)
         data = p.read_text(encoding="utf-8")

package/src/extensibility/extensions/types.ts

@@ -7,7 +7,13 @@
  * - Register commands, keyboard shortcuts, and CLI flags
  * - Interact with the user via UI primitives
  */
-import type { AgentMessage, AgentToolResult, AgentToolUpdateCallback, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type {
+	AgentMessage,
+	AgentToolResult,
+	AgentToolUpdateCallback,
+	ThinkingLevel,
+	ToolApproval,
+} from "@oh-my-pi/pi-agent-core";
 import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type {
 	Api,
@@ -392,6 +398,9 @@ export interface ToolDefinition<TParams extends TSchema = TSchema, TDetails = un
 	defaultInactive?: boolean;
 	/** If true, tool may stage deferred changes that require explicit resolve/discard. */
 	deferrable?: boolean;
+	/** Tool approval tier. Defaults to `"exec"` when omitted.
+	 *  `"read"`: read-only operations. `"write"`: mutations. `"exec"`: code execution. */
+	approval?: ToolApproval;
 	/** MCP server name for discovery/search metadata when this tool fronts an MCP server. */
 	mcpServerName?: string;
 	/** Original MCP tool name for discovery/search metadata. */

package/src/goals/tools/goal-tool.ts

@@ -10,7 +10,7 @@ import { formatDuration } from "../../slash-commands/helpers/format";
 import type { ToolSession } from "../../tools";
 import { formatErrorDetail, TRUNCATE_LENGTHS } from "../../tools/render-utils";
 import { ToolError } from "../../tools/tool-errors";
-import { renderStatusLine, truncateToWidth } from "../../tui";
+import { framedBlock, renderStatusLine, truncateToWidth } from "../../tui";
 import { completionBudgetReport, remainingTokens } from "../runtime";
 import type { Goal, GoalStatus, GoalToolDetails } from "../state";
 
@@ -173,8 +173,7 @@ export const goalToolRenderer = {
 		if (args.op === "create" && args.token_budget !== undefined) {
 			meta.push(`budget ${formatNumber(args.token_budget)}`);
 		}
-		const text = renderStatusLine({ icon: "pending", title: "Goal", description, meta }, uiTheme);
-		return new Text(text, 0, 0);
+		return new Text(renderStatusLine({ icon: "pending", title: "Goal", description, meta }, uiTheme), 0, 0);
 	},
 
 	renderResult(
@@ -190,51 +189,62 @@ export const goalToolRenderer = {
 
 		if (result.isError) {
 			const header = renderStatusLine({ icon: "error", title: "Goal", description }, uiTheme);
-			const body = formatErrorDetail(fallbackText || "Goal tool failed", uiTheme);
-			return new Text([header, body].join("\n"), 0, 0);
+			return framedBlock(uiTheme, width => ({
+				header,
+				sections: [{ lines: formatErrorDetail(fallbackText || "Goal tool failed", uiTheme).split("\n") }],
+				state: "error",
+				borderColor: "error",
+				width,
+			}));
 		}
 
 		const goal = details?.goal ?? null;
 		if (!goal) {
-			const header = renderStatusLine({ icon: "warning", title: "Goal", description }, uiTheme);
-			const body = uiTheme.fg("muted", "No active goal.");
-			return new Text([header, body].join("\n"), 0, 0);
+			return new Text(
+				renderStatusLine({ icon: "warning", title: "Goal", description, meta: ["no active goal"] }, uiTheme),
+				0,
+				0,
+			);
 		}
 
-		const lines: string[] = [];
-		lines.push(
-			renderStatusLine(
-				{
-					icon: "success",
-					title: "Goal",
-					description,
-					badge: { label: goal.status, color: goalBadgeColor(goal.status) },
-				},
-				uiTheme,
-			),
+		const header = renderStatusLine(
+			{
+				icon: "success",
+				title: "Goal",
+				description,
+				badge: { label: goal.status, color: goalBadgeColor(goal.status) },
+			},
+			uiTheme,
 		);
 
+		const lines: string[] = [];
 		const objectiveText = truncateToWidth(goal.objective.trim(), TRUNCATE_LENGTHS.LONG);
-		lines.push(`  ${uiTheme.italic(uiTheme.fg("muted", `"${objectiveText}"`))}`);
+		lines.push(uiTheme.italic(uiTheme.fg("muted", `"${objectiveText}"`)));
 
 		const used = formatNumber(goal.tokensUsed);
 		const tokensLine =
 			goal.tokenBudget !== undefined
 				? `${used} / ${formatNumber(goal.tokenBudget)} tokens (${formatNumber(Math.max(0, goal.tokenBudget - goal.tokensUsed))} left)`
 				: `${used} tokens`;
-		lines.push(`  ${uiTheme.fg("dim", tokensLine)}`);
-
+		const metaParts = [tokensLine];
 		if (goal.timeUsedSeconds > 0) {
-			lines.push(`  ${uiTheme.fg("dim", `${formatDuration(goal.timeUsedSeconds * 1000)} elapsed`)}`);
+			metaParts.push(`${formatDuration(goal.timeUsedSeconds * 1000)} elapsed`);
 		}
+		lines.push(uiTheme.fg("dim", metaParts.join(" · ")));
 
 		const report = details?.completionBudgetReport;
+		const sections: Array<{ label?: string; lines: string[] }> = [{ lines }];
 		if (report) {
-			lines.push("");
-			lines.push(uiTheme.italic(uiTheme.fg("muted", report)));
+			sections.push({ label: "Report", lines: report.split("\n").map(line => uiTheme.fg("muted", line)) });
 		}
 
-		return new Text(lines.join("\n"), 0, 0);
+		return framedBlock(uiTheme, width => ({
+			header,
+			sections,
+			state: "success",
+			borderColor: "borderMuted",
+			width,
+		}));
 	},
 
 	mergeCallAndResult: true,