examples: add fake-model agent loop to skills_code_review_agent

Wire the review through the framework: an LlmAgent with a review_code
FunctionTool, driven by a FakeReviewModel that needs no API key. On the
first turn the fake model emits a single tool call with the user's diff;
on the second turn (after the deterministic pipeline runs behind the
tool) it summarizes the findings. run_agent.py demos it; a smoke test
asserts the tool is called, a summary is produced, and no secret leaks.

The guard Filter will attach on the tool via filters_name (TOOL scope),
not on the agent, in a follow-up slice.

Updates #92

RELEASE NOTES: NONE

Author: Acture

examples/skills_code_review_agent/README.md

@@ -20,6 +20,9 @@ python run_review.py --repo-path /path/to/repo --no-db
 
 # Scored self-test over the labelled fixtures (detection-rate / false-positive-rate):
 python selftest.py
+
+# Run the review through the LlmAgent (fake model, no API key needed):
+python run_agent.py --fixture 0001_insecure.diff
 ```
 
 ## How it works
@@ -74,7 +77,7 @@ a rendered report — criterion 5 is binary-checked, so redaction is centralized
 
 ## Status
 
-Implemented: deterministic pipeline, DB persistence, 8 fixtures, scored self-test, CLI. Baseline
-secret redaction is in place. Planned follow-up slices: in-sandbox execution (Container/Cube), the
-tool-level Filter gate, redaction hardening to ≥95%, OpenTelemetry metrics wiring, and the
-fake-model agent loop that drives the review as a Skill tool.
+Implemented: deterministic pipeline, DB persistence, 8 fixtures, scored self-test, CLI, and the
+fake-model agent loop (`run_agent.py` drives the review through `LlmAgent` + a `FunctionTool` with no
+API key). Baseline secret redaction is in place. Planned follow-up slices: in-sandbox execution
+(Container/Cube), the tool-level Filter gate, redaction hardening to ≥95%, and OpenTelemetry metrics.

examples/skills_code_review_agent/agent/agent.py

@@ -0,0 +1,28 @@
+# Tencent is pleased to support the open source community by making tRPC-Agent-Python available.
+#
+# Copyright (C) 2026 Tencent. All rights reserved.
+#
+# tRPC-Agent-Python is licensed under Apache-2.0.
+
+"""Construct the code-review LlmAgent (Skills + tool), used by run_agent.py."""
+from __future__ import annotations
+
+from trpc_agent_sdk.agents import LlmAgent
+
+from .config import get_model
+from .prompts import INSTRUCTION
+from .tools import build_review_tool
+
+
+def create_agent() -> LlmAgent:
+    """An LlmAgent that reviews a diff by calling the review_code tool, then summarizes.
+
+    The guard Filter (slice 3) attaches on the tool via ``filters_name`` — a TOOL-scoped filter,
+    not on the agent (which resolves in the AGENT namespace and would raise).
+    """
+    return LlmAgent(
+        name="code_review_agent",
+        model=get_model(),
+        instruction=INSTRUCTION,
+        tools=[build_review_tool()],
+    )

examples/skills_code_review_agent/agent/config.py

@@ -0,0 +1,28 @@
+# Tencent is pleased to support the open source community by making tRPC-Agent-Python available.
+#
+# Copyright (C) 2026 Tencent. All rights reserved.
+#
+# tRPC-Agent-Python is licensed under Apache-2.0.
+
+"""Configuration for the agent path — model selection and defaults."""
+from __future__ import annotations
+
+import os
+
+from trpc_agent_sdk.models import LLMModel
+
+from .model import FakeReviewModel
+
+
+def get_model() -> LLMModel:
+    """Return the fake model by default (no API key); a real OpenAI model if one is configured."""
+    api_key = os.getenv("TRPC_AGENT_API_KEY")
+    if api_key:
+        from trpc_agent_sdk.models import OpenAIModel
+
+        return OpenAIModel(
+            model_name=os.getenv("MODEL_NAME", "gpt-4o-mini"),
+            api_key=api_key,
+            base_url=os.getenv("TRPC_AGENT_BASE_URL"),
+        )
+    return FakeReviewModel(model_name="fake-review-1")

examples/skills_code_review_agent/agent/model.py

@@ -0,0 +1,75 @@
+# Tencent is pleased to support the open source community by making tRPC-Agent-Python available.
+#
+# Copyright (C) 2026 Tencent. All rights reserved.
+#
+# tRPC-Agent-Python is licensed under Apache-2.0.
+
+"""FakeReviewModel — deterministic, no-API-key model for the dry-run agent path (criterion 6/8).
+
+It does not call any LLM. On the first turn it emits a single tool call to ``review_code`` with the
+user's diff; on the second turn (after the tool result comes back) it emits a short text summary.
+This lets the Skills + tool + telemetry agent path run in CI with no secrets, while the actual
+findings come from the deterministic scanner pipeline behind the tool.
+"""
+from __future__ import annotations
+
+from typing import AsyncGenerator, List, Optional
+
+from trpc_agent_sdk.models import LlmRequest, LlmResponse, LLMModel
+from trpc_agent_sdk.types import Content, FunctionCall, Part
+
+_TOOL_NAME = "review_code"
+
+
+def _iter_parts(request: LlmRequest):
+    for content in request.contents or []:
+        for part in content.parts or []:
+            yield content, part
+
+
+def _has_tool_result(request: LlmRequest) -> Optional[dict]:
+    """Return the tool's response dict if this request already carries one (the second turn)."""
+    for _content, part in _iter_parts(request):
+        if part is not None and part.function_response is not None:
+            return part.function_response.response or {}
+    return None
+
+
+def _last_user_diff(request: LlmRequest) -> str:
+    """The diff to review is the most recent user text part."""
+    latest = ""
+    for content, part in _iter_parts(request):
+        if part is not None and part.text and (content.role or "user") == "user":
+            latest = part.text
+    return latest
+
+
+class FakeReviewModel(LLMModel):
+
+    @classmethod
+    def supported_models(cls) -> List[str]:
+        return [r"fake-review.*"]
+
+    def validate_request(self, request: LlmRequest) -> None:  # no external validation needed
+        return None
+
+    async def _generate_async_impl(self,
+                                   request: LlmRequest,
+                                   stream: bool = False,
+                                   ctx: object = None) -> AsyncGenerator[LlmResponse, None]:
+        tool_result = _has_tool_result(request)
+        if tool_result is not None:
+            summary = tool_result.get("summary", {})
+            sev = tool_result.get("severity", {})
+            text = (f"Review complete (task {tool_result.get('task_id', '?')}). "
+                    f"{summary.get('total', 0)} active finding(s) "
+                    f"[critical={sev.get('critical', 0)}, high={sev.get('high', 0)}, "
+                    f"medium={sev.get('medium', 0)}, low={sev.get('low', 0)}], "
+                    f"{summary.get('needs_human_review', 0)} for human review. "
+                    f"See review_report.json for details.")
+            yield LlmResponse(content=Content(role="model", parts=[Part(text=text)]))
+            return
+
+        diff = _last_user_diff(request)
+        call = FunctionCall(id="cr-call-1", name=_TOOL_NAME, args={"diff_text": diff})
+        yield LlmResponse(content=Content(role="model", parts=[Part(function_call=call)]))

examples/skills_code_review_agent/agent/prompts.py

@@ -0,0 +1,11 @@
+# Tencent is pleased to support the open source community by making tRPC-Agent-Python available.
+#
+# Copyright (C) 2026 Tencent. All rights reserved.
+#
+# tRPC-Agent-Python is licensed under Apache-2.0.
+
+"""System instruction for the code-review agent's LLM finding source."""
+
+INSTRUCTION = ("You are an automated code reviewer. When given a diff, call the `review_code` tool with the "
+               "diff text to run the static-analysis pipeline, then summarize the findings for the user: how "
+               "many issues by severity, and the most important ones to fix first. Be concise and specific.")

examples/skills_code_review_agent/agent/tools.py

@@ -0,0 +1,32 @@
+# Tencent is pleased to support the open source community by making tRPC-Agent-Python available.
+#
+# Copyright (C) 2026 Tencent. All rights reserved.
+#
+# tRPC-Agent-Python is licensed under Apache-2.0.
+
+"""The review tool the agent calls — a thin wrapper over the deterministic pipeline."""
+from __future__ import annotations
+
+from typing import Any
+
+from trpc_agent_sdk.tools import FunctionTool
+
+from pipeline.engine import run_review
+
+
+def review_code(diff_text: str) -> dict[str, Any]:
+    """Run the code-review pipeline on a unified diff and return a findings summary.
+
+    Args:
+        diff_text: the unified diff to review.
+    """
+    result = run_review(diff_text=diff_text)
+    return {
+        "task_id": result.task_id,
+        "summary": result.report.findings_summary,
+        "severity": result.report.severity_stats,
+    }
+
+
+def build_review_tool() -> FunctionTool:
+    return FunctionTool(review_code)

examples/skills_code_review_agent/run_agent.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+
+# Tencent is pleased to support the open source community by making tRPC-Agent-Python available.
+#
+# Copyright (C) 2026 Tencent. All rights reserved.
+#
+# tRPC-Agent-Python is licensed under Apache-2.0.
+
+"""Run a code review through the LlmAgent (Skills + tool) — the framework-exercising path.
+
+Dry-run by default: with no API key, FakeReviewModel drives one call to the review_code tool and
+summarizes the result — no LLM, no secrets. Set TRPC_AGENT_API_KEY to use a real model instead.
+
+    python run_agent.py --fixture 0001_insecure.diff
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import uuid
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from trpc_agent_sdk.runners import Runner
+from trpc_agent_sdk.sessions import InMemorySessionService
+from trpc_agent_sdk.types import Content, Part
+
+from agent.agent import create_agent
+
+HERE = Path(__file__).parent
+
+
+async def review(diff_text: str) -> None:
+    app_name = "code_review_agent"
+    agent = create_agent()
+    runner = Runner(app_name=app_name, agent=agent, session_service=InMemorySessionService())
+
+    user_id, session_id = "reviewer", str(uuid.uuid4())
+    await runner.session_service.create_session(app_name=app_name, user_id=user_id, session_id=session_id)
+
+    message = Content(role="user", parts=[Part(text=diff_text)])
+    async for event in runner.run_async(user_id=user_id, session_id=session_id, new_message=message):
+        if not event.content or not event.content.parts:
+            continue
+        for part in event.content.parts:
+            if part.text:
+                print(part.text, end="", flush=True)
+            elif part.function_call:
+                print(f"\n[tool call] {part.function_call.name}")
+            elif part.function_response:
+                print(f"[tool result] {part.function_response.response}")
+    print()
+
+
+def main() -> None:
+    load_dotenv()
+    ap = argparse.ArgumentParser(description="Review a diff via the code-review agent.")
+    src = ap.add_mutually_exclusive_group(required=True)
+    src.add_argument("--diff-file")
+    src.add_argument("--fixture")
+    args = ap.parse_args()
+    path = Path(args.diff_file) if args.diff_file else HERE / "fixtures" / "diffs" / args.fixture
+    asyncio.run(review(path.read_text(encoding="utf-8")))
+
+
+if __name__ == "__main__":
+    main()

tests/examples/test_skills_code_review_agent.py

@@ -3,7 +3,6 @@
 # Copyright (C) 2026 Tencent. All rights reserved.
 #
 # tRPC-Agent-Python is licensed under Apache-2.0.
-
 """Smoke tests for the skills_code_review_agent example.
 
 Deterministic and fast: no real model, no Docker. Verifies the dry-run pipeline detects issues,
@@ -106,3 +105,36 @@ async def test_persist_and_query_no_secret_leak(tmp_path) -> None:
     raw = db_file.read_bytes()
     for secret in _SECRETS:
         assert secret.encode() not in raw
+
+
+@pytest.mark.asyncio
+async def test_agent_path_calls_tool_and_summarizes() -> None:
+    """The fake-model agent loop drives the review_code tool and summarizes — no API key."""
+    import uuid
+
+    from trpc_agent_sdk.runners import Runner
+    from trpc_agent_sdk.sessions import InMemorySessionService
+    from trpc_agent_sdk.types import Content, Part
+
+    from agent.agent import create_agent
+
+    runner = Runner(app_name="cr_test", agent=create_agent(), session_service=InMemorySessionService())
+    sid = str(uuid.uuid4())
+    await runner.session_service.create_session(app_name="cr_test", user_id="u", session_id=sid)
+
+    diff = (_FIXTURES / "0001_insecure.diff").read_text()
+    saw_tool_call = False
+    final_text = ""
+    async for event in runner.run_async(user_id="u",
+                                        session_id=sid,
+                                        new_message=Content(role="user", parts=[Part(text=diff)])):
+        for part in (event.content.parts if event.content else []) or []:
+            if part.function_call:
+                saw_tool_call = True
+            if part.text:
+                final_text += part.text
+
+    assert saw_tool_call
+    assert "Review complete" in final_text
+    for secret in _SECRETS:
+        assert secret not in final_text