pi-codebuddy-sdk 0.4.29 → 0.4.31

package/README.md

@@ -20,7 +20,7 @@ Restart `pi` if it was already running.
 
 ## Requirements
 
-- **`codebuddy` on your `PATH`** — the extension spawns the same CLI you use standalone. If `which codebuddy` fails, either add it to `PATH` or set `pathToCodebuddyCode` in `codebuddy-sdk.json` (see [Configuration](#configuration)).
+- **`codebuddy` on your `PATH`** — the extension spawns the same CLI you use standalone. If `which codebuddy` fails, either add it to `PATH` or set `pathToCodebuddyCode` in `codebuddy-sdk.json` (see [Configuration](#configuration)). That option selects the CLI entry point only; the JavaScript runtime used to run it comes from the host, and a Bun-compiled host without a `bun` on `PATH` needs `provider.executable` (see below).
 - **CodeBuddy auth already working** — if `codebuddy` works in your terminal, you do not need extra setup for this extension.
 
 ## Quick start (already using CodeBuddy)
@@ -101,7 +101,8 @@ File: `~/.pi/agent/codebuddy-sdk.json` or `.pi/codebuddy-sdk.json` in a project.
 | `askCodebuddy.allowFullMode` | `true` | Allow write-capable delegation mode |
 | `provider.appendSystemPrompt` | `true` | Use Pi's system prompt instead of CodeBuddy's default identity |
 | `provider.strictMcpConfig` | `true` | Use only Pi-bridged MCP tools |
-| `provider.pathToCodebuddyCode` | auto | Path to `codebuddy` when it is **not** on `PATH` |
+| `provider.pathToCodebuddyCode` | auto | Path to the `codebuddy` **CLI entry point** when it is **not** on `PATH`; does not change the JS runtime |
+| `provider.executable` | host runtime | Runtime used to spawn the CLI (e.g. `"node"`). Set it when the host is Bun-compiled (no `bun` on `PATH`); auto-detected otherwise |
 | `provider.contextWindow` | estimated | Override context window (tokens) for **all** models (e.g. `300000`) |
 | `provider.maxTokens` | estimated | Override max output tokens for **all** models (e.g. `32768`) |
 | `provider.modelOverrides` | — | Per-model overrides, keyed by model id or substring (see below) |
@@ -122,6 +123,12 @@ key wins and beats the global `contextWindow` / `maxTokens`:
 
 Supported per-model keys: `contextWindow`, `maxTokens`, `reasoning`, `images`.
 
+Window values the backend reports for a model are remembered per model id in
+`~/.pi/agent/codebuddy-sdk-learned-windows.json`, so the next start registers the
+last served values instead of the name estimate. Precedence: `modelOverrides` >
+learned > served metadata > estimate. Delete that file to start from estimates
+again (ids the backend no longer serves are dropped automatically).
+
 ## Privacy
 
 - The extension does **not** send conversation data to this repository or any third-party telemetry endpoint.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-codebuddy-sdk",
-  "version": "0.4.29",
+  "version": "0.4.31",
   "description": "Pi extension that uses CodeBuddy (via Agent SDK) as a model provider and adds an AskCodebuddy tool.",
   "author": "RealAlexandreAI",
   "license": "MIT",

package/src/cli-runtime.ts

@@ -0,0 +1,70 @@
+/**
+ * Pick a runtime the host can actually spawn for the CodeBuddy CLI subprocess.
+ *
+ * The Agent SDK resolves the child runtime from the *host* runtime
+ * (`@tencent-ai/agent-sdk/lib/transport/process-transport.js`, `resolveRuntime()`):
+ * when `process.versions.bun` is set it always spawns `bun`, and `node` is only
+ * the final default. Bun-compiled hosts — `omp`, or any single-file Bun binary —
+ * ship no `bun` executable on `PATH`, so every spawn fails with
+ * `Executable not found in $PATH: "bun"` and neither model discovery nor a turn
+ * can run.
+ *
+ * When the host is Bun and `bun` is not resolvable, hand the SDK an explicit
+ * `executable` (its branch 2) pointing at `node`. `provider.executable` in
+ * `codebuddy-sdk.json` overrides the automatic choice.
+ */
+import { accessSync, constants } from "node:fs";
+import { delimiter, join } from "node:path";
+
+export interface RuntimeHost {
+	/** `process.versions` */
+	versions?: Record<string, string | undefined>;
+	/** `process.env.PATH` */
+	path?: string;
+}
+
+function currentHost(): RuntimeHost {
+	return { versions: process.versions as Record<string, string | undefined>, path: process.env.PATH };
+}
+
+/** True when `name` is a runnable file in one of the `PATH` entries. */
+export function isOnPath(name: string, pathValue: string | undefined): boolean {
+	if (!name || !pathValue) return false;
+	for (const dir of pathValue.split(delimiter)) {
+		if (!dir) continue;
+		try {
+			accessSync(join(dir, name), constants.X_OK);
+			return true;
+		} catch {
+			// Not here — keep looking.
+		}
+	}
+	return false;
+}
+
+/**
+ * The runtime the CLI subprocess needs, or `undefined` when the SDK's own choice
+ * works (a node/deno host, or a Bun host that has a `bun` on `PATH`).
+ */
+export function resolveCliRuntime(host: RuntimeHost = currentHost()): string | undefined {
+	if (!host.versions?.bun) return undefined;
+	if (isOnPath("bun", host.path)) return undefined;
+	return isOnPath("node", host.path) ? "node" : undefined;
+}
+
+/**
+ * Return `args` with `options.executable` filled in when the host cannot spawn
+ * the SDK's default runtime. An explicit `executable` — on the call or in the
+ * config — always wins.
+ */
+export function withCliRuntime<T extends { options?: { executable?: string } }>(
+	args: T,
+	configuredExecutable?: string,
+	host: RuntimeHost = currentHost(),
+): T {
+	const options = args?.options;
+	if (options?.executable) return args;
+	const executable = configuredExecutable?.trim() || resolveCliRuntime(host);
+	if (!executable) return args;
+	return { ...args, options: { ...options, executable } };
+}

package/src/config.ts

@@ -27,6 +27,11 @@ export interface Config {
 		settingSources?: SettingSource[];
 		strictMcpConfig?: boolean;
 		pathToCodebuddyCode?: string;
+		/**
+		 * Runtime used to spawn the CodeBuddy CLI (e.g. `"node"`). Defaults to the
+		 * host runtime; set this when a Bun-compiled host has no `bun` on `PATH`.
+		 */
+		executable?: string;
 		/** Override the estimated context window (tokens) for ALL models. */
 		contextWindow?: number;
 		/** Override the estimated max output tokens for ALL models. */

package/src/index.ts

@@ -9,10 +9,12 @@ import { appendFileSync, mkdirSync, realpathSync, statSync } from "fs";
 import { homedir } from "os";
 import { dirname, join } from "path";
 import { PROVIDER_ID, messageContentToText, convertPiMessages } from "./convert.js";
-import { buildModels, codebuddyModelId, FALLBACK_MODELS, rawModelsFromSdk, resolveModel as _resolveModel, type PiModel } from "./models.js";
+import { buildModels, codebuddyModelId, FALLBACK_MODELS, matchesAnyOverrideKey, rawModelsFromSdk, resolveModel as _resolveModel, type PiModel } from "./models.js";
 import { readModelsCache, writeModelsCache } from "./models-cache.js";
+import { applyLearnedWindows, pruneLearnedWindows, readLearnedWindows, recordServedWindows, writeLearnedWindows } from "./learned-windows.js";
 import { clearOwnedStream, providerRegistration } from "./provider-registration.js";
 import { syncServedWindow } from "./served-window.js";
+import { withCliRuntime } from "./cli-runtime.js";
 import { readTranscript } from "./transcript-compat.js";
 import { MCP_SERVER_NAME, MCP_TOOL_PREFIX, buildCodebuddySystemPrompt } from "./skills.js";
 import { verifyWrittenSession as _verifyWrittenSession } from "./session-verify.js";
@@ -165,7 +167,7 @@ function installTransportTeardownGuard(sdkQuery: unknown): void {
 
 /** Create an SDK query and immediately arm the transport teardown guard. */
 function startQuery(args: Parameters<typeof query>[0]): ReturnType<typeof query> {
-	const q = query(args);
+	const q = query(withCliRuntime(args, providerSettings.executable));
 	try {
 		installTransportTeardownGuard(q);
 	} catch (err) {
@@ -853,10 +855,18 @@ function buildMcpServers(tools: Tool[], queryCtx: QueryContext): Record<string,
 // --- Usage helpers ---
 
 function updateUsage(output: AssistantMessage, usage: Record<string, number | undefined>, model: Model<any>): void {
-	if (usage.input_tokens != null) output.usage.input = usage.input_tokens;
+	// CodeBuddy reports OpenAI/DeepSeek-style usage: input_tokens covers the whole prompt and
+	// cache_read_input_tokens is the cached slice of that same prompt. pi's Usage type is
+	// Anthropic-style, where input holds only the uncached remainder, because pi derives
+	// promptTokens = input + cacheRead + cacheWrite (core/cache-stats). Storing the total in
+	// the input field therefore counts the cached prompt twice and makes pi report bogus
+	// 'Cache miss: <n> tokens re-billed' notices. Mirrors pi-ai's openai-completions adapter.
+	const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
+	const cacheWriteTokens = usage.cache_creation_input_tokens ?? 0;
+	if (usage.input_tokens != null) output.usage.input = Math.max(0, usage.input_tokens - cacheReadTokens - cacheWriteTokens);
 	if (usage.output_tokens != null) output.usage.output = usage.output_tokens;
-	if (usage.cache_read_input_tokens != null) output.usage.cacheRead = usage.cache_read_input_tokens;
-	if (usage.cache_creation_input_tokens != null) output.usage.cacheWrite = usage.cache_creation_input_tokens;
+	if (usage.cache_read_input_tokens != null) output.usage.cacheRead = cacheReadTokens;
+	if (usage.cache_creation_input_tokens != null) output.usage.cacheWrite = cacheWriteTokens;
 	// CodeBuddy may report reasoning/thinking tokens separately, while pi's Usage type does not model that field.
 	const reasoning = usage.reasoning_tokens ?? usage.thinking_tokens;
 	if (reasoning != null) (output.usage as typeof output.usage & { reasoning?: number }).reasoning = reasoning;
@@ -888,6 +898,12 @@ function syncServedContextWindow(label: string, message: CbMessage, model: Model
 	for (const change of changes) {
 		debug(`${label}: ${change.id} ${change.field} ${change.from} -> ${change.to}`);
 	}
+	// Remember the served values so the next process starts from them instead of
+	// re-registering the estimate (this backend reports no window metadata).
+	if (changes.length) {
+		const learned = readLearnedWindows();
+		if (recordServedWindows(learned, changes)) writeLearnedWindows(learned);
+	}
 }
 
 // --- Effort level mapping ---
@@ -1727,6 +1743,12 @@ async function discoverModels(pi: ExtensionAPI): Promise<void> {
 				providerSettings.modelOverrides ? undefined : providerSettings,
 				providerSettings.modelOverrides,
 			);
+			// Re-apply windows learned in earlier processes: they beat the name
+			// estimate and the served metadata, but never a user override. Ids the
+			// backend no longer serves are dropped from the store.
+			const learned = pruneLearnedWindows(readLearnedWindows(), MODELS.map((m) => m.id));
+			MODELS = applyLearnedWindows(MODELS, learned, (id) => matchesAnyOverrideKey(id, providerSettings.modelOverrides));
+			writeLearnedWindows(learned);
 			// Persist the successful discovery globally so a later session
 			// resume (module reload) can recover the real model list even if
 			// discovery fails that time (e.g. SDK subprocess gate is busy).

package/src/learned-windows.ts

@@ -0,0 +1,120 @@
+/**
+ * Served context windows, remembered across processes.
+ *
+ * This backend reports no window metadata, so every model is registered from a
+ * name estimate. The served value only arrives per turn, inside `modelUsage`;
+ * `syncServedWindow` applies it to the catalog entry and the live model, but
+ * only in memory. Without persistence that knowledge dies with the process:
+ * the next `discoverModels` re-registers the estimate and rewrites the model
+ * cache, so each restart shows the guess again for every model the user has not
+ * overridden by hand.
+ *
+ * Keep the last served value per model id on disk and re-apply it after
+ * `buildModels()`. Precedence: user `modelOverrides` > learned > SDK metadata >
+ * name estimate.
+ */
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import type { WindowSyncChange } from "./served-window.js";
+
+export interface LearnedWindow {
+	contextWindow?: number;
+	maxTokens?: number;
+}
+
+export type LearnedWindows = Record<string, LearnedWindow>;
+
+/** In-process cache so repeated reads in one session do not touch the disk. */
+export const LEARNED_WINDOWS_KEY = Symbol.for("codebuddy-sdk:learnedWindows");
+
+const defaultStoreFile = () => join(homedir(), ".pi", "agent", "codebuddy-sdk-learned-windows.json");
+
+// Injectable for tests.
+const storeFile = () => process.env.CODEBUDDY_SDK_LEARNED_WINDOWS_PATH || defaultStoreFile();
+
+function sanitize(value: unknown): LearnedWindow | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const raw = value as LearnedWindow;
+	const entry: LearnedWindow = {};
+	if (Number.isSafeInteger(raw.contextWindow) && (raw.contextWindow as number) > 0) entry.contextWindow = raw.contextWindow;
+	if (Number.isSafeInteger(raw.maxTokens) && (raw.maxTokens as number) > 0) entry.maxTokens = raw.maxTokens;
+	return Object.keys(entry).length ? entry : undefined;
+}
+
+export function readLearnedWindows(): LearnedWindows {
+	const inProcess = (globalThis as Record<symbol, unknown>)[LEARNED_WINDOWS_KEY] as LearnedWindows | undefined;
+	if (inProcess) return inProcess;
+	try {
+		const parsed: unknown = JSON.parse(readFileSync(storeFile(), "utf8"));
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+			const map: LearnedWindows = {};
+			for (const [id, value] of Object.entries(parsed as Record<string, unknown>)) {
+				const entry = sanitize(value);
+				if (entry) map[id] = entry;
+			}
+			return map;
+		}
+	} catch {
+		// No store yet, or unreadable — the caller falls back to estimates.
+	}
+	return {};
+}
+
+export function writeLearnedWindows(map: LearnedWindows): void {
+	(globalThis as Record<symbol, unknown>)[LEARNED_WINDOWS_KEY] = map;
+	try {
+		const path = storeFile();
+		mkdirSync(dirname(path), { recursive: true });
+		const tmp = `${path}.tmp`;
+		const sorted = Object.fromEntries(Object.entries(map).sort(([a], [b]) => a.localeCompare(b)));
+		writeFileSync(tmp, JSON.stringify(sorted));
+		renameSync(tmp, path);
+	} catch {
+		// Store is best-effort; the next turn re-learns the value.
+	}
+}
+
+/** Fold served-window changes into `map`. Returns true when something moved. */
+export function recordServedWindows(map: LearnedWindows, changes: readonly WindowSyncChange[]): boolean {
+	let touched = false;
+	for (const change of changes) {
+		if (!Number.isSafeInteger(change.to) || change.to <= 0) continue;
+		const entry = (map[change.id] ??= {});
+		if (entry[change.field] === change.to) continue;
+		entry[change.field] = change.to;
+		touched = true;
+	}
+	return touched;
+}
+
+/** Drop ids the backend no longer serves. */
+export function pruneLearnedWindows(map: LearnedWindows, ids: Iterable<string>): LearnedWindows {
+	const keep = new Set(ids);
+	const out: LearnedWindows = {};
+	for (const [id, value] of Object.entries(map)) {
+		if (keep.has(id)) out[id] = value;
+	}
+	return out;
+}
+
+/**
+ * Overwrite estimated windows with learned ones. Matching is by exact id on
+ * purpose — override keys use substring matching, learned ids must not leak into
+ * neighbouring models. `skip` keeps user overrides authoritative.
+ */
+export function applyLearnedWindows<T extends { id: string; contextWindow: number; maxTokens: number }>(
+	models: readonly T[],
+	learned: LearnedWindows,
+	skip?: (id: string) => boolean,
+): T[] {
+	return models.map((model) => {
+		const entry = learned[model.id];
+		if (!entry || skip?.(model.id)) return model;
+		return {
+			...model,
+			contextWindow: entry.contextWindow ?? model.contextWindow,
+			maxTokens: entry.maxTokens ?? model.maxTokens,
+		};
+	});
+}

package/src/models.ts

@@ -24,12 +24,28 @@ type SdkModelMeta = {
 	contextWindow?: { supportedLengths?: ReadonlyArray<number>; defaultLength?: number };
 };
 
+// Capabilities are inferred from the model id: this backend returns `{id, name}`
+// only, so there is no metadata to read (unlike the window, capabilities cannot
+// be learned from `modelUsage` either). `modelOverrides.reasoning` / `.images`
+// still win over every hint below.
+//
+// The families cover the CodeBuddy catalog, whose entries are reasoning-only and
+// image-capable apart from the two text-only models called out in
+// `TEXT_ONLY_MODELS`. Reasoning hints stay broad (`glm`, `deepseek`, …) and image
+// hints are version-scoped so an unverified model keeps the conservative default.
+const REASONING_HINTS = /claude|gemini|gpt-5|glm|hy[34]|deepseek|kimi|minimax|step|space/i;
+const IMAGE_HINTS = /claude|gemini|gpt|glm-5[.v]|hy[34]|deepseek-v4|kimi-k[23]|minimax-m[23]|step|space/i;
+// Verified text-only: the CodeBuddy catalog marks both `supportsImages: false`,
+// and a 1x1 PNG probe came back with "the current model doesn't support image
+// reading" from each.
+const TEXT_ONLY_MODELS = new Set(["glm-5.1", "glm-5.2"]);
+
 function detectThinking(id: string): boolean {
-	return /claude|gemini|gpt-5|hy3|deepseek|glm/i.test(id);
+	return REASONING_HINTS.test(id);
 }
 
 function detectImages(id: string): boolean {
-	return /claude|gemini|gpt/i.test(id);
+	return !TEXT_ONLY_MODELS.has(id.toLowerCase()) && IMAGE_HINTS.test(id);
 }
 
 function estimateContext(id: string): number {
@@ -87,6 +103,21 @@ export type ModelOverrides = {
  * (matched by exact id first, then case-insensitive substring, longest key
  * wins) and beats the global defaults.
  */
+/**
+ * True when a `modelOverrides` key selects `id`: exact match, or a
+ * case-insensitive substring.
+ */
+export function overrideKeyMatches(id: string, key: string): boolean {
+	const k = key.toLowerCase();
+	return id === key || (k.length > 0 && id.toLowerCase().includes(k));
+}
+
+/** True when any `modelOverrides` key selects `id`. */
+export function matchesAnyOverrideKey(id: string, perModel?: Record<string, unknown>): boolean {
+	if (!perModel) return false;
+	return Object.keys(perModel).some((key) => overrideKeyMatches(id, key));
+}
+
 export function buildModels(
 	models: PiModel[],
 	globalOverrides?: ModelOverrides,
@@ -94,10 +125,8 @@ export function buildModels(
 ): PiModel[] {
 	const sortedKeys = Object.keys(perModel ?? {}).sort((a, b) => b.length - a.length);
 	const match = (id: string): ModelOverrides | undefined => {
-		const lower = id.toLowerCase();
 		for (const key of sortedKeys) {
-			const k = key.toLowerCase();
-			if (id === key || (lower.includes(k) && k.length > 0)) return perModel![key];
+			if (overrideKeyMatches(id, key)) return perModel![key];
 		}
 		return undefined;
 	};