@oh-my-pi/pi-web-ui 1.337.0

package/src/utils/model-discovery.ts

@@ -0,0 +1,277 @@
+import { LMStudioClient } from "@lmstudio/sdk";
+import type { Model } from "@oh-my-pi/pi-ai";
+import { Ollama } from "ollama/browser";
+
+/**
+ * Discover models from an Ollama server.
+ * @param baseUrl - Base URL of the Ollama server (e.g., "http://localhost:11434")
+ * @param apiKey - Optional API key (currently unused by Ollama)
+ * @returns Array of discovered models
+ */
+export async function discoverOllamaModels(baseUrl: string, _apiKey?: string): Promise<Model<any>[]> {
+	try {
+		// Create Ollama client
+		const ollama = new Ollama({ host: baseUrl });
+
+		// Get list of available models
+		const { models } = await ollama.list();
+
+		// Fetch details for each model and convert to Model format
+		const ollamaModelPromises: Promise<Model<any> | null>[] = models.map(async (model: any) => {
+			try {
+				// Get model details
+				const details = await ollama.show({
+					model: model.name,
+				});
+
+				// Check capabilities - filter out models that don't support tools
+				const capabilities: string[] = (details as any).capabilities || [];
+				if (!capabilities.includes("tools")) {
+					console.debug(`Skipping model ${model.name}: does not support tools`);
+					return null;
+				}
+
+				// Extract model info
+				const modelInfo: any = details.model_info || {};
+
+				// Get context window size - look for architecture-specific keys
+				const architecture = modelInfo["general.architecture"] || "";
+				const contextKey = `${architecture}.context_length`;
+				const contextWindow = parseInt(modelInfo[contextKey] || "8192", 10);
+
+				// Ollama caps max tokens at 10x context length
+				const maxTokens = contextWindow * 10;
+
+				// Ollama only supports completions API
+				const ollamaModel: Model<any> = {
+					id: model.name,
+					name: model.name,
+					api: "openai-completions" as any,
+					provider: "", // Will be set by caller
+					baseUrl: `${baseUrl}/v1`,
+					reasoning: capabilities.includes("thinking"),
+					input: ["text"],
+					cost: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+					},
+					contextWindow: contextWindow,
+					maxTokens: maxTokens,
+				};
+
+				return ollamaModel;
+			} catch (err) {
+				console.error(`Failed to fetch details for model ${model.name}:`, err);
+				return null;
+			}
+		});
+
+		const results = await Promise.all(ollamaModelPromises);
+		return results.filter((m): m is Model<any> => m !== null);
+	} catch (err) {
+		console.error("Failed to discover Ollama models:", err);
+		throw new Error(`Ollama discovery failed: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+
+/**
+ * Discover models from a llama.cpp server via OpenAI-compatible /v1/models endpoint.
+ * @param baseUrl - Base URL of the llama.cpp server (e.g., "http://localhost:8080")
+ * @param apiKey - Optional API key
+ * @returns Array of discovered models
+ */
+export async function discoverLlamaCppModels(baseUrl: string, apiKey?: string): Promise<Model<any>[]> {
+	try {
+		const headers: HeadersInit = {
+			"Content-Type": "application/json",
+		};
+
+		if (apiKey) {
+			headers.Authorization = `Bearer ${apiKey}`;
+		}
+
+		const response = await fetch(`${baseUrl}/v1/models`, {
+			method: "GET",
+			headers,
+		});
+
+		if (!response.ok) {
+			throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+		}
+
+		const data = await response.json();
+
+		if (!data.data || !Array.isArray(data.data)) {
+			throw new Error("Invalid response format from llama.cpp server");
+		}
+
+		return data.data.map((model: any) => {
+			// llama.cpp doesn't always provide context window info
+			const contextWindow = model.context_length || 8192;
+			const maxTokens = model.max_tokens || 4096;
+
+			const llamaModel: Model<any> = {
+				id: model.id,
+				name: model.id,
+				api: "openai-completions" as any,
+				provider: "", // Will be set by caller
+				baseUrl: `${baseUrl}/v1`,
+				reasoning: false,
+				input: ["text"],
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				contextWindow: contextWindow,
+				maxTokens: maxTokens,
+			};
+
+			return llamaModel;
+		});
+	} catch (err) {
+		console.error("Failed to discover llama.cpp models:", err);
+		throw new Error(`llama.cpp discovery failed: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+
+/**
+ * Discover models from a vLLM server via OpenAI-compatible /v1/models endpoint.
+ * @param baseUrl - Base URL of the vLLM server (e.g., "http://localhost:8000")
+ * @param apiKey - Optional API key
+ * @returns Array of discovered models
+ */
+export async function discoverVLLMModels(baseUrl: string, apiKey?: string): Promise<Model<any>[]> {
+	try {
+		const headers: HeadersInit = {
+			"Content-Type": "application/json",
+		};
+
+		if (apiKey) {
+			headers.Authorization = `Bearer ${apiKey}`;
+		}
+
+		const response = await fetch(`${baseUrl}/v1/models`, {
+			method: "GET",
+			headers,
+		});
+
+		if (!response.ok) {
+			throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+		}
+
+		const data = await response.json();
+
+		if (!data.data || !Array.isArray(data.data)) {
+			throw new Error("Invalid response format from vLLM server");
+		}
+
+		return data.data.map((model: any) => {
+			// vLLM provides max_model_len which is the context window
+			const contextWindow = model.max_model_len || 8192;
+			const maxTokens = Math.min(contextWindow, 4096); // Cap max tokens
+
+			const vllmModel: Model<any> = {
+				id: model.id,
+				name: model.id,
+				api: "openai-completions" as any,
+				provider: "", // Will be set by caller
+				baseUrl: `${baseUrl}/v1`,
+				reasoning: false,
+				input: ["text"],
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+				},
+				contextWindow: contextWindow,
+				maxTokens: maxTokens,
+			};
+
+			return vllmModel;
+		});
+	} catch (err) {
+		console.error("Failed to discover vLLM models:", err);
+		throw new Error(`vLLM discovery failed: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+
+/**
+ * Discover models from an LM Studio server using the LM Studio SDK.
+ * @param baseUrl - Base URL of the LM Studio server (e.g., "http://localhost:1234")
+ * @param apiKey - Optional API key (unused for LM Studio SDK)
+ * @returns Array of discovered models
+ */
+export async function discoverLMStudioModels(baseUrl: string, _apiKey?: string): Promise<Model<any>[]> {
+	try {
+		// Extract host and port from baseUrl
+		const url = new URL(baseUrl);
+		const port = url.port ? parseInt(url.port, 10) : 1234;
+
+		// Create LM Studio client
+		const client = new LMStudioClient({ baseUrl: `ws://${url.hostname}:${port}` });
+
+		// List all downloaded models
+		const models = await client.system.listDownloadedModels();
+
+		// Filter to only LLM models and map to our Model format
+		return models
+			.filter((model) => model.type === "llm")
+			.map((model) => {
+				const contextWindow = model.maxContextLength;
+				// Use 10x context length like Ollama does
+				const maxTokens = contextWindow;
+
+				const lmStudioModel: Model<any> = {
+					id: model.path,
+					name: model.displayName || model.path,
+					api: "openai-completions" as any,
+					provider: "", // Will be set by caller
+					baseUrl: `${baseUrl}/v1`,
+					reasoning: model.trainedForToolUse || false,
+					input: model.vision ? ["text", "image"] : ["text"],
+					cost: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+					},
+					contextWindow: contextWindow,
+					maxTokens: maxTokens,
+				};
+
+				return lmStudioModel;
+			});
+	} catch (err) {
+		console.error("Failed to discover LM Studio models:", err);
+		throw new Error(`LM Studio discovery failed: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+
+/**
+ * Convenience function to discover models based on provider type.
+ * @param type - Provider type
+ * @param baseUrl - Base URL of the server
+ * @param apiKey - Optional API key
+ * @returns Array of discovered models
+ */
+export async function discoverModels(
+	type: "ollama" | "llama.cpp" | "vllm" | "lmstudio",
+	baseUrl: string,
+	apiKey?: string,
+): Promise<Model<any>[]> {
+	switch (type) {
+		case "ollama":
+			return discoverOllamaModels(baseUrl, apiKey);
+		case "llama.cpp":
+			return discoverLlamaCppModels(baseUrl, apiKey);
+		case "vllm":
+			return discoverVLLMModels(baseUrl, apiKey);
+		case "lmstudio":
+			return discoverLMStudioModels(baseUrl, apiKey);
+	}
+}

package/src/utils/proxy-utils.ts

@@ -0,0 +1,134 @@
+import type { Api, Context, Model, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
+import { streamSimple } from "@oh-my-pi/pi-ai";
+
+/**
+ * Centralized proxy decision logic.
+ *
+ * Determines whether to use a CORS proxy for LLM API requests based on:
+ * - Provider name
+ * - API key pattern (for providers where it matters)
+ */
+
+/**
+ * Check if a provider/API key combination requires a CORS proxy.
+ *
+ * @param provider - Provider name (e.g., "anthropic", "openai", "zai")
+ * @param apiKey - API key for the provider
+ * @returns true if proxy is required, false otherwise
+ */
+export function shouldUseProxyForProvider(provider: string, apiKey: string): boolean {
+	switch (provider.toLowerCase()) {
+		case "zai":
+			// Z-AI always requires proxy
+			return true;
+
+		case "anthropic":
+			// Anthropic OAuth tokens (sk-ant-oat-*) require proxy
+			// Regular API keys (sk-ant-api-*) do NOT require proxy
+			return apiKey.startsWith("sk-ant-oat");
+
+		// These providers work without proxy
+		case "openai":
+		case "google":
+		case "groq":
+		case "openrouter":
+		case "cerebras":
+		case "xai":
+		case "ollama":
+		case "lmstudio":
+			return false;
+
+		// Unknown providers - assume no proxy needed
+		// This allows new providers to work by default
+		default:
+			return false;
+	}
+}
+
+/**
+ * Apply CORS proxy to a model's baseUrl if needed.
+ *
+ * @param model - The model to potentially proxy
+ * @param apiKey - API key for the provider
+ * @param proxyUrl - CORS proxy URL (e.g., "https://proxy.mariozechner.at/proxy")
+ * @returns Model with modified baseUrl if proxy is needed, otherwise original model
+ */
+export function applyProxyIfNeeded<T extends Api>(model: Model<T>, apiKey: string, proxyUrl?: string): Model<T> {
+	// If no proxy URL configured, return original model
+	if (!proxyUrl) {
+		return model;
+	}
+
+	// If model has no baseUrl, can't proxy it
+	if (!model.baseUrl) {
+		return model;
+	}
+
+	// Check if this provider/key needs proxy
+	if (!shouldUseProxyForProvider(model.provider, apiKey)) {
+		return model;
+	}
+
+	// Apply proxy to baseUrl
+	return {
+		...model,
+		baseUrl: `${proxyUrl}/?url=${encodeURIComponent(model.baseUrl)}`,
+	};
+}
+
+/**
+ * Check if an error is likely a CORS error.
+ *
+ * CORS errors in browsers typically manifest as:
+ * - TypeError with message "Failed to fetch"
+ * - NetworkError
+ *
+ * @param error - The error to check
+ * @returns true if error is likely a CORS error
+ */
+export function isCorsError(error: unknown): boolean {
+	if (!(error instanceof Error)) {
+		return false;
+	}
+
+	// Check for common CORS error patterns
+	const message = error.message.toLowerCase();
+
+	// "Failed to fetch" is the standard CORS error in most browsers
+	if (error.name === "TypeError" && message.includes("failed to fetch")) {
+		return true;
+	}
+
+	// Some browsers report "NetworkError"
+	if (error.name === "NetworkError") {
+		return true;
+	}
+
+	// CORS-specific messages
+	if (message.includes("cors") || message.includes("cross-origin")) {
+		return true;
+	}
+
+	return false;
+}
+
+/**
+ * Create a streamFn that applies CORS proxy when needed.
+ * Reads proxy settings from storage on each call.
+ *
+ * @param getProxyUrl - Async function to get current proxy URL (or undefined if disabled)
+ * @returns A streamFn compatible with Agent's streamFn option
+ */
+export function createStreamFn(getProxyUrl: () => Promise<string | undefined>) {
+	return async (model: Model<any>, context: Context, options?: SimpleStreamOptions) => {
+		const apiKey = options?.apiKey;
+		const proxyUrl = await getProxyUrl();
+
+		if (!apiKey || !proxyUrl) {
+			return streamSimple(model, context, options);
+		}
+
+		const proxiedModel = applyProxyIfNeeded(model, apiKey, proxyUrl);
+		return streamSimple(proxiedModel, context, options);
+	};
+}