multiagentos 0.4.0__py3-none-any.whl

runtime/mcp/client.py

@@ -0,0 +1,120 @@
+"""Provider-neutral MCP client supporting stdio and Streamable HTTP."""
+from __future__ import annotations
+import json, os, subprocess, urllib.request, urllib.error, uuid
+from dataclasses import dataclass
+from typing import Any
+from core.contracts.mcp import MCPServerSpec, MCPSession, MCPTool, MCPToolCall, MCPToolResult
+
+class MCPError(RuntimeError): pass
+class MCPProtocolError(MCPError): pass
+
+@dataclass
+class _StdioSession:
+    process: subprocess.Popen[str]
+    session: MCPSession
+    next_id: int = 0
+
+class MCPClient:
+    def __init__(self, server: MCPServerSpec, *, cwd: str | None = None, timeout: float = 30.0):
+        self.server, self.cwd, self.timeout = server, cwd, timeout
+        self._stdio: _StdioSession | None = None
+        self._http_session: MCPSession | None = None
+        self._next_id = 0
+
+    @property
+    def session(self) -> MCPSession | None:
+        return self._stdio.session if self._stdio else self._http_session
+
+    def connect(self) -> MCPSession:
+        if self.server.requires_explicit_enable and not self.server.enabled:
+            raise MCPError(f"External MCP server requires explicit enablement: {self.server.id}")
+        if not self.server.enabled: raise MCPError(f"MCP server disabled: {self.server.id}")
+        if self.server.transport in {"streamable-http", "http", "sse"}:
+            return self._connect_http()
+        if self.server.transport != "stdio": raise MCPError(f"Unsupported MCP transport: {self.server.transport}")
+        if not self.server.command: raise MCPError(f"MCP server has no command: {self.server.id}")
+        env=os.environ.copy(); env.update(self.server.env)
+        process=subprocess.Popen([*self.server.command,*self.server.args],cwd=self.cwd,env=env,
+                                 stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,
+                                 text=True,bufsize=1)
+        session=MCPSession(str(uuid.uuid4()),self.server.id)
+        self._stdio=_StdioSession(process,session)
+        self._request_stdio("initialize",{"protocolVersion":session.protocol_version,"capabilities":{},
+                                         "clientInfo":{"name":"VYRELON","version":"0.1"}})
+        self._notify_stdio("notifications/initialized",{})
+        return session
+
+    def close(self) -> None:
+        if self._stdio:
+            p=self._stdio.process
+            if p.poll() is None:
+                p.terminate()
+                try: p.wait(timeout=2)
+                except subprocess.TimeoutExpired: p.kill()
+            self._stdio=None
+        self._http_session=None
+
+    def list_tools(self) -> tuple[MCPTool,...]:
+        result=self._request("tools/list",{})
+        return tuple(MCPTool(str(x["name"]),str(x.get("description","")),dict(x.get("inputSchema",{})),self.server.id)
+                     for x in result.get("tools",[]))
+
+    def call_tool(self, call: MCPToolCall) -> MCPToolResult:
+        if call.server_id != self.server.id: raise MCPError(f"Tool call targets {call.server_id}, not {self.server.id}")
+        result=self._request("tools/call",{"name":call.tool_name,"arguments":call.arguments})
+        return MCPToolResult(self.server.id,call.tool_name,tuple(result.get("content",[])),bool(result.get("isError",False)),result)
+
+    def _request(self,method:str,params:dict[str,Any])->dict[str,Any]:
+        if self.server.transport in {"streamable-http","http","sse"}: return self._http_request(method,params)[0]
+        return self._request_stdio(method,params)
+
+    def _request_stdio(self,method:str,params:dict[str,Any])->dict[str,Any]:
+        s=self._stdio
+        if not s or s.process.stdin is None or s.process.stdout is None: raise MCPError("MCP client is not connected")
+        s.next_id+=1; request_id=s.next_id
+        s.process.stdin.write(json.dumps({"jsonrpc":"2.0","id":request_id,"method":method,"params":params})+"\n"); s.process.stdin.flush()
+        while True:
+            line=s.process.stdout.readline()
+            if not line: raise MCPProtocolError(f"MCP server closed stdout while waiting for {method}")
+            message=json.loads(line)
+            if message.get("id") != request_id: continue
+            if "error" in message: raise MCPProtocolError(str(message["error"]))
+            return dict(message.get("result",{}))
+
+    def _notify_stdio(self,method:str,params:dict[str,Any])->None:
+        s=self._stdio
+        if not s or s.process.stdin is None: raise MCPError("MCP client is not connected")
+        s.process.stdin.write(json.dumps({"jsonrpc":"2.0","method":method,"params":params})+"\n"); s.process.stdin.flush()
+
+    def _connect_http(self)->MCPSession:
+        if not self.server.endpoint: raise MCPError(f"MCP server has no endpoint: {self.server.id}")
+        result,headers=self._http_request("initialize",{"protocolVersion":"2025-03-26","capabilities":{},
+                                                        "clientInfo":{"name":"VYRELON","version":"0.1"}})
+        sid=headers.get("Mcp-Session-Id") or headers.get("mcp-session-id") or str(uuid.uuid4())
+        self._http_session=MCPSession(sid,self.server.id,str(result.get("protocolVersion","2025-03-26")))
+        self._http_request("notifications/initialized",{},notification=True)
+        return self._http_session
+
+    def _http_request(self,method:str,params:dict[str,Any],*,notification:bool=False):
+        if not self.server.endpoint: raise MCPError("MCP server has no endpoint")
+        self._next_id+=1
+        payload={"jsonrpc":"2.0","method":method,"params":params}
+        if not notification: payload["id"]=self._next_id
+        headers={"Content-Type":"application/json","Accept":"application/json, text/event-stream",**self.server.headers}
+        if self._http_session: headers["Mcp-Session-Id"]=self._http_session.id
+        req=urllib.request.Request(self.server.endpoint,data=json.dumps(payload).encode(),headers=headers,method="POST")
+        try:
+            with urllib.request.urlopen(req,timeout=self.timeout) as response:
+                response_headers=dict(response.headers.items()); body=response.read().decode()
+        except urllib.error.HTTPError as exc:
+            raise MCPProtocolError(f"MCP HTTP {exc.code}: {exc.read().decode(errors='replace')}") from exc
+        except urllib.error.URLError as exc:
+            raise MCPError(f"MCP HTTP transport error: {exc.reason}") from exc
+        if notification: return {},response_headers
+        if "text/event-stream" in response_headers.get("Content-Type",""):
+            data=[line[5:].strip() for line in body.splitlines() if line.startswith("data:")]
+            if not data: raise MCPProtocolError("MCP SSE response contained no data event")
+            message=json.loads(data[-1])
+        else: message=json.loads(body)
+        if "error" in message: raise MCPProtocolError(str(message["error"]))
+        return dict(message.get("result",{})),response_headers

runtime/mcp/config.py

@@ -0,0 +1,36 @@
+"""Declarative MCP server configuration."""
+from __future__ import annotations
+import json
+from pathlib import Path
+from core.contracts.mcp import MCPServerSpec
+
+class MCPConfigLoader:
+    def load(self, project_root: Path) -> list[MCPServerSpec]:
+        path = project_root / ".multiagentos" / "mcp.json"
+        if not path.exists():
+            return []
+        data = json.loads(path.read_text())
+        servers = data.get("servers", data.get("mcpServers", {}))
+        result = []
+        for server_id, raw in servers.items():
+            command = raw.get("command")
+            if isinstance(command, str):
+                command = (command,)
+            else:
+                command = tuple(command or ())
+            args = tuple(str(x) for x in raw.get("args", ()))
+            result.append(MCPServerSpec(
+                id=server_id,
+                command=tuple(command),
+                args=args,
+                env={str(k): str(v) for k,v in raw.get("env", {}).items()},
+                transport=str(raw.get("transport", "stdio")),
+                endpoint=raw.get("url", raw.get("endpoint")),
+                headers={str(k): str(v) for k,v in raw.get("headers", {}).items()},
+                enabled=bool(raw.get("enabled", False if raw.get("source", "built-in") == "external" else True)),
+                metadata=dict(raw.get("metadata", {})),
+                source=str(raw.get("source", "built-in")),
+                cost_policy=str(raw.get("cost_policy", "no_external_billing" if raw.get("source", "built-in") == "built-in" else "external_service_possible")),
+                requires_explicit_enable=bool(raw.get("requires_explicit_enable", raw.get("source", "built-in") == "external")),
+            ))
+        return result

runtime/mcp/policy.py

@@ -0,0 +1,57 @@
+"""MCP tool authorization and profile loading."""
+from __future__ import annotations
+import json
+from pathlib import Path
+from core.contracts.agent import AgentContract
+from core.contracts.mcp import MCPTool, MCPToolProfile
+from core.contracts.vyrelon_runtime import ToolSideEffect
+
+class MCPAuthorizationError(PermissionError):
+    pass
+
+class MCPToolProfileLoader:
+    def load(self, project_root: Path) -> tuple[MCPToolProfile, ...]:
+        path = project_root / ".multiagentos" / "mcp-profiles.json"
+        if not path.exists():
+            return ()
+        data = json.loads(path.read_text(encoding="utf-8"))
+        result = []
+        for profile_id, item in data.get("profiles", {}).items():
+            result.append(MCPToolProfile(
+                id=profile_id,
+                server_ids=frozenset(item.get("servers", [])),
+                allowed_tools=frozenset(item.get("tools", [])),
+                denied_tools=frozenset(item.get("deny_tools", [])),
+                required_permissions=frozenset(item.get("permissions", [])),
+                allowed_side_effects=frozenset(ToolSideEffect(value) for value in item.get("side_effects", ["read"])),
+                metadata=item.get("metadata", {}),
+                tool_side_effects={key: ToolSideEffect(value) for key, value in item.get("tool_side_effects", {}).items()},
+            ))
+        return tuple(result)
+
+class MCPToolAuthorizer:
+    def __init__(self, profiles: tuple[MCPToolProfile, ...] = ()):
+        self.profiles = {p.id: p for p in profiles}
+
+    def authorize(self, agent: AgentContract, tool: MCPTool, profile_id: str | None = None) -> None:
+        if profile_id:
+            profile = self.profiles.get(profile_id)
+            if profile is None:
+                raise MCPAuthorizationError(f"MCP tool profile not found: {profile_id}")
+            if not profile.allows(tool, agent.permissions):
+                raise MCPAuthorizationError(f"MCP tool denied by profile '{profile_id}': {tool.server_id}:{tool.name}")
+        elif agent.tools and tool.name not in agent.tools and f"{tool.server_id}:{tool.name}" not in agent.tools:
+            raise MCPAuthorizationError(f"MCP tool not granted to agent: {tool.server_id}:{tool.name}")
+        if tool.permissions and not tool.permissions.issubset(agent.permissions):
+            missing = sorted(tool.permissions - agent.permissions)
+            raise MCPAuthorizationError(f"MCP tool permission denied: {tool.server_id}:{tool.name}; missing={missing}")
+
+    def filter_tools(self, agent: AgentContract, tools: tuple[MCPTool, ...], profile_id: str | None = None) -> tuple[MCPTool, ...]:
+        return tuple(tool for tool in tools if self._allowed(agent, tool, profile_id))
+
+    def _allowed(self, agent: AgentContract, tool: MCPTool, profile_id: str | None) -> bool:
+        try:
+            self.authorize(agent, tool, profile_id)
+            return True
+        except MCPAuthorizationError:
+            return False

runtime/mcp/proxy.py

@@ -0,0 +1,30 @@
+"""Provider-neutral MCP tool proxy with agent authorization."""
+from core.contracts.agent import AgentContract
+from core.contracts.mcp import MCPTool, MCPToolCall, MCPToolResult
+from runtime.mcp.client import MCPClient
+from runtime.mcp.policy import MCPToolAuthorizer
+
+class MCPToolProxy:
+    def __init__(self, clients: dict[str, MCPClient], authorizer: MCPToolAuthorizer | None = None):
+        self.clients = clients
+        self.authorizer = authorizer or MCPToolAuthorizer()
+
+    def list_tools(self, agent: AgentContract | None = None, profile_id: str | None = None) -> tuple[MCPTool, ...]:
+        tools = []
+        for client in self.clients.values():
+            tools.extend(client.list_tools())
+        result = tuple(tools)
+        return result if agent is None else self.authorizer.filter_tools(agent, result, profile_id)
+
+    def call(self, request: MCPToolCall, agent: AgentContract | None = None, profile_id: str | None = None) -> MCPToolResult:
+        client = self.clients.get(request.server_id)
+        if client is None:
+            raise KeyError(f"MCP server not connected: {request.server_id}")
+        if request.session_id and (client.session is None or client.session.id != request.session_id):
+            raise KeyError(f"MCP session mismatch for {request.server_id}")
+        if agent is not None:
+            tool = next((item for item in client.list_tools() if item.name == request.tool_name), None)
+            if tool is None:
+                raise KeyError(f"MCP tool not found: {request.server_id}:{request.tool_name}")
+            self.authorizer.authorize(agent, tool, profile_id)
+        return client.call_tool(request)

runtime/mcp/server.py

@@ -0,0 +1,137 @@
+"""MCP stdio server exposing a deliberately scoped VYRELON local tool surface."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+from runtime.builtin_tools import BuiltinToolBindings
+from runtime.policy import ExecutionPolicy
+from runtime.tool_calling import ToolRuntime
+from core.contracts.vyrelon_runtime import ToolRequest
+
+
+class VYRELONMCPServer:
+    """Small stdio MCP server suitable for Secure MCP Tunnel's mcp-command."""
+
+    PROTOCOL_VERSION = "2025-03-26"
+
+    def __init__(
+        self,
+        project_root: Path,
+        *,
+        allow_write: bool = False,
+        allow_process: bool = False,
+    ) -> None:
+        self.project_root = project_root.resolve()
+        self.runtime = ToolRuntime(
+            ExecutionPolicy(
+                allow_process=allow_process,
+                allow_filesystem_write=allow_write,
+            )
+        )
+        BuiltinToolBindings(str(self.project_root), self.runtime)
+
+    def _visible_tools(self) -> list[dict[str, object]]:
+        result = []
+        for spec in self.runtime.specs():
+            capability = {
+                "write": "filesystem.write",
+                "execute": "process",
+            }.get(spec.side_effect.value)
+            if capability and not self.runtime.policy.permits(capability):
+                continue
+            result.append(
+                {
+                    "name": spec.id,
+                    "description": spec.description,
+                    "inputSchema": spec.input_schema,
+                }
+            )
+        return result
+
+    def _call(self, name: str, arguments: dict[str, object]) -> dict[str, object]:
+        result = self.runtime.execute(
+            ToolRequest(name, arguments),
+            granted_permissions=frozenset(
+                {
+                    "filesystem.write"
+                    if self.runtime.policy.allow_filesystem_write
+                    else "",
+                    "process" if self.runtime.policy.allow_process else "",
+                }
+            )
+            - {""},
+            approved=True,
+        )
+        if result.ok:
+            output = result.output
+            text = output if isinstance(output, str) else json.dumps(output, ensure_ascii=False, default=str)
+            return {"content": [{"type": "text", "text": text}], "isError": False}
+        return {"content": [{"type": "text", "text": result.error or "tool execution failed"}], "isError": True}
+
+    def handle(self, message: dict[str, object]) -> dict[str, object] | None:
+        method = message.get("method")
+        request_id = message.get("id")
+
+        if method == "notifications/initialized":
+            return None
+
+        if method == "initialize":
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "result": {
+                    "protocolVersion": self.PROTOCOL_VERSION,
+                    "capabilities": {"tools": {}},
+                    "serverInfo": {"name": "VYRELON", "version": "0.3.0"},
+                },
+            }
+
+        if method == "tools/list":
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "result": {"tools": self._visible_tools()},
+            }
+
+        if method == "tools/call":
+            params = message.get("params")
+            if not isinstance(params, dict):
+                return self._error(request_id, -32602, "params must be an object")
+            name = params.get("name")
+            arguments = params.get("arguments", {})
+            if not isinstance(name, str) or not name:
+                return self._error(request_id, -32602, "tool name is required")
+            if not isinstance(arguments, dict):
+                return self._error(request_id, -32602, "tool arguments must be an object")
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "result": self._call(name, dict(arguments)),
+            }
+
+        return self._error(request_id, -32601, f"method not found: {method}")
+
+    @staticmethod
+    def _error(request_id: object, code: int, message: str) -> dict[str, object]:
+        return {"jsonrpc": "2.0", "id": request_id, "error": {"code": code, "message": message}}
+
+    def serve_forever(self, stdin=None, stdout=None) -> None:
+        stdin = stdin or sys.stdin
+        stdout = stdout or sys.stdout
+        for line in stdin:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                message = json.loads(line)
+                if not isinstance(message, dict):
+                    raise ValueError("JSON-RPC message must be an object")
+                response = self.handle(message)
+            except Exception as exc:
+                response = self._error(None, -32603, str(exc))
+            if response is not None:
+                stdout.write(json.dumps(response, ensure_ascii=False) + "\n")
+                stdout.flush()

runtime/mcp/session.py

@@ -0,0 +1,19 @@
+"""MCP session registry."""
+from runtime.mcp.client import MCPClient, MCPError
+from core.contracts.mcp import MCPSession
+
+class MCPSessionRegistry:
+    def __init__(self): self._clients={}
+    def add(self,client:MCPClient)->MCPSession:
+        if client.session is None: raise MCPError("MCP client is not connected")
+        self._clients[client.session.id]=client
+        return client.session
+    def get(self,session_id:str)->MCPClient:
+        if session_id not in self._clients: raise MCPError(f"MCP session not found: {session_id}")
+        return self._clients[session_id]
+    def close(self,session_id:str)->None:
+        client=self._clients.pop(session_id,None)
+        if client: client.close()
+    def close_all(self)->None:
+        for client in list(self._clients.values()): client.close()
+        self._clients.clear()

runtime/model/__init__.py

@@ -0,0 +1,5 @@
+"""Provider-neutral VYRELON model runtime."""
+
+from runtime.model.ai_runtime import AIExecution, AIExecutionError, AIRuntime
+
+__all__ = ["AIExecution", "AIExecutionError", "AIRuntime"]

runtime/model/ai_runtime.py

@@ -0,0 +1,165 @@
+"""Provider-neutral AI execution runtime for VYRELON."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from dataclasses import dataclass
+
+from core.contracts.ai import ModelSpec
+from core.contracts.model_runtime import ModelAdapter, ModelRequest, ModelResponse
+from core.contracts.vyrelon_runtime import (
+    FallbackPolicy,
+    RuntimeEvent,
+    RuntimeEventKind,
+    SessionSpec,
+)
+
+
+class AIRuntimeError(RuntimeError):
+    """Base error raised by the VYRELON AI runtime."""
+
+
+class AIExecutionError(AIRuntimeError):
+    """Raised when all configured model attempts fail."""
+
+    def __init__(self, message: str, *, attempts: tuple[str, ...]) -> None:
+        super().__init__(message)
+        self.attempts = attempts
+
+
+@dataclass(frozen=True)
+class AIExecution:
+    """Normalized result of one AI runtime invocation."""
+
+    response: ModelResponse
+    model_id: str
+    attempts: tuple[str, ...]
+
+
+class AIRuntime:
+    """Execute provider-neutral model adapters without a harness abstraction."""
+
+    def __init__(
+        self,
+        *,
+        models: dict[str, ModelSpec],
+        adapters: dict[str, ModelAdapter],
+    ) -> None:
+        self._models = models
+        self._adapters = adapters
+
+    def execute(
+        self,
+        request: ModelRequest,
+        *,
+        model_id: str,
+        session: SessionSpec | None = None,
+        fallback: FallbackPolicy | None = None,
+    ) -> AIExecution:
+        candidates = self._candidates(model_id, fallback)
+        attempts: list[str] = []
+        errors: list[str] = []
+
+        for candidate in candidates:
+            attempts.append(candidate)
+            model = self._model(candidate)
+            adapter = self._adapter(model)
+            try:
+                response = adapter.generate(model, request)
+            except Exception as exc:
+                if not self._retryable(exc, fallback):
+                    raise
+                errors.append(f"{candidate}: {exc}")
+                continue
+
+            metadata = dict(response.metadata)
+            metadata.update(
+                {"provider_id": model.provider_id, "attempts": tuple(attempts)}
+            )
+            if session is not None:
+                metadata["session_id"] = session.id
+            normalized = ModelResponse(
+                text=response.text,
+                model_id=response.model_id or candidate,
+                metadata=metadata,
+            )
+            return AIExecution(
+                response=normalized,
+                model_id=normalized.model_id,
+                attempts=tuple(attempts),
+            )
+
+        detail = "; ".join(errors) if errors else "no model candidates"
+        raise AIExecutionError(
+            f"AI execution failed: {detail}",
+            attempts=tuple(attempts),
+        )
+
+    def events(
+        self,
+        request: ModelRequest,
+        *,
+        model_id: str,
+        session: SessionSpec | None = None,
+        fallback: FallbackPolicy | None = None,
+    ) -> Iterator[RuntimeEvent]:
+        """Expose normalized lifecycle events around a model invocation."""
+        sequence = 0
+
+        def emit(kind: RuntimeEventKind, payload: object = None):
+            nonlocal sequence
+            sequence += 1
+            return RuntimeEvent(
+                kind=kind,
+                session_id=session.id if session else None,
+                payload=payload,
+                sequence=sequence,
+            )
+
+        yield emit(RuntimeEventKind.REQUEST, {"model_id": model_id})
+        try:
+            execution = self.execute(
+                request,
+                model_id=model_id,
+                session=session,
+                fallback=fallback,
+            )
+            yield emit(
+                RuntimeEventKind.MESSAGE,
+                {"model_id": execution.model_id, "text": execution.response.text},
+            )
+            yield emit(
+                RuntimeEventKind.COMPLETED,
+                {"model_id": execution.model_id, "attempts": execution.attempts},
+            )
+        except Exception as exc:
+            yield emit(RuntimeEventKind.ERROR, {"error": str(exc)})
+            raise
+
+    def _candidates(
+        self, model_id: str, fallback: FallbackPolicy | None
+    ) -> tuple[str, ...]:
+        if fallback is None:
+            return (model_id,)
+        candidates = fallback.candidates()
+        return candidates or (model_id,)
+
+    def _model(self, model_id: str) -> ModelSpec:
+        try:
+            return self._models[model_id]
+        except KeyError as exc:
+            raise AIRuntimeError(f"Model not registered: {model_id}") from exc
+
+    def _adapter(self, model: ModelSpec) -> ModelAdapter:
+        try:
+            return self._adapters[model.id]
+        except KeyError as exc:
+            raise AIRuntimeError(
+                f"Model adapter not registered: {model.id}"
+            ) from exc
+
+    @staticmethod
+    def _retryable(exc: Exception, fallback: FallbackPolicy | None) -> bool:
+        if fallback is None or not fallback.retryable_errors:
+            return False
+        return exc.__class__.__name__ in fallback.retryable_errors

runtime/model/cli.py

@@ -0,0 +1,49 @@
+"""Generic CLI model adapter for any model exposed by a command-line client."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from dataclasses import dataclass
+
+from core.contracts.ai import ModelSpec
+from core.contracts.model_runtime import ModelRequest, ModelResponse
+from runtime.policy import ExecutionPolicy
+
+
+@dataclass(frozen=True)
+class CLIModelAdapter:
+    command: tuple[str, ...]
+    policy: ExecutionPolicy = ExecutionPolicy()
+    timeout: float = 300
+
+    def generate(self, model: ModelSpec, request: ModelRequest) -> ModelResponse:
+        if not self.policy.permits("process"):
+            raise PermissionError("Model CLI execution is disabled by policy")
+        if not self.command or not all(isinstance(part, str) and part for part in self.command):
+            raise ValueError("CLI adapter command must be a non-empty argv tuple")
+
+        prompt = request.prompt
+        if request.system:
+            prompt = f"{request.system}\n\n{prompt}"
+
+        environment = os.environ.copy()
+        completed = subprocess.run(
+            list(self.command),
+            input=prompt,
+            capture_output=True,
+            text=True,
+            timeout=self.timeout,
+            check=False,
+            env=environment,
+        )
+        if completed.returncode != 0:
+            raise RuntimeError(
+                f"Model CLI failed with exit code {completed.returncode}: {completed.stderr.strip()}"
+            )
+
+        return ModelResponse(
+            text=completed.stdout,
+            model_id=model.id,
+            metadata={"adapter": "cli"},
+        )