agent-devkit 0.1.0 → 0.1.6

package/runtime/cli/aikit/fallback.py

@@ -6,7 +6,7 @@ from pathlib import Path
 from typing import Any
 
 from cli.aikit.credentials import CredentialResolverError
-from cli.aikit.providers import ProviderRegistryError, provider_status_with_credentials
+from cli.aikit.providers import ProviderRegistryError, load_providers, provider_status_with_credentials
 
 
 READY_PROVIDER_STATUSES = {"ok", "unknown"}
@@ -20,9 +20,11 @@ FALLBACKS = {
 }
 
 
-def evaluate_provider_requirements(root: Path, capability: dict[str, Any]) -> dict[str, Any]:
+def evaluate_provider_requirements(root: Path, capability: dict[str, Any], args: list[str] | None = None) -> dict[str, Any]:
     """Evaluate `requires.providers` without returning credential values."""
     requirements = provider_requirements(capability)
+    if not requirements and not has_fixture_arg(args or []):
+        requirements = infer_provider_requirements(root, capability)
     providers = {
         "used": [],
         "missing": [],
@@ -75,6 +77,50 @@ def provider_requirements(capability: dict[str, Any]) -> list[dict[str, Any]]:
     return [item for item in providers if isinstance(item, dict)]
 
 
+def infer_provider_requirements(root: Path, capability: dict[str, Any]) -> list[dict[str, Any]]:
+    capability_id = str(capability.get("id") or "")
+    if "." not in capability_id:
+        return []
+    agent_id, short_capability = capability_id.rsplit(".", 1)
+    candidates = {f"{agent_id}/{short_capability}", capability_id}
+    requirements: list[dict[str, Any]] = []
+    try:
+        providers = load_providers(root)
+    except ProviderRegistryError:
+        return []
+    for provider in providers:
+        capabilities = provider.get("capabilities") if isinstance(provider.get("capabilities"), dict) else {}
+        matched_mode = None
+        for mode in ("read", "write"):
+            declared = capabilities.get(mode) if isinstance(capabilities, dict) else []
+            if any(str(item) in candidates for item in (declared or [])):
+                matched_mode = mode
+                break
+        if not matched_mode:
+            continue
+        fallbacks = list(provider.get("fallbacks", []) or [])
+        requirements.append(
+            {
+                "id": provider.get("id"),
+                "mode": "required",
+                "fallback": fallbacks[0] if fallbacks else "blocked",
+                "purpose": f"inferred from provider registry for {agent_id}/{short_capability}",
+                "access": matched_mode,
+                "inferred": True,
+            }
+        )
+    return requirements
+
+
+def has_fixture_arg(args: list[str]) -> bool:
+    for index, item in enumerate(args):
+        if item == "--fixture" and index + 1 < len(args):
+            return True
+        if item.startswith("--fixture="):
+            return True
+    return False
+
+
 def provider_detail(requirement: dict[str, Any], status_item: dict[str, Any]) -> dict[str, Any]:
     provider_id = str(requirement.get("id") or "")
     return {

package/runtime/cli/aikit/install.py

@@ -9,7 +9,7 @@ from pathlib import Path
 from typing import Any
 
 from cli.aikit import __version__
-from cli.aikit.lock import lock_path, write_lock
+from cli.aikit.lock import GLOBAL_RUNTIME_DIR, PROJECT_RUNTIME_DIR, lock_path, write_lock
 
 
 HOST_ALIASES = {
@@ -46,7 +46,7 @@ def install_runtime(
     hosts = resolve_hosts(host)
     root = root.resolve()
     base = resolve_base(scope, target=target, home=home)
-    runtime_dir = base / ".ai-devkit"
+    runtime_dir = base / (GLOBAL_RUNTIME_DIR if scope == "global" else PROJECT_RUNTIME_DIR)
     bin_dir = runtime_dir / "bin"
     config_path = runtime_dir / "config.yaml"
     runtime_lock_path = lock_path(base, scope)
@@ -256,7 +256,8 @@ def write_runtime_config(path: Path, root: Path, scope: str, hosts: tuple[str, .
 
 
 def next_steps(scope: str, hosts: tuple[str, ...]) -> list[str]:
-    steps = ["Add `.ai-devkit/bin` to PATH when you want to call the installed `agent` directly."]
+    runtime_dir_name = GLOBAL_RUNTIME_DIR if scope == "global" else PROJECT_RUNTIME_DIR
+    steps = [f"Add `{runtime_dir_name}/bin` to PATH when you want to call the installed `agent` directly."]
     steps.append("Run `agent doctor --json` to validate the local runtime.")
     if "codex" in hosts:
         steps.append("Restart or reload Codex so it can discover the AI DevKit plugin/skill.")

package/runtime/cli/aikit/llm.py

@@ -159,6 +159,8 @@ def list_backends() -> dict[str, Any]:
     default_backend = config.get("llm", {}).get("default")
     configured = set(config.get("llm", {}).get("backends", {}))
     preference = llm_preference(config)
+    from cli.aikit.decision_store import get_decision
+
     return {
         "kind": "llm-backends",
         "config_path": str(config_path()),
@@ -179,6 +181,8 @@ def list_backends() -> dict[str, Any]:
                 "default_model": backend.default_model,
                 "command": backend.command,
                 "notes": backend.notes,
+                "decision": get_decision("llms", backend.id),
+                "enabled": not bool((get_decision("llms", backend.id) or {}).get("state") in {"disabled_by_user", "denied_by_user"}),
             }
             for backend in BACKENDS.values()
         ],
@@ -445,6 +449,11 @@ def candidate_backend_ids(
     llm = config.get("llm") if isinstance(config.get("llm"), dict) else {}
     configured = llm.get("backends") if isinstance(llm.get("backends"), dict) else {}
     configured_ids = [backend_id for backend_id in configured if backend_id in BACKENDS]
+    if not configured_ids:
+        return []
+    from cli.aikit.decision_store import is_disabled
+
+    configured_ids = [backend_id for backend_id in configured_ids if not is_disabled("llms", backend_id)]
     if not configured_ids:
         return []
     preference = llm_preference(config)

package/runtime/cli/aikit/local_llm_operator.py

@@ -0,0 +1,112 @@
+"""Runtime execution for the local-llm-operator agent."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from cli.aikit.llm import invoke_agent_prompt
+from cli.aikit.memory import redact_secrets
+
+
+FORBIDDEN_DELEGATION_MARKERS = (
+    "aprove",
+    "aprovar",
+    "reprove",
+    "reprovar",
+    "deploy",
+    "delete",
+    "excluir",
+    "execute escrita",
+    "permissao",
+    "permissão",
+)
+
+
+def maybe_delegate_local_llm(prompt: str, model_plan: dict[str, Any]) -> dict[str, Any]:
+    """Execute a bounded operational task with Ollama when the model plan selected it."""
+    delegation = model_plan.get("delegation") if isinstance(model_plan.get("delegation"), dict) else {}
+    if not model_plan.get("local_llm_selected") or not delegation.get("selected"):
+        return skipped("not-selected", "Local LLM delegation was not selected for this prompt.", model_plan=model_plan)
+    lowered = prompt.lower()
+    if any(marker in lowered for marker in FORBIDDEN_DELEGATION_MARKERS):
+        return skipped("forbidden", "Prompt contains an action that local LLM workers cannot execute.", model_plan=model_plan)
+    delegated_prompt = build_delegated_prompt(prompt, model_plan)
+    result = invoke_agent_prompt(
+        delegated_prompt,
+        "ollama",
+        public_name="Local LLM Operator",
+        allow_fallback=False,
+    )
+    payload = {
+        "kind": "local-llm-execution",
+        "agent_id": "local-llm-operator",
+        "capability_id": "delegate-operational-task",
+        "capability": "local-llm-operator.delegate-operational-task",
+        "status": "ok" if result.get("ok") else result.get("status", "failed"),
+        "ok": bool(result.get("ok")),
+        "llm_backend": result.get("llm_backend"),
+        "model_provider": "ollama",
+        "delegated_prompt": redact_secrets(delegated_prompt),
+        "response": result.get("response"),
+        "result": sanitize_llm_result(result),
+        "requires_review": True,
+    }
+    if not result.get("ok"):
+        payload["message"] = result.get("message") or "Local LLM delegation failed."
+    return payload
+
+
+def build_delegated_prompt(prompt: str, model_plan: dict[str, Any]) -> str:
+    forbidden = ", ".join((model_plan.get("delegation") or {}).get("forbidden_actions") or [])
+    return "\n".join(
+        [
+            "Execute apenas a parte operacional da tarefa abaixo.",
+            "Nao tome decisao final, nao aprove, nao escreva externamente e nao revise a entrega final.",
+            f"Acoes proibidas: {forbidden}.",
+            "Retorne um resumo estruturado, evidencias extraidas, lacunas e confianca.",
+            "",
+            "Tarefa original:",
+            redact_secrets(prompt),
+        ]
+    )
+
+
+def enrich_prompt_with_local_result(prompt: str, local_execution: dict[str, Any]) -> str:
+    if not local_execution.get("ok") or not local_execution.get("response"):
+        return prompt
+    return "\n".join(
+        [
+            prompt,
+            "",
+            "Contexto operacional produzido pelo local-llm-operator/Ollama:",
+            str(local_execution["response"]),
+            "",
+            "Use esse contexto apenas como apoio. A decisao, resposta final e revisao continuam sob responsabilidade do coordenador.",
+        ]
+    )
+
+
+def skipped(reason: str, message: str, *, model_plan: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "kind": "local-llm-execution",
+        "agent_id": "local-llm-operator",
+        "capability_id": "delegate-operational-task",
+        "capability": "local-llm-operator.delegate-operational-task",
+        "status": "skipped",
+        "ok": False,
+        "reason": reason,
+        "message": message,
+        "model_provider": model_plan.get("local_llm_provider") or "ollama",
+        "requires_review": bool(model_plan.get("local_llm_recommended") or model_plan.get("local_llm_selected")),
+    }
+
+
+def sanitize_llm_result(result: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "status": result.get("status"),
+        "ok": result.get("ok"),
+        "llm_backend": result.get("llm_backend"),
+        "llm_backend_attempts": result.get("llm_backend_attempts"),
+        "message": result.get("message"),
+        "exit_code": result.get("exit_code"),
+    }

package/runtime/cli/aikit/lock.py

@@ -14,11 +14,14 @@ from cli.aikit import __version__
 
 PROJECT_LOCK_NAME = "ai-devkit.lock"
 GLOBAL_LOCK_NAME = "runtime.lock"
+PROJECT_RUNTIME_DIR = ".ai-devkit"
+GLOBAL_RUNTIME_DIR = ".agent-devkit"
 
 
 def lock_path(base: Path, scope: str) -> Path:
     name = GLOBAL_LOCK_NAME if scope == "global" else PROJECT_LOCK_NAME
-    return base / ".ai-devkit" / name
+    runtime_dir = GLOBAL_RUNTIME_DIR if scope == "global" else PROJECT_RUNTIME_DIR
+    return base / runtime_dir / name
 
 
 def write_lock(