Skip to content

"Vibe-Trading: Your Personal Trading Agent"

fix(mcp): expose configured swarm reasoning metadata

cgycoreyc7cd28901a2f
diff --git a/agent/mcp_server.py b/agent/mcp_server.py
index f14f85a28..3e1b3a4a1 100644
--- a/agent/mcp_server.py
+++ b/agent/mcp_server.py
@@ -2347,6 +2347,7 @@ def _run_to_dict(run, *, timed_out: bool = False, is_stale: bool = False) -> dic
threshold. No disk state is changed by setting this — the explicit
:func:`reap_stale_runs` tool is what finalizes a stale run.
"""
+ from src.swarm.models import public_metadata_value, public_reasoning_effort
from src.swarm.serialization import run_level_error, serialize_task
return {
@@ -2360,6 +2361,10 @@ def _run_to_dict(run, *, timed_out: bool = False, is_stale: bool = False) -> dic
"final_report": run.final_report,
"total_input_tokens": run.total_input_tokens,
"total_output_tokens": run.total_output_tokens,
+ "provider": public_metadata_value(run.provider),
+ "model": public_metadata_value(run.model),
+ "reasoning_effort": public_reasoning_effort(run.reasoning_effort),
+ "use_responses_api": run.use_responses_api,
"timed_out": timed_out,
"is_stale": is_stale,
}
@@ -2446,6 +2451,8 @@ def list_runs(limit: int = 20) -> str:
Args:
limit: Maximum number of runs to return (default 20).
"""
+ from src.swarm.models import public_metadata_value, public_reasoning_effort
+
store = _get_swarm_store()
runs = store.list_runs(limit=limit)
items = []
@@ -2468,6 +2475,10 @@ def list_runs(limit: int = 20) -> str:
"task_counts": counts,
"total_input_tokens": reconciled.total_input_tokens,
"total_output_tokens": reconciled.total_output_tokens,
+ "provider": public_metadata_value(reconciled.provider),
+ "model": public_metadata_value(reconciled.model),
+ "reasoning_effort": public_reasoning_effort(reconciled.reasoning_effort),
+ "use_responses_api": reconciled.use_responses_api,
}
)
return json.dumps(items, ensure_ascii=False, indent=2)
diff --git a/agent/src/swarm/models.py b/agent/src/swarm/models.py
index f73963449..8d4bf010a 100644
--- a/agent/src/swarm/models.py
+++ b/agent/src/swarm/models.py
@@ -10,6 +10,42 @@ from enum import Enum
from pydantic import BaseModel, Field
+from src.tools.redaction import redact_text
+
+
+_PUBLIC_METADATA_MAX_LENGTH = 128
+_REDACTED_METADATA = "[redacted]"
+_REASONING_EFFORTS = frozenset({"none", "low", "medium", "high", "max"})
+
+
+def public_metadata_value(
+ value: str | None,
+ *,
+ allowed_values: frozenset[str] | None = None,
+) -> str | None:
+ """Return a bounded, credential-free value for public run metadata."""
+ if value is None:
+ return None
+ metadata = value.strip()
+ if not metadata:
+ return None
+ if len(metadata) > _PUBLIC_METADATA_MAX_LENGTH:
+ return _REDACTED_METADATA
+ if not metadata.isprintable() or "://" in metadata or metadata.startswith("//"):
+ return _REDACTED_METADATA
+ if allowed_values is not None and metadata not in allowed_values:
+ return _REDACTED_METADATA
+ if redact_text(metadata) != metadata:
+ return _REDACTED_METADATA
+ return metadata
+
+
+def public_reasoning_effort(value: str | None) -> str | None:
+ return public_metadata_value(
+ value.lower() if value is not None else None,
+ allowed_values=_REASONING_EFFORTS,
+ )
+
class TaskStatus(str, Enum):
"""SwarmTask lifecycle status.
@@ -190,6 +226,8 @@ class SwarmRun(BaseModel):
total_output_tokens: int = 0
provider: str | None = None
model: str | None = None
+ reasoning_effort: str | None = None
+ use_responses_api: bool | None = None
grounding_data: dict[str, list[dict]] | None = None
diff --git a/agent/src/swarm/runtime.py b/agent/src/swarm/runtime.py
index 815df2488..a8e1b7090 100644
--- a/agent/src/swarm/runtime.py
+++ b/agent/src/swarm/runtime.py
@@ -21,6 +21,7 @@ from typing import Callable
from src.config.accessor import get_env_config
from src.config.schema import AgentConfig
+from src.providers.llm import _ensure_dotenv
from src.swarm import grounding
from src.swarm.models import (
RunStatus,
@@ -30,6 +31,8 @@ from src.swarm.models import (
SwarmTask,
TaskStatus,
WorkerResult,
+ public_metadata_value,
+ public_reasoning_effort,
)
from src.swarm.presets import build_run_from_preset
from src.swarm.store import SwarmStore
@@ -105,6 +108,7 @@ class SwarmRuntime:
FileNotFoundError: If preset does not exist.
ValueError: If DAG validation fails.
"""
+ _ensure_dotenv()
# Reap any previously running runs whose host process died without
# finalizing them. Threshold is computed per-run from agent timeouts +
# heartbeat interval (see SwarmStore.compute_stale_threshold), so a
@@ -126,8 +130,10 @@ class SwarmRuntime:
# override applied via os.environ still shows up. Per-agent overrides
# remain visible on SwarmAgentSpec.model_name.
_cfg = get_env_config()
- run.provider = _cfg.llm.langchain_provider.strip().lower() or None
- run.model = _cfg.llm.langchain_model_name.strip() or None
+ run.provider = public_metadata_value(_cfg.llm.langchain_provider.lower())
+ run.model = public_metadata_value(_cfg.llm.langchain_model_name)
+ run.reasoning_effort = public_reasoning_effort(_cfg.llm.langchain_reasoning_effort)
+ run.use_responses_api = _cfg.llm.langchain_use_responses_api is True
self._store.create_run(run)
diff --git a/agent/tests/test_swarm_run_metadata.py b/agent/tests/test_swarm_run_metadata.py
index 88210c94d..94d2224ba 100644
--- a/agent/tests/test_swarm_run_metadata.py
+++ b/agent/tests/test_swarm_run_metadata.py
@@ -12,7 +12,11 @@ from __future__ import annotations
import pytest
+import src.providers.llm as llm_mod
+from src.config.accessor import reset_env_config
from src.swarm.models import SwarmRun
+from src.swarm.runtime import SwarmRuntime
+from src.swarm.store import SwarmStore
def _base_kwargs() -> dict:
@@ -26,16 +30,26 @@ def _base_kwargs() -> dict:
def test_provider_and_model_persist_on_construction() -> None:
"""Explicitly-supplied provider/model should appear in serialization."""
- run = SwarmRun(**_base_kwargs(), provider="openai", model="gpt-4o")
+ run = SwarmRun(
+ **_base_kwargs(),
+ provider="openai",
+ model="gpt-4o",
+ reasoning_effort="max",
+ use_responses_api=True,
+ )
assert run.provider == "openai"
assert run.model == "gpt-4o"
+ assert run.reasoning_effort == "max"
+ assert run.use_responses_api is True
# Round-trip through JSON to mirror the .swarm/runs/<id>/run.json path.
blob = run.model_dump_json()
rehydrated = SwarmRun.model_validate_json(blob)
assert rehydrated.provider == "openai"
assert rehydrated.model == "gpt-4o"
+ assert rehydrated.reasoning_effort == "max"
+ assert rehydrated.use_responses_api is True
def test_provider_and_model_default_to_none() -> None:
@@ -44,6 +58,123 @@ def test_provider_and_model_default_to_none() -> None:
assert run.provider is None
assert run.model is None
+ assert run.reasoning_effort is None
+ assert run.use_responses_api is None
+
+
+def test_runtime_loads_dotenv_before_capturing_provider_model(
+ monkeypatch: pytest.MonkeyPatch,
+ tmp_path,
+) -> None:
+ env_file = tmp_path / ".env"
+ env_file.write_text(
+ "LANGCHAIN_MODEL_NAME=smoke-model-from-dotenv\n",
+ encoding="utf-8",
+ )
+ monkeypatch.setenv("LANGCHAIN_PROVIDER", "openai")
+ monkeypatch.setenv("LANGCHAIN_REASONING_EFFORT", "max")
+ monkeypatch.setenv("LANGCHAIN_USE_RESPONSES_API", "true")
+ monkeypatch.delenv("LANGCHAIN_MODEL_NAME", raising=False)
+ monkeypatch.setattr(llm_mod, "_ENV_CANDIDATES", [env_file])
+ monkeypatch.setattr(llm_mod, "_dotenv_loaded", False)
+ reset_env_config()
+ monkeypatch.setattr(SwarmRuntime, "_execute_run", lambda *_: None)
+ runtime = SwarmRuntime(store=SwarmStore(tmp_path / "runs"))
+
+ run = runtime.start_run("risk_committee", {"goal": "smoke test"})
+
+ assert run.provider == "openai"
+ assert run.model == "smoke-model-from-dotenv"
+ assert run.reasoning_effort == "max"
+ assert run.use_responses_api is True
+
+
+def test_runtime_resolves_unset_responses_api_to_false(
+ monkeypatch: pytest.MonkeyPatch,
+ tmp_path,
+) -> None:
+ env_file = tmp_path / ".env"
+ env_file.write_text("LANGCHAIN_MODEL_NAME=smoke-model\n", encoding="utf-8")
+ monkeypatch.setenv("LANGCHAIN_PROVIDER", "openai")
+ monkeypatch.delenv("LANGCHAIN_USE_RESPONSES_API", raising=False)
+ monkeypatch.setattr(llm_mod, "_ENV_CANDIDATES", [env_file])
+ monkeypatch.setattr(llm_mod, "_dotenv_loaded", False)
+ reset_env_config()
+ monkeypatch.setattr(SwarmRuntime, "_execute_run", lambda *_: None)
+ runtime = SwarmRuntime(store=SwarmStore(tmp_path / "runs"))
+
+ run = runtime.start_run("risk_committee", {"goal": "smoke test"})
+
+ assert run.use_responses_api is False
+
+
+def test_runtime_redacts_sensitive_llm_metadata_before_persistence(
+ monkeypatch: pytest.MonkeyPatch,
+ tmp_path,
+) -> None:
+ env_file = tmp_path / ".env"
+ env_file.write_text(
+ "LANGCHAIN_MODEL_NAME=api_key=must-not-be-persisted\n",
+ encoding="utf-8",
+ )
+ monkeypatch.setenv("LANGCHAIN_PROVIDER", "openai")
+ monkeypatch.setattr(llm_mod, "_ENV_CANDIDATES", [env_file])
+ monkeypatch.setattr(llm_mod, "_dotenv_loaded", False)
+ reset_env_config()
+ monkeypatch.setattr(SwarmRuntime, "_execute_run", lambda *_: None)
+ store = SwarmStore(tmp_path / "runs")
+ runtime = SwarmRuntime(store=store)
+
+ run = runtime.start_run("risk_committee", {"goal": "smoke test"})
+
+ assert run.model == "[redacted]"
+ assert store.load_run(run.id).model == "[redacted]"
+
+
+def test_runtime_bounds_llm_metadata_before_persistence(
+ monkeypatch: pytest.MonkeyPatch,
+ tmp_path,
+) -> None:
+ env_file = tmp_path / ".env"
+ env_file.write_text(
+ f"LANGCHAIN_MODEL_NAME={'x' * 129}\n",
+ encoding="utf-8",
+ )
+ monkeypatch.setenv("LANGCHAIN_PROVIDER", "openai")
+ monkeypatch.setattr(llm_mod, "_ENV_CANDIDATES", [env_file])
+ monkeypatch.setattr(llm_mod, "_dotenv_loaded", False)
+ reset_env_config()
+ monkeypatch.setattr(SwarmRuntime, "_execute_run", lambda *_: None)
+ store = SwarmStore(tmp_path / "runs")
+ runtime = SwarmRuntime(store=store)
+
+ run = runtime.start_run("risk_committee", {"goal": "smoke test"})
+
+ assert run.model == "[redacted]"
+ assert store.load_run(run.id).model == "[redacted]"
+
+
+def test_runtime_redacts_unsupported_reasoning_effort_before_persistence(
+ monkeypatch: pytest.MonkeyPatch,
+ tmp_path,
+) -> None:
+ env_file = tmp_path / ".env"
+ env_file.write_text(
+ "LANGCHAIN_REASONING_EFFORT=unsupported\n",
+ encoding="utf-8",
+ )
+ monkeypatch.setenv("LANGCHAIN_PROVIDER", "openai")
+ monkeypatch.setattr(llm_mod, "_ENV_CANDIDATES", [env_file])
+ monkeypatch.setattr(llm_mod, "_dotenv_loaded", False)
+ reset_env_config()
+ monkeypatch.setattr(SwarmRuntime, "_execute_run", lambda *_: None)
+ store = SwarmStore(tmp_path / "runs")
+ runtime = SwarmRuntime(store=store)
+
+ run = runtime.start_run("risk_committee", {"goal": "smoke test"})
+
+ assert run.reasoning_effort == "[redacted]"
+ assert store.load_run(run.id).reasoning_effort == "[redacted]"
def test_legacy_run_json_without_provider_model_still_parses() -> None:
@@ -63,6 +194,8 @@ def test_legacy_run_json_without_provider_model_still_parses() -> None:
assert run.id == "legacy-run"
assert run.provider is None
assert run.model is None
+ assert run.reasoning_effort is None
+ assert run.use_responses_api is None
# Untouched fields still come through.
assert run.total_input_tokens == 12345
assert run.total_output_tokens == 678
diff --git a/agent/tests/test_swarm_status_hydration.py b/agent/tests/test_swarm_status_hydration.py
index 7d1c97df0..a67ea5644 100644
--- a/agent/tests/test_swarm_status_hydration.py
+++ b/agent/tests/test_swarm_status_hydration.py
@@ -125,6 +125,98 @@ def test_get_swarm_status_surfaces_live_progress(tmp_path, monkeypatch):
assert payload["is_stale"] is False
+def test_get_swarm_status_surfaces_llm_request_metadata(tmp_path, monkeypatch):
+ store = SwarmStore(base_dir=tmp_path)
+ run = _base_run()
+ run.provider = "openai"
+ run.model = "reasoning-model"
+ run.reasoning_effort = "max"
+ run.use_responses_api = True
+ store.create_run(run)
+ monkeypatch.setattr(mcp_server, "_get_swarm_store", lambda: store)
+
+ payload = json.loads(mcp_server.get_swarm_status(run.id))
+
+ assert payload["provider"] == "openai"
+ assert payload["model"] == "reasoning-model"
+ assert payload["reasoning_effort"] == "max"
+ assert payload["use_responses_api"] is True
+
+
+def test_get_swarm_status_redacts_sensitive_llm_request_metadata(tmp_path, monkeypatch):
+ store = SwarmStore(base_dir=tmp_path)
+ run = _base_run()
+ run.provider = "openai"
+ run.model = "api_key=must-not-be-returned"
+ run.reasoning_effort = "max"
+ store.create_run(run)
+ monkeypatch.setattr(mcp_server, "_get_swarm_store", lambda: store)
+
+ payload = json.loads(mcp_server.get_swarm_status(run.id))
+
+ assert payload["provider"] == "openai"
+ assert payload["model"] == "[redacted]"
+ assert payload["reasoning_effort"] == "max"
+
+
+def test_get_swarm_status_redacts_url_shaped_provider_metadata(tmp_path, monkeypatch):
+ store = SwarmStore(base_dir=tmp_path)
+ run = _base_run()
+ run.provider = "https://provider.example/path?session=private"
+ store.create_run(run)
+ monkeypatch.setattr(mcp_server, "_get_swarm_store", lambda: store)
+
+ payload = json.loads(mcp_server.get_swarm_status(run.id))
+
+ assert payload["provider"] == "[redacted]"
+
+
+def test_get_swarm_status_redacts_control_character_model_metadata(tmp_path, monkeypatch):
+ store = SwarmStore(base_dir=tmp_path)
+ run = _base_run()
+ run.model = "model\x00must-not-be-returned"
+ store.create_run(run)
+ monkeypatch.setattr(mcp_server, "_get_swarm_store", lambda: store)
+
+ payload = json.loads(mcp_server.get_swarm_status(run.id))
+
+ assert payload["model"] == "[redacted]"
+
+
+def test_list_runs_redacts_sensitive_llm_request_metadata(tmp_path, monkeypatch):
+ store = SwarmStore(base_dir=tmp_path)
+ run = _base_run()
+ run.provider = "openai"
+ run.model = "api_key=must-not-be-returned"
+ run.reasoning_effort = "max"
+ store.create_run(run)
+ monkeypatch.setattr(mcp_server, "_get_swarm_store", lambda: store)
+
+ payload = json.loads(mcp_server.list_runs())
+
+ assert payload[0]["provider"] == "openai"
+ assert payload[0]["model"] == "[redacted]"
+ assert payload[0]["reasoning_effort"] == "max"
+
+
+def test_list_runs_surfaces_llm_request_metadata(tmp_path, monkeypatch):
+ store = SwarmStore(base_dir=tmp_path)
+ run = _base_run()
+ run.provider = "openai"
+ run.model = "reasoning-model"
+ run.reasoning_effort = "max"
+ run.use_responses_api = False
+ store.create_run(run)
+ monkeypatch.setattr(mcp_server, "_get_swarm_store", lambda: store)
+
+ payload = json.loads(mcp_server.list_runs())
+
+ assert payload[0]["provider"] == "openai"
+ assert payload[0]["model"] == "reasoning-model"
+ assert payload[0]["reasoning_effort"] == "max"
+ assert payload[0]["use_responses_api"] is False
+
+
# ``test_get_swarm_status_flags_silent_run_as_stale`` from v2 was removed in
# v3 — read paths now auto-reconcile, so a zombie surfaces as ``status=failed``
# immediately (see ``test_get_swarm_status_auto_recovers_zombie`` below). The