@makefinks/daemon 0.1.0

package/src/utils/model-metadata.ts

@@ -0,0 +1,191 @@
+/**
+ * Fetches and caches model metadata from OpenRouter API.
+ * Provides context window size and pricing information.
+ */
+
+import type { ModelPricing } from "../types";
+import { debug } from "./debug-logger";
+import { getOpenRouterModelEndpointsMetadata } from "./openrouter-endpoints";
+import { mergePricingAverages } from "./openrouter-pricing";
+
+export interface ModelMetadata {
+	id: string;
+	name: string;
+	contextLength: number;
+	pricing?: ModelPricing;
+	/** Whether this model supports the reasoning effort parameter */
+	supportsReasoning: boolean;
+	/** Whether any provider endpoint supports caching (best-effort). */
+	supportsCaching: boolean;
+}
+
+type CachedModelMetadataEntry = {
+	timestamp: number;
+	metadata: ModelMetadata;
+};
+
+// In-memory cache for model metadata (derived from per-model endpoints)
+let cachedByModelId: Map<string, CachedModelMetadataEntry> | null = null;
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+/**
+ * Build model-level metadata from OpenRouter per-model endpoint info.
+ */
+async function fetchModelMetadata(modelId: string): Promise<ModelMetadata | null> {
+	const now = Date.now();
+
+	if (!cachedByModelId) cachedByModelId = new Map();
+
+	const cached = cachedByModelId.get(modelId);
+	if (cached && now - cached.timestamp < CACHE_TTL_MS) return cached.metadata;
+
+	try {
+		debug.log("Fetching model endpoint metadata from OpenRouter...", { modelId });
+
+		const endpoints = await getOpenRouterModelEndpointsMetadata(modelId);
+		if (!endpoints) return null;
+
+		const contextLength = endpoints.providers.reduce((max, p) => {
+			const value = typeof p.contextLength === "number" ? p.contextLength : 0;
+			return Math.max(max, value);
+		}, 0);
+
+		const pricingCandidates = endpoints.providers
+			.map((p) => p.pricing)
+			.filter((p): p is ModelPricing => Boolean(p));
+
+		const pricing = pricingCandidates.length > 0 ? mergePricingAverages(pricingCandidates) : undefined;
+
+		const supportsCaching = endpoints.providers.some((p) => p.supportsCaching);
+
+		const metadata: ModelMetadata = {
+			id: endpoints.modelId,
+			name: endpoints.modelName ?? endpoints.modelId,
+			contextLength,
+			pricing,
+			supportsReasoning: endpoints.supportsReasoning,
+			supportsCaching,
+		};
+
+		cachedByModelId.set(modelId, { timestamp: now, metadata });
+		return metadata;
+	} catch (error) {
+		debug.error("Failed to fetch model metadata:", error);
+		return cached?.metadata ?? null;
+	}
+}
+
+/**
+ * Get metadata for a specific model.
+ * @param modelId - The OpenRouter model ID (e.g., "google/gemini-2.5-flash-preview")
+ */
+export async function getModelMetadata(modelId: string): Promise<ModelMetadata | null> {
+	return fetchModelMetadata(modelId);
+}
+
+/**
+ * Get metadata for multiple models.
+ * @param modelIds - Array of OpenRouter model IDs
+ * @returns Map of model ID to metadata (only includes models that were found)
+ */
+export async function getModelsMetadata(modelIds: string[]): Promise<Map<string, ModelMetadata>> {
+	const result = new Map<string, ModelMetadata>();
+	const concurrency = 4;
+	let index = 0;
+
+	const workers = Array.from({ length: Math.min(concurrency, modelIds.length) }).map(async () => {
+		while (index < modelIds.length) {
+			const current = modelIds[index++];
+			if (!current) continue;
+			const metadata = await fetchModelMetadata(current);
+			if (metadata) result.set(current, metadata);
+		}
+	});
+
+	await Promise.all(workers);
+	return result;
+}
+
+export async function getOpenRouterProviderPricing(
+	modelId: string,
+	providerTag: string
+): Promise<ModelPricing | undefined> {
+	const endpoints = await getOpenRouterModelEndpointsMetadata(modelId);
+	return resolveOpenRouterProviderPricing(endpoints?.providers ?? [], providerTag);
+}
+
+export function resolveOpenRouterProviderPricing(
+	providers: Array<{ tag: string; providerName: string; pricing?: ModelPricing }>,
+	providerId: string
+): ModelPricing | undefined {
+	const normalized = providerId.trim().toLowerCase();
+	if (!normalized) return undefined;
+
+	const provider = providers.find((p) => {
+		return p.tag.toLowerCase() === normalized || p.providerName.trim().toLowerCase() === normalized;
+	});
+
+	return provider?.pricing;
+}
+
+export async function calculateOpenRouterCostForProvider(
+	modelId: string,
+	providerTag: string,
+	promptTokens: number,
+	completionTokens: number,
+	cachedInputTokens?: number
+): Promise<number | undefined> {
+	const pricing = await getOpenRouterProviderPricing(modelId, providerTag);
+	if (!pricing) return undefined;
+	return calculateCost(promptTokens, completionTokens, pricing, cachedInputTokens);
+}
+
+/**
+ * Calculate the cost in USD for a given token usage.
+ *
+ * Note: some providers expose discounted cache pricing (OpenRouter: `input_cache_read`).
+ * When `cachedInputTokens` is provided and the model has `pricing.inputCacheRead`,
+ * those cached tokens are charged at the discounted rate.
+ */
+export function calculateCost(
+	promptTokens: number,
+	completionTokens: number,
+	pricing: ModelPricing,
+	cachedInputTokens?: number
+): number {
+	const cached = Math.max(0, Math.min(cachedInputTokens ?? 0, promptTokens));
+	const uncachedPromptTokens = Math.max(0, promptTokens - cached);
+
+	const promptCost =
+		(uncachedPromptTokens / 1_000_000) * pricing.prompt +
+		(cached / 1_000_000) * (pricing.inputCacheRead ?? pricing.prompt);
+	const completionCost = (completionTokens / 1_000_000) * pricing.completion;
+	return promptCost + completionCost;
+}
+
+/**
+ * Format a cost value as a USD string.
+ */
+export function formatCost(cost: number): string {
+	if (cost <= 0) {
+		return "$0.00";
+	}
+	if (cost < 0.0001) {
+		return "<$0.0001";
+	}
+	if (cost < 0.01) {
+		return `$${cost.toFixed(4)}`;
+	}
+	return `$${cost.toFixed(2)}`;
+}
+
+/**
+ * Format context usage as a percentage string.
+ */
+export function formatContextUsage(usedTokens: number, contextLength: number): string {
+	const percentage = (usedTokens / contextLength) * 100;
+	if (percentage < 1) {
+		return `${percentage.toFixed(1)}%`;
+	}
+	return `${Math.round(percentage)}%`;
+}

package/src/utils/openrouter-endpoints.ts

@@ -0,0 +1,212 @@
+/**
+ * Fetches and caches per-model endpoint/provider data from OpenRouter.
+ *
+ * Note: OpenRouter's `/api/v1/models` endpoint does not include the full list of
+ * inference providers. The provider list is exposed per-model via:
+ * `/api/v1/models/{modelId}/endpoints`
+ */
+
+import { debug } from "./debug-logger";
+import type { ModelPricing } from "../types";
+import { mergePricingAverages, parseOpenRouterPricePerTokenToPerMillion } from "./openrouter-pricing";
+
+export interface OpenRouterInferenceProvider {
+	/** Provider routing slug (matches OpenRouter `provider.order` entries), e.g. "openai" */
+	tag: string;
+	/** Human-friendly provider name, e.g. "OpenAI" */
+	providerName: string;
+	/** Context length for this provider (best-effort, max across endpoints) */
+	contextLength?: number;
+	/** Prices per 1M tokens (best-effort, averaged across endpoints) */
+	pricing?: ModelPricing;
+	/** Whether this provider appears to support caching */
+	supportsCaching: boolean;
+}
+
+interface OpenRouterEndpointsEndpoint {
+	provider_name?: string;
+	tag?: string;
+	context_length?: number;
+	pricing?: {
+		prompt?: string;
+		completion?: string;
+		input_cache_read?: string;
+		input_cache_write?: string;
+	};
+	supports_implicit_caching?: boolean;
+	supported_parameters?: string[];
+}
+
+interface OpenRouterEndpointsResponse {
+	data?: {
+		id?: string;
+		name?: string;
+		endpoints?: OpenRouterEndpointsEndpoint[];
+	};
+}
+
+export interface OpenRouterModelEndpointsMetadata {
+	modelId: string;
+	modelName?: string;
+	/** Provider summaries derived from endpoints. */
+	providers: OpenRouterInferenceProvider[];
+	/** Whether ANY endpoint supports reasoning controls. */
+	supportsReasoning: boolean;
+}
+
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+type CachedModelEntry = {
+	timestamp: number;
+	data: OpenRouterModelEndpointsMetadata;
+};
+
+let cachedByModelId: Map<string, CachedModelEntry> | null = null;
+
+function encodeModelIdForEndpointsPath(modelId: string): string {
+	// OpenRouter expects the slash to remain a path separator. Encode each segment.
+	return modelId.split("/").map(encodeURIComponent).join("/");
+}
+
+function parseEndpointPricingToPerMillion(
+	pricing: OpenRouterEndpointsEndpoint["pricing"]
+): ModelPricing | undefined {
+	if (!pricing || typeof pricing !== "object") return undefined;
+
+	const prompt = parseOpenRouterPricePerTokenToPerMillion(pricing.prompt);
+	const completion = parseOpenRouterPricePerTokenToPerMillion(pricing.completion);
+	if (prompt === undefined || completion === undefined) return undefined;
+
+	const parsed: ModelPricing = { prompt, completion };
+
+	const cacheReadPrice = parseOpenRouterPricePerTokenToPerMillion(pricing.input_cache_read);
+	if (cacheReadPrice !== undefined) parsed.inputCacheRead = cacheReadPrice;
+
+	const cacheWritePrice = parseOpenRouterPricePerTokenToPerMillion(pricing.input_cache_write);
+	if (cacheWritePrice !== undefined) parsed.inputCacheWrite = cacheWritePrice;
+
+	return parsed;
+}
+
+function endpointSupportsReasoning(endpoint: OpenRouterEndpointsEndpoint): boolean {
+	const params = endpoint.supported_parameters;
+	if (!Array.isArray(params)) return false;
+	return params.includes("reasoning") || params.includes("reasoning_effort");
+}
+
+async function fetchModelEndpointsMetadata(modelId: string): Promise<OpenRouterModelEndpointsMetadata> {
+	const encodedPath = encodeModelIdForEndpointsPath(modelId);
+	const url = `https://openrouter.ai/api/v1/models/${encodedPath}/endpoints`;
+
+	const response = await fetch(url, {
+		headers: {
+			"Content-Type": "application/json",
+		},
+	});
+
+	if (!response.ok) {
+		throw new Error(`OpenRouter endpoints API error: ${response.status}`);
+	}
+
+	const data = (await response.json()) as OpenRouterEndpointsResponse;
+	const endpoints = data.data?.endpoints ?? [];
+
+	const supportsReasoning = endpoints.some(endpointSupportsReasoning);
+
+	const byTag = new Map<string, OpenRouterInferenceProvider>();
+	const pricingByTag = new Map<string, ModelPricing[]>();
+
+	for (const endpoint of endpoints) {
+		const tag = typeof endpoint.tag === "string" ? endpoint.tag : "";
+		if (!tag) continue;
+
+		const providerName =
+			typeof endpoint.provider_name === "string" && endpoint.provider_name.trim().length > 0
+				? endpoint.provider_name.trim()
+				: tag;
+
+		const existing = byTag.get(tag);
+		if (existing) {
+			const contextLength = typeof endpoint.context_length === "number" ? endpoint.context_length : undefined;
+			if (contextLength !== undefined) {
+				existing.contextLength = Math.max(existing.contextLength ?? 0, contextLength);
+			}
+			existing.supportsCaching =
+				existing.supportsCaching ||
+				endpoint.supports_implicit_caching === true ||
+				endpoint.pricing?.input_cache_read !== undefined ||
+				endpoint.pricing?.input_cache_write !== undefined;
+		}
+
+		if (!existing) {
+			const contextLength = typeof endpoint.context_length === "number" ? endpoint.context_length : undefined;
+			byTag.set(tag, {
+				tag,
+				providerName,
+				contextLength,
+				supportsCaching:
+					endpoint.supports_implicit_caching === true ||
+					endpoint.pricing?.input_cache_read !== undefined ||
+					endpoint.pricing?.input_cache_write !== undefined,
+			});
+		}
+
+		const parsedPricing = parseEndpointPricingToPerMillion(endpoint.pricing);
+		if (parsedPricing) {
+			const list = pricingByTag.get(tag);
+			if (list) {
+				list.push(parsedPricing);
+			} else {
+				pricingByTag.set(tag, [parsedPricing]);
+			}
+		}
+	}
+
+	const providers = Array.from(byTag.values())
+		.map((provider) => {
+			const prices = pricingByTag.get(provider.tag);
+			const merged = prices ? mergePricingAverages(prices) : undefined;
+			return merged ? { ...provider, pricing: merged } : provider;
+		})
+		.sort((a, b) => {
+			const byName = a.providerName.localeCompare(b.providerName);
+			if (byName !== 0) return byName;
+			return a.tag.localeCompare(b.tag);
+		});
+
+	return {
+		modelId,
+		modelName: typeof data.data?.name === "string" ? data.data.name : undefined,
+		providers,
+		supportsReasoning,
+	};
+}
+
+/**
+ * Get the list of inference providers available for a given model.
+ * Results are cached in-memory for a day.
+ */
+export async function getOpenRouterModelProviders(modelId: string): Promise<OpenRouterInferenceProvider[]> {
+	const metadata = await getOpenRouterModelEndpointsMetadata(modelId);
+	return metadata?.providers ?? [];
+}
+
+export async function getOpenRouterModelEndpointsMetadata(
+	modelId: string
+): Promise<OpenRouterModelEndpointsMetadata | null> {
+	const now = Date.now();
+	if (!cachedByModelId) cachedByModelId = new Map();
+
+	const cached = cachedByModelId.get(modelId);
+	if (cached && now - cached.timestamp < CACHE_TTL_MS) return cached.data;
+
+	try {
+		debug.log("Fetching OpenRouter endpoints for model...", { modelId });
+		const data = await fetchModelEndpointsMetadata(modelId);
+		cachedByModelId.set(modelId, { timestamp: now, data });
+		return data;
+	} catch (error) {
+		debug.error("Failed to fetch OpenRouter endpoints:", error);
+		return cached?.data ?? null;
+	}
+}

package/src/utils/openrouter-models.ts

@@ -0,0 +1,205 @@
+/**
+ * Fetches and caches the full OpenRouter models list.
+ * This is used to populate the "all models" picker section.
+ */
+
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import type { ModelOption, ModelPricing } from "../types";
+import { debug } from "./debug-logger";
+import { getAppConfigDir } from "./preferences";
+import { parseOpenRouterPricePerTokenToPerMillion } from "./openrouter-pricing";
+
+interface OpenRouterModelItem {
+	id?: string;
+	name?: string;
+	context_length?: number;
+	pricing?: {
+		prompt?: string;
+		completion?: string;
+		input_cache_read?: string;
+		input_cache_write?: string;
+	};
+	supports_tools?: boolean;
+	supported_parameters?: string[];
+}
+
+interface OpenRouterModelsResponse {
+	data?: OpenRouterModelItem[];
+}
+
+interface OpenRouterModelsCache {
+	timestamp: number;
+	models: ModelOption[];
+}
+
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const CACHE_FILENAME = "openrouter-models.json";
+
+let inMemoryCache: OpenRouterModelsCache | null = null;
+
+function getCachePath(): string {
+	return path.join(getAppConfigDir(), CACHE_FILENAME);
+}
+
+function parsePricing(pricing?: OpenRouterModelItem["pricing"]): ModelPricing | undefined {
+	if (!pricing || typeof pricing !== "object") return undefined;
+
+	const prompt = parseOpenRouterPricePerTokenToPerMillion(pricing.prompt);
+	const completion = parseOpenRouterPricePerTokenToPerMillion(pricing.completion);
+	if (prompt === undefined || completion === undefined) return undefined;
+
+	const parsed: ModelPricing = { prompt, completion };
+
+	const cacheRead = parseOpenRouterPricePerTokenToPerMillion(pricing.input_cache_read);
+	if (cacheRead !== undefined) parsed.inputCacheRead = cacheRead;
+
+	const cacheWrite = parseOpenRouterPricePerTokenToPerMillion(pricing.input_cache_write);
+	if (cacheWrite !== undefined) parsed.inputCacheWrite = cacheWrite;
+
+	return parsed;
+}
+
+function supportsToolCalling(model: OpenRouterModelItem): boolean {
+	if (typeof model.supports_tools === "boolean") return model.supports_tools;
+
+	const params = Array.isArray(model.supported_parameters)
+		? model.supported_parameters.map((p) => p.toLowerCase())
+		: [];
+
+	if (params.length > 0) {
+		const toolParams = new Set(["tools", "tool_choice", "functions", "function_call", "tool-call"]);
+		return params.some((p) => toolParams.has(p));
+	}
+
+	// If the API doesn't expose tool support, exclude the model by default.
+	return false;
+}
+
+function normalizeModels(items: OpenRouterModelItem[]): ModelOption[] {
+	const models: ModelOption[] = [];
+
+	for (const item of items) {
+		const id = typeof item.id === "string" ? item.id.trim() : "";
+		if (!id) continue;
+		if (!supportsToolCalling(item)) continue;
+
+		const name = typeof item.name === "string" && item.name.trim().length > 0 ? item.name.trim() : id;
+		const contextLength = typeof item.context_length === "number" ? item.context_length : undefined;
+		const pricing = parsePricing(item.pricing);
+
+		models.push({
+			id,
+			name,
+			contextLength,
+			pricing,
+		});
+	}
+
+	return models;
+}
+
+async function readCache(): Promise<OpenRouterModelsCache | null> {
+	try {
+		const payload = await fs.readFile(getCachePath(), "utf8");
+		const data = JSON.parse(payload) as OpenRouterModelsCache;
+		if (!data || typeof data.timestamp !== "number" || !Array.isArray(data.models)) return null;
+		return data;
+	} catch {
+		return null;
+	}
+}
+
+async function writeCache(cache: OpenRouterModelsCache): Promise<void> {
+	try {
+		const dir = getAppConfigDir();
+		await fs.mkdir(dir, { recursive: true });
+		await fs.writeFile(getCachePath(), JSON.stringify(cache, null, 2), "utf8");
+	} catch (error) {
+		debug.error("Failed to write OpenRouter models cache:", error);
+	}
+}
+
+async function fetchOpenRouterModelsFromApi(): Promise<OpenRouterModelsCache> {
+	const url = "https://openrouter.ai/api/v1/models";
+	const headers: Record<string, string> = {
+		"Content-Type": "application/json",
+	};
+
+	const apiKey = process.env.OPENROUTER_API_KEY;
+	if (apiKey) {
+		headers.Authorization = `Bearer ${apiKey}`;
+	}
+
+	const response = await fetch(url, { headers });
+	if (!response.ok) {
+		throw new Error(`OpenRouter models API error: ${response.status}`);
+	}
+
+	const data = (await response.json()) as OpenRouterModelsResponse;
+	const items = Array.isArray(data.data) ? data.data : [];
+
+	const models = normalizeModels(items);
+	const payload: OpenRouterModelsCache = {
+		timestamp: Date.now(),
+		models,
+	};
+
+	await writeCache(payload);
+	return payload;
+}
+
+function isCacheFresh(cache: OpenRouterModelsCache): boolean {
+	return Date.now() - cache.timestamp < CACHE_TTL_MS;
+}
+
+export interface OpenRouterModelsResult {
+	models: ModelOption[];
+	timestamp: number | null;
+	fromCache: boolean;
+}
+
+export async function getOpenRouterModels(options?: {
+	forceRefresh?: boolean;
+}): Promise<OpenRouterModelsResult> {
+	const forceRefresh = options?.forceRefresh ?? false;
+
+	if (!forceRefresh && inMemoryCache && isCacheFresh(inMemoryCache)) {
+		return {
+			models: inMemoryCache.models,
+			timestamp: inMemoryCache.timestamp,
+			fromCache: true,
+		};
+	}
+
+	if (!forceRefresh) {
+		const diskCache = await readCache();
+		if (diskCache && isCacheFresh(diskCache)) {
+			inMemoryCache = diskCache;
+			return {
+				models: diskCache.models,
+				timestamp: diskCache.timestamp,
+				fromCache: true,
+			};
+		}
+	}
+
+	try {
+		debug.log("Fetching OpenRouter model list...");
+		const cache = await fetchOpenRouterModelsFromApi();
+		inMemoryCache = cache;
+		return { models: cache.models, timestamp: cache.timestamp, fromCache: false };
+	} catch (error) {
+		debug.error("Failed to fetch OpenRouter models:", error);
+		const fallback = inMemoryCache ?? (await readCache());
+		if (fallback) {
+			inMemoryCache = fallback;
+			return {
+				models: fallback.models,
+				timestamp: fallback.timestamp,
+				fromCache: true,
+			};
+		}
+		return { models: [], timestamp: null, fromCache: true };
+	}
+}

package/src/utils/openrouter-pricing.ts

@@ -0,0 +1,59 @@
+import type { ModelPricing } from "../types";
+
+export function parseOpenRouterPricePerTokenToPerMillion(pricePerToken: unknown): number | undefined {
+	if (typeof pricePerToken !== "string") return undefined;
+	const parsed = Number(pricePerToken);
+	if (!Number.isFinite(parsed)) return undefined;
+	return parsed * 1_000_000;
+}
+
+export function mergePricingAverages(pricings: ModelPricing[]): ModelPricing | undefined {
+	let promptSum = 0;
+	let promptCount = 0;
+
+	let completionSum = 0;
+	let completionCount = 0;
+
+	let inputCacheReadSum = 0;
+	let inputCacheReadCount = 0;
+
+	let inputCacheWriteSum = 0;
+	let inputCacheWriteCount = 0;
+
+	for (const pricing of pricings) {
+		if (Number.isFinite(pricing.prompt)) {
+			promptSum += pricing.prompt;
+			promptCount += 1;
+		}
+		if (Number.isFinite(pricing.completion)) {
+			completionSum += pricing.completion;
+			completionCount += 1;
+		}
+
+		if (pricing.inputCacheRead !== undefined && Number.isFinite(pricing.inputCacheRead)) {
+			inputCacheReadSum += pricing.inputCacheRead;
+			inputCacheReadCount += 1;
+		}
+		if (pricing.inputCacheWrite !== undefined && Number.isFinite(pricing.inputCacheWrite)) {
+			inputCacheWriteSum += pricing.inputCacheWrite;
+			inputCacheWriteCount += 1;
+		}
+	}
+
+	if (promptCount === 0 || completionCount === 0) return undefined;
+
+	const merged: ModelPricing = {
+		prompt: promptSum / promptCount,
+		completion: completionSum / completionCount,
+	};
+
+	if (inputCacheReadCount > 0) {
+		merged.inputCacheRead = inputCacheReadSum / inputCacheReadCount;
+	}
+
+	if (inputCacheWriteCount > 0) {
+		merged.inputCacheWrite = inputCacheWriteSum / inputCacheWriteCount;
+	}
+
+	return merged;
+}

package/src/utils/openrouter-reported-cost.ts

@@ -0,0 +1,16 @@
+export function getOpenRouterReportedCost(providerMetadata: unknown): number | undefined {
+	if (!providerMetadata || typeof providerMetadata !== "object") return undefined;
+	if (!("openrouter" in providerMetadata)) return undefined;
+
+	const openrouter = (providerMetadata as { openrouter?: unknown }).openrouter;
+	if (!openrouter || typeof openrouter !== "object") return undefined;
+	if (!("usage" in openrouter)) return undefined;
+
+	const usage = (openrouter as { usage?: unknown }).usage;
+	if (!usage || typeof usage !== "object") return undefined;
+	if (!("cost" in usage)) return undefined;
+
+	const cost = (usage as { cost?: unknown }).cost;
+	if (typeof cost !== "number" || !Number.isFinite(cost)) return undefined;
+	return cost;
+}