@oh-my-pi/pi-coding-agent 15.11.6 → 15.11.8

package/src/collab/relay-client.ts

@@ -0,0 +1,216 @@
+/**
+ * Client-side WebSocket wrapper for collab live-session sharing.
+ *
+ * Connects to a relay room, seals/opens AES-GCM frames, and reconnects with
+ * exponential backoff on transient drops. Fatal relay close codes (room gone,
+ * host conflict, room full) and decryption failures never reconnect.
+ */
+import { logger } from "@oh-my-pi/pi-utils";
+import { open, seal } from "./crypto";
+import type { CollabFrame, RelayControlMessage } from "./protocol";
+import { packEnvelope, unpackEnvelope } from "./protocol";
+
+const FATAL_CLOSE_REASONS: Record<number, string> = {
+	4001: "room closed",
+	4004: "no such room",
+	4009: "a host is already connected for this room",
+	4029: "room is full",
+};
+
+const BACKOFF_BASE_MS = 1_000;
+const BACKOFF_MAX_MS = 30_000;
+/** Max enveloped frames buffered while a reconnect is pending; overflow is dropped. */
+const MAX_PENDING_SENDS = 256;
+
+export interface CollabSocketOptions {
+	/** wss://host[:port]/r/<roomId> — no query string. */
+	wsUrl: string;
+	role: "host" | "guest";
+	key: CryptoKey;
+}
+
+export class CollabSocket {
+	/** Fires after every successful (re)connect. */
+	onOpen?: () => void;
+	onFrame?: (frame: CollabFrame, fromPeer: number) => void;
+	onControl?: (msg: RelayControlMessage) => void;
+	/** Fires once per terminal close (intentional, fatal code, or bad key). willReconnect=true for transient drops that will retry. */
+	onClose?: (reason: string, willReconnect: boolean) => void;
+
+	readonly #opts: CollabSocketOptions;
+	#ws: WebSocket | null = null;
+	#retryTimer: NodeJS.Timeout | undefined;
+	#attempt = 0;
+	/** Terminal state: intentional close or fatal failure. Cleared by connect(). */
+	#closed = false;
+	/** Serializes seal() so frames hit the wire in send() order. */
+	#sendChain: Promise<void> = Promise.resolve();
+	/** Serializes open() so frames are delivered in arrival order. */
+	#recvChain: Promise<void> = Promise.resolve();
+	/** Envelopes sealed while disconnected, flushed on the next open. */
+	#pendingSends: Uint8Array[] = [];
+
+	constructor(opts: CollabSocketOptions) {
+		this.#opts = opts;
+	}
+
+	get isOpen(): boolean {
+		return this.#ws?.readyState === WebSocket.OPEN;
+	}
+
+	connect(): void {
+		if (this.#ws || this.#retryTimer) return;
+		this.#closed = false;
+		this.#attempt = 0;
+		this.#openSocket();
+	}
+
+	send(frame: CollabFrame, targetPeer = 0): void {
+		this.#sendChain = this.#sendChain
+			.then(async () => {
+				if (this.#closed) {
+					logger.debug("collab: dropping frame, socket closed", { t: frame.t });
+					return;
+				}
+				const sealed = await seal(this.#opts.key, frame);
+				const envelope = packEnvelope(targetPeer, sealed);
+				const ws = this.#ws;
+				if (ws && ws.readyState === WebSocket.OPEN) {
+					ws.send(envelope);
+					return;
+				}
+				if (this.#pendingSends.length >= MAX_PENDING_SENDS) {
+					logger.debug("collab: dropping frame, reconnect buffer full", { t: frame.t });
+					return;
+				}
+				this.#pendingSends.push(envelope);
+			})
+			.catch((err: unknown) => {
+				logger.debug("collab: send failed", { error: String(err) });
+			});
+	}
+
+	/** Intentional close: clears any retry timer, suppresses reconnect. A later connect() starts fresh. */
+	close(): void {
+		const hadActivity = this.#ws !== null || this.#retryTimer !== undefined;
+		this.#clearRetry();
+		const wasClosed = this.#closed;
+		this.#closed = true;
+		this.#pendingSends.length = 0;
+		const ws = this.#ws;
+		this.#ws = null;
+		if (ws) {
+			try {
+				ws.close(1000);
+			} catch {
+				// already closing/closed
+			}
+		}
+		if (hadActivity && !wasClosed) this.onClose?.("closed", false);
+	}
+
+	#openSocket(): void {
+		const ws = new WebSocket(`${this.#opts.wsUrl}?role=${this.#opts.role}`);
+		ws.binaryType = "arraybuffer";
+		this.#ws = ws;
+		ws.onopen = () => {
+			if (this.#ws !== ws) return;
+			this.#attempt = 0;
+			for (const envelope of this.#pendingSends) ws.send(envelope);
+			this.#pendingSends.length = 0;
+			this.onOpen?.();
+		};
+		ws.onmessage = (event: MessageEvent) => {
+			if (this.#ws !== ws) return;
+			this.#handleMessage(ws, event.data);
+		};
+		ws.onerror = () => {
+			// The paired close event carries the actionable state; nothing to do here.
+		};
+		ws.onclose = (event: CloseEvent) => {
+			if (this.#ws !== ws) return;
+			this.#ws = null;
+			this.#handleClose(event.code, event.reason);
+		};
+	}
+
+	#handleMessage(ws: WebSocket, data: unknown): void {
+		if (typeof data === "string") {
+			try {
+				this.onControl?.(JSON.parse(data) as RelayControlMessage);
+			} catch {
+				logger.debug("collab: ignoring malformed control message");
+			}
+			return;
+		}
+		const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : data instanceof Uint8Array ? data : null;
+		if (!bytes) return;
+		const envelope = unpackEnvelope(bytes);
+		if (!envelope) return;
+		this.#recvChain = this.#recvChain
+			.then(async () => {
+				if (this.#ws !== ws) return;
+				let frame: CollabFrame;
+				try {
+					frame = await open(this.#opts.key, envelope.payload);
+				} catch {
+					this.#failFatal("bad key or corrupted frame");
+					return;
+				}
+				if (this.#ws !== ws) return;
+				this.onFrame?.(frame, envelope.peerId);
+			})
+			.catch((err: unknown) => {
+				logger.debug("collab: frame handler failed", { error: String(err) });
+			});
+	}
+
+	#handleClose(code: number, reason: string): void {
+		if (this.#closed) return;
+		const fatalReason = FATAL_CLOSE_REASONS[code];
+		if (fatalReason !== undefined) {
+			this.#closed = true;
+			this.#pendingSends.length = 0;
+			this.onClose?.(fatalReason, false);
+			return;
+		}
+		this.onClose?.(reason || `connection lost (code ${code})`, true);
+		this.#scheduleRetry();
+	}
+
+	/** Decryption failure: wrong key or corrupted frame. Never reconnect. */
+	#failFatal(reason: string): void {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.#clearRetry();
+		this.#pendingSends.length = 0;
+		const ws = this.#ws;
+		this.#ws = null;
+		if (ws) {
+			try {
+				ws.close(1000);
+			} catch {
+				// already closing/closed
+			}
+		}
+		this.onClose?.(reason, false);
+	}
+
+	#scheduleRetry(): void {
+		const base = Math.min(BACKOFF_BASE_MS * 2 ** this.#attempt, BACKOFF_MAX_MS);
+		this.#attempt++;
+		const delay = base * (0.75 + Math.random() * 0.5);
+		this.#retryTimer = setTimeout(() => {
+			this.#retryTimer = undefined;
+			if (this.#closed) return;
+			this.#openSocket();
+		}, delay);
+	}
+
+	#clearRetry(): void {
+		if (this.#retryTimer !== undefined) {
+			clearTimeout(this.#retryTimer);
+			this.#retryTimer = undefined;
+		}
+	}
+}

package/src/commands/bench.ts

@@ -0,0 +1,42 @@
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { runBenchCommand } from "../cli/bench-cli";
+
+export default class Bench extends Command {
+	static description =
+		"Benchmark models with the same prompt: time-to-first-token and generation throughput (tokens/s)";
+
+	static args = {
+		models: Args.string({
+			description: "Model selectors (provider/model or fuzzy id, e.g. opus)",
+			required: true,
+			multiple: true,
+		}),
+	};
+
+	static flags = {
+		runs: Flags.integer({ description: "Requests per model (results are averaged)", default: 1 }),
+		"max-tokens": Flags.integer({ description: "Max output tokens per request", default: 512 }),
+		prompt: Flags.string({ description: "Custom prompt text (default: bundled bench prompt)" }),
+		json: Flags.boolean({ description: "Output JSON" }),
+	};
+
+	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",
+		"# Machine-readable output\n  omp bench opus --json",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Bench);
+		await runBenchCommand({
+			models: args.models ?? [],
+			flags: {
+				runs: flags.runs,
+				maxTokens: flags["max-tokens"],
+				prompt: flags.prompt,
+				json: flags.json,
+			},
+		});
+	}
+}

package/src/commands/join.ts

@@ -0,0 +1,39 @@
+/**
+ * Join a shared collab session from the CLI: launches the interactive TUI and
+ * immediately runs `/join <link>`.
+ */
+import { APP_NAME } from "@oh-my-pi/pi-utils";
+import { Args, Command } from "@oh-my-pi/pi-utils/cli";
+import { parseArgs } from "../cli/args";
+import { runRootCommand } from "../main";
+
+export default class Join extends Command {
+	static description = "Join a shared collab session (same as /join)";
+
+	static args = {
+		link: Args.string({
+			description: "Collab link shared by the host (/collab)",
+			required: true,
+		}),
+	};
+
+	static examples = [`${APP_NAME} join wss://relay.omp.sh/s/abc123#key`];
+
+	async run(): Promise<void> {
+		const { args } = await this.parse(Join);
+		const link = args.link?.trim();
+		if (!link) {
+			process.stderr.write(`Usage: ${APP_NAME} join <link>\n`);
+			process.exitCode = 1;
+			return;
+		}
+		if (!process.stdin.isTTY || !process.stdout.isTTY) {
+			process.stderr.write(`${APP_NAME} join requires an interactive terminal\n`);
+			process.exitCode = 1;
+			return;
+		}
+		const parsed = parseArgs([]);
+		parsed.join = link;
+		await runRootCommand(parsed, []);
+	}
+}

package/src/config/model-registry.ts

@@ -20,6 +20,11 @@ import {
 	UNK_CONTEXT_WINDOW,
 	UNK_MAX_TOKENS,
 } from "@oh-my-pi/pi-catalog/provider-models";
+import {
+	collapseBuiltModelVariants,
+	getVariantAliasSources,
+	resolveVariantAlias,
+} from "@oh-my-pi/pi-catalog/variant-collapse";
 
 // Sentinel for local-only OAuth token (LM Studio, vLLM) — declared inline to avoid loading
 // any provider module at startup. Must match `DEFAULT_LOCAL_TOKEN` in oauth/lm-studio.ts.
@@ -542,7 +547,37 @@ function normalizeSuppressedSelector(selector: string): string {
 	if (!trimmed) return trimmed;
 	const parsed = parseModelString(trimmed);
 	if (!parsed) return trimmed;
-	return `${parsed.provider}/${parsed.id}`;
+	// Retired effort-tier variant ids normalize to their collapsed logical id
+	// so persisted suppressions keyed by raw member ids still bind.
+	const aliasId = resolveVariantAlias(parsed.provider, parsed.id);
+	return `${parsed.provider}/${aliasId ?? parsed.id}`;
+}
+
+/**
+ * Look up a model's override, falling back to entries keyed by retired
+ * effort-tier variant ids (models.yml authored before collapsing). A raw key
+ * only re-binds when no live model holds that id.
+ */
+function resolveModelOverrideWithAliases(
+	overrides: Map<string, ModelOverride>,
+	model: Model<Api>,
+	hasLiveModel: (provider: string, id: string) => boolean,
+): ModelOverride | undefined {
+	const direct = overrides.get(model.id);
+	if (direct) return direct;
+	for (const rawId of getVariantAliasSources(model.provider, model.id)) {
+		if (hasLiveModel(model.provider, rawId)) continue;
+		const remapped = overrides.get(rawId);
+		if (remapped) {
+			logger.debug("model override re-keyed through variant alias", {
+				provider: model.provider,
+				from: rawId,
+				to: model.id,
+			});
+			return remapped;
+		}
+	}
+	return undefined;
 }
 
 function getDisabledProviderIdsFromSettings(): Set<string> {
@@ -567,6 +602,7 @@ function getConfiguredProviderOrderFromSettings(): string[] {
 export class ModelRegistry {
 	#models: Model<Api>[] = [];
 	#canonicalIndex: CanonicalModelIndex = { records: [], byId: new Map(), bySelector: new Map() };
+	#canonicalIndexDirty: boolean = true;
 	#customProviderApiKeys: Map<string, string> = new Map();
 	#keylessProviders: Set<string> = new Set();
 	#discoverableProviders: DiscoveryProviderConfig[] = [];
@@ -799,7 +835,9 @@ export class ModelRegistry {
 		const withConfigModels = this.#mergeCustomModels(resolvedDefaults, this.#customModelOverlays);
 		// Merge runtime extension models so they survive refresh() cycles
 		const combined = this.#mergeCustomModels(withConfigModels, this.#runtimeModelOverlays);
-		const withModelOverrides = this.#applyModelOverrides(combined, this.#modelOverrides);
+		// Custom/config providers bypass the model-manager merge point —
+		// collapse effort-tier variants here so X/X-thinking twins fold.
+		const withModelOverrides = this.#applyModelOverrides(collapseBuiltModelVariants(combined), this.#modelOverrides);
 		this.#models = this.#applyRuntimeProviderOverrides(withModelOverrides);
 		this.#rebuildCanonicalIndex();
 		this.#lastStaticLoadMtime = this.#modelsConfigFile.getMtimeMs();
@@ -1152,7 +1190,7 @@ export class ModelRegistry {
 		const withConfigModels = this.#mergeCustomModels(resolved, this.#customModelOverlays);
 		// Merge runtime extension models so they survive online discovery completion
 		const combined = this.#mergeCustomModels(withConfigModels, this.#runtimeModelOverlays);
-		const withModelOverrides = this.#applyModelOverrides(combined, this.#modelOverrides);
+		const withModelOverrides = this.#applyModelOverrides(collapseBuiltModelVariants(combined), this.#modelOverrides);
 		this.#models = this.#applyRuntimeProviderOverrides(withModelOverrides);
 		this.#rebuildCanonicalIndex();
 	}
@@ -1398,8 +1436,13 @@ export class ModelRegistry {
 	#applyProviderModelOverrides(provider: string, models: Model<Api>[]): Model<Api>[] {
 		const overrides = this.#modelOverrides.get(provider);
 		if (!overrides || overrides.size === 0) return models;
+		let liveIds: Set<string> | null = null;
+		const hasLiveModel = (_provider: string, id: string) => {
+			liveIds ??= new Set(models.map(m => m.id));
+			return liveIds.has(id);
+		};
 		return models.map(model => {
-			const override = overrides.get(model.id);
+			const override = resolveModelOverrideWithAliases(overrides, model, hasLiveModel);
 			if (!override) return model;
 			return applyModelOverride(model, override);
 		});
@@ -1443,10 +1486,15 @@ export class ModelRegistry {
 	}
 	#applyModelOverrides(models: Model<Api>[], overrides: Map<string, Map<string, ModelOverride>>): Model<Api>[] {
 		if (overrides.size === 0) return models;
+		let liveKeys: Set<string> | null = null;
+		const hasLiveModel = (provider: string, id: string) => {
+			liveKeys ??= new Set(models.map(m => `${m.provider}\u0000${m.id}`));
+			return liveKeys.has(`${provider}\u0000${id}`);
+		};
 		return models.map(model => {
 			const providerOverrides = overrides.get(model.provider);
 			if (!providerOverrides) return model;
-			const override = providerOverrides.get(model.id);
+			const override = resolveModelOverrideWithAliases(providerOverrides, model, hasLiveModel);
 			if (!override) return model;
 			return applyModelOverride(model, override);
 		});
@@ -1472,14 +1520,25 @@ export class ModelRegistry {
 			this.#rebuildPending = true;
 			return;
 		}
-		this.#canonicalIndex = buildCanonicalModelIndex(
-			this.#models,
-			getBundledCanonicalReferenceData(),
-			this.#equivalenceConfig,
-		);
+		// Defer the catalog-wide index build to first read. Boot model
+		// resolution reads it only when enabledModels or a default-role pattern
+		// is configured; the empty interactive launch never reads it pre-paint,
+		// so the ~200ms build over the full catalog moves off the first-paint
+		// critical path.
+		this.#canonicalIndexDirty = true;
 		this.#rebuildPending = false;
 	}
 
+	#ensureCanonicalIndex(): CanonicalModelIndex {
+		if (this.#canonicalIndexDirty) {
+			this.#canonicalIndex = logger.time("buildCanonicalModelIndex", () =>
+				buildCanonicalModelIndex(this.#models, getBundledCanonicalReferenceData(), this.#equivalenceConfig),
+			);
+			this.#canonicalIndexDirty = false;
+		}
+		return this.#canonicalIndex;
+	}
+
 	#suspendRebuild(): void {
 		this.#rebuildSuspended += 1;
 	}
@@ -1490,11 +1549,7 @@ export class ModelRegistry {
 		}
 		if (this.#rebuildSuspended === 0 && this.#rebuildPending) {
 			this.#rebuildPending = false;
-			this.#canonicalIndex = buildCanonicalModelIndex(
-				this.#models,
-				getBundledCanonicalReferenceData(),
-				this.#equivalenceConfig,
-			);
+			this.#canonicalIndexDirty = true;
 		}
 	}
 
@@ -1603,7 +1658,7 @@ export class ModelRegistry {
 	getCanonicalModels(options?: CanonicalModelQueryOptions): CanonicalModelRecord[] {
 		const { candidateKeys, isAvailable } = this.#canonicalQueryFilters(options);
 		const records: CanonicalModelRecord[] = [];
-		for (const record of this.#canonicalIndex.records) {
+		for (const record of this.#ensureCanonicalIndex().records) {
 			const variants = this.#filterCanonicalVariants(record, candidateKeys, isAvailable);
 			if (variants.length === 0) {
 				continue;
@@ -1629,7 +1684,7 @@ export class ModelRegistry {
 		const candidates = options?.candidates ?? (options?.availableOnly ? this.getAvailable() : this.getAll());
 		const preferences = this.#variantPreferences(candidates);
 		const selections: CanonicalModelSelection[] = [];
-		for (const record of this.#canonicalIndex.records) {
+		for (const record of this.#ensureCanonicalIndex().records) {
 			const variants = this.#filterCanonicalVariants(record, candidateKeys, isAvailable);
 			if (variants.length === 0) {
 				continue;
@@ -1647,7 +1702,7 @@ export class ModelRegistry {
 	}
 
 	getCanonicalVariants(canonicalId: string, options?: CanonicalModelQueryOptions): CanonicalModelVariant[] {
-		const record = this.#canonicalIndex.byId.get(canonicalId.trim().toLowerCase());
+		const record = this.#ensureCanonicalIndex().byId.get(canonicalId.trim().toLowerCase());
 		if (!record) {
 			return [];
 		}
@@ -1665,7 +1720,7 @@ export class ModelRegistry {
 	}
 
 	getCanonicalId(model: Model<Api>): string | undefined {
-		return this.#canonicalIndex.bySelector.get(formatCanonicalVariantSelector(model).toLowerCase());
+		return this.#ensureCanonicalIndex().bySelector.get(formatCanonicalVariantSelector(model).toLowerCase());
 	}
 
 	/**

package/src/config/model-resolver.ts

@@ -3,8 +3,9 @@
  *
  * Layering:
  * - `matchModel` is the single matching engine. Order: exact `provider/id`
- *   reference (with OpenRouter routed/date fallbacks) → exact canonical id →
- *   exact bare id → provider-scoped fuzzy → substring with alias-vs-dated pick.
+ *   reference (with variant-alias and OpenRouter routed/date fallbacks) →
+ *   exact canonical id → exact bare id → retired variant alias →
+ *   provider-scoped fuzzy → substring with alias-vs-dated pick.
  * - `parseModelPatternWithContext`/`parseModelPattern` layer the selector
  *   grammar on top: trailing `:level` thinking suffixes (`splitThinkingSuffix`)
  *   and `@upstream` provider routing (`splitUpstreamRouting`).
@@ -19,9 +20,11 @@ import type { Api, Effort, KnownProvider, Model, ModelSpec } from "@oh-my-pi/pi-
 import { buildModel } from "@oh-my-pi/pi-catalog/build";
 import { modelMatchesHost } from "@oh-my-pi/pi-catalog/hosts";
 import { buildModelProviderPriorityRank } from "@oh-my-pi/pi-catalog/identity";
+import { stripThinkingVariantToken } from "@oh-my-pi/pi-catalog/identity/family";
 import { clampThinkingLevelForModel } from "@oh-my-pi/pi-catalog/model-thinking";
 import { modelsAreEqual } from "@oh-my-pi/pi-catalog/models";
 import { DEFAULT_MODEL_PER_PROVIDER } from "@oh-my-pi/pi-catalog/provider-models";
+import { resolveBareVariantAlias, resolveVariantAlias } from "@oh-my-pi/pi-catalog/variant-collapse";
 import { fuzzyMatch } from "@oh-my-pi/pi-tui";
 import { logger } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
@@ -228,6 +231,18 @@ export function resolveProviderModelReference(
 		return exact;
 	}
 
+	// Retired effort-tier variant ids resolve to their collapsed logical
+	// model: hand-table aliases first, then the `X-thinking` → `X` grammar
+	// for auto-derived pairs. Exact lookup above always wins while raw is live.
+	const variantAliasId =
+		resolveVariantAlias(normalizedProvider, normalizedModelId) ?? stripThinkingVariantToken(normalizedModelId);
+	if (variantAliasId) {
+		const aliased = index.get(`${normalizedProvider}\u0000${variantAliasId.toLowerCase()}`);
+		if (aliased) {
+			return aliased;
+		}
+	}
+
 	if (normalizedProvider !== "openrouter") {
 		return undefined;
 	}
@@ -407,11 +422,13 @@ function findExactCanonicalModelMatch(
 
 /**
  * The single model-matching engine. Tries, in order:
- * 1. exact `provider/id` reference (OpenRouter routed/date fallbacks included),
+ * 1. exact `provider/id` reference (variant-alias and OpenRouter routed/date
+ *    fallbacks included),
  * 2. exact canonical id (coalesces provider variants),
  * 3. exact bare id (preference-ranked),
- * 4. provider-scoped fuzzy match,
- * 5. substring match with the alias-vs-dated pick.
+ * 4. retired effort-tier variant alias (collapsed catalog entries),
+ * 5. provider-scoped fuzzy match,
+ * 6. substring match with the alias-vs-dated pick.
  * Returns the matched model or undefined if no match found.
  */
 function matchModel(
@@ -440,6 +457,20 @@ function matchModel(
 	if (exactMatches.length > 0) {
 		return pickPreferredModel(exactMatches, context);
 	}
+
+	// Retired effort-tier variant ids (bare, no provider prefix) resolve to
+	// their collapsed logical model; models from the providers whose table
+	// declared the alias win ties. Auto-derived `X-thinking` pairs resolve
+	// through the grammar fallback.
+	const bareAlias = resolveBareVariantAlias(modelPattern);
+	const bareAliasTargetId = bareAlias?.id ?? stripThinkingVariantToken(modelPattern);
+	if (bareAliasTargetId) {
+		const aliasMatches = availableModels.filter(m => m.id.toLowerCase() === bareAliasTargetId.toLowerCase());
+		if (aliasMatches.length > 0) {
+			const preferred = bareAlias ? aliasMatches.filter(m => bareAlias.providers.includes(m.provider)) : [];
+			return pickPreferredModel(preferred.length > 0 ? preferred : aliasMatches, context);
+		}
+	}
 	// Check for provider/modelId format — fuzzy match within provider only.
 	const slashIndex = modelPattern.indexOf("/");
 	if (slashIndex !== -1) {