pi-usereq 0.49.0 → 0.51.0

package/pi.dev-src/pi-mono/web-ui/src/utils/model-discovery.ts

@@ -1,277 +0,0 @@
-import { LMStudioClient } from "@lmstudio/sdk";
-import type { Model } from "@mariozechner/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/pi.dev-src/pi-mono/web-ui/src/utils/proxy-utils.ts

@@ -1,139 +0,0 @@
-import type { Api, Context, Model, SimpleStreamOptions } from "@mariozechner/pi-ai";
-import { streamSimple } from "@mariozechner/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") || apiKey.startsWith("{");
-
-		case "openai-codex":
-			// Codex uses chatgpt.com/backend-api which has no CORS
-			return true;
-
-		// These providers work without proxy
-		case "openai":
-		case "google":
-		case "groq":
-		case "openrouter":
-		case "cerebras":
-		case "xai":
-		case "ollama":
-		case "lmstudio":
-		case "github-copilot":
-			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);
-	};
-}