feat(harbor): harden FabricAgent integration and add SWE-Bench workflow

README.md

@@ -188,9 +188,9 @@ the [Python SDK guide](docs/sdk/python.mdx). Exact signatures are in the
   diagnostics, requests, multi-turn runtimes, parallelism, results, and errors.
 - [Getting Started overview](docs/getting-started/overview.mdx): interface
   selection and the end-to-end Fabric workflow.
-- [Harbor example](examples/harbor/README.md) and
-  [multi-harness demo](examples/harbor/demo/README.md): ownership,
-  installation, and complete command matrices.
+- [Harbor examples](examples/harbor/README.md): validate the integration with a
+  deterministic, credential-free calculator smoke, optionally run the same
+  task with Hermes or Claude, and evaluate real coding tasks with SWE-Bench.
 - Adapter guides: [Hermes](adapters/hermes/README.md),
   [Codex SDK](adapters/codex/README.md), and
   [Deep Agents](adapters/deepagents/README.md).

adapters/claude/src/nemo_fabric_adapters/claude/adapter.py

@@ -12,6 +12,7 @@
 import os
 import shlex
 import shutil
+import subprocess
 from dataclasses import asdict
 from dataclasses import dataclass
 from dataclasses import is_dataclass
@@ -287,8 +288,12 @@ def _native_skill_paths(payload: dict[str, Any]) -> list[Path]:
         or {}
     )
     values = _mapping(native, name="capability_plan.native").get("skill_paths") or []
-    if not isinstance(values, list) or any(not isinstance(value, (str, Path)) for value in values):
-        raise AdapterConfigError("claude_invalid_configuration", "native skill_paths must be a list of paths")
+    if not isinstance(values, list) or any(
+        not isinstance(value, (str, Path)) for value in values
+    ):
+        raise AdapterConfigError(
+            "claude_invalid_configuration", "native skill_paths must be a list of paths"
+        )
     return [_resolve_path(payload, value) for value in values]
 
 
@@ -552,10 +557,14 @@ def load_claude_session_id(
             raise ValueError("missing Claude session")
         return session_id
     except (OSError, ValueError, json.JSONDecodeError) as error:
-        raise AdapterStateError("claude_invalid_runtime_state", "Claude runtime state is invalid") from error
+        raise AdapterStateError(
+            "claude_invalid_runtime_state", "Claude runtime state is invalid"
+        ) from error
 
 
-def save_claude_session_id(payload: dict[str, Any], fabric_runtime_id: str, claude_session_id: str) -> None:
+def save_claude_session_id(
+    payload: dict[str, Any], fabric_runtime_id: str, claude_session_id: str
+) -> None:
     if not claude_session_id:
         raise AdapterStateError(
             "claude_invalid_runtime_state", "Claude session ID is missing"
@@ -602,7 +611,9 @@ def _result_failed(result: ResultMessage) -> bool:
     )
 
 
-def normalize_result(payload: dict[str, Any], messages: list[Message], result: ResultMessage) -> dict[str, Any]:
+def normalize_result(
+    payload: dict[str, Any], messages: list[Message], result: ResultMessage
+) -> dict[str, Any]:
     del payload
     failed = _result_failed(result)
     error = None
@@ -718,6 +729,95 @@ def _relay_output(
     return output
 
 
+def _start_relay_gateway(
+    payload: dict[str, Any],
+    relay: ClaudeRelaySettings | None,
+) -> subprocess.Popen[Any] | None:
+    if relay is None:
+        return None
+    try:
+        return relay_gateway.start_relay_gateway(
+            launch=relay.gateway,
+            cwd=resolve_cwd(payload),
+        )
+    except relay_gateway.RelayGatewayError as error:
+        raise AdapterRelayError(
+            "claude_relay_start_failed",
+            "NeMo Relay gateway failed to start",
+            metadata={"gateway_log_path": str(relay.gateway.log_path)},
+        ) from error
+
+
+def _cleanup_relay(
+    relay: ClaudeRelaySettings | None,
+    gateway_process: subprocess.Popen[Any] | None,
+) -> AdapterRelayError | None:
+    cleanup_error: AdapterRelayError | None = None
+    if gateway_process is not None:
+        try:
+            relay_gateway.stop_relay_gateway(gateway_process)
+        except relay_gateway.RelayGatewayError:
+            cleanup_error = AdapterRelayError(
+                "claude_relay_stop_failed",
+                "NeMo Relay gateway failed to stop",
+                metadata={
+                    "gateway_log_path": str(relay.gateway.log_path)
+                    if relay is not None
+                    else ""
+                },
+            )
+    if relay is not None and relay.plugin_path.exists():
+        try:
+            shutil.rmtree(relay.plugin_path)
+        except OSError:
+            if cleanup_error is None:
+                cleanup_error = AdapterRelayError(
+                    "claude_relay_cleanup_failed",
+                    "Claude Relay hook configuration could not be removed",
+                )
+    return cleanup_error
+
+
+def _merge_relay_output(
+    output: dict[str, Any],
+    relay: ClaudeRelaySettings | None,
+    cleanup_error: AdapterRelayError | None,
+) -> dict[str, Any]:
+    if relay is None:
+        return output
+    output = _relay_output(output, relay)
+    if cleanup_error is None:
+        return output
+    cleanup: dict[str, Any] = {
+        "code": cleanup_error.code,
+        "message": cleanup_error.message,
+        "retryable": False,
+    }
+    if cleanup_error.metadata:
+        cleanup["metadata"] = cleanup_error.metadata
+    output["relay_runtime"]["cleanup_error"] = cleanup
+    if not output["failed"]:
+        output["completed"] = False
+        output["failed"] = True
+        output["error"] = cleanup
+    return output
+
+
+def _persist_result_session(
+    payload: dict[str, Any],
+    fabric_runtime_id: str,
+    prior_session_id: str | None,
+    result: ResultMessage,
+) -> dict[str, Any] | None:
+    if prior_session_id is not None and result.session_id != prior_session_id:
+        return _failure(
+            "claude_session_mismatch",
+            "Claude session identity changed during resume",
+        )
+    save_claude_session_id(payload, fabric_runtime_id, result.session_id)
+    return None
+
+
 async def run_claude(payload: dict[str, Any]) -> dict[str, Any]:
     fabric_runtime_id = runtime_id(payload)
     prior_session_id = load_claude_session_id(payload, fabric_runtime_id)
@@ -727,18 +827,7 @@ async def run_claude(payload: dict[str, Any]) -> dict[str, Any]:
     messages: list[Message] = []
     result: ResultMessage | None = None
     try:
-        if relay is not None:
-            try:
-                gateway_process = relay_gateway.start_relay_gateway(
-                    launch=relay.gateway,
-                    cwd=resolve_cwd(payload),
-                )
-            except relay_gateway.RelayGatewayError as error:
-                raise AdapterRelayError(
-                    "claude_relay_start_failed",
-                    "NeMo Relay gateway failed to start",
-                    metadata={"gateway_log_path": str(relay.gateway.log_path)},
-                ) from error
+        gateway_process = _start_relay_gateway(payload, relay)
         options = build_options(payload, resume=prior_session_id, relay=relay)
         try:
             async with asyncio.timeout(timeout_seconds(payload)):
@@ -767,59 +856,19 @@ async def run_claude(payload: dict[str, Any]) -> dict[str, Any]:
             else:
                 output = normalize_result(payload, messages, result)
                 if not output["failed"]:
-                    if (
-                        prior_session_id is not None
-                        and result.session_id != prior_session_id
-                    ):
-                        output = _failure(
-                            "claude_session_mismatch",
-                            "Claude session identity changed during resume",
+                    output = (
+                        _persist_result_session(
+                            payload,
+                            fabric_runtime_id,
+                            prior_session_id,
+                            result,
                         )
-                    else:
-                        save_claude_session_id(
-                            payload, fabric_runtime_id, result.session_id
-                        )
-    finally:
-        if gateway_process is not None:
-            try:
-                relay_gateway.stop_relay_gateway(gateway_process)
-            except relay_gateway.RelayGatewayError:
-                cleanup_error = AdapterRelayError(
-                    "claude_relay_stop_failed",
-                    "NeMo Relay gateway failed to stop",
-                    metadata={
-                        "gateway_log_path": str(relay.gateway.log_path)
-                        if relay is not None
-                        else ""
-                    },
-                )
-        if relay is not None and relay.plugin_path.exists():
-            try:
-                shutil.rmtree(relay.plugin_path)
-            except OSError:
-                if cleanup_error is None:
-                    cleanup_error = AdapterRelayError(
-                        "claude_relay_cleanup_failed",
-                        "Claude Relay hook configuration could not be removed",
+                        or output
                     )
+    finally:
+        cleanup_error = _cleanup_relay(relay, gateway_process)
 
-    if relay is not None:
-        output = _relay_output(output, relay)
-    if cleanup_error is not None:
-        cleanup: dict[str, Any] = {
-            "code": cleanup_error.code,
-            "message": cleanup_error.message,
-            "retryable": False,
-        }
-        if cleanup_error.metadata:
-            cleanup["metadata"] = cleanup_error.metadata
-        output["relay_runtime"]["cleanup_error"] = cleanup
-        if not output["failed"]:
-            output["completed"] = False
-            output["failed"] = True
-            output["error"] = cleanup
-
-    return output
+    return _merge_relay_output(output, relay, cleanup_error)
 
 
 def run(payload: dict[str, Any]) -> dict[str, Any]:
@@ -830,14 +879,20 @@ def run(payload: dict[str, Any]) -> dict[str, Any]:
     except ClaudeAdapterError as error:
         return adapter_failure(error)
     except Exception:  # Adapter boundary must always return normalized JSON.
-        return _failure("claude_adapter_internal_error", "Claude adapter failed unexpectedly")
+        return _failure(
+            "claude_adapter_internal_error", "Claude adapter failed unexpectedly"
+        )
 
 
 def main() -> None:
     try:
         payload = common_utils.load_payload()
-    except Exception:  # Malformed invocation input must still satisfy the process contract.
-        output = _failure("claude_adapter_internal_error", "Claude adapter failed unexpectedly")
+    except (
+        Exception
+    ):  # Malformed invocation input must still satisfy the process contract.
+        output = _failure(
+            "claude_adapter_internal_error", "Claude adapter failed unexpectedly"
+        )
     else:
         output = run(payload)
     print(json.dumps(output, sort_keys=True))

adapters/hermes/fabric-adapter.json

@@ -14,6 +14,7 @@
   },
   "config": {
     "accepts": [
+      "models",
       "tools",
       "tools.blocked",
       "mcp",

adapters/hermes/src/nemo_fabric_adapters/hermes/adapter.py

@@ -122,6 +122,16 @@ def hermes_mcp_server_config(server: dict[str, Any]) -> dict[str, Any]:
     if not target:
         raise ValueError("MCP server mapping requires a URL")
 
+    if transport == "stdio":
+        return common_utils.without_none(
+            {
+                "enabled": True,
+                "command": target,
+                "args": common_utils.normalize_list(server.get("args")) or None,
+                "env": server.get("env"),
+            }
+        )
+
     return {"enabled": True, "url": target, "transport": transport}