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

package/dist/types/tools/memory-render.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Inline TUI renderers for the long-term memory tools (`retain`, `recall`,
+ * `reflect`).
+ *
+ * These keep the transcript terse — one status line plus, for `retain`, one
+ * `Remember: …` line per stored item — instead of the generic JSON arg tree,
+ * which exploded multi-line memory blobs into an unreadable wall.
+ */
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+interface RetainRenderArgs {
+    items?: Array<{
+        content?: string;
+        context?: string;
+    }>;
+}
+interface QueryRenderArgs {
+    query?: string;
+}
+export declare const retainToolRenderer: {
+    inline: boolean;
+    mergeCallAndResult: boolean;
+    renderCall(args: RetainRenderArgs, options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: {
+            count?: number;
+        };
+        isError?: boolean;
+    }, options: RenderResultOptions, theme: Theme, args?: RetainRenderArgs): Component;
+};
+export declare const recallToolRenderer: {
+    inline: boolean;
+    mergeCallAndResult: boolean;
+    renderCall(args: QueryRenderArgs, _options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        isError?: boolean;
+    }, options: RenderResultOptions, theme: Theme, args?: QueryRenderArgs): Component;
+};
+export declare const reflectToolRenderer: {
+    inline: boolean;
+    mergeCallAndResult: boolean;
+    renderCall(args: QueryRenderArgs, _options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        isError?: boolean;
+    }, options: RenderResultOptions, theme: Theme, args?: QueryRenderArgs): Component;
+};
+export {};

package/dist/types/tools/{hindsight-retain.d.ts → memory-retain.d.ts}

@@ -1,14 +1,14 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import * as z from "zod/v4";
 import type { ToolSession } from ".";
-declare const hindsightRetainSchema: z.ZodObject<{
+declare const memoryRetainSchema: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
         content: z.ZodString;
         context: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export type HindsightRetainParams = z.infer<typeof hindsightRetainSchema>;
-export declare class HindsightRetainTool implements AgentTool<typeof hindsightRetainSchema> {
+export type MemoryRetainParams = z.infer<typeof memoryRetainSchema>;
+export declare class MemoryRetainTool implements AgentTool<typeof memoryRetainSchema> {
     private readonly session;
     readonly name = "retain";
     readonly approval: "read";
@@ -22,9 +22,9 @@ export declare class HindsightRetainTool implements AgentTool<typeof hindsightRe
     }, z.core.$strip>;
     readonly strict = true;
     readonly loadMode = "discoverable";
-    readonly summary = "Store important facts in hindsight memory";
+    readonly summary = "Store important facts in long-term memory";
     constructor(session: ToolSession);
-    static createIf(session: ToolSession): HindsightRetainTool | null;
-    execute(_id: string, params: HindsightRetainParams): Promise<AgentToolResult>;
+    static createIf(session: ToolSession): MemoryRetainTool | null;
+    execute(_id: string, params: MemoryRetainParams): Promise<AgentToolResult>;
 }
 export {};

package/dist/types/tools/todo-write.d.ts

@@ -21,9 +21,14 @@ export interface TodoPhase {
     name: string;
     tasks: TodoItem[];
 }
+export interface TodoCompletionTransition {
+    phase: string;
+    content: string;
+}
 export interface TodoWriteToolDetails {
     phases: TodoPhase[];
     storage: "session" | "memory";
+    completedTasks?: TodoCompletionTransition[];
 }
 declare const todoWriteSchema: z.ZodObject<{
     ops: z.ZodArray<z.ZodObject<{
@@ -137,6 +142,9 @@ type TodoWriteRenderArgs = {
 export declare function phaseRomanNumeral(oneBasedIndex: number): string;
 /** Display-only phase header: `I. Foundation`. State and prompts never see this. */
 export declare function formatPhaseDisplayName(name: string, oneBasedIndex: number): string;
+export declare const TODO_WRITE_STRIKE_HOLD_FRAMES = 2;
+export declare const TODO_WRITE_STRIKE_REVEAL_FRAMES = 12;
+export declare const TODO_WRITE_STRIKE_TOTAL_FRAMES: number;
 export declare const todoWriteToolRenderer: {
     renderCall(args: TodoWriteRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
     renderResult(result: {

package/dist/types/tools/tool-result.d.ts

@@ -24,6 +24,8 @@ export declare class ToolResultBuilder<TDetails extends DetailsWithMeta> {
     sourcePath(value: string): this;
     sourceInternal(value: string): this;
     diagnostics(summary: string, messages: string[]): this;
+    /** Flag the result as a non-throwing failure (agent-loop surfaces it as a tool error). */
+    error(value?: boolean): this;
     done(): AgentToolResult<TDetails>;
 }
 export declare function toolResult<TDetails extends DetailsWithMeta>(details?: TDetails): ToolResultBuilder<TDetails>;

package/dist/types/utils/title-generator.d.ts

@@ -1,6 +1,8 @@
 import { type Api, type Model } from "@oh-my-pi/pi-ai";
 import type { ModelRegistry } from "../config/model-registry";
 import type { Settings } from "../config/settings";
+export declare const TITLE_LOCAL_FALLBACK_DELAY_MS = 10000;
+export declare function raceFirstNonNull<T>(primary: Promise<T | null>, startFallback: () => Promise<T | null>, delayMs?: number, onPrimaryWinAfterFallback?: () => void): Promise<T | null>;
 /**
  * Generate a title for a session based on the first user message.
  *
@@ -15,6 +17,7 @@ import type { Settings } from "../config/settings";
  *   reflects the credential actually selected for this request.
  */
 export declare function generateSessionTitle(firstMessage: string, registry: ModelRegistry, settings: Settings, sessionId?: string, currentModel?: Model<Api>, metadataResolver?: (provider: string) => Record<string, unknown> | undefined): Promise<string | null>;
+export declare function generateTitleOnline(firstMessage: string, registry: ModelRegistry, settings: Settings, sessionId?: string, currentModel?: Model<Api>, metadataResolver?: (provider: string) => Record<string, unknown> | undefined, signal?: AbortSignal): Promise<string | null>;
 export declare function formatSessionTerminalTitle(sessionName: string | undefined, cwd?: string): string;
 /**
  * Set the terminal title using OSC 0 (sets both tab and window title). Unsupported terminals ignore it.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.5.13",
+	"version": "15.6.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -44,31 +44,35 @@
 		"generate-template": "bun scripts/generate-template.ts"
 	},
 	"dependencies": {
-		"@agentclientprotocol/sdk": "0.21.0",
-		"@babel/parser": "^7.29.3",
+		"@agentclientprotocol/sdk": "0.22.1",
+		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "15.5.13",
-		"@oh-my-pi/omp-stats": "15.5.13",
-		"@oh-my-pi/pi-agent-core": "15.5.13",
-		"@oh-my-pi/pi-ai": "15.5.13",
-		"@oh-my-pi/pi-natives": "15.5.13",
-		"@oh-my-pi/pi-tui": "15.5.13",
-		"@oh-my-pi/pi-utils": "15.5.13",
-		"@puppeteer/browsers": "^2.13.0",
+		"@oh-my-pi/hashline": "15.6.0",
+		"@oh-my-pi/omp-stats": "15.6.0",
+		"@oh-my-pi/pi-agent-core": "15.6.0",
+		"@oh-my-pi/pi-ai": "15.6.0",
+		"@oh-my-pi/pi-mnemosyne": "15.6.0",
+		"@oh-my-pi/pi-natives": "15.6.0",
+		"@oh-my-pi/pi-tui": "15.6.0",
+		"@oh-my-pi/pi-utils": "15.6.0",
+		"@puppeteer/browsers": "^3.0.4",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",
 		"chalk": "^5.6.2",
 		"diff": "^9.0.0",
-		"fflate": "0.8.2",
+		"fflate": "0.8.3",
 		"handlebars": "^4.7.9",
 		"linkedom": "^0.18.12",
-		"lru-cache": "11.3.6",
+		"lru-cache": "11.5.1",
 		"markit-ai": "0.5.3",
-		"puppeteer-core": "^24.42.0",
+		"puppeteer-core": "^25.1.0",
 		"turndown": "7.2.4",
 		"turndown-plugin-gfm": "1.0.2",
 		"zod": "4.4.3"
 	},
+	"optionalDependencies": {
+		"@huggingface/transformers": "^4.2.0"
+	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"
 	},

package/scripts/build-binary.ts

@@ -56,6 +56,7 @@ async function main(): Promise<void> {
 					"../stats/src/sync-worker.ts",
 					"./src/tools/browser/tab-worker-entry.ts",
 					"./src/eval/js/worker-entry.ts",
+					"./src/tiny/worker.ts",
 					// Legacy pi-* extension compat entrypoints served by
 					// `legacy-pi-compat.ts`. These are reached via computed bunfs paths
 					// (which `--compile`'s static analyzer cannot trace), so each must be

package/src/cli/tiny-models-cli.ts

@@ -0,0 +1,127 @@
+import { formatBytes } from "@oh-my-pi/pi-utils";
+import chalk from "chalk";
+import {
+	DEFAULT_TINY_TITLE_LOCAL_MODEL_KEY,
+	getTinyLocalModelSpec,
+	isTinyLocalModelKey,
+	TINY_LOCAL_MODELS,
+	type TinyLocalModelKey,
+} from "../tiny/models";
+import { shutdownTinyTitleClient, tinyTitleClient } from "../tiny/title-client";
+import type { TinyTitleProgressEvent } from "../tiny/title-protocol";
+
+export type TinyModelsAction = "download" | "list";
+
+export interface TinyModelsCommandArgs {
+	action: TinyModelsAction;
+	model?: string;
+	flags: {
+		json?: boolean;
+	};
+}
+
+interface ProgressReporter {
+	onProgress(event: TinyTitleProgressEvent): void;
+	finish(ok: boolean): void;
+}
+
+interface DownloadResult {
+	model: TinyLocalModelKey;
+	ok: boolean;
+}
+
+function writeLine(text = ""): void {
+	process.stdout.write(`${text}\n`);
+}
+
+function resolveModels(model: string | undefined): TinyLocalModelKey[] {
+	if (!model) return [DEFAULT_TINY_TITLE_LOCAL_MODEL_KEY];
+	if (model === "all") return TINY_LOCAL_MODELS.map(spec => spec.key);
+	if (!isTinyLocalModelKey(model)) {
+		const values = TINY_LOCAL_MODELS.map(spec => spec.key).join(", ");
+		throw new Error(`Unknown tiny local model: ${model}. Expected one of: ${values}, all`);
+	}
+	return [model];
+}
+
+function listModels(json: boolean | undefined): void {
+	if (json) {
+		writeLine(JSON.stringify({ models: TINY_LOCAL_MODELS }));
+		return;
+	}
+	writeLine(chalk.bold("Tiny local models"));
+	for (const spec of TINY_LOCAL_MODELS) {
+		const defaultMark = spec.key === DEFAULT_TINY_TITLE_LOCAL_MODEL_KEY ? chalk.cyan(" default") : "";
+		writeLine(`${chalk.cyan(spec.key)}${defaultMark}`);
+		writeLine(`  ${spec.label} — ${spec.description}`);
+	}
+}
+
+function makeProgressReporter(modelKey: TinyLocalModelKey, json: boolean | undefined): ProgressReporter {
+	if (json || !process.stdout.isTTY) {
+		return { onProgress: () => undefined, finish: () => undefined };
+	}
+	const label = getTinyLocalModelSpec(modelKey)?.label ?? modelKey;
+	let lastWidth = 0;
+	let lastProgress = -1;
+	const render = (event: TinyTitleProgressEvent): void => {
+		const progress = event.progress ?? lastProgress;
+		if (progress >= 0 && progress < lastProgress + 1 && event.status !== "ready") return;
+		if (progress >= 0) lastProgress = progress;
+		const ratio = progress >= 0 ? Math.max(0, Math.min(1, progress / 100)) : 0;
+		const barWidth = 30;
+		const filled = Math.round(ratio * barWidth);
+		const bar = `${"█".repeat(filled)}${"░".repeat(barWidth - filled)}`;
+		const pct = progress >= 0 ? `${Math.floor(progress).toString().padStart(3, " ")}%` : " --%";
+		const bytes = event.loaded && event.total ? ` ${formatBytes(event.loaded)}/${formatBytes(event.total)}` : "";
+		const file = event.file ? ` ${event.file.split("/").at(-1) ?? event.file}` : "";
+		const statusLabel = event.status === "ready" ? "Ready" : "Downloading";
+		const line = `${chalk.cyan(statusLabel)} ${label} [${bar}] ${pct}${bytes}${file}`;
+		process.stdout.write(`\r${line.padEnd(lastWidth)}`);
+		lastWidth = line.length;
+	};
+	return {
+		onProgress(event) {
+			if (event.modelKey !== modelKey) return;
+			render(event);
+		},
+		finish(ok) {
+			const suffix = ok ? chalk.green("done") : chalk.red("failed");
+			process.stdout.write(`\r${`${label}: ${suffix}`.padEnd(lastWidth)}\n`);
+		},
+	};
+}
+
+async function downloadOne(modelKey: TinyLocalModelKey, json: boolean | undefined): Promise<DownloadResult> {
+	const label = getTinyLocalModelSpec(modelKey)?.label ?? modelKey;
+	if (!json && !process.stdout.isTTY) writeLine(`Downloading ${label} (${modelKey})...`);
+	const progress = makeProgressReporter(modelKey, json);
+	const ok = await tinyTitleClient.downloadModel(modelKey, { onProgress: progress.onProgress });
+	progress.finish(ok);
+	if (!json && !process.stdout.isTTY) writeLine(ok ? `Downloaded ${label}.` : `Failed to download ${label}.`);
+	return { model: modelKey, ok };
+}
+
+export async function runTinyModelsCommand(command: TinyModelsCommandArgs): Promise<void> {
+	if (command.action === "list") {
+		listModels(command.flags.json);
+		return;
+	}
+
+	const models = resolveModels(command.model);
+	const results: DownloadResult[] = [];
+	try {
+		for (const model of models) {
+			results.push(await downloadOne(model, command.flags.json));
+		}
+	} finally {
+		await shutdownTinyTitleClient();
+	}
+
+	if (command.flags.json) {
+		writeLine(JSON.stringify({ results }));
+	}
+	if (results.some(result => !result.ok)) {
+		throw new Error("One or more tiny title models failed to download");
+	}
+}

package/src/cli-commands.ts

@@ -28,6 +28,7 @@ export const commands: CommandEntry[] = [
 	{ name: "ssh", load: () => import("./commands/ssh").then(m => m.default) },
 	{ name: "stats", load: () => import("./commands/stats").then(m => m.default) },
 	{ name: "update", load: () => import("./commands/update").then(m => m.default) },
+	{ name: "tiny-models", load: () => import("./commands/tiny-models").then(m => m.default) },
 	{ name: "worktree", load: () => import("./commands/worktree").then(m => m.default), aliases: ["wt"] },
 	{ name: "search", load: () => import("./commands/web-search").then(m => m.default), aliases: ["q"] },
 ];

package/src/cli.ts

@@ -32,20 +32,20 @@ async function showHelp(config: CliConfig): Promise<void> {
 	}
 }
 /**
- * Smoke-test entry. Spawns the stats sync worker, pings it, exits.
+ * Smoke-test entry. Spawns bundled workers, pings them, exits.
  *
  * Purpose: catch the silent worker-load regressions that hit compiled
- * binaries (issues #1011 and #1027). Neither `--version` nor
- * `stats --summary` actually spawns a Worker on a fresh install — the
- * sync path early-returns when no session files exist. This probe is the
- * minimal end-to-end test that proves `new Worker(...)` resolves and the
- * bundled worker module evaluates successfully. Wired into
- * `scripts/install-tests/run-ci.sh` so binary / source-link / tarball
- * installs all exercise it on every CI run.
+ * binaries (issues #1011 and #1027). Version/help paths do not spawn worker
+ * modules on a fresh install, so this probe is the minimal end-to-end test
+ * that proves `new Worker(...)` resolves and bundled worker modules evaluate.
+ * Wired into `scripts/install-tests/run-ci.sh` so binary / source-link /
+ * tarball installs all exercise it on every CI run.
  */
 async function runSmokeTest(): Promise<void> {
 	const { smokeTestSyncWorker } = await import("@oh-my-pi/omp-stats");
+	const { smokeTestTinyTitleWorker } = await import("./tiny/title-client");
 	await smokeTestSyncWorker();
+	await smokeTestTinyTitleWorker();
 	process.stdout.write("smoke-test: ok\n");
 }
 

package/src/commands/tiny-models.ts

@@ -0,0 +1,36 @@
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { runTinyModelsCommand, type TinyModelsAction, type TinyModelsCommandArgs } from "../cli/tiny-models-cli";
+
+const ACTIONS: TinyModelsAction[] = ["download", "list"];
+
+export default class TinyModels extends Command {
+	static description = "Download tiny local models (session titles + memory)";
+
+	static args = {
+		action: Args.string({
+			description: "Action to perform",
+			required: false,
+			options: ACTIONS,
+		}),
+		model: Args.string({
+			description: "Model key, or all",
+			required: false,
+		}),
+	};
+
+	static flags = {
+		json: Flags.boolean({ description: "Output JSON" }),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(TinyModels);
+		const command: TinyModelsCommandArgs = {
+			action: (args.action ?? "download") as TinyModelsAction,
+			model: args.model,
+			flags: {
+				json: flags.json,
+			},
+		};
+		await runTinyModelsCommand(command);
+	}
+}

package/src/config/model-equivalence.ts

@@ -1,4 +1,9 @@
 import { type Api, getBundledModels, getBundledProviders, type Model } from "@oh-my-pi/pi-ai";
+import {
+	getBracketStrippedModelIdCandidates,
+	getLongestModelLikeIdSegment,
+	getModelLikeIdSegments,
+} from "./model-id-affixes";
 
 export type CanonicalModelSource = "override" | "bundled" | "heuristic" | "fallback";
 
@@ -29,6 +34,7 @@ export interface CanonicalModelIndex {
 interface CanonicalReferenceData {
 	references: Map<string, Model<Api>>;
 	officialIds: Set<string>;
+	suffixAliases: Map<string, string>;
 }
 
 interface CompiledEquivalenceConfig {
@@ -70,6 +76,26 @@ function shouldReplaceReference(existing: Model<Api> | undefined, candidate: Mod
 	return existing.provider !== "openai" && candidate.provider === "openai";
 }
 
+function buildCanonicalSuffixAliasMap(references: ReadonlyMap<string, Model<Api>>): Map<string, string> {
+	const aliases = new Map<string, string>();
+	for (const reference of references.values()) {
+		const slashIndex = reference.id.lastIndexOf("/");
+		if (slashIndex === -1) {
+			continue;
+		}
+		const suffix = reference.id.slice(slashIndex + 1);
+		const alias = getLongestModelLikeIdSegment(suffix);
+		if (!alias) {
+			continue;
+		}
+		const existing = aliases.get(alias);
+		if (!existing || compareCandidatePreference(reference.id, existing) < 0) {
+			aliases.set(alias, reference.id);
+		}
+	}
+	return new Map([...aliases.entries()].map(([alias, referenceId]) => [normalizeCanonicalIdKey(alias), referenceId]));
+}
+
 function createCanonicalReferenceData(): CanonicalReferenceData {
 	if (referenceDataCache) {
 		return referenceDataCache;
@@ -85,9 +111,11 @@ function createCanonicalReferenceData(): CanonicalReferenceData {
 		}
 	}
 	const officialIds = new Set(references.keys());
+	const suffixAliases = buildCanonicalSuffixAliasMap(references);
 	referenceDataCache = {
 		references: Object.freeze(references) as Map<string, Model<Api>>,
 		officialIds: Object.freeze(officialIds) as Set<string>,
+		suffixAliases: Object.freeze(suffixAliases) as Map<string, string>,
 	};
 	return referenceDataCache;
 }
@@ -590,6 +618,13 @@ function expandHeavyCanonicalCandidates(normalized: string, queue: string[]): vo
 		queue.push(wrapperCandidate);
 	}
 
+	for (const strippedAffixCandidate of getBracketStrippedModelIdCandidates(normalized)) {
+		queue.push(strippedAffixCandidate);
+	}
+	for (const segment of getModelLikeIdSegments(normalized)) {
+		queue.push(segment);
+	}
+
 	const strippedSyntheticPrefix = stripSyntheticPrefix(normalized);
 	if (strippedSyntheticPrefix) {
 		queue.push(strippedSyntheticPrefix);
@@ -718,9 +753,15 @@ function resolveCanonicalIdForModel(
 	}
 
 	const heuristicCandidates = getHeuristicCanonicalCandidates(model.id, referenceData.officialIds);
-	const officialMatches = heuristicCandidates.filter(candidate => referenceData.officialIds.has(candidate));
+	const officialMatches = new Set(heuristicCandidates.filter(candidate => referenceData.officialIds.has(candidate)));
+	for (const candidate of heuristicCandidates) {
+		const aliased = referenceData.suffixAliases.get(normalizeCanonicalIdKey(candidate));
+		if (aliased) {
+			officialMatches.add(aliased);
+		}
+	}
 	const preferredFallback = getPreferredFallbackCanonicalCandidate(model.id, heuristicCandidates);
-	const match = selectBestOfficialCandidate(officialMatches);
+	const match = selectBestOfficialCandidate([...officialMatches]);
 	if (match) {
 		if (
 			preferredFallback &&

package/src/config/model-id-affixes.ts

@@ -0,0 +1,64 @@
+const LEADING_BRACKETED_AFFIX_PATTERN = /^(?:\s*(?:\[|【)[^\]】]+(?:\]|】)\s*)+/u;
+const TRAILING_BRACKETED_AFFIX_PATTERN = /(?:\s*(?:\[|【)[^\]】]+(?:\]|】)\s*)+$/u;
+const MODEL_ID_SEGMENT_PATTERN = /[a-z0-9.:-]+/g;
+const MODEL_FAMILY_PREFIX_PATTERN =
+	/^(claude|gemini|gpt|grok|glm|qwen|deepseek|kimi|mimo|doubao|ernie|gpt-oss|gemma|minimax|step|command|jamba|llama|o[1345])/i;
+
+function hasDigit(value: string): boolean {
+	return /\d/.test(value);
+}
+
+function compareSegmentPreference(left: string, right: string): number {
+	if (left.length !== right.length) {
+		return right.length - left.length;
+	}
+	return left.localeCompare(right);
+}
+
+export function getModelLikeIdSegments(modelId: string): string[] {
+	const normalized = normalizeModelIdWhitespace(modelId).toLowerCase();
+	if (!normalized) return [];
+	const segments = (normalized.match(MODEL_ID_SEGMENT_PATTERN) ?? []).filter(
+		segment => MODEL_FAMILY_PREFIX_PATTERN.test(segment) && hasDigit(segment),
+	);
+	const unique = [...new Set(segments)];
+	unique.sort(compareSegmentPreference);
+	return unique;
+}
+
+export function getLongestModelLikeIdSegment(modelId: string): string | undefined {
+	return getModelLikeIdSegments(modelId)[0];
+}
+
+function normalizeModelIdWhitespace(value: string): string {
+	return value.trim().replace(/\s+/g, " ");
+}
+
+/**
+ * Strip reseller / wrapper tags that are injected as bracketed affixes around an
+ * upstream model id, e.g.
+ *   "[Kiro] claude-opus-4-8"                -> "claude-opus-4-8"
+ *   "[gcli转] gemini-3.1-pro-preview [假流]" -> "gemini-3.1-pro-preview"
+ */
+export function getBracketStrippedModelIdCandidates(modelId: string): string[] {
+	const normalized = normalizeModelIdWhitespace(modelId);
+	if (!normalized) return [];
+
+	const candidates = new Set<string>();
+	const withoutLeading = normalizeModelIdWhitespace(normalized.replace(LEADING_BRACKETED_AFFIX_PATTERN, ""));
+	const withoutTrailing = normalizeModelIdWhitespace(normalized.replace(TRAILING_BRACKETED_AFFIX_PATTERN, ""));
+	const withoutBoth = normalizeModelIdWhitespace(
+		normalized.replace(LEADING_BRACKETED_AFFIX_PATTERN, "").replace(TRAILING_BRACKETED_AFFIX_PATTERN, ""),
+	);
+
+	for (const candidate of [withoutBoth, withoutLeading, withoutTrailing]) {
+		if (candidate && candidate !== normalized) {
+			candidates.add(candidate);
+		}
+	}
+	return [...candidates];
+}
+
+export function stripBracketedModelIdAffixes(modelId: string): string | undefined {
+	return getBracketStrippedModelIdCandidates(modelId)[0];
+}