adding support for claude code routing (#575)

* fixed for claude code routing. first commit

* removing redundant enum tags for cache_control

* making sure that claude code can run via the archgw cli

* fixing broken config

* adding a README.md and updated the cli to use more of our defined patterns for params

* fixed config.yaml

* minor fixes to make sure PR is clean. Ready to ship

* adding claude-sonnet-4-5 to the config

* fixes based on PR

* fixed alias for README

* fixed 400 error handling tests, now that we write temperature to 1.0 for GPT-5

---------

Co-authored-by: Salman Paracha <salmanparacha@MacBook-Pro-257.local>
Co-authored-by: Salman Paracha <salmanparacha@MacBook-Pro-288.local>

arch/tools/cli/config_generator.py

@@ -242,7 +242,7 @@ def validate_and_render_schema():
     if llm_gateway_listener.get("address") == None:
         llm_gateway_listener["address"] = "127.0.0.1"
     if llm_gateway_listener.get("timeout") == None:
-        llm_gateway_listener["timeout"] = "10s"
+        llm_gateway_listener["timeout"] = "300s"
 
     use_agent_orchestrator = config_yaml.get("overrides", {}).get(
         "use_agent_orchestrator", False

arch/tools/cli/core.py

@@ -1,3 +1,4 @@
+import json
 import subprocess
 import os
 import time
@@ -185,3 +186,93 @@ def stop_arch_modelserver():
     except subprocess.CalledProcessError as e:
         log.info(f"Failed to start model_server. Please check archgw_modelserver logs")
         sys.exit(1)
+
+
+def start_cli_agent(arch_config_file=None, settings_json="{}"):
+    """Start a CLI client connected to Arch."""
+
+    with open(arch_config_file, "r") as file:
+        arch_config = file.read()
+        arch_config_yaml = yaml.safe_load(arch_config)
+
+    # Get egress listener configuration
+    egress_config = arch_config_yaml.get("listeners", {}).get("egress_traffic", {})
+    host = egress_config.get("host", "127.0.0.1")
+    port = egress_config.get("port", 12000)
+
+    # Parse additional settings from command line
+    try:
+        additional_settings = json.loads(settings_json) if settings_json else {}
+    except json.JSONDecodeError:
+        log.error("Settings must be valid JSON")
+        sys.exit(1)
+
+    # Set up environment variables
+    env = os.environ.copy()
+    env.update(
+        {
+            "ANTHROPIC_AUTH_TOKEN": "test",  # Use test token for arch
+            "ANTHROPIC_API_KEY": "",
+            "ANTHROPIC_BASE_URL": f"http://{host}:{port}",
+            "NO_PROXY": host,
+            "DISABLE_TELEMETRY": "true",
+            "DISABLE_COST_WARNINGS": "true",
+            "API_TIMEOUT_MS": "600000",
+        }
+    )
+
+    # Set ANTHROPIC_SMALL_FAST_MODEL from additional_settings or model alias
+    if "ANTHROPIC_SMALL_FAST_MODEL" in additional_settings:
+        env["ANTHROPIC_SMALL_FAST_MODEL"] = additional_settings[
+            "ANTHROPIC_SMALL_FAST_MODEL"
+        ]
+    else:
+        # Check if arch.claude.code.small.fast alias exists in model_aliases
+        model_aliases = arch_config_yaml.get("model_aliases", {})
+        if "arch.claude.code.small.fast" in model_aliases:
+            env["ANTHROPIC_SMALL_FAST_MODEL"] = "arch.claude.code.small.fast"
+        else:
+            log.info(
+                "Tip: Set an alias 'arch.claude.code.small.fast' in your model_aliases config to set a small fast model Claude Code"
+            )
+            log.info("Or provide ANTHROPIC_SMALL_FAST_MODEL in --settings JSON")
+
+    # Non-interactive mode configuration from additional_settings only
+    if additional_settings.get("NON_INTERACTIVE_MODE", False):
+        env.update(
+            {
+                "CI": "true",
+                "FORCE_COLOR": "0",
+                "NODE_NO_READLINE": "1",
+                "TERM": "dumb",
+            }
+        )
+
+    # Build claude command arguments
+    claude_args = []
+
+    # Add settings if provided, excluding those already handled as environment variables
+    if additional_settings:
+        # Filter out settings that are already processed as environment variables
+        claude_settings = {
+            k: v
+            for k, v in additional_settings.items()
+            if k not in ["ANTHROPIC_SMALL_FAST_MODEL", "NON_INTERACTIVE_MODE"]
+        }
+        if claude_settings:
+            claude_args.append(f"--settings={json.dumps(claude_settings)}")
+
+    # Use claude from PATH
+    claude_path = "claude"
+    log.info(f"Connecting Claude Code Agent to Arch at {host}:{port}")
+
+    try:
+        subprocess.run([claude_path] + claude_args, env=env, check=True)
+    except subprocess.CalledProcessError as e:
+        log.error(f"Error starting claude: {e}")
+        sys.exit(1)
+    except FileNotFoundError:
+        log.error(
+            f"{claude_path} not found. Make sure Claude Code is installed: npm install -g @anthropic-ai/claude-code"
+        )
+        sys.exit(1)

arch/tools/cli/main.py

@@ -4,13 +4,20 @@ import sys
 import subprocess
 import multiprocessing
 import importlib.metadata
+import json
 from cli import targets
-from cli.docker_cli import docker_validate_archgw_schema, stream_gateway_logs
+from cli.docker_cli import (
+    docker_validate_archgw_schema,
+    stream_gateway_logs,
+    docker_container_status,
+)
 from cli.utils import (
     getLogger,
     get_llm_provider_access_keys,
+    has_ingress_listener,
     load_env_file_to_dict,
     stream_access_logs,
+    find_config_file,
 )
 from cli.core import (
     start_arch_modelserver,
@@ -18,9 +25,11 @@ from cli.core import (
     start_arch,
     stop_docker_container,
     download_models_from_hf,
+    start_cli_agent,
 )
 from cli.consts import (
     ARCHGW_DOCKER_IMAGE,
+    ARCHGW_DOCKER_NAME,
     KATANEMO_DOCKERHUB_REPO,
     SERVICE_NAME_ARCHGW,
     SERVICE_NAME_MODEL_SERVER,
@@ -170,12 +179,8 @@ def up(file, path, service, foreground):
         start_arch_modelserver(foreground)
         return
 
-    if file:
-        # If a file is provided, process that file
-        arch_config_file = os.path.abspath(file)
-    else:
-        # If no file is provided, use the path and look for arch_config.yaml
-        arch_config_file = os.path.abspath(os.path.join(path, "arch_config.yaml"))
+    # Use the utility function to find config file
+    arch_config_file = find_config_file(path, file)
 
     # Check if the file exists
     if not os.path.exists(arch_config_file):
@@ -183,7 +188,6 @@ def up(file, path, service, foreground):
         return
 
     log.info(f"Validating {arch_config_file}")
-
     (
         validation_return_code,
         validation_stdout,
@@ -240,8 +244,15 @@ def up(file, path, service, foreground):
     if service == SERVICE_NAME_ARCHGW:
         start_arch(arch_config_file, env, foreground=foreground)
     else:
-        download_models_from_hf()
-        start_arch_modelserver(foreground)
+        # Check if ingress_traffic listener is configured before starting model_server
+        if has_ingress_listener(arch_config_file):
+            download_models_from_hf()
+            start_arch_modelserver(foreground)
+        else:
+            log.info(
+                "Skipping model_server startup: no ingress_traffic listener configured in arch_config.yaml"
+            )
+
         start_arch(arch_config_file, env, foreground=foreground)
 
 
@@ -321,10 +332,51 @@ def logs(debug, follow):
             archgw_process.terminate()
 
 
+@click.command()
+@click.argument("type", type=click.Choice(["claude"]), required=True)
+@click.argument("file", required=False)  # Optional file argument
+@click.option(
+    "--path", default=".", help="Path to the directory containing arch_config.yaml"
+)
+@click.option(
+    "--settings",
+    default="{}",
+    help="Additional settings as JSON string for the CLI agent.",
+)
+def cli_agent(type, file, path, settings):
+    """Start a CLI agent connected to Arch.
+
+    CLI_AGENT: The type of CLI agent to start (currently only 'claude' is supported)
+    """
+
+    # Check if archgw docker container is running
+    archgw_status = docker_container_status(ARCHGW_DOCKER_NAME)
+    if archgw_status != "running":
+        log.error(f"archgw docker container is not running (status: {archgw_status})")
+        log.error("Please start archgw using the 'archgw up' command.")
+        sys.exit(1)
+
+    # Determine arch_config.yaml path
+    arch_config_file = find_config_file(path, file)
+    if not os.path.exists(arch_config_file):
+        log.error(f"Config file not found: {arch_config_file}")
+        sys.exit(1)
+
+    try:
+        start_cli_agent(arch_config_file, settings)
+    except SystemExit:
+        # Re-raise SystemExit to preserve exit codes
+        raise
+    except Exception as e:
+        click.echo(f"Error: {e}")
+        sys.exit(1)
+
+
 main.add_command(up)
 main.add_command(down)
 main.add_command(build)
 main.add_command(logs)
+main.add_command(cli_agent)
 main.add_command(generate_prompt_targets)
 
 if __name__ == "__main__":

arch/tools/cli/utils.py

@@ -21,6 +21,22 @@ def getLogger(name="cli"):
 log = getLogger(__name__)
 
 
+def has_ingress_listener(arch_config_file):
+    """Check if the arch config file has ingress_traffic listener configured."""
+    try:
+        with open(arch_config_file) as f:
+            arch_config_dict = yaml.safe_load(f)
+
+        ingress_traffic = arch_config_dict.get("listeners", {}).get(
+            "ingress_traffic", {}
+        )
+
+        return bool(ingress_traffic)
+    except Exception as e:
+        log.error(f"Error reading config file {arch_config_file}: {e}")
+        return False
+
+
 def get_llm_provider_access_keys(arch_config_file):
     with open(arch_config_file, "r") as file:
         arch_config = file.read()
@@ -72,6 +88,19 @@ def load_env_file_to_dict(file_path):
     return env_dict
 
 
+def find_config_file(path=".", file=None):
+    """Find the appropriate config file path."""
+    if file:
+        # If a file is provided, process that file
+        return os.path.abspath(file)
+    else:
+        # If no file is provided, use the path and look for arch_config.yaml first, then config.yaml for convenience
+        arch_config_file = os.path.abspath(os.path.join(path, "config.yaml"))
+        if not os.path.exists(arch_config_file):
+            arch_config_file = os.path.abspath(os.path.join(path, "arch_config.yaml"))
+        return arch_config_file
+
+
 def stream_access_logs(follow):
     """
     Get the archgw access logs