pi-free 2.0.11 → 2.0.13

package/providers/novita/novita.ts

@@ -0,0 +1,205 @@
+/**
+ * Novita AI Provider Extension
+ *
+ * Novita AI deploys 100+ open-source models with an OpenAI-compatible API.
+ * Known for competitive pricing, globally distributed GPU infrastructure,
+ * and support for chat, vision, and Anthropic-compatible endpoints.
+ *
+ * API: https://api.novita.ai/openai/v1
+ * Models: /v1/models returns non-standard pricing fields (input_token_price_per_m,
+ * output_token_price_per_m) plus rich metadata (context_size, max_output_tokens,
+ * features for reasoning, input_modalities for vision).
+ *
+ * Setup:
+ *   1. Sign up at https://novita.ai
+ *   2. Get API key from dashboard
+ *   3. Set NOVITA_API_KEY env var or add to ~/.pi/free.json
+ *
+ * Usage:
+ *   pi install git:github.com/apmantza/pi-free
+ *   # Set NOVITA_API_KEY env var
+ *   # Models appear in /model selector
+ */
+
+import type {
+	ExtensionAPI,
+	ProviderModelConfig,
+} from "@earendil-works/pi-coding-agent";
+import { getNovitaApiKey, getNovitaShowPaid } from "../../config.ts";
+import {
+	BASE_URL_NOVITA,
+	DEFAULT_FETCH_TIMEOUT_MS,
+	PROVIDER_NOVITA,
+} from "../../constants.ts";
+import { createLogger } from "../../lib/logger.ts";
+import {
+	getProxyModelCompat,
+	isLikelyReasoningModel,
+} from "../../lib/provider-compat.ts";
+import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
+import { fetchWithRetry } from "../../lib/util.ts";
+import { createReRegister, setupProvider } from "../../provider-helper.ts";
+
+const _logger = createLogger("novita");
+
+// =============================================================================
+// Types
+// =============================================================================
+
+interface NovitaModel {
+	id: string;
+	display_name?: string;
+	description?: string;
+	input_token_price_per_m?: number;
+	output_token_price_per_m?: number;
+	context_size?: number;
+	max_output_tokens?: number;
+	features?: string[];
+	input_modalities?: string[];
+	output_modalities?: string[];
+	model_type?: string;
+	endpoints?: string[];
+	status?: number;
+}
+
+// =============================================================================
+// Fetch
+// =============================================================================
+
+async function fetchNovitaModels(
+	apiKey: string,
+): Promise<ProviderModelConfig[]> {
+	_logger.info("[novita] Fetching models from Novita API...");
+
+	try {
+		const response = await fetchWithRetry(
+			`${BASE_URL_NOVITA}/models`,
+			{
+				headers: {
+					Authorization: `Bearer ${apiKey}`,
+					"Content-Type": "application/json",
+				},
+			},
+			3,
+			1000,
+			DEFAULT_FETCH_TIMEOUT_MS,
+		);
+
+		if (!response.ok) {
+			throw new Error(`Novita API error: ${response.status}`);
+		}
+
+		const json = (await response.json()) as { data?: NovitaModel[] };
+		const models = (json.data ?? []).filter(
+			(m) => m.status === 1 && m.model_type === "chat",
+		);
+
+		_logger.info(`[novita] Fetched ${models.length} models`);
+
+		return models.map((m): ProviderModelConfig => {
+			const name = m.display_name || m.id.split("/").pop() || m.id;
+			const reasoning =
+				(m.features ?? []).includes("reasoning") ||
+				isLikelyReasoningModel({ id: m.id, name });
+			const hasVision = m.input_modalities?.includes("image") ?? false;
+
+			// Novita pricing is per-MILLION tokens. Divide for per-token (Pi convention).
+			const inputCost = (m.input_token_price_per_m ?? 0) / 1_000_000;
+			const outputCost = (m.output_token_price_per_m ?? 0) / 1_000_000;
+			const hasPricing =
+				m.input_token_price_per_m !== undefined ||
+				m.output_token_price_per_m !== undefined;
+
+			return {
+				id: m.id,
+				name,
+				reasoning,
+				input: hasVision ? ["text", "image"] : ["text"],
+				cost: {
+					input: inputCost,
+					output: outputCost,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				contextWindow: m.context_size ?? 128_000,
+				maxTokens: m.max_output_tokens ?? 16_384,
+				compat: getProxyModelCompat({ id: m.id, name }),
+				_pricingKnown: hasPricing,
+			} as ProviderModelConfig & { _pricingKnown?: boolean };
+		});
+	} catch (error) {
+		_logger.error("[novita] Failed to fetch models:", {
+			error: error instanceof Error ? error.message : String(error),
+		});
+		return [];
+	}
+}
+
+// =============================================================================
+// Extension Entry Point
+// =============================================================================
+
+export default async function novitaProvider(pi: ExtensionAPI) {
+	const apiKey = getNovitaApiKey();
+
+	if (!apiKey) {
+		_logger.info(
+			"[novita] Skipping — NOVITA_API_KEY not set. Sign up at https://novita.ai/",
+		);
+		return;
+	}
+
+	// Fetch models
+	const allModels = await fetchNovitaModels(apiKey);
+
+	if (allModels.length === 0) {
+		_logger.warn("[novita] No chat models available");
+		return;
+	}
+
+	// Use isFreeModel with allModels for proper detection
+	// Novita returns pricing for all models → _pricingKnown=true → Route A OR logic
+	const freeModels = allModels.filter((m) =>
+		isFreeModel({ ...m, provider: PROVIDER_NOVITA }, allModels),
+	);
+
+	const stored = { free: freeModels, all: allModels };
+
+	_logger.info(
+		`[novita] Registered ${allModels.length} models (${freeModels.length} free)`,
+	);
+
+	// Create re-register function
+	const reRegister = createReRegister(pi, {
+		providerId: PROVIDER_NOVITA,
+		baseUrl: BASE_URL_NOVITA,
+		apiKey,
+	});
+
+	// Register with global toggle
+	registerWithGlobalToggle(PROVIDER_NOVITA, stored, reRegister, true);
+
+	// Setup provider with toggle command
+	setupProvider(
+		pi,
+		{
+			providerId: PROVIDER_NOVITA,
+			initialShowPaid: getNovitaShowPaid(),
+			tosUrl: "https://novita.ai/terms",
+			reRegister: (models, _stored) => {
+				if (_stored) {
+					stored.free = _stored.free;
+					stored.all = _stored.all;
+				}
+				reRegister(models);
+			},
+		},
+		stored,
+	);
+
+	// Initial registration — respect persisted toggle state
+	const showPaid = getNovitaShowPaid();
+	const initialModels =
+		showPaid && stored.all.length > 0 ? stored.all : freeModels;
+	reRegister(initialModels);
+}

package/providers/nvidia/nvidia.ts

@@ -31,7 +31,7 @@ import {
 	URL_MODELS_DEV,
 } from "../../constants.ts";
 import { createLogger } from "../../lib/logger.ts";
-import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
+import { registerWithGlobalToggle } from "../../lib/registry.ts";
 import type { ModelsDevModel, ModelsDevProvider } from "../../lib/types.ts";
 import {
 	fetchWithRetry,
@@ -382,11 +382,9 @@ export default async function nvidiaProvider(pi: ExtensionAPI) {
 		return;
 	}
 
-	// Store both sets for global toggle using consistent isFreeModel helper
-	// NVIDIA uses Route B (name-based): only models with "free" in name are marked free
-	const freeModels = allModels.filter((m) =>
-		isFreeModel({ ...m, provider: PROVIDER_NVIDIA }),
-	);
+	// All NVIDIA NIM models are accessible via free credits (no payment method required).
+	// Same approach as Codestral/Ollama: all models shown as free-tier.
+	const freeModels = allModels;
 	const stored = { free: freeModels, all: allModels };
 
 	// Create re-register function

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;
+	};
+}

package/providers/sambanova/sambanova.ts

@@ -31,7 +31,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { getSambanovaApiKey, getSambanovaShowPaid } from "../../config.ts";
 import { BASE_URL_SAMBANOVA, PROVIDER_SAMBANOVA } from "../../constants.ts";
 import { createLogger } from "../../lib/logger.ts";
-import { registerWithGlobalToggle } from "../../lib/registry.ts";
+import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
 import { fetchOpenAICompatibleModels } from "../../lib/util.ts";
 import { createReRegister, setupProvider } from "../../provider-helper.ts";
 
@@ -66,7 +66,13 @@ export default async function sambanovaProvider(pi: ExtensionAPI) {
 
 	// All SambaNova models are free-tier (no payment method required).
 	// Rate limits are lower on free tier but all models are accessible.
-	const freeModels = allModels;
+	// Override _pricingKnown so isFreeModel trusts the zero costs.
+	for (const m of allModels) {
+		(m as unknown as { _pricingKnown?: boolean })._pricingKnown = true;
+	}
+	const freeModels = allModels.filter((m) =>
+		isFreeModel({ ...m, provider: PROVIDER_SAMBANOVA }, allModels),
+	);
 	const stored = { free: freeModels, all: allModels };
 
 	_logger.info(

package/providers/together/together.ts

@@ -45,7 +45,7 @@ import {
 	getProxyModelCompat,
 	isLikelyReasoningModel,
 } from "../../lib/provider-compat.ts";
-import { registerWithGlobalToggle } from "../../lib/registry.ts";
+import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
 import { fetchWithRetry } from "../../lib/util.ts";
 import { createReRegister, setupProvider } from "../../provider-helper.ts";
 
@@ -123,7 +123,8 @@ async function fetchTogetherModels(
 				contextWindow: m.context_length ?? 128_000,
 				maxTokens: 16_384,
 				compat: getProxyModelCompat({ id: m.id, name }),
-			};
+				_pricingKnown: m.pricing !== undefined,
+			} as ProviderModelConfig & { _pricingKnown?: boolean };
 		});
 }
 
@@ -150,13 +151,9 @@ export default async function togetherProvider(pi: ExtensionAPI) {
 	}
 
 	// Together AI is a pay-per-token provider with $1 trial credit.
-	// Zero-cost models (if any) are marked free; all others are paid.
-	const freeModels = allModels.filter(
-		(m) =>
-			m.cost.input === 0 &&
-			m.cost.output === 0 &&
-			m.cost.cacheRead === 0 &&
-			m.cost.cacheWrite === 0,
+	// Use isFreeModel for consistent detection across all providers.
+	const freeModels = allModels.filter((m) =>
+		isFreeModel({ ...m, provider: PROVIDER_TOGETHER }, allModels),
 	);
 	const stored = { free: freeModels, all: allModels };