@happyvertical/ai 0.79.0 → 0.80.1

package/dist/chunks/ollama-D4ksOTO8.js

@@ -0,0 +1,626 @@
+import { a as ContextLengthError, c as extractTextContent, i as ContentFilterError, o as ModelNotFoundError, r as AuthenticationError, s as RateLimitError, t as AIError } from "./types-FHs-KbGL.js";
+import { a as normalizeBaseAIOptions, c as prepareRequestControls, o as normalizeChatOptions, s as normalizeImageGenerationOptions } from "./safety-CEnoJS6X.js";
+import { t as emitUsage } from "./usage-C1Y1Nlg4.js";
+import { ValidationError } from "@happyvertical/utils";
+//#region src/shared/providers/ollama.ts
+/**
+* Ollama provider implementation.
+*
+* Uses Ollama's native `/api/*` endpoints for chat, completions, embeddings,
+* and model discovery, while bridging to the experimental OpenAI-compatible
+* image-generation endpoint when available.
+*/
+var DEFAULT_OLLAMA_HOST = "http://localhost:11434";
+var OLLAMA_CAPABILITIES = {
+	chat: true,
+	completion: true,
+	embeddings: true,
+	streaming: true,
+	functions: true,
+	vision: true,
+	fineTuning: false,
+	imageEmbeddings: true,
+	imageGeneration: true,
+	tts: false,
+	voiceCloning: false,
+	voiceDesign: false,
+	maxContextLength: 131072,
+	supportedOperations: [
+		"chat",
+		"completion",
+		"embedding",
+		"streaming",
+		"functions",
+		"vision",
+		"image_embedding",
+		"image_generation"
+	]
+};
+function stripTrailingSlash(value) {
+	return value.replace(/\/+$/, "");
+}
+function normalizeHost(baseUrl) {
+	const rawBase = baseUrl?.trim() || DEFAULT_OLLAMA_HOST;
+	const base = stripTrailingSlash(/^[a-z][a-z0-9+.-]*:\/\//i.test(rawBase) ? rawBase : `http://${rawBase}`);
+	if (base.endsWith("/api")) return base.slice(0, -4);
+	if (base.endsWith("/v1")) return base.slice(0, -3);
+	return base;
+}
+function isEmbeddingModel(modelId) {
+	return /(?:^|[-_:/])(?:embed|embedding)|nomic-embed|mxbai-embed/i.test(modelId);
+}
+function isImageGenerationModel(modelId) {
+	return /(?:^|[-_:/])(flux|sdxl|stable(?:[-_ ]?diffusion)?|z-image|image(?:[-_ ]?(?:turbo|gen|generator)))/i.test(modelId);
+}
+function inferVisionSupport(modelId, capabilities) {
+	if (capabilities.has("vision")) return true;
+	return /vision|llava|bakllava|moondream|pixtral|qwen.*vl|vl-|gemma3/i.test(modelId);
+}
+function inferFunctionSupport(modelId, capabilities) {
+	if (capabilities.has("tools") || capabilities.has("tool_calling") || capabilities.has("function_calling")) return true;
+	if (isEmbeddingModel(modelId) || isImageGenerationModel(modelId)) return false;
+	return /qwen|llama3|gpt-oss|mistral|deepseek|command-r|phi4/i.test(modelId);
+}
+function parseCapabilities(modelId, show) {
+	const capabilities = new Set((show?.capabilities || []).map((capability) => capability.toLowerCase()));
+	if (isImageGenerationModel(modelId)) return ["image_generation"];
+	if (capabilities.has("embedding") || capabilities.has("embeddings") || isEmbeddingModel(modelId)) return ["embeddings"];
+	const supported = /* @__PURE__ */ new Set(["text", "chat"]);
+	if (inferVisionSupport(modelId, capabilities)) supported.add("vision");
+	if (inferFunctionSupport(modelId, capabilities)) supported.add("functions");
+	return [...supported];
+}
+function parseContextLength(modelId, show) {
+	const modelInfo = show?.model_info || {};
+	for (const [key, value] of Object.entries(modelInfo)) if (key.endsWith(".context_length") && typeof value === "number") return value;
+	const numCtxMatch = show?.parameters?.match(/\bnum_ctx\s+(\d+)/);
+	if (numCtxMatch?.[1]) return Number(numCtxMatch[1]);
+	if (isEmbeddingModel(modelId)) return 8192;
+	if (/gemma3|qwen3|gpt-oss|llama3/i.test(modelId)) return 131072;
+	return 32768;
+}
+function mapUsage(promptTokens, completionTokens) {
+	if (typeof promptTokens !== "number" && typeof completionTokens !== "number") return;
+	const prompt = promptTokens || 0;
+	const completion = completionTokens || 0;
+	return {
+		promptTokens: prompt,
+		completionTokens: completion,
+		totalTokens: prompt + completion
+	};
+}
+function mapFinishReason(reason) {
+	switch (reason) {
+		case "stop": return "stop";
+		case "length": return "length";
+		case "content_filter": return "content_filter";
+		default: return "stop";
+	}
+}
+function scoreModelForCapability(model, capability) {
+	const id = model.id.toLowerCase();
+	let score = 0;
+	if (id.includes(":latest")) score += 6;
+	if (id.includes("instruct") || id.includes("-it")) score += 6;
+	if (id.startsWith("hf.co/")) score -= 8;
+	if (/ocr|rerank|embed|image|diffusion|flux/.test(id)) score -= 12;
+	switch (capability) {
+		case "vision":
+			if (model.supportsVision) score += 25;
+			if (/gemma4|gemma3/.test(id)) score += 12;
+			if (/qwen.*vl|llava|moondream|vision/.test(id)) score += 8;
+			if (/ocr/.test(id)) score -= 10;
+			break;
+		case "embedding":
+			if (model.capabilities.includes("embeddings")) score += 20;
+			if (/nomic|mxbai|embed/.test(id)) score += 6;
+			break;
+		case "image_generation":
+			if (model.capabilities.includes("image_generation")) score += 20;
+			if (/flux|sdxl|stable/.test(id)) score += 8;
+			break;
+		default:
+			if (model.capabilities.includes("chat")) score += 12;
+			if (model.supportsFunctions) score += 4;
+			if (/llama|mistral|qwen|gemma|phi|command-r|deepseek-coder/.test(id)) score += 8;
+			if (/gpt-oss/.test(id)) score -= 3;
+			break;
+	}
+	return score;
+}
+var OllamaProvider = class {
+	options;
+	host;
+	configuredDefaultModel;
+	modelListPromise;
+	modelShowCache = /* @__PURE__ */ new Map();
+	resolvedModelCache = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.host = normalizeHost(options.baseUrl);
+		this.options = normalizeBaseAIOptions({
+			...options,
+			baseUrl: this.host
+		});
+		this.configuredDefaultModel = options.defaultModel;
+	}
+	get nativeBaseUrl() {
+		return `${this.host}/api`;
+	}
+	get compatibilityBaseUrl() {
+		return `${this.host}/v1`;
+	}
+	buildHeaders(stream = false) {
+		const headers = new Headers(this.options.headers);
+		headers.set("Content-Type", "application/json");
+		headers.set("Accept", stream ? "application/x-ndjson, application/json" : "application/json");
+		if (this.options.apiKey) headers.set("Authorization", `Bearer ${this.options.apiKey}`);
+		return headers;
+	}
+	async buildHttpError(response) {
+		const text = await response.text();
+		const message = text && text.trim().length > 0 ? text.trim() : `Ollama request failed with status ${response.status}`;
+		switch (response.status) {
+			case 401:
+			case 403: return new AuthenticationError("ollama");
+			case 404: return new ModelNotFoundError(message, "ollama");
+			case 413: return new ContextLengthError("ollama");
+			case 429: return new RateLimitError("ollama");
+			default:
+				if (/content[_ -]?filter/i.test(message)) return new ContentFilterError("ollama");
+				if (/context|too long|maximum context/i.test(message)) return new ContextLengthError("ollama");
+				return new AIError(message, "API_ERROR", "ollama");
+		}
+	}
+	mapError(error) {
+		if (error instanceof AIError) return error;
+		if (error instanceof Error && error.name === "AbortError") return new AIError("Ollama request timed out", "TIMEOUT", "ollama");
+		return new AIError(error instanceof Error ? error.message : "Unknown error occurred", "UNKNOWN_ERROR", "ollama");
+	}
+	async requestJson(path, body, options = {}) {
+		const baseUrl = options.compatibility ? this.compatibilityBaseUrl : this.nativeBaseUrl;
+		const response = await fetch(`${baseUrl}${path}`, {
+			method: body ? "POST" : "GET",
+			headers: this.buildHeaders(),
+			body: body ? JSON.stringify(body) : void 0,
+			signal: options.signal
+		});
+		if (!response.ok) throw await this.buildHttpError(response);
+		return await response.json();
+	}
+	async requestStream(path, body, signal) {
+		const response = await fetch(`${this.nativeBaseUrl}${path}`, {
+			method: "POST",
+			headers: this.buildHeaders(true),
+			body: JSON.stringify(body),
+			signal
+		});
+		if (!response.ok) throw await this.buildHttpError(response);
+		return response;
+	}
+	async *parseNdjson(response) {
+		const reader = response.body?.getReader();
+		if (!reader) return;
+		const decoder = new TextDecoder();
+		let buffer = "";
+		while (true) {
+			const { value, done } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			let newlineIndex = buffer.indexOf("\n");
+			while (newlineIndex !== -1) {
+				const line = buffer.slice(0, newlineIndex).trim();
+				buffer = buffer.slice(newlineIndex + 1);
+				if (line) yield JSON.parse(line);
+				newlineIndex = buffer.indexOf("\n");
+			}
+		}
+		buffer += decoder.decode();
+		const line = buffer.trim();
+		if (line) yield JSON.parse(line);
+	}
+	async showModel(model) {
+		const cached = this.modelShowCache.get(model);
+		if (cached) return cached;
+		const pending = this.requestJson("/show", {
+			model,
+			verbose: false
+		}).catch((_error) => null);
+		this.modelShowCache.set(model, pending);
+		return pending;
+	}
+	async resolveModel(capability, explicitModel) {
+		if (explicitModel) return explicitModel;
+		if (this.configuredDefaultModel && (capability === "chat" || capability === "vision")) return this.configuredDefaultModel;
+		const cached = this.resolvedModelCache.get(capability);
+		if (cached) return cached;
+		const pending = this.selectModel(capability).catch((error) => {
+			this.resolvedModelCache.delete(capability);
+			throw error;
+		});
+		this.resolvedModelCache.set(capability, pending);
+		return pending;
+	}
+	async selectModel(capability) {
+		const model = (await this.getModels()).filter((candidate) => {
+			switch (capability) {
+				case "vision": return candidate.capabilities.includes("vision") || candidate.supportsVision === true;
+				case "embedding": return candidate.capabilities.includes("embeddings");
+				case "image_generation": return candidate.capabilities.includes("image_generation");
+				default: return candidate.capabilities.includes("chat");
+			}
+		}).sort((left, right) => scoreModelForCapability(right, capability) - scoreModelForCapability(left, capability))[0];
+		if (!model) throw new ValidationError(`No ${capability} model is available from the Ollama host`, {
+			provider: "ollama",
+			capability,
+			hint: "Pass model/defaultModel explicitly or make sure the Ollama host has a compatible model installed"
+		});
+		return model.id;
+	}
+	isVisionRequest(messages) {
+		return messages.some((message) => Array.isArray(message.content) && message.content.some((part) => part.type === "image_url"));
+	}
+	async imageToBase64Payload(image, signal) {
+		if (Buffer.isBuffer(image)) return image.toString("base64");
+		if (image.startsWith("data:")) {
+			const commaIndex = image.indexOf(",");
+			return commaIndex === -1 ? image : image.slice(commaIndex + 1);
+		}
+		const response = await fetch(image, { signal });
+		if (!response.ok) throw new AIError(`Failed to fetch image: ${response.status} ${response.statusText}`, "IMAGE_FETCH_ERROR", "ollama");
+		const arrayBuffer = await response.arrayBuffer();
+		return Buffer.from(arrayBuffer).toString("base64");
+	}
+	async imageToDataUrl(image, signal) {
+		if (Buffer.isBuffer(image)) return `data:image/png;base64,${image.toString("base64")}`;
+		if (image.startsWith("data:")) return image;
+		const response = await fetch(image, { signal });
+		if (!response.ok) throw new AIError(`Failed to fetch image: ${response.status} ${response.statusText}`, "IMAGE_FETCH_ERROR", "ollama");
+		const contentType = response.headers.get("content-type") || "image/png";
+		const arrayBuffer = await response.arrayBuffer();
+		return `data:${contentType};base64,${Buffer.from(arrayBuffer).toString("base64")}`;
+	}
+	parseToolArguments(argumentsText) {
+		if (!argumentsText) return {};
+		try {
+			const parsed = JSON.parse(argumentsText);
+			return parsed && typeof parsed === "object" ? parsed : {};
+		} catch {
+			return {};
+		}
+	}
+	async mapMessagesToOllama(messages, signal) {
+		return await Promise.all(messages.map(async (message) => {
+			const content = extractTextContent(message.content);
+			const mapped = {
+				role: message.role === "function" ? "tool" : message.role,
+				content
+			};
+			if (Array.isArray(message.content)) {
+				const imageParts = message.content.filter((part) => part.type === "image_url");
+				if (imageParts.length > 0) mapped.images = await Promise.all(imageParts.map((part) => this.imageToBase64Payload(part.image_url.url, signal)));
+			}
+			if (mapped.role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.length > 0) mapped.tool_calls = message.tool_calls.map((toolCall, index) => ({
+				type: "function",
+				function: {
+					index,
+					name: toolCall.function.name,
+					arguments: this.parseToolArguments(toolCall.function.arguments)
+				}
+			}));
+			if (mapped.role === "tool" && message.name) mapped.tool_name = message.name;
+			return mapped;
+		}));
+	}
+	mapTools(tools, toolChoice) {
+		if (!tools || tools.length === 0 || toolChoice === "none") return;
+		const scopedTools = toolChoice && typeof toolChoice === "object" ? tools.filter((tool) => tool.function.name === toolChoice.function.name) : tools;
+		if (scopedTools.length === 0) return;
+		return scopedTools.map((tool) => ({
+			type: "function",
+			function: {
+				name: tool.function.name,
+				description: tool.function.description,
+				parameters: tool.function.parameters || { type: "object" }
+			}
+		}));
+	}
+	buildRuntimeOptions(options) {
+		const runtimeOptions = {};
+		if (typeof options.maxTokens === "number") runtimeOptions.num_predict = options.maxTokens;
+		if (typeof options.temperature === "number") runtimeOptions.temperature = options.temperature;
+		if (typeof options.topP === "number") runtimeOptions.top_p = options.topP;
+		if (options.stop) runtimeOptions.stop = Array.isArray(options.stop) ? options.stop : [options.stop];
+		if (typeof options.seed === "number") runtimeOptions.seed = options.seed;
+		return Object.keys(runtimeOptions).length > 0 ? runtimeOptions : void 0;
+	}
+	mapThink(options) {
+		if (options.reasoning?.maxTokens === 0) return false;
+		if (options.reasoning?.effort) return options.reasoning.effort === "none" ? false : options.reasoning.effort;
+		if (!Object.hasOwn(options, "thinkingLevel")) return;
+		return options.thinkingLevel;
+	}
+	async chat(messages, options = {}) {
+		const startTime = Date.now();
+		let controls;
+		try {
+			options = normalizeChatOptions(this.options, options, "ollama", options.model || this.options.defaultModel);
+			controls = prepareRequestControls(this.options, options);
+			const model = await this.resolveModel(this.isVisionRequest(messages) ? "vision" : "chat", options.model);
+			const response = await this.requestJson("/chat", {
+				model,
+				messages: await this.mapMessagesToOllama(messages, controls.signal),
+				stream: false,
+				format: options.responseFormat?.type === "json_object" ? "json" : void 0,
+				tools: this.mapTools(options.tools, options.toolChoice),
+				think: this.mapThink(options),
+				keep_alive: this.options.keepAlive,
+				options: this.buildRuntimeOptions(options)
+			}, { signal: controls.signal });
+			const usage = mapUsage(response.prompt_eval_count, response.eval_count);
+			emitUsage(this.options, "ollama", "chat", response.model || model, usage, startTime, options.usageTags);
+			const toolCalls = response.message?.tool_calls?.filter((call) => call.function?.name).map((call, index) => ({
+				id: `${response.model || model}-tool-${index + 1}`,
+				type: "function",
+				function: {
+					name: call.function?.name || "",
+					arguments: JSON.stringify(call.function?.arguments || {})
+				}
+			})) || void 0;
+			return {
+				content: response.message?.content || "",
+				model: response.model || model,
+				usage,
+				finishReason: toolCalls && toolCalls.length > 0 ? "tool_calls" : mapFinishReason(response.done_reason),
+				toolCalls: toolCalls && toolCalls.length > 0 ? toolCalls : void 0
+			};
+		} catch (error) {
+			if (controls?.didTimeout()) throw new AIError(`AI request timed out after ${controls.timeout}ms`, "AI_TIMEOUT", "ollama", options.model);
+			if (options.signal?.aborted) throw new AIError("AI request aborted by caller", "AI_ABORTED", "ollama", options.model);
+			throw this.mapError(error);
+		} finally {
+			controls?.cleanup();
+		}
+	}
+	async complete(prompt, options = {}) {
+		const startTime = Date.now();
+		let controls;
+		try {
+			options = normalizeChatOptions(this.options, options, "ollama", options.model || this.options.defaultModel);
+			controls = prepareRequestControls(this.options, options);
+			const model = await this.resolveModel("chat", options.model);
+			const response = await this.requestJson("/generate", {
+				model,
+				prompt,
+				stream: false,
+				keep_alive: this.options.keepAlive,
+				options: this.buildRuntimeOptions(options)
+			}, { signal: controls.signal });
+			const usage = mapUsage(response.prompt_eval_count, response.eval_count);
+			emitUsage(this.options, "ollama", "complete", response.model || model, usage, startTime, options.usageTags);
+			return {
+				content: response.response || "",
+				model: response.model || model,
+				usage,
+				finishReason: mapFinishReason(response.done_reason)
+			};
+		} catch (error) {
+			if (controls?.didTimeout()) throw new AIError(`AI request timed out after ${controls.timeout}ms`, "AI_TIMEOUT", "ollama", options.model);
+			if (options.signal?.aborted) throw new AIError("AI request aborted by caller", "AI_ABORTED", "ollama", options.model);
+			throw this.mapError(error);
+		} finally {
+			controls?.cleanup();
+		}
+	}
+	async message(text, options = {}) {
+		const messages = [...options.history || [], {
+			role: options.role || "user",
+			content: text
+		}];
+		return (await this.chat(messages, {
+			model: options.model,
+			maxTokens: options.maxTokens,
+			temperature: options.temperature,
+			topP: options.topP,
+			stop: options.stop,
+			stream: options.stream,
+			frequencyPenalty: options.frequencyPenalty,
+			presencePenalty: options.presencePenalty,
+			responseFormat: options.responseFormat,
+			seed: options.seed,
+			tools: options.tools,
+			toolChoice: options.toolChoice,
+			onProgress: options.onProgress,
+			signal: options.signal,
+			timeout: options.timeout,
+			reasoning: options.reasoning,
+			usageTags: options.usageTags
+		})).content;
+	}
+	async embed(text, options = {}) {
+		const startTime = Date.now();
+		try {
+			const model = await this.resolveModel("embedding", options.model);
+			const input = Array.isArray(text) ? text : [text];
+			const response = await this.requestJson("/embed", {
+				model,
+				input,
+				keep_alive: this.options.keepAlive
+			});
+			const embeddings = response.embeddings || (response.embedding ? [response.embedding] : void 0);
+			if (!embeddings || embeddings.length === 0) throw new AIError("Invalid embedding response from Ollama", "INVALID_RESPONSE", "ollama");
+			const usage = mapUsage(response.prompt_eval_count, 0);
+			emitUsage(this.options, "ollama", "embed", response.model || model, usage, startTime, options.usageTags);
+			return {
+				embeddings,
+				usage,
+				model: response.model || model
+			};
+		} catch (error) {
+			throw this.mapError(error);
+		}
+	}
+	async embedImage(image, options = {}) {
+		const description = await this.describeImage(image, "Describe this image in detail for semantic embedding. Include objects, people, text, setting, colors, composition, and notable visual relationships.");
+		return this.embed(description, {
+			model: options.model,
+			dimensions: options.dimensions,
+			user: options.user
+		});
+	}
+	async describeImage(image, prompt, options = {}) {
+		const defaultPrompt = "Describe this image for a search index. Include objects, mood, lighting, and any visible text.";
+		const imageUrl = await this.imageToDataUrl(image, options.signal);
+		return (await this.chat([{
+			role: "user",
+			content: [{
+				type: "text",
+				text: prompt || defaultPrompt
+			}, {
+				type: "image_url",
+				image_url: {
+					url: imageUrl,
+					detail: options.detail || "auto"
+				}
+			}]
+		}], {
+			model: options.model,
+			maxTokens: options.maxTokens ?? 500,
+			reasoning: options.reasoning || {
+				effort: "none",
+				maxTokens: 0
+			},
+			signal: options.signal,
+			timeout: options.timeout,
+			usageTags: options.usageTags
+		})).content;
+	}
+	async generateImage(prompt, options = {}) {
+		let controls;
+		try {
+			options = normalizeImageGenerationOptions(this.options, options, "ollama", options.model);
+			controls = prepareRequestControls(this.options, options);
+			if (options.imageInput) throw new AIError("Ollama image generation does not support imageInput in this adapter yet.", "NOT_IMPLEMENTED", "ollama");
+			if (options.outputFormat === "url") throw new AIError("Ollama image generation only supports buffer or base64 outputs in this adapter.", "NOT_SUPPORTED", "ollama");
+			const model = await this.resolveModel("image_generation", options.model);
+			return {
+				images: ((await this.requestJson("/images/generations", {
+					model,
+					prompt,
+					n: options.n,
+					size: options.size || "1024x1024",
+					response_format: "b64_json",
+					quality: options.quality,
+					style: options.style
+				}, {
+					compatibility: true,
+					signal: controls.signal
+				})).data || []).map((item) => {
+					const b64 = item.b64_json || "";
+					return {
+						data: options.outputFormat === "base64" ? b64 : Buffer.from(b64, "base64"),
+						mimeType: "image/png",
+						revisedPrompt: item.revised_prompt
+					};
+				}),
+				model
+			};
+		} catch (error) {
+			if (controls?.didTimeout()) throw new AIError(`AI request timed out after ${controls.timeout}ms`, "AI_TIMEOUT", "ollama", options.model);
+			if (options.signal?.aborted) throw new AIError("AI request aborted by caller", "AI_ABORTED", "ollama", options.model);
+			throw this.mapError(error);
+		} finally {
+			controls?.cleanup();
+		}
+	}
+	async *stream(messages, options = {}) {
+		const startTime = Date.now();
+		let controls;
+		try {
+			options = normalizeChatOptions(this.options, options, "ollama", options.model || this.options.defaultModel);
+			controls = prepareRequestControls(this.options, options);
+			const model = await this.resolveModel(this.isVisionRequest(messages) ? "vision" : "chat", options.model);
+			const response = await this.requestStream("/chat", {
+				model,
+				messages: await this.mapMessagesToOllama(messages, controls.signal),
+				stream: true,
+				format: options.responseFormat?.type === "json_object" ? "json" : void 0,
+				tools: this.mapTools(options.tools, options.toolChoice),
+				think: this.mapThink(options),
+				keep_alive: this.options.keepAlive,
+				options: this.buildRuntimeOptions(options)
+			}, controls.signal);
+			let finalUsage;
+			let finalModel = model;
+			for await (const chunk of this.parseNdjson(response)) {
+				if (chunk.model) finalModel = chunk.model;
+				if (typeof chunk.message?.content === "string" && chunk.message.content) {
+					if (options.onProgress) options.onProgress(chunk.message.content);
+					yield chunk.message.content;
+				}
+				if (chunk.done) finalUsage = mapUsage(chunk.prompt_eval_count, chunk.eval_count);
+			}
+			emitUsage(this.options, "ollama", "stream", finalModel, finalUsage, startTime, options.usageTags);
+		} catch (error) {
+			if (controls?.didTimeout()) throw new AIError(`AI request timed out after ${controls.timeout}ms`, "AI_TIMEOUT", "ollama", options.model);
+			if (options.signal?.aborted) throw new AIError("AI request aborted by caller", "AI_ABORTED", "ollama", options.model);
+			throw this.mapError(error);
+		} finally {
+			controls?.cleanup();
+		}
+	}
+	async countTokens(text) {
+		return Math.ceil(text.length / 4);
+	}
+	async getModels() {
+		if (this.modelListPromise) return this.modelListPromise;
+		this.modelListPromise = (async () => {
+			const summaries = (await this.requestJson("/tags")).models || [];
+			return Promise.all(summaries.map(async (summary) => {
+				const modelId = summary.name || summary.model;
+				if (!modelId) throw new AIError("Ollama returned a model without an identifier", "INVALID_RESPONSE", "ollama");
+				const show = await this.showModel(modelId);
+				const capabilities = parseCapabilities(modelId, show);
+				const vision = capabilities.includes("vision");
+				const functions = capabilities.includes("functions");
+				const parameterSize = show?.details?.parameter_size || summary.details?.parameter_size;
+				const family = show?.details?.family || summary.details?.family;
+				return {
+					id: modelId,
+					name: modelId,
+					description: parameterSize || family ? `${family || "Ollama"} ${parameterSize || ""}`.trim() : `Ollama model: ${modelId}`,
+					contextLength: parseContextLength(modelId, show),
+					capabilities,
+					supportsFunctions: functions,
+					supportsVision: vision
+				};
+			}));
+		})().catch((error) => {
+			this.modelListPromise = void 0;
+			throw this.mapError(error);
+		});
+		return this.modelListPromise;
+	}
+	async getCapabilities() {
+		return { ...OLLAMA_CAPABILITIES };
+	}
+	async synthesizeSpeech(_text, _options) {
+		throw new AIError("TTS is not supported by the Ollama provider.", "NOT_IMPLEMENTED", "ollama");
+	}
+	streamSpeech(_text, _options) {
+		const error = new AIError("TTS streaming is not supported by the Ollama provider.", "NOT_IMPLEMENTED", "ollama");
+		return { [Symbol.asyncIterator]: () => ({ next: () => Promise.reject(error) }) };
+	}
+	async cloneVoice(_options) {
+		throw new AIError("Voice cloning is not supported by the Ollama provider.", "NOT_IMPLEMENTED", "ollama");
+	}
+	async designVoice(_options) {
+		throw new AIError("Voice design is not supported by the Ollama provider.", "NOT_IMPLEMENTED", "ollama");
+	}
+	async getVoices(_options) {
+		throw new AIError("Voice listing is not supported by the Ollama provider.", "NOT_IMPLEMENTED", "ollama");
+	}
+};
+//#endregion
+export { OllamaProvider };
+
+//# sourceMappingURL=ollama-D4ksOTO8.js.map