kodit 0.3.14__tar.gz → 0.3.16__tar.gz

{kodit-0.3.14 → kodit-0.3.16}/CLAUDE.md

@@ -76,10 +76,9 @@ The codebase follows Domain-Driven Design (DDD) with clean architecture:
 
 Key environment variables:
 
-- `KODIT_EMBEDDING_PROVIDER` - embedding provider (local/openai)
-- `KODIT_DATABASE_URL` - database connection string
-- `KODIT_OPENAI_API_KEY` - for OpenAI embeddings
-- `KODIT_LOG_LEVEL` - logging level
+- `DB_URL` - database connection string
+- `LOG_LEVEL` - logging level
+- `DEFAULT_SEARCH_PROVIDER` - deciding whether to use vectorchord or sqlite
 
 See `config.py` for full configuration options.
 

{kodit-0.3.14 → kodit-0.3.16}/Makefile

@@ -1,7 +1,10 @@
 # Makefile for Kodit
 
 # Generate OpenAPI json schema from the FastAPI app
-openapi:
+build:
+	uv build
+
+openapi: build
 	uv run src/kodit/utils/dump_openapi.py --out docs/reference/api/ kodit.app:app
 
 openapi-check: openapi

{kodit-0.3.14 → kodit-0.3.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.3.14
+Version: 0.3.16
 Summary: Code indexing for better AI code generation
 Project-URL: Homepage, https://docs.helixml.tech/kodit/
 Project-URL: Documentation, https://docs.helixml.tech/kodit/

{kodit-0.3.14 → kodit-0.3.16}/docs/reference/api/index.md

@@ -12,7 +12,7 @@ look at the [hosted version](https://kodit.helix.ml/docs).
 This is the REST API for the Kodit server. Please refer to the
 [Kodit documentation](https://docs.helix.ml/kodit/) for more information.
     
-Current version: 0.3.14
+Current version: 0.3.16
 
 ## Authentication
 

{kodit-0.3.14 → kodit-0.3.16}/docs/reference/api/openapi.json

@@ -3,7 +3,7 @@
   "info": {
     "title": "kodit API",
     "description": "\nThis is the REST API for the Kodit server. Please refer to the\n[Kodit documentation](https://docs.helix.ml/kodit/) for more information.\n    ",
-    "version": "0.3.14"
+    "version": "0.3.16"
   },
   "paths": {
     "/healthz": {

{kodit-0.3.14 → kodit-0.3.16}/src/kodit/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.14'
-__version_tuple__ = version_tuple = (0, 3, 14)
+__version__ = version = '0.3.16'
+__version_tuple__ = version_tuple = (0, 3, 16)
+
+__commit_id__ = commit_id = None

{kodit-0.3.14 → kodit-0.3.16}/src/kodit/application/services/code_indexing_application_service.py

@@ -241,27 +241,38 @@ class CodeIndexingApplicationService:
             [x.id for x in final_results]
         )
 
+        # Create a mapping from snippet ID to search result to handle cases where
+        # some snippet IDs don't exist (e.g., with vectorchord inconsistencies)
+        snippet_map = {
+            result.snippet.id: result
+            for result in search_results
+            if result.snippet.id is not None
+        }
+
+        # Filter final_results to only include IDs that we actually found snippets for
+        valid_final_results = [fr for fr in final_results if fr.id in snippet_map]
+
         return [
             MultiSearchResult(
-                id=result.snippet.id or 0,
-                content=result.snippet.original_text(),
+                id=snippet_map[fr.id].snippet.id or 0,
+                content=snippet_map[fr.id].snippet.original_text(),
                 original_scores=fr.original_scores,
                 # Enhanced fields
-                source_uri=str(result.source.working_copy.remote_uri),
+                source_uri=str(snippet_map[fr.id].source.working_copy.remote_uri),
                 relative_path=str(
-                    result.file.as_path().relative_to(
-                        result.source.working_copy.cloned_path
-                    )
+                    snippet_map[fr.id]
+                    .file.as_path()
+                    .relative_to(snippet_map[fr.id].source.working_copy.cloned_path)
                 ),
                 language=MultiSearchResult.detect_language_from_extension(
-                    result.file.extension()
+                    snippet_map[fr.id].file.extension()
                 ),
-                authors=[author.name for author in result.authors],
-                created_at=result.snippet.created_at or datetime.now(UTC),
+                authors=[author.name for author in snippet_map[fr.id].authors],
+                created_at=snippet_map[fr.id].snippet.created_at or datetime.now(UTC),
                 # Summary from snippet entity
-                summary=result.snippet.summary_text(),
+                summary=snippet_map[fr.id].snippet.summary_text(),
             )
-            for result, fr in zip(search_results, final_results, strict=True)
+            for fr in valid_final_results
         ]
 
     async def list_snippets(

{kodit-0.3.14 → kodit-0.3.16}/src/kodit/config.py

@@ -49,6 +49,14 @@ class Endpoint(BaseModel):
     model: str | None = None
     api_key: str | None = None
     num_parallel_tasks: int | None = None
+    socket_path: str | None = Field(
+        default=None,
+        description="Unix socket path for local communication (e.g., /tmp/openai.sock)",
+    )
+    timeout: float | None = Field(
+        default=None,
+        description="Request timeout in seconds (default: 30.0)",
+    )
 
 
 class Search(BaseModel):

{kodit-0.3.14 → kodit-0.3.16}/src/kodit/infrastructure/embedding/embedding_factory.py

@@ -1,6 +1,5 @@
 """Factory for creating embedding services with DDD architecture."""
 
-from openai import AsyncOpenAI
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from kodit.config import AppContext, Endpoint
@@ -48,15 +47,14 @@ def embedding_domain_service_factory(
     endpoint = _get_endpoint_configuration(app_context)
     if endpoint and endpoint.type == "openai":
         log_event("kodit.embedding", {"provider": "openai"})
+        # Use new httpx-based provider with socket support
         embedding_provider = OpenAIEmbeddingProvider(
-            openai_client=AsyncOpenAI(
-                api_key=endpoint.api_key or "default",
-                base_url=endpoint.base_url or "https://api.openai.com/v1",
-                timeout=10,
-                max_retries=2,
-            ),
+            api_key=endpoint.api_key,
+            base_url=endpoint.base_url or "https://api.openai.com/v1",
             model_name=endpoint.model or "text-embedding-3-small",
             num_parallel_tasks=endpoint.num_parallel_tasks or OPENAI_NUM_PARALLEL_TASKS,
+            socket_path=endpoint.socket_path,
+            timeout=endpoint.timeout or 30.0,
         )
     else:
         log_event("kodit.embedding", {"provider": "local"})

{kodit-0.3.14 → kodit-0.3.16}/src/kodit/infrastructure/embedding/embedding_providers/openai_embedding_provider.py

@@ -1,11 +1,12 @@
-"""OpenAI embedding provider implementation."""
+"""OpenAI embedding provider implementation using httpx."""
 
 import asyncio
 from collections.abc import AsyncGenerator
+from typing import Any
 
+import httpx
 import structlog
 import tiktoken
-from openai import AsyncOpenAI
 from tiktoken import Encoding
 
 from kodit.domain.services.embedding_service import EmbeddingProvider
@@ -22,29 +23,53 @@ OPENAI_NUM_PARALLEL_TASKS = 10  # Semaphore limit for concurrent OpenAI requests
 
 
 class OpenAIEmbeddingProvider(EmbeddingProvider):
-    """OpenAI embedding provider that uses OpenAI's embedding API."""
+    """OpenAI embedding provider that uses OpenAI's embedding API via httpx."""
 
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
-        openai_client: AsyncOpenAI,
+        api_key: str | None = None,
+        base_url: str = "https://api.openai.com",
         model_name: str = "text-embedding-3-small",
         num_parallel_tasks: int = OPENAI_NUM_PARALLEL_TASKS,
+        socket_path: str | None = None,
+        timeout: float = 30.0,
     ) -> None:
         """Initialize the OpenAI embedding provider.
 
         Args:
-            openai_client: The OpenAI client instance
-            model_name: The model name to use for embeddings
+            api_key: The OpenAI API key.
+            base_url: The base URL for the OpenAI API.
+            model_name: The model name to use for embeddings.
+            num_parallel_tasks: Maximum number of concurrent requests.
+            socket_path: Optional Unix socket path for local communication.
+            timeout: Request timeout in seconds.
 
         """
-        self.openai_client = openai_client
         self.model_name = model_name
         self.num_parallel_tasks = num_parallel_tasks
         self.log = structlog.get_logger(__name__)
+        self.api_key = api_key
+        self.base_url = base_url
+        self.socket_path = socket_path
+        self.timeout = timeout
 
         # Lazily initialised token encoding
         self._encoding: Encoding | None = None
 
+        # Create httpx client with optional Unix socket support
+        if socket_path:
+            transport = httpx.AsyncHTTPTransport(uds=socket_path)
+            self.http_client = httpx.AsyncClient(
+                transport=transport,
+                base_url="http://localhost",  # Base URL for Unix socket
+                timeout=timeout,
+            )
+        else:
+            self.http_client = httpx.AsyncClient(
+                base_url=base_url,
+                timeout=timeout,
+            )
+
     # ---------------------------------------------------------------------
     # Helper utilities
     # ---------------------------------------------------------------------
@@ -52,7 +77,17 @@ class OpenAIEmbeddingProvider(EmbeddingProvider):
     def _get_encoding(self) -> "Encoding":
         """Return (and cache) the tiktoken encoding for the chosen model."""
         if self._encoding is None:
-            self._encoding = tiktoken.encoding_for_model(self.model_name)
+            try:
+                self._encoding = tiktoken.encoding_for_model(self.model_name)
+            except KeyError:
+                # If the model is not supported by tiktoken, use a default encoding
+                self.log.info(
+                    "Model not supported by tiktoken, using default encoding",
+                    model_name=self.model_name,
+                    default_encoding="o200k_base",
+                )
+                self._encoding = tiktoken.get_encoding("o200k_base")
+
         return self._encoding
 
     def _split_sub_batches(
@@ -66,6 +101,37 @@ class OpenAIEmbeddingProvider(EmbeddingProvider):
             batch_size=BATCH_SIZE,
         )
 
+    async def _call_embeddings_api(
+        self, texts: list[str]
+    ) -> dict[str, Any]:
+        """Call the embeddings API using httpx.
+
+        Args:
+            texts: The texts to embed.
+
+        Returns:
+            The API response as a dictionary.
+
+        """
+        headers = {
+            "Content-Type": "application/json",
+        }
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        data = {
+            "model": self.model_name,
+            "input": texts,
+        }
+
+        response = await self.http_client.post(
+            "/v1/embeddings",
+            json=data,
+            headers=headers,
+        )
+        response.raise_for_status()
+        return response.json()
+
     async def embed(
         self, data: list[EmbeddingRequest]
     ) -> AsyncGenerator[list[EmbeddingResponse], None]:
@@ -89,17 +155,17 @@ class OpenAIEmbeddingProvider(EmbeddingProvider):
         ) -> list[EmbeddingResponse]:
             async with sem:
                 try:
-                    response = await self.openai_client.embeddings.create(
-                        model=self.model_name,
-                        input=[item.text for item in batch],
+                    response = await self._call_embeddings_api(
+                        [item.text for item in batch]
                     )
+                    embeddings_data = response.get("data", [])
 
                     return [
                         EmbeddingResponse(
                             snippet_id=item.snippet_id,
-                            embedding=embedding.embedding,
+                            embedding=emb_data.get("embedding", []),
                         )
-                        for item, embedding in zip(batch, response.data, strict=True)
+                        for item, emb_data in zip(batch, embeddings_data, strict=True)
                     ]
                 except Exception as e:
                     self.log.exception("Error embedding batch", error=str(e))
@@ -109,3 +175,9 @@ class OpenAIEmbeddingProvider(EmbeddingProvider):
         tasks = [_process_batch(batch) for batch in batched_data]
         for task in asyncio.as_completed(tasks):
             yield await task
+
+    async def close(self) -> None:
+        """Close the HTTP client."""
+        if hasattr(self, "http_client"):
+            await self.http_client.aclose()
+

{kodit-0.3.14 → kodit-0.3.16}/src/kodit/infrastructure/enrichment/enrichment_factory.py

@@ -45,17 +45,14 @@ def enrichment_domain_service_factory(
     enrichment_provider: EnrichmentProvider | None = None
     if endpoint and endpoint.type == "openai":
         log_event("kodit.enrichment", {"provider": "openai"})
-        from openai import AsyncOpenAI
-
+        # Use new httpx-based provider with socket support
         enrichment_provider = OpenAIEnrichmentProvider(
-            openai_client=AsyncOpenAI(
-                api_key=endpoint.api_key or "default",
-                base_url=endpoint.base_url or "https://api.openai.com/v1",
-                timeout=60,
-                max_retries=2,
-            ),
+            api_key=endpoint.api_key,
+            base_url=endpoint.base_url or "https://api.openai.com/v1",
             model_name=endpoint.model or "gpt-4o-mini",
             num_parallel_tasks=endpoint.num_parallel_tasks or OPENAI_NUM_PARALLEL_TASKS,
+            socket_path=endpoint.socket_path,
+            timeout=endpoint.timeout or 30.0,
         )
     else:
         log_event("kodit.enrichment", {"provider": "local"})

kodit-0.3.16/src/kodit/infrastructure/enrichment/openai_enrichment_provider.py

@@ -0,0 +1,159 @@
+"""OpenAI enrichment provider implementation using httpx."""
+
+import asyncio
+from collections.abc import AsyncGenerator
+from typing import Any
+
+import httpx
+import structlog
+
+from kodit.domain.services.enrichment_service import EnrichmentProvider
+from kodit.domain.value_objects import EnrichmentRequest, EnrichmentResponse
+
+ENRICHMENT_SYSTEM_PROMPT = """
+You are a professional software developer. You will be given a snippet of code.
+Please provide a concise explanation of the code.
+"""
+
+# Default tuned to approximately fit within OpenAI's rate limit of 500 / RPM
+OPENAI_NUM_PARALLEL_TASKS = 40
+
+
+class OpenAIEnrichmentProvider(EnrichmentProvider):
+    """OpenAI enrichment provider implementation using httpx."""
+
+    def __init__(  # noqa: PLR0913
+        self,
+        api_key: str | None = None,
+        base_url: str = "https://api.openai.com",
+        model_name: str = "gpt-4o-mini",
+        num_parallel_tasks: int = OPENAI_NUM_PARALLEL_TASKS,
+        socket_path: str | None = None,
+        timeout: float = 30.0,
+    ) -> None:
+        """Initialize the OpenAI enrichment provider.
+
+        Args:
+            api_key: The OpenAI API key.
+            base_url: The base URL for the OpenAI API.
+            model_name: The model name to use for enrichment.
+            num_parallel_tasks: Maximum number of concurrent requests.
+            socket_path: Optional Unix socket path for local communication.
+            timeout: Request timeout in seconds.
+
+        """
+        self.log = structlog.get_logger(__name__)
+        self.model_name = model_name
+        self.num_parallel_tasks = num_parallel_tasks
+        self.api_key = api_key
+        self.base_url = base_url
+        self.socket_path = socket_path
+        self.timeout = timeout
+
+        # Create httpx client with optional Unix socket support
+        if socket_path:
+            transport = httpx.AsyncHTTPTransport(uds=socket_path)
+            self.http_client = httpx.AsyncClient(
+                transport=transport,
+                base_url="http://localhost",  # Base URL for Unix socket
+                timeout=timeout,
+            )
+        else:
+            self.http_client = httpx.AsyncClient(
+                base_url=base_url,
+                timeout=timeout,
+            )
+
+    async def _call_chat_completion(
+        self, messages: list[dict[str, str]]
+    ) -> dict[str, Any]:
+        """Call the chat completion API using httpx.
+
+        Args:
+            messages: The messages to send to the API.
+
+        Returns:
+            The API response as a dictionary.
+
+        """
+        headers = {
+            "Content-Type": "application/json",
+        }
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        data = {
+            "model": self.model_name,
+            "messages": messages,
+        }
+
+        response = await self.http_client.post(
+            "/v1/chat/completions",
+            json=data,
+            headers=headers,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    async def enrich(
+        self, requests: list[EnrichmentRequest]
+    ) -> AsyncGenerator[EnrichmentResponse, None]:
+        """Enrich a list of requests using OpenAI API.
+
+        Args:
+            requests: List of enrichment requests.
+
+        Yields:
+            Enrichment responses as they are processed.
+
+        """
+        if not requests:
+            self.log.warning("No requests for enrichment")
+            return
+
+        # Process batches in parallel with a semaphore to limit concurrent requests
+        sem = asyncio.Semaphore(self.num_parallel_tasks)
+
+        async def process_request(request: EnrichmentRequest) -> EnrichmentResponse:
+            async with sem:
+                if not request.text:
+                    return EnrichmentResponse(
+                        snippet_id=request.snippet_id,
+                        text="",
+                    )
+                try:
+                    messages = [
+                        {
+                            "role": "system",
+                            "content": ENRICHMENT_SYSTEM_PROMPT,
+                        },
+                        {"role": "user", "content": request.text},
+                    ]
+                    response = await self._call_chat_completion(messages)
+                    content = (
+                        response.get("choices", [{}])[0]
+                        .get("message", {})
+                        .get("content", "")
+                    )
+                    return EnrichmentResponse(
+                        snippet_id=request.snippet_id,
+                        text=content or "",
+                    )
+                except Exception as e:
+                    self.log.exception("Error enriching request", error=str(e))
+                    return EnrichmentResponse(
+                        snippet_id=request.snippet_id,
+                        text="",
+                    )
+
+        # Create tasks for all requests
+        tasks = [process_request(request) for request in requests]
+
+        # Process all requests and yield results as they complete
+        for task in asyncio.as_completed(tasks):
+            yield await task
+
+    async def close(self) -> None:
+        """Close the HTTP client."""
+        if hasattr(self, "http_client"):
+            await self.http_client.aclose()

{kodit-0.3.14 → kodit-0.3.16}/src/kodit/middleware.py

@@ -53,6 +53,7 @@ async def logging_middleware(request: Request, call_next: Callable) -> Response:
                 "client_host": client_host,
                 "client_port": client_port,
             },
+            headers=dict(request.headers),
             network={"client": {"ip": client_host, "port": client_port}},
             duration=process_time,
         )

kodit-0.3.14/tests/kodit/application/test_code_indexing_application_service.py → kodit-0.3.16/tests/kodit/application/code_indexing_application_service_test.py

@@ -2,6 +2,7 @@
 
 from pathlib import Path
 from typing import Any
+from unittest.mock import patch
 
 import pytest
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -13,10 +14,13 @@ from kodit.application.services.code_indexing_application_service import (
     CodeIndexingApplicationService,
 )
 from kodit.config import AppContext
+from kodit.domain.entities import SnippetWithContext
 from kodit.domain.interfaces import ProgressCallback
 from kodit.domain.protocols import IndexRepository
 from kodit.domain.services.index_query_service import IndexQueryService
 from kodit.domain.value_objects import (
+    FusionRequest,
+    FusionResult,
     MultiSearchRequest,
     ProgressEvent,
 )
@@ -292,3 +296,65 @@ def subtract(a: int, b: int) -> int:
     # The above should not raise an error
     final_index = await indexing_query_service.get_index_by_id(index.id)
     assert final_index is not None
+
+
+@pytest.mark.asyncio
+async def test_vectorchord_bug_zip_mismatch(
+    code_indexing_service: CodeIndexingApplicationService,
+    tmp_path: Path,
+) -> None:
+    """Test that reproduces the vectorchord bug with zip() length mismatch.
+
+    This happens when get_snippets_by_ids returns fewer snippets than the
+    number of IDs in final_results, which can occur when some snippet IDs
+    don't exist in the database or when related files/sources are missing.
+    """
+    # Create a temporary Python file
+    test_file = tmp_path / "test_code.py"
+    test_file.write_text("""
+def add(a: int, b: int) -> int:
+    return a + b
+
+def subtract(a: int, b: int) -> int:
+    return a - b
+""")
+
+    # Create initial index
+    index = await code_indexing_service.create_index_from_uri(str(tmp_path))
+    await code_indexing_service.run_index(index)
+    assert len(index.snippets) > 0, "Should have snippets for initial file"
+
+    # Mock perform_fusion to always return some fake results
+    # This ensures final_results is not empty
+    async def mock_perform_fusion(
+        rankings: list[list[FusionRequest]],  # noqa: ARG001
+        k: float = 60.0,  # noqa: ARG001
+    ) -> list[FusionResult]:
+        # Always return some fake fusion results to ensure final_results is populated
+        return [
+            FusionResult(id=99999, score=1.0, original_scores=[1.0]),
+            FusionResult(id=99998, score=0.8, original_scores=[0.8]),
+        ]
+
+    # Mock get_snippets_by_ids to return an empty list
+    # This ensures search_results is empty while final_results is not
+    async def mock_get_snippets_by_ids(ids: list[int]) -> list[SnippetWithContext]:  # noqa: ARG001
+        return []
+
+    # Apply the mocks using patch.object to avoid mypy errors
+    with (
+        patch.object(
+            code_indexing_service.index_query_service,
+            "perform_fusion",
+            side_effect=mock_perform_fusion,
+        ),
+        patch.object(
+            code_indexing_service.index_query_service,
+            "get_snippets_by_ids",
+            side_effect=mock_get_snippets_by_ids,
+        ),
+    ):
+        # This search used to fail with ValueError: zip() argument 2 is longer
+        await code_indexing_service.search(
+            MultiSearchRequest(keywords=["add"], top_k=5)
+        )

{kodit-0.3.14 → kodit-0.3.16}/tests/kodit/config_test.py

@@ -114,3 +114,33 @@ class TestAppContextAutoIndexing:
                 del os.environ["AUTO_INDEXING_SOURCES_0_URI"]
             if "DEFAULT_ENDPOINT_API_KEY" in os.environ:
                 del os.environ["DEFAULT_ENDPOINT_API_KEY"]
+
+    def test_endpoint_timeout_configuration(self) -> None:
+        """Test endpoint timeout configuration from env vars."""
+        # Set environment variables for different endpoint timeouts
+        os.environ["DEFAULT_ENDPOINT_TIMEOUT"] = "45.0"
+        os.environ["EMBEDDING_ENDPOINT_TIMEOUT"] = "60.0"
+        os.environ["ENRICHMENT_ENDPOINT_TIMEOUT"] = "90.0"
+
+        try:
+            # Create new context with env vars
+            app_context = AppContext()
+
+            # Verify timeout configurations
+            assert app_context.default_endpoint is not None
+            assert app_context.default_endpoint.timeout == 45.0
+
+            assert app_context.embedding_endpoint is not None
+            assert app_context.embedding_endpoint.timeout == 60.0
+
+            assert app_context.enrichment_endpoint is not None
+            assert app_context.enrichment_endpoint.timeout == 90.0
+
+        finally:
+            # Clean up environment variables
+            if "DEFAULT_ENDPOINT_TIMEOUT" in os.environ:
+                del os.environ["DEFAULT_ENDPOINT_TIMEOUT"]
+            if "EMBEDDING_ENDPOINT_TIMEOUT" in os.environ:
+                del os.environ["EMBEDDING_ENDPOINT_TIMEOUT"]
+            if "ENRICHMENT_ENDPOINT_TIMEOUT" in os.environ:
+                del os.environ["ENRICHMENT_ENDPOINT_TIMEOUT"]

{kodit-0.3.14 → kodit-0.3.16}/tests/kodit/infrastructure/embedding/embedding_factory_test.py

@@ -82,4 +82,4 @@ async def test_embedding_domain_service_factory(
     )
     assert isinstance(service.vector_search_repository, LocalVectorSearchRepository)
     assert isinstance(service.embedding_provider, OpenAIEmbeddingProvider)
-    assert service.embedding_provider.openai_client.base_url == test_base_url
+    assert service.embedding_provider.base_url == test_base_url