fred-runtime 2.0.2__tar.gz → 2.0.4__tar.gz

{fred_runtime-2.0.2 → fred_runtime-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fred-runtime
-Version: 2.0.2
+Version: 2.0.4
 Summary: Runtime adapters and infrastructure wiring for Fred v2 agents.
 Author-email: Thales <noreply@thalesgroup.com>
 License: Apache-2.0

{fred_runtime-2.0.2 → fred_runtime-2.0.4}/fred_runtime/app/agent_app.py

@@ -62,15 +62,16 @@ from fred_core.logs.log_setup import log_setup
 from fred_core.logs.memory_log_store import RamLogStore
 from fred_core.security.oidc import get_keycloak_client_id, get_keycloak_url
 from fred_core.security.structure import KeycloakUser
-from fred_sdk.contracts.eval import EvalStep, EvalTrace
 from fred_sdk.contracts.context import (
     AgentInvocationRequest,
     AgentInvocationResult,
     BoundRuntimeContext,
+    ConversationTurn,
     PortableContext,
     PortableEnvironment,
     RuntimeContext,
 )
+from fred_sdk.contracts.eval import EvalStep, EvalTrace
 from fred_sdk.contracts.execution import (
     ExecutionGrantAction,
     ExecutionGrantViolation,
@@ -83,6 +84,7 @@ from fred_sdk.contracts.models import (
     GraphAgentDefinition,
     MCPServerConfiguration,
     ReActAgentDefinition,
+    TuningValue,
 )
 from fred_sdk.contracts.react_contract import ReActInput, ReActMessage, ReActMessageRole
 from fred_sdk.contracts.runtime import (
@@ -94,9 +96,6 @@ from fred_sdk.contracts.runtime import (
     RuntimeEvent,
     RuntimeServices,
 )
-from fred_runtime.graph.graph_runtime import GraphRuntime
-from fred_runtime.react.react_runtime import ReActRuntime
-from fred_runtime.runtime_support.checkpoints import load_checkpoint
 from fred_sdk.support.authored_toolsets import (
     AuthoredToolRuntimePorts,
     build_authored_tool_handlers,
@@ -104,6 +103,9 @@ from fred_sdk.support.authored_toolsets import (
 from pydantic import BaseModel, Field, TypeAdapter, model_validator
 
 from fred_runtime.common.kf_markdown_media_client import KfMarkdownMediaClient
+from fred_runtime.graph.graph_runtime import GraphRuntime
+from fred_runtime.react.react_runtime import ReActRuntime
+from fred_runtime.runtime_support.checkpoints import load_checkpoint
 
 from ..common.structures import AgentSettingsLike
 from ..integrations.v2_runtime.adapters import (
@@ -567,6 +569,7 @@ class LocalRegistryAgentInvoker(AgentInvokerPort):
             message=request.message,
             context=context_dict,
             resume_payload=None,
+            invocation_turns=request.prior_turns,
         )
 
         content_parts: list[str] = []
@@ -748,6 +751,14 @@ class _AgentExecuteRequest(BaseModel):
             "LangGraph Command(resume=...) — the message field is ignored."
         ),
     )
+    invocation_turns: tuple[ConversationTurn, ...] = Field(
+        default=(),
+        description="Prior conversation turns forwarded by the calling agent.",
+    )
+    inline_tuning: dict[str, TuningValue] | None = Field(
+        default=None,
+        description="Optional inline tuning overrides. Honored only in agent_id (direct template) mode.",
+    )
 
     @model_validator(mode="after")
     def _require_message_or_resume(self) -> "_AgentExecuteRequest":
@@ -794,6 +805,8 @@ def _to_internal_request(r: RuntimeExecuteRequest) -> "_AgentExecuteRequest":
         context=r.to_legacy_context() or None,
         checkpoint_id=r.checkpoint_id,
         resume_payload=r.resume_payload,
+        invocation_turns=r.invocation_turns,
+        inline_tuning=r.inline_tuning,
     )
 
 
@@ -806,6 +819,18 @@ class _AgentTemplateSummary(BaseModel):
     available_mcp_servers: list[MCPServerConfiguration] = Field(default_factory=list)
 
 
+class _McpCatalogEntry(BaseModel):
+    id: str
+    name: str
+    description: str | None = None
+    enabled: bool
+    transport: str | None = None
+
+
+class _McpCatalogResponse(BaseModel):
+    servers: list[_McpCatalogEntry]
+
+
 class _ResolvedAgentInstance(BaseModel):
     agent_instance_id: str
     template_agent_id: str
@@ -827,7 +852,7 @@ def _apply_runtime_tuning(
     definition: ReActAgentDefinition | GraphAgentDefinition, tuning: AgentTuning
 ) -> ReActAgentDefinition | GraphAgentDefinition:
     """
-    Overlay persisted business tuning onto one registered ReAct template.
+    Overlay persisted business tuning onto one registered agent template.
 
     Why this exists:
     - control-plane stores the full effective tuning for a managed agent
@@ -841,18 +866,29 @@ def _apply_runtime_tuning(
     - `definition = _apply_runtime_tuning(template_definition, resolution.tuning)`
     """
 
+    mcp_servers = tuning.mcp_servers
+    if tuning.selected_mcp_server_ids:
+        selected = frozenset(tuning.selected_mcp_server_ids)
+        mcp_servers = [s for s in mcp_servers if s.id in selected]
+
     update: dict[str, object] = {
         "role": tuning.role,
         "description": tuning.description,
         "tags": tuple(tuning.tags),
         "fields": tuple(field.model_copy(deep=True) for field in tuning.fields),
         "default_mcp_servers": tuple(
-            server.model_copy(deep=True) for server in tuning.mcp_servers
+            server.model_copy(deep=True) for server in mcp_servers
         ),
+        # Forward all values for all agent types so every execution surface can
+        # read admin-set tuning (graph steps via context.tuning_values, ReAct
+        # prompting via definition.tuning_values).
+        "tuning_values": dict(tuning.values),
     }
-    system_prompt = tuning.values.get("prompts.system")
-    if isinstance(system_prompt, str) and system_prompt.strip():
-        update["system_prompt_template"] = system_prompt
+    if isinstance(definition, ReActAgentDefinition):
+        # Also overlay system_prompt_template directly for ReAct runtime compatibility.
+        system_prompt = tuning.values.get("prompts.system")
+        if isinstance(system_prompt, str) and system_prompt.strip():
+            update["system_prompt_template"] = system_prompt
     return definition.model_copy(update=update)
 
 
@@ -915,6 +951,18 @@ async def _resolve_agent_instance(
                 detail=f"Unknown agent_id: {request.agent_id!r}. "
                 f"Known agents: {list(registry.keys())}",
             )
+        if request.inline_tuning:
+            definition = _apply_runtime_tuning(
+                definition,
+                AgentTuning(
+                    role=definition.role,
+                    description=definition.description,
+                    tags=list(definition.tags),
+                    fields=list(definition.fields),
+                    mcp_servers=list(definition.default_mcp_servers),
+                    values=request.inline_tuning,
+                ),
+            )
         return _ResolvedExecutionTarget(
             definition=definition,
             effective_agent_id=definition.agent_id,
@@ -1745,11 +1793,24 @@ async def _iterate_runtime_event_payloads(
         user_groups=ctx.get("user_groups"),
         language=ctx.get("language"),
         access_token=access_token,
+        refresh_token=ctx.get("refresh_token"),
+        access_token_expires_at=ctx.get("access_token_expires_at"),
         trace_id=ctx.get("trace_id"),
         correlation_id=correlation_id,
         agent_instance_id=request.agent_instance_id,
         template_agent_id=definition.agent_id,
         execution_action=execution_action,
+        # Chat options forwarded from the frontend RuntimeContext.
+        # These were present in ctx but were silently dropped, causing
+        # ContextAwareTool and all KF search helpers to always use defaults.
+        selected_document_libraries_ids=ctx.get("selected_document_libraries_ids"),
+        selected_document_uids=ctx.get("selected_document_uids"),
+        selected_chat_context_ids=ctx.get("selected_chat_context_ids"),
+        search_policy=ctx.get("search_policy"),
+        search_rag_scope=ctx.get("search_rag_scope"),
+        include_session_scope=ctx.get("include_session_scope"),
+        include_corpus_scope=ctx.get("include_corpus_scope"),
+        deep_search=ctx.get("deep_search"),
     )
 
     binding = BoundRuntimeContext(
@@ -1783,6 +1844,7 @@ async def _iterate_runtime_event_payloads(
         session_id=ctx.get("session_id") or request_id,
         checkpoint_id=request.checkpoint_id,
         resume_payload=request.resume_payload,
+        invocation_turns=getattr(request, "invocation_turns", ()),
     )
 
     try:
@@ -1972,6 +2034,40 @@ def _build_agent_router(
             for definition in registry.values()
         ]
 
+    @router.get("/mcp-catalog")
+    async def get_mcp_catalog() -> _McpCatalogResponse:
+        """
+        Return the full MCP server catalog declared in mcp_catalog.yaml.
+
+        Why this endpoint exists:
+        - control-plane drift detection needs to compare stored instance
+          selections against the live pod catalog at listing time
+        - returns ALL servers (enabled and disabled) so the caller can
+          distinguish "configured but disabled" from "absent from catalog"
+
+        How to use it:
+        - call from control-plane agent-instance listing to populate
+          catalog_warnings when stored mcp_server_ids are no longer present
+
+        Example:
+        - `GET /fred/agents/v2/agents/mcp-catalog`
+        """
+        mcp_configuration = get_runtime_context().config.mcp_configuration
+        if mcp_configuration is None:
+            return _McpCatalogResponse(servers=[])
+        return _McpCatalogResponse(
+            servers=[
+                _McpCatalogEntry(
+                    id=srv.id,
+                    name=srv.name,
+                    description=srv.description,
+                    enabled=srv.enabled,
+                    transport=srv.transport,
+                )
+                for srv in mcp_configuration.servers
+            ]
+        )
+
     @router.get("/sessions", dependencies=_auth_deps)
     async def list_sessions(user_id: str) -> list[str]:
         """

{fred_runtime-2.0.2 → fred_runtime-2.0.4}/fred_runtime/cli/completion.py

@@ -14,6 +14,7 @@ _COMMANDS: tuple[str, ...] = (
     "/context",
     "/delete-session",
     "/delete-checkpoint",
+    "/inspect",
     "/purge-session",
     "/execution-context",
     "/history",
@@ -21,17 +22,32 @@ _COMMANDS: tuple[str, ...] = (
     "/login",
     "/login-password",
     "/mode",
+    "/run",
     "/session",
     "/session-info",
     "/session-new",
     "/sessions",
     "/stats",
     "/team",
+    "/tune",
+    "/tuning",
     "/logout",
     "/quit",
     "/whoami",
 )
 
+# Scenario keywords for fred.test.assistant — used for /run tab-completion.
+_TEST_ASSISTANT_SCENARIOS: tuple[str, ...] = (
+    "echo",
+    "error",
+    "hitl choice",
+    "hitl text",
+    "long",
+    "model planning",
+    "model routing",
+    "trace",
+)
+
 
 def completion_candidates(
     line_buffer: str,
@@ -50,6 +66,9 @@ def completion_candidates(
     if stripped.startswith("/mode "):
         prefix = stripped.removeprefix("/mode ").strip()
         return [mode for mode in ("eval", "final", "stream") if mode.startswith(prefix)]
+    if stripped.startswith("/run "):
+        prefix = stripped.removeprefix("/run ").strip()
+        return [s for s in _TEST_ASSISTANT_SCENARIOS if s.startswith(prefix)]
     if stripped.startswith("/"):
         return complete_slash_commands(stripped, commands=_COMMANDS)
     return []

{fred_runtime-2.0.2 → fred_runtime-2.0.4}/fred_runtime/cli/history_display.py

@@ -312,6 +312,7 @@ def run_single_turn(
     stream: bool,
     color_enabled: bool,
     resume_payload: Any = None,
+    inline_tuning: dict[str, Any] | None = None,
 ) -> tuple[int, dict[str, Any] | None]:
     """
     Execute one prompt and print the most useful runtime output.
@@ -327,6 +328,7 @@ def run_single_turn(
             user_id=user_id,
             team_id=team_id,
             resume_payload=resume_payload,
+            inline_tuning=inline_tuning,
         )
         if "error" in payload:
             print(
@@ -362,6 +364,7 @@ def run_single_turn(
         user_id=user_id,
         team_id=team_id,
         resume_payload=resume_payload,
+        inline_tuning=inline_tuning,
     ):
         if verbose:
             print(json.dumps(event, ensure_ascii=False))

{fred_runtime-2.0.2 → fred_runtime-2.0.4}/fred_runtime/cli/pod_client.py

@@ -58,6 +58,16 @@ class AgentPodClient:
             raise RuntimeError("Agent list response must be a JSON array of strings.")
         return payload
 
+    def list_templates(self) -> list[dict[str, Any]]:
+        response = self.http_client.get(
+            f"{self.base_url}/agents/templates", headers=self._auth_headers()
+        )
+        response.raise_for_status()
+        payload = response.json()
+        if not isinstance(payload, list):
+            raise RuntimeError("Templates response must be a JSON array.")
+        return payload
+
     def execute(
         self,
         *,
@@ -69,6 +79,7 @@ class AgentPodClient:
         agent_instance_id: str | None = None,
         checkpoint_id: str | None = None,
         resume_payload: Any = None,
+        inline_tuning: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         runtime_context: dict[str, Any] = {"user_id": user_id}
         if team_id:
@@ -85,6 +96,8 @@ class AgentPodClient:
             payload["checkpoint_id"] = checkpoint_id
         if resume_payload is not None:
             payload["resume_payload"] = resume_payload
+        if inline_tuning:
+            payload["inline_tuning"] = inline_tuning
         response = self.http_client.post(
             f"{self.base_url}/agents/execute",
             json=payload,
@@ -142,6 +155,7 @@ class AgentPodClient:
         agent_instance_id: str | None = None,
         checkpoint_id: str | None = None,
         resume_payload: Any = None,
+        inline_tuning: dict[str, Any] | None = None,
     ) -> list[dict[str, Any]]:
         events: list[dict[str, Any]] = []
         for event in self.iter_stream_events(
@@ -153,6 +167,7 @@ class AgentPodClient:
             agent_instance_id=agent_instance_id,
             checkpoint_id=checkpoint_id,
             resume_payload=resume_payload,
+            inline_tuning=inline_tuning,
         ):
             events.append(event)
         return events
@@ -168,6 +183,7 @@ class AgentPodClient:
         agent_instance_id: str | None = None,
         checkpoint_id: str | None = None,
         resume_payload: Any = None,
+        inline_tuning: dict[str, Any] | None = None,
     ) -> Iterator[dict[str, Any]]:
         runtime_context: dict[str, Any] = {"user_id": user_id}
         if team_id:
@@ -184,6 +200,8 @@ class AgentPodClient:
             payload["checkpoint_id"] = checkpoint_id
         if resume_payload is not None:
             payload["resume_payload"] = resume_payload
+        if inline_tuning:
+            payload["inline_tuning"] = inline_tuning
         with self.http_client.stream(
             "POST",
             f"{self.base_url}/agents/execute/stream",

{fred_runtime-2.0.2 → fred_runtime-2.0.4}/fred_runtime/cli/repl.py

@@ -33,7 +33,10 @@ from .repl_helpers import (
     execution_mode_label,
     fmt_bytes,
     parse_mode_command,
+    parse_tuning_value,
     print_help,
+    print_inspect,
+    print_tuning_table,
 )
 
 
@@ -109,11 +112,21 @@ def run_interactive_chat(
     current_session_id = session_id
     current_mode: ExecutionMode = mode
     current_team_id = team_id
+    current_inline_tuning: dict[str, Any] = {}
     while True:
         try:
+            tuning_badge = (
+                colorize(
+                    f" ~{len(current_inline_tuning)}",
+                    color=ANSI_YELLOW,
+                    enabled=color_enabled,
+                )
+                if current_inline_tuning
+                else ""
+            )
             prompt = (
                 f"{colorize(current_agent, color=ANSI_CYAN, enabled=color_enabled, bold=True)}"
-                "> "
+                f"{tuning_badge}> "
             )
             message = input(prompt).strip()
         except EOFError:
@@ -1161,6 +1174,87 @@ def run_interactive_chat(
         if message in {"/quit", "/exit"}:
             return 0
 
+        # ── /inspect ───────────────────────────────────────────────────────
+        if message == "/inspect":
+            try:
+                templates = client.list_templates()
+            except Exception as exc:
+                print(
+                    colorize(
+                        f"  Could not load templates: {exc}",
+                        color=ANSI_RED,
+                        enabled=color_enabled,
+                    )
+                )
+                continue
+            print_inspect(templates, current_agent, color_enabled=color_enabled)
+            continue
+
+        # ── /run <scenario> ────────────────────────────────────────────────
+        if message.startswith("/run"):
+            scenario = message.removeprefix("/run").strip()
+            if not scenario:
+                print(
+                    colorize(
+                        "  Usage: /run <scenario>  (tab-complete for available scenarios)",
+                        color=ANSI_DIM,
+                        enabled=color_enabled,
+                    )
+                )
+                continue
+            message = scenario
+
+        # ── /tuning / /tune ────────────────────────────────────────────────
+        if message == "/tuning":
+            print_tuning_table(current_inline_tuning, color_enabled=color_enabled)
+            continue
+        if message.startswith("/tune"):
+            arg = message.removeprefix("/tune").strip()
+            if not arg:
+                print_tuning_table(current_inline_tuning, color_enabled=color_enabled)
+                continue
+            if "=" not in arg:
+                print(
+                    colorize(
+                        "  Usage: /tune key=value  (clear with key=)",
+                        color=ANSI_DIM,
+                        enabled=color_enabled,
+                    )
+                )
+                continue
+            key, _, raw_val = arg.partition("=")
+            key = key.strip()
+            if not key:
+                print(
+                    colorize(
+                        "  Key cannot be empty.",
+                        color=ANSI_YELLOW,
+                        enabled=color_enabled,
+                    )
+                )
+                continue
+            if not raw_val:
+                current_inline_tuning.pop(key, None)
+                print(
+                    colorize(
+                        f"  Cleared tuning override for {key!r}.",
+                        color=ANSI_DIM,
+                        enabled=color_enabled,
+                    )
+                )
+            else:
+                value = parse_tuning_value(raw_val)
+                current_inline_tuning[key] = value
+                val_repr = repr(value) if not isinstance(value, str) else f'"{value}"'
+                print(
+                    colorize(
+                        f"  Set {key} = {val_repr}",
+                        color=ANSI_GREEN,
+                        enabled=color_enabled,
+                    )
+                )
+            continue
+
         if message.startswith("/"):
             bare = message.split()[0]
             _USAGE_HINTS: dict[str, str] = {
@@ -1199,6 +1293,7 @@ def run_interactive_chat(
                 verbose=verbose,
                 stream=(current_mode == "stream"),
                 color_enabled=color_enabled,
+                inline_tuning=current_inline_tuning or None,
             )
             while hitl is not None:
                 req = hitl.get("request") or {}
@@ -1241,6 +1336,7 @@ def run_interactive_chat(
                     stream=(current_mode == "stream"),
                     color_enabled=color_enabled,
                     resume_payload=resume_value,
+                    inline_tuning=current_inline_tuning or None,
                 )
         if exit_code != 0:
             print("The request failed. Use /help for commands or try another agent.")