multiagentos 0.4.0__py3-none-any.whl

runtime/agent/model_backed.py

@@ -0,0 +1,49 @@
+"""Agent executor backed by the provider-neutral model runtime."""
+
+from __future__ import annotations
+
+import json
+
+from core.contracts.agent import AgentContract
+from core.contracts.ai import ModelSpec
+from core.contracts.model_runtime import ModelRequest, ModelResponse
+from core.contracts.work_unit import WorkUnit
+from core.registry import AIRegistry
+from runtime.model.invoker import ModelInvoker
+
+
+class ModelBackedAgentExecutor:
+    """Turn an assigned model into an executable VYRELON Agent."""
+
+    def __init__(self, ai_registry: AIRegistry, model_invoker: ModelInvoker) -> None:
+        self.ai_registry = ai_registry
+        self.model_invoker = model_invoker
+
+    def execute(
+        self, *, agent: AgentContract, model_id: str, work_unit: WorkUnit
+    ) -> ModelResponse:
+        model = self.ai_registry.model(model_id)
+        request = ModelRequest(
+            system=self._system_prompt(agent),
+            prompt=self._work_prompt(work_unit),
+            metadata={
+                "agent_id": agent.id,
+                "role": agent.role,
+                "work_unit_id": work_unit.id,
+            },
+        )
+        return self.model_invoker.generate(model, request)
+
+    @staticmethod
+    def _system_prompt(agent: AgentContract) -> str:
+        capabilities = ", ".join(sorted(agent.capabilities)) or "general development"
+        return (
+            f"You are the VYRELON {agent.role} agent. "
+            f"Your capabilities are: {capabilities}. "
+            "Work only within the objective and permissions provided by the orchestrator."
+        )
+
+    @staticmethod
+    def _work_prompt(work_unit: WorkUnit) -> str:
+        inputs = json.dumps(work_unit.inputs, ensure_ascii=False, sort_keys=True, default=str)
+        return f"Objective: {work_unit.objective}\nInputs: {inputs}"

runtime/agent/process.py

@@ -0,0 +1,21 @@
+"""Process-backed AgentExecutor for the VYRELON lifecycle."""
+
+from __future__ import annotations
+
+from core.contracts.agent import AgentContract
+from core.contracts.work_unit import WorkUnit
+from runtime.process import ProcessResult, ProcessRuntime
+
+
+class ProcessAgentExecutor:
+    """Execute an agent's work through the local process runtime."""
+
+    def __init__(self, command: list[str]) -> None:
+        self.command = list(command)
+
+    def execute(
+        self, *, agent: AgentContract, model_id: str, work_unit: WorkUnit
+    ) -> ProcessResult:
+        work_unit.metadata["executor_agent"] = agent.id
+        work_unit.metadata["model_id"] = model_id
+        return ProcessRuntime().run(self.command, cwd=work_unit.metadata.get("cwd"))

runtime/builtin_tools.py

@@ -0,0 +1,57 @@
+"""Built-in VYRELON tool bindings."""
+from __future__ import annotations
+from dataclasses import dataclass
+from pathlib import Path
+from core.contracts.vyrelon_runtime import ToolRequest, ToolSideEffect, ToolSpec
+from runtime.local.filesystem import FilesystemRuntime
+from runtime.local.patch import PatchRuntime
+from runtime.local.shell import PersistentShellRuntime
+from runtime.tool_calling import ToolRuntime
+
+@dataclass
+class BuiltinToolBindings:
+    project_root: str
+    runtime: ToolRuntime
+    filesystem: FilesystemRuntime | None = None
+    patch: PatchRuntime | None = None
+    shell: PersistentShellRuntime | None = None
+
+    def __post_init__(self) -> None:
+        self.filesystem = self.filesystem or FilesystemRuntime(policy=self.runtime.policy)
+        self.patch = self.patch or PatchRuntime(policy=self.runtime.policy)
+        self.shell = self.shell or PersistentShellRuntime(self.project_root, policy=self.runtime.policy)
+        self._register()
+
+    def _register(self) -> None:
+        self.runtime.register(ToolSpec("filesystem.read","Read a text file inside the project root.",ToolSideEffect.READ,input_schema={"type":"object","required":["path"]}),self._read)
+        self.runtime.register(ToolSpec("filesystem.write","Write text to a file inside the project root.",ToolSideEffect.WRITE,frozenset({"filesystem.write"}),{"type":"object","required":["path","content"]}),self._write)
+        self.runtime.register(ToolSpec("patch.apply","Check and apply a unified Git patch to the project.",ToolSideEffect.WRITE,frozenset({"filesystem.write"}),{"type":"object","required":["patch"]}),self._patch)
+        self.runtime.register(ToolSpec("shell.run","Run a command in the project root.",ToolSideEffect.EXECUTE,frozenset({"process"}),{"type":"object","required":["command"]}),self._shell)
+
+    def _path(self, request: ToolRequest) -> str:
+        value=request.arguments.get("path")
+        if not isinstance(value,str) or not value: raise ValueError("path must be a non-empty string")
+        return str(Path(self.project_root)/value)
+
+    def _approved(self, request: ToolRequest) -> bool:
+        return request.metadata.get("approved") is True
+
+    def _read(self, request: ToolRequest) -> object:
+        return self.filesystem.read_text(self._path(request))
+
+    def _write(self, request: ToolRequest) -> object:
+        content=request.arguments.get("content")
+        if not isinstance(content,str): raise ValueError("content must be a string")
+        return str(self.filesystem.write_text(self._path(request),content,approved=self._approved(request)))
+
+    def _patch(self, request: ToolRequest) -> object:
+        patch=request.arguments.get("patch")
+        if not isinstance(patch,str) or not patch.strip(): raise ValueError("patch must be a non-empty string")
+        result=self.patch.apply(self.project_root,patch,approved=self._approved(request))
+        return {"returncode":result.returncode,"stdout":result.stdout,"stderr":result.stderr}
+
+    def _shell(self, request: ToolRequest) -> object:
+        command=request.arguments.get("command")
+        if not isinstance(command,str) or not command.strip(): raise ValueError("command must be a non-empty string")
+        result=self.shell.run(command)
+        return {"returncode":result.returncode,"stdout":result.stdout,"stderr":result.stderr}

runtime/capability.py

@@ -0,0 +1,143 @@
+"""Persistent model capability registry."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from core.contracts.ai import ModelSpec
+from core.contracts.capability import (
+    CapabilityConfidence,
+    CapabilityMatch,
+    ModelCapabilityProfile,
+)
+
+
+class CapabilityStore:
+    """Project-scoped JSON persistence for normalized model capabilities."""
+
+    def __init__(self, root: Path) -> None:
+        self.root = Path(root)
+        self.root.mkdir(parents=True, exist_ok=True)
+
+    def path(self, model_id: str) -> Path:
+        safe = model_id.replace("/", "__").replace(":", "__")
+        return self.root / f"{safe}.json"
+
+    def exists(self, model_id: str) -> bool:
+        return self.path(model_id).exists()
+
+    def save(self, profile: ModelCapabilityProfile) -> None:
+        self.path(profile.model_id).write_text(
+            json.dumps(
+                {
+                    "model_id": profile.model_id,
+                    "provider_id": profile.provider_id,
+                    "capabilities": sorted(profile.capabilities),
+                    "confidence": profile.confidence.value,
+                    "source": profile.source,
+                    "metadata": profile.metadata,
+                },
+                indent=2,
+                default=str,
+            ),
+            encoding="utf-8",
+        )
+
+    def load(self, model_id: str) -> ModelCapabilityProfile:
+        data = json.loads(self.path(model_id).read_text(encoding="utf-8"))
+        return ModelCapabilityProfile(
+            model_id=str(data["model_id"]),
+            provider_id=str(data["provider_id"]),
+            capabilities=frozenset(str(item) for item in data.get("capabilities", [])),
+            confidence=CapabilityConfidence(str(data.get("confidence", "unknown"))),
+            source=str(data.get("source", "unknown")),
+            metadata=dict(data.get("metadata", {})),
+        )
+
+
+class CapabilityRegistry:
+    """Resolve and persist model capability profiles."""
+
+    def __init__(self, store: CapabilityStore) -> None:
+        self.store = store
+
+    def profile(self, model: ModelSpec) -> ModelCapabilityProfile:
+        if self.store.exists(model.id):
+            stored = self.store.load(model.id)
+            if stored.provider_id == model.provider_id:
+                return stored
+        capabilities = frozenset(str(item) for item in model.capabilities)
+        profile = ModelCapabilityProfile(
+            model_id=model.id,
+            provider_id=model.provider_id,
+            capabilities=capabilities,
+            confidence=CapabilityConfidence.DECLARED,
+            source="model_spec",
+        )
+        self.store.save(profile)
+        return profile
+
+    def merge(self, profile: ModelCapabilityProfile) -> ModelCapabilityProfile:
+        """Merge a discovered or observed profile with the persisted profile."""
+        if self.store.exists(profile.model_id):
+            current = self.store.load(profile.model_id)
+            if current.provider_id != profile.provider_id:
+                raise ValueError(f"Capability provider mismatch for {profile.model_id}")
+            confidence = (
+                CapabilityConfidence.OBSERVED
+                if CapabilityConfidence.OBSERVED in {current.confidence, profile.confidence}
+                else CapabilityConfidence.DECLARED
+                if CapabilityConfidence.DECLARED in {current.confidence, profile.confidence}
+                else CapabilityConfidence.UNKNOWN
+            )
+            metadata = dict(current.metadata)
+            metadata.update(profile.metadata)
+            merged = ModelCapabilityProfile(
+                model_id=profile.model_id,
+                provider_id=profile.provider_id,
+                capabilities=frozenset(current.capabilities | profile.capabilities),
+                confidence=confidence,
+                source=f"{current.source}+{profile.source}",
+                metadata=metadata,
+            )
+        else:
+            merged = profile
+        self.store.save(merged)
+        return merged
+
+    def observe_response(self, model: ModelSpec, metadata: dict[str, object]) -> ModelCapabilityProfile:
+        """Record capabilities directly evidenced by a successful model response."""
+        observed = {"chat"}
+        if "tool_calls" in metadata or metadata.get("tools_used") is True:
+            observed.add("tools")
+        if metadata.get("structured_output") is True:
+            observed.add("structured_output")
+        return self.merge(ModelCapabilityProfile(
+            model_id=model.id,
+            provider_id=model.provider_id,
+            capabilities=frozenset(observed),
+            confidence=CapabilityConfidence.OBSERVED,
+            source="runtime_observation",
+            metadata={"observed_capabilities": sorted(observed)},
+        ))
+
+    def match(self, model: ModelSpec, requirements: frozenset[str]) -> CapabilityMatch:
+        profile = self.profile(model)
+        matched = profile.capabilities & requirements
+        missing = requirements - profile.capabilities
+        return CapabilityMatch(
+            model_id=model.id,
+            required=requirements,
+            matched=matched,
+            missing=missing,
+            score=profile.match_score(requirements),
+            confidence=profile.confidence,
+        )
+
+    def matches(
+        self,
+        models: list[ModelSpec],
+        requirements: frozenset[str],
+    ) -> dict[str, CapabilityMatch]:
+        return {model.id: self.match(model, requirements) for model in models}

runtime/chat_adapter_registry.py

@@ -0,0 +1,43 @@
+"""Resolve project Chat Agent contracts to provider adapters."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from core.chat_agent_registry import ChatAgentRegistry
+from core.contracts.chat_agent import ChatAgentProvider
+
+
+class ChatAdapterRegistry:
+    def __init__(self) -> None:
+        self._factories: dict[ChatAgentProvider, Any] = {}
+
+    def register(self, provider: ChatAgentProvider, factory: Any) -> None:
+        self._factories[provider] = factory
+
+    def create(self, provider: ChatAgentProvider, *, model: str | None = None) -> Any:
+        try:
+            factory = self._factories[provider]
+        except KeyError as exc:
+            raise LookupError(f"no Chat Agent adapter registered for {provider.value}") from exc
+        return factory(model=model)
+
+
+def default_chat_adapters() -> ChatAdapterRegistry:
+    registry = ChatAdapterRegistry()
+
+    def openai_factory(*, model=None):
+        from integrations.openai.chat_agent import OpenAIChatAgentAdapter
+        return OpenAIChatAgentAdapter(model=model)
+
+    registry.register(ChatAgentProvider.CHATGPT, openai_factory)
+    return registry
+
+
+def resolve_project_chat_adapter(
+    project_agent,
+    model: str | None = None,
+    registry: ChatAdapterRegistry | None = None,
+):
+    adapters = registry or default_chat_adapters()
+    return adapters.create(project_agent.provider, model=model)

runtime/chat_config.py

@@ -0,0 +1,57 @@
+"""Project-scoped conversational Chat Agent configuration."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class ChatConfig:
+    version: int
+    agent_id: str
+    model: str | None = None
+
+    def validate(self) -> None:
+        if self.version != 1:
+            raise ValueError(f"unsupported chat config version: {self.version}")
+        if not self.agent_id.strip():
+            raise ValueError("chat agent id must not be empty")
+        if self.model is not None and not self.model.strip():
+            raise ValueError("chat model must not be empty when provided")
+
+    def to_dict(self) -> dict[str, object]:
+        self.validate()
+        return {"version": self.version, "agent_id": self.agent_id, "model": self.model}
+
+
+DEFAULT_CHAT_CONFIG = ChatConfig(version=1, agent_id="chatgpt", model=None)
+
+
+def load_chat_config(project_root: Path) -> ChatConfig:
+    path = project_root / ".multiagentos" / "chat.json"
+    if not path.is_file():
+        raise FileNotFoundError(f"VYRELON chat config not found: {path}")
+    data = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise ValueError("chat config must be a JSON object")
+    config = ChatConfig(
+        version=int(data.get("version", 0)),
+        agent_id=str(data.get("agent_id", "")),
+        model=data.get("model"),
+    )
+    config.validate()
+    return config
+
+
+def write_default_chat_config(project_root: Path) -> Path:
+    target = project_root / ".multiagentos"
+    target.mkdir(parents=True, exist_ok=True)
+    path = target / "chat.json"
+    if not path.exists():
+        path.write_text(
+            json.dumps(DEFAULT_CHAT_CONFIG.to_dict(), indent=2) + "\n",
+            encoding="utf-8",
+        )
+    return path

runtime/chat_execution.py

@@ -0,0 +1,52 @@
+"""End-to-end project Chat Agent execution facade."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from core.chat_agent_bridge import ChatAgentExecutionResult, ChatAgentRequest
+from core.contracts.agent import AgentContract
+from core.contracts.ai import ModelSpec
+from core.contracts.execution import AgentExecutor, ResultReviewer, ResultVerifier
+from runtime.vyrelon import VYRELONRuntime
+
+
+def execute_project_chat_request(
+    project_root: Path,
+    request: ChatAgentRequest,
+    *,
+    agent: AgentContract,
+    models: list[ModelSpec],
+    executor: AgentExecutor,
+    verifier: ResultVerifier | None = None,
+    reviewer: ResultReviewer | None = None,
+    chat_agent_id: str | None = None,
+    preferred_model_ids: list[str] | None = None,
+    routing_strategy: str = "pool",
+) -> ChatAgentExecutionResult:
+    """Resolve the configured Chat Agent and execute through VYRELON.
+
+    The configured conversational provider supplies intent/plan; the supplied
+    VYRELON Agent/Model contracts own execution.
+    """
+    runtime = VYRELONRuntime()
+    configured_agent, configured_model = runtime.project_chat_agent(project_root)
+    adapter = runtime.project_chat_adapter(project_root)
+
+    selected_chat_agent_id = chat_agent_id or configured_agent.id
+    if configured_model and preferred_model_ids is None:
+        preferred_model_ids = [configured_model]
+
+    return runtime.execute_chat_request(
+        request=request,
+        adapter=adapter,
+        agent=agent,
+        models=models,
+        executor=executor,
+        chat_agent_id=selected_chat_agent_id,
+        preferred_model_ids=preferred_model_ids,
+        verifier=verifier,
+        reviewer=reviewer,
+        routing_strategy=routing_strategy,
+        project_root=project_root,
+    )

runtime/config/__init__.py

@@ -0,0 +1 @@
+"""VYRELON runtime configuration."""

runtime/config/loader.py

@@ -0,0 +1,67 @@
+"""JSON configuration loader for AI providers and agents."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from core.contracts.agent import AgentContract
+from core.contracts.ai import AIProvider, ModelSpec
+from core.registry import AIRegistry, AgentRegistry
+from core.routing import RoutingStrategy
+
+
+class RuntimeConfig:
+    def __init__(
+        self,
+        agents: AgentRegistry,
+        ai: AIRegistry,
+        routing: dict[str, RoutingStrategy],
+    ) -> None:
+        self.agents = agents
+        self.ai = ai
+        self.routing = routing
+
+
+class ConfigLoader:
+    def load(self, path: Path) -> RuntimeConfig:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        ai_registry = AIRegistry()
+        for provider_data in data.get("ai", {}).get("providers", []):
+            models = tuple(
+                ModelSpec(
+                    id=model["id"],
+                    provider_id=provider_data["id"],
+                    capabilities=frozenset(model.get("capabilities", [])),
+                    metadata=dict(model.get("metadata", {})),
+                )
+                for model in provider_data.get("models", [])
+            )
+            ai_registry.register(
+                AIProvider(
+                    id=provider_data["id"],
+                    kind=provider_data.get("type", "generic"),
+                    models=models,
+                    metadata=dict(provider_data.get("metadata", {})),
+                )
+            )
+
+        agent_registry = AgentRegistry()
+        routing = {}
+        for agent_data in data.get("agents", []):
+            agent = AgentContract(
+                id=agent_data["id"],
+                role=agent_data.get("role", agent_data["id"]),
+                capabilities=frozenset(agent_data.get("capabilities", [])),
+                tools=frozenset(agent_data.get("tools", [])),
+                permissions=frozenset(agent_data.get("permissions", [])),
+                model_ids=tuple(agent_data.get("models", [])),
+                metadata=dict(agent_data.get("metadata", {})),
+                kind=agent_data.get("type", "custom"),
+            )
+            agent_registry.register(agent)
+            routing[agent.id] = RoutingStrategy(
+                agent_data.get("strategy", RoutingStrategy.POOL.value)
+            )
+
+        return RuntimeConfig(agent_registry, ai_registry, routing)