claude-code-workflow 7.2.29 → 7.2.30

package/ccw-litellm/src/ccw_litellm/__init__.py

@@ -1,47 +0,0 @@
-"""ccw-litellm package.
-
-This package provides a small, stable interface layer around LiteLLM to share
-between the ccw and codex-lens projects.
-"""
-
-from __future__ import annotations
-
-from .clients import LiteLLMClient, LiteLLMEmbedder
-from .config import (
-    EmbeddingModelConfig,
-    LiteLLMConfig,
-    LLMModelConfig,
-    ProviderConfig,
-    get_config,
-    load_config,
-    reset_config,
-)
-from .interfaces import (
-    AbstractEmbedder,
-    AbstractLLMClient,
-    ChatMessage,
-    LLMResponse,
-)
-
-__version__ = "0.1.0"
-
-__all__ = [
-    "__version__",
-    # Abstract interfaces
-    "AbstractEmbedder",
-    "AbstractLLMClient",
-    "ChatMessage",
-    "LLMResponse",
-    # Client implementations
-    "LiteLLMClient",
-    "LiteLLMEmbedder",
-    # Configuration
-    "LiteLLMConfig",
-    "ProviderConfig",
-    "LLMModelConfig",
-    "EmbeddingModelConfig",
-    "load_config",
-    "get_config",
-    "reset_config",
-]
-

package/ccw-litellm/src/ccw_litellm/cli.py

@@ -1,108 +0,0 @@
-"""CLI entry point for ccw-litellm."""
-
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-
-def main() -> int:
-    """Main CLI entry point."""
-    parser = argparse.ArgumentParser(
-        prog="ccw-litellm",
-        description="Unified LiteLLM interface for ccw and codex-lens",
-    )
-    subparsers = parser.add_subparsers(dest="command", help="Available commands")
-
-    # config command
-    config_parser = subparsers.add_parser("config", help="Show configuration")
-    config_parser.add_argument(
-        "--path",
-        type=Path,
-        help="Configuration file path",
-    )
-
-    # embed command
-    embed_parser = subparsers.add_parser("embed", help="Generate embeddings")
-    embed_parser.add_argument("texts", nargs="+", help="Texts to embed")
-    embed_parser.add_argument(
-        "--model",
-        default="default",
-        help="Embedding model name (default: default)",
-    )
-    embed_parser.add_argument(
-        "--output",
-        choices=["json", "shape"],
-        default="shape",
-        help="Output format (default: shape)",
-    )
-
-    # chat command
-    chat_parser = subparsers.add_parser("chat", help="Chat with LLM")
-    chat_parser.add_argument("message", help="Message to send")
-    chat_parser.add_argument(
-        "--model",
-        default="default",
-        help="LLM model name (default: default)",
-    )
-
-    # version command
-    subparsers.add_parser("version", help="Show version")
-
-    args = parser.parse_args()
-
-    if args.command == "version":
-        from . import __version__
-
-        print(f"ccw-litellm {__version__}")
-        return 0
-
-    if args.command == "config":
-        from .config import get_config
-
-        try:
-            config = get_config(config_path=args.path if hasattr(args, "path") else None)
-            print(config.model_dump_json(indent=2))
-        except Exception as e:
-            print(f"Error loading config: {e}", file=sys.stderr)
-            return 1
-        return 0
-
-    if args.command == "embed":
-        from .clients import LiteLLMEmbedder
-
-        try:
-            embedder = LiteLLMEmbedder(model=args.model)
-            vectors = embedder.embed(args.texts)
-
-            if args.output == "json":
-                print(json.dumps(vectors.tolist()))
-            else:
-                print(f"Shape: {vectors.shape}")
-                print(f"Dimensions: {embedder.dimensions}")
-        except Exception as e:
-            print(f"Error: {e}", file=sys.stderr)
-            return 1
-        return 0
-
-    if args.command == "chat":
-        from .clients import LiteLLMClient
-        from .interfaces import ChatMessage
-
-        try:
-            client = LiteLLMClient(model=args.model)
-            response = client.chat([ChatMessage(role="user", content=args.message)])
-            print(response.content)
-        except Exception as e:
-            print(f"Error: {e}", file=sys.stderr)
-            return 1
-        return 0
-
-    parser.print_help()
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/ccw-litellm/src/ccw_litellm/clients/__init__.py

@@ -1,12 +0,0 @@
-"""Client implementations for ccw-litellm."""
-
-from __future__ import annotations
-
-from .litellm_embedder import LiteLLMEmbedder
-from .litellm_llm import LiteLLMClient
-
-__all__ = [
-    "LiteLLMClient",
-    "LiteLLMEmbedder",
-]
-

package/ccw-litellm/src/ccw_litellm/clients/litellm_embedder.py

@@ -1,270 +0,0 @@
-"""LiteLLM embedder implementation for text embeddings."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any, Sequence
-
-import litellm
-import numpy as np
-from numpy.typing import NDArray
-
-from ..config import LiteLLMConfig, get_config
-from ..interfaces.embedder import AbstractEmbedder
-
-logger = logging.getLogger(__name__)
-
-
-class LiteLLMEmbedder(AbstractEmbedder):
-    """LiteLLM embedder implementation.
-
-    Supports multiple embedding providers (OpenAI, etc.) through LiteLLM's unified interface.
-
-    Example:
-        embedder = LiteLLMEmbedder(model="default")
-        vectors = embedder.embed(["Hello world", "Another text"])
-        print(vectors.shape)  # (2, 1536)
-    """
-
-    def __init__(
-        self,
-        model: str = "default",
-        config: LiteLLMConfig | None = None,
-        **litellm_kwargs: Any,
-    ) -> None:
-        """Initialize LiteLLM embedder.
-
-        Args:
-            model: Model name from configuration (default: "default")
-            config: Configuration instance (default: use global config)
-            **litellm_kwargs: Additional arguments to pass to litellm.embedding()
-        """
-        self._config = config or get_config()
-        self._model_name = model
-        self._litellm_kwargs = litellm_kwargs
-
-        # Get embedding model configuration
-        try:
-            self._model_config = self._config.get_embedding_model(model)
-        except ValueError as e:
-            logger.error(f"Failed to get embedding model configuration: {e}")
-            raise
-
-        # Get provider configuration
-        try:
-            self._provider_config = self._config.get_provider(self._model_config.provider)
-        except ValueError as e:
-            logger.error(f"Failed to get provider configuration: {e}")
-            raise
-
-        # Set up LiteLLM environment
-        self._setup_litellm()
-
-    def _setup_litellm(self) -> None:
-        """Configure LiteLLM with provider settings."""
-        provider = self._model_config.provider
-
-        # Set API key
-        if self._provider_config.api_key:
-            litellm.api_key = self._provider_config.api_key
-            # Also set environment-specific keys
-            if provider == "openai":
-                litellm.openai_key = self._provider_config.api_key
-            elif provider == "anthropic":
-                litellm.anthropic_key = self._provider_config.api_key
-
-        # Set API base
-        if self._provider_config.api_base:
-            litellm.api_base = self._provider_config.api_base
-
-    def _format_model_name(self) -> str:
-        """Format model name for LiteLLM.
-
-        Returns:
-            Formatted model name (e.g., "openai/text-embedding-3-small")
-        """
-        provider = self._model_config.provider
-        model = self._model_config.model
-
-        # For some providers, LiteLLM expects explicit prefix
-        if provider in ["azure", "vertex_ai", "bedrock"]:
-            return f"{provider}/{model}"
-
-        # For providers with custom api_base (OpenAI-compatible endpoints),
-        # use openai/ prefix to tell LiteLLM to use OpenAI API format
-        if self._provider_config.api_base and provider not in ["openai", "anthropic"]:
-            return f"openai/{model}"
-
-        return model
-
-    @property
-    def dimensions(self) -> int:
-        """Embedding vector size."""
-        return self._model_config.dimensions
-
-    @property
-    def max_input_tokens(self) -> int:
-        """Maximum token limit for embeddings.
-
-        Returns the configured max_input_tokens from model config,
-        enabling adaptive batch sizing based on actual model capacity.
-        """
-        return self._model_config.max_input_tokens
-
-    def _estimate_tokens(self, text: str) -> int:
-        """Estimate token count for a text using fast heuristic.
-
-        Args:
-            text: Text to estimate tokens for
-
-        Returns:
-            Estimated token count (len/4 is a reasonable approximation)
-        """
-        return len(text) // 4
-
-    def _create_batches(
-        self,
-        texts: list[str],
-        max_tokens: int = 30000
-    ) -> list[list[str]]:
-        """Split texts into batches that fit within token limits.
-
-        Args:
-            texts: List of texts to batch
-            max_tokens: Maximum tokens per batch (default: 30000, safe margin for 40960 limit)
-
-        Returns:
-            List of text batches
-        """
-        batches = []
-        current_batch = []
-        current_tokens = 0
-
-        for text in texts:
-            text_tokens = self._estimate_tokens(text)
-
-            # If single text exceeds limit, truncate it
-            if text_tokens > max_tokens:
-                logger.warning(f"Text with {text_tokens} estimated tokens exceeds limit, truncating")
-                # Truncate to fit (rough estimate: 4 chars per token)
-                max_chars = max_tokens * 4
-                text = text[:max_chars]
-                text_tokens = self._estimate_tokens(text)
-
-            # Start new batch if current would exceed limit
-            if current_tokens + text_tokens > max_tokens and current_batch:
-                batches.append(current_batch)
-                current_batch = []
-                current_tokens = 0
-
-            current_batch.append(text)
-            current_tokens += text_tokens
-
-        # Add final batch
-        if current_batch:
-            batches.append(current_batch)
-
-        return batches
-
-    def embed(
-        self,
-        texts: str | Sequence[str],
-        *,
-        batch_size: int | None = None,
-        max_tokens_per_batch: int | None = None,
-        **kwargs: Any,
-    ) -> NDArray[np.floating]:
-        """Embed one or more texts.
-
-        Args:
-            texts: Single text or sequence of texts
-            batch_size: Batch size for processing (deprecated, use max_tokens_per_batch)
-            max_tokens_per_batch: Maximum estimated tokens per API call.
-                If None, uses 90% of model's max_input_tokens for safety margin.
-            **kwargs: Additional arguments for litellm.embedding()
-
-        Returns:
-            A numpy array of shape (n_texts, dimensions).
-
-        Raises:
-            Exception: If LiteLLM embedding fails
-        """
-        # Normalize input to list
-        if isinstance(texts, str):
-            text_list = [texts]
-        else:
-            text_list = list(texts)
-
-        if not text_list:
-            # Return empty array with correct shape
-            return np.empty((0, self.dimensions), dtype=np.float32)
-
-        # Merge kwargs
-        embedding_kwargs = {**self._litellm_kwargs, **kwargs}
-
-        # For OpenAI-compatible endpoints, ensure encoding_format is set
-        if self._provider_config.api_base and "encoding_format" not in embedding_kwargs:
-            embedding_kwargs["encoding_format"] = "float"
-
-        # Determine adaptive max_tokens_per_batch
-        # Use 90% of model's max_input_tokens as safety margin
-        if max_tokens_per_batch is None:
-            max_tokens_per_batch = int(self.max_input_tokens * 0.9)
-            logger.debug(
-                f"Using adaptive batch size: {max_tokens_per_batch} tokens "
-                f"(90% of {self.max_input_tokens})"
-            )
-
-        # Split into token-aware batches
-        batches = self._create_batches(text_list, max_tokens_per_batch)
-
-        if len(batches) > 1:
-            logger.info(f"Split {len(text_list)} texts into {len(batches)} batches for embedding")
-
-        all_embeddings = []
-
-        for batch_idx, batch in enumerate(batches):
-            try:
-                # Build call kwargs with explicit api_base
-                call_kwargs = {**embedding_kwargs}
-                if self._provider_config.api_base:
-                    call_kwargs["api_base"] = self._provider_config.api_base
-                if self._provider_config.api_key:
-                    call_kwargs["api_key"] = self._provider_config.api_key
-
-                # Call LiteLLM embedding for this batch
-                response = litellm.embedding(
-                    model=self._format_model_name(),
-                    input=batch,
-                    **call_kwargs,
-                )
-
-                # Extract embeddings
-                batch_embeddings = [item["embedding"] for item in response.data]
-                all_embeddings.extend(batch_embeddings)
-
-            except Exception as e:
-                logger.error(f"LiteLLM embedding failed for batch {batch_idx + 1}/{len(batches)}: {e}")
-                raise
-
-        # Convert to numpy array
-        result = np.array(all_embeddings, dtype=np.float32)
-
-        # Validate dimensions
-        if result.shape[1] != self.dimensions:
-            logger.warning(
-                f"Expected {self.dimensions} dimensions, got {result.shape[1]}. "
-                f"Configuration may be incorrect."
-            )
-
-        return result
-
-    @property
-    def model_name(self) -> str:
-        """Get configured model name."""
-        return self._model_name
-
-    @property
-    def provider(self) -> str:
-        """Get configured provider name."""
-        return self._model_config.provider

package/ccw-litellm/src/ccw_litellm/clients/litellm_llm.py

@@ -1,198 +0,0 @@
-"""LiteLLM client implementation for LLM operations."""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-from typing import Any, Sequence
-
-import litellm
-
-from ..config import LiteLLMConfig, get_config
-from ..interfaces.llm import AbstractLLMClient, ChatMessage, LLMResponse
-
-logger = logging.getLogger(__name__)
-
-
-class LiteLLMClient(AbstractLLMClient):
-    """LiteLLM client implementation.
-
-    Supports multiple providers (OpenAI, Anthropic, etc.) through LiteLLM's unified interface.
-
-    Example:
-        client = LiteLLMClient(model="default")
-        response = client.chat([
-            ChatMessage(role="user", content="Hello!")
-        ])
-        print(response.content)
-    """
-
-    def __init__(
-        self,
-        model: str = "default",
-        config: LiteLLMConfig | None = None,
-        **litellm_kwargs: Any,
-    ) -> None:
-        """Initialize LiteLLM client.
-
-        Args:
-            model: Model name from configuration (default: "default")
-            config: Configuration instance (default: use global config)
-            **litellm_kwargs: Additional arguments to pass to litellm.completion()
-        """
-        self._config = config or get_config()
-        self._model_name = model
-        self._litellm_kwargs = litellm_kwargs
-
-        # Get model configuration
-        try:
-            self._model_config = self._config.get_llm_model(model)
-        except ValueError as e:
-            logger.error(f"Failed to get model configuration: {e}")
-            raise
-
-        # Get provider configuration
-        try:
-            self._provider_config = self._config.get_provider(self._model_config.provider)
-        except ValueError as e:
-            logger.error(f"Failed to get provider configuration: {e}")
-            raise
-
-        # Set up LiteLLM environment
-        self._setup_litellm()
-
-    def _setup_litellm(self) -> None:
-        """Configure LiteLLM with provider settings."""
-        provider = self._model_config.provider
-
-        # Set API key
-        if self._provider_config.api_key:
-            env_var = f"{provider.upper()}_API_KEY"
-            litellm.api_key = self._provider_config.api_key
-            # Also set environment-specific keys
-            if provider == "openai":
-                litellm.openai_key = self._provider_config.api_key
-            elif provider == "anthropic":
-                litellm.anthropic_key = self._provider_config.api_key
-
-        # Set API base
-        if self._provider_config.api_base:
-            litellm.api_base = self._provider_config.api_base
-
-    def _format_model_name(self) -> str:
-        """Format model name for LiteLLM.
-
-        Returns:
-            Formatted model name (e.g., "gpt-4", "claude-3-opus-20240229")
-        """
-        # LiteLLM expects model names in format: "provider/model" or just "model"
-        # If provider is explicit, use provider/model format
-        provider = self._model_config.provider
-        model = self._model_config.model
-
-        # For some providers, LiteLLM expects explicit prefix
-        if provider in ["anthropic", "azure", "vertex_ai", "bedrock"]:
-            return f"{provider}/{model}"
-
-        # If there's a custom api_base, use openai/ prefix to force OpenAI-compatible routing
-        # This prevents LiteLLM from auto-detecting model provider from name
-        # (e.g., "gemini-2.5-pro" would otherwise trigger Vertex AI auth)
-        if self._provider_config.api_base:
-            # Check if it's not the default OpenAI endpoint
-            default_openai_bases = [
-                "https://api.openai.com/v1",
-                "https://api.openai.com",
-            ]
-            if self._provider_config.api_base not in default_openai_bases:
-                return f"openai/{model}"
-
-        return model
-
-    def chat(
-        self,
-        messages: Sequence[ChatMessage],
-        **kwargs: Any,
-    ) -> LLMResponse:
-        """Chat completion for a sequence of messages.
-
-        Args:
-            messages: Sequence of chat messages
-            **kwargs: Additional arguments for litellm.completion()
-
-        Returns:
-            LLM response with content and raw response
-
-        Raises:
-            Exception: If LiteLLM completion fails
-        """
-        # Convert messages to LiteLLM format
-        litellm_messages = [
-            {"role": msg.role, "content": msg.content} for msg in messages
-        ]
-
-        # Merge kwargs
-        completion_kwargs = {**self._litellm_kwargs, **kwargs}
-
-        # Build extra_headers from multiple sources
-        if "extra_headers" not in completion_kwargs:
-            completion_kwargs["extra_headers"] = {}
-
-        # 1. Load custom headers from environment variable (set by CCW)
-        env_headers = os.environ.get("CCW_LITELLM_EXTRA_HEADERS")
-        if env_headers:
-            try:
-                custom_headers = json.loads(env_headers)
-                completion_kwargs["extra_headers"].update(custom_headers)
-            except json.JSONDecodeError:
-                logger.warning(f"Invalid JSON in CCW_LITELLM_EXTRA_HEADERS: {env_headers}")
-
-        # 2. Override User-Agent to avoid being blocked by some API proxies
-        # that detect and block OpenAI SDK's default User-Agent
-        # This is a fallback - user can override via custom headers
-        if "User-Agent" not in completion_kwargs["extra_headers"]:
-            completion_kwargs["extra_headers"]["User-Agent"] = "python-httpx/0.27"
-
-        try:
-            # Call LiteLLM
-            response = litellm.completion(
-                model=self._format_model_name(),
-                messages=litellm_messages,
-                **completion_kwargs,
-            )
-
-            # Extract content
-            content = response.choices[0].message.content or ""
-
-            return LLMResponse(content=content, raw=response)
-
-        except Exception as e:
-            logger.error(f"LiteLLM completion failed: {e}")
-            raise
-
-    def complete(self, prompt: str, **kwargs: Any) -> LLMResponse:
-        """Text completion for a prompt.
-
-        Args:
-            prompt: Input prompt
-            **kwargs: Additional arguments for litellm.completion()
-
-        Returns:
-            LLM response with content and raw response
-
-        Raises:
-            Exception: If LiteLLM completion fails
-        """
-        # Convert to chat format (most modern models use chat interface)
-        messages = [ChatMessage(role="user", content=prompt)]
-        return self.chat(messages, **kwargs)
-
-    @property
-    def model_name(self) -> str:
-        """Get configured model name."""
-        return self._model_name
-
-    @property
-    def provider(self) -> str:
-        """Get configured provider name."""
-        return self._model_config.provider

package/ccw-litellm/src/ccw_litellm/config/__init__.py

@@ -1,22 +0,0 @@
-"""Configuration management for LiteLLM integration."""
-
-from __future__ import annotations
-
-from .loader import get_config, load_config, reset_config
-from .models import (
-    EmbeddingModelConfig,
-    LiteLLMConfig,
-    LLMModelConfig,
-    ProviderConfig,
-)
-
-__all__ = [
-    "LiteLLMConfig",
-    "ProviderConfig",
-    "LLMModelConfig",
-    "EmbeddingModelConfig",
-    "load_config",
-    "get_config",
-    "reset_config",
-]
-