vamp-cli 0.1.0__py3-none-any.whl

vamp_cli/agent/runtime/runtime.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Sequence
+from enum import Enum
+
+from langchain_core.runnables import Runnable
+
+from vamp_cli.config.schema import AppConfig, ProfileConfig
+from vamp_cli.llm.router import ModelRouter
+from vamp_cli.tools.registry import ToolRegistry
+from vamp_cli.prompts.prompts import PromptStore
+from vamp_cli.agent.roles import AgentRole
+from vamp_cli.tools.base import Tools
+
+
+
+@dataclass(frozen=True)
+class AgentProfile:
+    role: str
+    model: Runnable[Any, Any]
+    tools: dict[str, Tools]          # {name: Tools} - for execution dispatch
+    tool_schemas: list[dict]         # OpenAI-format - for giving tool list to llm model
+    system_prompt: str
+    context_window: int
+    
+
+class AgentRuntime:
+
+    def __init__(
+        self,
+        config: AppConfig,
+        model_router: ModelRouter,
+        tool_registry: ToolRegistry,
+        prompt_store: PromptStore,
+    ) -> None:
+        self._config = config
+        self._model_router = model_router
+        self._tool_registry = tool_registry
+        self._prompt_store = prompt_store
+        self._profile_cache: dict[str, AgentProfile] = {}
+        
+        
+    def resolve(self, role: AgentRole) -> AgentProfile:
+        
+        # check cache hit
+        if role.value in self._profile_cache:
+            return self._profile_cache[role.value]
+        
+        profile = self._build_profile(role=role)
+        
+        # cache the profile
+        self._profile_cache[role.value] = profile
+        
+        return profile
+    
+        
+    def _build_profile(self, role: AgentRole) -> AgentProfile:
+        
+        profile_cfg = self._resolve_profile(role)
+        
+        # Tool objects, keyed by name - for execution.
+        tools_by_name = self._tool_registry.get_tools(profile_cfg.tools)
+
+        # OpenAI-format schemas - for binding into the router.
+        tool_schemas = self._tool_registry.get_openai_tools(profile_cfg.tools)
+        
+   
+        system_prompt = self._prompt_store.load(profile_cfg.prompt)
+
+        model = self._model_router.get(
+            profile_cfg.model,
+            tools=tool_schemas,        # openai compatiable tool schema dict
+            usage_context=role.value,
+        )
+        
+        context_window_size = self._config.models[profile_cfg.model].capabilities.context_window
+        
+        profile =  AgentProfile(
+            role=role.value,
+            model=model,
+            tools=tools_by_name,
+            tool_schemas=tool_schemas,
+            system_prompt=system_prompt,
+            context_window=context_window_size
+        )
+        
+        return profile
+        
+    
+    def _resolve_profile(self, role: AgentRole)-> ProfileConfig:
+        
+        profiles = self._config.profiles
+
+        if role.value in profiles:
+            return profiles[role.value]
+        
+        if role.value not in profiles:
+            if role.value == "coder":
+                return profiles["default_coder"]
+            if role.value == "planner":
+                return profiles["default_planner"]
+
+        raise KeyError(
+            f"Role '{role}' is not configured and no 'default_{role.value}' profile exists"
+        )
+    
+
+
+
+
+    
+'''
+at call site:
+
+tool_calls = response.tool_calls
+
+for tc in tool_calls:
+
+    # openai raw tool call
+    name = tc["function"]["name"]
+    args = json.loads(tc["function"]["arguments"])
+    
+    tool = profile.tools[name]     # Dict[str, Tools]
+    result = tool.run(**args)
+
+
+def normalize_tool_call(tc: dict) -> tuple[str, dict]:
+    if "function" in tc:                          # OpenAI raw
+        return tc["function"]["name"], json.loads(tc["function"]["arguments"])
+    return tc["name"], tc["args"]                 # LangChain
+
+'''

vamp_cli/agent/state.py

@@ -0,0 +1,55 @@
+from enum import Enum
+import operator
+from typing import TypedDict, Annotated, Literal
+
+from langchain_core.messages import BaseMessage
+from langgraph.graph.message import add_messages
+
+
+
+class TodoItem(TypedDict):
+    id: str
+    description: str
+    status: Literal[
+        "pending",
+        "in_progress",
+        "completed",
+        "blocked",
+    ]
+
+
+class AgentState(TypedDict):
+    
+    # messages: Annotated[list[BaseMessage], add_messages]
+    planner_messages: Annotated[
+        list[BaseMessage],
+        add_messages,
+    ]
+    
+    requires_execution: bool
+
+    coder_messages: Annotated[
+        list[BaseMessage],
+        add_messages,
+    ]
+
+    task: str
+    
+    mode: Literal["normal", "plan"]
+    
+    plan: str | None # only generated in plan mode
+    
+    todo: list[TodoItem]
+    
+    iteration: int
+    
+    # tool-approval pipeline
+    _pending_tool_channel:   str | None
+    _pending_tool_calls:     list[dict]
+    _dangerous_tool_call_ids: list[str]
+    _approved_tool_call_ids:  list[str]
+    _denied_tool_call_ids:    list[str]
+    
+    
+    
+    

vamp_cli/agent/status.py

@@ -0,0 +1,17 @@
+from enum import Enum
+from typing import Optional
+from pydantic import BaseModel
+
+
+class AgentStatus(str, Enum):
+    PLANNING = "planning"
+    EXECUTING = "executing"
+    VERIFYING = "verifying"
+    REPAIRING = "repairing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class FeedbackResponse(BaseModel):
+    approved: bool
+    reason: Optional[str] = None

vamp_cli/config/loader.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+import yaml
+from pydantic import ValidationError
+
+from vamp_cli.config.schema import AppConfig, ModelConfig
+
+DEFAULT_CONFIG_DIR = Path(__file__).resolve().parent
+DEFAULT_CONFIG_PATH = DEFAULT_CONFIG_DIR / "default_config.yaml"
+
+CONFIG_PATH = Path.home() / ".vamp/config.yaml"
+
+class ConfigError(ValueError):
+    """Raised when configuration is structurally invalid or incomplete."""
+
+
+def load_config() -> AppConfig:
+    """Load, validate, resolve secrets, and cross-check the YAML config.
+
+    This is the only place in the application that reads config.yaml.
+    """
+    
+    config_path = CONFIG_PATH
+
+    if not config_path.exists():
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        with open(DEFAULT_CONFIG_PATH, "r", encoding="utf-8") as f:
+            content = f.read()
+            
+        with open(config_path, "x", encoding="utf-8") as f:
+            f.write(content)
+    
+           
+    if not config_path.is_file():
+        raise ConfigError(f"Config file does not exist: {config_path}")
+
+    try:
+        with config_path.open("r", encoding="utf-8") as fh:
+            raw: Any = yaml.safe_load(fh) or {}
+    except yaml.YAMLError as exc:
+        raise ConfigError(f"Invalid YAML in {config_path}: {exc}") from exc
+    except OSError as exc:
+        raise ConfigError(f"Unable to read config {config_path}: {exc}") from exc
+
+    try:
+        config = AppConfig.model_validate(raw)
+    except ValidationError as exc:
+        raise ConfigError(f"Invalid configuration in {config_path}:\n{exc}") from exc
+
+    _resolve_api_keys(config)
+    _validate_references(config)
+    return config
+
+
+def get_api_key(cfg: ModelConfig) -> str | None:
+    """Return a model's already-resolved API key."""
+
+    return cfg.api_key
+
+
+def _resolve_api_keys(config: AppConfig) -> None:
+    """Resolve API key environment variables into the in-memory config."""
+
+    for name, cfg in config.models.items():
+        if not cfg.api_key_env:
+            continue
+        try:
+            value = os.getenv(cfg.api_key_env)
+            if not value:
+                # print(
+                #     ConfigError(
+                #         f"Model '{name}' requires environment variable "
+                #         f"'{cfg.api_key_env}', but it is not set."
+                #     )
+                # )
+                cfg.api_key = "EXAMPLEMODEL_API_KEY"
+                continue
+                
+            cfg.api_key = value
+        except Exception:
+            pass
+
+
+
+def _validate_references(config: AppConfig) -> None:
+    """Validate model references, profile references, and fallback cycles."""
+
+    model_names = set(config.models)
+
+    if not model_names:
+        raise ConfigError("At least one model must be configured.")
+
+    if config.profiles and any(p not in config.profiles for p in config.default_profile):
+        raise ConfigError(
+            f"default_profile '{config.default_profile}' is not defined in profiles."
+        )
+
+    for profile_name, profile in config.profiles.items():
+        if profile.model not in model_names:
+            raise ConfigError(
+                f"Profile '{profile_name}' references unknown model "
+                f"'{profile.model}'."
+            )
+
+    for model_name, model in config.models.items():
+        for fallback in model.fallbacks:
+            if fallback not in model_names:
+                raise ConfigError(
+                    f"Model '{model_name}' references unknown fallback '{fallback}'."
+                )
+            if fallback == model_name:
+                raise ConfigError(
+                    f"Model '{model_name}' cannot use itself as a fallback."
+                )
+
+    _check_fallback_cycles(config)
+
+
+def _check_fallback_cycles(config: AppConfig) -> None:
+    visiting: set[str] = set()
+    visited: set[str] = set()
+    path: list[str] = []  # tracks the exact order of traversal
+
+    def visit(model_name: str) -> None:
+        if model_name in visiting:
+            cycle_start_idx = path.index(model_name)
+            cycle_path = path[cycle_start_idx:] + [model_name]
+            path_str = " -> ".join(cycle_path)
+            raise ConfigError(
+                f"Fallback cycle detected involving model '{model_name}'."
+                f"Fallback cycle: {path_str}"
+            )
+        if model_name in visited:
+            return
+
+        visiting.add(model_name)
+        path.append(model_name)  # push to history stack
+        
+        for fallback in config.models[model_name].fallbacks:
+            visit(fallback)
+            
+        path.pop() # pop from history stack
+        visiting.remove(model_name)
+        visited.add(model_name)
+
+    for model_name in config.models:
+        visit(model_name)

vamp_cli/config/schema.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class ModelCapabilities(BaseModel):
+    """Declarative capabilities used by higher layers before invocation."""
+
+    model_config = ConfigDict(extra="allow")
+
+    supports_tools: bool = True
+    supports_parallel_tools: bool = True
+    supports_streaming: bool = True
+    
+    supports_reasoning: bool = False
+    reasoning_param: str | None = None  # ex: "reasoning_effort" or "thinking"
+    reasoning_value: Any | None = None  # ex: "high" or {"type": "enabled", "budget_tokens": 4000}
+    
+    context_window: int = 128_000
+
+
+class ModelConfig(BaseModel):
+    """Configuration for one logical model name."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    model: str
+    api_base: str | None = None
+    api_key_env: str | None = None
+
+    # Resolved by config.loader.py from api_key_env.
+    # It is excluded from normal serialization and displayed masked by SecretStr.
+    api_key: str | None = Field(default=None, repr=False)
+
+    params: dict[str, Any] = Field(default_factory=dict)
+    fallbacks: list[str] = Field(default_factory=list)
+    adapter: str = "default"
+    capabilities: ModelCapabilities = Field(default_factory=ModelCapabilities)
+
+
+class ProfileConfig(BaseModel):
+    """Agent profile configuration consumed later by AgentRuntime."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    model: str
+    tools: list[str] = Field(default_factory=list)
+    prompt: str
+
+
+class AppConfig(BaseModel):
+    """Validated application configuration loaded from YAML."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    models: dict[str, ModelConfig]
+    profiles: dict[str, ProfileConfig] = Field(default_factory=dict)
+    default_profile: list[str] = ["default_coder", "default_planner"]
+    
+    @model_validator(mode="after")
+    def _check_references(self) -> "AppConfig":
+        
+        # Ensure default_profile list is not empty
+        if not self.default_profile:
+            raise ValueError("config must define at least one item in default_profile")
+        
+        # Check that every item in default_profile list actually exists under profiles
+        for p in self.default_profile:
+            if p not in self.profiles:
+                raise ValueError(f"default_profile item '{p}' is not defined in profiles.")
+
+        # Check profile models match defined models
+        for name, profile in self.profiles.items():
+            if profile.model not in self.models:
+                raise ValueError(
+                    f"profile '{name}' uses unknown model '{profile.model}'. "
+                    f"Defined models: {sorted(self.models)}"
+                )
+    
+        return self

vamp_cli/llm/adapter.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import Any, Protocol
+
+from langchain_core.runnables import Runnable
+
+from vamp_cli.config.schema import ModelConfig
+
+
+
+class ModelAdapter(Protocol):
+    def adapt(
+        self,
+        runnable: Runnable[Any, Any],
+        *,
+        model_name: str,
+        config: ModelConfig,
+    ) -> Runnable[Any, Any]:
+        ...
+
+
+class PassThroughAdapter(ModelAdapter):
+    """Default adapter for models with no special handling."""
+
+    def adapt(
+        self,
+        runnable: Runnable[Any, Any],
+        *,
+        model_name: str,
+        config: ModelConfig,
+    ) -> Runnable[Any, Any]:
+        return runnable
+
+
+class ReasoningAdapter(ModelAdapter):
+    """Injects provider-specific reasoning/thinking parameters into the runnable."""
+
+    def adapt(
+        self,
+        runnable: Runnable[Any, Any],
+        *,
+        model_name: str,
+        config: ModelConfig,
+    ) -> Runnable[Any, Any]:
+        caps = config.capabilities
+        
+        # If the model configuration has reasoning enabled and specifies parameter structures
+        if caps.supports_reasoning and caps.reasoning_param:
+            kwargs = {caps.reasoning_param: caps.reasoning_value}
+            return runnable.bind(**kwargs)
+            
+        return runnable

vamp_cli/llm/adapter_registry.py

@@ -0,0 +1,26 @@
+from vamp_cli.llm.adapter import (
+    ModelAdapter,
+    PassThroughAdapter,
+    ReasoningAdapter
+)
+
+
+class AdapterRegistry:
+    def __init__(
+        self,
+        adapters: dict[str, ModelAdapter] | None = None,
+    ) -> None:
+        self._adapters = {
+            "reasoning": ReasoningAdapter(),
+            "default": PassThroughAdapter(),
+            **(adapters or {}),
+        }
+
+    def get(self, name: str) -> ModelAdapter:
+        try:
+            return self._adapters[name]
+        except KeyError:
+            raise KeyError(
+                f"Unknown model adapter '{name}'. "
+                f"Available adapters: {sorted(self._adapters)}"
+            ) from None

vamp_cli/llm/debug_callbacks.py

@@ -0,0 +1,18 @@
+import logging
+import json
+from langchain_core.callbacks import BaseCallbackHandler
+
+log = logging.getLogger(__name__)
+
+class DumpPayloadCallback(BaseCallbackHandler):
+    def on_llm_start(self, serialized, prompts, **kwargs):
+        log.info("=== LLM START ===")
+        log.info("serialized=%s", json.dumps(serialized, default=str)[:2000])
+        log.info("prompts=%s", prompts)
+
+    def on_chat_model_start(self, serialized, messages, **kwargs):
+        log.info("=== CHAT START ===")
+        log.info("messages=%s", messages)
+        log.info("invocation_params=%s", kwargs.get("invocation_params"))
+        log.info("options=%s", kwargs.get("options"))
+        log.info("metadata=%s", kwargs.get("metadata"))