fred-runtime 2.0.0__tar.gz → 2.0.1__tar.gz

{fred_runtime-2.0.0 → fred_runtime-2.0.1}/PKG-INFO

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

{fred_runtime-2.0.0 → fred_runtime-2.0.1}/fred_runtime/app/agent_app.py

@@ -558,12 +558,8 @@ class LocalRegistryAgentInvoker(AgentInvokerPort):
                 is_error=True,
             )
 
-        execute_request = _AgentExecuteRequest.model_construct(
-            agent_id=request.agent_id,
-            agent_instance_id=None,
-            message=request.message,
-            context=request.context.model_dump(mode="json"),
-            resume_payload=None,
+        execute_request = _to_internal_request(
+            _build_runtime_execute_request_from_invocation(request)
         )
 
         content_parts: list[str] = []
@@ -770,6 +766,13 @@ class _AgentExecuteRequest(BaseModel):
         return self
 
 
+@dataclass(slots=True)
+class _PreparedRuntimeExecution:
+    runtime: ReActRuntime | GraphRuntime
+    execution_config: ExecutionConfig
+    executor_input: Any
+
+
 def _to_internal_request(r: RuntimeExecuteRequest) -> "_AgentExecuteRequest":
     """
     Bridge a public RuntimeExecuteRequest to the internal execution model.
@@ -794,6 +797,36 @@ def _to_internal_request(r: RuntimeExecuteRequest) -> "_AgentExecuteRequest":
     )
 
 
+def _build_runtime_execute_request_from_invocation(
+    request: AgentInvocationRequest,
+) -> RuntimeExecuteRequest:
+    """
+    Project one in-process agent invocation onto the public execute contract.
+
+    Why this exists:
+    - pod-local agent-to-agent calls should follow the same request projection
+      path as HTTP execution, rather than hand-constructing a second private
+      request shape
+    - future continuity fields should therefore land once on the typed runtime
+      contract, then flow through both local and remote invocation paths
+
+    How to use it:
+    - call from `LocalRegistryAgentInvoker.invoke(...)`
+    - pass the result through `_to_internal_request(...)` until the remaining
+      internal helpers consume `RuntimeExecuteRequest` directly
+
+    Example:
+    - `runtime_request = _build_runtime_execute_request_from_invocation(request)`
+    """
+
+    return RuntimeExecuteRequest(
+        agent_id=request.agent_id,
+        input=request.message,
+        session_id=request.context.session_id,
+        runtime_context=request.context.model_dump(mode="json"),
+    )
+
+
 class _AgentTemplateSummary(BaseModel):
     template_agent_id: str
     title: str
@@ -838,17 +871,23 @@ def _apply_runtime_tuning(
     - `definition = _apply_runtime_tuning(template_definition, resolution.tuning)`
     """
 
-    return definition.model_copy(
-        update={
-            "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
-            ),
-        }
-    )
+    update: dict[str, Any] = {
+        "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
+        ),
+    }
+    system_prompt = tuning.values.get("prompts.system")
+    if (
+        isinstance(definition, ReActAgentDefinition)
+        and isinstance(system_prompt, str)
+        and system_prompt.strip()
+    ):
+        update["system_prompt_template"] = system_prompt
+    return definition.model_copy(update=update)
 
 
 def _available_mcp_servers_for_definition(
@@ -1565,7 +1604,42 @@ async def _stream(
             )
 
 
-async def _iterate_runtime_event_payloads(
+def _build_executor_input(
+    definition: ReActAgentDefinition | GraphAgentDefinition,
+    request: _AgentExecuteRequest,
+) -> Any:
+    """
+    Normalize one turn into the executor input expected by the selected runtime.
+
+    Why this exists:
+    - `ReActRuntime` and `GraphRuntime` accept different input shapes
+    - resume turns also bypass normal message validation, so the mapping should
+      live in one helper instead of being repeated inline in the execution loop
+
+    How to use it:
+    - call while assembling one prepared runtime execution
+    - pass the returned object unchanged to `executor.stream(...)`
+
+    Example:
+    - `executor_input = _build_executor_input(definition, request)`
+    """
+
+    if isinstance(definition, GraphAgentDefinition):
+        input_cls = definition.input_model()
+        if request.resume_payload is not None:
+            return input_cls.model_construct(message="")
+        return input_cls.model_validate({"message": request.message or ""})
+
+    return ReActInput(
+        messages=(
+            ()
+            if request.resume_payload is not None
+            else (ReActMessage(role=ReActMessageRole.USER, content=request.message),)
+        ),
+    )
+
+
+def _prepare_runtime_execution(
     definition: ReActAgentDefinition | GraphAgentDefinition,
     request: _AgentExecuteRequest,
     access_token: str | None = None,
@@ -1573,26 +1647,24 @@ async def _iterate_runtime_event_payloads(
     team_id: str | None = None,
     registry: Mapping[str, ReActAgentDefinition | GraphAgentDefinition] | None = None,
     exchange_id: str | None = None,
-) -> AsyncIterator[dict[str, Any]]:
+) -> _PreparedRuntimeExecution:
     """
-    Execute one agent turn and yield runtime-event payloads as JSON-ready dicts.
+    Build the bound runtime, executor input, and execution config for one turn.
 
-    Why this helper exists:
-    - both `/agents/execute` and `/agents/execute/stream` share the same runtime
-      wiring and event production path
-    - keeping the generator payload-oriented lets the HTTP layer choose whether
-      it renders SSE or returns a terminal JSON response
+    Why this exists:
+    - `execute`, `execute/stream`, and in-process agent invocation all converge
+      on `_iterate_runtime_event_payloads`, so this is the narrowest place to
+      centralize request projection before memory fields are added
+    - it removes one long block of binding/runtime setup from the event loop and
+      gives future continuity fields a single place to enter the runtime stack
 
-    team_id:
-    - callers are responsible for resolving the effective team before calling this
-      function; see _stream() for the standalone "personal" default logic
-    - None is accepted for agent-to-agent (AgentInvoker) invocations where no
-      team scope is required
+    How to use it:
+    - call from `_iterate_runtime_event_payloads(...)`
+    - activate the returned runtime, obtain its executor, then stream with the
+      returned `executor_input` and `execution_config`
 
-    access_token:
-    - the user's JWT forwarded via the Authorization header
-    - stored in RuntimeContext so KF tool adapters can use it for outbound calls
-    - None in local dev when security is disabled
+    Example:
+    - `prepared = _prepare_runtime_execution(definition, request, team_id="fredlab")`
     """
 
     request_id = str(uuid4())
@@ -1651,7 +1723,6 @@ async def _iterate_runtime_event_payloads(
         runtime_context=runtime_context,
         portable_context=portable_context,
     )
-
     services = _build_runtime_services(
         definition,
         binding,
@@ -1659,8 +1730,9 @@ async def _iterate_runtime_event_payloads(
         registry=registry,
         access_token=access_token,
     )
+    runtime: ReActRuntime | GraphRuntime
     if isinstance(definition, GraphAgentDefinition):
-        runtime: ReActRuntime | GraphRuntime = GraphRuntime(
+        runtime = GraphRuntime(
             definition=definition,
             services=services,
         )
@@ -1679,40 +1751,58 @@ async def _iterate_runtime_event_payloads(
         checkpoint_id=request.checkpoint_id,
         resume_payload=request.resume_payload,
     )
+    return _PreparedRuntimeExecution(
+        runtime=runtime,
+        execution_config=execution_config,
+        executor_input=_build_executor_input(definition, request),
+    )
+
+
+async def _iterate_runtime_event_payloads(
+    definition: ReActAgentDefinition | GraphAgentDefinition,
+    request: _AgentExecuteRequest,
+    access_token: str | None = None,
+    *,
+    team_id: str | None = None,
+    registry: Mapping[str, ReActAgentDefinition | GraphAgentDefinition] | None = None,
+    exchange_id: str | None = None,
+) -> AsyncIterator[dict[str, Any]]:
+    """
+    Execute one agent turn and yield runtime-event payloads as JSON-ready dicts.
+
+    Why this helper exists:
+    - both `/agents/execute` and `/agents/execute/stream` share the same runtime
+      wiring and event production path
+    - keeping the generator payload-oriented lets the HTTP layer choose whether
+      it renders SSE or returns a terminal JSON response
+
+    team_id:
+    - callers are responsible for resolving the effective team before calling this
+      function; see _stream() for the standalone "personal" default logic
+    - None is accepted for agent-to-agent (AgentInvoker) invocations where no
+      team scope is required
+
+    access_token:
+    - the user's JWT forwarded via the Authorization header
+    - stored in RuntimeContext so KF tool adapters can use it for outbound calls
+    - None in local dev when security is disabled
+    """
+    prepared = _prepare_runtime_execution(
+        definition,
+        request,
+        access_token=access_token,
+        team_id=team_id,
+        registry=registry,
+        exchange_id=exchange_id,
+    )
 
     try:
-        await runtime.activate()
-        executor = await runtime.get_executor()
-        if isinstance(definition, GraphAgentDefinition):
-            # Graph agents receive their typed input schema; the agent's
-            # build_turn_state() maps it to graph state before the first node runs.
-            # The standard contract is a single "message" field in the input schema.
-            # On a HITL resume the runtime ignores input entirely (state is loaded
-            # from the checkpoint), so bypass validation with model_construct.
-            input_cls = definition.input_model()
-            if request.resume_payload is not None:
-                graph_input = input_cls.model_construct(message="")
-            else:
-                graph_input = input_cls.model_validate(
-                    {"message": request.message or ""}
-                )
-            executor_input: ReActInput | object = graph_input
-        else:
-            # On HITL resume, messages are ignored by the codec — the graph
-            # resumes from its checkpointed interrupt via Command(resume=...).
-            # On a normal turn, the user message is the only input.
-            executor_input = ReActInput(
-                messages=(
-                    ()
-                    if request.resume_payload is not None
-                    else (
-                        ReActMessage(
-                            role=ReActMessageRole.USER, content=request.message
-                        ),
-                    )
-                ),
-            )
-        async for event in executor.stream(executor_input, execution_config):
+        await prepared.runtime.activate()
+        executor = await prepared.runtime.get_executor()
+        async for event in executor.stream(
+            prepared.executor_input,
+            prepared.execution_config,
+        ):
             payload = event.model_dump(mode="json")
             if not isinstance(payload, dict):
                 raise RuntimeError(
@@ -1725,7 +1815,7 @@ async def _iterate_runtime_event_payloads(
         )
         yield RuntimeErrorEvent(message=str(exc)).model_dump(mode="json")
     finally:
-        await runtime.dispose()
+        await prepared.runtime.dispose()
 
 
 def _terminal_execute_payload(

{fred_runtime-2.0.0 → fred_runtime-2.0.1}/fred_runtime.egg-info/PKG-INFO

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

{fred_runtime-2.0.0 → fred_runtime-2.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fred-runtime"
-version = "2.0.0"
+version = "2.0.1"
 description = "Runtime adapters and infrastructure wiring for Fred v2 agents."
 readme = "README.md"
 requires-python = ">=3.12,<3.13"

{fred_runtime-2.0.0 → fred_runtime-2.0.1}/tests/test_agent_app.py

@@ -4,6 +4,7 @@ import asyncio
 import json
 import time
 from types import SimpleNamespace
+from typing import cast
 
 from conftest import StaticChatModelFactory, ToolFriendlyFakeChatModel
 from fastapi.testclient import TestClient
@@ -14,6 +15,11 @@ from fred_core.kpi.prometheus_kpi_store import PrometheusKPIStore
 from fred_core.users.store import postgres_user_store
 from fred_sdk.authoring import ReActAgent, tool
 from fred_sdk.authoring.api import ToolContext
+from fred_sdk.contracts.context import (
+    AgentInvocationRequest,
+    PortableContext,
+    PortableEnvironment,
+)
 from fred_sdk.contracts.execution import ExecutionGrant, ExecutionGrantAction
 from fred_sdk.contracts.models import ReActAgentDefinition
 from langchain_core.messages import AIMessage
@@ -884,6 +890,88 @@ def test_execute_route_propagates_checkpoint_and_observability_context(
     }
 
 
+def test_local_registry_invoker_reuses_runtime_execute_projection(monkeypatch) -> None:
+    """
+    Ensure local agent invocation flows through the typed runtime request bridge.
+
+    Why this exists:
+    - the multi-agent memory work needs one request-projection path for HTTP and
+      in-process agent calls, or new continuity fields will be duplicated again
+    - this regression proves `LocalRegistryAgentInvoker` no longer hand-builds a
+      separate private request payload
+
+    How to use it:
+    - run in the default offline `fred-runtime` test suite
+
+    Example:
+    - `pytest tests/test_agent_app.py -q`
+    """
+
+    seen: dict[str, object] = {}
+
+    async def _fake_iterate_runtime_event_payloads(
+        definition,
+        request,
+        access_token=None,
+        *,
+        team_id=None,
+        registry=None,
+        exchange_id=None,
+    ):
+        _ = (definition, access_token, team_id, registry, exchange_id)
+        seen["checkpoint_id"] = request.checkpoint_id
+        seen["context"] = dict(request.context or {})
+        yield {"kind": "final", "sequence": 0, "content": "ok"}
+
+    monkeypatch.setattr(
+        agent_app_module,
+        "_iterate_runtime_event_payloads",
+        _fake_iterate_runtime_event_payloads,
+    )
+
+    definition = _EchoAgent()
+    invoker = agent_app_module.LocalRegistryAgentInvoker(
+        registry={definition.agent_id: definition},
+        access_token="token-1",
+    )
+
+    result = asyncio.run(
+        invoker.invoke(
+            AgentInvocationRequest(
+                agent_id=definition.agent_id,
+                message="hello",
+                context=PortableContext(
+                    request_id="req-1",
+                    correlation_id="corr-1",
+                    actor="alice",
+                    tenant="tenant-a",
+                    environment=PortableEnvironment.DEV,
+                    trace_id="trace-1",
+                    session_id="session-1",
+                    user_id="alice",
+                    team_id="fredlab",
+                ),
+            )
+        )
+    )
+
+    assert result.content == "ok"
+    assert result.is_error is False
+    assert seen["checkpoint_id"] is None
+    context = seen["context"]
+    assert isinstance(context, dict)
+    assert context["request_id"] == "req-1"
+    assert context["correlation_id"] == "corr-1"
+    assert context["actor"] == "alice"
+    assert context["tenant"] == "tenant-a"
+    assert context["environment"] == "dev"
+    assert context["trace_id"] == "trace-1"
+    assert context["session_id"] == "session-1"
+    assert context["user_id"] == "alice"
+    assert context["team_id"] == "fredlab"
+    assert context["execution_action"] == "execute"
+
+
 def test_resume_rejects_non_pending_checkpoint(monkeypatch, tmp_path) -> None:
     """
     Ensure resume requests fail fast when the checkpoint is not waiting for input.
@@ -1071,3 +1159,65 @@ def test_no_security_resolves_personal_team_in_portable_context(
     assert any("team:personal" in e.get("content", "") for e in tool_results), (
         f"Expected team:personal in tool_result events, got: {tool_results}"
     )
+
+
+def test_apply_runtime_tuning_applies_system_prompt_from_values() -> None:
+    """
+    Ensure _apply_runtime_tuning writes prompts.system into system_prompt_template.
+
+    Why this exists:
+    - control-plane stores user-set field values in AgentTuning.values; the
+      runtime must apply them at execution time, not silently drop them
+
+    How to use it:
+    - run in the default offline fred-runtime test suite
+
+    Example:
+    - `pytest tests/test_agent_app.py::test_apply_runtime_tuning_applies_system_prompt_from_values -q`
+    """
+    from fred_sdk.contracts.models import AgentTuning
+    from fred_runtime.app.agent_app import _apply_runtime_tuning
+
+    definition = _EchoAgent()
+    assert (
+        definition.system_prompt_template
+        == "Use the demo_echo tool, then answer briefly."
+    )
+
+    tuning = AgentTuning(
+        role=definition.role,
+        description=definition.description,
+        values={"prompts.system": "Custom override prompt."},
+    )
+    result = cast(_EchoAgent, _apply_runtime_tuning(definition, tuning))
+    assert result.system_prompt_template == "Custom override prompt."
+    assert result.policy().system_prompt_template == "Custom override prompt."
+
+
+def test_apply_runtime_tuning_ignores_blank_system_prompt() -> None:
+    """
+    Ensure _apply_runtime_tuning does not override when prompts.system is blank.
+
+    Why this exists:
+    - an empty or whitespace-only value means "use the agent default"; the
+      control-plane UI stores an empty string when the field is cleared
+
+    How to use it:
+    - run in the default offline fred-runtime test suite
+    """
+    from fred_sdk.contracts.models import AgentTuning
+    from fred_runtime.app.agent_app import _apply_runtime_tuning
+
+    definition = _EchoAgent()
+    original = definition.system_prompt_template
+
+    for blank in ("", "   "):
+        tuning = AgentTuning(
+            role=definition.role,
+            description=definition.description,
+            values={"prompts.system": blank},
+        )
+        result = cast(_EchoAgent, _apply_runtime_tuning(definition, tuning))
+        assert result.system_prompt_template == original, (
+            f"blank {blank!r} should not override"
+        )