@oh-my-pi/pi-coding-agent 16.1.6 → 16.1.8

package/src/collab/guest.ts

@@ -20,6 +20,7 @@ import type { AgentHubRemote } from "../modes/components/agent-hub";
 import type { InteractiveModeContext } from "../modes/types";
 import { AgentRegistry } from "../registry/agent-registry";
 import type { AgentSessionEvent } from "../session/agent-session";
+import type { SessionEntry } from "../session/session-entries";
 import { shouldDisableReasoning, toReasoningEffort } from "../thinking";
 import { setSessionTerminalTitle } from "../utils/title-generator";
 import { importRoomKey } from "./crypto";
@@ -47,10 +48,35 @@ export const COLLAB_GUEST_ALLOWED_COMMANDS: Record<string, true> = {
 	exit: true,
 	quit: true,
 };
+/**
+ * How long the guest waits for the host's small `welcome` frame before giving
+ * up on the join. The welcome carries metadata only (`entryCount`, header,
+ * state, agents), so it lands well under one second on any working relay.
+ */
 const WELCOME_TIMEOUT_MS = 30_000;
+/**
+ * How long the guest waits between `snapshot-chunk` frames during the initial
+ * sync. Resets on each chunk arrival, so a multi-MB snapshot only fails when
+ * the relay genuinely stalls — not because the total wall-clock crossed the
+ * welcome budget. The default relay sustains ~350 KB/s; a 512 KB chunk lands
+ * in under two seconds with comfortable headroom.
+ */
+const SNAPSHOT_PROGRESS_TIMEOUT_MS = 30_000;
 const TRANSCRIPT_TIMEOUT_MS = 20_000;
 
 type WelcomeFrame = Extract<CollabFrame, { t: "welcome" }>;
+type SnapshotChunkFrame = Extract<CollabFrame, { t: "snapshot-chunk" }>;
+
+/** Accumulator for an in-flight chunked welcome — see {@link CollabGuestLink}. */
+interface PendingSnapshot {
+	header: WelcomeFrame["header"];
+	state: WelcomeFrame["state"];
+	agents: AgentSnapshot[];
+	readOnly: boolean;
+	entryCount: number;
+	entries: SessionEntry[];
+	isResync: boolean;
+}
 
 export class CollabGuestLink {
 	#ctx: InteractiveModeContext;
@@ -60,8 +86,24 @@ export class CollabGuestLink {
 	#returnSessionFile: string | null = null;
 	/** Frames apply strictly in arrival order through this chain. */
 	#applyChain: Promise<void> = Promise.resolve();
+	/** True after the initial snapshot has been written to disk and resumed. */
 	#welcomed = false;
 	#left = false;
+	/**
+	 * Buffer for the in-flight chunked welcome. Set by the small `welcome`
+	 * frame, accumulated by every `snapshot-chunk`, drained when the final
+	 * chunk lands (or the snapshot-progress timer fires).
+	 */
+	#pendingSnapshot: PendingSnapshot | null = null;
+	/**
+	 * Fires `firstWelcome.reject` from a stalled welcome/snapshot during the
+	 * initial join. Set in {@link join}, cleared on resolve/reject; arming a
+	 * timer after that point is a no-op so reconnect-time stalls fall through
+	 * to the normal socket close handling instead of aborting the live session.
+	 */
+	#joinReject: ((err: Error) => void) | null = null;
+	#welcomeTimer: Timer | null = null;
+	#snapshotProgressTimer: Timer | null = null;
 	/** base64url write token from a full link; absent when joined via a view link. */
 	#writeToken: string | undefined;
 	/** True when the host marked this peer read-only (view link). */
@@ -143,11 +185,23 @@ export class CollabGuestLink {
 
 		const firstWelcome = Promise.withResolvers<void>();
 		let joined = false;
+		this.#joinReject = err => firstWelcome.reject(err);
+
+		const finishJoin = (): void => {
+			if (joined) return;
+			joined = true;
+			firstWelcome.resolve();
+		};
 
 		socket.onOpen = () => {
 			// (Re)connect: re-introduce ourselves; the host answers with a fresh
-			// welcome which (re)syncs the replica.
+			// welcome which (re)syncs the replica. Discard any partially-streamed
+			// snapshot from a prior connection: the host will resend the full
+			// chunk train.
 			this.#welcomed = false;
+			this.#pendingSnapshot = null;
+			this.#clearSnapshotProgressTimer();
+			this.#armWelcomeTimer();
 			socket.send({
 				t: "hello",
 				proto: COLLAB_PROTO,
@@ -159,19 +213,35 @@ export class CollabGuestLink {
 			this.#applyChain = this.#applyChain
 				.then(async () => {
 					if (frame.t === "welcome") {
-						await this.#applyWelcome(frame, joined);
-						if (!joined) {
-							joined = true;
-							firstWelcome.resolve();
+						this.#clearWelcomeTimer();
+						this.#beginWelcome(frame, joined);
+						if (frame.entryCount === 0) {
+							await this.#finalizeSnapshot();
+							finishJoin();
+						}
+						return;
+					}
+					if (frame.t === "snapshot-chunk") {
+						const ready = this.#accumulateSnapshotChunk(frame);
+						if (ready) {
+							await this.#finalizeSnapshot();
+							finishJoin();
 						}
 						return;
 					}
 					if (!this.#welcomed || this.#left) return;
 					this.#applyFrame(frame);
 				})
-				.catch(err => logger.warn("collab guest frame apply failed", { type: frame.t, error: String(err) }));
+				.catch(err => {
+					logger.warn("collab guest frame apply failed", { type: frame.t, error: String(err) });
+					if (!joined && (frame.t === "welcome" || frame.t === "snapshot-chunk")) {
+						firstWelcome.reject(err instanceof Error ? err : new Error(String(err)));
+					}
+				});
 		};
 		socket.onClose = (reason, willReconnect) => {
+			this.#clearWelcomeTimer();
+			this.#clearSnapshotProgressTimer();
 			this.#flushPendingTranscripts();
 			if (this.#left) return;
 			if (!joined) {
@@ -186,11 +256,12 @@ export class CollabGuestLink {
 			void this.#restoreLocalSession();
 		};
 		socket.connect();
+		// Cover the connect phase too: if the relay blackholes the WebSocket
+		// handshake (no onOpen, no onClose), onOpen never arms the welcome timer,
+		// so without this the join would hang forever. onOpen re-arms (resetting
+		// the budget) once the socket actually opens.
+		this.#armWelcomeTimer();
 
-		const timeout = setTimeout(
-			() => firstWelcome.reject(new Error("timed out waiting for the host's welcome")),
-			WELCOME_TIMEOUT_MS,
-		);
 		try {
 			await firstWelcome.promise;
 		} catch (err) {
@@ -199,7 +270,9 @@ export class CollabGuestLink {
 			this.#socket = null;
 			throw err;
 		} finally {
-			clearTimeout(timeout);
+			this.#joinReject = null;
+			this.#clearWelcomeTimer();
+			this.#clearSnapshotProgressTimer();
 		}
 
 		this.#ctx.collabGuest = this;
@@ -222,11 +295,56 @@ export class CollabGuestLink {
 		this.#socket?.send({ t: "abort" });
 	}
 
-	/** Write the welcome snapshot to the replica file and (re)load it through the resume machinery. */
-	async #applyWelcome(frame: WelcomeFrame, isResync: boolean): Promise<void> {
+	/**
+	 * Latch the welcome metadata and prime the snapshot accumulator. The
+	 * heavy resume work (file write, `switchSession`, render) only happens in
+	 * {@link #finalizeSnapshot}, so the small welcome frame clears the join
+	 * timeout immediately even when the transcript still has to stream in.
+	 */
+	#beginWelcome(frame: WelcomeFrame, isResync: boolean): void {
 		if (this.#left) return;
+		this.#pendingSnapshot = {
+			header: frame.header,
+			state: frame.state,
+			agents: frame.agents,
+			readOnly: frame.readOnly === true,
+			entryCount: frame.entryCount,
+			entries: [],
+			isResync,
+		};
+		this.#armSnapshotProgressTimer();
+	}
+
+	/**
+	 * Append a chunk to the pending snapshot. Returns `true` when the
+	 * accumulator has gathered every entry the welcome promised, or the host
+	 * tagged this chunk as `final`. The caller is responsible for invoking
+	 * {@link #finalizeSnapshot} on the same applyChain microtask.
+	 */
+	#accumulateSnapshotChunk(frame: SnapshotChunkFrame): boolean {
+		const pending = this.#pendingSnapshot;
+		if (!pending) {
+			logger.debug("collab guest dropping orphan snapshot-chunk");
+			return false;
+		}
+		pending.entries.push(...frame.entries);
+		const complete = frame.final || pending.entries.length >= pending.entryCount;
+		if (complete) {
+			this.#clearSnapshotProgressTimer();
+		} else {
+			this.#armSnapshotProgressTimer();
+		}
+		return complete;
+	}
+
+	/** Write the accumulated welcome snapshot to the replica file and (re)load it through the resume machinery. */
+	async #finalizeSnapshot(): Promise<void> {
+		const pending = this.#pendingSnapshot;
+		this.#pendingSnapshot = null;
+		this.#clearSnapshotProgressTimer();
+		if (!pending || this.#left) return;
 		const replicaPath = path.join(getConfigRootDir(), "collab", `${this.#roomId}.jsonl`);
-		const lines = [frame.header, ...frame.entries].map(entry => JSON.stringify(entry)).join("\n");
+		const lines = [pending.header, ...pending.entries].map(entry => JSON.stringify(entry)).join("\n");
 		await Bun.write(replicaPath, `${lines}\n`);
 
 		// Resume sequence (selector-controller.handleResumeSession) minus
@@ -235,20 +353,54 @@ export class CollabGuestLink {
 		this.#clearTransientUi();
 		this.#clearAgentMirror();
 		await this.#ctx.session.switchSession(replicaPath);
-		this.state = frame.state;
-		this.#applyHostState(frame.state);
+		this.state = pending.state;
+		this.#applyHostState(pending.state);
 		this.#ctx.resetObserverRegistry();
-		this.#applyAgentSnapshots(frame.agents);
+		this.#applyAgentSnapshots(pending.agents);
 		this.#assistantStreamSynced = false;
-		setSessionTerminalTitle(frame.state.sessionName ?? frame.header.title, frame.state.cwd);
+		setSessionTerminalTitle(pending.state.sessionName ?? pending.header.title, pending.state.cwd);
 		this.#ctx.chatContainer.clear();
 		this.#ctx.renderInitialMessages({ clearTerminalHistory: true });
 		await this.#ctx.reloadTodos();
 		this.#updateStatusSegment();
-		this.#readOnly = frame.readOnly === true;
+		this.#readOnly = pending.readOnly;
 		this.#welcomed = true;
 		const suffix = this.#readOnly ? " (read-only)" : "";
-		this.#ctx.showStatus(isResync ? `Reconnected to collab session${suffix}` : `Joined collab session${suffix}`);
+		this.#ctx.showStatus(
+			pending.isResync ? `Reconnected to collab session${suffix}` : `Joined collab session${suffix}`,
+		);
+	}
+
+	#armWelcomeTimer(): void {
+		if (this.#joinReject === null) return;
+		this.#clearWelcomeTimer();
+		this.#welcomeTimer = setTimeout(() => {
+			this.#welcomeTimer = null;
+			this.#joinReject?.(new Error("timed out waiting for the host's welcome"));
+		}, WELCOME_TIMEOUT_MS);
+	}
+
+	#clearWelcomeTimer(): void {
+		if (this.#welcomeTimer !== null) {
+			clearTimeout(this.#welcomeTimer);
+			this.#welcomeTimer = null;
+		}
+	}
+
+	#armSnapshotProgressTimer(): void {
+		if (this.#joinReject === null) return;
+		this.#clearSnapshotProgressTimer();
+		this.#snapshotProgressTimer = setTimeout(() => {
+			this.#snapshotProgressTimer = null;
+			this.#joinReject?.(new Error("timed out waiting for the host's session snapshot"));
+		}, SNAPSHOT_PROGRESS_TIMEOUT_MS);
+	}
+
+	#clearSnapshotProgressTimer(): void {
+		if (this.#snapshotProgressTimer !== null) {
+			clearTimeout(this.#snapshotProgressTimer);
+			this.#snapshotProgressTimer = null;
+		}
 	}
 
 	#applyFrame(frame: CollabFrame): void {

package/src/collab/host.ts

@@ -94,6 +94,13 @@ function isWireSessionEntry(entry: StoredSessionEntry): entry is StoredSessionEn
 const CONNECT_TIMEOUT_MS = 15_000;
 /** Max bytes served per fetch-transcript reply (guest re-requests from `newSize`). */
 const TRANSCRIPT_READ_CAP = 4 * 1024 * 1024;
+/**
+ * Soft byte cap per `snapshot-chunk` frame. The first MB of a snapshot takes
+ * ~3s through the default relay, so a 512 KB chunk lands well under the
+ * guest's 30 s per-chunk progress timeout; oversized single entries still
+ * ship in a chunk of their own.
+ */
+const SNAPSHOT_CHUNK_BYTES = 512 * 1024;
 
 /** Display name for this process's user in collab sessions. */
 export function collabDisplayName(ctx: InteractiveModeContext): string {
@@ -323,9 +330,10 @@ export class CollabHost {
 		const canWrite = this.#verifyWriteToken(writeToken);
 		this.#peers.set(fromPeer, { name: cleanName, canWrite });
 
-		// Snapshot and send synchronously: no awaits between snapshot and send, so
-		// later entries/events queue behind the welcome on the same socket and the
-		// guest never sees a gap.
+		// Snapshot and send synchronously: no awaits between snapshot, welcome,
+		// and chunk sends, so subsequent broadcast frames (entry/event/state/bus)
+		// queue behind the snapshot on the same socket and the guest can't
+		// observe a gap between the snapshot fragment and live traffic.
 		const snapshot = this.#ctx.sessionManager.snapshotForReplication();
 		if (JSON.stringify(snapshot).length > WELCOME_IMAGE_STRIP_THRESHOLD) {
 			let stripped = 0;
@@ -335,18 +343,21 @@ export class CollabHost {
 			logger.info("collab welcome exceeded size threshold; stripped images", { stripped });
 		}
 		const entries = snapshot.entries.filter(isWireSessionEntry);
-		this.#socket?.send(
+		const socket = this.#socket;
+		if (!socket) return;
+		socket.send(
 			{
 				t: "welcome",
 				proto: COLLAB_PROTO,
 				header: snapshot.header,
-				entries,
 				state: this.#buildState(),
 				agents: this.#snapshotAgents(),
+				entryCount: entries.length,
 				readOnly: canWrite ? undefined : true,
 			},
 			fromPeer,
 		);
+		this.#sendSnapshotChunks(entries, fromPeer);
 		this.#ctx.session.emitNotice(
 			"info",
 			`${cleanName} joined the collab session${canWrite ? "" : " (read-only)"}`,
@@ -356,6 +367,37 @@ export class CollabHost {
 		this.#scheduleStateBroadcast();
 	}
 
+	/**
+	 * Slice {@link entries} into byte-bounded `snapshot-chunk` frames targeted
+	 * at {@link fromPeer}. Every batch carries at least one entry (a single
+	 * oversize entry ships alone), and the last batch is tagged `final: true`
+	 * so the guest can finalize the replica. An empty snapshot still emits one
+	 * `final` chunk so the guest never blocks on a missing terminator.
+	 */
+	#sendSnapshotChunks(entries: (StoredSessionEntry & WireSessionEntry)[], fromPeer: number): void {
+		const socket = this.#socket;
+		if (!socket) return;
+		if (entries.length === 0) {
+			socket.send({ t: "snapshot-chunk", entries: [], final: true }, fromPeer);
+			return;
+		}
+		let i = 0;
+		while (i < entries.length) {
+			const batch: (StoredSessionEntry & WireSessionEntry)[] = [];
+			let batchBytes = 0;
+			while (i < entries.length) {
+				const entry = entries[i];
+				if (!entry) break;
+				const entryBytes = JSON.stringify(entry).length;
+				if (batch.length > 0 && batchBytes + entryBytes > SNAPSHOT_CHUNK_BYTES) break;
+				batch.push(entry);
+				batchBytes += entryBytes;
+				i++;
+			}
+			socket.send({ t: "snapshot-chunk", entries: batch, final: i >= entries.length }, fromPeer);
+		}
+	}
+
 	#handlePrompt(text: string, images: ImageContent[] | undefined, fromPeer: number): void {
 		const peer = this.#peers.get(fromPeer);
 		if (!peer?.canWrite) {

package/src/collab/protocol.ts

@@ -65,12 +65,27 @@ export type CollabFrame =
 			t: "welcome";
 			proto: number;
 			header: SessionHeader;
-			entries: SessionEntry[];
 			state: CollabSessionState;
 			agents: AgentSnapshot[];
+			/**
+			 * Total number of `SessionEntry` items the host will deliver in the
+			 * `snapshot-chunk` frames that follow. The guest stays in the
+			 * snapshot-loading phase until it has accumulated that many entries
+			 * (or a chunk arrives with `final: true`).
+			 */
+			entryCount: number;
 			/** True when this peer joined through a read-only (view) link. */
 			readOnly?: boolean;
 	  }
+	/**
+	 * Targeted snapshot fragment delivered after `welcome`. Splits a large
+	 * transcript across many small frames so the guest's per-chunk progress
+	 * timeout resets each time the relay delivers another batch; without
+	 * chunking, a multi-MB session has to fit one giant frame inside the
+	 * 30 s first-welcome budget. The last chunk carries `final: true` so the
+	 * guest can finalize the replica session.
+	 */
+	| { t: "snapshot-chunk"; entries: SessionEntry[]; final: boolean }
 	| { t: "entry"; entry: SessionEntry }
 	| { t: "event"; event: AgentSessionEvent }
 	| { t: "state"; state: CollabSessionState }

package/src/config/models-config-schema.ts

@@ -57,6 +57,7 @@ const OpenAICompatFields = {
 	"supportsReasoningParams?": "boolean",
 	"alwaysSendMaxTokens?": "boolean",
 	"strictResponsesPairing?": "boolean",
+	"supportsImageDetailOriginal?": "boolean",
 	// anthropic-messages compat flags (same `compat` slot, per-api interpretation)
 	"requiresToolResultId?": "boolean",
 	"replayUnsignedThinking?": "boolean",

package/src/config/settings-schema.ts

@@ -134,7 +134,7 @@ export const TAB_GROUPS: Record<SettingTab, readonly string[]> = {
 		"Developer",
 	],
 	tasks: ["Modes", "Subagents", "Isolation", "Commands & Skills"],
-	providers: ["Services", "Tiny Model", "Protocol", "Privacy"],
+	providers: ["Services", "Fireworks", "Tiny Model", "Protocol", "Privacy"],
 };
 
 /** Status line segment identifiers */
@@ -413,7 +413,7 @@ export const SETTINGS_SCHEMA = {
 	},
 	"advisor.immuneTurns": {
 		type: "number",
-		default: 1,
+		default: 3,
 		ui: {
 			tab: "model",
 			group: "Advisor",
@@ -422,9 +422,9 @@ export const SETTINGS_SCHEMA = {
 				"After an advisor concern or blocker interrupts, route further concerns/blockers non-interruptingly for this many primary turns.",
 			options: [
 				{ value: "0", label: "0 turns", description: "Allow every concern/blocker to interrupt." },
-				{ value: "1", label: "1 turn", description: "Default." },
+				{ value: "1", label: "1 turn" },
 				{ value: "2", label: "2 turns" },
-				{ value: "3", label: "3 turns" },
+				{ value: "3", label: "3 turns", description: "Default." },
 				{ value: "4", label: "4 turns" },
 				{ value: "5", label: "5 turns" },
 			],
@@ -899,6 +899,28 @@ export const SETTINGS_SCHEMA = {
 			description: "Hide thinking blocks in assistant responses",
 		},
 	},
+	proseOnlyThinking: {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "model",
+			group: "Thinking",
+			label: "Prose Only Thinking",
+			description: "Omit code blocks from thinking summaries and replace them with an ellipsis",
+		},
+	},
+
+	omitThinking: {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "model",
+			group: "Thinking",
+			label: "Omit Thinking summaries",
+			description:
+				"Instruct upstream providers to completely omit thinking summaries from responses (where supported)",
+		},
+	},
 
 	"model.loopGuard.enabled": {
 		type: "boolean",
@@ -1631,7 +1653,7 @@ export const SETTINGS_SCHEMA = {
 	"compaction.strategy": {
 		type: "enum",
 		values: ["context-full", "handoff", "shake", "snapcompact", "off"] as const,
-		default: "context-full",
+		default: "snapcompact",
 		ui: {
 			tab: "context",
 			group: "Compaction",
@@ -2235,6 +2257,18 @@ export const SETTINGS_SCHEMA = {
 			condition: "mnemopiActive",
 		},
 	},
+	"mnemopi.proactiveLinking": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "memory",
+			group: "Mnemopi",
+			label: "Mnemopi Proactive Linking",
+			description:
+				"Ingest new memories into the episodic graph as they are stored, linking them to related entities and memories",
+			condition: "mnemopiActive",
+		},
+	},
 	"mnemopi.noEmbeddings": {
 		type: "boolean",
 		default: false,
@@ -4020,6 +4054,26 @@ export const SETTINGS_SCHEMA = {
 			],
 		},
 	},
+	"providers.fireworksTier": {
+		type: "enum",
+		values: ["standard", "priority"] as const,
+		default: "standard",
+		ui: {
+			tab: "providers",
+			group: "Fireworks",
+			label: "Fireworks Tier",
+			description:
+				'Serving path for Fireworks requests. Priority sends `service_tier: "priority"` for higher reliability during peak traffic at a higher price; Standard omits it. Fast (`-fast`) models ignore this — Fast is its own serving path.',
+			options: [
+				{ value: "standard", label: "Standard", description: "Default serving path (no service_tier)" },
+				{
+					value: "priority",
+					label: "Priority",
+					description: "Priority serving path: higher reliability, premium per-token pricing",
+				},
+			],
+		},
+	},
 	"providers.tts": {
 		type: "enum",
 		values: ["auto", "local", "xai"] as const,

package/src/edit/renderer.ts

@@ -283,7 +283,7 @@ function renderEditHeader(
 	width: number,
 	uiTheme: Theme,
 	options: {
-		icon: "pending" | "success" | "error";
+		icon?: "pending" | "success" | "error";
 		iconOverride?: string;
 		op?: Operation;
 		rawPath: string;
@@ -614,14 +614,12 @@ export const editToolRenderer = {
 		}
 		const callPreviewCaches: RenderedStringCache[] = [];
 		return framedBlock(uiTheme, width => {
-			// Static pending icon, never the animated glyph: the header is the
-			// head row of the framed block, and native-scrollback commits are
-			// prefix-only — an animating head row would pin the commit boundary
-			// at the top and keep a tall expanded preview from scroll-appending
-			// mid-stream. The liveness cue rides the trailing "(preview)" /
+			// No status icon on the head row: it's the head of the framed block,
+			// and native-scrollback commits are prefix-only — an animated glyph
+			// would pin the commit boundary at the top, and the pending hourglass
+			// just adds noise. The liveness cue rides the trailing "(preview)" /
 			// "(streaming)" line instead.
 			const header = renderEditHeader(width, uiTheme, {
-				icon: "pending",
 				op,
 				rawPath,
 				rename,
@@ -796,20 +794,18 @@ function renderMultiFileResult(
 				if (allLines.length > 0) allLines.push("");
 				const spinnerFrame = options.spinnerFrame;
 				const spinner = spinnerFrame !== undefined ? formatStatusIcon("running", uiTheme, spinnerFrame) : "";
+				// Spinner while actively rendering, otherwise no icon — never the
+				// pending hourglass on the head row.
 				allLines.push(
 					renderStatusLine(
 						{
-							icon: "pending",
+							iconOverride: spinner,
 							title: "Edit",
 							description: uiTheme.fg("dim", `${remaining} more file${remaining > 1 ? "s" : ""} pending…`),
 						},
 						uiTheme,
 					),
 				);
-				if (spinner) {
-					// Replace the pending icon with spinner on the last line
-					allLines[allLines.length - 1] = allLines[allLines.length - 1].replace(/^(?:\x1b\[[^m]*m)*./u, spinner);
-				}
 			}
 
 			cached = { key, lines: allLines };

package/src/extensibility/legacy-pi-ai-shim.ts

@@ -19,6 +19,7 @@
  * `types.ts` via the `export *` below — pi-ai still exports both as types,
  * only the runtime `Type` builder and `StringEnum()` helper were removed.
  */
+import { getBundledModel, getBundledModels } from "@oh-my-pi/pi-catalog/models";
 import { type TSchema, Type } from "./typebox";
 
 export interface StringEnumOptions<T extends string> {
@@ -28,10 +29,14 @@ export interface StringEnumOptions<T extends string> {
 	[key: string]: unknown;
 }
 
-function stringEnumWireSchema<T extends string>(values: readonly T[], options: StringEnumOptions<T> | undefined) {
+function stringEnumWireSchema<T extends string | number>(
+	values: readonly T[] | Record<string, T>,
+	options: StringEnumOptions<any> | undefined,
+) {
+	const enumValues = Array.isArray(values) ? [...values] : Object.values(values);
 	const schema: Record<string, unknown> = {
 		type: "string",
-		enum: [...values],
+		enum: enumValues,
 	};
 	if (!options) return schema;
 	for (const key in options) {
@@ -42,12 +47,15 @@ function stringEnumWireSchema<T extends string>(values: readonly T[], options: S
 	return schema;
 }
 
-export function StringEnum<T extends string>(values: readonly T[], options?: StringEnumOptions<T>): TSchema {
+export function StringEnum<T extends string | number>(
+	values: readonly T[] | Record<string, T>,
+	options?: StringEnumOptions<any>,
+): TSchema {
 	const opts = {
 		description: options?.description ?? "Legacy string enum compatibility schema",
 		...options,
 	};
-	const schema: TSchema = values.length === 0 ? Type.Never(opts) : Type.Enum(values, opts);
+	const schema: TSchema = Array.isArray(values) && values.length === 0 ? Type.Never(opts) : Type.Enum(values, opts);
 	Object.defineProperty(schema, "toJSON", {
 		value: () => stringEnumWireSchema(values, options),
 		enumerable: false,
@@ -59,3 +67,7 @@ export function StringEnum<T extends string>(values: readonly T[], options?: Str
 
 export * from "@oh-my-pi/pi-ai";
 export { Type };
+
+/** Compatibility aliases for renamed catalog functions */
+export const getModel = getBundledModel;
+export const getModels = getBundledModels;