pi-freeflow 1.2.0 → 1.2.1

package/src/models.ts

@@ -0,0 +1,343 @@
+/**
+ * Static model definitions and upstream routing catalogs for pi-freeflow
+ *
+ * Defines the 23 verified free models:
+ * - 9 OpenCode Zen models (2 Responses API + 7 Chat Completions)
+ * - 14 KiloCode Keyless Gateway models (11 OpenRouter format + 3 Standard format)
+ */
+
+import type { ModelDef, Upstream } from "./types.ts";
+
+/**
+ * OpenCode Zen free models verified against the live catalog and inference APIs.
+ * Endpoint: https://opencode.ai/zen/v1
+ */
+export const OPENCODE_MODELS: ModelDef[] = [
+	{
+		id: "deepseek-v4-flash-free",
+		name: "DeepSeek V4 Flash (1M)",
+		reasoning: true,
+		contextWindow: 1_000_000,
+		maxTokens: 384_000,
+		input: ["text"],
+		thinkingLevelMap: {
+			off: "low",
+			minimal: "low",
+			low: "low",
+			medium: "high",
+			high: "high",
+			xhigh: "max",
+			max: "max",
+		},
+	},
+	{
+		id: "x-preview-f-free",
+		name: "Ox Alpha (1M)",
+		reasoning: true,
+		contextWindow: 1_048_576,
+		maxTokens: 131_072,
+		input: ["text", "image"],
+		thinkingLevelMap: {
+			off: "low",
+			minimal: "low",
+			low: "low",
+			medium: "high",
+			high: "high",
+			xhigh: "max",
+			max: "max",
+		},
+	},
+	{
+		id: "muse-spark-1.2-contributor-free",
+		name: "Muse Spark 1.2 (1M)",
+		reasoning: true,
+		contextWindow: 1_048_576,
+		maxTokens: 131_072,
+		api: "openai-responses",
+		input: ["text", "image"],
+		thinkingLevelMap: {
+			off: null,
+			minimal: "minimal",
+			low: "low",
+			medium: "medium",
+			high: "high",
+			xhigh: "xhigh",
+			max: "max",
+		},
+	},
+	{
+		id: "mimo-v2.5-free",
+		name: "MiMo V2.5 (1M)",
+		reasoning: true,
+		contextWindow: 1_048_576,
+		maxTokens: 131_072,
+		input: ["text", "image"],
+		thinkingLevelMap: {
+			off: "low",
+			minimal: "low",
+			low: "low",
+			medium: "medium",
+			high: "high",
+			xhigh: "high",
+			max: "high",
+		},
+	},
+	{
+		id: "hy3-free",
+		name: "Hy3 (262K)",
+		reasoning: true,
+		contextWindow: 262_144,
+		maxTokens: 128_000,
+		input: ["text"],
+		thinkingLevelMap: {
+			off: "low",
+			minimal: "low",
+			low: "low",
+			medium: "high",
+			high: "high",
+			xhigh: "max",
+			max: "max",
+		},
+	},
+	{
+		id: "nemotron-3-ultra-free",
+		name: "Nemotron 3 Ultra (1M)",
+		reasoning: true,
+		contextWindow: 1_000_000,
+		maxTokens: 128_000,
+		input: ["text"],
+		thinkingLevelMap: {
+			off: "low",
+			minimal: "low",
+			low: "low",
+			medium: "high",
+			high: "high",
+			xhigh: "max",
+			max: "max",
+		},
+	},
+	{
+		id: "nemotron-3.5-lightning-free",
+		name: "Nemotron 3.5 Lightning (1M)",
+		reasoning: true,
+		contextWindow: 1_000_000,
+		maxTokens: 262_144,
+		input: ["text"],
+		thinkingLevelMap: {
+			off: "low",
+			minimal: "low",
+			low: "low",
+			medium: "high",
+			high: "high",
+			xhigh: "max",
+			max: "max",
+		},
+	},
+	{
+		id: "big-pickle",
+		name: "Big Pickle",
+		reasoning: true,
+		contextWindow: 200_000,
+		maxTokens: 32_000,
+		input: ["text"],
+		thinkingLevelMap: {
+			off: "high",
+			minimal: "high",
+			low: "high",
+			medium: "high",
+			high: "high",
+			xhigh: "max",
+			max: "max",
+		},
+	},
+	{
+		id: "laguna-s-2.1-free",
+		name: "Laguna S 2.1 (1M)",
+		reasoning: true,
+		contextWindow: 1_048_576,
+		maxTokens: 131_072,
+		input: ["text"],
+		thinkingLevelMap: {
+			off: "low",
+			minimal: "low",
+			low: "low",
+			medium: "high",
+			high: "high",
+			xhigh: "max",
+			max: "max",
+		},
+	},
+];
+
+/**
+ * Backward compatibility alias for OPENCODE_MODELS
+ */
+export const KNOWN_MODELS = OPENCODE_MODELS;
+
+/**
+ * KiloCode Gateway free models (keyless — https://kilo.ai/docs/gateway).
+ * Endpoint: https://api.kilo.ai/api/gateway/chat/completions
+ */
+export const KILO_MODELS: ModelDef[] = [
+	{
+		id: "dots-studio/dots-3-note-preview:free",
+		name: "Dots3-Note Preview (512K)",
+		reasoning: true,
+		contextWindow: 512_000,
+		maxTokens: 512_000,
+		input: ["text", "image"],
+		thinkingFormat: "openrouter",
+	},
+	{
+		id: "stepfun/step-3.7-flash:free",
+		name: "Step 3.7 Flash",
+		reasoning: true,
+		contextWindow: 262_144,
+		maxTokens: 262_144,
+		input: ["text", "image"],
+		thinkingFormat: "openrouter",
+	},
+	{
+		id: "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free",
+		name: "Nemotron 3 Nano Omni",
+		reasoning: true,
+		contextWindow: 256_000,
+		maxTokens: 65_536,
+		input: ["text", "image"],
+		thinkingFormat: "openrouter",
+	},
+	{
+		id: "nvidia/nemotron-3-ultra-550b-a55b:free",
+		name: "Nemotron 3 Ultra 550B (1M)",
+		reasoning: true,
+		contextWindow: 1_000_000,
+		maxTokens: 65_536,
+		input: ["text"],
+		thinkingFormat: "openrouter",
+	},
+	{
+		id: "nvidia/nemotron-3.5-lightning:free",
+		name: "Nemotron 3.5 Lightning (Kilo)",
+		reasoning: true,
+		contextWindow: 1_000_000,
+		maxTokens: 65_536,
+		input: ["text"],
+		thinkingFormat: "openrouter",
+	},
+	{
+		id: "nvidia/nemotron-3-super-120b-a12b:free",
+		name: "Nemotron 3 Super 120B",
+		reasoning: true,
+		contextWindow: 262_144,
+		maxTokens: 262_144,
+		input: ["text"],
+		thinkingFormat: "openrouter",
+	},
+	{
+		id: "tencent/hy3:free",
+		name: "Tencent Hy3 (Kilo)",
+		reasoning: true,
+		contextWindow: 262_144,
+		maxTokens: 128_000,
+		input: ["text"],
+		thinkingFormat: "openrouter",
+	},
+	{
+		id: "cohere/north-mini-code:free",
+		name: "North Mini Code",
+		reasoning: true,
+		contextWindow: 256_000,
+		maxTokens: 64_000,
+		input: ["text"],
+		thinkingFormat: "openrouter",
+	},
+	{
+		id: "poolside/laguna-s-2.1:free",
+		name: "Laguna S 2.1 (Kilo)",
+		reasoning: true,
+		contextWindow: 262_144,
+		maxTokens: 32_768,
+		input: ["text"],
+		thinkingFormat: "openrouter",
+	},
+	{
+		id: "poolside/laguna-xs-2.1:free",
+		name: "Laguna XS 2.1",
+		reasoning: true,
+		contextWindow: 262_144,
+		maxTokens: 32_768,
+		input: ["text"],
+		thinkingFormat: "openrouter",
+	},
+	{
+		id: "liquid/lfm-2.5-2.6b:free",
+		name: "Liquid LFM 2.5",
+		reasoning: true,
+		contextWindow: 65_536,
+		maxTokens: 8_192,
+		input: ["text"],
+		thinkingFormat: "openrouter",
+	},
+	{
+		id: "kilo-auto/free",
+		name: "Kilo Auto",
+		reasoning: false,
+		contextWindow: 256_000,
+		maxTokens: 10_000,
+		input: ["text"],
+	},
+	{
+		id: "openrouter/free",
+		name: "OpenRouter Auto",
+		reasoning: false,
+		contextWindow: 200_000,
+		maxTokens: 65_536,
+		input: ["text"],
+	},
+	{
+		id: "nvidia/nemotron-3.5-content-safety:free",
+		name: "Nemotron Content Safety",
+		reasoning: false,
+		contextWindow: 128_000,
+		maxTokens: 8_192,
+		input: ["text"],
+	},
+];
+
+/**
+ * Set of all KiloCode model IDs for fast lookup
+ */
+export const KILO_MODEL_IDS = new Set<string>(KILO_MODELS.map((m) => m.id));
+
+/**
+ * Combined list of all 23 static free models
+ */
+export const ALL_MODELS: ModelDef[] = [...OPENCODE_MODELS, ...KILO_MODELS];
+
+/**
+ * Map of model ID -> ModelDef
+ */
+export const MODEL_MAP = new Map<string, ModelDef>(
+	ALL_MODELS.map((m) => [m.id, m]),
+);
+
+/**
+ * Lookup a model definition by ID
+ */
+export function getModelDef(id: string): ModelDef | undefined {
+	return MODEL_MAP.get(id);
+}
+
+/**
+ * Check if a model ID belongs to KiloCode Gateway
+ */
+export function isKiloModel(id: string): boolean {
+	return KILO_MODEL_IDS.has(id);
+}
+
+/**
+ * Determine the upstream provider for a given model ID
+ */
+export function getModelUpstream(id: string): Upstream {
+	return isKiloModel(id) ? "kilo" : "opencode";
+}

package/src/normalizer.ts

@@ -0,0 +1,173 @@
+/**
+ * Request payload normalization for pi-freeflow
+ *
+ * Normalizes tool choice, translates Anthropic thinking to OpenAI reasoning_effort,
+ * applies per-model thinkingLevelMap translation, and enforces token clamping.
+ */
+
+import { RELAY_MAX_TOKENS } from "./config.ts";
+import { isDebugEnabled, log } from "./logger.ts";
+import { MODEL_MAP } from "./models.ts";
+import type { ModelDef } from "./types.ts";
+
+/**
+ * Normalizes an OpenAI-compatible / Anthropic request payload before forwarding to upstream.
+ *
+ * 1. Strips empty tools and normalizes tool_choice (none -> stripped, other non-auto -> auto for OpenCode).
+ * 2. Translates Anthropic thinking ({ type: "enabled", budget_tokens }) to OpenAI reasoning_effort.
+ * 3. Applies per-model thinkingLevelMap and reasoning effort normalization.
+ * 4. Clamps token limits (min 16 for OpenCode, maxTokens from modelDef, RELAY_MAX_TOKENS for relays).
+ */
+export function normalizeRequestBody(
+	body: Record<string, unknown>,
+	isRelay = false,
+	isKilo = false,
+	reqId?: string,
+): Record<string, unknown> {
+	const DBG = isDebugEnabled();
+	const modelId = typeof body.model === "string" ? body.model : "";
+	const modelDef = MODEL_MAP.get(modelId);
+	const isResponsesApi = modelId === "muse-spark-1.2-contributor-free";
+
+	if (DBG) {
+		log(
+			"debug",
+			`normalize: incoming model=${modelId} kilo=${isKilo} relay=${isRelay}`,
+			{
+				reasoning_effort: body.reasoning_effort,
+				reasoning: body.reasoning,
+				thinking: (body as Record<string, unknown>).thinking,
+				tool_choice: body.tool_choice,
+				toolsLen: Array.isArray(body.tools) ? body.tools.length : undefined,
+			},
+			reqId,
+		);
+	}
+
+	// 1. Tool choice & empty tools normalization (pi-ai compat: opencode only supports auto)
+	if (Array.isArray(body.tools) && body.tools.length === 0) {
+		delete body.tools;
+		delete body.tool_choice;
+	}
+	if (body.tool_choice === "none") {
+		delete body.tool_choice;
+		delete body.tools;
+	} else if (!isKilo && body.tool_choice && body.tool_choice !== "auto") {
+		body.tool_choice = "auto";
+	}
+
+	// 1b. Anthropic thinking -> OpenAI reasoning_effort auto-translate
+	// Pi sends anthropic `thinking: {type:"enabled",budget_tokens}` when provider is anthropic.
+	// Our proxy is always openai-completions/responses upstream, so translate.
+	// Ref: pi-ai api/anthropic-messages.js (thinking.type adaptive/enabled/disabled) -> api/openai-completions.js (reasoning_effort)
+	const thinkingRaw = (body as Record<string, unknown>).thinking;
+	if (thinkingRaw && typeof thinkingRaw === "object") {
+		const th = thinkingRaw as Record<string, unknown>;
+		if (th.type === "disabled") {
+			delete (body as Record<string, unknown>).thinking;
+			// Mark as off so downstream reasoning mapping can clear effort
+			if (!body.reasoning_effort && !body.reasoning) {
+				body.reasoning_effort = "off";
+			}
+		} else if (th.type === "enabled" || th.type === "adaptive") {
+			delete (body as Record<string, unknown>).thinking;
+			// Preserve budget as hint if no explicit effort set
+			if (!body.reasoning_effort && typeof th.budget_tokens === "number") {
+				const budget = th.budget_tokens as number;
+				if (budget >= 8000) body.reasoning_effort = "xhigh";
+				else if (budget >= 4000) body.reasoning_effort = "high";
+				else if (budget >= 2000) body.reasoning_effort = "medium";
+				else body.reasoning_effort = "low";
+			}
+		}
+	}
+
+	// 2. Reasoning normalization — per-model thinkingLevelMap aware
+	// Ref: pi-ai api/openai-completions.js (compat.thinkingFormat branches) + api/openai-responses-shared.js
+	const mapEffort = (rawEffort: string): string | null | undefined => {
+		const key = rawEffort.toLowerCase() as keyof NonNullable<
+			ModelDef["thinkingLevelMap"]
+		>;
+		let mapped: string | null | undefined;
+		if (modelDef?.thinkingLevelMap && key in modelDef.thinkingLevelMap) {
+			mapped = modelDef.thinkingLevelMap[key] as string | null;
+		} else if (rawEffort === "xhigh" || rawEffort === "max") {
+			mapped = isResponsesApi
+				? "xhigh"
+				: modelId === "x-preview-f-free"
+					? "max"
+					: "xhigh";
+		} else if (rawEffort === "high" || rawEffort === "medium") {
+			mapped = "high";
+		} else if (rawEffort === "minimal") {
+			mapped = "minimal";
+		} else if (rawEffort === "none" || rawEffort === "off") {
+			mapped = null;
+		} else {
+			mapped = "low";
+		}
+
+		if (isResponsesApi && mapped === "max") {
+			mapped = "xhigh";
+		}
+		return mapped;
+	};
+	if (typeof body.reasoning_effort === "string") {
+		const mapped = mapEffort(body.reasoning_effort);
+		if (mapped === null || mapped === undefined) {
+			delete body.reasoning_effort;
+		} else {
+			body.reasoning_effort = mapped;
+		}
+	}
+	if (body.reasoning && typeof body.reasoning === "object") {
+		const r = body.reasoning as Record<string, unknown>;
+		if (r.effort === "none" || r.effort === "off") {
+			delete r.effort;
+		} else if (typeof r.effort === "string") {
+			const mapped = mapEffort(r.effort);
+			if (mapped === null || mapped === undefined) {
+				delete r.effort;
+			} else {
+				r.effort = mapped;
+			}
+		}
+		if (isResponsesApi && r.effort === "max") r.effort = "xhigh";
+	}
+
+	// 3. Max & Min tokens clamping (model-specific clamp + Vercel relay clamp)
+	const modelMax = modelDef?.maxTokens ?? RELAY_MAX_TOKENS;
+	const clampTokens = (val: number): number => {
+		let clamped = val;
+		if (!isKilo && clamped < 16) clamped = 16;
+		if (clamped > modelMax) clamped = modelMax;
+		if (isRelay && clamped > RELAY_MAX_TOKENS) clamped = RELAY_MAX_TOKENS;
+		return clamped;
+	};
+
+	if (typeof body.max_tokens === "number") {
+		body.max_tokens = clampTokens(body.max_tokens);
+	}
+	if (typeof body.maxTokens === "number") {
+		body.maxTokens = clampTokens(body.maxTokens);
+	}
+	if (typeof body.max_output_tokens === "number") {
+		body.max_output_tokens = clampTokens(body.max_output_tokens);
+	}
+
+	if (DBG) {
+		log(
+			"debug",
+			`normalize: outgoing model=${modelId}`,
+			{
+				reasoning_effort: body.reasoning_effort,
+				reasoning: body.reasoning,
+				max_tokens: body.max_tokens,
+				max_output_tokens: body.max_output_tokens,
+			},
+			reqId,
+		);
+	}
+
+	return body;
+}