@phi-code-admin/phi-code 0.77.1 → 0.77.3

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## [0.77.3] - 2026-06-13
+
+### Added
+
+- **`/context` command to view and set the active model's context window.**
+  `/context` shows the current window and whether it is provider-reported,
+  inferred, or a manual override. `/context 256k`, `/context 1M`, or
+  `/context 200000` set it (applied immediately to the footer and auto-compaction,
+  and saved as a per-model override that survives restarts and the background
+  refresh). `/context auto` clears the override. Useful when a provider reports no
+  window and the inferred value is wrong: the window directly drives when the
+  conversation auto-compacts (`compact when tokens > window - reserve`).
+
+### Changed
+
+- **Default fallback context window raised from 128k to 256k**, matching most
+  current high-end models. Known 128k families (DeepSeek, Llama, GPT-4o, Hy3) are
+  pinned explicitly so they are not over-reported. Note the asymmetry: a too-large
+  window risks a late compaction and a hard "context exceeded" on a genuinely
+  smaller model, so set the real value with `/context` when in doubt.
+
+## [0.77.2] - 2026-06-13
+
+### Changed
+
+- **Unified, dynamic context-window resolution across all providers.** A single
+  `inferContextWindow(modelId, apiValue, providerId)` resolver now backs both the
+  generic live-models path and the OpenCode Go path, replacing the duplicated flat
+  `128k` fallbacks. When a provider API omits the window, it is inferred by model
+  family (Qwen/MiniMax 1M, Gemini 1-2M, Kimi 256k, GLM/MiMo 200k, GPT-5 400k,
+  Claude 200k) instead of collapsing to 128k.
+- **Background model refresh now covers the OpenCode Go provider pair.** The
+  session-start refresh (and `/models refresh`) previously skipped
+  `opencode-go-anthropic` entirely and did not split Qwen/MiniMax onto the
+  Anthropic endpoint. It now refreshes both `opencode-go` and
+  `opencode-go-anthropic` from the shared catalog, so large-context models
+  (e.g. `qwen3.7-plus`) self-correct to their real window on the next session
+  without re-running `/setup`.
+
 ## [0.77.1] - 2026-06-13
 
 ### Fixed

package/extensions/phi/models.ts

@@ -16,6 +16,12 @@
  */
 
 import { ApiKeyStore, type ConfigWatcher, type ExtensionAPI, getApiKeyStore, getConfigWatcher } from "phi-code";
+import {
+	buildOpenCodeGoAnthropicProviderConfig,
+	buildOpenCodeGoProviderConfig,
+	getOpenCodeGoModels,
+} from "./providers/opencode-go.js";
+import { formatWindow, inferContextWindow, parseContextWindow } from "./providers/context-window.js";
 import { fetchLiveModels, peekCache, resetLiveModelsCache, toPersistedModel } from "./providers/live-models.js";
 
 const PROVIDER_DISPLAY: Record<string, string> = {
@@ -42,6 +48,41 @@ interface RefreshOutcome {
 	error?: string;
 }
 
+/**
+ * Refresh the OpenCode Go provider pair from the shared catalog.
+ * "opencode-go" persists the OpenAI-compat models; "opencode-go-anthropic"
+ * persists the Qwen/MiniMax models served over the Anthropic endpoint. Both
+ * sides get family-inferred context windows via the config builders.
+ */
+async function refreshOpenCodeGo(
+	store: ApiKeyStore,
+	watcher: ConfigWatcher,
+	providerId: string,
+	apiKey: string | undefined,
+	stored: ReturnType<ApiKeyStore["getProvider"]>,
+): Promise<RefreshOutcome> {
+	const { models, source } = await getOpenCodeGoModels({ apiKey, forceRefresh: true });
+	const keyForBuild = apiKey ?? stored?.apiKey ?? "local";
+	const config =
+		providerId === "opencode-go-anthropic"
+			? buildOpenCodeGoAnthropicProviderConfig(keyForBuild, models)
+			: buildOpenCodeGoProviderConfig(keyForBuild, models);
+
+	if (config.models.length === 0) {
+		return { provider: providerId, source: source === "fallback" ? "fallback" : "skipped", count: 0 };
+	}
+
+	watcher.muteForWrite("models_json_changed");
+	store.setKey(providerId, stored?.apiKey ?? apiKey ?? "local", {
+		baseUrl: stored?.baseUrl ?? config.baseUrl,
+		api: stored?.api ?? config.api,
+		models: config.models,
+	});
+
+	const outcomeSource = source === "live" ? "live" : source === "cache" ? "cache" : "fallback";
+	return { provider: providerId, source: outcomeSource, count: config.models.length };
+}
+
 async function refreshOne(
 	store: ApiKeyStore,
 	watcher: ConfigWatcher,
@@ -52,6 +93,12 @@ async function refreshOne(
 		? stored.apiKey
 		: undefined;
 
+	// OpenCode Go is a provider pair the generic fetchLiveModels path can't express
+	// (and never handled the Anthropic side), so refresh it from the shared catalog.
+	if (providerId === "opencode-go" || providerId === "opencode-go-anthropic") {
+		return await refreshOpenCodeGo(store, watcher, providerId, apiKey, stored);
+	}
+
 	resetLiveModelsCache(providerId);
 	const result = await fetchLiveModels(providerId, {
 		apiKey,
@@ -144,6 +191,96 @@ export default function modelsExtension(pi: ExtensionAPI) {
 		},
 	});
 
+	pi.registerCommand("context", {
+		description:
+			"Show or set the active model's context window (e.g. `/context 256k`, `/context 1M`, `/context auto`). Drives when the conversation auto-compacts.",
+		handler: async (args, ctx) => {
+			const model = ctx.model;
+			if (!model) {
+				ctx.ui.notify("No active model. Select one with `/model` first.", "warning");
+				return;
+			}
+			const provider = model.provider;
+			const modelId = model.id;
+			const arg = args.trim();
+
+			const readOverrideWindow = (): number | undefined => {
+				const overrides = store.getProvider(provider)?.modelOverrides as
+					| Record<string, { contextWindow?: number }>
+					| undefined;
+				return overrides?.[modelId]?.contextWindow;
+			};
+
+			const writeOverrides = (overrides: Record<string, unknown>): void => {
+				const stored = store.getProvider(provider) ?? {};
+				watcher.muteForWrite("models_json_changed");
+				store.setKey(provider, stored.apiKey ?? "local", { modelOverrides: overrides });
+			};
+
+			try {
+				if (arg === "") {
+					const source = readOverrideWindow() !== undefined ? "manual override" : "provider / inferred";
+					ctx.ui.notify(
+						`**${modelId}** (\`${provider}\`) context window: \`${formatWindow(model.contextWindow)}\` (${source}).\n` +
+							"Set the real value with `/context 256k`, `/context 1M`, or `/context 200000`. " +
+							"Reset to the detected value with `/context auto`.\n" +
+							"This is what determines when the conversation auto-compacts.",
+						"info",
+					);
+					return;
+				}
+
+				if (arg.toLowerCase() === "auto" || arg.toLowerCase() === "reset") {
+					const stored = store.getProvider(provider) ?? {};
+					const overrides = { ...((stored.modelOverrides as Record<string, unknown>) ?? {}) };
+					const entry = overrides[modelId];
+					if (entry && typeof entry === "object") {
+						const next = { ...(entry as Record<string, unknown>) };
+						delete next.contextWindow;
+						if (Object.keys(next).length === 0) delete overrides[modelId];
+						else overrides[modelId] = next;
+					}
+					writeOverrides(overrides);
+
+					// Revert the active model to the persisted/inferred window.
+					const persistedModels = (store.getProvider(provider)?.models as
+						| Array<{ id?: string; contextWindow?: number }>
+						| undefined) ?? [];
+					const persisted = persistedModels.find((m) => m?.id === modelId)?.contextWindow;
+					const reverted = persisted && persisted > 0 ? persisted : inferContextWindow(modelId, undefined, provider);
+					await pi.setModel({ ...model, contextWindow: reverted });
+					ctx.ui.notify(`Cleared context override for **${modelId}**. Reverted to \`${formatWindow(reverted)}\`.`, "info");
+					return;
+				}
+
+				const value = parseContextWindow(arg);
+				if (!value) {
+					ctx.ui.notify("Invalid value. Use e.g. `256k`, `1M`, or `200000`.", "warning");
+					return;
+				}
+
+				// Immediate effect: the footer and auto-compaction use the new window right away.
+				await pi.setModel({ ...model, contextWindow: value });
+
+				// Persist as a per-model override so it survives restarts and the background
+				// refresh (which rewrites `models` but leaves `modelOverrides` untouched).
+				const stored = store.getProvider(provider) ?? {};
+				const overrides = { ...((stored.modelOverrides as Record<string, unknown>) ?? {}) };
+				const existing = (overrides[modelId] as Record<string, unknown> | undefined) ?? {};
+				overrides[modelId] = { ...existing, contextWindow: value };
+				writeOverrides(overrides);
+
+				ctx.ui.notify(
+					`Context window for **${modelId}** set to \`${formatWindow(value)}\` (saved). ` +
+						`Auto-compaction now triggers near ${formatWindow(value)}.`,
+					"info",
+				);
+			} catch (err) {
+				ctx.ui.notify(`/context error: ${err instanceof Error ? err.message : String(err)}`, "error");
+			}
+		},
+	});
+
 	async function listCommand(target: string | undefined, ctx: { ui: { notify: (m: string, t?: "info" | "warning" | "error") => void } }): Promise<void> {
 		const providers = target ? [target] : store.listProviders();
 		if (providers.length === 0) {

package/extensions/phi/providers/context-window.ts

@@ -0,0 +1,63 @@
+/**
+ * Shared context-window resolver for all phi providers.
+ *
+ * Provider `/models` endpoints are inconsistent: some report the context window
+ * (under `context_length`, `context_window`, `inputTokenLimit`, ...), many omit
+ * it entirely (OpenCode Go for newer Qwen models, Alibaba, ...). A flat default
+ * badly under-reports large-context families and surfaces as a wrong "/128k" in
+ * the footer. This resolver layers the sources:
+ *   1. the value reported by the provider API (if present and positive);
+ *   2. a curated per-family heuristic (keeps large-context models correct);
+ *   3. a generic default.
+ *
+ * Family values mirror the bundled static specs (OPENCODE_GO_FALLBACK_MODELS,
+ * default-models.json, live-models static specs).
+ */
+
+// Default when nothing is known. 256k matches the majority of current high-end
+// models. Note the asymmetry: over-reporting risks a hard "context exceeded" on a
+// genuinely smaller model (caught late by the overflow safety net), while
+// under-reporting only compacts a little early. Use `/context` to set the real
+// window for a model whose value is unknown.
+const DEFAULT_CONTEXT_WINDOW = 256_000;
+
+export function inferContextWindow(modelId: string, apiValue?: number, providerId?: string): number {
+	if (typeof apiValue === "number" && apiValue > 0) return apiValue;
+
+	const id = (modelId ?? "").toLowerCase();
+	// Large-context families that provider /models endpoints often omit.
+	if (id.includes("qwen") || id.includes("minimax")) return 1_000_000;
+	if (id.includes("gemini")) return id.includes("flash") ? 1_000_000 : 2_000_000;
+	if (id.includes("gpt-5")) return 400_000;
+	if (id.includes("kimi")) return 256_000;
+	if (id.includes("glm") || id.includes("mimo")) return 200_000;
+	if (id.includes("claude")) return 200_000;
+	// Known 128k families: pin them so the larger default does not over-report them.
+	if (id.includes("deepseek") || id.includes("llama") || id.includes("gpt-4") || id.includes("hy3")) return 128_000;
+
+	// Provider-level hint when the model id is opaque.
+	const provider = (providerId ?? "").toLowerCase();
+	if (provider.includes("google") || provider.includes("gemini")) return 2_000_000;
+
+	return DEFAULT_CONTEXT_WINDOW;
+}
+
+/** Parse a context-window value like "256k", "1M", "1.5m", or "200000". */
+export function parseContextWindow(input: string): number | undefined {
+	const m = input.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*([km])?$/);
+	if (!m) return undefined;
+	const n = Number.parseFloat(m[1]);
+	if (!Number.isFinite(n) || n <= 0) return undefined;
+	const mult = m[2] === "k" ? 1_000 : m[2] === "m" ? 1_000_000 : 1;
+	const value = Math.round(n * mult);
+	return value > 0 ? value : undefined;
+}
+
+/** Format a token count as a compact "256k" / "1M" label. */
+export function formatWindow(n: number): string {
+	if (n >= 1_000_000) {
+		const v = n / 1_000_000;
+		return `${Number.isInteger(v) ? v : v.toFixed(1)}M`;
+	}
+	return `${Math.round(n / 1_000)}k`;
+}

package/extensions/phi/providers/live-models.ts

@@ -25,6 +25,7 @@ import {
 	pingOpenCodeGo,
 } from "./opencode-go.js";
 import { ALIBABA_MODELS, ALIBABA_PROVIDERS, pingAlibaba } from "./alibaba.js";
+import { inferContextWindow } from "./context-window.js";
 
 export const LAST_VERIFIED = "2026-05-15";
 
@@ -462,7 +463,9 @@ export function toPersistedModel(m: LiveModel): {
 		name: m.name ?? m.id,
 		reasoning: m.reasoning ?? true,
 		input: ["text"] as const,
-		contextWindow: m.contextWindow ?? 128_000,
+		// Infer by model family when the provider API omits the window, instead of
+		// collapsing large-context models (Qwen/MiniMax/Gemini/...) to a flat 128k.
+		contextWindow: inferContextWindow(m.id, m.contextWindow),
 		maxTokens: m.maxTokens ?? 16_384,
 	};
 }

package/extensions/phi/providers/opencode-go.ts

@@ -18,6 +18,8 @@
  * Model IDs follow format: opencode-go/<model-id> (e.g., opencode-go/kimi-k2.6).
  */
 
+import { inferContextWindow } from "./context-window.js";
+
 export const OPENCODE_GO_ENV_VAR = "OPENCODE_GO_API_KEY";
 export const OPENCODE_GO_AUTH_URL = "https://opencode.ai/auth";
 export const OPENCODE_GO_MODELS_URL = "https://opencode.ai/zen/go/v1/models";
@@ -211,17 +213,11 @@ export function isOpenCodeGoAnthropicModel(id: string): boolean {
 
 /**
  * Infer a model's context window by family when the OpenCode Go API does not
- * report one (it omits it for some newer models, e.g. qwen3.7-plus). A flat
- * 128k default badly under-reports the large-context Qwen/MiniMax models, which
- * surfaces as a wrong "/128k" in the footer. Values mirror OPENCODE_GO_FALLBACK_MODELS.
+ * report one (it omits it for some newer models, e.g. qwen3.7-plus). Delegates
+ * to the shared resolver so every provider applies the same family heuristics.
  */
 export function inferOpenCodeGoContextWindow(id: string, provided?: number): number {
-	if (typeof provided === "number" && provided > 0) return provided;
-	const lower = id.toLowerCase();
-	if (/^(qwen|minimax)/.test(lower)) return 1_000_000;
-	if (/^kimi/.test(lower)) return 256_000;
-	if (/^(glm|mimo)/.test(lower)) return 200_000;
-	return 128_000;
+	return inferContextWindow(id, provided, "opencode-go");
 }
 
 function toPersistedOpenCodeGoModel(m: OpenCodeGoModel) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@phi-code-admin/phi-code",
-	"version": "0.77.1",
+	"version": "0.77.3",
 	"description": "Coding agent CLI with persistent memory, sub-agents, intelligent routing, and orchestration",
 	"type": "module",
 	"piConfig": {