pi-multikey 1.13.0 → 1.14.0

package/config.ts

@@ -360,8 +360,8 @@ function normalizePool(pool: PoolConfig): PoolConfig {
 }
 
 /** Convert a pool config into pi ProviderModelConfig-style definitions (provider-level compat merged in). */
-export function toProviderModels(pool: PoolConfig): ProviderModelConfig[] {
-	return pool.models.map(
+export function toProviderModels(pool: PoolConfig, models?: PoolModelConfig[]): ProviderModelConfig[] {
+	return (models ?? pool.models).map(
 		(m): ProviderModelConfig => ({
 			id: m.id,
 			name: m.name ?? m.id,

package/index.ts

@@ -11,7 +11,7 @@
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { getApiProvider, type Api } from "@earendil-works/pi-ai";
-import { configPath, endpointHeaders, loadConfig, saveConfig, toProviderModels, type KeypoolConfig, type PoolConfig } from "./config.ts";
+import { configPath, endpointHeaders, loadConfig, saveConfig, toProviderModels, type KeypoolConfig, type PoolConfig, type PoolModelConfig } from "./config.ts";
 import { resetConversation } from "./identity.ts";
 import { KeyPool } from "./pool.ts";
 import { createRotatingStreamSimple } from "./stream.ts";
@@ -36,6 +36,8 @@ export default function multikey(pi: ExtensionAPI) {
 
 	const pools = new Map<string, KeyPool>();
 	for (const pool of config.pools) pools.set(pool.id, new KeyPool(pool));
+	/** pi provider ids registered per pool (pool.id plus one suffixed id per extra transport). */
+	const providerIds = new Map<string, string[]>();
 
 	let ui: ExtensionContext["ui"] | undefined;
 	const notify = (message: string) => {
@@ -47,33 +49,68 @@ export default function multikey(pi: ExtensionAPI) {
 	};
 
 	/**
-	 * Register a pool as a pi provider. Returns undefined on success, or a
+	 * Register a pool as pi provider(s). Returns undefined on success, or a
 	 * human-readable reason why the pool was skipped (unknown api, incomplete).
+	 *
+	 * One pi provider per transport: pi dispatches to a provider's custom
+	 * streamSimple only when model.api matches the registered api
+	 * (provider-composer.js), so models on another transport would bypass key
+	 * rotation and per-request identity headers entirely — on OpenCode Zen
+	 * that draws 403 FreeTierError (verified live 2026-09-21: muse-spark went
+	 * out with the dummy key and a uuid session). Extra transports register
+	 * under "<pool.id>.<api>" sharing the same KeyPool, so keys are entered
+	 * once and rotation/cooldowns span both providers.
 	 */
 	function registerPool(pool: PoolConfig): string | undefined {
 		if (pool.keys.length === 0 || pool.models.length === 0) {
 			return pool.keys.length === 0 ? "no API keys" : "no models";
 		}
-		const api = pool.api ?? "openai-completions";
-		if (!getApiProvider(api as Api)) {
-			// Never throw at startup over a bad api value; report it instead so
-			// the user gets a fix hint (and /multikey marks the pool broken).
-			return `unknown api type "${api}" (edit the pool and pick a valid API type)`;
+		const defaultApi = pool.api ?? "openai-completions";
+		const groups = new Map<string, PoolModelConfig[]>();
+		for (const m of pool.models) {
+			const api = m.api ?? defaultApi;
+			const list = groups.get(api);
+			if (list) list.push(m);
+			else groups.set(api, [m]);
+		}
+		for (const api of groups.keys()) {
+			if (!getApiProvider(api as Api)) {
+				// Never throw at startup over a bad api value; report it instead so
+				// the user gets a fix hint (and /multikey marks the pool broken).
+				return `unknown api type "${api}" (edit the pool and pick a valid API type)`;
+			}
 		}
 		const keyPool = pools.get(pool.id) ?? new KeyPool(pool);
 		keyPool.updateConfig(pool);
 		pools.set(pool.id, keyPool);
 
-		pi.registerProvider(pool.id, {
-			name: pool.name ?? pool.id,
-			baseUrl: pool.baseUrl,
-			// Real keys are injected per-request by the rotating stream function.
-			apiKey: "multikey-managed",
-			api,
-			headers: { ...pool.headers, ...endpointHeaders(pool.baseUrl) },
-			models: toProviderModels(pool),
-			streamSimple: createRotatingStreamSimple(keyPool, api, notify, () => saveConfig(config)),
-		});
+		const wanted: string[] = [];
+		for (const [api, models] of groups) {
+			const providerId = api === defaultApi ? pool.id : `${pool.id}.${api}`;
+			wanted.push(providerId);
+			pi.registerProvider(providerId, {
+				name: api === defaultApi ? (pool.name ?? pool.id) : `${pool.name ?? pool.id} (${api})`,
+				baseUrl: pool.baseUrl,
+				// Real keys are injected per-request by the rotating stream function.
+				apiKey: "multikey-managed",
+				api,
+				headers: { ...pool.headers, ...endpointHeaders(pool.baseUrl) },
+				models: toProviderModels(pool, models),
+				streamSimple: createRotatingStreamSimple(keyPool, api, notify, () => saveConfig(config)),
+			});
+		}
+		// Drop split providers left over from a previous registration whose
+		// models have since moved transports (or back to a single provider).
+		for (const stale of providerIds.get(pool.id) ?? []) {
+			if (!wanted.includes(stale)) {
+				try {
+					pi.unregisterProvider(stale);
+				} catch {
+					// Already gone.
+				}
+			}
+		}
+		providerIds.set(pool.id, wanted);
 		return undefined;
 	}
 
@@ -98,11 +135,14 @@ export default function multikey(pi: ExtensionAPI) {
 		config.pools = config.pools.filter((p) => p.id !== poolId);
 		pools.delete(poolId);
 		saveConfig(config);
-		try {
-			pi.unregisterProvider(poolId);
-		} catch {
-			// Not registered yet.
+		for (const providerId of [poolId, ...(providerIds.get(poolId) ?? [])]) {
+			try {
+				pi.unregisterProvider(providerId);
+			} catch {
+				// Not registered yet.
+			}
 		}
+		providerIds.delete(poolId);
 	}
 
 	function reloadFromDisk() {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-multikey",
-	"version": "1.13.0",
+	"version": "1.14.0",
 	"description": "One pi provider backed by many API keys: automatic 429 rotation, per-request key leases for concurrent subagents, and a /multikey management TUI",
 	"keywords": [
 		"pi-package",

package/presets.ts

@@ -133,7 +133,7 @@ export const PRESETS: Preset[] = [
 	{
 		id: "opencode-zen",
 		name: "OpenCode Zen",
-		description: "opencode.ai/zen free tier — Big Pickle, MiMo V2.5, Ling 3.0 Fin, Nemotron 3 Ultra/Lightning, Muse Spark 1.3 (6 free models)",
+		description: "opencode.ai/zen free tier — Big Pickle, MiMo V2.6 Flash, MiMo V2.5, Ling 3.0 Fin, Nemotron 3 Ultra/Lightning, Muse Spark 1.3 (7 free models)",
 		defaultPoolId: "zen",
 		// Inference gateway, not zen/v1: the v2 client's console /api/v2/config
 		// prescribes this as the opencode provider baseURL, and the free lineup
@@ -155,10 +155,39 @@ export const PRESETS: Preset[] = [
 				maxTokens: 32_000,
 				compat: ZEN_CHAT_COMPAT,
 			},
+			{
+				// Xiaomi MiMo-V2.6-Flash, released to the Zen free tier 2026-09-22 and
+				// the successor of mimo-v2.5-free (docs opencode.ai/docs/zen lists both,
+				// in that order). Limits are authoritative from console /api/v2/config
+				// `providers.opencode.models` and mirrored exactly by models.dev:
+				// ctx 200,000 / out 32,000, tools on, cost 0. Upstream inputs
+				// text/image/audio/video/pdf (pi tracks text + image, like mimo-v2.5).
+				// Reasoning is always-on with no effort control: models.dev reports
+				// `reasoning: true`, `reasoning_options: []`, `interleaved.field =
+				// reasoning_content`; verified live 2026-09-22 that reasoning_content
+				// streams separately and usage reports reasoning_tokens — so, like the
+				// rest of the free lineup, no thinkingLevelMap.
+				// Verified live 2026-09-22 (agentic probe shape, see probe.ts): streaming
+				// chat with the read/shell/edit/write quartet → 200, content "PONG",
+				// finish stop, usage {prompt 191, completion 13, reasoning 9}; the same
+				// request without tools/stream → 403 FreeTierError, confirming the gate
+				// still applies to this model id.
+				id: "mimo-v2.6-flash-free",
+				name: "MiMo V2.6 Flash Free",
+				reasoning: true,
+				input: ["text", "image"],
+				contextWindow: 200_000,
+				maxTokens: 127_000,
+				compat: ZEN_CHAT_COMPAT,
+			},
 			{
 				// Xiaomi MiMo V2.5 omni; raw model is 1M ctx but the Zen FREE tier serves 200K/32K.
 				// Repo metadata: inputs text/image/audio/video (pi tracks text + image),
 				// reasoning via separate reasoning_content stream, no reasoning_options.
+				// Still listed in opencode.ai/docs/zen's free lineup and still answers 200
+				// (verified live 2026-09-22), but it disappeared from the console
+				// /api/v2/config model map that day when mimo-v2.6-flash-free landed —
+				// kept because it demonstrably works; drop it when it 404s.
 				id: "mimo-v2.5-free",
 				name: "MiMo V2.5 Free",
 				reasoning: true,

package/stream.ts

@@ -54,8 +54,8 @@ interface CapturedResponse {
 export type Notifier = (message: string) => void;
 
 export function createRotatingStreamSimple(pool: KeyPool, apiName: string, notify: Notifier, onConfigDirty?: () => void) {
-	const impl = getApiProvider(apiName as Api);
-	if (!impl) throw new Error(`multikey: no API provider registered for api: ${apiName}`);
+	const fallback = getApiProvider(apiName as Api);
+	if (!fallback) throw new Error(`multikey: no API provider registered for api: ${apiName}`);
 	// Auth style: "api-key" providers want the key in x-api-key (some reject
 	// Authorization entirely); bearer is the pi-ai default and needs no help.
 	const authStyle = pool.config.auth ?? "bearer";
@@ -108,6 +108,15 @@ export function createRotatingStreamSimple(pool: KeyPool, apiName: string, notif
 
 				try {
 					const captured: CapturedResponse = { status: 0 };
+					// Transport follows the MODEL, not the pool: pi dispatches to a
+					// provider's custom streamSimple only when model.api matches the
+					// registered api (provider-composer.js), so a pool mixing
+					// transports (e.g. oc.zen's openai-responses muse-spark entry)
+					// must resolve the impl per request. Anything without a match
+					// falls back to the pool-level api. Verified live 2026-09-21:
+					// without this, muse-spark bypassed rotation (dummy key, no
+					// ses_/msg_ identity headers) and drew 403 FreeTierError.
+					const impl = getApiProvider(model.api) ?? fallback;
 					// Identity headers (session / request) are per-request, so they are
 					// merged here rather than baked into the provider registration.
 					// Providers apply options.headers last, so these win over the static