@oh-my-pi/pi-coding-agent 16.2.1 → 16.2.2

package/src/session/messages.ts

@@ -18,6 +18,7 @@ import type {
 	TextContent,
 	UserMessage,
 } from "@oh-my-pi/pi-ai";
+import * as AIError from "@oh-my-pi/pi-ai/error";
 import { prompt } from "@oh-my-pi/pi-utils";
 import userInterjectionTemplate from "../prompts/steering/user-interjection.md" with { type: "text" };
 
@@ -70,11 +71,10 @@ export interface SkillPromptDetails {
  *  (fallback error emission) read it via `isSilentAbort`. */
 export const SILENT_ABORT_MARKER = "__omp.silent_abort__";
 
-/** Type-guard for `SILENT_ABORT_MARKER`. Renderers MUST branch on this rather
- *  than string-comparing inline so refactors to the marker constant (e.g.,
- *  namespacing changes) propagate through every consumer in lockstep. */
-export function isSilentAbort(errorMessage: string | undefined): boolean {
-	return errorMessage === SILENT_ABORT_MARKER;
+/** Type-guard for silent aborts. Renderers MUST call this helper so structured
+ *  `errorId` and legacy persisted marker messages stay in lockstep. */
+export function isSilentAbort(message: Pick<AssistantMessage, "errorId" | "errorMessage">): boolean {
+	return AIError.is(message.errorId, AIError.Flag.SilentAbort) || message.errorMessage === SILENT_ABORT_MARKER;
 }
 
 /** Reason threaded through `AbortController.abort(reason)` when the user aborts
@@ -84,12 +84,12 @@ export function isSilentAbort(errorMessage: string | undefined): boolean {
  *  abort, but interactive renderers suppress this redundant transcript line. */
 export const USER_INTERRUPT_LABEL = "Interrupted by user";
 
-export function isUserInterruptAbort(errorMessage: string | undefined): boolean {
-	return errorMessage === USER_INTERRUPT_LABEL;
+export function isUserInterruptAbort(message: Pick<AssistantMessage, "errorId" | "errorMessage">): boolean {
+	return AIError.is(message.errorId, AIError.Flag.UserInterrupt) || message.errorMessage === USER_INTERRUPT_LABEL;
 }
 
-export function shouldRenderAbortReason(errorMessage: string | undefined): boolean {
-	return !isSilentAbort(errorMessage) && !isUserInterruptAbort(errorMessage);
+export function shouldRenderAbortReason(message: Pick<AssistantMessage, "errorId" | "errorMessage">): boolean {
+	return !isSilentAbort(message) && !isUserInterruptAbort(message);
 }
 
 /** Sentinel `errorMessage` the agent stamps on any abort that carried no custom
@@ -101,9 +101,17 @@ export const GENERIC_ABORT_SENTINEL = "Request was aborted";
  *  no threaded reason fall back to the retry-aware generic label. Call
  *  `shouldRenderAbortReason` before rendering when user interrupts should stay
  *  visually quiet. */
-export function resolveAbortLabel(errorMessage: string | undefined, retryAttempt = 0): string {
-	if (errorMessage && errorMessage !== GENERIC_ABORT_SENTINEL && !isSilentAbort(errorMessage)) {
-		return errorMessage;
+export function resolveAbortLabel(
+	message: Pick<AssistantMessage, "errorId" | "errorMessage">,
+	retryAttempt = 0,
+): string {
+	const genericAbort =
+		AIError.is(message.errorId, AIError.Flag.Abort) ||
+		!message.errorMessage ||
+		message.errorMessage === GENERIC_ABORT_SENTINEL ||
+		isSilentAbort(message);
+	if (!genericAbort) {
+		return message.errorMessage!;
 	}
 	if (retryAttempt > 0) {
 		return `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`;

package/src/session/session-persistence.ts

@@ -110,9 +110,8 @@ function truncateForPersistence(obj: unknown, blobStore: BlobStore, key?: string
 		const entries: Array<readonly [string, unknown]> = [];
 		for (const [childKey, value] of Object.entries(obj)) {
 			// Strip transient/redundant properties that shouldn't be persisted.
-			// - partialJson: streaming accumulator for tool call JSON parsing
 			// - jsonlEvents: raw subprocess streaming events (already saved to artifact files)
-			if (childKey === "partialJson" || childKey === "jsonlEvents") {
+			if (childKey === "jsonlEvents") {
 				changed = true;
 				continue;
 			}

package/src/session/settings-stream-fn.ts

@@ -0,0 +1,49 @@
+/**
+ * Settings-aware stream wrapper shared by the main agent (sdk.ts) and the
+ * advisor agent (AgentSession.#buildAdvisorRuntime).
+ *
+ * Reads OpenRouter / Antigravity routing variants, Responses-family text
+ * verbosity, per-provider in-flight caps, and the loop guard out of `Settings`
+ * per request, layering them onto whatever options the caller passed. Before
+ * this helper existed, advisor turns called bare `streamSimple` while the main
+ * turn went through an inline closure that read these settings — so an advisor on
+ * OpenRouter never saw `providers.openrouterVariant`, breaking sticky routing
+ * and OpenRouter response-cache hits across advisor calls.
+ */
+import type { StreamFn } from "@oh-my-pi/pi-agent-core";
+import { type SimpleStreamOptions, streamSimple } from "@oh-my-pi/pi-ai";
+import { type Settings, validateProviderMaxInFlightRequests } from "../config/settings";
+
+/**
+ * Build a {@link StreamFn} that reads provider routing/guard settings from
+ * `settings` per call and forwards to `base` (defaults to `streamSimple`).
+ *
+ * Caller-supplied `streamOptions` always win — the helper only fills holes.
+ */
+export function createSettingsAwareStreamFn(settings: Settings, base: StreamFn = streamSimple): StreamFn {
+	return (model, context, streamOptions) => {
+		const openrouterRoutingPreset = settings.get("providers.openrouterVariant");
+		const openrouterVariant =
+			openrouterRoutingPreset && openrouterRoutingPreset !== "default" ? openrouterRoutingPreset : undefined;
+		const antigravityEndpointMode = settings.get("providers.antigravityEndpoint");
+		const textVerbosity =
+			model.api === "openai-codex-responses" || model.api === "openai-responses"
+				? settings.get("textVerbosity")
+				: undefined;
+		const merged: SimpleStreamOptions = {
+			...streamOptions,
+			openrouterVariant: streamOptions?.openrouterVariant ?? openrouterVariant,
+			antigravityEndpointMode: streamOptions?.antigravityEndpointMode ?? antigravityEndpointMode,
+			textVerbosity: streamOptions?.textVerbosity ?? textVerbosity,
+			maxInFlightRequests: validateProviderMaxInFlightRequests(
+				streamOptions?.maxInFlightRequests ?? settings.get("providers.maxInFlightRequests"),
+			),
+			loopGuard: {
+				enabled: settings.get("model.loopGuard.enabled"),
+				checkAssistantContent: settings.get("model.loopGuard.checkAssistantContent"),
+				...streamOptions?.loopGuard,
+			},
+		};
+		return base(model, context, merged);
+	};
+}

package/src/session/turn-persistence.ts

@@ -0,0 +1,142 @@
+/**
+ * Helpers that share one cheap, structural identity for messages — both during
+ * incremental persistence and for the mid-run-compaction ordering check.
+ *
+ * Previously `AgentSession` carried two near-duplicate routines
+ * (`#sessionMessagesReferToSameTurn` + `#messageValueSignature`) that
+ * reconstructed the branch path on every check (O(n²) `unshift`) and
+ * `JSON.stringify`-compared the full message content on every pairwise hit.
+ * Long-running sessions with many subagents fired this thousands of times per
+ * minute and froze the TUI loop (see issue #3629). The persistence key already
+ * encodes a stable logical identity — timestamp + role-specific discriminators
+ * — so the structural compare is now the rare collision tiebreaker (e.g. two
+ * provider responses at the same millisecond with `undefined` responseId),
+ * not the load-bearing check.
+ *
+ * The helpers here keep that identity in one place and expose the planner so
+ * the persistence-ordering logic is unit-testable without standing up an
+ * `AgentSession`.
+ */
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+
+/**
+ * Stable identity for messages that pass through {@link AgentSession}'s
+ * incremental persistence path.
+ *
+ * The discriminators chosen per role are precisely the fields that uniquely
+ * identify a single logical message instance:
+ *
+ * - `assistant` — timestamp + provider + model + responseId + stopReason
+ *   (responseId is the canonical provider-side id when available; the rest
+ *   disambiguate when it is not, e.g. local/dev models).
+ * - `toolResult` — timestamp + toolCallId + toolName (toolCallId is unique
+ *   per execution; toolName guards against synthetic reuse).
+ * - `user` / `developer` — timestamp + attribution (attribution distinguishes
+ *   user-typed vs hook-injected at the same wall-clock millisecond).
+ * - `fileMention` — timestamp.
+ *
+ * Returns `undefined` for message roles that are not persisted through this
+ * path (e.g. `hookMessage`, `custom`, `bashExecution`) — those follow other
+ * append paths in `SessionManager`.
+ */
+export function sessionMessagePersistenceKey(message: AgentMessage): string | undefined {
+	switch (message.role) {
+		case "assistant":
+			return [
+				"assistant",
+				message.timestamp,
+				message.provider,
+				message.model,
+				message.responseId ?? "",
+				message.stopReason,
+			].join(":");
+		case "toolResult":
+			return `toolResult:${message.timestamp}:${message.toolCallId}:${message.toolName}`;
+		case "user":
+		case "developer":
+			return `${message.role}:${message.timestamp}:${message.attribution ?? ""}`;
+		case "fileMention":
+			return `fileMention:${message.timestamp}`;
+		default:
+			return undefined;
+	}
+}
+
+/**
+ * Slow-path content equality check used when two messages collide on
+ * {@link sessionMessagePersistenceKey}. Only the role's content fields are
+ * compared (no timestamps, no metadata) because the key already pinned all of
+ * those down.
+ *
+ * Most calls into the persistence path never reach this — keys are unique
+ * enough in production that the snapshot lookup short-circuits at the key
+ * level. Restoring the structural compare here preserves the pre-#3629
+ * contract that two messages with the same metadata BUT different content are
+ * distinct (e.g. two assistant turns with `undefined` responseId emitted in
+ * the same wall-clock millisecond, which is exactly how the in-memory test
+ * harness crafts streamed responses).
+ */
+export function sameMessageContent(left: AgentMessage, right: AgentMessage): boolean {
+	if (left === right) return true;
+	if (left.role !== right.role) return false;
+	// `JSON.stringify` is the slow-path serializer here on purpose: nothing on
+	// the hot persistence-check path reaches it (key lookup short-circuits
+	// first), so a stable lexicographic compare beats hand-rolling structural
+	// equality for content arrays that mix text / tool blocks / file refs.
+	const leftRaw = left.role === "fileMention" ? left.files : "content" in left ? left.content : undefined;
+	const rightRaw = right.role === "fileMention" ? right.files : "content" in right ? right.content : undefined;
+	if (leftRaw === undefined || rightRaw === undefined) return false;
+	return (JSON.stringify(leftRaw) ?? "undefined") === (JSON.stringify(rightRaw) ?? "undefined");
+}
+
+/**
+ * Outcome of {@link planTurnPersistence}.
+ *
+ * `ok` lists the turn-message indices that still need to be appended (in
+ * order). `out-of-order` reports the first message whose later sibling is
+ * already persisted — the caller bails so it does not silently splice a
+ * stale message between newer entries on the live branch.
+ */
+export type TurnPersistencePlan =
+	| { kind: "ok"; toPersist: readonly number[] }
+	| { kind: "out-of-order"; messageIndex: number };
+
+/**
+ * Decide what to do with a turn's messages relative to what's already on the
+ * branch, in a single pass over the pre-computed keys.
+ *
+ * @param turnKeys persistence keys for each turn message, in the order the
+ *   agent loop emitted them. `undefined` slots represent messages with no
+ *   persistence key (skipped silently).
+ * @param persistedKeys the snapshot of persistence keys currently on the
+ *   branch (built once per call from {@link sessionMessagePersistenceKey} for
+ *   each persisted message entry).
+ *
+ * The check is O(n²) over turn messages — but `n` here is the size of one
+ * turn (a handful of tool results), not the size of the branch. That's the
+ * point of this refactor: the expensive O(branch) work happens exactly once,
+ * inside the caller's snapshot loop, not per-comparison.
+ */
+export function planTurnPersistence(
+	turnKeys: readonly (string | undefined)[],
+	persistedKeys: ReadonlySet<string>,
+): TurnPersistencePlan {
+	const toPersist: number[] = [];
+	for (let index = 0; index < turnKeys.length; index++) {
+		const key = turnKeys[index];
+		// Slots without a persistence key (non-persistent roles like `custom` /
+		// `hookMessage`) take other branches in `SessionManager` — they are not
+		// our responsibility to append, and they cannot violate ordering because
+		// they have no identity on the branch.
+		if (key === undefined) continue;
+		if (persistedKeys.has(key)) continue;
+		for (let later = index + 1; later < turnKeys.length; later++) {
+			const laterKey = turnKeys[later];
+			if (laterKey !== undefined && persistedKeys.has(laterKey)) {
+				return { kind: "out-of-order", messageIndex: index };
+			}
+		}
+		toPersist.push(index);
+	}
+	return { kind: "ok", toPersist };
+}

package/src/session/unexpected-stop-classifier.ts

@@ -64,10 +64,10 @@ export async function classifyUnexpectedStop(
 }
 
 async function classifyOnline(text: string, deps: ClassifyUnexpectedStopDeps): Promise<boolean | undefined> {
-	const resolved = resolveRoleSelection(["smol"], deps.settings, deps.registry.getAvailable(), deps.registry);
+	const resolved = resolveRoleSelection(["tiny", "smol"], deps.settings, deps.registry.getAvailable(), deps.registry);
 	const model = resolved?.model;
 	if (!model) {
-		throw new Error("unexpected-stop: no smol model available for classification");
+		throw new Error("unexpected-stop: no tiny/smol model available for classification");
 	}
 	const apiKey = await deps.registry.getApiKey(model, deps.sessionId);
 	if (!apiKey) {

package/src/slash-commands/helpers/mcp.ts

@@ -1,3 +1,4 @@
+import * as AIError from "@oh-my-pi/pi-ai/error";
 import { getMCPConfigPath, logger } from "@oh-my-pi/pi-utils";
 import { connectToServer, disconnectServer, listPrompts, listResources, listTools } from "../../mcp/client";
 import {
@@ -350,7 +351,7 @@ async function handleSmitherySearchCommand(rest: string, runtime: SlashCommandRu
 		return commandConsumed();
 	} catch (err) {
 		const message = errorMessage(err);
-		if (/401|403|unauthorized|forbidden/i.test(message)) {
+		if (AIError.is(AIError.classify(err), AIError.Flag.AuthFailed)) {
 			return usage(
 				"Smithery authentication required. Run /mcp smithery-login in the TUI client or add an API key to ~/.omp/agent/smithery.json.",
 				runtime,

package/src/tiny/models.ts

@@ -87,8 +87,9 @@ void TINY_TITLE_MODEL_VALUES_MATCH_REGISTRY;
 export const TINY_TITLE_MODEL_OPTIONS = [
 	{
 		value: ONLINE_TINY_TITLE_MODEL_KEY,
-		label: "Online (pi/smol)",
-		description: "Current online title generation path; no local model download or on-device inference.",
+		label: "Online (TINY role, else pi/smol)",
+		description:
+			"Online title generation: the TINY model role (set one in /models) when assigned, otherwise the online fallback (commit role, then pi/smol). No local download or on-device inference.",
 	},
 	...TINY_TITLE_LOCAL_MODELS.map(model => ({
 		value: model.key,
@@ -183,9 +184,9 @@ void TINY_MEMORY_MODEL_VALUES_MATCH_REGISTRY;
 export const TINY_MEMORY_MODEL_OPTIONS = [
 	{
 		value: ONLINE_MEMORY_MODEL_KEY,
-		label: "Online (smol/remote)",
+		label: "Online (TINY role, else smol)",
 		description:
-			"Use the configured Mnemopi LLM mode (smol or remote); no local model download or on-device inference.",
+			"Use the online model: the TINY role from /models when set, otherwise pi/smol. No local model download or on-device inference.",
 	},
 	...TINY_MEMORY_LOCAL_MODELS.map(model => ({
 		value: model.key,
@@ -245,8 +246,9 @@ export type AutoThinkingModelKey = TinyMemoryModelKey;
 export const AUTO_THINKING_MODEL_OPTIONS = [
 	{
 		value: ONLINE_AUTO_THINKING_MODEL_KEY,
-		label: "Online (smol)",
-		description: "Classify prompt difficulty with the online smol model; no local download or on-device inference.",
+		label: "Online (TINY role, else smol)",
+		description:
+			"Classify prompt difficulty online with the TINY role model (set one in /models) or pi/smol; no local download or on-device inference.",
 	},
 	...TINY_MEMORY_LOCAL_MODELS.map(model => ({
 		value: model.key,

package/src/tiny/text.ts

@@ -173,14 +173,15 @@ export function normalizeGeneratedTitle(value: string | null | undefined, source
  * (`TinyVMM` → `tinyvmm`). The user's message is the source of truth, so per
  * title token:
  *  1. typed verbatim in the message → keep it (the user established the casing);
- *  2. else the message has the same word with *distinctive* casing
- *     (`TinyVMM`, `iOS`, `API`) → adopt the user's casing (restoration);
+ *  2. else the message has the same word with *distinctive* mixed casing
+ *     (`TinyVMM`, `iOS`, `IDs`) → adopt the user's casing (restoration);
  *  3. else it's a camelCase artifact (lowercase word + stray interior capital,
  *     `dAemon`) the user never wrote → lowercase it;
  *  4. else leave it — preserves model-cased proper nouns like `GitHub`, `OAuth`.
  *
- * Restoration is limited to distinctively cased source tokens so a sentence that
- * merely *starts* with `For` can't force a mid-title `for` to `For`.
+ * Restoration is limited to distinctively *mixed*-cased source tokens: a sentence
+ * that merely *starts* with `For` can't force a mid-title `for` to `For`, and
+ * emphatic all-caps (`ALL ERROR HANDLING`) is never re-shouted over sentence case.
  */
 function reconcileTitleCasing(title: string, sourceText: string): string {
 	const verbatim = new Set<string>();
@@ -200,10 +201,16 @@ function reconcileTitleCasing(title: string, sourceText: string): string {
 	});
 }
 
-/** Casing richer than a leading capital — interior or repeated uppercase
- *  (`TinyVMM`, `iOS`, `API`). Worth restoring from the user's message. */
+/** Mixed-case identifier the user cased deliberately (`TinyVMM`, `iOS`, `IDs`):
+ *  an interior/repeated capital plus at least one lowercase letter. Only these
+ *  are restored when the model flattens them.
+ *
+ *  Pure all-caps is intentionally excluded. The model preserves its own acronyms
+ *  verbatim regardless, so restoring all-caps from the source would only ever
+ *  re-shout emphatic input (`ALL ERROR HANDLING`, `FIX THE BUG`) over the
+ *  sentence case the prompt asks for. */
 function isDistinctiveCasing(token: string): boolean {
-	return /\p{L}\p{Lu}/u.test(token);
+	return /\p{Ll}/u.test(token) && /\p{L}\p{Lu}/u.test(token);
 }
 
 /** A lowercase word carrying a stray interior capital (`dAemon`, `cReate`): the

package/src/tools/image-gen.ts

@@ -1,6 +1,7 @@
 import * as os from "node:os";
 import * as path from "node:path";
-import { type ApiKey, type FetchImpl, getEnvApiKey, type Model, ProviderHttpError, withAuth } from "@oh-my-pi/pi-ai";
+import { type ApiKey, type FetchImpl, getEnvApiKey, type Model, withAuth } from "@oh-my-pi/pi-ai";
+import { ProviderHttpError } from "@oh-my-pi/pi-ai/error";
 import {
 	CODEX_BASE_URL,
 	getCodexAccountId,

package/src/tools/tts.ts

@@ -4,7 +4,8 @@
 // the `providers.tts` switch.
 
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { type ApiKey, ProviderHttpError, withAuth } from "@oh-my-pi/pi-ai";
+import { type ApiKey, withAuth } from "@oh-my-pi/pi-ai";
+import { ProviderHttpError } from "@oh-my-pi/pi-ai/error";
 import { type } from "arktype";
 import { settings } from "../config/settings";
 import type { CustomTool, CustomToolContext } from "../extensibility/custom-tools/types";

package/src/utils/title-generator.ts

@@ -72,7 +72,7 @@ function getTitleModel(registry: ModelRegistry, settings: Settings, currentModel
 	const availableModels = registry.getAvailable();
 	if (availableModels.length === 0) return undefined;
 
-	const titleModel = resolveRoleSelection(["title", "commit", "smol"], settings, availableModels, registry)?.model;
+	const titleModel = resolveRoleSelection(["tiny", "commit", "smol"], settings, availableModels, registry)?.model;
 	if (titleModel) return titleModel;
 
 	if (currentModel) return currentModel;

package/src/web/search/providers/tavily.ts

@@ -120,25 +120,7 @@ async function callTavilySearch(apiKey: string, params: TavilySearchParams): Pro
 	return (await response.json()) as TavilySearchResponse;
 }
 
-/** Execute Tavily web search. */
-export async function searchTavily(params: SearchParams): Promise<SearchResponse> {
-	const tavilyParams: TavilySearchParams = {
-		query: params.query,
-		num_results: params.numSearchResults ?? params.limit,
-		recency: params.recency,
-		signal: params.signal,
-		fetch: params.fetch,
-	};
-	const keyOrResolver: ApiKey = params.authStorage.resolver("tavily", {
-		sessionId: params.sessionId,
-	});
-
-	const numResults = clampNumResults(tavilyParams.num_results, DEFAULT_NUM_RESULTS, MAX_NUM_RESULTS);
-	const response = await withAuth(keyOrResolver, key => callTavilySearch(key, tavilyParams), {
-		signal: params.signal,
-		missingKeyMessage:
-			'Tavily credentials not found. Set TAVILY_API_KEY or configure an API key for provider "tavily".',
-	});
+function toSearchResponse(response: TavilySearchResponse, numResults: number): SearchResponse {
 	const sources: SearchSource[] = [];
 
 	for (const result of response.results ?? []) {
@@ -161,6 +143,41 @@ export async function searchTavily(params: SearchParams): Promise<SearchResponse
 	};
 }
 
+function hasRenderableResponse(response: SearchResponse): boolean {
+	if (response.answer?.trim()) return true;
+	return response.sources.length > 0;
+}
+
+/** Execute Tavily web search. */
+export async function searchTavily(params: SearchParams): Promise<SearchResponse> {
+	const tavilyParams: TavilySearchParams = {
+		query: params.query,
+		num_results: params.numSearchResults ?? params.limit,
+		recency: params.recency,
+		signal: params.signal,
+		fetch: params.fetch,
+	};
+	const keyOrResolver: ApiKey = params.authStorage.resolver("tavily", {
+		sessionId: params.sessionId,
+	});
+
+	const numResults = clampNumResults(tavilyParams.num_results, DEFAULT_NUM_RESULTS, MAX_NUM_RESULTS);
+	const authOptions = {
+		signal: params.signal,
+		missingKeyMessage:
+			'Tavily credentials not found. Set TAVILY_API_KEY or configure an API key for provider "tavily".',
+	};
+	const callWithAuth = (searchParams: TavilySearchParams) =>
+		withAuth(keyOrResolver, key => callTavilySearch(key, searchParams), authOptions);
+
+	const response = toSearchResponse(await callWithAuth(tavilyParams), numResults);
+	if (!tavilyParams.recency || hasRenderableResponse(response)) {
+		return response;
+	}
+
+	return toSearchResponse(await callWithAuth({ ...tavilyParams, recency: undefined }), numResults);
+}
+
 /** Search provider for Tavily web search. */
 export class TavilyProvider extends SearchProvider {
 	readonly id = "tavily";