kodit 0.5.2__py3-none-any.whl → 0.5.3__py3-none-any.whl

kodit/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.5.2'
-__version_tuple__ = version_tuple = (0, 5, 2)
+__version__ = version = '0.5.3'
+__version_tuple__ = version_tuple = (0, 5, 3)
 
 __commit_id__ = commit_id = None

kodit/application/factories/server_factory.py

@@ -1,7 +1,6 @@
 """Create a big object that contains all the application services."""
 
 from collections.abc import Callable
-from typing import TYPE_CHECKING
 
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -86,9 +85,6 @@ from kodit.infrastructure.sqlalchemy.task_status_repository import (
 )
 from kodit.infrastructure.sqlalchemy.unit_of_work import SqlAlchemyUnitOfWork
 
-if TYPE_CHECKING:
-    from kodit.domain.services.enrichment_service import EnrichmentDomainService
-
 
 class ServerFactory:
     """Factory for creating server application services."""
@@ -109,7 +105,6 @@ class ServerFactory:
         self._commit_indexing_application_service: (
             CommitIndexingApplicationService | None
         ) = None
-        self._enrichment_service: EnrichmentDomainService | None = None
         self._enricher_service: Enricher | None = None
         self._task_status_repository: TaskStatusRepository | None = None
         self._operation: ProgressTracker | None = None

kodit/config.py

@@ -70,6 +70,18 @@ class Endpoint(BaseModel):
         default=60,
         description="Request timeout in seconds",
     )
+    max_retries: int = Field(
+        default=5,
+        description="Maximum number of retries for the endpoint",
+    )
+    initial_delay: float = Field(
+        default=2.0,
+        description="Initial delay in seconds for the endpoint",
+    )
+    backoff_factor: float = Field(
+        default=2.0,
+        description="Backoff factor for the endpoint",
+    )
     extra_params: dict[str, Any] | None = Field(
         default=None,
         description="Extra provider-specific non-secret parameters for LiteLLM",

kodit/infrastructure/embedding/embedding_providers/litellm_embedding_provider.py

@@ -1,14 +1,9 @@
 """LiteLLM embedding provider implementation."""
 
-import asyncio
 from collections.abc import AsyncGenerator
-from typing import Any
 
-import httpx
-import litellm
 import structlog
 import tiktoken
-from litellm import aembedding
 
 from kodit.config import Endpoint
 from kodit.domain.services.embedding_service import EmbeddingProvider
@@ -16,6 +11,10 @@ from kodit.domain.value_objects import EmbeddingRequest, EmbeddingResponse
 from kodit.infrastructure.embedding.embedding_providers.batching import (
     split_sub_batches,
 )
+from kodit.infrastructure.providers.async_batch_processor import (
+    process_items_concurrently,
+)
+from kodit.infrastructure.providers.litellm_provider import LiteLLMProvider
 
 
 class LiteLLMEmbeddingProvider(EmbeddingProvider):
@@ -34,22 +33,7 @@ class LiteLLMEmbeddingProvider(EmbeddingProvider):
         self.endpoint = endpoint
         self.log = structlog.get_logger(__name__)
         self._encoding: tiktoken.Encoding | None = None
-
-        # Configure LiteLLM with custom HTTPX client for Unix socket support if needed
-        self._setup_litellm_client()
-
-    def _setup_litellm_client(self) -> None:
-        """Set up LiteLLM with custom HTTPX client for Unix socket support."""
-        if self.endpoint.socket_path:
-            # Create HTTPX client with Unix socket transport
-            transport = httpx.AsyncHTTPTransport(uds=self.endpoint.socket_path)
-            unix_client = httpx.AsyncClient(
-                transport=transport,
-                base_url="http://localhost",  # Base URL for Unix socket
-                timeout=self.endpoint.timeout,
-            )
-            # Set as LiteLLM's async client session
-            litellm.aclient_session = unix_client
+        self.provider: LiteLLMProvider = LiteLLMProvider(self.endpoint)
 
     def _split_sub_batches(
         self, encoding: tiktoken.Encoding, data: list[EmbeddingRequest]
@@ -62,45 +46,6 @@ class LiteLLMEmbeddingProvider(EmbeddingProvider):
             batch_size=self.endpoint.num_parallel_tasks,
         )
 
-    async def _call_embeddings_api(self, texts: list[str]) -> Any:
-        """Call the embeddings API using LiteLLM.
-
-        Args:
-            texts: The texts to embed.
-
-        Returns:
-            The API response as a dictionary.
-
-        """
-        kwargs = {
-            "model": self.endpoint.model,
-            "input": texts,
-            "timeout": self.endpoint.timeout,
-        }
-
-        # Add API key if provided
-        if self.endpoint.api_key:
-            kwargs["api_key"] = self.endpoint.api_key
-
-        # Add base_url if provided
-        if self.endpoint.base_url:
-            kwargs["api_base"] = self.endpoint.base_url
-
-        # Add extra parameters
-        kwargs.update(self.endpoint.extra_params or {})
-
-        try:
-            # Use litellm's async embedding function
-            response = await aembedding(**kwargs)
-            return (
-                response.model_dump() if hasattr(response, "model_dump") else response
-            )
-        except Exception as e:
-            self.log.exception(
-                "LiteLLM embedding API error", error=str(e), model=self.endpoint.model
-            )
-            raise
-
     async def embed(
         self, data: list[EmbeddingRequest]
     ) -> AsyncGenerator[list[EmbeddingResponse], None]:
@@ -113,39 +58,45 @@ class LiteLLMEmbeddingProvider(EmbeddingProvider):
         encoding = self._get_encoding()
         batched_data = self._split_sub_batches(encoding, data)
 
-        # Process batches concurrently with semaphore
-        sem = asyncio.Semaphore(self.endpoint.num_parallel_tasks or 10)
-
         async def _process_batch(
             batch: list[EmbeddingRequest],
         ) -> list[EmbeddingResponse]:
-            async with sem:
-                response = await self._call_embeddings_api(
-                    [item.text for item in batch]
+            texts = [item.text for item in batch]
+            response = await self.provider.embedding(texts)
+            embeddings_data = response.get("data", [])
+
+            # Handle mismatch between batch size and response size
+            if len(embeddings_data) != len(batch):
+                preview_response = embeddings_data[:3] if embeddings_data else None
+                self.log.error(
+                    "Embedding response size mismatch",
+                    batch_size=len(batch),
+                    response_size=len(embeddings_data),
+                    texts_preview=[t[:50] for t in texts[:3]],
+                    response_preview=preview_response,
+                )
+                raise ValueError(
+                    f"Expected {len(batch)} embeddings, got {len(embeddings_data)}"
                 )
-                embeddings_data = response.get("data", [])
 
-                return [
-                    EmbeddingResponse(
-                        snippet_id=item.snippet_id,
-                        embedding=emb_data.get("embedding", []),
-                    )
-                    for item, emb_data in zip(batch, embeddings_data, strict=True)
-                ]
+            return [
+                EmbeddingResponse(
+                    snippet_id=item.snippet_id,
+                    embedding=emb_data.get("embedding", []),
+                )
+                for item, emb_data in zip(batch, embeddings_data, strict=True)
+            ]
 
-        tasks = [_process_batch(batch) for batch in batched_data]
-        for task in asyncio.as_completed(tasks):
-            yield await task
+        async for result in process_items_concurrently(
+            batched_data,
+            _process_batch,
+            self.endpoint.num_parallel_tasks,
+        ):
+            yield result
 
     async def close(self) -> None:
-        """Close the provider and cleanup HTTPX client if using Unix sockets."""
-        if (
-            self.endpoint.socket_path
-            and hasattr(litellm, "aclient_session")
-            and litellm.aclient_session
-        ):
-            await litellm.aclient_session.aclose()
-            litellm.aclient_session = None
+        """Close the provider."""
+        await self.provider.close()
 
     def _get_encoding(self) -> tiktoken.Encoding:
         """Return (and cache) the tiktoken encoding for the chosen model."""

kodit/infrastructure/enricher/litellm_enricher.py

@@ -1,21 +1,18 @@
 """LiteLLM enricher implementation."""
 
-import asyncio
 from collections.abc import AsyncGenerator
-from typing import Any
 
-import httpx
-import litellm
 import structlog
-from litellm import acompletion
 
 from kodit.config import Endpoint
 from kodit.domain.enrichments.enricher import Enricher
 from kodit.domain.enrichments.request import EnrichmentRequest
 from kodit.domain.enrichments.response import EnrichmentResponse
 from kodit.infrastructure.enricher.utils import clean_thinking_tags
-
-DEFAULT_NUM_PARALLEL_TASKS = 20
+from kodit.infrastructure.providers.async_batch_processor import (
+    process_items_concurrently,
+)
+from kodit.infrastructure.providers.litellm_provider import LiteLLMProvider
 
 
 class LiteLLMEnricher(Enricher):
@@ -32,64 +29,8 @@ class LiteLLMEnricher(Enricher):
 
         """
         self.log = structlog.get_logger(__name__)
-        self.model_name = endpoint.model or "gpt-4o-mini"
-        self.api_key = endpoint.api_key
-        self.base_url = endpoint.base_url
-        self.socket_path = endpoint.socket_path
-        self.num_parallel_tasks = (
-            endpoint.num_parallel_tasks or DEFAULT_NUM_PARALLEL_TASKS
-        )
-        self.timeout = endpoint.timeout
-        self.extra_params = endpoint.extra_params or {}
-
-        self._setup_litellm_client()
-
-    def _setup_litellm_client(self) -> None:
-        """Set up LiteLLM with custom HTTPX client for Unix socket support."""
-        if self.socket_path:
-            transport = httpx.AsyncHTTPTransport(uds=self.socket_path)
-            unix_client = httpx.AsyncClient(
-                transport=transport,
-                base_url="http://localhost",
-                timeout=self.timeout,
-            )
-            litellm.aclient_session = unix_client
-
-    async def _call_chat_completion(self, messages: list[dict[str, str]]) -> Any:
-        """Call the chat completion API using LiteLLM.
-
-        Args:
-            messages: The messages to send to the API.
-
-        Returns:
-            The API response as a dictionary.
-
-        """
-        kwargs = {
-            "model": self.model_name,
-            "messages": messages,
-            "timeout": self.timeout,
-        }
-
-        if self.api_key:
-            kwargs["api_key"] = self.api_key
-
-        if self.base_url:
-            kwargs["api_base"] = self.base_url
-
-        kwargs.update(self.extra_params)
-
-        try:
-            response = await acompletion(**kwargs)
-            self.log.debug("enrichment request", request=kwargs, response=response)
-            return (
-                response.model_dump() if hasattr(response, "model_dump") else response
-            )
-        except Exception as e:
-            self.log.exception(
-                "LiteLLM completion API error", error=str(e), model=self.model_name
-            )
-            raise
+        self.provider: LiteLLMProvider = LiteLLMProvider(endpoint)
+        self.endpoint = endpoint
 
     async def enrich(
         self, requests: list[EnrichmentRequest]
@@ -107,47 +48,36 @@ class LiteLLMEnricher(Enricher):
             self.log.warning("No requests for enrichment")
             return
 
-        sem = asyncio.Semaphore(self.num_parallel_tasks)
-
         async def process_request(
             request: EnrichmentRequest,
         ) -> EnrichmentResponse:
-            async with sem:
-                if not request.text:
-                    return EnrichmentResponse(
-                        id=request.id,
-                        text="",
-                    )
-                messages = [
-                    {
-                        "role": "system",
-                        "content": request.system_prompt,
-                    },
-                    {"role": "user", "content": request.text},
-                ]
-                response = await self._call_chat_completion(messages)
-                content = (
-                    response.get("choices", [{}])[0]
-                    .get("message", {})
-                    .get("content", "")
-                )
-                cleaned_content = clean_thinking_tags(content or "")
+            if not request.text:
                 return EnrichmentResponse(
                     id=request.id,
-                    text=cleaned_content,
+                    text="",
                 )
+            messages = [
+                {
+                    "role": "system",
+                    "content": request.system_prompt,
+                },
+                {"role": "user", "content": request.text},
+            ]
+            response = await self.provider.chat_completion(messages)
+            content = (
+                response.get("choices", [{}])[0].get("message", {}).get("content", "")
+            )
+            cleaned_content = clean_thinking_tags(content or "")
+            return EnrichmentResponse(
+                id=request.id,
+                text=cleaned_content,
+            )
 
-        tasks = [process_request(request) for request in requests]
-
-        for task in asyncio.as_completed(tasks):
-            yield await task
+        async for result in process_items_concurrently(
+            requests, process_request, self.endpoint.num_parallel_tasks
+        ):
+            yield result
 
     async def close(self) -> None:
         """Close the enricher and cleanup HTTPX client if using Unix sockets."""
-        if (
-            self.socket_path
-            and hasattr(litellm, "aclient_session")
-            and litellm.aclient_session
-        ):
-            await litellm.aclient_session.aclose()
-            litellm.aclient_session = None
+        await self.provider.close()

kodit/infrastructure/providers/__init__.py

@@ -0,0 +1 @@
+"""Provider utilities for LiteLLM and async batch processing."""

kodit/infrastructure/providers/async_batch_processor.py

@@ -0,0 +1,51 @@
+"""Generic async batch processor with semaphore-controlled concurrency."""
+
+import asyncio
+from collections.abc import AsyncGenerator, Awaitable, Callable
+from typing import TypeVar
+
+T = TypeVar("T")
+R = TypeVar("R")
+
+
+async def process_items_concurrently(
+    items: list[T],
+    process_fn: Callable[[T], Awaitable[R]],
+    max_parallel_tasks: int,
+) -> AsyncGenerator[R, None]:
+    """Process items concurrently with semaphore-controlled concurrency.
+
+    Args:
+        items: List of items to process.
+        process_fn: Async function to process each item.
+        max_parallel_tasks: Maximum number of concurrent tasks.
+
+    Yields:
+        Results as they are completed (not necessarily in order).
+
+    """
+    if not items:
+        return
+
+    sem = asyncio.Semaphore(max_parallel_tasks)
+
+    async def _process_with_semaphore(item: T) -> R:
+        async with sem:
+            return await process_fn(item)
+
+    tasks: list[asyncio.Task[R]] = [
+        asyncio.create_task(_process_with_semaphore(item)) for item in items
+    ]
+
+    try:
+        for task in asyncio.as_completed(tasks):
+            yield await task
+    finally:
+        # Cancel any remaining tasks when generator exits
+        # (due to exception, Ctrl+C, or early consumer termination)
+        for task in tasks:
+            if not task.done():
+                task.cancel()
+
+        # Wait for all tasks to finish cancelling
+        await asyncio.gather(*tasks, return_exceptions=True)

kodit/infrastructure/providers/litellm_provider.py

@@ -0,0 +1,132 @@
+"""LiteLLM provider implementation."""
+
+import asyncio
+import functools
+from collections.abc import Callable, Coroutine
+from typing import Any
+
+import litellm
+import structlog
+from litellm import acompletion, aembedding
+
+from kodit.config import Endpoint
+
+ProviderMaxRetriesError = Exception("LiteLLM API error: Max retries exceeded")
+
+RETRYABLE_ERRORS = (
+    litellm.exceptions.Timeout,
+    litellm.exceptions.RateLimitError,
+    litellm.exceptions.InternalServerError,
+    litellm.exceptions.ServiceUnavailableError,
+    litellm.exceptions.APIConnectionError,
+    litellm.exceptions.MidStreamFallbackError,
+)
+
+
+def litellm_retry(
+    func: Callable[..., Coroutine[Any, Any, Any]],
+) -> Callable[..., Coroutine[Any, Any, Any]]:
+    """Retry decorator for LiteLLM API calls with exponential backoff.
+
+    Extracts retry configuration from the endpoint attribute of the first
+    argument (self) if it's a LiteLLMProvider instance.
+    """
+
+    @functools.wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
+        # Extract endpoint configuration from self if available
+        endpoint = None
+        if args and hasattr(args[0], "endpoint"):
+            endpoint = args[0].endpoint
+
+        # Use endpoint configuration or fall back to defaults
+        max_retries = endpoint.max_retries if endpoint else 5
+        initial_delay = endpoint.initial_delay if endpoint else 2.0
+        backoff_factor = endpoint.backoff_factor if endpoint else 2.0
+
+        retries = max_retries
+        delay = initial_delay
+        log: structlog.stdlib.BoundLogger = structlog.get_logger(__name__)
+
+        while True:
+            try:
+                return await func(*args, **kwargs)
+            except (asyncio.CancelledError, KeyboardInterrupt):
+                raise
+            except Exception as e:
+                if isinstance(e, RETRYABLE_ERRORS) and retries > 0:
+                    log.warning(
+                        "LiteLLM API error: Retrying",
+                        error=e,
+                        retries=retries,
+                        backoff=delay,
+                    )
+                    try:
+                        await asyncio.sleep(delay)
+                    except (asyncio.CancelledError, KeyboardInterrupt):
+                        # Cancellation during sleep should stop retries immediately
+                        log.info("Retry cancelled during backoff")
+                        raise
+                    retries -= 1
+                    delay *= backoff_factor
+                    continue
+
+                exception_info = {
+                    attr: getattr(e, attr)
+                    for attr in dir(e)
+                    if not attr.startswith("_")
+                }
+                log.exception(
+                    "LiteLLM API error, check provider logs for details",
+                    error=e,
+                    exception_info=exception_info,
+                    retries=retries,
+                    backoff=delay,
+                )
+                raise
+
+    return wrapper
+
+
+class LiteLLMProvider:
+    """LiteLLM provider that supports 100+ providers."""
+
+    def __init__(self, endpoint: Endpoint) -> None:
+        """Initialize the LiteLLM provider."""
+        self.endpoint = endpoint
+
+    def _populate_base_kwargs(self) -> dict[str, Any]:
+        """Populate base kwargs common to all API calls."""
+        kwargs = {
+            "model": self.endpoint.model,
+            "timeout": self.endpoint.timeout,
+        }
+
+        if self.endpoint.api_key:
+            kwargs["api_key"] = self.endpoint.api_key
+
+        if self.endpoint.base_url:
+            kwargs["api_base"] = self.endpoint.base_url
+
+        kwargs.update(self.endpoint.extra_params or {})
+
+        return kwargs
+
+    @litellm_retry
+    async def chat_completion(self, messages: list[dict[str, str]]) -> Any:
+        """Call the chat completion API using LiteLLM."""
+        kwargs = self._populate_base_kwargs()
+        kwargs["messages"] = messages
+        response = await acompletion(max_retries=0, **kwargs)
+        return response.model_dump()
+
+    @litellm_retry
+    async def embedding(self, texts: list[str]) -> Any:
+        """Call the embedding API using LiteLLM."""
+        kwargs = self._populate_base_kwargs()
+        kwargs["input"] = texts
+        response = await aembedding(max_retries=0, **kwargs)
+        return response.model_dump()
+
+    async def close(self) -> None:
+        """Close the provider - litellm handles its own connection cleanup."""

kodit/log.py

@@ -1,6 +1,7 @@
 """Logging configuration for kodit."""
 
 import logging
+import os
 import platform
 import re
 import shutil
@@ -11,6 +12,9 @@ from functools import lru_cache
 from pathlib import Path
 from typing import Any
 
+# Set litellm logging level BEFORE import to prevent broken logging objects
+os.environ["LITELLM_LOG"] = "ERROR"
+
 import litellm
 import rudderstack.analytics as rudder_analytics  # type: ignore[import-untyped]
 import structlog
@@ -108,9 +112,14 @@ def configure_logging(app_context: AppContext) -> None:
         else:
             logging.getLogger(_log).disabled = True
 
-    # More litellm logging cruft
+    # Disable litellm's internal debug logging
     litellm.suppress_debug_info = True
 
+    # Monkey-patch litellm's Logging class to add missing debug method
+    # This prevents AttributeError when litellm tries to call logging_obj.debug()
+    if not hasattr(litellm.Logging, "debug"):
+        litellm.Logging.debug = lambda _self, *_args, **_kwargs: None  # type: ignore[attr-defined]
+
     # Configure SQLAlchemy loggers to use our structlog setup
     for _log in ["sqlalchemy.engine", "alembic"]:
         engine_logger = logging.getLogger(_log)

{kodit-0.5.2.dist-info → kodit-0.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.5.2
+Version: 0.5.3
 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.5.2.dist-info → kodit-0.5.3.dist-info}/RECORD

@@ -1,19 +1,19 @@
 kodit/.gitignore,sha256=ztkjgRwL9Uud1OEi36hGQeDGk3OLK1NfDEO8YqGYy8o,11
 kodit/__init__.py,sha256=aEKHYninUq1yh6jaNfvJBYg-6fenpN132nJt1UU6Jxs,59
-kodit/_version.py,sha256=LGYtjQ6cyPZC_N0AovMIeSYYDK21050nm3HYgDanQBM,704
+kodit/_version.py,sha256=EWl7XaGZUG57Di8WiRltpKAkwy1CShJuJ-i6_rAPr-w,704
 kodit/app.py,sha256=niIfZiuuDp7mLzrBwQhx_FU7RvKfUALNV5y0o43miss,5802
 kodit/cli.py,sha256=QSTXIUDxZo3anIONY-grZi9_VSehWoS8QoVJZyOmWPQ,3086
 kodit/cli_utils.py,sha256=umkvt4kWNapk6db6RGz6bmn7oxgDpsW2Vo09MZ37OGg,2430
-kodit/config.py,sha256=s3xm0ve_Sw5LllAA-PKzka3OF-ucQ4F0O8XqZcJ7-Yc,7667
+kodit/config.py,sha256=x_67lawaejOenJvl8yMxzXgdIkeWx8Yyc2ISO37GCvc,8031
 kodit/database.py,sha256=Pjxx0k431_lCqAJwE3FpLfs74qz1l5JFUQX1TD-wgSs,3264
-kodit/log.py,sha256=ZpM0eMo_DVGQqrHxg0VV6dMrN2AAmu_3C0I3G7p2nMw,8828
+kodit/log.py,sha256=vaucGfLv1qTsLmx-1cMLxKkUthey_P9NKzRogFzkOi0,9265
 kodit/mcp.py,sha256=PwMogCaYwEJ289y_8-LkLQrL00q2vesYRVxix6-4nuE,7166
 kodit/middleware.py,sha256=TiwebNpaEmiP7QRuZrfZcCL51IUefQyNLSPuzVyk8UM,2813
 kodit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kodit/application/__init__.py,sha256=mH50wTpgP9dhbKztFsL8Dda9Hi18TSnMVxXtpp4aGOA,35
 kodit/application/factories/__init__.py,sha256=bU5CvEnaBePZ7JbkCOp1MGTNP752bnU2uEqmfy5FdRk,37
 kodit/application/factories/reporting_factory.py,sha256=3IpRiAw_olM69db-jbDAtjyGtd6Nh5o8jUJX3-rXCA8,1421
-kodit/application/factories/server_factory.py,sha256=m6tWMH9rSENqEEePpoWtHT51iQZ1IjZ2ZtvLugsbFmo,16456
+kodit/application/factories/server_factory.py,sha256=RJ-u0IpKSahq__ZzxP3yPyJ5sVWgGJhyxNbI9uIu-ZY,16251
 kodit/application/services/__init__.py,sha256=p5UQNw-H5sxQvs5Etfte93B3cJ1kKW6DNxK34uFvU1E,38
 kodit/application/services/code_search_application_service.py,sha256=sqMgyAw7e2d2FWroaonaL8G1Hwigb-Yku71dut3wOpQ,4963
 kodit/application/services/commit_indexing_application_service.py,sha256=S5Gep4aXB9_1CWxs9xcIMnGmsrfrwJqvfDAHIPhoS1k,29860
@@ -51,7 +51,6 @@ kodit/domain/factories/git_repo_factory.py,sha256=4yaa-waMbzapNtldHG1oxBVMuI6JB-
 kodit/domain/services/__init__.py,sha256=Q1GhCK_PqKHYwYE4tkwDz5BIyXkJngLBBOHhzvX8nzo,42
 kodit/domain/services/bm25_service.py,sha256=-E5k0td2Ucs25qygWkJlY0fl7ZckOUe5xZnKYff3hF8,3631
 kodit/domain/services/embedding_service.py,sha256=al-vBd7H9KuCqZTWtC7q8CEDVXaIQhDhvMFV9IxWasU,4663
-kodit/domain/services/enrichment_service.py,sha256=ziFaYqTYE5R2LTgirYDCniQxVuB1d3ZeONEalyaS_o0,858
 kodit/domain/services/git_repository_service.py,sha256=b-zAAFVxU22KKp2ACyKUgOpFKK7uar4PV5mqoN0Vgzk,15534
 kodit/domain/services/git_service.py,sha256=nVQCfXQ8kW-MAAoAd8bgSQmCdgPMVftUh5qd4du_bes,11352
 kodit/domain/services/physical_architecture_service.py,sha256=0YgoAvbUxT_VwgIh_prftSYnil_XIqNPSoP0g37eIt4,7209
@@ -98,11 +97,11 @@ kodit/infrastructure/embedding/vectorchord_vector_search_repository.py,sha256=nI
 kodit/infrastructure/embedding/embedding_providers/__init__.py,sha256=qeZ-oAIAxMl5QqebGtO1lq-tHjl_ucAwOXePklcwwGk,34
 kodit/infrastructure/embedding/embedding_providers/batching.py,sha256=a8CL9PX2VLmbeg616fc_lQzfC4BWTVn32m4SEhXpHxc,3279
 kodit/infrastructure/embedding/embedding_providers/hash_embedding_provider.py,sha256=V6OdCuWyQQOvo3OJGRi-gBKDApIcrELydFg7T696P5s,2257
-kodit/infrastructure/embedding/embedding_providers/litellm_embedding_provider.py,sha256=9Q5he_MI8xXENODwCvYCbhVawTjTv1bArGQrmxoWLas,5297
+kodit/infrastructure/embedding/embedding_providers/litellm_embedding_provider.py,sha256=RuZ5OvD2CJPzAq7CDRI0GdjyLHoHLEmInzdhlFDMp0U,3795
 kodit/infrastructure/embedding/embedding_providers/local_embedding_provider.py,sha256=9aLV1Zg4KMhYWlGRwgAUtswW4aIabNqbsipWhAn64RI,4133
 kodit/infrastructure/enricher/__init__.py,sha256=5KCwKHnQ3i_-1s5Q8kquUY_Y0BktJMGVrsDJLtTlDNc,55
 kodit/infrastructure/enricher/enricher_factory.py,sha256=R2UlmCrMW55nvPHHf5Aj0soEBr7T_XU1dgDWwqs49Cg,1593
-kodit/infrastructure/enricher/litellm_enricher.py,sha256=q3V6frb29yzmodzqQ6TDovbSmittiwHtoPNYy5x4dLQ,4866
+kodit/infrastructure/enricher/litellm_enricher.py,sha256=ZWqQQxtuWAr7SpdfxNtLq6GUmTpXGWADoOAEuhFX8ls,2666
 kodit/infrastructure/enricher/local_enricher.py,sha256=AUzmpjlPK7LGaX5DO8thmvfdwNPLLHCB4W5wyudqk3k,4317
 kodit/infrastructure/enricher/null_enricher.py,sha256=Vu3agCTXROzYl2MzM8gVgH2rMw_FHIkgH-S1vijKw_0,1048
 kodit/infrastructure/enricher/utils.py,sha256=FE9UCuxxzSdoHrmAC8Si2b5D6Nf6kVqgM1yjUVyCvW0,930
@@ -123,6 +122,9 @@ kodit/infrastructure/physical_architecture/detectors/__init__.py,sha256=z8JzHOy8
 kodit/infrastructure/physical_architecture/detectors/docker_compose_detector.py,sha256=NQWN24eV_wl3tDMsCnL2FbcBsGz2y-4pEfASBejeAKg,13245
 kodit/infrastructure/physical_architecture/formatters/__init__.py,sha256=2OCvhVKGUTHusxlsqRbLk8cNtzZ9HrGqnKYcozuLOE0,81
 kodit/infrastructure/physical_architecture/formatters/narrative_formatter.py,sha256=43bERS_iGhL94pkUV2Bn5vjeaHPxjHatuDh7dHreh_M,5713
+kodit/infrastructure/providers/__init__.py,sha256=XjB6DIQIXRrwRhSY32EF3QhZGTWNWsBZA5pwUc--ZZc,65
+kodit/infrastructure/providers/async_batch_processor.py,sha256=0GkfBfOdQWoZ9JL-_ZCqtlpL2R19nUUn-fhK9y0O0s0,1466
+kodit/infrastructure/providers/litellm_provider.py,sha256=Ybxws56fUKhN-Cku43vdmhlIINmwM7v9LckWnfowjCc,4504
 kodit/infrastructure/reporting/__init__.py,sha256=4Qu38YbDOaeDqLdT_CbK8tOZHTKGrHRXncVKlGRzOeQ,32
 kodit/infrastructure/reporting/db_progress.py,sha256=VVaCKjC_UFwdRptXbBroG9qhXCxI4bZmElf1PMsBzWA,819
 kodit/infrastructure/reporting/log_progress.py,sha256=yhzkjYulEn_sfpKwHKi--HdQHLb4h4uEolhFYqvdHS8,1261
@@ -165,8 +167,8 @@ kodit/utils/dump_config.py,sha256=dd5uPgqh6ATk02Zt59t2JFKR9X17YWjHudV0nE8VktE,11
 kodit/utils/dump_openapi.py,sha256=EasYOnnpeabwb_sTKQUBrrOLHjPcOFQ7Zx0YKpx9fmM,1239
 kodit/utils/generate_api_paths.py,sha256=TMtx9v55podDfUmiWaHgJHLtEWLV2sLL-5ejGFMPzAo,3569
 kodit/utils/path_utils.py,sha256=UB_81rx7Y1G1jalVv2PX8miwaprBbcqEdtoQ3hPT3kU,2451
-kodit-0.5.2.dist-info/METADATA,sha256=gcQYxwPZ5mx36u7ejs76xkZSBKUEnyGzDc5qJAcrrlQ,7703
-kodit-0.5.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kodit-0.5.2.dist-info/entry_points.txt,sha256=hoTn-1aKyTItjnY91fnO-rV5uaWQLQ-Vi7V5et2IbHY,40
-kodit-0.5.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-kodit-0.5.2.dist-info/RECORD,,
+kodit-0.5.3.dist-info/METADATA,sha256=340z0xqhe7h6HOYh85xfIIryGRIBuNLzHI50L2-EdFI,7703
+kodit-0.5.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kodit-0.5.3.dist-info/entry_points.txt,sha256=hoTn-1aKyTItjnY91fnO-rV5uaWQLQ-Vi7V5et2IbHY,40
+kodit-0.5.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+kodit-0.5.3.dist-info/RECORD,,

kodit/domain/services/enrichment_service.py

@@ -1,27 +0,0 @@
-"""Domain service for enrichment operations."""
-
-from collections.abc import AsyncGenerator
-
-from kodit.domain.enrichments.enricher import Enricher
-from kodit.domain.enrichments.request import EnrichmentRequest
-from kodit.domain.enrichments.response import EnrichmentResponse
-
-
-class EnrichmentDomainService:
-    """Domain service for enrichment operations."""
-
-    def __init__(self, enricher: Enricher) -> None:
-        """Initialize the enrichment domain service."""
-        self.enricher = enricher
-
-    async def enrich_documents(
-        self, requests: list[EnrichmentRequest]
-    ) -> AsyncGenerator[EnrichmentResponse, None]:
-        """Enrich documents using the enricher.
-
-        Yields:
-            Enrichment responses as they are processed.
-
-        """
-        async for response in self.enricher.enrich(requests):
-            yield response