@oh-my-pi/pi-coding-agent 16.2.5 → 16.2.6

package/dist/types/cli/bench-cli.d.ts

@@ -1,5 +1,5 @@
 import type { ResolvedThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Api, ApiKeyResolver, AssistantMessageEventStream, Context, Model, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
+import type { Api, ApiKeyResolver, AssistantMessageEventStream, Context, Model, ServiceTier, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
 import { type CanonicalModelVariant } from "@oh-my-pi/pi-catalog/identity";
 import type { ApiKeyResolverModel } from "../config/api-key-resolver";
 import { type CanonicalModelQueryOptions } from "../config/model-registry";
@@ -10,7 +10,10 @@ export interface BenchCommandArgs {
         runs?: number;
         maxTokens?: number;
         prompt?: string;
+        /** Service-tier setting value (`none` omits); overrides the configured `serviceTier` setting. */
+        serviceTier?: string;
         json?: boolean;
+        par?: number;
     };
 }
 export interface BenchModelRegistry {
@@ -62,6 +65,8 @@ export interface BenchSummary {
     maxTokens: number;
     models: BenchModelReport[];
     failures: number;
+    /** Requested service tier passed to every request; absent when none was requested. Scoped tiers (`openai-only`/`claude-only`) may be dropped per-provider downstream. */
+    serviceTier?: ServiceTier;
 }
 type BenchStreamSimple = (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream;
 export interface BenchDependencies {

package/dist/types/commands/bench.d.ts

@@ -20,9 +20,17 @@ export default class Bench extends Command {
         prompt: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };
+        "service-tier": import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            options: readonly ["none", "auto", "default", "flex", "scale", "priority", "openai-only", "claude-only"];
+        };
         json: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
             description: string;
         };
+        par: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"integer"> & {
+            description: string;
+            default: number;
+        };
     };
     static examples: string[];
     run(): Promise<void>;

package/dist/types/config/model-discovery.d.ts

@@ -37,10 +37,14 @@ export interface DiscoveryContext {
      */
     getBearerApiKeyResolver(provider: string): Promise<ApiKey | undefined>;
 }
+type LlamaCppDiscoveredModelRuntimeMetadata = {
+    contextWindow: number;
+    maxTokens: number;
+};
 export declare function discoverModelsByProviderType(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;
 export declare function discoverOllamaModels(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;
 export declare function discoverLlamaCppModels(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;
-export declare function discoverLlamaCppModelContextWindow(model: Pick<Model<Api>, "provider" | "id" | "baseUrl" | "headers">, ctx: DiscoveryContext): Promise<number | undefined>;
+export declare function discoverLlamaCppModelRuntimeMetadata(model: Pick<Model<Api>, "provider" | "id" | "baseUrl" | "headers">, ctx: DiscoveryContext): Promise<LlamaCppDiscoveredModelRuntimeMetadata | undefined>;
 export declare function discoverOpenAIModelsList(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;
 export declare function discoverLiteLLMModels(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;
 /**
@@ -61,3 +65,4 @@ export declare function discoverLiteLLMModels(providerConfig: DiscoveryProviderC
 export declare function discoverProxyModels(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;
 export declare function normalizeLiteLLMDiscoveryBaseUrl(baseUrl?: string): string;
 export declare function normalizeOpenAIModelsListBaseUrl(baseUrl?: string): string;
+export {};

package/dist/types/config/settings-schema.d.ts

@@ -4494,7 +4494,7 @@ export declare const SETTINGS_SCHEMA: {
             }, {
                 readonly value: "duckduckgo";
                 readonly label: "DuckDuckGo";
-                readonly description: "Uses DuckDuckGo Instant Answer API (no API key)";
+                readonly description: "Scrapes the DuckDuckGo HTML frontend (no API key)";
             }];
         };
     };

package/dist/types/edit/index.d.ts

@@ -18,6 +18,7 @@ export * from "./modes/patch";
 export * from "./modes/replace";
 export * from "./normalize";
 export * from "./renderer";
+export * from "./snapshot-details";
 export * from "./streaming";
 type TInput = typeof replaceEditSchema | typeof patchEditSchema | typeof hashlineEditParamsSchema | typeof applyPatchSchema;
 type HashlineParams = typeof hashlineEditParamsSchema.infer;

package/dist/types/edit/renderer.d.ts

@@ -29,6 +29,8 @@ export interface EditToolPerFileResult {
     oldText?: string;
     /** Source-of-truth content after the edit; `undefined` for delete operations. */
     newText?: string;
+    /** True when {@link pruneOversizedEditSnapshots} dropped `oldText`/`newText` from this entry. Aggregators check this to suppress misleading combined snapshots when at least one entry of a multi-entry single-path edit was pruned. */
+    snapshotsPruned?: boolean;
     /** Pre-move source path; set only when the edit moved/renamed the file. The header renders `sourcePath → path`. */
     sourcePath?: string;
 }
@@ -53,6 +55,8 @@ export interface EditToolDetails {
     oldText?: string;
     /** Source-of-truth content after the edit; `undefined` for delete operations. */
     newText?: string;
+    /** True when {@link pruneOversizedEditSnapshots} dropped `oldText`/`newText` from this entry. Aggregators check this to suppress misleading combined snapshots when at least one entry of a multi-entry single-path edit was pruned. */
+    snapshotsPruned?: boolean;
     /** Pre-move source path; set only when the edit moved/renamed the file. The header renders `sourcePath → path`. */
     sourcePath?: string;
 }

package/dist/types/edit/snapshot-details.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Bound the size of the `oldText` / `newText` snapshots that edit-tool results
+ * carry in `details`. These fields hold the full pre/post file content; for
+ * large files they balloon the per-turn JSONL line and the session file
+ * (300 KB+ each on the cases reported in #3786) without paying for any LLM
+ * context (provider serializers send only `content`, never `details`).
+ *
+ * Only consumer of the raw snapshots is the ACP event mapper, which builds a
+ * `diff` ToolCallContent for ACP clients (Zed). When the snapshots are pruned
+ * the mapper returns `undefined` for that file and the text content still
+ * flows — diff visualization degrades gracefully for over-threshold edits.
+ */
+import type { EditToolDetails, EditToolPerFileResult } from "./renderer";
+/**
+ * Combined `oldText` + `newText` character budget for a single edit-tool
+ * result. Applies both per-entry (one file at a time) and as an aggregate
+ * across `perFileResults` (so a many-small-files batch can't accumulate
+ * unbounded snapshot bytes — see #3787 review).
+ *
+ * Picked so typical code-file edits keep ACP diff visualization while
+ * pathological cases (large generated files, full-file rewrites, or
+ * many-file batches) drop the raw snapshots before they hit the
+ * session JSONL.
+ */
+export declare const MAX_EDIT_SNAPSHOT_TEXT_CHARS = 32768;
+/**
+ * Prune oversized `oldText` / `newText` from an edit-tool details payload,
+ * recursing into `perFileResults` when present. Per-file overload comes first
+ * so the more specific shape (required `path`) wins overload resolution at
+ * the per-file call sites.
+ */
+export declare function pruneOversizedEditSnapshots(details: EditToolPerFileResult): EditToolPerFileResult;
+export declare function pruneOversizedEditSnapshots(details: EditToolDetails): EditToolDetails;

package/dist/types/mcp/oauth-flow.d.ts

@@ -59,12 +59,10 @@ export interface MCPOAuthConfig {
     /** OAuth scopes (space-separated) */
     scopes?: string;
     /**
-     * `prompt` parameter for the authorization request. Defaults to `"consent"`
-     * so the provider always shows its authorize screen instead of silently
-     * re-approving the browser's current session — without it, reauthorizing to
-     * switch accounts/workspaces is impossible once a session cookie exists
-     * (RFC 6749 §3.1 requires servers to ignore the param when unsupported).
-     * Set to `""` to omit the parameter entirely.
+     * `prompt` parameter for the authorization request. By default the parameter
+     * is omitted, matching the reference MCP SDK, except for `offline_access`
+     * requests where OIDC Core requires `prompt=consent` to issue refresh-token
+     * access. Set to `""` to omit the parameter entirely.
      */
     prompt?: string;
     /** Exact redirect URI to advertise to the provider */

package/dist/types/modes/controllers/tool-args-reveal.d.ts

@@ -6,13 +6,20 @@ type ToolArgsRevealControllerOptions = {
     getSmoothStreaming(): boolean;
     requestRender(): void;
 };
+type ToolArgsRevealTarget = {
+    rawInput: boolean;
+    exposeRawPartialJson: boolean;
+    fullArgs: Record<string, unknown>;
+};
 /**
  * Paces streamed tool-call arguments the same way StreamingRevealController
  * paces assistant text: providers that deliver `partialJson` in large batches
  * (or throttle their partial parses) would otherwise make write/edit/bash
  * streaming previews jump in chunks. Each pending tool call reveals its raw
  * argument stream at the shared 30fps cadence with the same adaptive
- * catch-up step, re-parsing the revealed prefix per frame.
+ * catch-up step. JSON prefixes are parsed only when enough new bytes arrive to
+ * change renderer-visible fields, while raw-prefix consumers still receive
+ * fresh `__partialJson` on every reveal frame.
  *
  * Reveal units are UTF-16 code units of the raw stream, not graphemes —
  * the prefix goes through a JSON parser rather than straight to the screen,
@@ -26,7 +33,7 @@ export declare class ToolArgsRevealController {
      * args to render right now. With smoothing disabled the full target passes
      * through in the caller's legacy shape (`{ ...args, __partialJson }`).
      */
-    setTarget(id: string, partialJson: string, rawInput: boolean, fullArgs: Record<string, unknown>): Record<string, unknown>;
+    setTarget(id: string, partialJson: string, target: ToolArgsRevealTarget): Record<string, unknown>;
     /** Attach the component future ticks push frames into. */
     bind(id: string, component: ToolArgsRevealComponent): void;
     /** Final arguments arrived (the JSON closed): drop the reveal so the

package/dist/types/session/agent-session.d.ts

@@ -184,6 +184,8 @@ export interface AgentSessionConfig {
      * main agent. Defaults to plain `streamSimple` when omitted.
      */
     advisorStreamFn?: StreamFn;
+    /** Hint that OpenAI Codex requests should prefer websocket transport when supported. */
+    preferWebsockets?: boolean;
     /** Provider payload hook used by the active session request path */
     onPayload?: SimpleStreamOptions["onPayload"];
     /** Provider response hook used by the active session request path */
@@ -470,6 +472,8 @@ export declare class AgentSession {
     setSessionSwitchReconciler(reconciler: (() => Promise<void>) | null): void;
     /** Provider-scoped mutable state store for transport/session caches. */
     get providerSessionState(): Map<string, ProviderSessionState>;
+    /** Hint forwarded to provider calls that support websocket transport. */
+    get preferWebsockets(): boolean | undefined;
     getHindsightSessionState(): HindsightSessionState | undefined;
     setHindsightSessionState(state: HindsightSessionState | undefined): HindsightSessionState | undefined;
     getMnemopiSessionState(): MnemopiSessionState | undefined;

package/dist/types/session/session-manager.d.ts

@@ -75,10 +75,9 @@ export declare class SessionManager {
     /** Flush pending writes. Call before switching sessions or on shutdown. */
     flush(): Promise<void>;
     /**
-     * Synchronously flush all in-memory entries to disk. Use when the process may
-     * exit before an async flush settles (Ctrl+C in the TUI). Software-crash
-     * durable; not atomic and not power-loss safe — a same-process crash never
-     * lands mid-`writeFileSync`.
+     * Synchronously makes the current append-only session durable. Avoid rewriting
+     * an already-current file: large restored sessions can contain GiB of compacted
+     * history, and Ctrl+C must not rebuild the whole JSONL string just to flush.
      */
     flushSync(): void;
     /** Flush, then close the append writer. */

package/dist/types/web/search/providers/duckduckgo.d.ts

@@ -2,9 +2,9 @@ import type { AuthStorage } from "@oh-my-pi/pi-ai";
 import type { SearchResponse } from "../../../web/search/types";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
-/** Execute DuckDuckGo Instant Answer API search. */
+/** Execute a DuckDuckGo web search via the no-JS HTML frontend. */
 export declare function searchDuckDuckGo(params: SearchParams): Promise<SearchResponse>;
-/** Search provider for DuckDuckGo Instant Answer API. */
+/** Search provider for DuckDuckGo (no API key required). */
 export declare class DuckDuckGoProvider extends SearchProvider {
     readonly id = "duckduckgo";
     readonly label = "DuckDuckGo";

package/dist/types/web/search/types.d.ts

@@ -78,7 +78,7 @@ export declare const SEARCH_PROVIDER_OPTIONS: readonly [{
 }, {
     readonly value: "duckduckgo";
     readonly label: "DuckDuckGo";
-    readonly description: "Uses DuckDuckGo Instant Answer API (no API key)";
+    readonly description: "Scrapes the DuckDuckGo HTML frontend (no API key)";
 }];
 /** Supported web search providers (every option except `auto`). */
 export type SearchProviderId = Exclude<(typeof SEARCH_PROVIDER_OPTIONS)[number]["value"], "auto">;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.2.5",
+	"version": "16.2.6",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -55,17 +55,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.2.5",
-		"@oh-my-pi/omp-stats": "16.2.5",
-		"@oh-my-pi/pi-agent-core": "16.2.5",
-		"@oh-my-pi/pi-ai": "16.2.5",
-		"@oh-my-pi/pi-catalog": "16.2.5",
-		"@oh-my-pi/pi-mnemopi": "16.2.5",
-		"@oh-my-pi/pi-natives": "16.2.5",
-		"@oh-my-pi/pi-tui": "16.2.5",
-		"@oh-my-pi/pi-utils": "16.2.5",
-		"@oh-my-pi/pi-wire": "16.2.5",
-		"@oh-my-pi/snapcompact": "16.2.5",
+		"@oh-my-pi/hashline": "16.2.6",
+		"@oh-my-pi/omp-stats": "16.2.6",
+		"@oh-my-pi/pi-agent-core": "16.2.6",
+		"@oh-my-pi/pi-ai": "16.2.6",
+		"@oh-my-pi/pi-catalog": "16.2.6",
+		"@oh-my-pi/pi-mnemopi": "16.2.6",
+		"@oh-my-pi/pi-natives": "16.2.6",
+		"@oh-my-pi/pi-tui": "16.2.6",
+		"@oh-my-pi/pi-utils": "16.2.6",
+		"@oh-my-pi/pi-wire": "16.2.6",
+		"@oh-my-pi/snapcompact": "16.2.6",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/cli/args.ts

@@ -94,6 +94,35 @@ const PARSE_DEPS: ParseDeps = {
 	thinkingEfforts: CLI_THINKING_LEVELS,
 };
 
+const WINDOWS_PATH_VALUE_FLAGS: ReadonlySet<string> = new Set(["--extension", "-e", "--hook"]);
+const WINDOWS_PATH_START_RE =
+	/^(?:[A-Za-z]:[\\/]|\\\\[?]\\(?:[A-Za-z]:[\\/]|UNC[\\/])|\\\\[^\\/]+[\\/][^\\/]+[\\/]|\/\/[?]\/(?:[A-Za-z]:\/|UNC\/)|\/\/[^/]+\/[^/]+\/)/;
+const WINDOWS_MODULE_PATH_SUFFIX_RE = /\.(?:[cm]?[jt]sx?)$/i;
+
+function consumeBuiltInStringValue(flag: string, args: string[], valueIndex: number): { value: string; index: number } {
+	const value = args[valueIndex];
+	if (
+		value === undefined ||
+		!WINDOWS_PATH_VALUE_FLAGS.has(flag) ||
+		!WINDOWS_PATH_START_RE.test(value) ||
+		WINDOWS_MODULE_PATH_SUFFIX_RE.test(value)
+	) {
+		return { value: value ?? "", index: valueIndex };
+	}
+
+	let candidate = value;
+	for (let index = valueIndex + 1; index < args.length; index++) {
+		const next = args[index];
+		if (next === PROFILE_BOOTSTRAP_BOUNDARY_ARG || next.startsWith("-")) break;
+		candidate += ` ${next}`;
+		if (WINDOWS_MODULE_PATH_SUFFIX_RE.test(candidate)) {
+			return { value: candidate, index };
+		}
+	}
+
+	return { value, index: valueIndex };
+}
+
 export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { type: "boolean" | "string" }>): Args {
 	// Work on a copy: the `--option=value` handling below splices the value
 	// into the array, and callers reuse the same argv (the post-extension
@@ -161,7 +190,9 @@ export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { ty
 			// here only when its boolean extension is NOT loaded) would otherwise swallow
 			// the marker as its value and drop the user's trailing message.
 			if (i + 1 < args.length && args[i + 1] !== PROFILE_BOOTSTRAP_BOUNDARY_ARG) {
-				STRING_SETTERS[arg](result, args[++i], PARSE_DEPS);
+				const consumed = consumeBuiltInStringValue(arg, args, i + 1);
+				i = consumed.index;
+				STRING_SETTERS[arg](result, consumed.value, PARSE_DEPS);
 			}
 		} else if (OPTIONAL_VALUE_FLAGS.has(arg)) {
 			const config = OPTIONAL_FLAGS[arg];

package/src/cli/bench-cli.ts

@@ -8,6 +8,8 @@ import type {
 	Context,
 	Effort,
 	Model,
+	ProviderSessionState,
+	ServiceTier,
 	SimpleStreamOptions,
 } from "@oh-my-pi/pi-ai";
 import { streamSimple } from "@oh-my-pi/pi-ai";
@@ -23,12 +25,14 @@ import {
 	getModelMatchPreferences,
 	resolveCliModel,
 } from "../config/model-resolver";
+import { resolveServiceTierSetting } from "../config/service-tier";
 import { Settings } from "../config/settings";
 import benchPrompt from "../prompts/bench.md" with { type: "text" };
 import { discoverAuthStorage, loadCliExtensionProviders } from "../sdk";
 import { resolveThinkingLevelForModel, shouldDisableReasoning, toReasoningEffort } from "../thinking";
 
-const DEFAULT_RUNS = 1;
+const DEFAULT_RUNS = 10;
+const DEFAULT_PAR = 4;
 const DEFAULT_MAX_TOKENS = 512;
 const ERROR_WIDTH = 110;
 const BENCH_PROMPT = benchPrompt.trim();
@@ -39,7 +43,10 @@ export interface BenchCommandArgs {
 		runs?: number;
 		maxTokens?: number;
 		prompt?: string;
+		/** Service-tier setting value (`none` omits); overrides the configured `serviceTier` setting. */
+		serviceTier?: string;
 		json?: boolean;
+		par?: number;
 	};
 }
 
@@ -99,6 +106,8 @@ export interface BenchSummary {
 	maxTokens: number;
 	models: BenchModelReport[];
 	failures: number;
+	/** Requested service tier passed to every request; absent when none was requested. Scoped tiers (`openai-only`/`claude-only`) may be dropped per-provider downstream. */
+	serviceTier?: ServiceTier;
 }
 
 type BenchStreamSimple = (
@@ -131,6 +140,13 @@ function normalizePositiveInteger(name: string, value: number | undefined, fallb
 	return value;
 }
 
+function closeProviderSessionStates(providerSessionState: Map<string, ProviderSessionState>): void {
+	for (const state of providerSessionState.values()) {
+		state.close();
+	}
+	providerSessionState.clear();
+}
+
 function isFirstTokenEvent(event: AssistantMessageEvent): boolean {
 	switch (event.type) {
 		case "text_delta":
@@ -188,6 +204,8 @@ interface BenchRequestOptions {
 	reasoning?: Effort;
 	/** Only set for an explicit `:off` suffix — some endpoints reject disablement. */
 	disableReasoning?: boolean;
+	/** Requested service tier passed to `streamSimple`; absent omits the option. The provider layer applies scope/support gating before it reaches the wire. */
+	serviceTier?: ServiceTier;
 }
 
 async function runBenchRequest(
@@ -198,6 +216,7 @@ async function runBenchRequest(
 ): Promise<BenchRunResult> {
 	const startedAt = now();
 	let firstTokenAt: number | undefined;
+	const providerSessionState = new Map<string, ProviderSessionState>();
 	try {
 		const context: Context = {
 			// Codex's Responses endpoint 400s with "Instructions are required" when no
@@ -214,6 +233,9 @@ async function runBenchRequest(
 					: options.maxTokens,
 			reasoning: options.reasoning,
 			disableReasoning: options.disableReasoning,
+			serviceTier: options.serviceTier,
+			providerSessionState,
+			preferWebsockets: true,
 			// pi-ai opts every OpenRouter request into response caching (1h TTL).
 			// Bench sends a byte-identical request each run, so within the TTL
 			// OpenRouter replays the cached generation with zeroed usage — the run
@@ -270,6 +292,8 @@ async function runBenchRequest(
 		};
 	} catch (error) {
 		return { ok: false, error: getErrorMessage(error) };
+	} finally {
+		closeProviderSessionStates(providerSessionState);
 	}
 }
 
@@ -469,10 +493,11 @@ function resolveBenchModels(
 	}
 	return resolved;
 }
-
 export async function runBenchCommand(command: BenchCommandArgs, deps: BenchDependencies = {}): Promise<BenchSummary> {
 	const runs = normalizePositiveInteger("runs", command.flags.runs, DEFAULT_RUNS);
 	const maxTokens = normalizePositiveInteger("max-tokens", command.flags.maxTokens, DEFAULT_MAX_TOKENS);
+	const par =
+		command.flags.par !== undefined ? normalizePositiveInteger("par", command.flags.par, DEFAULT_PAR) : DEFAULT_PAR;
 	const prompt = command.flags.prompt?.trim() || BENCH_PROMPT;
 	const json = command.flags.json === true;
 	const randomSessionId = deps.randomSessionId ?? (() => Bun.randomUUIDv7());
@@ -493,6 +518,12 @@ export async function runBenchCommand(command: BenchCommandArgs, deps: BenchDepe
 	const runtime = await (deps.createRuntime ?? createDefaultRuntime)();
 	try {
 		const targets = resolveBenchModels(command.models, runtime.modelRegistry, runtime.settings, writeStderr);
+		// Explicit `--service-tier` wins; otherwise fall back to the configured
+		// `serviceTier` setting (`none`/unset omits the wire field). Scope-aware
+		// gating to the model's provider happens downstream in the provider layer.
+		const serviceTierValue = command.flags.serviceTier ?? runtime.settings?.get("serviceTier");
+		const serviceTier = serviceTierValue ? resolveServiceTierSetting(serviceTierValue, undefined) : undefined;
+		if (!json && serviceTier) writeStdout(`${chalk.dim(`service tier: ${serviceTier}`)}\n`);
 		const reports: BenchModelReport[] = [];
 		for (const { selector, model, thinking } of targets) {
 			if (!json) {
@@ -501,21 +532,29 @@ export async function runBenchCommand(command: BenchCommandArgs, deps: BenchDepe
 				writeStdout(`${chalk.bold(resolvedModel)}${resolvedNote}\n`);
 			}
 			const results: BenchRunResult[] = [];
-			for (let index = 0; index < runs; index++) {
-				const sessionId = randomSessionId();
-				const initialKey = await runtime.modelRegistry.getApiKey(model, sessionId);
-				if (!initialKey) {
-					const failure: BenchRunFailure = {
-						ok: false,
-						error: `No credentials for provider "${model.provider}". Run \`omp\` and use /login, or set the provider API key.`,
-					};
-					results.push(failure);
-					if (!json) writeStdout(`${formatRunLine(failure, index, runs)}\n`);
-					break; // remaining runs would fail identically
-				}
-				if (!json && interactive) {
-					writeStdout(chalk.dim(`  … run ${index + 1}/${runs} streaming`));
-				}
+
+			// Preflight check: let's verify credentials before starting any runs.
+			// This matches the old sequential break behavior exactly and avoids launching/printing
+			// multiple failures.
+			const testSessionId = randomSessionId();
+			const preflightKey = await runtime.modelRegistry.getApiKey(model, testSessionId);
+			if (!preflightKey) {
+				const failure: BenchRunFailure = {
+					ok: false,
+					error: `No credentials for provider "${model.provider}". Run \`omp\` and use /login, or set the provider API key.`,
+				};
+				results.push(failure);
+				if (!json) writeStdout(`${formatRunLine(failure, 0, runs)}\n`);
+				reports.push(buildModelReport(selector, model, thinking, results));
+				continue;
+			}
+
+			// We will launch up to `par` workers/requests concurrently.
+			// To keep output clean, non-JSON output emits entries in correct index order.
+			let nextToPrint = 0;
+
+			const runWorker = async (index: number) => {
+				const sessionId = index === 0 ? testSessionId : randomSessionId();
 				const result = await runBenchRequest(
 					model,
 					{
@@ -525,20 +564,49 @@ export async function runBenchCommand(command: BenchCommandArgs, deps: BenchDepe
 						maxTokens,
 						reasoning: toReasoningEffort(thinking),
 						disableReasoning: shouldDisableReasoning(thinking) ? true : undefined,
+						serviceTier,
 					},
 					streamFn,
 					now,
 				);
-				results.push(result);
+				results[index] = result;
+			};
+
+			// Concurrency-limited running pool
+			const queue = Array.from({ length: runs }, (_, i) => i);
+			const activeWorkers: Promise<void>[] = [];
+
+			const processNext = async (): Promise<void> => {
+				if (queue.length === 0) return;
+				const index = queue.shift()!;
+
+				// Pre-print a status update if requested and interactive
+				if (!json && interactive) {
+					writeStdout(chalk.dim(`  … run ${index + 1}/${runs} streaming\n`));
+				}
+
+				await runWorker(index);
+
+				// Attempt to print completed results that are in-order
 				if (!json) {
-					if (interactive) writeStdout("\r\x1b[2K");
-					writeStdout(`${formatRunLine(result, index, runs)}\n`);
+					while (nextToPrint < runs && results[nextToPrint] !== undefined) {
+						const res = results[nextToPrint];
+						writeStdout(`${formatRunLine(res, nextToPrint, runs)}\n`);
+						nextToPrint++;
+					}
 				}
+
+				await processNext();
+			};
+
+			for (let w = 0; w < Math.min(par, runs); w++) {
+				activeWorkers.push(processNext());
 			}
+			await Promise.all(activeWorkers);
 			reports.push(buildModelReport(selector, model, thinking, results));
 		}
 		const failures = reports.reduce((sum, report) => sum + report.results.filter(result => !result.ok).length, 0);
-		const summary: BenchSummary = { runs, maxTokens, models: reports, failures };
+		const summary: BenchSummary = { runs, maxTokens, models: reports, failures, serviceTier };
 		if (json) {
 			writeStdout(`${JSON.stringify(summary, null, 2)}\n`);
 		} else if (reports.length > 1 || runs > 1) {

package/src/cli/web-search-cli.ts

@@ -4,8 +4,10 @@
  * Handles `omp q`/`omp web-search` subcommands for testing web search providers.
  */
 
-import { APP_NAME } from "@oh-my-pi/pi-utils";
+import { APP_NAME, getProjectDir } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
+import { applyProviderGlobalsFromSettings } from "../config/provider-globals";
+import { Settings } from "../config/settings";
 import { initTheme, theme } from "../modes/theme/theme";
 import { runSearchQuery, type SearchQueryParams } from "../web/search/index";
 import { SEARCH_PROVIDER_ORDER } from "../web/search/provider";
@@ -85,6 +87,9 @@ export async function runSearchCommand(cmd: SearchCommandArgs): Promise<void> {
 		process.exit(1);
 	}
 
+	const settings = await Settings.init({ cwd: getProjectDir() });
+	applyProviderGlobalsFromSettings(settings);
+
 	await initTheme();
 
 	const params: SearchQueryParams = {

package/src/commands/bench.ts

@@ -1,5 +1,6 @@
 import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { runBenchCommand } from "../cli/bench-cli";
+import { SERVICE_TIER_SETTING_VALUES } from "../config/service-tier";
 
 export default class Bench extends Command {
 	static description =
@@ -14,16 +15,22 @@ export default class Bench extends Command {
 	};
 
 	static flags = {
-		runs: Flags.integer({ description: "Requests per model (results are averaged)", default: 1 }),
+		runs: Flags.integer({ description: "Requests per model (results are averaged)", default: 10 }),
 		"max-tokens": Flags.integer({ description: "Max output tokens per request", default: 512 }),
 		prompt: Flags.string({ description: "Custom prompt text (default: bundled bench prompt)" }),
+		"service-tier": Flags.string({
+			description: "Service tier hint (default: configured `serviceTier` setting; `none` omits it)",
+			options: SERVICE_TIER_SETTING_VALUES,
+		}),
 		json: Flags.boolean({ description: "Output JSON" }),
+		par: Flags.integer({ description: "Execute runs with N parallel queries/requests", default: 4 }),
 	};
 
 	static examples = [
 		"# Compare two models\n  omp bench anthropic/claude-opus-4-5 openai/gpt-5.2",
 		"# Fuzzy selectors work\n  omp bench opus sonnet",
 		"# Average over 3 runs each\n  omp bench opus gpt-5.2 --runs 3",
+		"# Force priority serving tier\n  omp bench openai-codex/gpt-5.5:low --runs 10 --service-tier priority",
 		"# Machine-readable output\n  omp bench opus --json",
 	];
 
@@ -35,7 +42,9 @@ export default class Bench extends Command {
 				runs: flags.runs,
 				maxTokens: flags["max-tokens"],
 				prompt: flags.prompt,
+				serviceTier: flags["service-tier"],
 				json: flags.json,
+				par: flags.par,
 			},
 		});
 	}

package/src/config/mcp-schema.json

@@ -92,7 +92,7 @@
         },
         "prompt": {
           "type": "string",
-          "description": "OAuth `prompt` parameter sent during authorization (default: \"consent\" so the provider always shows its account/consent screen; set to \"\" to omit)."
+          "description": "OAuth `prompt` parameter sent during authorization (default: omit unless the requested scope contains `offline_access`, which sends \"consent\"; set to \"\" to always omit)."
         }
       },
       "description": "Explicit OAuth client settings for servers that need them during /mcp reauth or initial connect."