@oh-my-pi/pi-coding-agent 16.3.8 → 16.3.10

package/dist/types/commands/say.d.ts

@@ -1,19 +1,24 @@
 import { Command } from "@oh-my-pi/pi-utils/cli";
 export default class Say extends Command {
+    #private;
     static description: string;
     static args: {
         text: import("@oh-my-pi/pi-utils/cli").ArgDescriptor & {
-            required: true;
             description: string;
         };
     };
     static flags: {
         voice: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
             description: string;
+            options: readonly string[];
         };
         model: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };
+        file: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
+            char: string;
+            description: string;
+        };
         out: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
             char: string;
             description: string;

package/dist/types/commit/agentic/lock-files.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Lock-file handling for the split-commit workflow.
+ *
+ * The commit agent hides these machine-generated files from analysis so the
+ * model does not waste tokens on them and does not treat them as evidence for
+ * commit boundaries. That leaves them staged but unseen: without deterministic
+ * post-plan placement the split validator rejects the plan with
+ * `Split commit plan missing staged files: <lockfile>`, and the executor
+ * (`git stage.reset` -> per-group `stage.hunks`) would silently drop the file
+ * if the validator were skipped. See issue #4632.
+ */
+import type { SplitCommitPlan } from "./state.js";
+/**
+ * Lock file basename -> ordered sibling manifests. Order matters: the first
+ * manifest present in a commit group's changes wins.
+ */
+export declare const LOCK_FILE_MANIFESTS: Readonly<Record<string, readonly string[]>>;
+/**
+ * Lock-file basenames the commit agent excludes from `git_overview` output and
+ * from split-commit validation. Derived from {@link LOCK_FILE_MANIFESTS} so a
+ * single edit keeps both the analysis filter and the post-plan pairing in sync.
+ */
+export declare const EXCLUDED_LOCK_FILES: ReadonlySet<string>;
+/**
+ * Attach staged lock files the model never saw to the split plan.
+ *
+ * Placement precedence per lock file:
+ *   1. commit group that touches a sibling manifest (same directory)
+ *   2. commit group that touches a manifest in any directory
+ *   3. last commit group (fallback)
+ *
+ * Mutates {@link plan} in place. No-ops on an empty plan, on lock files
+ * already present in some commit group, and on staged files that are not
+ * recognized lock files.
+ */
+export declare function assignLockFilesToPlan(plan: SplitCommitPlan, stagedFiles: readonly string[]): void;

package/dist/types/config/model-discovery.d.ts

@@ -38,8 +38,9 @@ export interface DiscoveryContext {
     getBearerApiKeyResolver(provider: string): Promise<ApiKey | undefined>;
 }
 type LlamaCppDiscoveredModelRuntimeMetadata = {
-    contextWindow: number;
-    maxTokens: number;
+    contextWindow?: number;
+    maxTokens?: number;
+    input?: ("text" | "image")[];
 };
 export declare function discoverModelsByProviderType(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;
 export declare function discoverOllamaModels(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;

package/dist/types/modes/interactive-mode.d.ts

@@ -33,7 +33,7 @@ import { TranscriptContainer } from "./components/transcript-container.js";
 import { EventController } from "./controllers/event-controller.js";
 import { type LoopLimitRuntime } from "./loop-limit.js";
 import { OAuthManualInputManager } from "./oauth-manual-input.js";
-import type { ObservableSession } from "./session-observer-registry.js";
+import { type ObservableSession } from "./session-observer-registry.js";
 import type { Theme } from "./theme/theme.js";
 import type { CompactionQueuedMessage, InteractiveModeContext, InteractiveModeInitOptions, InteractiveSelectorDialogOptions, SubmittedUserInput, TodoItem, TodoPhase } from "./types.js";
 /**
@@ -63,7 +63,7 @@ export interface InteractiveModeOptions {
 }
 /**
  * Build the anchored subagent HUD block: a bold accent "Subagents" header plus
- * one tree row per running agent in the same `Id: description` shape the
+ * a bounded set of running-agent rows in the same `Id: description` shape the
  * inline task rows use (muted task preview when no description was given).
  * Layout mirrors the Todos HUD exactly: unindented header, then
  * `renderTreeList` rows (dim connectors) shifted right by one space.
@@ -217,7 +217,9 @@ export declare class InteractiveMode implements InteractiveModeContext {
     finishPendingSubmission(input: SubmittedUserInput): void;
     updateEditorBorderColor(): void;
     /** Refresh the running-subagents status badge from the active local or collab registry. */
-    syncRunningSubagentBadge(): void;
+    syncRunningSubagentBadge(options?: {
+        requestRender?: boolean;
+    }): void;
     rebuildChatFromMessages(): void;
     /**
      * Render the ctrl+p model-role cycle chip track into its own anchored

package/dist/types/modes/session-observer-registry.d.ts

@@ -21,10 +21,12 @@ export interface ObservableSession {
     /** Latest progress snapshot from the subagent executor */
     progress?: AgentProgress;
 }
+/** Coarse source of an observer change; callers use it to separate lifecycle work from high-frequency progress. */
+export type SessionObserverChangeKind = "main" | "reset" | "lifecycle" | "progress";
 export declare class SessionObserverRegistry {
     #private;
     /** Add a change listener. Returns unsubscribe function. */
-    onChange(cb: () => void): () => void;
+    onChange(cb: (kind: SessionObserverChangeKind) => void): () => void;
     setMainSession(sessionFile?: string): void;
     getSessions(): ObservableSession[];
     getActiveSubagentCount(): number;

package/dist/types/session/agent-session.d.ts

@@ -423,6 +423,7 @@ export interface SessionStats {
     };
     premiumRequests: number;
     cost: number;
+    contextUsage?: ContextUsage;
 }
 /** Advisor statistics for /advisor status command. */
 export interface AdvisorStats {
@@ -1160,15 +1161,18 @@ export declare class AgentSession {
     /** Whether there are pending Python messages waiting to be flushed */
     get hasPendingPythonMessages(): boolean;
     /**
-     * Surfaces (and consumes) pending IRC incoming records before the next model
+     * Surfaces and consumes pending IRC incoming records before the next model
      * step can inject them automatically.
      *
-     * The inbox tool injects the formatted body into the tool result, so the
-     * model sees it once via the result. Leaving the record in either pending
-     * IRC queue would deliver it a second time at the next step boundary —
-     * including on `peek`, which is why peek also drains here.
-     */
-    drainPendingIrcInboxMessages(agentId: string): IrcMessage[];
+     * Tool results already expose the formatted body to the model. Leaving the
+     * same record in either pending IRC queue would deliver it a second time at
+     * the next step boundary — including on `peek`, which is why inbox peeks
+     * also drain here.
+     */
+    drainPendingIrcInboxMessages(agentId: string, opts?: {
+        from?: string;
+        limit?: number;
+    }): IrcMessage[];
     /**
      * Deliver an IRC message into this session (recipient side; called by the
      * IrcBus). Emits the `irc_message` session event for UI cards and injects

package/dist/types/task/renderer.d.ts

@@ -10,5 +10,4 @@ export declare const taskToolRenderer: {
     readonly renderCall: typeof renderCall;
     readonly renderResult: typeof renderResult;
     readonly mergeCallAndResult: true;
-    readonly animatedPartialResult: true;
 };

package/dist/types/tools/browser/run-cancellation.d.ts

@@ -1,3 +1,14 @@
+/**
+ * Marks a run-scoped promise as observed without changing its behavior for awaited callers.
+ *
+ * Browser run teardown aborts can reject promises created for evaluated code after user code
+ * has stopped observing them (for example fire-and-forget `wait()`/facade calls). In 16.3.0
+ * those zero-consumer rejections reached the process-level `unhandledRejection` handler and
+ * killed every subagent sharing the process (issues #4499/#4672). Attaching a no-op rejection
+ * handler at creation makes the promise observed while returning the original promise so callers
+ * that do await it still receive the rejection.
+ */
+export declare function markHandled<T>(promise: Promise<T>): Promise<T>;
 /** Sleeps inside evaluated browser code while honoring the owning run's cancellation signal. */
 export declare function waitForBrowserRun(ms: number, signal: AbortSignal): Promise<void>;
 /** Binds a long-lived browser facade to one evaluated run's abort signal. */

package/dist/types/tools/browser/tab-protocol.d.ts

@@ -80,6 +80,7 @@ export type WorkerInbound = {
 } | {
     type: "abort";
     id: string;
+    expectedCleanup?: boolean;
 } | {
     type: "tool-reply";
     id: string;

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

@@ -19,7 +19,7 @@ export declare class ToolError extends Error {
  */
 export declare class ToolAbortError extends Error {
     static readonly MESSAGE = "Operation aborted";
-    constructor(message?: string);
+    constructor(message?: string, options?: ErrorOptions);
 }
 /**
  * Throw ToolAbortError if the signal is aborted.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.3.8",
+	"version": "16.3.10",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -56,17 +56,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.3.8",
-		"@oh-my-pi/omp-stats": "16.3.8",
-		"@oh-my-pi/pi-agent-core": "16.3.8",
-		"@oh-my-pi/pi-ai": "16.3.8",
-		"@oh-my-pi/pi-catalog": "16.3.8",
-		"@oh-my-pi/pi-mnemopi": "16.3.8",
-		"@oh-my-pi/pi-natives": "16.3.8",
-		"@oh-my-pi/pi-tui": "16.3.8",
-		"@oh-my-pi/pi-utils": "16.3.8",
-		"@oh-my-pi/pi-wire": "16.3.8",
-		"@oh-my-pi/snapcompact": "16.3.8",
+		"@oh-my-pi/hashline": "16.3.10",
+		"@oh-my-pi/omp-stats": "16.3.10",
+		"@oh-my-pi/pi-agent-core": "16.3.10",
+		"@oh-my-pi/pi-ai": "16.3.10",
+		"@oh-my-pi/pi-catalog": "16.3.10",
+		"@oh-my-pi/pi-mnemopi": "16.3.10",
+		"@oh-my-pi/pi-natives": "16.3.10",
+		"@oh-my-pi/pi-tui": "16.3.10",
+		"@oh-my-pi/pi-utils": "16.3.10",
+		"@oh-my-pi/pi-wire": "16.3.10",
+		"@oh-my-pi/snapcompact": "16.3.10",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/commands/say.ts

@@ -1,17 +1,20 @@
 /**
  * Synthesize text with the local TTS engine and play it (or save it with --out).
  *
- * Demonstrates the on-device speech stack end to end: the first run downloads
- * the configured local model, synthesis happens in the TTS worker subprocess,
- * and the resulting WAV is either played through the speakers or written to disk.
+ * Text comes from the argument or --file. Input is segmented into
+ * sentence-sized chunks ({@link SpeakableStream}) and synthesized through the
+ * streaming TTS worker, so arbitrarily long text plays gaplessly instead of
+ * hitting Kokoro's single-call ~510-phoneme truncation. --out concatenates the
+ * streamed segments into one WAV. The first run downloads the configured local
+ * model into the worker's cache.
  */
-import * as os from "node:os";
-import * as path from "node:path";
-import { getProjectDir, Snowflake } from "@oh-my-pi/pi-utils";
+import { getProjectDir } from "@oh-my-pi/pi-utils";
 import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import chalk from "chalk";
 import { Settings, settings } from "../config/settings";
-import { playAudioFile, removeTempFile } from "../tts/player";
+import { TTS_LOCAL_VOICE_VALUES } from "../tts/models";
+import { SpeakableStream } from "../tts/speakable";
+import { StreamingAudioPlayer } from "../tts/streaming-player";
 import { shutdownTtsClient, ttsClient } from "../tts/tts-client";
 import { encodeWav } from "../tts/wav";
 
@@ -19,24 +22,28 @@ export default class Say extends Command {
 	static description = "Synthesize text with the local TTS engine and play it through the speakers";
 
 	static args = {
-		text: Args.string({ required: true, description: "Text to speak" }),
+		text: Args.string({ description: "Text to speak (or use --file)" }),
 	};
 
 	static flags = {
-		voice: Flags.string({ description: "Voice id" }),
+		voice: Flags.string({ description: "Voice id", options: TTS_LOCAL_VOICE_VALUES }),
 		model: Flags.string({ description: "Local TTS model key" }),
+		file: Flags.string({ char: "f", description: "Read the text to speak from this file" }),
 		out: Flags.string({ char: "o", description: "Write WAV to this path instead of playing" }),
 	};
 
 	static examples = [
 		'omp say "hello world"',
+		"omp say --file notes.md --voice bm_fable",
 		'omp say "hello world" --out /tmp/hello.wav',
-		'omp say "bonjour" --voice af_heart --model kokoro',
 	];
 
 	async run(): Promise<void> {
 		const { args, flags } = await this.parse(Say);
-		const text = args.text ?? "";
+		if (args.text && flags.file) {
+			process.stderr.write(chalk.red("error: pass either text or --file, not both\n"));
+			process.exit(1);
+		}
 
 		await Settings.init({ cwd: getProjectDir() });
 		const model = flags.model ?? settings.get("tts.localModel");
@@ -55,23 +62,42 @@ export default class Say extends Command {
 		});
 
 		try {
-			const audio = await ttsClient.synthesize(model, text, { voice });
-			if (!audio) {
-				process.stderr.write(
-					chalk.red(
-						`error: could not synthesize with local TTS model "${model}". ` +
-							"Run `omp setup speech` to install it.\n",
-					),
-				);
+			const text = flags.file ? await Bun.file(flags.file).text() : (args.text ?? "");
+			const splitter = new SpeakableStream();
+			const segments = [...splitter.push(text), ...splitter.flush()];
+			if (segments.length === 0) {
+				process.stderr.write(chalk.red("error: nothing speakable in the input\n"));
 				exitCode = 1;
 				return;
 			}
 
-			const wav = encodeWav(audio.pcm, audio.sampleRate);
-			const durationSec = audio.pcm.length / audio.sampleRate;
+			const stream = ttsClient.synthesizeStream(model, { voice });
+			for (const segment of segments) stream.push(segment);
+			stream.end();
 
 			if (flags.out) {
+				const pcms: Float32Array[] = [];
+				let total = 0;
+				let sampleRate = 0;
+				for await (const chunk of stream.chunks) {
+					pcms.push(chunk.pcm);
+					total += chunk.pcm.length;
+					sampleRate = chunk.sampleRate;
+				}
+				if (total === 0) {
+					this.#synthesisFailed(model);
+					exitCode = 1;
+					return;
+				}
+				const pcm = new Float32Array(total);
+				let offset = 0;
+				for (const part of pcms) {
+					pcm.set(part, offset);
+					offset += part.length;
+				}
+				const wav = encodeWav(pcm, sampleRate);
 				await Bun.write(flags.out, wav);
+				const durationSec = total / sampleRate;
 				process.stdout.write(
 					`${chalk.green("saved")} ${flags.out} ` +
 						`${chalk.dim(`(${voice}, ${model}, ${durationSec.toFixed(1)}s, ${wav.byteLength} bytes)`)}\n`,
@@ -79,16 +105,25 @@ export default class Say extends Command {
 				return;
 			}
 
-			const tmp = path.join(os.tmpdir(), `omp-say-${Snowflake.next()}.wav`);
-			await Bun.write(tmp, wav);
-			try {
-				await playAudioFile(tmp);
-				process.stdout.write(
-					`${chalk.green("spoke")} ${chalk.dim(`(${voice}, ${model}, ${durationSec.toFixed(1)}s)`)}\n`,
-				);
-			} finally {
-				await removeTempFile(tmp);
+			const player = new StreamingAudioPlayer();
+			let spoken = 0;
+			let seconds = 0;
+			for await (const chunk of stream.chunks) {
+				player.start(chunk.sampleRate);
+				player.write(chunk.pcm);
+				spoken++;
+				seconds += chunk.pcm.length / chunk.sampleRate;
 			}
+			if (spoken === 0) {
+				player.stop();
+				this.#synthesisFailed(model);
+				exitCode = 1;
+				return;
+			}
+			await player.end();
+			process.stdout.write(
+				`${chalk.green("spoke")} ${chalk.dim(`(${voice}, ${model}, ${seconds.toFixed(1)}s, ${spoken} segments)`)}\n`,
+			);
 		} catch (err) {
 			process.stderr.write(chalk.red(`error: ${err instanceof Error ? err.message : String(err)}\n`));
 			exitCode = 1;
@@ -99,4 +134,12 @@ export default class Say extends Command {
 
 		if (exitCode !== 0) process.exit(exitCode);
 	}
+
+	#synthesisFailed(model: string): void {
+		process.stderr.write(
+			chalk.red(
+				`error: could not synthesize with local TTS model "${model}". Run \`omp setup speech\` to install it.\n`,
+			),
+		);
+	}
 }

package/src/commit/agentic/index.ts

@@ -13,6 +13,7 @@ import { discoverAuthStorage, discoverContextFiles } from "../../sdk";
 import * as git from "../../utils/git";
 import { type ExistingChangelogEntries, runCommitAgentSession } from "./agent";
 import { generateFallbackProposal } from "./fallback";
+import { assignLockFilesToPlan } from "./lock-files";
 import splitConfirmPrompt from "./prompts/split-confirm.md" with { type: "text" };
 import type { CommitAgentState, CommitProposal, HunkSelector, SplitCommitPlan } from "./state";
 import { computeDependencyOrder } from "./topo-sort";
@@ -230,6 +231,7 @@ async function runSplitCommit(
 		appendFilesToLastCommit(plan, ctx.additionalFiles);
 	}
 	const stagedFiles = await git.diff.changedFiles(ctx.cwd, { cached: true });
+	assignLockFilesToPlan(plan, stagedFiles);
 	const plannedFiles = new Set(plan.commits.flatMap(commit => commit.changes.map(change => change.path)));
 	const missingFiles = stagedFiles.filter(file => !plannedFiles.has(file));
 	if (missingFiles.length > 0) {
@@ -266,7 +268,7 @@ async function runSplitCommit(
 		throw new Error(order.error);
 	}
 
-	const stagedDiff = await git.diff(ctx.cwd, { cached: true });
+	const stagedDiff = await git.diff(ctx.cwd, { cached: true, binary: true });
 	await git.stage.reset(ctx.cwd);
 	for (const commitIndex of order) {
 		const commit = plan.commits[commitIndex];

package/src/commit/agentic/lock-files.ts

@@ -0,0 +1,107 @@
+/**
+ * Lock-file handling for the split-commit workflow.
+ *
+ * The commit agent hides these machine-generated files from analysis so the
+ * model does not waste tokens on them and does not treat them as evidence for
+ * commit boundaries. That leaves them staged but unseen: without deterministic
+ * post-plan placement the split validator rejects the plan with
+ * `Split commit plan missing staged files: <lockfile>`, and the executor
+ * (`git stage.reset` -> per-group `stage.hunks`) would silently drop the file
+ * if the validator were skipped. See issue #4632.
+ */
+
+import type { SplitCommitPlan } from "./state";
+
+/**
+ * Lock file basename -> ordered sibling manifests. Order matters: the first
+ * manifest present in a commit group's changes wins.
+ */
+export const LOCK_FILE_MANIFESTS: Readonly<Record<string, readonly string[]>> = {
+	"Cargo.lock": ["Cargo.toml"],
+	"package-lock.json": ["package.json"],
+	"yarn.lock": ["package.json"],
+	"pnpm-lock.yaml": ["package.json"],
+	"bun.lock": ["package.json"],
+	"bun.lockb": ["package.json"],
+	"go.sum": ["go.mod"],
+	"poetry.lock": ["pyproject.toml"],
+	"Pipfile.lock": ["Pipfile"],
+	"uv.lock": ["pyproject.toml"],
+	"composer.lock": ["composer.json"],
+	"Gemfile.lock": ["Gemfile"],
+	"flake.lock": ["flake.nix"],
+	"pubspec.lock": ["pubspec.yaml"],
+	"Podfile.lock": ["Podfile"],
+	"mix.lock": ["mix.exs"],
+	"gradle.lockfile": ["build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts"],
+};
+
+/**
+ * Lock-file basenames the commit agent excludes from `git_overview` output and
+ * from split-commit validation. Derived from {@link LOCK_FILE_MANIFESTS} so a
+ * single edit keeps both the analysis filter and the post-plan pairing in sync.
+ */
+export const EXCLUDED_LOCK_FILES: ReadonlySet<string> = new Set(Object.keys(LOCK_FILE_MANIFESTS));
+
+/**
+ * Attach staged lock files the model never saw to the split plan.
+ *
+ * Placement precedence per lock file:
+ *   1. commit group that touches a sibling manifest (same directory)
+ *   2. commit group that touches a manifest in any directory
+ *   3. last commit group (fallback)
+ *
+ * Mutates {@link plan} in place. No-ops on an empty plan, on lock files
+ * already present in some commit group, and on staged files that are not
+ * recognized lock files.
+ */
+export function assignLockFilesToPlan(plan: SplitCommitPlan, stagedFiles: readonly string[]): void {
+	if (plan.commits.length === 0) return;
+
+	const planned = new Set(plan.commits.flatMap(commit => commit.changes.map(change => change.path)));
+	const orphanedLockFiles: string[] = [];
+	for (const file of stagedFiles) {
+		if (planned.has(file)) continue;
+		const parts = file.split("/");
+		const basename = parts[parts.length - 1];
+		if (EXCLUDED_LOCK_FILES.has(basename)) orphanedLockFiles.push(file);
+	}
+	if (orphanedLockFiles.length === 0) return;
+
+	for (const lockFile of orphanedLockFiles) {
+		const parts = lockFile.split("/");
+		const basename = parts[parts.length - 1];
+		const dir = parts.slice(0, -1).join("/");
+		const manifests = LOCK_FILE_MANIFESTS[basename] ?? [];
+		const targetIndex = findManifestCommitIndex(plan, dir, manifests);
+		plan.commits[targetIndex].changes.push({ path: lockFile, hunks: { type: "all" } });
+		planned.add(lockFile);
+	}
+}
+
+function findManifestCommitIndex(plan: SplitCommitPlan, lockDir: string, manifests: readonly string[]): number {
+	// Prefer a manifest in the same directory as the lock file — the strongest
+	// semantic signal (e.g. workspace-crate `Cargo.toml` next to `Cargo.lock`).
+	for (const manifestName of manifests) {
+		for (let i = 0; i < plan.commits.length; i++) {
+			for (const change of plan.commits[i].changes) {
+				const parts = change.path.split("/");
+				const basename = parts[parts.length - 1];
+				const dir = parts.slice(0, -1).join("/");
+				if (basename === manifestName && dir === lockDir) return i;
+			}
+		}
+	}
+	// Fall back to any matching manifest — a monorepo may lock at repo root
+	// while the manifest sits under a subpath.
+	for (const manifestName of manifests) {
+		for (let i = 0; i < plan.commits.length; i++) {
+			for (const change of plan.commits[i].changes) {
+				const parts = change.path.split("/");
+				if (parts[parts.length - 1] === manifestName) return i;
+			}
+		}
+	}
+	// Nothing matched: attach to the last commit so the file still ships.
+	return plan.commits.length - 1;
+}

package/src/commit/agentic/tools/git-overview.ts

@@ -3,26 +3,7 @@ import type { CommitAgentState, GitOverviewSnapshot } from "../../../commit/agen
 import { extractScopeCandidates } from "../../../commit/analysis/scope";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
 import * as git from "../../../utils/git";
-
-const EXCLUDED_LOCK_FILES = new Set([
-	"Cargo.lock",
-	"package-lock.json",
-	"yarn.lock",
-	"pnpm-lock.yaml",
-	"bun.lock",
-	"bun.lockb",
-	"go.sum",
-	"poetry.lock",
-	"Pipfile.lock",
-	"uv.lock",
-	"composer.lock",
-	"Gemfile.lock",
-	"flake.lock",
-	"pubspec.lock",
-	"Podfile.lock",
-	"mix.lock",
-	"gradle.lockfile",
-]);
+import { EXCLUDED_LOCK_FILES } from "../lock-files";
 
 function isExcludedFile(path: string): boolean {
 	const basename = path.split("/").pop() ?? path;

package/src/config/model-discovery.ts

@@ -151,8 +151,9 @@ type LlamaCppDiscoveredServerMetadata = {
 };
 
 type LlamaCppDiscoveredModelRuntimeMetadata = {
-	contextWindow: number;
-	maxTokens: number;
+	contextWindow?: number;
+	maxTokens?: number;
+	input?: ("text" | "image")[];
 };
 
 type LlamaCppModelListEntry = {
@@ -594,12 +595,14 @@ export async function discoverLlamaCppModelRuntimeMetadata(
 			entry.configuredContextWindow ??
 			serverMetadata?.contextWindow ??
 			entry.trainingContextWindow;
+		const input = serverMetadata?.input;
 		if (contextWindow === undefined) {
-			return undefined;
+			return input === undefined ? undefined : { input };
 		}
 		return {
 			contextWindow,
 			maxTokens: resolveLlamaCppMaxTokens(contextWindow, serverMetadata?.maxTokens),
+			...(input !== undefined ? { input } : {}),
 		};
 	};
 	try {

package/src/config/model-registry.ts

@@ -866,12 +866,13 @@ export class ModelRegistry {
 		if (runtimeMetadata === undefined) {
 			return this.find(model.provider, model.id) ?? model;
 		}
-		const { contextWindow, maxTokens } = runtimeMetadata;
+		const { contextWindow, maxTokens, input } = runtimeMetadata;
 		const current = this.find(model.provider, model.id) ?? model;
 		const override = this.#resolveLiveModelOverride(current);
 		const customModel = this.#resolveLiveCustomModelOverlay(current);
 		const patch: ModelPatch = {};
 		if (
+			contextWindow !== undefined &&
 			override?.contextWindow === undefined &&
 			customModel?.contextWindow === undefined &&
 			current.contextWindow !== contextWindow
@@ -884,15 +885,25 @@ export class ModelRegistry {
 			patch.contextWindow ??
 			current.contextWindow ??
 			contextWindow;
-		const effectiveMaxTokens = Math.min(maxTokens, effectiveContextWindow);
+		if (maxTokens !== undefined && effectiveContextWindow !== undefined) {
+			const effectiveMaxTokens = Math.min(maxTokens, effectiveContextWindow);
+			if (
+				override?.maxTokens === undefined &&
+				customModel?.maxTokens === undefined &&
+				current.maxTokens !== effectiveMaxTokens
+			) {
+				patch.maxTokens = effectiveMaxTokens;
+			}
+		}
 		if (
-			override?.maxTokens === undefined &&
-			customModel?.maxTokens === undefined &&
-			current.maxTokens !== effectiveMaxTokens
+			input !== undefined &&
+			override?.input === undefined &&
+			customModel?.input === undefined &&
+			(current.input.length !== input.length || current.input.some((value, index) => value !== input[index]))
 		) {
-			patch.maxTokens = effectiveMaxTokens;
+			patch.input = input;
 		}
-		if (patch.contextWindow === undefined && patch.maxTokens === undefined) {
+		if (patch.contextWindow === undefined && patch.maxTokens === undefined && patch.input === undefined) {
 			return current;
 		}
 		const patched = applyModelPatch(current, patch, "merge");