ai-sdk-ollama 0.1.0

package/dist/index.cjs

@@ -0,0 +1,991 @@
+'use strict';
+
+var provider = require('@ai-sdk/provider');
+var ollama$1 = require('ollama');
+
+// src/provider.ts
+
+// src/utils/convert-to-ollama-messages.ts
+function convertToOllamaChatMessages(prompt) {
+  const messages = [];
+  for (const message of prompt) {
+    switch (message.role) {
+      case "system": {
+        messages.push({
+          role: "system",
+          content: message.content
+        });
+        break;
+      }
+      case "user": {
+        if (typeof message.content === "string") {
+          messages.push({
+            role: "user",
+            content: message.content
+          });
+        } else {
+          const textParts = message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+          const imageParts = message.content.filter(
+            (part) => part.type === "file"
+          ).filter((part) => part.mediaType.startsWith("image/")).map((part) => {
+            if (part.data instanceof URL) {
+              return part.data.href;
+            } else if (typeof part.data === "string") {
+              if (part.data.startsWith("data:")) {
+                const base64Match = part.data.match(/data:[^;]+;base64,(.+)/);
+                if (base64Match) {
+                  return base64Match[1];
+                }
+              }
+              return part.data;
+            } else if (part.data instanceof Uint8Array) {
+              return Buffer.from(part.data).toString("base64");
+            } else {
+              return String(part.data);
+            }
+          });
+          messages.push({
+            role: "user",
+            content: textParts,
+            images: imageParts.length > 0 ? imageParts.filter((img) => img !== void 0) : void 0
+          });
+        }
+        break;
+      }
+      case "assistant": {
+        let content = "";
+        if (typeof message.content === "string") {
+          content = message.content;
+        } else {
+          content = message.content.filter((part) => part.type === "text").map((part) => part.text).join("");
+          const toolCalls = message.content.filter(
+            (part) => part.type === "tool-call"
+          );
+          if (toolCalls.length > 0) {
+            const toolCallText = toolCalls.map((tc) => `[Tool Call: ${tc.toolName}]`).join("\n");
+            if (toolCallText) {
+              content = content ? `${content}
+${toolCallText}` : toolCallText;
+            }
+          }
+        }
+        messages.push({
+          role: "assistant",
+          content
+        });
+        break;
+      }
+      case "tool": {
+        messages.push({
+          role: "user",
+          content: `[Tool Result]`
+        });
+        break;
+      }
+      default: {
+        throw new Error(
+          `Unsupported message role: ${message.role}`
+        );
+      }
+    }
+  }
+  return messages;
+}
+
+// src/utils/map-ollama-finish-reason.ts
+function mapOllamaFinishReason(reason) {
+  if (!reason) return "unknown";
+  switch (reason) {
+    case "stop": {
+      return "stop";
+    }
+    case "length": {
+      return "length";
+    }
+    default: {
+      return "unknown";
+    }
+  }
+}
+
+// src/utils/ollama-error.ts
+var OllamaError = class _OllamaError extends Error {
+  cause;
+  constructor({ message, cause }) {
+    super(message);
+    this.name = "OllamaError";
+    this.cause = cause;
+  }
+  static isOllamaError(error) {
+    return error instanceof _OllamaError;
+  }
+};
+
+// src/utils/model-capabilities.ts
+var MODEL_CAPABILITIES = {
+  // Llama family
+  "llama3.2": {
+    supportsToolCalling: true,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 128e3,
+    recommendedFor: ["general", "coding", "reasoning"]
+  },
+  "llama3.2:1b": {
+    supportsToolCalling: true,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 128e3,
+    recommendedFor: ["lightweight", "edge"]
+  },
+  "llama3.2:3b": {
+    supportsToolCalling: true,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 128e3,
+    recommendedFor: ["balanced", "general"]
+  },
+  "llama3.2-vision": {
+    supportsToolCalling: true,
+    supportsVision: true,
+    supportsJsonMode: true,
+    contextWindow: 128e3,
+    recommendedFor: ["vision", "multimodal"]
+  },
+  "llama3.1": {
+    supportsToolCalling: true,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 128e3,
+    recommendedFor: ["general", "coding", "reasoning"]
+  },
+  "llama3.1:8b": {
+    supportsToolCalling: true,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 128e3,
+    recommendedFor: ["general", "balanced"]
+  },
+  "llama3.1:70b": {
+    supportsToolCalling: true,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 128e3,
+    recommendedFor: ["complex", "reasoning", "professional"]
+  },
+  "llama3.1:405b": {
+    supportsToolCalling: true,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 128e3,
+    recommendedFor: ["enterprise", "complex", "research"]
+  },
+  llama3: {
+    supportsToolCalling: false,
+    // Older Llama 3 doesn't support tools
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 8192,
+    recommendedFor: ["general", "legacy"]
+  },
+  llama2: {
+    supportsToolCalling: false,
+    supportsVision: false,
+    supportsJsonMode: false,
+    contextWindow: 4096,
+    recommendedFor: ["legacy"]
+  },
+  // Mistral family
+  mistral: {
+    supportsToolCalling: true,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 32768,
+    recommendedFor: ["general", "multilingual"]
+  },
+  "mistral-nemo": {
+    supportsToolCalling: true,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 128e3,
+    recommendedFor: ["general", "multilingual", "long-context"]
+  },
+  mixtral: {
+    supportsToolCalling: true,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 32768,
+    recommendedFor: ["complex", "reasoning", "multilingual"]
+  },
+  // Phi family
+  phi3: {
+    supportsToolCalling: false,
+    // Most Phi models don't support tools yet
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 128e3,
+    recommendedFor: ["lightweight", "mobile"]
+  },
+  "phi3.5": {
+    supportsToolCalling: false,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 128e3,
+    recommendedFor: ["lightweight", "mobile"]
+  },
+  "phi4-mini": {
+    supportsToolCalling: false,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 128e3,
+    recommendedFor: ["lightweight", "mobile", "edge"]
+  },
+  // Qwen family
+  "qwen2.5": {
+    supportsToolCalling: true,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 32768,
+    recommendedFor: ["general", "multilingual", "coding"]
+  },
+  "qwen2.5-coder": {
+    supportsToolCalling: true,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 32768,
+    recommendedFor: ["coding", "development"]
+  },
+  qwen2: {
+    supportsToolCalling: true,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 32768,
+    recommendedFor: ["general", "multilingual"]
+  },
+  // Gemma family
+  gemma2: {
+    supportsToolCalling: false,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 8192,
+    recommendedFor: ["general", "research"]
+  },
+  gemma: {
+    supportsToolCalling: false,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 8192,
+    recommendedFor: ["general", "research"]
+  },
+  // Vision models
+  llava: {
+    supportsToolCalling: false,
+    supportsVision: true,
+    supportsJsonMode: true,
+    contextWindow: 4096,
+    recommendedFor: ["vision", "image-analysis"]
+  },
+  "minicpm-v": {
+    supportsToolCalling: false,
+    supportsVision: true,
+    supportsJsonMode: true,
+    contextWindow: 8192,
+    recommendedFor: ["vision", "lightweight"]
+  },
+  bakllava: {
+    supportsToolCalling: false,
+    supportsVision: true,
+    supportsJsonMode: true,
+    contextWindow: 4096,
+    recommendedFor: ["vision", "image-analysis"]
+  },
+  // Coding models
+  codellama: {
+    supportsToolCalling: false,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 16384,
+    recommendedFor: ["coding", "development"]
+  },
+  "deepseek-coder": {
+    supportsToolCalling: false,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 16384,
+    recommendedFor: ["coding", "development"]
+  },
+  // Command-R family (Cohere)
+  "command-r": {
+    supportsToolCalling: true,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 128e3,
+    recommendedFor: ["enterprise", "rag", "reasoning"]
+  },
+  "command-r-plus": {
+    supportsToolCalling: true,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 128e3,
+    recommendedFor: ["enterprise", "complex", "rag"]
+  },
+  // Firefunction
+  "firefunction-v2": {
+    supportsToolCalling: true,
+    supportsVision: false,
+    supportsJsonMode: true,
+    contextWindow: 32768,
+    recommendedFor: ["tools", "function-calling"]
+  }
+};
+function getModelCapabilities(modelId) {
+  const normalizedId = normalizeModelId(modelId);
+  if (MODEL_CAPABILITIES[normalizedId]) {
+    return MODEL_CAPABILITIES[normalizedId];
+  }
+  const baseFamily = getModelFamily(normalizedId);
+  if (MODEL_CAPABILITIES[baseFamily]) {
+    return MODEL_CAPABILITIES[baseFamily];
+  }
+  return {
+    supportsToolCalling: false,
+    supportsVision: false,
+    supportsJsonMode: false,
+    contextWindow: 4096,
+    recommendedFor: ["unknown"]
+  };
+}
+function normalizeModelId(modelId) {
+  return modelId.toLowerCase().replace(/^ollama\//, "").replace(/:latest$/, "").replace(/-instruct$/, "").replace(/-chat$/, "");
+}
+function getModelFamily(modelId) {
+  const normalized = normalizeModelId(modelId);
+  if (normalized.includes("llama3.2")) return "llama3.2";
+  if (normalized.includes("llama3.1")) return "llama3.1";
+  if (normalized.includes("llama3")) return "llama3";
+  if (normalized.includes("llama2")) return "llama2";
+  if (normalized.includes("mistral")) return "mistral";
+  if (normalized.includes("mixtral")) return "mixtral";
+  if (normalized.includes("phi4")) return "phi4-mini";
+  if (normalized.includes("phi3.5")) return "phi3.5";
+  if (normalized.includes("phi3")) return "phi3";
+  if (normalized.includes("qwen2.5")) return "qwen2.5";
+  if (normalized.includes("qwen2")) return "qwen2";
+  if (normalized.includes("gemma2")) return "gemma2";
+  if (normalized.includes("gemma")) return "gemma";
+  if (normalized.includes("command-r-plus")) return "command-r-plus";
+  if (normalized.includes("command-r")) return "command-r";
+  if (normalized.includes("firefunction")) return "firefunction-v2";
+  if (normalized.includes("codellama")) return "codellama";
+  if (normalized.includes("deepseek")) return "deepseek-coder";
+  if (normalized.includes("llava")) return "llava";
+  if (normalized.includes("minicpm")) return "minicpm-v";
+  if (normalized.includes("bakllava")) return "bakllava";
+  return normalized;
+}
+function modelSupports(modelId, feature) {
+  const capabilities = getModelCapabilities(modelId);
+  return Boolean(capabilities[feature]);
+}
+function getModelInfo(modelId) {
+  const capabilities = getModelCapabilities(modelId);
+  const normalized = normalizeModelId(modelId);
+  return {
+    modelId: normalized,
+    capabilities,
+    isSupported: capabilities.recommendedFor[0] !== "unknown"
+  };
+}
+
+// src/models/chat-language-model.ts
+var OllamaChatLanguageModel = class {
+  constructor(modelId, settings, config) {
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+  }
+  specificationVersion = "v2";
+  defaultObjectGenerationMode = "json";
+  supportsImages = false;
+  supportsVideoURLs = false;
+  supportsAudioURLs = false;
+  supportsVideoFile = false;
+  supportsAudioFile = false;
+  supportsImageFile = true;
+  supportedUrls = {};
+  get provider() {
+    return this.config.provider;
+  }
+  get supportsStructuredOutputs() {
+    return this.settings.structuredOutputs ?? false;
+  }
+  getCallOptions(options) {
+    const {
+      prompt,
+      temperature,
+      maxOutputTokens,
+      topP,
+      topK,
+      frequencyPenalty,
+      presencePenalty,
+      stopSequences,
+      seed,
+      responseFormat,
+      tools
+    } = options;
+    const warnings = [];
+    if (tools && tools.length > 0 && !modelSupports(this.modelId, "supportsToolCalling")) {
+      throw new Error(
+        `Model '${this.modelId}' does not support tool calling. Consider using models like llama3.2, llama3.1, mistral, qwen2.5, or command-r for tool calling features.`
+      );
+    }
+    if (responseFormat?.type === "json" && responseFormat.schema && !this.supportsStructuredOutputs) {
+      throw new Error(
+        "JSON schema is only supported when structuredOutputs is enabled"
+      );
+    }
+    if (responseFormat?.type === "json" && !modelSupports(this.modelId, "supportsJsonMode")) {
+      throw new Error(
+        `Model '${this.modelId}' does not support JSON mode. Consider using models like llama3.2, mistral, or qwen2.5 for structured output support.`
+      );
+    }
+    const ollamaTools = tools ? tools.map((tool) => {
+      if (tool.type === "function") {
+        return {
+          type: "function",
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.inputSchema
+            // Ollama expects a specific schema format
+          }
+        };
+      }
+      throw new Error(
+        `Provider-defined tools are not supported by Ollama. Use function tools instead.`
+      );
+    }) : void 0;
+    const ollamaOptions = {
+      // Start with AI SDK parameters mapped to Ollama names
+      ...temperature !== void 0 && { temperature },
+      ...maxOutputTokens !== void 0 && { num_predict: maxOutputTokens },
+      ...topP !== void 0 && { top_p: topP },
+      ...topK !== void 0 && { top_k: topK },
+      ...frequencyPenalty !== void 0 && {
+        frequency_penalty: frequencyPenalty
+      },
+      ...presencePenalty !== void 0 && {
+        presence_penalty: presencePenalty
+      },
+      ...stopSequences !== void 0 && { stop: stopSequences },
+      ...seed !== void 0 && { seed },
+      // Ollama model options override AI SDK parameters
+      ...this.settings.options
+    };
+    for (const key of Object.keys(ollamaOptions)) {
+      if (ollamaOptions[key] === void 0) {
+        delete ollamaOptions[key];
+      }
+    }
+    let format;
+    if (responseFormat?.type === "json") {
+      format = "json";
+    }
+    const messages = convertToOllamaChatMessages(prompt);
+    return {
+      messages,
+      options: ollamaOptions,
+      format,
+      tools: ollamaTools,
+      warnings
+    };
+  }
+  async doGenerate(options) {
+    const {
+      messages,
+      options: ollamaOptions,
+      format,
+      tools,
+      warnings
+    } = this.getCallOptions(options);
+    try {
+      const response = await this.config.client.chat({
+        model: this.modelId,
+        messages,
+        options: ollamaOptions,
+        format,
+        tools,
+        stream: false
+      });
+      const text = response.message.content;
+      const toolCalls = response.message.tool_calls;
+      const content = [];
+      if (text) {
+        content.push({ type: "text", text });
+      }
+      if (toolCalls && toolCalls.length > 0) {
+        for (const toolCall of toolCalls) {
+          content.push({
+            type: "tool-call",
+            toolCallId: crypto.randomUUID(),
+            // Ollama doesn't provide IDs
+            toolName: toolCall.function.name,
+            input: JSON.stringify(toolCall.function.arguments || {})
+          });
+        }
+      }
+      return {
+        content,
+        finishReason: mapOllamaFinishReason(
+          response.done_reason
+        ),
+        usage: {
+          inputTokens: response.prompt_eval_count || 0,
+          outputTokens: response.eval_count || 0,
+          totalTokens: (response.prompt_eval_count || 0) + (response.eval_count || 0)
+        },
+        providerMetadata: {
+          ollama: {
+            model: response.model,
+            created_at: response.created_at ? new Date(response.created_at).toISOString() : void 0,
+            total_duration: response.total_duration,
+            load_duration: response.load_duration,
+            eval_duration: response.eval_duration
+          }
+        },
+        request: {
+          body: JSON.stringify({
+            model: this.modelId,
+            messages,
+            options: ollamaOptions,
+            format,
+            tools
+          })
+        },
+        response: {
+          timestamp: /* @__PURE__ */ new Date(),
+          modelId: this.modelId
+        },
+        warnings
+      };
+    } catch (error) {
+      throw new OllamaError({
+        message: error instanceof Error ? error.message : String(error),
+        cause: error
+      });
+    }
+  }
+  async doStream(options) {
+    const {
+      messages,
+      options: ollamaOptions,
+      format,
+      tools,
+      warnings
+    } = this.getCallOptions(options);
+    try {
+      const stream = await this.config.client.chat({
+        model: this.modelId,
+        messages,
+        options: ollamaOptions,
+        format,
+        tools,
+        stream: true
+      });
+      let usage = {
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0
+      };
+      let finishReason = "unknown";
+      const transformStream = new TransformStream({
+        async transform(chunk, controller) {
+          if (chunk.done) {
+            usage = {
+              inputTokens: chunk.prompt_eval_count || 0,
+              outputTokens: chunk.eval_count || 0,
+              totalTokens: (chunk.prompt_eval_count || 0) + (chunk.eval_count || 0)
+            };
+            finishReason = mapOllamaFinishReason(
+              chunk.done_reason
+            );
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              usage
+            });
+          } else {
+            if (chunk.message.tool_calls && chunk.message.tool_calls.length > 0) {
+              for (const toolCall of chunk.message.tool_calls) {
+                controller.enqueue({
+                  type: "tool-call",
+                  toolCallId: crypto.randomUUID(),
+                  // Ollama doesn't provide IDs
+                  toolName: toolCall.function.name,
+                  input: JSON.stringify(toolCall.function.arguments || {})
+                });
+              }
+            } else if (chunk.message.content) {
+              controller.enqueue({
+                type: "text-delta",
+                id: crypto.randomUUID(),
+                // Generate unique ID for each text chunk
+                delta: chunk.message.content
+              });
+            }
+          }
+        }
+      });
+      const readableStream = new ReadableStream({
+        async start(controller) {
+          try {
+            for await (const chunk of stream) {
+              controller.enqueue(chunk);
+            }
+            controller.close();
+          } catch (error) {
+            controller.error(error);
+          }
+        }
+      });
+      return {
+        stream: readableStream.pipeThrough(transformStream),
+        rawCall: {
+          rawPrompt: messages,
+          rawSettings: {
+            model: this.modelId,
+            options: ollamaOptions,
+            format,
+            tools
+          }
+        },
+        warnings: warnings.length > 0 ? warnings : void 0
+      };
+    } catch (error) {
+      throw new OllamaError({
+        message: error instanceof Error ? error.message : String(error),
+        cause: error
+      });
+    }
+  }
+};
+
+// src/models/embedding-model.ts
+var OllamaEmbeddingModel = class {
+  constructor(modelId, settings, config) {
+    this.settings = settings;
+    this.config = config;
+    this.modelId = modelId;
+  }
+  specificationVersion = "v2";
+  modelId;
+  maxEmbeddingsPerCall = 2048;
+  supportsParallelCalls = true;
+  get provider() {
+    return this.config.provider;
+  }
+  async doEmbed(params) {
+    const { values, abortSignal } = params;
+    if (values.length > this.maxEmbeddingsPerCall) {
+      throw new OllamaError({
+        message: `Too many values to embed. Maximum: ${this.maxEmbeddingsPerCall}, Received: ${values.length}`
+      });
+    }
+    if (values.length === 0) {
+      return { embeddings: [] };
+    }
+    try {
+      const embeddings = [];
+      for (const value of values) {
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        const response = await this.config.client.embed({
+          model: this.modelId,
+          input: value,
+          options: this.settings.options
+        });
+        if (!response.embeddings) {
+          throw new OllamaError({
+            message: `No embeddings field in response`
+          });
+        }
+        if (response.embeddings.length === 0) {
+          throw new OllamaError({
+            message: `Empty embeddings array returned`
+          });
+        }
+        embeddings.push(response.embeddings[0]);
+        if (abortSignal?.aborted) {
+          throw new Error("Embedding generation aborted");
+        }
+      }
+      if (embeddings.length === 0) {
+        throw new OllamaError({
+          message: `No valid values provided for embedding (all were undefined/null)`
+        });
+      }
+      return {
+        embeddings
+      };
+    } catch (error) {
+      if (error instanceof OllamaError) {
+        throw error;
+      }
+      throw new OllamaError({
+        message: error instanceof Error ? error.message : String(error),
+        cause: error
+      });
+    }
+  }
+};
+
+// src/utils/model-suggestions.ts
+function suggestModelsForFeatures(requirements) {
+  const suggestions = [];
+  if (requirements.toolCalling) {
+    suggestions.push(
+      {
+        modelId: "llama3.2",
+        reason: "Excellent tool calling support with good general performance",
+        capabilities: getModelCapabilities("llama3.2")
+      },
+      {
+        modelId: "llama3.1:8b",
+        reason: "Strong tool calling with larger model for complex tasks",
+        capabilities: getModelCapabilities("llama3.1:8b")
+      },
+      {
+        modelId: "mistral",
+        reason: "Fast tool calling with multilingual support",
+        capabilities: getModelCapabilities("mistral")
+      },
+      {
+        modelId: "qwen2.5",
+        reason: "Excellent coding and tool calling capabilities",
+        capabilities: getModelCapabilities("qwen2.5")
+      }
+    );
+  }
+  if (requirements.vision) {
+    suggestions.push(
+      {
+        modelId: "llama3.2-vision",
+        reason: "Best vision model with tool calling support",
+        capabilities: getModelCapabilities("llama3.2-vision")
+      },
+      {
+        modelId: "llava",
+        reason: "Specialized vision model for image analysis",
+        capabilities: getModelCapabilities("llava")
+      },
+      {
+        modelId: "minicpm-v",
+        reason: "Lightweight vision model for edge deployments",
+        capabilities: getModelCapabilities("minicpm-v")
+      }
+    );
+  }
+  if (requirements.performance === "fast") {
+    suggestions.push(
+      {
+        modelId: "llama3.2:1b",
+        reason: "Fastest model with modern features",
+        capabilities: getModelCapabilities("llama3.2:1b")
+      },
+      {
+        modelId: "phi4-mini",
+        reason: "Optimized for speed and low resource usage",
+        capabilities: getModelCapabilities("phi4-mini")
+      }
+    );
+  } else if (requirements.performance === "quality") {
+    suggestions.push(
+      {
+        modelId: "llama3.1:70b",
+        reason: "Highest quality responses for complex tasks",
+        capabilities: getModelCapabilities("llama3.1:70b")
+      },
+      {
+        modelId: "mixtral",
+        reason: "Excellent reasoning and multilingual capabilities",
+        capabilities: getModelCapabilities("mixtral")
+      }
+    );
+  }
+  if (requirements.contextSize === "large") {
+    suggestions.push(
+      {
+        modelId: "llama3.2",
+        reason: "128K context window for long documents",
+        capabilities: getModelCapabilities("llama3.2")
+      },
+      {
+        modelId: "mistral-nemo",
+        reason: "128K context with excellent multilingual support",
+        capabilities: getModelCapabilities("mistral-nemo")
+      }
+    );
+  }
+  const uniqueSuggestions = suggestions.filter(
+    (suggestion, index, array) => array.findIndex((s) => s.modelId === suggestion.modelId) === index
+  );
+  return uniqueSuggestions.filter((suggestion) => {
+    if (requirements.toolCalling && !suggestion.capabilities.supportsToolCalling) {
+      return false;
+    }
+    if (requirements.vision && !suggestion.capabilities.supportsVision) {
+      return false;
+    }
+    if (requirements.jsonMode && !suggestion.capabilities.supportsJsonMode) {
+      return false;
+    }
+    return true;
+  });
+}
+function getFeatureNotSupportedMessage(modelId, feature) {
+  const suggestions = suggestModelsForFeatures({ [feature]: true });
+  const topSuggestions = suggestions.slice(0, 3);
+  const featureNames = {
+    toolCalling: "tool calling",
+    vision: "vision/image analysis",
+    jsonMode: "JSON mode"
+  };
+  let message = `Model '${modelId}' does not support ${featureNames[feature]}.`;
+  if (topSuggestions.length > 0) {
+    message += `
+
+Recommended models for ${featureNames[feature]}:`;
+    for (const suggestion of topSuggestions) {
+      message += `
+\u2022 ${suggestion.modelId} - ${suggestion.reason}`;
+    }
+  }
+  return message;
+}
+function validateModelConfiguration(modelId, options) {
+  const capabilities = getModelCapabilities(modelId);
+  const issues = [];
+  const suggestions = [];
+  if (options.hasTools && !capabilities.supportsToolCalling) {
+    issues.push(`Tool calling not supported by '${modelId}'`);
+    const toolModels = suggestModelsForFeatures({ toolCalling: true }).slice(
+      0,
+      2
+    );
+    suggestions.push(
+      `For tool calling, consider: ${toolModels.map((m) => m.modelId).join(", ")}`
+    );
+  }
+  if (options.hasImages && !capabilities.supportsVision) {
+    issues.push(`Vision/image analysis not supported by '${modelId}'`);
+    const visionModels = suggestModelsForFeatures({ vision: true }).slice(0, 2);
+    suggestions.push(
+      `For vision tasks, consider: ${visionModels.map((m) => m.modelId).join(", ")}`
+    );
+  }
+  if (options.needsJsonMode && !capabilities.supportsJsonMode) {
+    issues.push(`JSON mode may not work reliably with '${modelId}'`);
+    const jsonModels = suggestModelsForFeatures({ jsonMode: true }).slice(0, 2);
+    suggestions.push(
+      `For structured output, consider: ${jsonModels.map((m) => m.modelId).join(", ")}`
+    );
+  }
+  if (options.expectedTokens && options.expectedTokens > capabilities.contextWindow) {
+    issues.push(
+      `Expected tokens (${options.expectedTokens}) exceed model context window (${capabilities.contextWindow})`
+    );
+    const largeContextModels = suggestModelsForFeatures({
+      contextSize: "large"
+    }).slice(0, 2);
+    suggestions.push(
+      `For large context, consider: ${largeContextModels.map((m) => m.modelId).join(", ")}`
+    );
+  }
+  return {
+    isValid: issues.length === 0,
+    issues,
+    suggestions,
+    capabilities
+  };
+}
+
+// src/utils/validate-model.ts
+function validateModel(modelId, context) {
+  const validation = validateModelConfiguration(modelId, context || {});
+  return validation;
+}
+function getModelStatus(modelId) {
+  const capabilities = getModelCapabilities(modelId);
+  const status = {
+    isKnown: capabilities.recommendedFor[0] !== "unknown",
+    features: {
+      toolCalling: capabilities.supportsToolCalling,
+      vision: capabilities.supportsVision,
+      jsonMode: capabilities.supportsJsonMode
+    },
+    contextWindow: capabilities.contextWindow,
+    recommendedFor: capabilities.recommendedFor,
+    isLegacy: capabilities.recommendedFor.includes("legacy")
+  };
+  return status;
+}
+
+// src/provider.ts
+function createOllama(options = {}) {
+  const client = new ollama$1.Ollama({
+    host: options.baseURL,
+    fetch: options.fetch,
+    headers: options.headers
+  });
+  const createChatModel = (modelId, settings = {}) => {
+    validateModel(modelId);
+    return new OllamaChatLanguageModel(modelId, settings, {
+      client,
+      provider: "ollama"
+    });
+  };
+  const createEmbeddingModel = (modelId, settings = {}) => {
+    return new OllamaEmbeddingModel(modelId, settings, {
+      client,
+      provider: "ollama"
+    });
+  };
+  const provider$1 = function(modelId, settings) {
+    if (new.target) {
+      throw new Error(
+        "The Ollama provider cannot be called with the new keyword."
+      );
+    }
+    return createChatModel(modelId, settings);
+  };
+  provider$1.chat = createChatModel;
+  provider$1.languageModel = createChatModel;
+  provider$1.embedding = createEmbeddingModel;
+  provider$1.textEmbedding = createEmbeddingModel;
+  provider$1.textEmbeddingModel = createEmbeddingModel;
+  provider$1.imageModel = (modelId) => {
+    throw new provider.NoSuchModelError({
+      modelId,
+      modelType: "imageModel",
+      message: "Image generation is not supported by Ollama"
+    });
+  };
+  return provider$1;
+}
+var ollama = createOllama();
+
+exports.OllamaChatLanguageModel = OllamaChatLanguageModel;
+exports.OllamaEmbeddingModel = OllamaEmbeddingModel;
+exports.OllamaError = OllamaError;
+exports.createOllama = createOllama;
+exports.getFeatureNotSupportedMessage = getFeatureNotSupportedMessage;
+exports.getModelCapabilities = getModelCapabilities;
+exports.getModelInfo = getModelInfo;
+exports.getModelStatus = getModelStatus;
+exports.modelSupports = modelSupports;
+exports.ollama = ollama;
+exports.suggestModelsForFeatures = suggestModelsForFeatures;
+exports.validateModel = validateModel;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map