pi-free 2.0.12 → 2.0.13

package/README.md

@@ -20,7 +20,7 @@ When you install pi-free, it:
 
 3. **Filters to show only free models by default** for providers that expose pricing — You see only the models that cost $0 to use. Paid models are hidden until you explicitly toggle them on.
 
-4. **Provides per-provider toggle commands** — Run `/toggle-{provider}` (e.g., `/toggle-kilo`, `/toggle-opencode`) to switch between free-only mode and showing all models including paid ones. Changes apply immediately and your preference is saved for the next Pi restart.
+4. **Provides per-provider toggle commands** — Run `/toggle-{provider}` (e.g., `/toggle-kilo`) to switch between free-only mode and showing all models including paid ones. Changes apply immediately and your preference is saved for the next Pi restart.
 
 5. **Handles authentication for you** — OAuth flows (Kilo, Cline) open your browser automatically; API keys are read from `~/.pi/free.json` or environment variables
 
@@ -46,7 +46,6 @@ Free models are shown by default — look for the provider prefixes:
 
 **✅ Free Models (no payment required):**
 
-- `opencode/` — OpenCode models (no setup required; toggle with `/toggle-opencode`)
 - `kilo/` — Kilo models (free models available immediately, more after `/login kilo`)
 - `openrouter/` — OpenRouter models (free account required)
 - `cline/` — Cline models (run `/login cline` to use)
@@ -75,7 +74,6 @@ Free models are shown by default — look for the provider prefixes:
 - `cerebras/` — Cerebras models (when `CEREBRAS_API_KEY` set)
 - `xai/` — xAI models (when `XAI_API_KEY` set)
 - `huggingface/` — Hugging Face models (when `HF_TOKEN` set)
-- `opencode/` — OpenCode models (fetched from opencode.ai/zen/v1, when `OPENCODE_API_KEY` set)
 - `openrouter/` — OpenRouter models (fetched from openrouter.ai, when `OPENROUTER_API_KEY` set)
 - `fastrouter/` — FastRouter models (always discovered, 170+ models, no auth for listing)
 
@@ -86,7 +84,6 @@ Free models are shown by default — look for the provider prefixes:
 Want to see paid models too? Run the toggle command for your provider:
 
 ```
-/toggle-opencode   # Toggle OpenCode (✅ offers free models)
 /toggle-kilo       # Toggle Kilo (✅ offers free models)
 /toggle-openrouter # Toggle OpenRouter (✅ offers free models)
 /toggle-cline      # Toggle Cline (✅ offers free models)
@@ -114,10 +111,6 @@ Want to see paid models too? Run the toggle command for your provider:
 - **🔧 Dynamic providers** show all fetched models by default — the toggle filters the list when you have an API key configured
 - **Freemium providers** show all models by default; you manage your usage limits via their dashboards
 
-You'll see a notification like: `opencode: showing free models` or `opencode: showing all models`
-
-**Note:** Built-in provider toggles such as OpenCode and OpenRouter update in the current session — no restart needed.
-
 ### 4. Add API keys for more providers (optional)
 
 Some providers require a free account or API key.
@@ -204,7 +197,7 @@ Providers have different pricing models. pi-free handles them all:
 
 **Provider types:**
 
-- ✅ **Free providers** (OpenCode, Kilo, Cline) — Toggle between free-only vs paid models
+- ✅ **Free providers** (Kilo, Cline) — Toggle between free-only vs paid models
 - 🔄 **Freemium** (NVIDIA, Ollama) — Free tier with limits, toggle shows all
 - 🔧 **Dynamic API** (Mistral, Groq, Cerebras, xAI) — Fetched when API key configured, toggle filters the list
 
@@ -219,17 +212,6 @@ Authentication is handled automatically:
 
 ## Using Free Models (No Setup Required)
 
-### OpenCode
-
-Works immediately with zero setup:
-
-1. Press `Ctrl+L`
-2. Search for `opencode/`
-3. Pick any model (e.g., `opencode/big-pickle`)
-4. Start chatting
-
-No account, no API key, no OAuth. Run `/toggle-opencode` to switch between free and paid OpenCode models.
-
 ### Kilo (free models, more after login)
 
 Kilo shows free models immediately. To unlock all models, authenticate with Kilo's free OAuth:
@@ -450,7 +432,6 @@ Each provider has toggle commands to switch between free and all models:
 
 | Command                 | Action                                                   |
 | ----------------------- | -------------------------------------------------------- |
-| `/toggle-opencode`      | Toggle between free/all OpenCode models                  |
 | `/toggle-kilo`          | Toggle between free/all Kilo models                      |
 | `/toggle-openrouter`    | Toggle between free/all OpenRouter models                |
 | `/toggle-cline`         | Toggle between free/all Cline models                     |
@@ -477,7 +458,7 @@ Each provider has toggle commands to switch between free and all models:
 - **For 🔄 freemium providers**: Shows all models by default; toggle switches between filtered and full list
 - **For 🔧 dynamic API providers**: Filters the model list when you have an API key configured
 - **Persists your preference** to `~/.pi/free.json` for next startup
-- Shows a notification: "opencode: showing free models" or "opencode: showing all models"
+
 
 ### Probe Commands (Health Check)
 

package/lib/built-in-toggle.ts

@@ -24,9 +24,18 @@ import {
 	registerWithGlobalToggle,
 } from "./registry.ts";
 import { createToggleState } from "./toggle-state.ts";
+import {
+	OPENCODE_DYNAMIC_API,
+	createOpenCodeSessionTracker,
+	createOpenCodeStreamSimple,
+	isOpenCodeProvider,
+} from "../providers/opencode-session.ts";
 
 const _logger = createLogger("built-in-toggle");
 
+// OpenCode requires per-request ids; see createOpenCodeStreamSimple().
+const _opencodeSession = createOpenCodeSessionTracker();
+
 // =============================================================================
 // Configuration
 // =============================================================================
@@ -38,6 +47,7 @@ interface BuiltInToggleConfig {
 
 const BUILT_IN_TOGGLE_PROVIDERS: BuiltInToggleConfig[] = [
 	{ id: "opencode", getShowPaid: getOpencodeShowPaid },
+	{ id: "opencode-go", getShowPaid: getOpencodeShowPaid },
 	{ id: "openrouter", getShowPaid: getOpenrouterShowPaid },
 ];
 
@@ -113,7 +123,9 @@ function tryCaptureProvider(
 	);
 	if (providerModels.length === 0) return undefined;
 
-	const allModels = providerModels.map(modelToProviderConfig);
+	const allModels = providerModels.map((m: Model<Api>) =>
+		modelToProviderConfig(m, config.id),
+	);
 	const freeModels = allModels.filter((m: ProviderModelConfig) =>
 		isFreeModel({ ...m, provider: config.id }, allModels),
 	);
@@ -126,7 +138,10 @@ function tryCaptureProvider(
 		pi.registerProvider(config.id, {
 			baseUrl,
 			apiKey: apiKeyEnv,
-			api,
+			api: isOpenCodeProvider(config.id) ? OPENCODE_DYNAMIC_API : api,
+			...(isOpenCodeProvider(config.id)
+				? { streamSimple: createOpenCodeStreamSimple(_opencodeSession) }
+				: {}),
 			models,
 		});
 	};
@@ -196,8 +211,11 @@ function registerToggleCommand(
 // Helpers
 // =============================================================================
 
-function modelToProviderConfig(m: Model<Api>): ProviderModelConfig {
-	return {
+function modelToProviderConfig(
+	m: Model<Api>,
+	providerId?: string,
+): ProviderModelConfig {
+	const base: ProviderModelConfig = {
 		id: m.id,
 		name: m.name,
 		api: m.api,
@@ -209,6 +227,14 @@ function modelToProviderConfig(m: Model<Api>): ProviderModelConfig {
 		headers: m.headers,
 		compat: (m as any).compat,
 	};
+
+	// Use a custom OpenCode API wrapper so per-request headers are regenerated
+	// for every LLM call instead of being frozen at registration time.
+	if (providerId && isOpenCodeProvider(providerId)) {
+		base.api = OPENCODE_DYNAMIC_API;
+	}
+
+	return base;
 }
 
 // =============================================================================
@@ -253,6 +279,7 @@ function setupStatusBar(
 function getApiKeyEnvForProvider(providerId: string): string {
 	const envMap: Record<string, string> = {
 		opencode: "OPENCODE_API_KEY",
+		"opencode-go": "OPENCODE_API_KEY",
 		openrouter: "OPENROUTER_API_KEY",
 	};
 	return envMap[providerId] || `${providerId.toUpperCase()}_API_KEY`;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-free",
-	"version": "2.0.12",
+	"version": "2.0.13",
 	"type": "module",
 	"description": "AI model providers for Pi with free model filtering and dynamic model fetching",
 	"keywords": [

package/providers/dynamic-built-in/index.ts

@@ -22,6 +22,7 @@
  * OpenAI is intentionally skipped per user request.
  */
 
+import type { Api } from "@earendil-works/pi-ai";
 import type {
 	ExtensionAPI,
 	ProviderModelConfig,
@@ -46,9 +47,18 @@ import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
 import { fetchOpenRouterCompatibleModels } from "../model-fetcher.ts";
 import { createToggleState } from "../../lib/toggle-state.ts";
 import { enhanceWithCI } from "../../provider-helper.ts";
+import {
+	OPENCODE_DYNAMIC_API,
+	createOpenCodeSessionTracker,
+	createOpenCodeStreamSimple,
+	isOpenCodeProvider,
+} from "../opencode-session.ts";
 
 const _logger = createLogger("dynamic-built-in");
 
+// OpenCode headers must be regenerated for every LLM request.
+const _opencodeSession = createOpenCodeSessionTracker();
+
 // =============================================================================
 // Generic Model Fetcher
 // =============================================================================
@@ -170,7 +180,7 @@ interface DynamicProviderDef {
 	providerId: string;
 	getApiKey: () => string | undefined;
 	baseUrl: string;
-	api: "openai-completions" | "mistral-conversations" | "anthropic-messages";
+	api: Api;
 	defaultShowPaid: boolean | (() => boolean);
 	/** Optional per-provider compat overrides (e.g., DeepSeek proxy). */
 	compat?: ProviderModelConfig["compat"];
@@ -217,10 +227,18 @@ const DYNAMIC_PROVIDERS: DynamicProviderDef[] = [
 		providerId: "opencode",
 		getApiKey: getOpencodeApiKey,
 		baseUrl: "https://opencode.ai/zen/v1",
-		api: "openai-completions",
+		api: OPENCODE_DYNAMIC_API,
 		defaultShowPaid: getOpencodeShowPaid,
 		// OpenCode API returns no pricing — _pricingKnown=false, name-based detection
 	},
+	{
+		providerId: "opencode-go",
+		getApiKey: getOpencodeApiKey,
+		baseUrl: "https://opencode.ai/zen/go/v1",
+		api: OPENCODE_DYNAMIC_API,
+		defaultShowPaid: getOpencodeShowPaid,
+		// OpenCode Go uses the same OPENCODE_API_KEY and per-request headers
+	},
 	{
 		providerId: "openrouter",
 		getApiKey: getOpenrouterApiKey,
@@ -261,9 +279,11 @@ async function discoverAndRegister(
 			});
 		}
 
-		// Apply DeepSeek proxy compat to matching models
+		// Apply DeepSeek proxy compat to matching models. OpenCode headers are
+		// injected per request by createOpenCodeStreamSimple(), not stored here.
 		allModels = allModels.map((m) => ({
 			...m,
+			api: isOpenCodeProvider(config.providerId) ? OPENCODE_DYNAMIC_API : m.api,
 			compat: getProxyModelCompat(m) ?? m.compat,
 		}));
 	} catch (error) {
@@ -327,6 +347,9 @@ async function registerProvider(
 			baseUrl: config.baseUrl,
 			apiKey,
 			api: config.api,
+			...(isOpenCodeProvider(config.providerId)
+				? { streamSimple: createOpenCodeStreamSimple(_opencodeSession) }
+				: {}),
 			models: enhanceWithCI(models, config.providerId),
 		});
 	};

package/providers/opencode-session.ts

@@ -1,33 +1,371 @@
-import { randomUUID } from "node:crypto";
-
-/**
- * Shared OpenCode session/request tracking.
- *
- * OpenCode endpoints appear to behave more reliably when a stable session id
- * is included across requests in the same Pi session.
- */
-export function createOpenCodeSessionTracker() {
-	let sessionId = "";
-	let requestCount = 0;
-
-	function generateId(): string {
-		return randomUUID().replaceAll("-", "");
-	}
-
-	function getSessionId(): string {
-		if (!sessionId) {
-			sessionId = generateId();
-		}
-		return sessionId;
-	}
-
-	function nextRequestId(): string {
-		requestCount++;
-		return `${getSessionId()}-${requestCount}`;
-	}
-
-	return {
-		getSessionId,
-		nextRequestId,
-	};
-}
+import { existsSync, lstatSync, readFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import type {
+	Api,
+	AssistantMessage,
+	AssistantMessageEvent,
+	AssistantMessageEventStream,
+	Context,
+	Model,
+	SimpleStreamOptions,
+} from "@earendil-works/pi-ai";
+import type { ProviderConfig } from "@earendil-works/pi-coding-agent";
+
+export const OPENCODE_DYNAMIC_API = "opencode-dynamic" as const;
+
+export const OPENCODE_STATIC_HEADERS = {
+	"User-Agent": "opencode/1.15.5",
+	"x-opencode-client": "cli",
+} as const;
+
+/**
+ * OpenCode-native identifier generation.
+ *
+ * OpenCode's server uses checkHeaders to distinguish native CLI requests from
+ * third-party clients.  Native identifiers use ULID-style prefixes:
+ *
+ *   Session:  ses_<hex><base62>   (e.g. ses_a1b2c3d4e5f6g7h8i9j0k1l2m3n4)
+ *   Request:  msg_<hex><base62>   (e.g. msg_01KA1B2C3D4E5F6G7H8I9J0K1L2M)
+ *
+ * If the server does not see the expected prefix it applies a fallback rate
+ * limit (~2 req/day) which causes models to "freeze" after a few prompts.
+ */
+function generateOpenCodeId(prefix: string): string {
+	// Timestamp in ms as big-endian hex (matches ULID-style sortability).
+	const ms = BigInt(Date.now());
+	const timeHex = ms.toString(16).padStart(12, "0");
+	// Random suffix (crypto) encoded as base62 for compactness.
+	const randomLen = 14;
+	const base62Chars =
+		"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+	const bytes = randomBytes(randomLen);
+	let suffix = "";
+	for (let i = 0; i < randomLen; i++) {
+		suffix += base62Chars[bytes[i] % 62];
+	}
+	return `${prefix}${timeHex}${suffix}`;
+}
+
+/**
+ * Shared OpenCode session/request tracking.
+ *
+ * OpenCode endpoints require native-format identifiers (ses_ / msg_ prefix)
+ * to receive the full daily rate limit.  Without matching prefixes the server
+ * falls back to a ~2 req/day limit, causing free models to freeze after a
+ * couple of prompts.
+ */
+export function createOpenCodeSessionTracker() {
+	let sessionId = "";
+
+	function getSessionId(): string {
+		if (!sessionId) {
+			sessionId = generateOpenCodeId("ses_");
+		}
+		return sessionId;
+	}
+
+	function nextRequestId(): string {
+		return generateOpenCodeId("msg_");
+	}
+
+	return {
+		getSessionId,
+		nextRequestId,
+	};
+}
+
+export type OpenCodeSessionTracker = ReturnType<
+	typeof createOpenCodeSessionTracker
+>;
+
+export function createOpenCodeHeaders(
+	tracker: OpenCodeSessionTracker,
+	existingHeaders?: Record<string, string>,
+): Record<string, string> {
+	return {
+		...existingHeaders,
+		...OPENCODE_STATIC_HEADERS,
+		"x-opencode-session": tracker.getSessionId(),
+		"x-opencode-request": tracker.nextRequestId(),
+	};
+}
+
+export function isOpenCodeProvider(providerId: string): boolean {
+	return providerId === "opencode" || providerId === "opencode-go";
+}
+
+function stripTrailingSlashes(value: string): string {
+	let end = value.length;
+	while (end > 0 && value.codePointAt(end - 1) === 47) {
+		end--;
+	}
+	return value.slice(0, end);
+}
+
+function isAnthropicOpenCodeEndpoint(model: Model<Api>): boolean {
+	return !stripTrailingSlashes(model.baseUrl).endsWith("/v1");
+}
+
+type StreamSimpleFn<TApi extends Api> = (
+	model: Model<TApi>,
+	context: Context,
+	options?: SimpleStreamOptions,
+) => AssistantMessageEventStream;
+
+type AnthropicStreamModule = {
+	streamSimpleAnthropic: StreamSimpleFn<"anthropic-messages">;
+};
+
+type OpenAICompletionsStreamModule = {
+	streamSimpleOpenAICompletions: StreamSimpleFn<"openai-completions">;
+};
+
+const piAiSubpathCache = new Map<string, Promise<unknown>>();
+
+async function importPiAiSubpath<T>(subpath: string): Promise<T> {
+	const specifier = `@earendil-works/pi-ai/${subpath}`;
+	const cached = piAiSubpathCache.get(specifier) as Promise<T> | undefined;
+	if (cached) return cached;
+
+	const promise = importPiAiSubpathUncached<T>(specifier);
+	piAiSubpathCache.set(specifier, promise);
+	return promise;
+}
+
+async function importPiAiSubpathUncached<T>(specifier: string): Promise<T> {
+	try {
+		return (await import(specifier)) as T;
+	} catch (directError) {
+		const resolved = resolvePiAiSubpathFromPackage(specifier);
+		if (!resolved) throw directError;
+		try {
+			return (await import(pathToFileURL(resolved).href)) as T;
+		} catch {
+			throw directError;
+		}
+	}
+}
+
+const PI_AI_DEPENDENCY_CANARY = "openai";
+
+function findPiAiPackageDir(requireBase: string): string | undefined {
+	try {
+		const require = createRequire(requireBase);
+		const resolved = require.resolve(PI_AI_DEPENDENCY_CANARY);
+		let dir = dirname(resolved);
+		while (dir !== dirname(dir)) {
+			if (basename(dir) === "node_modules") {
+				const piAiDir = join(dir, "@earendil-works", "pi-ai");
+				const pkgJsonPath = join(piAiDir, "package.json");
+				if (existsSync(pkgJsonPath) && lstatSync(pkgJsonPath).isFile()) {
+					return piAiDir;
+				}
+			}
+			dir = dirname(dir);
+		}
+	} catch {
+		// Resolution failed — try the next base.
+	}
+	return undefined;
+}
+
+function resolvePiAiSubpathFromPackage(specifier: string): string | undefined {
+	const subpath = specifier.replace("@earendil-works/pi-ai/", "");
+	const candidates = [process.argv[1], import.meta.url].filter(
+		(value): value is string => Boolean(value),
+	);
+
+	for (const candidate of candidates) {
+		const pkgDir = findPiAiPackageDir(candidate);
+		if (!pkgDir) continue;
+		try {
+			const pkg = JSON.parse(
+				readFileSync(join(pkgDir, "package.json"), "utf-8"),
+			);
+			const exportEntry = pkg.exports?.[`./${subpath}`];
+			const targetPath = exportEntry?.import ?? exportEntry?.default;
+			if (typeof targetPath === "string") {
+				return join(pkgDir, targetPath);
+			}
+		} catch {
+			// Try the next resolution base.
+		}
+	}
+
+	return undefined;
+}
+
+class DeferredAssistantMessageEventStream {
+	private queue: AssistantMessageEvent[] = [];
+	private waiting: Array<
+		(result: IteratorResult<AssistantMessageEvent>) => void
+	> = [];
+	private done = false;
+	private resolveResult!: (message: AssistantMessage) => void;
+	private readonly finalResultPromise: Promise<AssistantMessage>;
+
+	constructor() {
+		this.finalResultPromise = new Promise((resolve) => {
+			this.resolveResult = resolve;
+		});
+	}
+
+	push(event: AssistantMessageEvent): void {
+		if (this.done) return;
+
+		if (event.type === "done" || event.type === "error") {
+			this.done = true;
+			this.resolveResult(event.type === "done" ? event.message : event.error);
+		}
+
+		const waiter = this.waiting.shift();
+		if (waiter) {
+			waiter({ value: event, done: false });
+		} else {
+			this.queue.push(event);
+		}
+	}
+
+	end(result?: AssistantMessage): void {
+		if (this.done) return;
+		this.done = true;
+		if (result) this.resolveResult(result);
+		while (this.waiting.length > 0) {
+			this.waiting.shift()?.({ value: undefined, done: true });
+		}
+	}
+
+	async *[Symbol.asyncIterator](): AsyncIterator<AssistantMessageEvent> {
+		while (true) {
+			if (this.queue.length > 0) {
+				yield this.queue.shift()!;
+			} else if (this.done) {
+				return;
+			} else {
+				const result = await new Promise<IteratorResult<AssistantMessageEvent>>(
+					(resolve) => this.waiting.push(resolve),
+				);
+				if (result.done) return;
+				yield result.value;
+			}
+		}
+	}
+
+	result(): Promise<AssistantMessage> {
+		return this.finalResultPromise;
+	}
+}
+
+function createErrorMessage(
+	model: Model<Api>,
+	error: unknown,
+): AssistantMessage {
+	const message = error instanceof Error ? error.message : String(error);
+	return {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				total: 0,
+			},
+		},
+		stopReason: "error",
+		errorMessage: message,
+		timestamp: Date.now(),
+	};
+}
+
+async function pipeStream(
+	stream: DeferredAssistantMessageEventStream,
+	upstream: AssistantMessageEventStream,
+): Promise<void> {
+	let finalMessage: AssistantMessage | undefined;
+	try {
+		for await (const event of upstream) {
+			stream.push(event);
+			if (event.type === "done") finalMessage = event.message;
+			if (event.type === "error") finalMessage = event.error;
+		}
+		stream.end(finalMessage ?? (await upstream.result()));
+	} catch (error) {
+		if (finalMessage) {
+			stream.end(finalMessage);
+		} else {
+			throw error;
+		}
+	}
+}
+
+/**
+ * Pi's static model headers are evaluated at registration time. OpenCode treats
+ * x-opencode-request like a per-request id, so reusing one value across turns can
+ * leave later requests attached to an old/in-flight generation. Registering a
+ * provider-specific stream keeps the normal Pi parsers but refreshes headers for
+ * every LLM call.
+ */
+export function createOpenCodeStreamSimple(
+	tracker: OpenCodeSessionTracker,
+): NonNullable<ProviderConfig["streamSimple"]> {
+	return (model, context, options) => {
+		const headers = createOpenCodeHeaders(tracker, options?.headers);
+		const stream = new DeferredAssistantMessageEventStream();
+
+		void (async () => {
+			try {
+				if (isAnthropicOpenCodeEndpoint(model)) {
+					const { streamSimpleAnthropic } =
+						await importPiAiSubpath<AnthropicStreamModule>("anthropic");
+					await pipeStream(
+						stream,
+						streamSimpleAnthropic(
+							{
+								...model,
+								api: "anthropic-messages",
+							} as Model<"anthropic-messages">,
+							context,
+							{ ...options, headers },
+						),
+					);
+					return;
+				}
+
+				const { streamSimpleOpenAICompletions } =
+					await importPiAiSubpath<OpenAICompletionsStreamModule>(
+						"openai-completions",
+					);
+				await pipeStream(
+					stream,
+					streamSimpleOpenAICompletions(
+						{
+							...model,
+							api: "openai-completions",
+						} as Model<"openai-completions">,
+						context,
+						{ ...options, headers },
+					),
+				);
+			} catch (error) {
+				const errorMessage = createErrorMessage(model, error);
+				stream.push({ type: "start", partial: errorMessage });
+				stream.push({ type: "error", reason: "error", error: errorMessage });
+			}
+		})();
+
+		return stream as unknown as AssistantMessageEventStream;
+	};
+}