Skip to content

Switchyard lets LLM applications route traffic across models and providers while preserving native OpenAI and Anthropic API compatibility - enabling flexible model selection, benchmarking, and cost/performance optimization.

Rust
31.0 KB
Raw Blame
# Harbor Agent Patches
# Upstream: github.com/harbor-framework/harbor@331dcba (v0.6.4)
#
# Apply from site-packages root:
#   cd .venv/lib/python3.13/site-packages && patch -p1 < ../../../../patches/harbor-agent-patches.diff

--- a/harbor/agents/installed/base.py
+++ b/harbor/agents/installed/base.py
@@ -277,7 +277,7 @@
         Override in subclasses if the command output needs parsing."""
         return stdout.strip()

-    def _truncate_output(self, text: str | None, max_len: int = 1000) -> str:
+    def _truncate_output(self, text: str | None, max_len: int = 8000) -> str:
         if not text:
             return "None"
         if len(text) > max_len:
--- a/harbor/agents/installed/claude_code.py
+++ b/harbor/agents/installed/claude_code.py
@@ -129,10 +129,16 @@
         await self.exec_as_root(
             environment,
             command=(
+                # Skip if claude is already installed (e.g. from agent-bake layer).
+                "if command -v claude >/dev/null 2>&1; then"
+                f"  echo 'claude {self._version or 'unknown'} already installed, skipping system pkg install';"
+                "  exit 0;"
+                "fi;"
                 "if command -v apk &> /dev/null; then"
                 "  apk add --no-cache curl bash nodejs npm;"
                 " elif command -v apt-get &> /dev/null; then"
-                "  apt-get update && apt-get install -y curl;"
+                # Tolerate dead xenial repos / unsigned PPAs on EOL cybergym base images.
+                "  (apt-get update 2>/dev/null || true) && apt-get install -y curl;"
                 " elif command -v yum &> /dev/null; then"
                 "  yum install -y curl;"
                 " else"
@@ -147,6 +153,11 @@
             environment,
             command=(
                 "set -euo pipefail; "
+                # Skip if claude is already installed (e.g. from agent-bake layer).
+                "if command -v claude >/dev/null 2>&1; then"
+                f"  echo 'claude {self._version or 'unknown'} already installed, skipping install';"
+                "  exit 0;"
+                "fi;"
                 "if command -v apk &> /dev/null; then"
                 f"  npm install -g @anthropic-ai/claude-code{'@' + self._version if self._version else ''};"
                 " else"
@@ -1104,6 +1115,16 @@
         # Disable non-essential traffic (telemetry, etc.)
         env["CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC"] = "1"

+        # Disable attribution header to prevent KV cache invalidation on
+        # inference gateways (see unsloth.ai/docs/basics/claude-code).
+        # Without this, the prepended header causes ~90% slower inference.
+        env["CLAUDE_CODE_ATTRIBUTION_HEADER"] = "0"
+        env["CLAUDE_CODE_ENABLE_TELEMETRY"] = "0"
+        # NVIDIA gateway rejects the `context_management` beta field that
+        # claude-code >=2.1.114 injects; disabling experimental betas keeps
+        # the outbound request compatible.
+        env["CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS"] = "1"
+
         # Allow bypassPermissions mode when running as root inside containers
         env["IS_SANDBOX"] = "1"

--- a/harbor/agents/installed/codex.py
+++ b/harbor/agents/installed/codex.py
@@ -77,10 +77,19 @@
         await self.exec_as_root(
             environment,
             command=(
+                # Skip if codex is already installed (e.g. from agent-bake layer).
+                "if command -v codex >/dev/null 2>&1; then"
+                f"  echo 'codex {self._version or 'unknown'} already installed, skipping system pkg install';"
+                "  exit 0;"
+                "fi;"
                 "if ldd --version 2>&1 | grep -qi musl || [ -f /etc/alpine-release ]; then"
                 "  apk add --no-cache curl bash nodejs npm ripgrep;"
                 " elif command -v apt-get &>/dev/null; then"
-                "  apt-get update && apt-get install -y curl ripgrep;"
+                "  (apt-get update 2>/dev/null || true) && apt-get install -y curl"
+                " && (apt-get install -y ripgrep"
+                " || (curl -fsSL https://github.com/BurntSushi/ripgrep/releases/download/15.1.0/ripgrep-15.1.0-x86_64-unknown-linux-musl.tar.gz"
+                " | tar -xz -C /tmp"
+                " && install -m755 /tmp/ripgrep-15.1.0-x86_64-unknown-linux-musl/rg /usr/local/bin/rg));"
                 " elif command -v yum &>/dev/null; then"
                 "  yum install -y curl ripgrep;"
                 " else"
@@ -95,14 +104,24 @@
             environment,
             command=(
                 "set -euo pipefail; "
+                # Skip if codex is already installed (e.g. from agent-bake layer).
+                "if command -v codex >/dev/null 2>&1; then"
+                f"  echo 'codex {self._version or 'unknown'} already installed, skipping install';"
+                "  exit 0;"
+                "fi;"
                 "if ldd --version 2>&1 | grep -qi musl || [ -f /etc/alpine-release ]; then"
                 f"  npm install -g @openai/codex{version_spec};"
                 " else"
-                "  curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.2/install.sh | bash &&"
+                "  for _nvm_i in 1 2 3; do"
+                " curl -fsSL https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.2/install.sh -o /tmp/nvm-install.sh"
+                " && bash /tmp/nvm-install.sh && break"
+                ' || { [ "$_nvm_i" -lt 3 ] && sleep 5 || exit 1; }; done &&'
                 '  export NVM_DIR="$HOME/.nvm" &&'
                 '  \\. "$NVM_DIR/nvm.sh" || true &&'
                 "  command -v nvm &>/dev/null || { echo 'Error: NVM failed to load' >&2; exit 1; } &&"
-                "  nvm install 22 && nvm alias default 22 && npm -v &&"
+                "  nvm install 22;"
+                " if ! node --version >/dev/null 2>&1; then nvm install 16 && nvm use 16; fi;"
+                " nvm alias default $(nvm current) && npm -v &&"
                 f"  npm install -g @openai/codex{version_spec};"
                 " fi && "
                 "codex --version"
@@ -647,13 +666,14 @@
         if not self.skills_dir:
             return None
         return (
-            f"mkdir -p $HOME/.agents/skills && "
+            'mkdir -p "$CODEX_HOME/skills" && '
             f"cp -r {shlex.quote(self.skills_dir)}/* "
-            f"$HOME/.agents/skills/ 2>/dev/null || true"
+            '"$CODEX_HOME/skills/" 2>/dev/null || true'
         )

     def _build_register_mcp_servers_command(self) -> str | None:
-        """Return a shell command that writes MCP config to $CODEX_HOME/config.toml."""
+        """Return a shell command that appends MCP config to $CODEX_HOME/config.toml.
+        Appends (>>) so the gateway provider stanza written during setup is preserved."""
         if not self.mcp_servers:
             return None
         lines: list[str] = []
@@ -710,7 +730,19 @@
         if not self.model_name:
             raise ValueError("Model name is required")

-        model = self.model_name.split("/")[-1]
+        model = self.model_name
+
+        # Load the custom model catalog so gateway-routed models (azure/openai/...)
+        # are recognized by codex as reasoning-capable. Without this, codex drops
+        # reasoning.effort from the Responses API payload on unknown slugs.
+        # Path is taken from CODEX_MODEL_CATALOG_JSON env var; if unset or the
+        # file does not exist, no catalog is injected (reasoning may be absent).
+        _catalog_json = ""
+        _catalog_path = self._get_env("CODEX_MODEL_CATALOG_JSON")
+        if _catalog_path and Path(_catalog_path).is_file():
+            with open(_catalog_path) as _f:
+                _catalog_json = _f.read()
+        _escaped_catalog = shlex.quote(_catalog_json) if _catalog_json else ""

         # Build command with optional CLI config flags from descriptors.
         cli_flags = self.build_cli_flags()
@@ -765,12 +797,33 @@
             env["OPENAI_BASE_URL"] = openai_base_url

         # codex 0.118.0 only honors openai_base_url from config.toml, not the env var.
+        # Full nvidia_gateway provider block so wire_api=responses is set; required
+        # for NVIDIA/vLLM gateway routing (bare openai_base_url drops reasoning.effort).
+        # Closed-book toggle: prepend `web_search = "disabled"` BEFORE the
+        # [model_providers.nvidia_gateway] section. TOML scope rules mean any
+        # bare key after a [section] header belongs to that section, so writing
+        # web_search after the provider block makes it a (silently ignored)
+        # provider field instead of the top-level codex config the
+        # resolve_web_search_mode() reader expects.
         config_toml_block = ""
         if openai_base_url:
+            web_search_prefix = ""
+            if self._get_env("CODEX_DISABLE_WEB_SEARCH"):
+                web_search_prefix = 'web_search = "disabled"\n'
             config_toml_block = (
-                '\ncat >>"$CODEX_HOME/config.toml" <<TOML\n'
-                'openai_base_url = "${OPENAI_BASE_URL}"\n'
-                "TOML"
+                '\ncat >>"$CODEX_HOME/config.toml" <<EOF2\n'
+                f"{web_search_prefix}"
+                'model_provider = "nvidia_gateway"\n'
+                "[model_providers.nvidia_gateway]\n"
+                'name = "NVIDIA Gateway"\n'
+                'base_url = "${OPENAI_BASE_URL}"\n'
+                'env_key = "OPENAI_API_KEY"\n'
+                'wire_api = "responses"\n'
+                "[tools]\n"
+                "view_image = false\n"
+                "[features]\n"
+                "unified_exec = false\n"
+                "EOF2"
             )

         setup_command += config_toml_block
@@ -783,6 +836,14 @@
         if mcp_command:
             setup_command += f"\n{mcp_command}"

+        # Write custom model catalog so codex recognizes gateway-routed model
+        # slugs and includes reasoning.effort in the Responses API payload.
+        if _catalog_json:
+            setup_command += (
+                f'\nmkdir -p "$CODEX_HOME" && '
+                f'echo {_escaped_catalog} > "$CODEX_HOME/custom-model-catalog.json"'
+            )
+
         if setup_command.strip():
             await self.exec_as_agent(
                 environment,
@@ -799,11 +860,15 @@
                     "--skip-git-repo-check "
                     f"--model {model} "
                     "--json "
-                    "--enable unified_exec "
-                    f"{cli_flags_arg}"
-                    "-- "  # end of flags
-                    f"{escaped_instruction} "
-                    f"2>&1 </dev/null | tee {
+                    "--disable unified_exec "
+                    + (
+                        '-c "model_catalog_json=\\"${CODEX_HOME}/custom-model-catalog.json\\"" '
+                        if _catalog_json else ""
+                    )
+                    + f"{cli_flags_arg}"
+                    + "-- "  # end of flags
+                    + f"{escaped_instruction} "
+                    + f"2>&1 </dev/null | tee {
                         EnvironmentPaths.agent_dir / self._OUTPUT_FILENAME
                     }"
                 ),
--- a/harbor/agents/installed/opencode.py
+++ b/harbor/agents/installed/opencode.py
@@ -3,6 +3,7 @@
 import os
 import shlex
 from datetime import datetime, timezone
+from pathlib import Path
 from typing import Any

 from harbor.agents.installed.base import (
@@ -76,27 +77,36 @@
         return AgentName.OPENCODE.value

     def get_version_command(self) -> str | None:
-        return ". ~/.nvm/nvm.sh; opencode --version"
+        return "opencode --version"

     async def install(self, environment: BaseEnvironment) -> None:
+        version_spec = f"@{self._version}" if self._version else "@latest"
         await self.exec_as_root(
             environment,
-            command="apt-get update && apt-get install -y curl",
-            env={"DEBIAN_FRONTEND": "noninteractive"},
-        )
-        version_spec = f"@{self._version}" if self._version else "@latest"
-        await self.exec_as_agent(
-            environment,
+            # Install Node 16 LTS directly from nodejs.org (whitelisted in
+            # restrict-network.sh). Bypasses NVM entirely -- NVM requires a
+            # git clone from github.com whose IPs rotate past the iptables
+            # snapshot taken at container startup, causing intermittent
+            # "Network is unreachable" errors. Node 16 is the last LTS that
+            # requires only glibc 2.17; Ubuntu 16.04 Xenial ships glibc 2.23.
+            # Node 18+ requires glibc 2.28 and will not run on Xenial.
+            # apt-get update is best-effort: dead Xenial PPAs fail silently.
             command=(
                 "set -euo pipefail; "
-                "curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.2/install.sh | bash && "
-                'export NVM_DIR="$HOME/.nvm" && '
-                '\\. "$NVM_DIR/nvm.sh" || true && '
-                "command -v nvm &>/dev/null || { echo 'Error: NVM failed to load' >&2; exit 1; } && "
-                "nvm install 22 && npm -v && "
+                # Skip if opencode is already installed (e.g. from agent-bake layer).
+                "if command -v opencode >/dev/null 2>&1; then"
+                f"  echo 'opencode {self._version or 'unknown'} already installed, skipping install';"
+                "  exit 0;"
+                "fi;"
+                "(apt-get update 2>/dev/null || true) && apt-get install -y --no-install-recommends curl; "
+                "curl -fsSL https://nodejs.org/dist/v20.11.1/node-v20.11.1-linux-x64.tar.gz "
+                "-o /tmp/node.tar.gz && "
+                "tar -xzf /tmp/node.tar.gz -C /usr/local --strip-components=1 && "
+                "rm /tmp/node.tar.gz && "
                 f"npm i -g opencode-ai{version_spec} && "
                 "opencode --version"
             ),
+            env={"DEBIAN_FRONTEND": "noninteractive"},
         )

     @staticmethod
@@ -373,14 +383,82 @@

         if self.model_name and "/" in self.model_name:
             provider, model_id = self.model_name.split("/", 1)
-            provider_config: dict[str, Any] = {"models": {model_id: {}}}
+            # Set temperature: true to unlock the capability gate in opencode.
+            # Without this, agent-level temperature/top_p values are silently
+            # dropped (see session/llm.ts: capabilities.temperature check).
+            provider_config: dict[str, Any] = {"models": {model_id: {"temperature": True}}}
             base_url = os.environ.get("OPENAI_BASE_URL")
             if base_url and provider == "openai":
                 # opencode reads baseURL from provider.options, not the provider root.
                 # See: https://github.com/anomalyco/opencode config.ts ProviderConfig schema.
                 provider_config.setdefault("options", {})["baseURL"] = base_url
+            # Custom "nvidia" (gateway) and "vllm" (local) providers both
+            # use @ai-sdk/openai-compatible to call /v1/chat/completions
+            # instead of /v1/responses. Required for endpoints that don't
+            # support the OpenAI Responses API.
+            if provider in ("nvidia", "vllm"):
+                provider_config["npm"] = "@ai-sdk/openai-compatible"
+                # Literal ${VAR} placeholders expanded inside the container at
+                # write-time via heredoc so the container's env wins.
+                provider_config["options"] = {
+                    "baseURL": "${OPENAI_BASE_URL}",
+                    "apiKey": "${OPENAI_API_KEY}",
+                }
+                _effort = os.environ.get("OPENCODE_REASONING_EFFORT", "")
+                if _effort:
+                    provider_config["models"][model_id].setdefault(
+                        "options", {}
+                    )["reasoningEffort"] = _effort
             config["provider"] = {provider: provider_config}
+
+        # Inject per-mode agent sampling params from env vars.
+        # OPENCODE_BUILD_* controls the "build" mode (code generation).
+        # OPENCODE_PLAN_* controls the "plan" mode (planning/reasoning).
+        _AGENT_PARAMS = [
+            ("temperature", float),
+            ("top_p", float),
+            ("top_k", int),
+            ("max_tokens", int),
+            ("presence_penalty", float),
+        ]
+        agent_cfg: dict[str, Any] = {}
+        for mode in ("build", "plan"):
+            mode_params: dict[str, Any] = {}
+            for param, cast in _AGENT_PARAMS:
+                val = os.environ.get(f"OPENCODE_{mode.upper()}_{param.upper()}", "")
+                if val:
+                    mode_params[param] = cast(val)
+            if mode_params:
+                agent_cfg[mode] = mode_params
+        if agent_cfg:
+            config["agent"] = agent_cfg

+        # Override small_model so opencode doesn't fall back to gpt-5-nano
+        # for title generation (fails on self-hosted vLLM with one model).
+        small_model = os.environ.get("OPENCODE_SMALL_MODEL", "")
+        if small_model:
+            config["small_model"] = small_model
+
+        # Auto-approve all tool operations so non-interactive container
+        # execution (stdin from /dev/null) doesn't silently reject prompts.
+        # Closed-book mode: deny webfetch and websearch via the permission
+        # ruleset, the canonical opencode mechanism (see
+        # opencode/packages/opencode/src/permission/index.ts:fromConfig +
+        # disabled). The earlier `tools.<name>=false` field is not honored
+        # by opencode 1.14.31; permission.<name>="deny" is.
+        if os.environ.get("OPENCODE_DISABLE_WEBFETCH"):
+            config["permission"] = {
+                "*": "allow",
+                "webfetch": "deny",
+                "websearch": "deny",
+            }
+        else:
+            config["permission"] = "allow"
+
+        # Disable auto-compaction for baseline reproducibility.
+        if os.environ.get("OPENCODE_DISABLE_AUTO_COMPACT", "1") == "1":
+            config["compaction"] = {"auto": False}
+
         # Layer: defaults → auto-generated → job-level overrides.
         # Deep-merge preserves sibling keys within nested dicts (e.g. provider, experimental).
         config = self._deep_merge(copy.deepcopy(self._DEFAULT_CONFIG), config)
@@ -390,8 +468,12 @@
             return None

         config_json = json.dumps(config, indent=2)
-        escaped = shlex.quote(config_json)
-        return f"mkdir -p ~/.config/opencode && echo {escaped} > ~/.config/opencode/opencode.json"
+        # Unquoted heredoc so ${OPENAI_BASE_URL} / ${OPENAI_API_KEY} (and any
+        # other ${VAR}) are expanded inside the container at write-time.
+        return (
+            "mkdir -p ~/.config/opencode && "
+            f"cat > ~/.config/opencode/opencode.json <<EOF\n{config_json}\nEOF"
+        )

     @with_prompt_template
     async def run(
@@ -444,6 +526,8 @@
         elif provider == "openai":
             keys.append("OPENAI_API_KEY")
             keys.append("OPENAI_BASE_URL")
+        elif provider in ("nvidia", "vllm"):
+            keys.extend(["OPENAI_API_KEY", "OPENAI_BASE_URL"])
         elif provider == "opencode":
             keys.append("OPENCODE_API_KEY")
         elif provider == "xai":
@@ -463,6 +547,11 @@
         # Enable fake VCS for OpenCode
         env["OPENCODE_FAKE_VCS"] = "git"

+        # Cap output tokens for vLLM endpoints that reject requests exceeding context.
+        max_output = os.environ.get("OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX", "")
+        if max_output:
+            env["OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX"] = max_output
+
         skills_command = self._build_register_skills_command()
         if skills_command:
             await self.exec_as_agent(environment, command=skills_command, env=env)
@@ -478,7 +567,6 @@
             environment,
             # Note that the --thinking flag just means thinking blocks will be included in the json formatted output
             command=(
-                ". ~/.nvm/nvm.sh; "
                 f"opencode --model={self.model_name} run --format=json {cli_flags_arg}--thinking --dangerously-skip-permissions -- {escaped_instruction} "
                 f"2>&1 </dev/null | stdbuf -oL tee /logs/agent/opencode.txt"
             ),
--- a/harbor/agents/installed/pi.py
+++ b/harbor/agents/installed/pi.py
@@ -14,6 +14,8 @@

 class Pi(BaseInstalledAgent):
     _OUTPUT_FILENAME = "pi.txt"
+    # Source nvm only if it exists: the prebaked dataset image installs pi on PATH without nvm.
+    _NVM_PRELUDE = '[ -s "$HOME/.nvm/nvm.sh" ] && . "$HOME/.nvm/nvm.sh"; '

     CLI_FLAGS = [
         CliFlag(
@@ -29,7 +31,7 @@
         return AgentName.PI.value

     def get_version_command(self) -> str | None:
-        return ". ~/.nvm/nvm.sh; pi --version"
+        return f"{self._NVM_PRELUDE}pi --version"

     def parse_version(self, stdout: str) -> str:
         return stdout.strip().splitlines()[-1].strip()
@@ -37,7 +39,14 @@
     async def install(self, environment: BaseEnvironment) -> None:
         await self.exec_as_root(
             environment,
-            command="apt-get update && apt-get install -y curl",
+            command=(
+                # Skip if pi is already installed (e.g. from agent-bake layer).
+                "if command -v pi >/dev/null 2>&1; then"
+                f"  echo 'pi {self._version or 'unknown'} already installed, skipping system pkg install';"
+                "  exit 0;"
+                "fi;"
+                "apt-get update && apt-get install -y curl"
+            ),
             env={"DEBIAN_FRONTEND": "noninteractive"},
         )
         version_spec = f"@{self._version}" if self._version else "@latest"
@@ -45,12 +54,17 @@
             environment,
             command=(
                 "set -euo pipefail; "
+                # Skip if pi is already installed (e.g. from agent-bake layer).
+                "if command -v pi >/dev/null 2>&1; then"
+                f"  echo 'pi {self._version or 'unknown'} already installed, skipping install';"
+                "  exit 0;"
+                "fi;"
                 "curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.2/install.sh | bash && "
                 'export NVM_DIR="$HOME/.nvm" && '
                 '\\. "$NVM_DIR/nvm.sh" || true && '
                 "command -v nvm &>/dev/null || { echo 'Error: NVM failed to load' >&2; exit 1; } && "
                 "nvm install 22 && npm -v && "
-                f"npm install -g @mariozechner/pi-coding-agent{version_spec} && "
+                f"npm install -g @earendil-works/pi-coding-agent{version_spec} && "
                 "pi --version"
             ),
         )
@@ -65,6 +79,46 @@
             f"$HOME/.agents/skills/ 2>/dev/null || true"
         )

+    def _build_models_json_command(self, provider: str, model_id: str) -> str | None:
+        """Return a shell command that writes ~/.pi/agent/models.json for Switchyard.
+
+        pi has no built-in "switchyard" provider and does not read OPENAI_BASE_URL, so this
+        command adds the gateway as a custom provider before pi starts.
+        """
+        if provider != "switchyard":
+            return None
+        base_url = self._get_env("OPENAI_BASE_URL")
+        if not base_url:
+            raise ValueError("--model switchyard/<route> requires OPENAI_BASE_URL")
+        model_entry: dict[str, object] = {
+            "id": model_id,
+            "name": f"{model_id} (Switchyard)",
+            "reasoning": True,
+        }
+        context_window = self._get_env("PI_CONTEXT_WINDOW")
+        if context_window:
+            model_entry["contextWindow"] = int(context_window)
+        max_output_tokens = self._get_env("PI_MAX_OUTPUT_TOKENS")
+        if max_output_tokens:
+            model_entry["maxTokens"] = int(max_output_tokens)
+        models_config = {
+            "providers": {
+                "switchyard": {
+                    "baseUrl": base_url,
+                    "api": "openai-completions",
+                    # Keep the literal string "$OPENAI_API_KEY"; pi expands the variable itself.
+                    "apiKey": "$OPENAI_API_KEY",
+                    "compat": {"supportsDeveloperRole": False},
+                    "models": [model_entry],
+                }
+            }
+        }
+        # shlex.quote wraps the JSON in single quotes so the shell does not expand "$OPENAI_API_KEY".
+        return (
+            'mkdir -p "$HOME/.pi/agent" && '
+            f'echo {shlex.quote(json.dumps(models_config))} > "$HOME/.pi/agent/models.json"'
+        )
+
     @with_prompt_template
     async def run(
         self,
@@ -77,7 +131,7 @@
         if not self.model_name or "/" not in self.model_name:
             raise ValueError("Model name must be in the format provider/model_name")

-        provider, _ = self.model_name.split("/", 1)
+        provider, model_id = self.model_name.split("/", 1)

         env: dict[str, str] = {}
         keys: list[str] = []
@@ -106,7 +160,7 @@
             keys.append("HF_TOKEN")
         elif provider == "mistral":
             keys.append("MISTRAL_API_KEY")
-        elif provider == "openai":
+        elif provider in ("openai", "switchyard"):
             keys.append("OPENAI_API_KEY")
         elif provider == "openrouter":
             keys.append("OPENROUTER_API_KEY")
@@ -123,9 +177,7 @@
             if val:
                 env[key] = val

-        model_args = (
-            f"--provider {provider} --model {self.model_name.split('/', 1)[1]} "
-        )
+        model_args = f"--provider {provider} --model {model_id} "

         cli_flags = self.build_cli_flags()
         if cli_flags:
@@ -134,11 +186,14 @@
         skills_command = self._build_register_skills_command()
         if skills_command:
             await self.exec_as_agent(environment, command=skills_command)
+        models_json_command = self._build_models_json_command(provider, model_id)
+        if models_json_command:
+            await self.exec_as_agent(environment, command=models_json_command)

         await self.exec_as_agent(
             environment,
             command=(
-                f". ~/.nvm/nvm.sh; "
+                f"{self._NVM_PRELUDE}"
                 f"pi --print --mode json --no-session "
                 f"{model_args}"
                 f"{cli_flags}"

--- a/harbor/models/trial/config.py
+++ b/harbor/models/trial/config.py
@@ -219,4 +219,5 @@
     def generate_trial_name(self):
         task_id = self.task.get_task_id()
         task_name = task_id.get_name().split("/")[-1]
-        return f"{task_name[:32].rstrip('_-')}__{ShortUUID().random(length=7)}"
+        # Use single dash: __ causes Docker Compose v5 to reject image tag as invalid reference
+        return f"{task_name[:32].rstrip('_-')}-{ShortUUID().random(length=7)}"
--- /dev/null
+++ b/harbor/switchyard_patch_id.txt
@@ -0,0 +1 @@
+switchyard-harbor-patches-2026-09-22-v3

--- a/harbor/agents/installed/hermes.py
+++ b/harbor/agents/installed/hermes.py
@@ -59,6 +59,16 @@
         return 'export PATH="$HOME/.local/bin:$PATH"; hermes version'

     async def install(self, environment: BaseEnvironment) -> None:
+        # Skip if hermes is already installed (e.g. from the dataset
+        # agent-bake layer). hermes installs to $HOME/.local/bin, so export
+        # that path before probing. Required for closed-book runs where the
+        # task-time curl install cannot reach github/pypi.
+        probe = await self.exec_as_agent(
+            environment,
+            command='export PATH="$HOME/.local/bin:$PATH"; command -v hermes >/dev/null 2>&1 && echo present || true',
+        )
+        if "present" in (getattr(probe, "stdout", "") or ""):
+            return
         await self.exec_as_root(
             environment,
             command="apt-get update && apt-get install -y curl git ripgrep xz-utils",
@@ -92,11 +92,31 @@
     # ------------------------------------------------------------------
 
     @staticmethod
-    def _build_config_yaml(model: str) -> str:
-        """Generate a hermes config.yaml with full capabilities enabled."""
+    def _build_config_yaml(
+        model: str, base_url: str | None = None, api_key: str | None = None
+    ) -> str:
+        """Generate a hermes config.yaml with full capabilities enabled.
+
+        When ``base_url`` is given, route the model through a custom
+        OpenAI-compatible endpoint (e.g. a Switchyard gateway): hermes only
+        honors a custom endpoint via its config.yaml ``model.provider=custom`` +
+        ``model.base_url`` (the ``OPENAI_BASE_URL`` env var is ignored for the
+        chat model), so we nest the provider/base_url/api_key under ``model``.
+        """
+        model_field: Any
+        if base_url:
+            model_field = {
+                "default": model,
+                "provider": "custom",
+                "base_url": base_url,
+            }
+            if api_key:
+                model_field["api_key"] = api_key
+        else:
+            model_field = model
         config: dict[str, Any] = {
-            "model": model,
-            "provider": "auto",
+            "model": model_field,
+            **({} if base_url else {"provider": "auto"}),
             "toolsets": ["hermes-cli"],
             "agent": {"max_turns": 90},
             "memory": {
@@ -357,6 +377,9 @@
         # Try native provider key first, fall back to OpenRouter.
         hermes_provider_flag: str | None = None
         use_native = False
+        # Custom OpenAI-compatible endpoint (e.g. Switchyard) for the chat model.
+        custom_base_url: str | None = None
+        custom_api_key: str | None = None
 
         if provider in _NATIVE_PROVIDERS:
             native_flag, key_names = _NATIVE_PROVIDERS[provider]
@@ -367,11 +390,15 @@
                     hermes_provider_flag = native_flag
                     use_native = True
                     break
-            # Forward OPENAI_BASE_URL when using native OpenAI key
+            # Forward OPENAI_BASE_URL when using native OpenAI key. Hermes ignores
+            # this env var for the chat model, so also thread it into config.yaml
+            # as a custom provider (see _build_config_yaml).
             if use_native and provider == "openai":
                 base_url = os.environ.get("OPENAI_BASE_URL")
                 if base_url:
                     env["OPENAI_BASE_URL"] = base_url
+                    custom_base_url = base_url
+                    custom_api_key = os.environ.get("OPENAI_API_KEY")
 
         if not use_native:
             openrouter_key = os.environ.get("OPENROUTER_API_KEY")
@@ -386,9 +413,15 @@
             env["OPENROUTER_API_KEY"] = openrouter_key
 
         # Native providers with --provider flag use just the model name;
-        # everything else (OpenRouter, openai direct) uses provider/model.
-        cli_model = model if hermes_provider_flag else self.model_name
-        config_yaml = self._build_config_yaml(cli_model)
+        # a custom OpenAI-compatible endpoint also uses the bare model (the
+        # base_url already targets the gateway); everything else uses provider/model.
+        if custom_base_url:
+            cli_model = model
+        else:
+            cli_model = model if hermes_provider_flag else self.model_name
+        config_yaml = self._build_config_yaml(
+            cli_model, base_url=custom_base_url, api_key=custom_api_key
+        )
 
         # Pass instruction via env var (safe from shell escaping issues)
         env["HARBOR_INSTRUCTION"] = instruction