claude-code-workflow 7.2.29 → 7.3.0

package/ccw-litellm/README.md

@@ -1,180 +0,0 @@
-# ccw-litellm
-
-Unified LiteLLM interface layer shared by ccw and codex-lens projects.
-
-## Features
-
-- **Unified LLM Interface**: Abstract interface for LLM operations (chat, completion)
-- **Unified Embedding Interface**: Abstract interface for text embeddings
-- **Multi-Provider Support**: OpenAI, Anthropic, Azure, and more via LiteLLM
-- **Configuration Management**: YAML-based configuration with environment variable substitution
-- **Type Safety**: Full type annotations with Pydantic models
-
-## Installation
-
-```bash
-pip install -e .
-```
-
-## Quick Start
-
-### Configuration
-
-Create a configuration file at `~/.ccw/config/litellm-config.yaml`:
-
-```yaml
-version: 1
-default_provider: openai
-
-providers:
-  openai:
-    api_key: ${OPENAI_API_KEY}
-    api_base: https://api.openai.com/v1
-
-llm_models:
-  default:
-    provider: openai
-    model: gpt-4
-
-embedding_models:
-  default:
-    provider: openai
-    model: text-embedding-3-small
-    dimensions: 1536
-```
-
-### Usage
-
-#### LLM Client
-
-```python
-from ccw_litellm import LiteLLMClient, ChatMessage
-
-# Initialize client with default model
-client = LiteLLMClient(model="default")
-
-# Chat completion
-messages = [
-    ChatMessage(role="user", content="Hello, how are you?")
-]
-response = client.chat(messages)
-print(response.content)
-
-# Text completion
-response = client.complete("Once upon a time")
-print(response.content)
-```
-
-#### Embedder
-
-```python
-from ccw_litellm import LiteLLMEmbedder
-
-# Initialize embedder with default model
-embedder = LiteLLMEmbedder(model="default")
-
-# Embed single text
-vector = embedder.embed("Hello world")
-print(vector.shape)  # (1, 1536)
-
-# Embed multiple texts
-vectors = embedder.embed(["Text 1", "Text 2", "Text 3"])
-print(vectors.shape)  # (3, 1536)
-```
-
-#### Custom Configuration
-
-```python
-from ccw_litellm import LiteLLMClient, load_config
-
-# Load custom configuration
-config = load_config("/path/to/custom-config.yaml")
-
-# Use custom configuration
-client = LiteLLMClient(model="fast", config=config)
-```
-
-## Configuration Reference
-
-### Provider Configuration
-
-```yaml
-providers:
-  <provider_name>:
-    api_key: <api_key_or_${ENV_VAR}>
-    api_base: <base_url>
-```
-
-Supported providers: `openai`, `anthropic`, `azure`, `vertex_ai`, `bedrock`, etc.
-
-### LLM Model Configuration
-
-```yaml
-llm_models:
-  <model_name>:
-    provider: <provider_name>
-    model: <model_identifier>
-```
-
-### Embedding Model Configuration
-
-```yaml
-embedding_models:
-  <model_name>:
-    provider: <provider_name>
-    model: <model_identifier>
-    dimensions: <embedding_dimensions>
-```
-
-## Environment Variables
-
-The configuration supports environment variable substitution using the `${VAR}` or `${VAR:-default}` syntax:
-
-```yaml
-providers:
-  openai:
-    api_key: ${OPENAI_API_KEY}              # Required
-    api_base: ${OPENAI_API_BASE:-https://api.openai.com/v1}  # With default
-```
-
-## API Reference
-
-### Interfaces
-
-- `AbstractLLMClient`: Abstract base class for LLM clients
-- `AbstractEmbedder`: Abstract base class for embedders
-- `ChatMessage`: Message data class (role, content)
-- `LLMResponse`: Response data class (content, raw)
-
-### Implementations
-
-- `LiteLLMClient`: LiteLLM implementation of AbstractLLMClient
-- `LiteLLMEmbedder`: LiteLLM implementation of AbstractEmbedder
-
-### Configuration
-
-- `LiteLLMConfig`: Root configuration model
-- `ProviderConfig`: Provider configuration model
-- `LLMModelConfig`: LLM model configuration model
-- `EmbeddingModelConfig`: Embedding model configuration model
-- `load_config(path)`: Load configuration from YAML file
-- `get_config(path, reload)`: Get global configuration singleton
-- `reset_config()`: Reset global configuration (for testing)
-
-## Development
-
-### Running Tests
-
-```bash
-pytest tests/ -v
-```
-
-### Type Checking
-
-```bash
-mypy src/ccw_litellm
-```
-
-## License
-
-MIT

package/ccw-litellm/pyproject.toml

@@ -1,35 +0,0 @@
-[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "ccw-litellm"
-version = "0.1.0"
-description = "Unified LiteLLM interface layer shared by ccw and codex-lens"
-requires-python = ">=3.10"
-authors = [{ name = "ccw-litellm contributors" }]
-dependencies = [
-  "litellm>=1.0.0",
-  "pyyaml",
-  "numpy",
-  "pydantic>=2.0",
-]
-
-[project.optional-dependencies]
-dev = [
-  "pytest>=7.0",
-]
-
-[project.scripts]
-ccw-litellm = "ccw_litellm.cli:main"
-
-[tool.setuptools]
-package-dir = { "" = "src" }
-
-[tool.setuptools.packages.find]
-where = ["src"]
-include = ["ccw_litellm*"]
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-addopts = "-q"

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