feat(plugins): Ollama support (mpfaffenberger#352)

* Add Ollama model type handler for OpenAI integration

* Add docstring to Ollama plugin initialization

Adds docstring for the Ollama plugin.

* Implement tests for Ollama plugin model handler

Add unit tests for the Ollama plugin model type handler, covering various scenarios including custom endpoints, environment variables, and model creation.

Author: Dialvive

code_puppy/plugins/ollama/__init__.py

@@ -0,0 +1 @@
+"""Ollama plugin — registers the 'ollama' model type for local OpenAI Chat Completions-compatible endpoints."""

code_puppy/plugins/ollama/register_callbacks.py

@@ -0,0 +1,127 @@
+"""Ollama model type handler for OpenAI Chat Completions-compatible endpoints.
+
+Registers the 'ollama' model type so users can connect Code Puppy to local
+inference servers (Ollama, LM Studio, vLLM, llama.cpp, etc.) via
+~/.code_puppy/extra_models.json.
+
+Minimal config (Ollama on localhost with defaults):
+{
+    "ollama-qwen3": {
+        "type": "ollama",
+        "name": "qwen3:30b",
+        "context_length": 131072
+    }
+}
+
+Full config (remote server, same custom_endpoint format as custom_openai):
+{
+    "lmstudio-codellama": {
+        "type": "ollama",
+        "name": "codellama:34b",
+        "context_length": 16384,
+        "custom_endpoint": {
+            "url": "http://192.168.1.50:1234/v1",
+            "api_key": "$LM_STUDIO_KEY"
+        }
+    }
+}
+
+Note: Code Puppy requires models with strong tool/function calling support.
+Models without tool calling will notwork properly.
+"""
+
+import logging
+import os
+from typing import Any
+
+from pydantic_ai.models.openai import OpenAIChatModel
+from pydantic_ai.providers.openai import OpenAIProvider
+
+from code_puppy.callbacks import register_callback
+from code_puppy.http_utils import create_async_client
+from code_puppy.model_factory import get_custom_config
+
+logger = logging.getLogger(__name__)
+
+# Ollama defaults
+_DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434/v1"
+_DEFAULT_OLLAMA_API_KEY = "ollama"
+
+
+def create_ollama_model(
+    model_name: str,
+    model_config: dict[str, Any],
+    config: dict[str, Any],
+) -> OpenAIChatModel | None:
+    """Create a model for an OpenAI Chat Completions-compatible endpoint.
+
+    When ``custom_endpoint`` is present in *model_config*, the standard
+    ``get_custom_config()`` helper is used (same path as ``custom_openai``
+    and ``codex`` model types).
+
+    When ``custom_endpoint`` is absent, sensible Ollama defaults are applied:
+    - base URL from ``OLLAMA_HOST`` env var, or ``http://localhost:11434/v1``
+    - api_key ``"ollama"`` (required non-empty by OpenAIProvider, not validated by Ollama)
+
+    Args:
+        model_name: The config key name of the model.
+        model_config: The model's configuration dict.
+        config: The full models configuration (unused, kept for API compat).
+
+    Returns:
+        OpenAIChatModel instance, or None if creation fails.
+    """
+    try:
+        if "custom_endpoint" in model_config:
+            url, headers, verify, api_key = get_custom_config(model_config)
+        else:
+            # Derive base URL: OLLAMA_HOST env var → default
+            ollama_host = os.environ.get("OLLAMA_HOST", "").rstrip("/")
+            if ollama_host:
+                url = (
+                    ollama_host if ollama_host.endswith("/v1") else f"{ollama_host}/v1"
+                )
+            else:
+                url = _DEFAULT_OLLAMA_BASE_URL
+            headers = {}
+            verify = None
+            api_key = _DEFAULT_OLLAMA_API_KEY
+
+        client = create_async_client(headers=headers, verify=verify)
+
+        provider_args: dict[str, Any] = {
+            "base_url": url,
+            "http_client": client,
+        }
+        if api_key:
+            provider_args["api_key"] = api_key
+        else:
+            provider_args["api_key"] = _DEFAULT_OLLAMA_API_KEY
+
+        provider = OpenAIProvider(**provider_args)
+
+        actual_model_name = model_config.get("name", model_name)
+        model = OpenAIChatModel(actual_model_name, provider=provider)
+        model.provider = (
+            provider  # Expose for connection-pooling cleanup (project convention)
+        )
+
+        logger.info("Created ollama model: %s -> %s", actual_model_name, url)
+        return model
+
+    except Exception as e:
+        logger.error("Failed to create ollama model '%s': %s", model_name, e)
+        return None
+
+
+def _get_ollama_model_types():
+    """Return the ollama model type handler for the register_model_type hook."""
+    return [
+        {
+            "type": "ollama",
+            "handler": create_ollama_model,
+        },
+    ]
+
+
+register_callback("register_model_type", _get_ollama_model_types)

tests/plugins/test_ollama_plugin.py

@@ -0,0 +1,199 @@
+"""Tests for the Ollama plugin model type handler."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from pydantic_ai.models.openai import OpenAIChatModel, OpenAIResponsesModel
+
+from code_puppy.plugins.ollama.register_callbacks import (
+    _DEFAULT_OLLAMA_API_KEY,
+    _DEFAULT_OLLAMA_BASE_URL,
+    _get_ollama_model_types,
+    create_ollama_model,
+)
+
+MODULE = "code_puppy.plugins.ollama.register_callbacks"
+
+
+@pytest.fixture
+def mock_async_client():
+    with patch(f"{MODULE}.create_async_client") as mock:
+        mock.return_value = MagicMock()
+        yield mock
+
+
+@pytest.fixture
+def mock_get_custom_config():
+    with patch(f"{MODULE}.get_custom_config") as mock:
+        mock.return_value = (
+            "http://remote:8080/v1",
+            {"X-Key": "val"},
+            None,
+            "custom-key",
+        )
+        yield mock
+
+
+@pytest.fixture
+def mock_provider():
+    with patch(f"{MODULE}.OpenAIProvider") as mock:
+        mock.return_value = MagicMock()
+        yield mock
+
+
+def test_custom_endpoint_uses_get_custom_config(
+    mock_async_client, mock_get_custom_config, mock_provider
+):
+    model_config = {
+        "name": "codellama:34b",
+        "custom_endpoint": {
+            "url": "http://remote:8080/v1",
+            "api_key": "custom-key",
+        },
+    }
+    result = create_ollama_model("my-model", model_config, {})
+
+    mock_get_custom_config.assert_called_once_with(model_config)
+    assert isinstance(result, OpenAIChatModel)
+
+
+def test_no_custom_endpoint_defaults_to_localhost(
+    mock_async_client, mock_provider, monkeypatch
+):
+    monkeypatch.delenv("OLLAMA_HOST", raising=False)
+    model_config = {"name": "llama3:8b"}
+    result = create_ollama_model("my-model", model_config, {})
+
+    assert isinstance(result, OpenAIChatModel)
+    # Verify the client was created with empty headers and no verify
+    mock_async_client.assert_called_once_with(headers={}, verify=None)
+
+
+def test_ollama_host_env_appends_v1(mock_async_client, mock_provider, monkeypatch):
+    monkeypatch.setenv("OLLAMA_HOST", "http://myserver:11434")
+    model_config = {"name": "gpt3:30b"}
+    create_ollama_model("my-model", model_config, {})
+
+    # Check the provider was called with /v1 appended
+    call_kwargs = mock_provider.call_args[1]
+    assert call_kwargs["base_url"] == "http://myserver:11434/v1"
+
+
+def test_ollama_host_already_ends_with_v1(
+    mock_async_client, mock_provider, monkeypatch
+):
+    monkeypatch.setenv("OLLAMA_HOST", "http://myserver:11434/v1")
+    model_config = {"name": "gpt3:30b"}
+    create_ollama_model("my-model", model_config, {})
+
+    call_kwargs = mock_provider.call_args[1]
+    assert call_kwargs["base_url"] == "http://myserver:11434/v1"
+
+
+def test_ollama_host_trailing_slash_stripped(
+    mock_async_client, mock_provider, monkeypatch
+):
+    monkeypatch.setenv("OLLAMA_HOST", "http://myserver:11434/")
+    model_config = {"name": "gpt3:30b"}
+    create_ollama_model("my-model", model_config, {})
+
+    call_kwargs = mock_provider.call_args[1]
+    assert call_kwargs["base_url"] == "http://myserver:11434/v1"
+
+
+def test_ollama_host_empty_string_uses_default(
+    mock_async_client, mock_provider, monkeypatch
+):
+    monkeypatch.setenv("OLLAMA_HOST", "")
+    model_config = {"name": "llama3:8b"}
+    create_ollama_model("my-model", model_config, {})
+
+    call_kwargs = mock_provider.call_args[1]
+    assert call_kwargs["base_url"] == _DEFAULT_OLLAMA_BASE_URL
+
+
+def test_returns_open_ai_chat_model_not_responses(
+    mock_async_client, mock_provider, monkeypatch
+):
+    monkeypatch.delenv("OLLAMA_HOST", raising=False)
+    model_config = {"name": "llama3:8b"}
+    result = create_ollama_model("my-model", model_config, {})
+
+    assert isinstance(result, OpenAIChatModel)
+    assert not isinstance(result, OpenAIResponsesModel)
+
+
+def test_provider_is_set_on_model(mock_async_client, mock_provider, monkeypatch):
+    monkeypatch.delenv("OLLAMA_HOST", raising=False)
+    model_config = {"name": "llama3:8b"}
+    result = create_ollama_model("my-model", model_config, {})
+
+    assert result is not None
+    assert hasattr(result, "provider")
+    assert result.provider is not None
+
+
+def test_uses_model_config_name(mock_async_client, mock_provider, monkeypatch):
+    monkeypatch.delenv("OLLAMA_HOST", raising=False)
+    model_config = {"name": "gpt3:30b"}
+    result = create_ollama_model("config-key", model_config, {})
+
+    assert result is not None
+    assert result.model_name == "gpt3:30b"
+
+
+def test_falls_back_to_model_name_key(mock_async_client, mock_provider, monkeypatch):
+    monkeypatch.delenv("OLLAMA_HOST", raising=False)
+    model_config = {}  # No "name" key
+    result = create_ollama_model("fallback-name", model_config, {})
+
+    assert result is not None
+    assert result.model_name == "fallback-name"
+
+
+def test_returns_none_on_exception(monkeypatch):
+    monkeypatch.delenv("OLLAMA_HOST", raising=False)
+    model_config = {
+        "name": "test",
+        "custom_endpoint": {"url": "http://x", "api_key": "k"},
+    }
+    with patch(f"{MODULE}.get_custom_config", side_effect=RuntimeError("boom")):
+        result = create_ollama_model("bad-model", model_config, {})
+    assert result is None
+
+
+def test_get_ollama_model_types_structure():
+    result = _get_ollama_model_types()
+    assert isinstance(result, list)
+    assert len(result) == 1
+    entry = result[0]
+    assert entry["type"] == "ollama"
+    assert callable(entry["handler"])
+    assert entry["handler"] is create_ollama_model
+
+
+def test_api_key_defaults_to_ollama(mock_async_client, mock_provider, monkeypatch):
+    monkeypatch.delenv("OLLAMA_HOST", raising=False)
+    model_config = {"name": "llama3:8b"}
+    create_ollama_model("my-model", model_config, {})
+
+    call_kwargs = mock_provider.call_args[1]
+    assert call_kwargs["api_key"] == _DEFAULT_OLLAMA_API_KEY
+
+
+def test_api_key_fallback_when_custom_returns_none(mock_async_client, mock_provider):
+    with patch(f"{MODULE}.get_custom_config") as mock_gcc:
+        mock_gcc.return_value = ("http://x/v1", {}, None, None)
+        create_ollama_model(
+            "m",
+            {"name": "t", "custom_endpoint": {"url": "http://x/v1"}},
+            {},
+        )
+
+    call_kwargs = mock_provider.call_args[1]
+    assert call_kwargs["api_key"] == _DEFAULT_OLLAMA_API_KEY
+
+
+def test_default_constants():
+    assert _DEFAULT_OLLAMA_BASE_URL == "http://localhost:11434/v1"
+    assert _DEFAULT_OLLAMA_API_KEY == "ollama"