velune-cli 0.9.0__py3-none-any.whl

velune/plugins/registry.py

@@ -0,0 +1,56 @@
+"""Plugin catalog registry tracking active plugin components and hook associations."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from velune.plugins.hooks import PluginHookDispatcher
+from velune.plugins.schemas import PluginManifest
+
+logger = logging.getLogger("velune.plugins.registry")
+
+
+class PluginRegistry:
+    """Stores all loaded manifests and associated hook boundaries."""
+
+    def __init__(self, hook_dispatcher: PluginHookDispatcher | None = None) -> None:
+        self.hook_dispatcher = hook_dispatcher or PluginHookDispatcher()
+        self._manifests: dict[str, PluginManifest] = {}
+        self._instances: dict[str, Any] = {}
+
+    def register_plugin(self, manifest: PluginManifest, instance: Any) -> None:
+        """Saves a loaded plugin manifest and instantiates hook callbacks."""
+        self._manifests[manifest.name] = manifest
+        self._instances[manifest.name] = instance
+
+        # Search for callable hook methods based on manifest hooks list
+        for hook_name in manifest.hooks:
+            method_name = f"on_{hook_name}" if not hook_name.startswith("on_") else hook_name
+            # Strip 'on_' prefix for dispatcher hook names
+            clean_hook_name = hook_name
+            if clean_hook_name.startswith("on_"):
+                clean_hook_name = clean_hook_name[3:]
+
+            if hasattr(instance, method_name):
+                callback = getattr(instance, method_name)
+                if callable(callback):
+                    self.hook_dispatcher.register_hook(clean_hook_name, callback)
+                    logger.info(
+                        "Associated plugin %s with hook: %s", manifest.name, clean_hook_name
+                    )
+            else:
+                logger.warning(
+                    "Plugin %s declared hook %s but lacks method %s",
+                    manifest.name,
+                    hook_name,
+                    method_name,
+                )
+
+    def get_plugin(self, name: str) -> Any | None:
+        """Fetch active plugin instance."""
+        return self._instances.get(name)
+
+    def list_plugins(self) -> list[PluginManifest]:
+        """Returns metadata list of loaded active plugins."""
+        return list(self._manifests.values())

velune/plugins/schemas.py

@@ -0,0 +1,21 @@
+"""Plugin manifest schemas and validation."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class PluginManifest(BaseModel):
+    """Manifest data loaded from a plugin directory containing metadata and registration hooks."""
+
+    name: str = Field(..., description="Unique alphabetic slug of the plugin.")
+    version: str = Field("0.1.0", description="Plugin semantic version.")
+    description: str = Field("", description="Short plugin functional details.")
+    entry_point: str = Field(..., description="Relative python module path (e.g., 'plugin.py').")
+    hooks: list[str] = Field(
+        default_factory=list, description="List of Hook names subscribed (e.g., 'pre_execute')."
+    )
+    author: str | None = None
+    metadata: dict[str, Any] = Field(default_factory=dict)

velune/providers/__init__.py

@@ -0,0 +1,23 @@
+"""Provider abstraction layer."""
+
+# Provider adapters: import from velune.providers.adapters.*
+# velune/providers/{name}/provider.py files are deprecated shims
+
+from velune.providers.base import EmbeddingProvider, InferenceEngine, ModelProvider
+from velune.providers.benchmarker import ProviderBenchmarker
+from velune.providers.registry import ProviderRegistry
+from velune.providers.router import ProviderRouter
+from velune.providers.task_classifier import ComplexityLevel, TaskClassifier, TaskProfile, TaskType
+
+__all__ = [
+    "ModelProvider",
+    "InferenceEngine",
+    "EmbeddingProvider",
+    "ProviderRegistry",
+    "ProviderRouter",
+    "ProviderBenchmarker",
+    "TaskClassifier",
+    "TaskProfile",
+    "TaskType",
+    "ComplexityLevel",
+]

velune/providers/adapters/anthropic.py

@@ -0,0 +1,257 @@
+"""Anthropic provider adapter implementation."""
+
+from __future__ import annotations
+
+import json
+import time
+from collections.abc import AsyncIterator
+
+import httpx
+from pydantic import SecretStr
+
+from velune.core.errors.provider import (
+    InferenceError,
+    ProviderAuthenticationError,
+)
+from velune.core.types.inference import InferenceRequest, InferenceResponse, StreamChunk
+from velune.core.types.model import CapabilityLevel, ModelDescriptor
+from velune.core.types.provider import ProviderCapabilities, ProviderHealth
+from velune.providers.base import ModelProvider
+from velune.providers.keystore import get_key
+
+
+class AnthropicProvider(ModelProvider):
+    """Anthropic provider for Claude models."""
+
+    def __init__(
+        self, api_key: str | SecretStr | None = None, base_url: str = "https://api.anthropic.com"
+    ) -> None:
+        self._api_key = api_key or get_key("anthropic")
+        if hasattr(self._api_key, "get_secret_value"):
+            self._api_key = self._api_key.get_secret_value()
+        self._base_url = base_url
+        self.client: httpx.AsyncClient | None = None
+        self._capabilities = ProviderCapabilities(
+            supports_streaming=True,
+            supports_function_calling=True,
+            supports_embeddings=False,
+            max_context_window=200000,
+        )
+
+    @property
+    def provider_id(self) -> str:
+        return "anthropic"
+
+    async def initialize(self) -> None:
+        """Initialize HTTP client with Anthropic specific headers."""
+        if not self._api_key:
+            raise ProviderAuthenticationError(
+                "Anthropic API key not found in configuration or environment"
+            )
+        if not self.client:
+            headers = {
+                "x-api-key": self._api_key,
+                "anthropic-version": "2023-06-01",
+                "content-type": "application/json",
+            }
+            self.client = httpx.AsyncClient(base_url=self._base_url, headers=headers, timeout=300.0)
+
+    async def list_models(self) -> list[ModelDescriptor]:
+        """List active Claude models."""
+        await self.initialize()
+        # Anthropic has static lists, or we can query their endpoints. Here we provide the standard suite.
+        return [
+            ModelDescriptor(
+                model_id="claude-opus-4-5",
+                display_name="Claude Opus 4.5",
+                provider_id="anthropic",
+                context_length=200000,
+                capabilities={
+                    "coding": CapabilityLevel.EXPERT,
+                    "reasoning": CapabilityLevel.EXPERT,
+                    "planning": CapabilityLevel.EXPERT,
+                    "summarization": CapabilityLevel.EXPERT,
+                    "instruction_following": CapabilityLevel.EXPERT,
+                    "tool_use": CapabilityLevel.EXPERT,
+                    "long_context": CapabilityLevel.EXPERT,
+                },
+                is_local=False,
+            ),
+            ModelDescriptor(
+                model_id="claude-sonnet-4-5",
+                display_name="Claude Sonnet 4.5",
+                provider_id="anthropic",
+                context_length=200000,
+                capabilities={
+                    "coding": CapabilityLevel.ADVANCED,
+                    "reasoning": CapabilityLevel.ADVANCED,
+                    "planning": CapabilityLevel.ADVANCED,
+                    "summarization": CapabilityLevel.ADVANCED,
+                    "instruction_following": CapabilityLevel.ADVANCED,
+                    "tool_use": CapabilityLevel.EXPERT,
+                    "long_context": CapabilityLevel.ADVANCED,
+                },
+                is_local=False,
+            ),
+            ModelDescriptor(
+                model_id="claude-haiku-4-5",
+                display_name="Claude Haiku 4.5",
+                provider_id="anthropic",
+                context_length=200000,
+                capabilities={
+                    "coding": CapabilityLevel.INTERMEDIATE,
+                    "reasoning": CapabilityLevel.INTERMEDIATE,
+                    "planning": CapabilityLevel.INTERMEDIATE,
+                    "summarization": CapabilityLevel.INTERMEDIATE,
+                    "instruction_following": CapabilityLevel.ADVANCED,
+                    "tool_use": CapabilityLevel.ADVANCED,
+                    "long_context": CapabilityLevel.INTERMEDIATE,
+                },
+                is_local=False,
+            ),
+        ]
+
+    async def infer(self, request: InferenceRequest) -> InferenceResponse:
+        """Perform Claude inference."""
+        await self.initialize()
+        assert self.client is not None
+        start = time.perf_counter()
+        try:
+            # Map standard messages to Anthropic format (system role is parsed out if present)
+            system_prompt = ""
+            anth_messages = []
+            for msg in request.messages:
+                if msg.get("role") == "system":
+                    system_prompt = msg.get("content", "")
+                else:
+                    anth_messages.append({"role": msg.get("role"), "content": msg.get("content")})
+
+            payload = {
+                "model": request.model_id,
+                "messages": anth_messages,
+                "max_tokens": request.max_tokens or 4096,
+                "temperature": request.temperature,
+                "top_p": request.top_p,
+            }
+            if system_prompt:
+                payload["system"] = system_prompt
+            if request.stop_sequences:
+                payload["stop_sequences"] = request.stop_sequences
+
+            response = await self.client.post("/v1/messages", json=payload)
+            response.raise_for_status()
+            data = response.json()
+            latency = (time.perf_counter() - start) * 1000.0
+
+            content = ""
+            if data.get("content"):
+                content = data["content"][0].get("text", "")
+
+            # Record latency in health monitor if available
+            self._record_latency_to_monitor(latency)
+
+            return InferenceResponse(
+                content=content,
+                model_id=request.model_id,
+                finish_reason=data.get("stop_reason") or "end_turn",
+                tokens_used=data.get("usage", {}).get("total_tokens", 0),
+                latency_ms=latency,
+            )
+        except httpx.HTTPError as e:
+            raise InferenceError(f"Anthropic message completion failed: {e}")
+
+    async def stream(self, request: InferenceRequest) -> AsyncIterator[StreamChunk]:
+        """Perform streaming completion."""
+        await self.initialize()
+        assert self.client is not None
+        start = time.perf_counter()
+        first_token = True
+        try:
+            system_prompt = ""
+            anth_messages = []
+            for msg in request.messages:
+                if msg.get("role") == "system":
+                    system_prompt = msg.get("content", "")
+                else:
+                    anth_messages.append({"role": msg.get("role"), "content": msg.get("content")})
+
+            payload = {
+                "model": request.model_id,
+                "messages": anth_messages,
+                "max_tokens": request.max_tokens or 4096,
+                "temperature": request.temperature,
+                "top_p": request.top_p,
+                "stream": True,
+            }
+            if system_prompt:
+                payload["system"] = system_prompt
+            if request.stop_sequences:
+                payload["stop_sequences"] = request.stop_sequences
+
+            async with self.client.stream("POST", "/v1/messages", json=payload) as response:
+                response.raise_for_status()
+                async for line in response.aiter_lines():
+                    if line.startswith("data: "):
+                        data_str = line[6:]
+                        try:
+                            data = json.loads(data_str)
+                            d_type = data.get("type")
+                            if d_type == "content_block_delta":
+                                # Record latency at first token
+                                if first_token:
+                                    latency = (time.perf_counter() - start) * 1000.0
+                                    self._record_latency_to_monitor(latency)
+                                    first_token = False
+                                yield StreamChunk(
+                                    content=data["delta"].get("text", ""),
+                                )
+                            elif d_type == "message_delta":
+                                yield StreamChunk(
+                                    content="",
+                                    finish_reason=data.get("delta", {}).get("stop_reason"),
+                                )
+                        except (json.JSONDecodeError, KeyError):
+                            continue
+        except httpx.HTTPError as e:
+            raise InferenceError(f"Anthropic stream failed: {e}")
+
+    async def embed(self, texts: list[str], model_id: str) -> list[list[float]]:
+        raise NotImplementedError("Anthropic provider does not support embeddings.")
+
+    def _record_latency_to_monitor(self, latency_ms: float) -> None:
+        """Record latency to health monitor if available."""
+        try:
+            from velune.kernel.registry import get_container
+
+            container = get_container()
+            if container.has("runtime.provider_health_monitor"):
+                monitor = container.get("runtime.provider_health_monitor")
+                monitor.record_latency(self.provider_id, int(latency_ms))
+        except (ImportError, AttributeError, KeyError):
+            pass  # Health monitor not available, skip
+
+    async def health_check(self) -> ProviderHealth:
+        """Simple validation verification."""
+        try:
+            await self.initialize()
+            assert self.client is not None
+            # Fetch a simple request with 1 token output
+            payload = {
+                "model": "claude-haiku-4-5",
+                "messages": [{"role": "user", "content": "ping"}],
+                "max_tokens": 1,
+            }
+            resp = await self.client.post("/v1/messages", json=payload)
+            if resp.status_code == 200:
+                return ProviderHealth.HEALTHY
+            return ProviderHealth.DEGRADED
+        except Exception:
+            return ProviderHealth.UNAVAILABLE
+
+    def get_capabilities(self) -> ProviderCapabilities:
+        return self._capabilities
+
+    async def shutdown(self) -> None:
+        if self.client:
+            await self.client.aclose()
+            self.client = None

velune/providers/adapters/fireworks.py

@@ -0,0 +1,115 @@
+"""Fireworks.AI provider adapter — OpenAI-compatible REST API."""
+
+from __future__ import annotations
+
+from velune.core.types.model import CapabilityLevel, ModelDescriptor
+from velune.core.types.provider import ProviderCapabilities
+from velune.providers.adapters.openai import OpenAIProvider
+from velune.providers.keystore import get_key
+
+FIREWORKS_MODELS: list[ModelDescriptor] = [
+    ModelDescriptor(
+        model_id="accounts/fireworks/models/llama-v3p3-70b-instruct",
+        display_name="Llama 3.3 70B Instruct",
+        provider_id="fireworks",
+        context_length=131072,
+        capabilities={
+            "coding": CapabilityLevel.ADVANCED,
+            "reasoning": CapabilityLevel.ADVANCED,
+            "planning": CapabilityLevel.ADVANCED,
+            "summarization": CapabilityLevel.EXPERT,
+            "instruction_following": CapabilityLevel.EXPERT,
+            "tool_use": CapabilityLevel.ADVANCED,
+            "long_context": CapabilityLevel.ADVANCED,
+        },
+        speed_tier="fast",
+        is_local=False,
+        cost_per_1k_tokens=0.0009,
+        tags=["cloud", "fireworks", "llama"],
+    ),
+    ModelDescriptor(
+        model_id="accounts/fireworks/models/deepseek-r1",
+        display_name="DeepSeek R1",
+        provider_id="fireworks",
+        context_length=163840,
+        capabilities={
+            "coding": CapabilityLevel.EXPERT,
+            "reasoning": CapabilityLevel.EXPERT,
+            "planning": CapabilityLevel.EXPERT,
+            "summarization": CapabilityLevel.ADVANCED,
+            "instruction_following": CapabilityLevel.EXPERT,
+            "tool_use": CapabilityLevel.ADVANCED,
+            "long_context": CapabilityLevel.ADVANCED,
+        },
+        speed_tier="slow",
+        is_local=False,
+        cost_per_1k_tokens=0.003,
+        tags=["cloud", "fireworks", "deepseek", "reasoning"],
+    ),
+    ModelDescriptor(
+        model_id="accounts/fireworks/models/qwen2p5-coder-32b-instruct",
+        display_name="Qwen 2.5 Coder 32B Instruct",
+        provider_id="fireworks",
+        context_length=131072,
+        capabilities={
+            "coding": CapabilityLevel.EXPERT,
+            "reasoning": CapabilityLevel.ADVANCED,
+            "planning": CapabilityLevel.ADVANCED,
+            "summarization": CapabilityLevel.ADVANCED,
+            "instruction_following": CapabilityLevel.EXPERT,
+            "tool_use": CapabilityLevel.ADVANCED,
+            "long_context": CapabilityLevel.ADVANCED,
+        },
+        speed_tier="medium",
+        is_local=False,
+        cost_per_1k_tokens=0.0009,
+        tags=["cloud", "fireworks", "qwen", "coding"],
+    ),
+    ModelDescriptor(
+        model_id="accounts/fireworks/models/mixtral-8x22b-instruct",
+        display_name="Mixtral 8x22B Instruct",
+        provider_id="fireworks",
+        context_length=65536,
+        capabilities={
+            "coding": CapabilityLevel.ADVANCED,
+            "reasoning": CapabilityLevel.ADVANCED,
+            "planning": CapabilityLevel.ADVANCED,
+            "summarization": CapabilityLevel.EXPERT,
+            "instruction_following": CapabilityLevel.ADVANCED,
+            "tool_use": CapabilityLevel.ADVANCED,
+            "long_context": CapabilityLevel.ADVANCED,
+        },
+        speed_tier="medium",
+        is_local=False,
+        cost_per_1k_tokens=0.0009,
+        tags=["cloud", "fireworks", "mixtral", "moe"],
+    ),
+]
+
+
+class FireworksProvider(OpenAIProvider):
+    """Fireworks.AI — fast, cheap open-model inference."""
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        base_url: str = "https://api.fireworks.ai/inference/v1",
+    ) -> None:
+        self._api_key = api_key or get_key("fireworks")
+        if hasattr(self._api_key, "get_secret_value"):
+            self._api_key = self._api_key.get_secret_value()
+        self._base_url = base_url
+        self.client = None
+        self._capabilities = ProviderCapabilities(
+            supports_streaming=True,
+            supports_function_calling=True,
+            supports_embeddings=False,
+            max_context_window=131072,
+        )
+
+    @property
+    def provider_id(self) -> str:
+        return "fireworks"
+
+    async def list_models(self) -> list[ModelDescriptor]:
+        return list(FIREWORKS_MODELS)