Add runner skill and show model

Author: shuds13

ensemble_agent/agent.py

@@ -26,6 +26,9 @@
 async def run_agent(config: AgentConfig):
     """Main entry point: build skills, connect MCP, run the agent loop."""
 
+    # Archive existing output dir before starting fresh
+    ArchiveManager.archive_existing_output_dir(config.output_dir)
+
     # Set up archive manager
     archive = ArchiveManager(config.output_dir)
 
@@ -55,9 +58,9 @@ async def run_agent(config: AgentConfig):
             tools.extend(skill.get_tools())
 
         # Create LLM and agent
-        llm = create_llm(config.model, config.temperature, config.base_url)
+        llm, service = create_llm(config.model, config.temperature, config.base_url)
         agent = create_agent(llm, tools)
-        print("Agent initialized\n")
+        print(f"Agent initialized (model: {config.model}, service: {service})\n")
 
         # Build system prompt
         system_prompt = build_system_prompt(skills, has_generator)

ensemble_agent/llm.py

@@ -4,18 +4,39 @@
 import sys
 
 
+def _service_label(model, base_url):
+    """Determine the service name from model and base_url."""
+    if "claude" in model.lower():
+        anthropic_base = os.environ.get("ANTHROPIC_BASE_URL", "")
+        if "anl.gov" in anthropic_base or "argo" in anthropic_base.lower():
+            return "Argo"
+        return "Anthropic"
+    if base_url:
+        if "anl.gov" in base_url or "argo" in base_url.lower():
+            return "Argo"
+        if "alcf" in base_url.lower():
+            return "ALCF"
+        return f"OpenAI-compatible ({base_url})"
+    return "OpenAI"
+
+
 def create_llm(model, temperature=0, base_url=None):
-    """Create LLM — ChatAnthropic for Claude models, ChatOpenAI otherwise."""
+    """Create LLM — ChatAnthropic for Claude models, ChatOpenAI otherwise.
+
+    Returns (llm, service_label).
+    """
+    service = _service_label(model, base_url)
     if "claude" in model.lower():
         try:
             from langchain_anthropic import ChatAnthropic
         except ImportError:
             sys.exit("Error: pip install langchain-anthropic required for Claude models")
         anthropic_base = os.environ.get("ANTHROPIC_BASE_URL")
-        return ChatAnthropic(
+        llm = ChatAnthropic(
             model=model, temperature=temperature, base_url=anthropic_base or None,
             streaming=True,
         )
+        return llm, service
     from langchain_openai import ChatOpenAI
 
-    return ChatOpenAI(model=model, temperature=temperature, base_url=base_url)
+    return ChatOpenAI(model=model, temperature=temperature, base_url=base_url), service

ensemble_agent/skills/runner.py

@@ -6,6 +6,7 @@
 from langchain_core.tools import StructuredTool
 
 from .base import Skill
+from ..config import MAX_RETRIES
 
 
 class RunScriptInput(BaseModel):
@@ -15,17 +16,29 @@ class RunScriptInput(BaseModel):
 class RunnerSkill(Skill):
     """Provides the run_script tool."""
 
+    def __init__(self, config, archive):
+        super().__init__(config, archive)
+        self._run_count = 0
+        self._max_runs = config.max_retries + 1  # initial run + retries
+
     def get_tools(self):
         work_dir = self.archive.work_dir
         archive = self.archive
         timeout = self.config.script_timeout
+        skill = self
 
         async def run_script_tool(script_name: str) -> str:
+            skill._run_count += 1
+            if skill._run_count > skill._max_runs:
+                msg = f"RUN LIMIT REACHED ({skill._max_runs} runs). Stop and report the current status to the user."
+                print(f"\n{msg}", flush=True)
+                return msg
+
             script_path = work_dir / script_name
             if not script_path.exists():
                 return f"ERROR: Script '{script_name}' not found"
 
-            print(f"\nRunning {script_name}...", flush=True)
+            print(f"\nRunning {script_name}... (run {skill._run_count}/{skill._max_runs})", flush=True)
             try:
                 result = subprocess.run(
                     ["python", script_name],
@@ -45,10 +58,12 @@ async def run_script_tool(script_name: str) -> str:
                     )
                     print(f"Failed (code {result.returncode})", flush=True)
                     archive.archive_run_output(error_msg)
+                    remaining = skill._max_runs - skill._run_count
                     return (
                         f"FAILED (code {result.returncode})\n"
                         f"Stderr:\n{result.stderr}\n"
-                        f"Stdout:\n{result.stdout[:500]}"
+                        f"Stdout:\n{result.stdout[:500]}\n"
+                        f"\nYou have {remaining} run(s) remaining."
                     )
             except subprocess.TimeoutExpired:
                 return f"ERROR: Script timed out ({timeout}s)"