@oh-my-pi/pi-coding-agent 16.2.9 → 16.2.11

package/src/config/model-discovery.ts

@@ -35,6 +35,31 @@ import type { ProviderDiscovery } from "./models-config-schema";
 export const DISCOVERY_DEFAULT_CONTEXT_WINDOW = OPENAI_COMPAT_DISCOVERY_DEFAULT_CONTEXT_WINDOW;
 export const DISCOVERY_DEFAULT_MAX_TOKENS = OPENAI_COMPAT_DISCOVERY_DEFAULT_MAX_TOKENS;
 
+/**
+ * Run `fn` with an abort signal that fires after `timeoutMs`, clearing the
+ * backing timer the instant the operation settles.
+ *
+ * Unlike the built-in abort-signal timeout API, the timer never outlives the
+ * request: on the success path it is cancelled before `fn` resolves, so the
+ * signal is never aborted and no pending callback lingers on the heap. A leaked
+ * abort-signal timeout (e.g. discovery against a mocked fetch that resolves
+ * instantly) fires seconds later and sets its abort `reason` — which crashed
+ * Bun's concurrent GC while it marked the signal's wrapped reason during an
+ * unrelated allocation (`JSAbortSignal::visitAdditionalChildren`).
+ */
+async function withTimeoutSignal<T>(timeoutMs: number, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {
+	const controller = new AbortController();
+	const timer = setTimeout(
+		() => controller.abort(new DOMException("The operation timed out.", "TimeoutError")),
+		timeoutMs,
+	);
+	try {
+		return await fn(controller.signal);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
 const DEFAULT_OLLAMA_BASE_URL = "http://127.0.0.1:11434";
 const OLLAMA_HOST_DEFAULT_PORT = "11434";
 
@@ -288,16 +313,18 @@ async function discoverOllamaModelMetadata(
 ): Promise<OllamaDiscoveredModelMetadata | null> {
 	const showUrl = `${endpoint}/api/show`;
 	try {
-		const response = await ctx.fetch(showUrl, {
-			method: "POST",
-			headers: { ...(headers ?? {}), "Content-Type": "application/json" },
-			body: JSON.stringify({ model: modelId }),
-			signal: AbortSignal.timeout(150),
+		const payload = await withTimeoutSignal(150, async signal => {
+			const response = await ctx.fetch(showUrl, {
+				method: "POST",
+				headers: { ...(headers ?? {}), "Content-Type": "application/json" },
+				body: JSON.stringify({ model: modelId }),
+				signal,
+			});
+			if (!response.ok) {
+				return null;
+			}
+			return (await response.json()) as unknown;
 		});
-		if (!response.ok) {
-			return null;
-		}
-		const payload = (await response.json()) as unknown;
 		if (!isRecord(payload)) {
 			return null;
 		}
@@ -339,14 +366,16 @@ export async function discoverOllamaModels(
 	const endpoint = normalizeOllamaBaseUrl(providerConfig.baseUrl);
 	const tagsUrl = `${endpoint}/api/tags`;
 	const headers = { ...(providerConfig.headers ?? {}) };
-	const response = await ctx.fetch(tagsUrl, {
-		headers,
-		signal: AbortSignal.timeout(250),
+	const payload = await withTimeoutSignal(250, async signal => {
+		const response = await ctx.fetch(tagsUrl, {
+			headers,
+			signal,
+		});
+		if (!response.ok) {
+			throw new Error(`HTTP ${response.status} from ${tagsUrl}`);
+		}
+		return (await response.json()) as { models?: Array<{ name?: string; model?: string }> };
 	});
-	if (!response.ok) {
-		throw new Error(`HTTP ${response.status} from ${tagsUrl}`);
-	}
-	const payload = (await response.json()) as { models?: Array<{ name?: string; model?: string }> };
 	const entries = (payload.models ?? []).flatMap(item => {
 		const id = item.model || item.name;
 		return id ? [{ id, name: item.name || id }] : [];
@@ -384,14 +413,16 @@ async function discoverLlamaCppServerMetadata(
 ): Promise<LlamaCppDiscoveredServerMetadata | null> {
 	const propsUrl = `${toLlamaCppNativeBaseUrl(baseUrl)}/props`;
 	try {
-		const response = await ctx.fetch(propsUrl, {
-			headers,
-			signal: AbortSignal.timeout(150),
+		const payload = await withTimeoutSignal(150, async signal => {
+			const response = await ctx.fetch(propsUrl, {
+				headers,
+				signal,
+			});
+			if (!response.ok) {
+				return null;
+			}
+			return (await response.json()) as unknown;
 		});
-		if (!response.ok) {
-			return null;
-		}
-		const payload = (await response.json()) as unknown;
 		if (!isRecord(payload)) {
 			return null;
 		}
@@ -415,24 +446,26 @@ export async function discoverLlamaCppModels(
 	const baseHeaders: Record<string, string> = { ...(providerConfig.headers ?? {}) };
 	let headers = baseHeaders;
 	const attempt = async (h: Record<string, string>) => {
-		const [response, metadata] = await Promise.all([
-			ctx.fetch(modelsUrl, {
-				headers: h,
-				signal: AbortSignal.timeout(250),
+		const [payload, metadata] = await Promise.all([
+			withTimeoutSignal(250, async signal => {
+				const response = await ctx.fetch(modelsUrl, {
+					headers: h,
+					signal,
+				});
+				if (!response.ok) {
+					throw new Error(`HTTP ${response.status} from ${modelsUrl}`);
+				}
+				headers = h;
+				return (await response.json()) as unknown;
 			}),
 			discoverLlamaCppServerMetadata(ctx, baseUrl, h),
 		]);
-		if (!response.ok) {
-			throw new Error(`HTTP ${response.status} from ${modelsUrl}`);
-		}
-		headers = h;
-		return [response, metadata] as const;
+		return [payload, metadata] as const;
 	};
 	const apiKey = await ctx.getBearerApiKeyResolver(providerConfig.provider);
-	const [response, serverMetadata] = apiKey
+	const [payload, serverMetadata] = apiKey
 		? await withAuth(apiKey, key => attempt({ ...baseHeaders, Authorization: `Bearer ${key}` }))
 		: await attempt(baseHeaders);
-	const payload = (await response.json()) as unknown;
 	const models = parseLlamaCppModelList(payload);
 	const discovered: Model<Api>[] = [];
 	for (const item of models) {
@@ -476,17 +509,22 @@ export async function discoverLlamaCppModelRuntimeMetadata(
 	const modelsUrl = `${baseUrl}/models`;
 	const baseHeaders: Record<string, string> = { ...(model.headers ?? {}) };
 	const attempt = async (headers: Record<string, string>) => {
-		const [response, serverMetadata] = await Promise.all([
-			ctx.fetch(modelsUrl, {
-				headers,
-				signal: AbortSignal.timeout(250),
+		const [entries, serverMetadata] = await Promise.all([
+			withTimeoutSignal(250, async signal => {
+				const response = await ctx.fetch(modelsUrl, {
+					headers,
+					signal,
+				});
+				if (!response.ok) {
+					return undefined;
+				}
+				return parseLlamaCppModelList(await response.json());
 			}),
 			discoverLlamaCppServerMetadata(ctx, baseUrl, headers),
 		]);
-		if (!response.ok) {
+		if (!entries) {
 			return undefined;
 		}
-		const entries = parseLlamaCppModelList(await response.json());
 		const entry = entries.find(entry => entry.id === model.id);
 		if (!entry) {
 			return undefined;
@@ -524,26 +562,28 @@ export async function discoverOpenAIModelsList(
 			providerConfig.discovery.type === "lm-studio"
 				? fetchLmStudioNativeModelMetadata(baseUrl, ctx.fetch, { headers: h })
 				: Promise.resolve(null);
-		const [res, nativeMetadata] = await Promise.all([
-			ctx.fetch(modelsUrl, {
-				headers: h,
-				signal: AbortSignal.timeout(10_000),
+		const [payload, nativeMetadata] = await Promise.all([
+			withTimeoutSignal(10_000, async signal => {
+				const res = await ctx.fetch(modelsUrl, {
+					headers: h,
+					signal,
+				});
+				if (!res.ok) {
+					throw new Error(`HTTP ${res.status} from ${modelsUrl}`);
+				}
+				headers = h;
+				return (await res.json()) as {
+					data?: Array<{ id?: string; max_model_len?: unknown; context_length?: unknown }>;
+				};
 			}),
 			nativeMetadataPromise,
 		]);
-		if (!res.ok) {
-			throw new Error(`HTTP ${res.status} from ${modelsUrl}`);
-		}
-		headers = h;
-		return [res, nativeMetadata] as const;
+		return [payload, nativeMetadata] as const;
 	};
 	const apiKey = await ctx.getBearerApiKeyResolver(providerConfig.provider);
-	const [response, nativeMetadata] = apiKey
+	const [payload, nativeMetadata] = apiKey
 		? await withAuth(apiKey, key => attempt({ ...baseHeaders, Authorization: `Bearer ${key}` }))
 		: await attempt(baseHeaders);
-	const payload = (await response.json()) as {
-		data?: Array<{ id?: string; max_model_len?: unknown; context_length?: unknown }>;
-	};
 	const models = payload.data ?? [];
 	const discovered: Model<Api>[] = [];
 	for (const item of models) {
@@ -600,15 +640,17 @@ export async function discoverLiteLLMModels(
 			}
 			return response;
 		};
-		const models = await fetchLiteLLMRichModels({
-			api: providerConfig.api,
-			provider: providerConfig.provider,
-			baseUrl,
-			headers: h,
-			fetch: authAwareFetch,
-			referenceResolver: resolveReference,
-			signal: AbortSignal.timeout(10_000),
-		});
+		const models = await withTimeoutSignal(10_000, signal =>
+			fetchLiteLLMRichModels({
+				api: providerConfig.api,
+				provider: providerConfig.provider,
+				baseUrl,
+				headers: h,
+				fetch: authAwareFetch,
+				referenceResolver: resolveReference,
+				signal,
+			}),
+		);
 		if (authError && models === null) {
 			throw authError;
 		}
@@ -657,24 +699,24 @@ export async function discoverProxyModels(
 
 	const baseHeaders: Record<string, string> = { ...(providerConfig.headers ?? {}) };
 	let headers = baseHeaders;
-	const attempt = async (h: Record<string, string>) => {
-		const res = await ctx.fetch(modelsUrl, {
-			headers: h,
-			signal: AbortSignal.timeout(10_000),
+	const attempt = async (h: Record<string, string>) =>
+		withTimeoutSignal(10_000, async signal => {
+			const res = await ctx.fetch(modelsUrl, {
+				headers: h,
+				signal,
+			});
+			if (!res.ok) {
+				throw new Error(`HTTP ${res.status} from ${modelsUrl}`);
+			}
+			headers = h;
+			return (await res.json()) as {
+				data?: Array<{ id?: string; name?: string; supported_endpoint_types?: string[]; context_length?: number }>;
+			};
 		});
-		if (!res.ok) {
-			throw new Error(`HTTP ${res.status} from ${modelsUrl}`);
-		}
-		headers = h;
-		return res;
-	};
 	const apiKey = await ctx.getBearerApiKeyResolver(providerConfig.provider);
-	const response = apiKey
+	const payload = apiKey
 		? await withAuth(apiKey, key => attempt({ ...baseHeaders, Authorization: `Bearer ${key}` }))
 		: await attempt(baseHeaders);
-	const payload = (await response.json()) as {
-		data?: Array<{ id?: string; name?: string; supported_endpoint_types?: string[]; context_length?: number }>;
-	};
 	const items = payload.data ?? [];
 	const discovered: Model<Api>[] = [];
 	for (const item of items) {

package/src/extensibility/skills.ts

@@ -384,6 +384,83 @@ export function getSkillSlashCommandName(skill: Pick<Skill, "name">): string {
 	return `skill:${skill.name}`;
 }
 
+/**
+ * Parsed `/skill:<name>` invocation: either at the start of the draft (the
+ * traditional slash-command position) or as a `/skill:<name>` token embedded
+ * mid-prompt. For the mid-prompt form the surrounding prose is threaded
+ * through as `args` so the skill sees the full user request.
+ */
+export interface ParsedSkillInvocation {
+	/** Bare skill name without the leading `skill:` prefix. */
+	name: string;
+	/** User-supplied arguments (everything outside the `/skill:<name>` token). */
+	args: string;
+}
+
+const MID_PROMPT_SKILL_RE = /(^|\s)\/skill:([^\s/]+)(\s|$)/;
+
+/**
+ * Detect a `/skill:<name>` invocation in a user draft.
+ *
+ * Returns `undefined` when the text contains no skill token. Otherwise:
+ *   - Leading form (`/skill:foo bar baz`): name=`foo`, args=`bar baz`.
+ *   - Mid-prompt form (`fix the bug /skill:foo focus on auth`): name=`foo`,
+ *     args=`fix the bug focus on auth` — the surrounding prose collapsed
+ *     into a single args string.
+ *
+ * Mid-prompt detection is disabled when the draft itself starts with a
+ * different slash command (e.g. `/compact /skill:foo`) or a local-execution
+ * sigil — `!cmd` / `!!cmd` for the bash tool and `$ cmd` / `$$ cmd` for the
+ * python tool. Those handlers run after the skill-command dispatcher and
+ * their bodies routinely contain `/skill:<name>` references that are not
+ * meant as skill invocations.
+ */
+export function parseSkillInvocation(text: string): ParsedSkillInvocation | undefined {
+	const trimmedStart = text.trimStart();
+	if (trimmedStart.startsWith("/skill:")) {
+		const spaceIndex = trimmedStart.indexOf(" ");
+		const name =
+			spaceIndex === -1 ? trimmedStart.slice("/skill:".length) : trimmedStart.slice("/skill:".length, spaceIndex);
+		if (!name) return undefined;
+		const args = spaceIndex === -1 ? "" : trimmedStart.slice(spaceIndex + 1).trim();
+		return { name, args };
+	}
+	if (trimmedStart.startsWith("/")) return undefined;
+	if (startsWithLocalExecutionPrefix(trimmedStart)) return undefined;
+	const match = MID_PROMPT_SKILL_RE.exec(text);
+	if (!match) return undefined;
+	const leading = match[1] ?? "";
+	const trailing = match[3] ?? "";
+	const tokenStart = match.index + leading.length;
+	const tokenEnd = match.index + match[0].length - trailing.length;
+	const name = match[2] ?? "";
+	if (!name) return undefined;
+	const before = text.slice(0, tokenStart).trimEnd();
+	const after = text.slice(tokenEnd).trimStart();
+	const args = [before, after]
+		.filter(part => part.length > 0)
+		.join(" ")
+		.trim();
+	return { name, args };
+}
+
+/**
+ * Whether the (already left-trimmed) draft begins with a TUI local-execution
+ * sigil that downstream branches will consume verbatim — `!`/`!!` for the bash
+ * tool and `$`/`$$` followed by ASCII whitespace for the python tool. Mirrors
+ * `pythonCommandPrefixLength` in `modes/controllers/input-controller` so the
+ * two checks agree without forcing a circular import.
+ */
+function startsWithLocalExecutionPrefix(trimmedStart: string): boolean {
+	if (trimmedStart.startsWith("!")) return true;
+	if (trimmedStart.charCodeAt(0) !== 36 /* $ */) return false;
+	if (trimmedStart.charCodeAt(1) === 123 /* { */) return false;
+	const sigilLength = trimmedStart.charCodeAt(1) === 36 /* $ */ ? 2 : 1;
+	const next = trimmedStart.charCodeAt(sigilLength);
+	if (Number.isNaN(next)) return true;
+	return next === 32 /* space */ || next === 9 /* tab */ || next === 10 /* LF */ || next === 13 /* CR */;
+}
+
 export async function buildSkillPromptMessage(
 	skill: Pick<Skill, "name" | "filePath">,
 	args: string,