@oh-my-pi/pi-coding-agent 15.5.13 → 15.6.0

package/src/config/model-registry.ts

@@ -42,6 +42,12 @@ import {
 	formatCanonicalVariantSelector,
 	type ModelEquivalenceConfig,
 } from "./model-equivalence";
+import {
+	getBracketStrippedModelIdCandidates,
+	getLongestModelLikeIdSegment,
+	getModelLikeIdSegments,
+	stripBracketedModelIdAffixes,
+} from "./model-id-affixes";
 import {
 	type ModelOverride,
 	type ModelsConfig,
@@ -192,7 +198,7 @@ function validateProviderConfiguration(
 		}
 	}
 
-	if (mode === "models-config" && config.discovery && !config.api) {
+	if (mode === "models-config" && config.discovery && !config.api && config.discovery.type !== "proxy") {
 		throw new Error(`Provider ${providerName}: "api" is required when discovery is enabled at provider level.`);
 	}
 
@@ -650,20 +656,53 @@ function shouldReplaceCustomReference(existing: Model<Api> | undefined, candidat
 	return existing.provider !== "openai" && candidate.provider === "openai";
 }
 
+function normalizeCustomReferenceKey(value: string): string {
+	return value.trim().toLowerCase();
+}
+
 function buildCustomReferenceMap(): Map<string, Model<Api>> {
 	const references = new Map<string, Model<Api>>();
 	for (const provider of getBundledProviders()) {
 		for (const model of getBundledModels(provider as Parameters<typeof getBundledModels>[0])) {
 			const candidate = model as Model<Api>;
-			if (shouldReplaceCustomReference(references.get(candidate.id), candidate)) {
-				references.set(candidate.id, candidate);
+			const key = normalizeCustomReferenceKey(candidate.id);
+			if (shouldReplaceCustomReference(references.get(key), candidate)) {
+				references.set(key, candidate);
 			}
 		}
 	}
 	return references;
 }
 
+function buildCustomReferenceSuffixAliasMap(exactReferences: ReadonlyMap<string, Model<Api>>): Map<string, Model<Api>> {
+	const aliases = new Map<string, Model<Api>>();
+	for (const reference of exactReferences.values()) {
+		const slashIndex = reference.id.lastIndexOf("/");
+		if (slashIndex === -1) {
+			continue;
+		}
+		const suffix = reference.id.slice(slashIndex + 1);
+		const alias = getLongestModelLikeIdSegment(suffix);
+		if (!alias) {
+			continue;
+		}
+		if (shouldReplaceCustomReference(aliases.get(alias), reference)) {
+			aliases.set(alias, reference);
+		}
+	}
+	return aliases;
+}
+
 const customReferenceMap = buildCustomReferenceMap();
+const customReferenceSuffixAliasMap = buildCustomReferenceSuffixAliasMap(customReferenceMap);
+
+const CUSTOM_REFERENCE_TRAILING_MARKER_PATTERN =
+	/[-:](?:thinking|customtools|high|low|medium|minimal|xhigh|free|cloud|exacto|nitro|original|optimized|nvfp4|fp8|fp4|bf16|int8|int4|search)$/i;
+
+function stripCustomReferenceTrailingMarker(candidate: string): string | undefined {
+	const match = CUSTOM_REFERENCE_TRAILING_MARKER_PATTERN.exec(candidate);
+	return match ? candidate.slice(0, match.index) : undefined;
+}
 
 function getCustomReferenceCandidateIds(modelId: string): string[] {
 	const candidates = new Set<string>();
@@ -673,23 +712,46 @@ function getCustomReferenceCandidateIds(modelId: string): string[] {
 		if (!candidate || candidates.has(candidate)) continue;
 		candidates.add(candidate);
 
+		for (const stripped of getBracketStrippedModelIdCandidates(candidate)) {
+			queue.push(stripped);
+		}
+		for (const segment of getModelLikeIdSegments(candidate)) {
+			queue.push(segment);
+		}
+
 		for (const suffix of [":cloud", "-cloud"] as const) {
 			if (candidate.toLowerCase().endsWith(suffix)) {
 				queue.push(candidate.slice(0, -suffix.length));
 			}
 		}
 
+		const slashIndex = candidate.lastIndexOf("/");
+		if (slashIndex !== -1) {
+			queue.push(candidate.slice(slashIndex + 1));
+		}
+
 		const colonToDash = candidate.replace(/:/g, "-");
 		if (colonToDash !== candidate) {
 			queue.push(colonToDash);
 		}
+
+		const lowercased = candidate.toLowerCase();
+		if (lowercased !== candidate) {
+			queue.push(lowercased);
+		}
+
+		const strippedMarker = stripCustomReferenceTrailingMarker(candidate);
+		if (strippedMarker) {
+			queue.push(strippedMarker);
+		}
 	}
 	return [...candidates];
 }
 
 function resolveCustomModelReference(modelId: string): Model<Api> | undefined {
 	for (const candidate of getCustomReferenceCandidateIds(modelId)) {
-		const reference = customReferenceMap.get(candidate);
+		const key = normalizeCustomReferenceKey(candidate);
+		const reference = customReferenceMap.get(key) ?? customReferenceSuffixAliasMap.get(key);
 		if (reference) return reference;
 	}
 	return undefined;
@@ -1209,13 +1271,17 @@ export class ModelRegistry {
 				keylessProviders.add(providerName);
 			}
 
-			if (providerConfig.discovery && providerConfig.api) {
+			if (providerConfig.discovery && (providerConfig.api || providerConfig.discovery.type === "proxy")) {
+				const disableStrictCompat = providerConfig.disableStrictTools ? { disableStrictTools: true } : undefined;
 				discoverableProviders.push({
 					provider: providerName,
-					api: providerConfig.api as Api,
+					// Proxy discovery derives per-model api from /v1/models's
+					// supported_endpoint_types; the provider-level api is only a
+					// fallback for entries that don't advertise one.
+					api: (providerConfig.api ?? "openai-completions") as Api,
 					baseUrl: providerConfig.baseUrl,
 					headers: providerConfig.headers,
-					compat: providerConfig.compat,
+					compat: mergeCompat(providerConfig.compat, disableStrictCompat),
 					discovery: providerConfig.discovery,
 					optional: false,
 				});
@@ -1385,6 +1451,8 @@ export class ModelRegistry {
 			case "lm-studio":
 			case "openai-models-list":
 				return this.#discoverOpenAIModelsList(providerConfig);
+			case "proxy":
+				return this.#discoverProxyModels(providerConfig);
 		}
 	}
 
@@ -1711,7 +1779,7 @@ export class ModelRegistry {
 
 		const response = await fetch(modelsUrl, {
 			headers,
-			signal: AbortSignal.timeout(250),
+			signal: AbortSignal.timeout(10_000),
 		});
 		if (!response.ok) {
 			throw new Error(`HTTP ${response.status} from ${modelsUrl}`);
@@ -1746,6 +1814,96 @@ export class ModelRegistry {
 		return this.#applyProviderModelOverrides(providerConfig.provider, discovered);
 	}
 
+	/**
+	 * Discover models from an Anthropic+OpenAI-compatible reseller proxy that
+	 * exposes both `/v1/messages` and `/v1/chat/completions`, advertising each
+	 * model's wire capabilities through `supported_endpoint_types` on
+	 * `GET /v1/models` (new-api / one-api-style proxies).
+	 *
+	 * Routing per model:
+	 *   supported_endpoint_types: ["anthropic", ...] -> api: "anthropic-messages"
+	 *   supported_endpoint_types: ["openai"]         -> api: "openai-completions"
+	 *   missing / neither                            -> provider-level api fallback
+	 *
+	 * Anthropic models share the same baseUrl; the Anthropic SDK strips a
+	 * trailing `/v1` itself before appending `/v1/messages`, so the discovery
+	 * URL (which ends in `/v1`) round-trips correctly.
+	 */
+	async #discoverProxyModels(providerConfig: DiscoveryProviderConfig): Promise<Model<Api>[]> {
+		const baseUrl = this.#normalizeOpenAIModelsListBaseUrl(providerConfig.baseUrl);
+		const modelsUrl = `${baseUrl}/models`;
+
+		const headers: Record<string, string> = { ...(providerConfig.headers ?? {}) };
+		const apiKey = await this.authStorage.getApiKey(providerConfig.provider);
+		if (apiKey && apiKey !== DEFAULT_LOCAL_TOKEN && apiKey !== kNoAuth) {
+			headers.Authorization = `Bearer ${apiKey}`;
+		}
+
+		const response = await fetch(modelsUrl, {
+			headers,
+			signal: AbortSignal.timeout(10_000),
+		});
+		if (!response.ok) {
+			throw new Error(`HTTP ${response.status} from ${modelsUrl}`);
+		}
+		const payload = (await response.json()) as {
+			data?: Array<{ id?: string; name?: string; supported_endpoint_types?: string[] }>;
+		};
+		const items = payload.data ?? [];
+		const discovered: Model<Api>[] = [];
+		for (const item of items) {
+			const id = item.id;
+			if (!id) continue;
+			const endpoints = item.supported_endpoint_types ?? [];
+			const api: Api | undefined = endpoints.includes("anthropic")
+				? "anthropic-messages"
+				: endpoints.includes("openai")
+					? "openai-completions"
+					: providerConfig.api;
+			if (!api) continue;
+			const isAnthropic = api === "anthropic-messages";
+			const reference = resolveCustomModelReference(id);
+			const discoveryName = typeof item.name === "string" ? item.name.trim() : "";
+			const displayName =
+				reference?.name ??
+				(discoveryName && discoveryName !== id ? discoveryName : undefined) ??
+				stripBracketedModelIdAffixes(id) ??
+				id;
+			discovered.push(
+				enrichModelThinking({
+					id,
+					name: displayName,
+					api,
+					provider: providerConfig.provider,
+					baseUrl,
+					reasoning: reference?.reasoning ?? false,
+					thinking: reference?.thinking,
+					input: reference?.input ?? ["text"],
+					// Proxy pricing is provider-specific and usually does not match
+					// upstream bundled catalogs, so keep costs local-unknown even when
+					// we successfully recover the upstream model identity.
+					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+					contextWindow: reference?.contextWindow ?? 128000,
+					maxTokens: reference?.maxTokens ?? 8192,
+					headers,
+					// OpenAI-compat fields are no-ops on anthropic models; the
+					// Anthropic SDK ignores them. Provider-level disableStrictTools
+					// flows in via #applyProviderCompat for the third-party-Anthropic
+					// path. Cross-wire bundled compat is intentionally not copied:
+					// request-shaping fields are provider-wire specific.
+					compat: isAnthropic
+						? undefined
+						: {
+								supportsStore: false,
+								supportsDeveloperRole: false,
+								supportsReasoningEffort: false,
+							},
+				}),
+			);
+		}
+		return this.#applyProviderModelOverrides(providerConfig.provider, discovered);
+	}
+
 	#normalizeLlamaCppBaseUrl(baseUrl?: string): string {
 		const defaultBaseUrl = "http://127.0.0.1:8080";
 		const raw = baseUrl || defaultBaseUrl;

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

@@ -121,7 +121,7 @@ export const ModelOverrideSchema = z.object({
 export type ModelOverride = z.infer<typeof ModelOverrideSchema>;
 
 export const ProviderDiscoverySchema = z.object({
-	type: z.enum(["ollama", "llama.cpp", "lm-studio", "openai-models-list"]),
+	type: z.enum(["ollama", "llama.cpp", "lm-studio", "openai-models-list", "proxy"]),
 });
 
 export const ProviderAuthSchema = z.enum(["apiKey", "none", "oauth"]);

package/src/config/settings-schema.ts

@@ -1,6 +1,14 @@
 import { THINKING_EFFORTS } from "@oh-my-pi/pi-ai";
 import { TASK_SIMPLE_MODES } from "../task/simple-mode";
 import { getThinkingLevelMetadata } from "../thinking";
+import {
+	ONLINE_MEMORY_MODEL_KEY,
+	ONLINE_TINY_TITLE_MODEL_KEY,
+	TINY_MEMORY_MODEL_OPTIONS,
+	TINY_MEMORY_MODEL_VALUES,
+	TINY_TITLE_MODEL_OPTIONS,
+	TINY_TITLE_MODEL_VALUES,
+} from "../tiny/models";
 import { EDIT_MODES } from "../utils/edit-mode";
 
 /** Unified settings schema - single source of truth for all settings.
@@ -81,6 +89,7 @@ export type StatusLineSegmentId =
 	| "hostname"
 	| "cache_read"
 	| "cache_write"
+	| "cache_hit"
 	| "session_name"
 	| "usage";
 
@@ -1291,24 +1300,193 @@ export const SETTINGS_SCHEMA = {
 	"memories.summaryInjectionTokenLimit": { type: "number", default: 5000 },
 
 	// Memory backend selector — picks between local memories pipeline,
-	// Hindsight remote memory, or off. Legacy `memories.enabled` keeps gating
-	// the local backend; see config/settings.ts migration for details.
+	// Mnemosyne local SQLite, Hindsight remote memory, or off. Legacy
+	// `memories.enabled` keeps gating the local backend; see config/settings.ts
+	// migration for details.
 	"memory.backend": {
 		type: "enum",
-		values: ["off", "local", "hindsight"] as const,
+		values: ["off", "local", "hindsight", "mnemosyne"] as const,
 		default: "off",
 		ui: {
 			tab: "memory",
 			label: "Memory Backend",
-			description: "Off, local memory pipeline, or Hindsight remote memory",
+			description: "Off, local summary pipeline, Mnemosyne SQLite, or Hindsight remote memory",
 			options: [
 				{ value: "off", label: "Off", description: "No memory subsystem runs" },
 				{ value: "local", label: "Local", description: "Local rollout summarisation pipeline (memory_summary.md)" },
 				{ value: "hindsight", label: "Hindsight", description: "Vectorize Hindsight remote memory service" },
+				{
+					value: "mnemosyne",
+					label: "Mnemosyne",
+					description: "Local SQLite recall/retain backend with optional embeddings",
+				},
 			],
 		},
 	},
 
+	// Mnemosyne local SQLite memory backend.
+	"mnemosyne.dbPath": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne DB Path",
+			description: "Optional SQLite DB path. Defaults to the agent memories directory.",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.bank": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne Bank",
+			description: "Optional shared bank base name. Per-project modes derive project-local banks from it.",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.scoping": {
+		type: "enum",
+		values: ["global", "per-project", "per-project-tagged"] as const,
+		default: "per-project",
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne Scoping",
+			description:
+				"global = one shared bank; per-project = isolated bank per cwd; per-project-tagged = project-local writes plus global recall visibility",
+			options: [
+				{
+					value: "global",
+					label: "Global",
+					description: "One shared Mnemosyne bank for every project",
+				},
+				{
+					value: "per-project",
+					label: "Per project",
+					description: "Project-local Mnemosyne bank per cwd basename",
+				},
+				{
+					value: "per-project-tagged",
+					label: "Per project (tagged)",
+					description: "Write to a project-local bank but merge project + shared recall results",
+				},
+			],
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.autoRecall": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne Auto Recall",
+			description: "Recall local memories into the first turn of each session",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.autoRetain": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne Auto Retain",
+			description: "Retain completed conversation turns into local Mnemosyne memory",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.noEmbeddings": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne Disable Embeddings",
+			description: "Force deterministic FTS-only recall instead of vector embeddings",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.embeddingModel": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne Embedding Model",
+			description: "Optional embedding model override passed to Mnemosyne",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.embeddingApiUrl": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne Embedding API URL",
+			description: "Optional OpenAI-compatible embedding endpoint passed to Mnemosyne",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.embeddingApiKey": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne Embedding API Key",
+			description: "Optional embedding API key passed to Mnemosyne",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.llmMode": {
+		type: "enum",
+		values: ["none", "smol", "remote"] as const,
+		default: "smol",
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne LLM Mode",
+			description: "Use no LLM, the configured smol model, or a remote OpenAI-compatible endpoint",
+			condition: "mnemosyneActive",
+			options: [
+				{ value: "none", label: "None", description: "Disable Mnemosyne LLM-backed extraction" },
+				{ value: "smol", label: "Smol", description: "Use the configured pi-ai smol model" },
+				{ value: "remote", label: "Remote", description: "Use the Mnemosyne remote LLM settings below" },
+			],
+		},
+	},
+	"mnemosyne.llmBaseUrl": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne LLM Base URL",
+			description: "Optional OpenAI-compatible LLM endpoint for Mnemosyne remote mode",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.llmApiKey": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne LLM API Key",
+			description: "Optional LLM API key for Mnemosyne remote mode",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.llmModel": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "memory",
+			label: "Mnemosyne LLM Model",
+			description: "Optional LLM model name for Mnemosyne remote mode",
+			condition: "mnemosyneActive",
+		},
+	},
+	"mnemosyne.retainEveryNTurns": { type: "number", default: 4 },
+	"mnemosyne.recallLimit": { type: "number", default: 8 },
+	"mnemosyne.recallContextTurns": { type: "number", default: 3 },
+	"mnemosyne.recallMaxQueryChars": { type: "number", default: 4000 },
+	"mnemosyne.injectionTokenLimit": { type: "number", default: 5000 },
+	"mnemosyne.debug": { type: "boolean", default: false },
+
 	// Hindsight (https://hindsight.vectorize.io)
 	"hindsight.apiUrl": {
 		type: "string",
@@ -2016,16 +2194,6 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
-	"calc.enabled": {
-		type: "boolean",
-		default: false,
-		ui: {
-			tab: "tools",
-			label: "Calculator",
-			description: "Enable the calculator tool for basic calculations",
-		},
-	},
-
 	"tts.enabled": {
 		type: "boolean",
 		default: false,
@@ -2736,6 +2904,30 @@ export const SETTINGS_SCHEMA = {
 			],
 		},
 	},
+	"providers.tinyModel": {
+		type: "enum",
+		values: TINY_TITLE_MODEL_VALUES,
+		default: ONLINE_TINY_TITLE_MODEL_KEY,
+		ui: {
+			tab: "providers",
+			label: "Tiny Model",
+			description: "Session-title model: online pi/smol by default, or a local on-device model",
+			options: TINY_TITLE_MODEL_OPTIONS,
+		},
+	},
+	"providers.memoryModel": {
+		type: "enum",
+		values: TINY_MEMORY_MODEL_VALUES,
+		default: ONLINE_MEMORY_MODEL_KEY,
+		ui: {
+			tab: "memory",
+			label: "Memory Model",
+			description:
+				"Mnemosyne LLM for fact extraction + consolidation: online (smol/remote) by default, or a local on-device model",
+			condition: "mnemosyneActive",
+			options: TINY_MEMORY_MODEL_OPTIONS,
+		},
+	},
 
 	"providers.kimiApiFormat": {
 		type: "enum",

package/src/edit/hashline/diff.ts

@@ -11,6 +11,7 @@
  */
 import {
 	Patch as HashlinePatch,
+	missingSnapshotTagMessage,
 	normalizeToLF,
 	type Patch,
 	type PatchSection,
@@ -40,10 +41,6 @@ async function readSectionText(absolutePath: string, sectionPath: string): Promi
 	}
 }
 
-function hasAnchorScoped(section: PatchSection): boolean {
-	return section.hasAnchorScopedEdit;
-}
-
 function snapshotMatchesCurrent(snapshot: Snapshot, currentText: string): boolean {
 	return snapshot.text === currentText;
 }
@@ -54,9 +51,10 @@ function validateSectionHash(
 	snapshots: SnapshotStore,
 ): string | null {
 	if (section.fileHash === undefined) {
-		return hasAnchorScoped(section)
-			? `Missing hashline snapshot tag for anchored edit to ${section.path}; use \`¶${section.path}#tag\` from your latest read.`
-			: null;
+		// The snapshot tag is mandatory on every section — head/tail inserts
+		// included — to keep this preview path in lockstep with the apply path
+		// (`Patcher.prepare`), which rejects tagless sections unconditionally.
+		return missingSnapshotTagMessage(section.path);
 	}
 	const snapshot = snapshots.byHash(absolutePath, section.fileHash);
 	if (snapshot && snapshotMatchesCurrent(snapshot, text)) return null;