machinaos 0.0.76 → 0.0.78

package/server/nodes/agent/ai_agent.py

@@ -41,6 +41,12 @@ class AIAgentParams(BaseModel):
     provider: Literal[
         "openai", "anthropic", "gemini", "openrouter",
         "groq", "cerebras", "deepseek", "kimi", "mistral",
+        # Local-server providers — agent execution reads
+        # ``{provider}_proxy`` to point the LangChain client at the
+        # user's localhost server. Without these entries the dropdown
+        # silently falls back to ``"openai"`` and execute_agent ends
+        # up calling api.openai.com instead.
+        "ollama", "lmstudio",
     ] = "openai"
     model: str = Field(
         default="", json_schema_extra={"placeholder": "Select a model..."},
@@ -114,18 +120,22 @@ class AIAgentNode(ActionNode):
         underlying LangGraph orchestration + tool binding + memory
         I/O + streaming hooks stay in AIService.
         """
-        from core.container import container
+        from services.plugin.deps import get_ai_service, get_database
 
         from ._inline import prepare_agent_call
 
-        ai_service = container.ai_service()
-        database = container.database()
+        ai_service = get_ai_service()
+        database = get_database()
         kwargs = await prepare_agent_call(
             node_id=ctx.node_id, node_type=self.type,
             parameters=params.model_dump(),
             context=ctx.raw, database=database,
             log_prefix="[AI Agent]",
         )
+        # ``execute_agent`` raises ``NodeUserError`` directly for typed
+        # openai SDK failures (context overflow, bad key, server down).
+        # Anything that comes back here as ``success=False`` is a real
+        # bug worth a stacktrace via ``RuntimeError``.
         response = await ai_service.execute_agent(ctx.node_id, **kwargs)
         if response.get("success"):
             return response.get("result") or response

package/server/nodes/agent/chat_agent.py

@@ -28,6 +28,9 @@ class ChatAgentParams(BaseModel):
     provider: Literal[
         "openai", "anthropic", "gemini", "openrouter",
         "groq", "cerebras", "deepseek", "kimi", "mistral",
+        # Local-server providers — see ai_agent.Params for the proxy_url
+        # rationale. Same fix; same reason.
+        "ollama", "lmstudio",
     ] = "openai"
     model: str = Field(
         default="", json_schema_extra={"placeholder": "Select a model..."},
@@ -100,12 +103,12 @@ class ChatAgentNode(ActionNode):
     @Operation("execute", cost={"service": "chat_agent", "action": "run", "count": 1})
     async def execute_op(self, ctx: NodeContext, params: ChatAgentParams) -> Any:
         """Inlined from handlers/ai.handle_chat_agent (Wave 11.D.6)."""
-        from core.container import container
+        from services.plugin.deps import get_ai_service, get_database
 
         from ._inline import prepare_agent_call
 
-        ai_service = container.ai_service()
-        database = container.database()
+        ai_service = get_ai_service()
+        database = get_database()
         kwargs = await prepare_agent_call(
             node_id=ctx.node_id, node_type=self.type,
             parameters=params.model_dump(),

package/server/nodes/agent/claude_code_agent.py

@@ -1,48 +1,123 @@
-"""Claude Code Agent — Wave 11.E.3 inlined.
+"""Claude Code Agent — multi-instance via `AICliService`.
 
-Shells out to the local ``claude`` CLI binary (isolated auth via
-``services/claude_oauth.py``). Status updates broadcast on entry +
-exit; skill instructions concatenated into the system prompt.
+Refactored from the single-task shim. ``Params.tasks`` is a list of
+``ClaudeTaskSpec``; each task gets its own git worktree, its own session
+id, and runs in parallel under a 5-way semaphore.
+
+Back-compat: an empty `tasks` array with a non-empty `prompt` falls back
+to a single-task batch — preserves the legacy single-shot UX.
+
+Skill instructions connected via the parent node's ``input-skill`` handle
+are exposed to the CLI through the MCP server's ``listSkills`` /
+``getSkill`` tools (NOT concatenated into the system prompt — the
+agent fetches them on-demand). Connected skill names ARE collected here
+and passed to ``run_batch()`` so the MCP server can scope its responses.
 """
 
 from __future__ import annotations
 
 import time
+import uuid
 from datetime import datetime
-from typing import Any, Optional
+from pathlib import Path
+from typing import Any, List, Optional
 
-from pydantic import ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 from core.logging import get_logger
-from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+from services.plugin import ActionNode, NodeContext, NodeUserError, Operation, TaskQueue
 from services.plugin.edge_walker import collect_agent_connections
 
 from ._handles import STD_AGENT_HINTS, std_agent_handles
-from ._specialized import SpecializedAgentOutput, SpecializedAgentParams
 
 logger = get_logger(__name__)
 
 
-class ClaudeCodeAgentParams(SpecializedAgentParams):
-    """Adds CLI-specific flags the handler body reads from payload."""
+# Late import the cli_agent types so node_registry import doesn't pull
+# the whole MCP / pool stack at module import time.
+from services.cli_agent import ClaudeTaskSpec  # noqa: E402
+from services.cli_agent.types import SessionResultModel  # noqa: E402
 
-    max_turns: int = Field(default=10, ge=1)
-    max_budget_usd: float = Field(default=5.0, ge=0.0)
-    system_prompt: Optional[str] = Field(default=None)
-    working_directory: Optional[str] = Field(default=None)
-    allowed_tools: str = Field(
-        default="Read,Edit,Bash,Glob,Grep,Write",
-        )
+
+class ClaudeCodeAgentParams(BaseModel):
+    """Multi-task batch parameters for Claude Code.
+
+    Two paths:
+      1. ``tasks=[...]`` — explicit list, runs N in parallel
+      2. ``tasks=[]`` + legacy ``prompt`` — synthesises a single-task batch
+    """
+
+    tasks: List[ClaudeTaskSpec] = Field(
+        default_factory=list,
+        description="List of Claude tasks to run in parallel (max 5 concurrent).",
+        json_schema_extra={"rows": 1},
+    )
+    # Legacy single-task fallback ----------------------------------------
+    prompt: str = Field(
+        default="",
+        description="Legacy: single-prompt fallback used only when "
+                    "`tasks` is empty.",
+        json_schema_extra={"rows": 4, "placeholder": "Or use the tasks array..."},
+    )
+    model: str = Field(
+        default="claude-sonnet-4-6",
+        description="Default model for tasks that don't override it.",
+    )
+    system_prompt: Optional[str] = Field(default=None, json_schema_extra={"rows": 3})
+    working_directory: Optional[str] = Field(
+        default=None,
+        description="Git repo root. Defaults to the workflow's workspace dir.",
+    )
+    max_parallel: int = Field(
+        default=5, ge=1, le=20,
+        description="Concurrency cap.",
+    )
+    allowed_credentials: List[str] = Field(
+        default_factory=list,
+        description="Credential names the CLI is permitted to fetch via MCP.",
+    )
+
+    # Saved workflow JSON may persist these list fields as `null` rather
+    # than `[]` when the user has never edited them. Coerce so Pydantic's
+    # strict list validation doesn't reject the params on load.
+    @field_validator("tasks", "allowed_credentials", mode="before")
+    @classmethod
+    def _none_is_empty_list(cls, v: Any) -> Any:
+        return [] if v is None else v
 
     model_config = ConfigDict(extra="ignore")
 
 
+class ClaudeCodeAgentOutput(BaseModel):
+    """Aggregated batch output."""
+    success: bool = True
+    n_tasks: int = 0
+    n_succeeded: int = 0
+    n_failed: int = 0
+    total_cost_usd: Optional[float] = None
+    wall_clock_ms: int = 0
+    tasks: List[SessionResultModel] = Field(default_factory=list)
+    provider: str = "claude"
+    timestamp: Optional[str] = None
+    # Legacy single-task fields, populated when n_tasks==1 for back-compat:
+    response: Optional[str] = None
+    session_id: Optional[str] = None
+    cost_usd: Optional[float] = None
+    # `extra="forbid"` so a malformed CLI envelope raises a real
+    # ValidationError at the Output boundary instead of silently emitting
+    # an unparseable shape downstream.
+    model_config = ConfigDict(extra="forbid")
+
+
 class ClaudeCodeAgentNode(ActionNode):
     type = "claude_code_agent"
     display_name = "Claude Code"
     subtitle = "Agentic Coding"
     group = ("agent",)
-    description = "Claude Code CLI as a specialized agent"
+    description = (
+        "Run N parallel Claude Code CLI sessions over a list of tasks. "
+        "Each task is isolated in its own git worktree."
+    )
     component_kind = "agent"
     handles = std_agent_handles()
     ui_hints = STD_AGENT_HINTS
@@ -50,84 +125,221 @@ class ClaudeCodeAgentNode(ActionNode):
     task_queue = TaskQueue.AI_HEAVY
 
     Params = ClaudeCodeAgentParams
-    Output = SpecializedAgentOutput
+    Output = ClaudeCodeAgentOutput
 
-    @Operation("execute", cost={"service": "claude_code_agent", "action": "run", "count": 1})
-    async def execute_op(self, ctx: NodeContext, params: ClaudeCodeAgentParams) -> Any:
-        from core.container import container
-        from services.claude_code_service import get_claude_code_service
+    @Operation(
+        "execute",
+        cost={"service": "claude_code_agent", "action": "run", "count": 1},
+    )
+    async def execute_op(
+        self, ctx: NodeContext, params: ClaudeCodeAgentParams,
+    ) -> Any:
+        from services.cli_agent.service import get_ai_cli_service
+        from services.cli_agent.types import session_result_to_model
+        from services.plugin.deps import get_database
         from services.status_broadcaster import get_status_broadcaster
 
         start_time = time.time()
         broadcaster = get_status_broadcaster()
         workflow_id = ctx.workflow_id
         node_id = ctx.node_id
-        payload = params.model_dump()
 
         await broadcaster.update_node_status(
             node_id, "executing",
-            {"message": "Starting Claude Code..."},
+            {"message": "Starting Claude Code batch..."},
             workflow_id=workflow_id,
         )
 
-        # Resolve prompt: explicit param wins; otherwise pull text from
-        # the upstream node connected to input-main.
-        prompt = payload.get("prompt", "")
-        if not prompt:
-            for edge in ctx.raw.get("edges", []):
-                if edge.get("target") == node_id and edge.get("targetHandle") in ("input-main", None):
-                    src = ctx.raw.get("outputs", {}).get(edge.get("source"), {})
-                    if isinstance(src, dict):
-                        prompt = src.get("message") or src.get("text") or src.get("content") or str(src)
-                    elif src:
-                        prompt = str(src)
-                    if prompt:
-                        break
-        if not prompt:
-            raise RuntimeError("No prompt provided")
-
-        database = container.database()
-        _, skill_data, _, _, _ = await collect_agent_connections(node_id, ctx.raw, database)
-
-        system_parts = []
-        if payload.get("system_prompt"):
-            system_parts.append(payload["system_prompt"])
-        for skill in skill_data:
-            instr = skill.get("parameters", {}).get("instructions", "")
-            if instr:
-                system_parts.append(instr)
-
-        model = payload.get("model", "claude-sonnet-4-6")
-        await broadcaster.update_node_status(
-            node_id, "executing",
-            {"message": f"Running Claude Code ({model})..."},
-            workflow_id=workflow_id,
+        # Collect connected memory/skills/tools/input/task in one pass —
+        # same edge-walker the AI Agent uses (services/plugin/edge_walker.py).
+        # This must run BEFORE prompt resolution so the auto-fallback can
+        # read from `input_data` exactly the way `nodes/agent/_inline.py`
+        # does for the standard agent path.
+        database = get_database()
+        memory_data, skill_data, tool_data, input_data, _ = (
+            await collect_agent_connections(
+                node_id, ctx.raw, database, log_prefix="[Claude Code]",
+            )
         )
+        connected_skills = [
+            s.get("skill_name") or s.get("label")
+            for s in skill_data
+            if s.get("skill_name") or s.get("label")
+        ]
 
-        service = get_claude_code_service()
-        data = await service.execute(
-            prompt=prompt,
+        # Memory bridge: claude maintains its own session JSONL on disk
+        # under `<CLAUDE_CONFIG_DIR>/projects/<cwd-encoded>/<UUID>.jsonl`.
+        # The project_key is derived from cwd (`[^a-zA-Z0-9.-] -> -`),
+        # so memory continuity needs (a) a STABLE cwd across runs and
+        # (b) the right session_id passed on argv.
+        #
+        # (a) is handled by AICliService passing memory_bound=True so
+        # AICliSession spawns under repo_root instead of an ephemeral
+        # worktree — see `services/cli_agent/session.py:cwd()`.
+        #
+        # (b) splits on whether claude has run for this memory before:
+        #
+        #   - First run (no last_session_id): pass `--session-id <UUID5>`
+        #     where UUID5 is deterministically derived from
+        #     (memory_node_id, simpleMemory.session_id). Claude creates
+        #     the session at exactly that UUID, writes its JSONL to a
+        #     predictable location. _persist_memory saves the same
+        #     UUID as last_session_id after success.
+        #
+        #   - Subsequent runs: pass `--resume <last_session_id>`.
+        #     Claude finds its own JSONL and continues.
+        #
+        # Stale-`last_session_id` self-healing: if `--resume` fails with
+        # "No conversation found", `_persist_memory` clears the stale
+        # UUID; the next run falls into the first-run branch and
+        # recovers automatically.
+        resume_session_id: Optional[str] = None
+        first_run_session_uuid: Optional[str] = None
+        if memory_data:
+            last = memory_data.get("last_session_id") or None
+            if last:
+                resume_session_id = last
+            else:
+                raw = memory_data.get("session_id") or memory_data["node_id"]
+                name = f"{memory_data['node_id']}:{raw}"
+                first_run_session_uuid = str(
+                    uuid.uuid5(uuid.NAMESPACE_OID, name)
+                )
+            logger.info(
+                "[Claude Code memory] memory_node=%s last_session_id=%s "
+                "-> %s",
+                memory_data.get("node_id"),
+                last,
+                f"--resume {resume_session_id}" if resume_session_id
+                else f"--session-id {first_run_session_uuid} (first run)",
+            )
+
+        tasks = list(params.tasks)
+        if not tasks:
+            # AI-Agent-style prompt resolution: explicit `prompt` field
+            # wins; otherwise extract from upstream input via the same
+            # `message > text > content > str()` chain `_inline.py` uses.
+            prompt = (params.prompt or "").strip()
+            if not prompt and input_data:
+                prompt = (
+                    (input_data.get("message") if isinstance(input_data, dict) else None)
+                    or (input_data.get("text") if isinstance(input_data, dict) else None)
+                    or (input_data.get("content") if isinstance(input_data, dict) else None)
+                    or str(input_data)
+                )
+            if not prompt:
+                raise NodeUserError(
+                    "Claude Code agent has no prompt — fill in the Prompt "
+                    "field, populate the Tasks array, or connect a node "
+                    "to the Input handle."
+                )
+            spec_kwargs: dict = {
+                "prompt": prompt,
+                "model": params.model,
+                "system_prompt": params.system_prompt,
+            }
+            if resume_session_id:
+                spec_kwargs["resume_session_id"] = resume_session_id
+            elif first_run_session_uuid:
+                spec_kwargs["session_id"] = first_run_session_uuid
+            tasks = [ClaudeTaskSpec(**spec_kwargs)]
+        else:
+            # Apply node-level defaults to tasks that don't override.
+            for i, t in enumerate(tasks):
+                changed: dict = {}
+                if not t.model and params.model:
+                    changed["model"] = params.model
+                if not t.system_prompt and params.system_prompt:
+                    changed["system_prompt"] = params.system_prompt
+                if not t.session_id and not t.resume_session_id:
+                    if resume_session_id:
+                        changed["resume_session_id"] = resume_session_id
+                    elif first_run_session_uuid:
+                        changed["session_id"] = first_run_session_uuid
+                if changed:
+                    tasks[i] = t.model_copy(update=changed)
+
+        # Memory continuity requires serial execution; parallel
+        # `--resume` against one session JSONL would corrupt it.
+        if memory_data and len(tasks) > 1:
+            raise NodeUserError(
+                "Memory-bound batches must run one task at a time. "
+                "Reduce Tasks to a single entry, or disconnect the "
+                "memory node."
+            )
+
+        # Workspace dir — workflow.py injects this into context
+        workspace_dir = ctx.raw.get("workspace_dir") or params.working_directory
+        if workspace_dir is None:
+            from core.config import Settings
+            workspace_dir = Path(Settings().workspace_base_resolved) / (
+                workflow_id or "default"
+            )
+        workspace_dir = Path(workspace_dir)
+
+        repo_root = (
+            Path(params.working_directory) if params.working_directory else None
+        )
+
+        svc = get_ai_cli_service()
+        result = await svc.run_batch(
+            "claude",
+            tasks=tasks,
             node_id=node_id,
-            model=model,
-            cwd=payload.get("working_directory") or None,
-            allowed_tools=payload.get("allowed_tools", "Read,Edit,Bash,Glob,Grep,Write"),
-            max_turns=int(payload.get("max_turns", 10)),
-            max_budget_usd=float(payload.get("max_budget_usd", 5.0)),
-            system_prompt="\n\n".join(system_parts) if system_parts else None,
+            workflow_id=workflow_id or "",
+            workspace_dir=workspace_dir,
+            broadcaster=broadcaster,
+            repo_root=repo_root,
+            connected_skill_names=connected_skills,
+            connected_tools=tool_data,
+            connected_memory=memory_data,
+            allowed_credentials=params.allowed_credentials,
+            max_parallel=params.max_parallel,
+        )
+
+        elapsed = time.time() - start_time
+        logger.debug(
+            "[claude_code_agent] node=%s tasks=%d ok=%d fail=%d elapsed=%.2fs",
+            node_id, result.n_tasks, result.n_succeeded, result.n_failed, elapsed,
         )
 
         await broadcaster.update_node_status(
-            node_id, "success",
-            {"message": "Claude Code completed"},
+            node_id, "success" if result.n_failed == 0 else "warning",
+            {
+                "message": (
+                    f"Batch complete: {result.n_succeeded}/{result.n_tasks} "
+                    f"succeeded"
+                ),
+                "n_tasks": result.n_tasks,
+                "n_succeeded": result.n_succeeded,
+                "n_failed": result.n_failed,
+            },
             workflow_id=workflow_id,
         )
-        logger.debug("[ClaudeCode] node=%s elapsed=%.2fs", node_id, time.time() - start_time)
+
+        task_models = [session_result_to_model(t).model_dump() for t in result.tasks]
+
+        # Legacy single-task convenience fields
+        legacy_response = None
+        legacy_session_id = None
+        legacy_cost = None
+        if len(result.tasks) == 1:
+            legacy_response = result.tasks[0].response
+            legacy_session_id = result.tasks[0].session_id
+            legacy_cost = result.tasks[0].cost_usd
 
         return {
-            "response": data.get("result", ""),
-            "model": model,
-            "provider": "anthropic",
-            "session_id": data.get("session_id", ""),
-            "usage": data.get("usage", {}),
-            "timestamp": datetime.now().isoformat(),
+            "success": result.n_failed == 0,
+            "n_tasks": result.n_tasks,
+            "n_succeeded": result.n_succeeded,
+            "n_failed": result.n_failed,
+            "total_cost_usd": result.total_cost_usd,
+            "wall_clock_ms": result.wall_clock_ms,
+            "tasks": task_models,
+            "provider": result.provider,
+            "timestamp": result.timestamp or datetime.now().isoformat(),
+            "response": legacy_response,
+            "session_id": legacy_session_id,
+            "cost_usd": legacy_cost,
         }
+