fred-sdk 3.3.4__tar.gz → 3.3.5__tar.gz

{fred_sdk-3.3.4 → fred_sdk-3.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fred-sdk
-Version: 3.3.4
+Version: 3.3.5
 Summary: Authoring SDK for Fred agents — graph, ReAct, and team agent primitives.
 Author-email: Thales <noreply@thalesgroup.com>
 License: Apache-2.0

{fred_sdk-3.3.4 → fred_sdk-3.3.5}/fred_sdk/authoring/__init__.py

@@ -58,7 +58,9 @@ from .knowledge_flow_mcp import (
     MCP_SERVER_KNOWLEDGE_FLOW_CORPUS,
     MCP_SERVER_KNOWLEDGE_FLOW_FS,
     MCP_SERVER_KNOWLEDGE_FLOW_OPENSEARCH_OPS,
+    MCP_SERVER_KNOWLEDGE_FLOW_PROMETHEUS_OPS,
     MCP_SERVER_KNOWLEDGE_FLOW_TABULAR,
+    MCP_SERVER_KNOWLEDGE_FLOW_TEXT,
     MCPServerRef,
 )
 
@@ -68,7 +70,9 @@ __all__ = [
     "MCP_SERVER_KNOWLEDGE_FLOW_CORPUS",
     "MCP_SERVER_KNOWLEDGE_FLOW_FS",
     "MCP_SERVER_KNOWLEDGE_FLOW_OPENSEARCH_OPS",
+    "MCP_SERVER_KNOWLEDGE_FLOW_PROMETHEUS_OPS",
     "MCP_SERVER_KNOWLEDGE_FLOW_TABULAR",
+    "MCP_SERVER_KNOWLEDGE_FLOW_TEXT",
     "ReActAgent",
     "ToolContext",
     "ToolInvocationError",

{fred_sdk-3.3.4 → fred_sdk-3.3.5}/fred_sdk/contracts/capability/__init__.py

@@ -32,7 +32,7 @@ How to use:
 from __future__ import annotations
 
 from ..models import StoredCapabilityConfig
-from .base import AgentCapability
+from .base import AgentCapability, ToolCarrierMiddleware
 from .chat_controls import (
     ChatControlsRequest,
     ChatControlsRequestItem,
@@ -80,6 +80,7 @@ __all__ = [
     "SidePanelSpec",
     "StoredCapabilityConfig",
     "TeamScopePolicy",
+    "ToolCarrierMiddleware",
     "UploadedFile",
     "chat_part_kind",
 ]

{fred_sdk-3.3.4 → fred_sdk-3.3.5}/fred_sdk/contracts/capability/base.py

@@ -23,7 +23,8 @@ Why this module exists:
 
 How to use:
 - subclass with the three generic parameters and declare `manifest` plus the
-  typed models; only `middleware()` is abstract::
+  typed models; implement `tools()` — the primary, execution-model-agnostic
+  authoring surface every simple capability needs::
 
       class PptFillerCapability(AgentCapability[PptConfig, PptStored, PptTurn]):
           manifest = CapabilityManifest(id="ppt_filler", ...)
@@ -31,7 +32,12 @@ How to use:
           StoredConfigModel = PptStored     # defaults to ConfigModel if omitted
           TurnOptionsModel = PptTurn        # defaults to EmptyModel if omitted
 
-          def middleware(self, ctx): ...
+          def tools(self, ctx): ...
+
+  `middleware()` has a default that wraps `tools()` for `create_agent()`
+  (ReAct); override `middleware()` directly only for ReAct-loop-specific hooks
+  a plain tool cannot express (prompt injection, model-call wrapping — see
+  `McpCapability`).
 
 - installing the package IS the registration: declare a `fred.capabilities`
   entry point pointing at the subclass (RFC §4, §7)
@@ -47,10 +53,11 @@ Contract rules (RFC §3.2, §5.3):
 
 from __future__ import annotations
 
-from abc import ABC, abstractmethod
+from abc import ABC
 from collections.abc import Mapping, Sequence
 from typing import TYPE_CHECKING, Any, ClassVar, Generic, TypeVar, cast
 
+from langchain.agents.middleware import AgentMiddleware
 from pydantic import BaseModel
 
 from .context import CapabilityContext, EmptyModel, SaveContext
@@ -58,7 +65,7 @@ from .hitl import HitlSpec
 from .manifest import CapabilityManifest, ChatControlSpec, UploadedFile
 
 if TYPE_CHECKING:
-    from langchain.agents.middleware import AgentMiddleware
+    from langchain_core.tools import BaseTool
 
 ConfigT = TypeVar("ConfigT", bound=BaseModel)
 StoredT = TypeVar("StoredT", bound=BaseModel)
@@ -168,13 +175,58 @@ class AgentCapability(ABC, Generic[ConfigT, StoredT, TurnOptionsT]):
 
         return None
 
-    @abstractmethod
+    def tools(
+        self, ctx: CapabilityContext[StoredT, TurnOptionsT]
+    ) -> Sequence["BaseTool"]:
+        """
+        The runtime half, execution-model-agnostic (RFC §3.2, §5): the plain
+        LangChain tools this capability's turn exposes, bound to `ctx`. This is
+        the PRIMARY authoring surface — implement this, not `middleware()`,
+        unless the capability needs a ReAct-loop-specific hook `middleware()`
+        offers (prompt injection, model-call wrapping) that a plain tool
+        cannot express.
+
+        Default: no tools.
+        """
+
+        del ctx
+        return ()
+
     def middleware(
         self, ctx: CapabilityContext[StoredT, TurnOptionsT]
     ) -> Sequence["AgentMiddleware"]:
         """
-        The runtime half (RFC §3.2, §5): the LangChain middleware STACK
-        carrying this capability's tools and hooks, bound to the turn's
-        context. Authored list order is preserved within this capability's
-        block (§5.3).
+        The ReAct-loop-only escape hatch (RFC §3.2, §5): the LangChain
+        middleware STACK carrying this capability's tools and hooks, bound to
+        the turn's context. Authored list order is preserved within this
+        capability's block (§5.3). Only `create_agent()` (ReAct) consumes
+        this; Graph agents never see it (Invariant A).
+
+        Default: wraps `tools()` in one generic tool-carrier middleware, which
+        is correct for every capability whose only runtime need is exposing
+        tools. Override directly only for hooks `tools()` cannot express (see
+        `McpCapability.middleware`, a prompt-fragment-only override).
         """
+
+        tools = self.tools(ctx)
+        if not tools:
+            return []
+        return [ToolCarrierMiddleware(tools)]
+
+
+class ToolCarrierMiddleware(AgentMiddleware):
+    """
+    Carries one capability's `tools()` output for `create_agent()` to bind.
+
+    Public (not `_`-prefixed) so the runtime assembly loop
+    (`fred_runtime.capabilities.assembly.build_capability_agent_block`) can
+    build it directly from the SAME `tools(ctx)` call used for
+    `CapabilityAgentBlock.tools`/HITL binding, instead of letting the default
+    `middleware()` above call `tools(ctx)` a second, separate time (CAPAB-02)
+    — one `tools()` call per capability per assembly, one set of tool
+    instances shared by every consumer.
+    """
+
+    def __init__(self, tools: Sequence["BaseTool"]) -> None:
+        super().__init__()
+        self.tools = list(tools)

{fred_sdk-3.3.4 → fred_sdk-3.3.5}/fred_sdk/contracts/capability/manifest.py

@@ -244,6 +244,40 @@ class CapabilityManifest(BaseModel):
     # ever authored; this discriminator exists on `CapabilityCatalogEntry` for
     # that projection and is carried here only so the two models stay aligned.
     kind: Literal["tool", "agent"] = "tool"
+    # Which execution models this capability's runtime actually works under
+    # (CAPAB-02, RFC §3.2/§3.9). Default = both, correct for any capability
+    # whose only runtime need is `tools()` (execution-model-agnostic by
+    # construction). A capability that overrides `middleware()` for a
+    # ReAct-specific hook (dynamic per-turn tools, `before_model` state edits,
+    # prompt injection) WITHOUT also implementing `tools()` MUST declare
+    # `("react",)` explicitly — selecting it on a Graph agent then fails
+    # loudly at assembly instead of silently contributing no tools.
+    execution_models: tuple[Literal["react", "graph"], ...] = ("react", "graph")
+
+    @model_validator(mode="after")
+    def _check_execution_models(self) -> "CapabilityManifest":
+        if not self.execution_models:
+            raise ValueError(
+                f"CapabilityManifest '{self.id}': execution_models must not be empty."
+            )
+        if "react" not in self.execution_models:
+            # No capability runtime need is Graph-only: `tools()` is the only
+            # Graph-visible surface, and it feeds the ReAct binding
+            # identically (via the default middleware() wrap) — there is no
+            # equivalent "ReAct-only escape hatch" mechanism in reverse. A
+            # declaration missing "react" cannot correspond to anything the
+            # runtime can actually build, so it fails at declaration time
+            # rather than silently being ignored (nothing today even reads
+            # this field on the ReAct assembly path, which would otherwise
+            # make ("graph",) a lie the runtime never catches).
+            raise ValueError(
+                f"CapabilityManifest '{self.id}': execution_models must "
+                'include "react" — there is no Graph-only capability shape '
+                "(every Graph-visible tool is also ReAct-visible, since "
+                'tools() feeds both). Use ("react",) or the default '
+                '("react", "graph").'
+            )
+        return self
 
 
 class CapabilityCatalogEntry(BaseModel):
@@ -283,6 +317,10 @@ class CapabilityCatalogEntry(BaseModel):
     # projection of an agent template into this catalog, CAPAB-01 RFC §8.6) —
     # see `CapabilityManifest.kind`.
     kind: Literal["tool", "agent"] = "tool"
+    # See `CapabilityManifest.execution_models` (CAPAB-02). Advertised so a
+    # future catalog/UI filter can hide a ReAct-only capability from a Graph
+    # template's picker instead of only failing loud at selection time.
+    execution_models: tuple[Literal["react", "graph"], ...] = ("react", "graph")
     # Ingress-relative base URL of this capability's auto-mounted router
     # (`{pod_base_url}/capabilities/{id}`), or None when the capability ships
     # no `router` (#1979, RFC §9.1). The template-bound (pre-save) surface
@@ -327,5 +365,6 @@ class CapabilityCatalogEntry(BaseModel):
             assets=[slot.model_copy(deep=True) for slot in manifest.assets],
             team_scope=manifest.team_scope,
             kind=manifest.kind,
+            execution_models=manifest.execution_models,
             route_base_url=route_base_url if manifest.router is not None else None,
         )

{fred_sdk-3.3.4 → fred_sdk-3.3.5}/fred_sdk/contracts/models.py

@@ -98,6 +98,35 @@ class UIHints(BaseModel):
     textarea: bool = False
     group: Optional[str] = None
     hide: bool = False
+    widget: Optional[str] = Field(
+        default=None,
+        description=(
+            "Names a frontend form widget to render this field instead of "
+            "the type-derived default input. Resolved first against the "
+            "owning capability plugin's `configWidgets` (custom widgets, "
+            "AGENT-CAPABILITY-RFC §9 item 4, #1903), then against stock "
+            "widgets — known stock ids: 'document_libraries' "
+            "(library/document tree picker for an array of library tag ids). "
+            "Unknown ids fall back to the default input, so older frontends "
+            "degrade gracefully."
+        ),
+    )
+    visible_when: Optional[str] = Field(
+        default=None,
+        description=(
+            "Key of a sibling field in the same form: this field is only "
+            "shown while that sibling's effective value (current input or its "
+            "declared default) is truthy. Display-only — the value is kept, "
+            "and backends must not rely on the field being hidden."
+        ),
+    )
+    advanced: bool = Field(
+        default=False,
+        description=(
+            "Renders the field inside the form's collapsed 'Advanced "
+            "settings' disclosure instead of the main section. Display-only."
+        ),
+    )
 
 
 class FieldSpec(BaseModel):
@@ -223,7 +252,7 @@ class MCPServerRef(BaseModel):
     """
 
     id: str = Field(..., validation_alias=AliasChoices("id", "name"))
-    require_tools: list[str] = []
+    require_tools: list[str] = Field(default_factory=list)
     locked: bool = Field(
         default=False,
         description=(
@@ -833,7 +862,7 @@ class ReActPolicy(FrozenModel):
     - "Operations copilot": tools + explicit approval on risky actions
     """
 
-    system_prompt_template: str | None = Field(
+    system_prompt_template: str = Field(
         ...,
         min_length=1,
         description=(

{fred_sdk-3.3.4 → fred_sdk-3.3.5}/fred_sdk/contracts/runtime.py

@@ -192,6 +192,7 @@ class ToolResultRuntimeEvent(RuntimeEventBase):
     is_error: bool = False
     sources: tuple[VectorSearchHit, ...] = ()
     ui_parts: tuple[UiPart, ...] = ()
+    latency_ms: int | None = None
 
 
 class HumanChoiceOption(FrozenModel):
@@ -617,6 +618,7 @@ class DocumentSearchPort(ABC):
         library_tag_ids: Sequence[str] | None = None,
         document_uids: Sequence[str] | None = None,
         search_policy: str | None = None,
+        attachments_only: bool = False,
     ) -> DocumentSearchResult:
         """
         Run one scoped vector search and return typed hits.
@@ -624,7 +626,191 @@ class DocumentSearchPort(ABC):
         `library_tag_ids` / `document_uids` are the capability's already-narrowed
         scope (None = "no capability-side narrowing at this level"); the adapter
         further bounds them by the session binding. `search_policy` overrides the
-        binding's default policy when provided.
+        binding's default policy when provided. `attachments_only=True` restricts
+        the search to the conversation's session-scoped documents (attached
+        files) and excludes the corpus entirely.
+        """
+
+
+class AgentAssetPort(ABC):
+    """
+    Capability-safe storage for one agent instance's configuration assets
+    (#1903, RFC AGENT-CAPABILITY §3.4, §3.8).
+
+    Doctrine: `validate_config` must never persist an asset binary inside the
+    stored config — it stores the bytes through THIS port and keeps only the
+    returned key. The adapter privately binds the acting identity, the team,
+    and the agent instance (the KF path is
+    `teams/{team}/agents/{agent_instance_id}/config/{key}`); a capability only
+    ever names the slot-relative `key`. The per-turn binding and raw access
+    token never enter `CapabilityContext`.
+
+    Reads are team-membership-gated on the KF side, so ANY user chatting with
+    the agent can fetch the asset at tool time; writes require the same team
+    resource-update permission as the team-shared space.
+    """
+
+    @abstractmethod
+    async def store(
+        self,
+        key: str,
+        content: bytes,
+        *,
+        content_type: str | None = None,
+        filename: str | None = None,
+    ) -> str:
+        """Store one asset under `key` and return the stored key."""
+
+    @abstractmethod
+    async def fetch(self, key: str) -> bytes:
+        """Fetch one asset's bytes by `key`; raise if it does not exist."""
+
+    @abstractmethod
+    async def delete(self, key: str) -> None:
+        """Delete one asset by `key` (missing keys are a no-op)."""
+
+
+class DocumentRawContent(FrozenModel):
+    """Original uploaded bytes of one corpus document (#1903 image support)."""
+
+    content: bytes
+    content_type: str = "application/octet-stream"
+    filename: str = ""
+
+
+class DocumentContentPort(ABC):
+    """
+    Capability-safe fetch of a corpus document's ORIGINAL bytes by uid
+    (#1903, PPT-filler image support; RFC AGENT-CAPABILITY §3.8 doctrine).
+
+    Takes only the document uid — auth and identity come from the adapter's
+    privately-captured per-turn binding, never from the caller.
+    """
+
+    @abstractmethod
+    async def fetch_raw(self, document_uid: str) -> DocumentRawContent:
+        """Fetch one document's original bytes; raise on missing/forbidden."""
+
+
+class FolderDocumentEntry(FrozenModel):
+    """One document inside a resolved folder (#1903 image support)."""
+
+    document_uid: str
+    document_name: str
+
+
+class DocumentFolderPort(ABC):
+    """
+    Capability-safe access to author folders (DOCUMENT tags) (#1903, PPT-filler
+    image support).
+
+    The adapter binds the space (team vs personal) privately; the capability
+    passes only the author's folder string (e.g. ``"images/flags"``) or an
+    already-resolved tag id.
+    """
+
+    @abstractmethod
+    async def resolve_folder(self, folder: str) -> str | None:
+        """Resolve one folder string to its DOCUMENT tag id, else None."""
+
+    @abstractmethod
+    async def list_folder_documents(
+        self, folder_tag_id: str
+    ) -> tuple[FolderDocumentEntry, ...]:
+        """List the documents carried by one folder tag (uid + display name)."""
+
+
+class DocumentTreeResult(FrozenModel):
+    """Typed result of one capability-scoped document tree listing."""
+
+    tree: str = ""
+    truncated: bool = False
+
+
+class DocumentSummaryResult(FrozenModel):
+    """Typed result of one on-demand document summarization."""
+
+    document_uid: str
+    summary: str = ""
+    shrunk_for_budget: bool = False
+    keywords: tuple[str, ...] = ()
+
+
+class DocumentPortCallError(Exception):
+    """
+    Typed transport failure raised by document port adapters.
+
+    Why this exists: a failing document tool must surface a clean `is_error`
+    tool result (actionable detail, never a raised exception reaching the
+    runtime's ToolNode) — but the capability must not import the adapter's
+    HTTP stack to introspect the failure. Adapters map their transport errors
+    (timeout, HTTP status) onto this exception; capabilities render it.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        timed_out: bool = False,
+        status_code: int | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.timed_out = timed_out
+        self.status_code = status_code
+
+
+class DocumentTreePort(ABC):
+    """
+    Capability-safe folder/document tree listing over the platform corpus
+    (same doctrine as `DocumentSearchPort`): the port takes SCOPE PARAMETERS
+    only — never a caller-supplied context, identity, or access token. Auth
+    and identity come solely from the adapter's privately-captured per-turn
+    binding, which never enters `CapabilityContext`.
+    """
+
+    @abstractmethod
+    async def tree(
+        self,
+        *,
+        working_directory: str | None = None,
+        library_tag_ids: Sequence[str] | None = None,
+        max_chars: int = 6000,
+    ) -> DocumentTreeResult:
+        """
+        Return the caller's authorized folder/document tree as rendered text.
+
+        `library_tag_ids` is the capability's already-narrowed library scope
+        (None = "no capability-side narrowing"); the adapter further bounds it
+        by the session binding before calling Knowledge Flow, completing
+        `turn_option ⊆ capability_config ⊆ session_binding`. Raises
+        `DocumentPortCallError` on transport failure.
+        """
+
+
+class DocumentSummarizePort(ABC):
+    """
+    Capability-safe on-demand document summarization (same doctrine as
+    `DocumentSearchPort`): scope parameters only, identity stays private to
+    the adapter. No scope narrowing here — the caller already holds a concrete
+    `document_uid` (from a search hit, tree listing, or the conversation's
+    attached-files context) and Knowledge Flow's own per-document ReBAC is the
+    real authorization gate. Document uids are internal working identifiers:
+    tools use them freely, but they are never surfaced to the end user.
+    """
+
+    @abstractmethod
+    async def summarize(
+        self,
+        document_uid: str,
+        *,
+        instruction: str | None = None,
+        max_chars: int = 2000,
+    ) -> DocumentSummaryResult:
+        """
+        Summarize one document by uid, optionally steered by `instruction`,
+        bounded by `max_chars`. Long-running server-side (map-reduce over the
+        whole document); adapters use an extended read timeout. Raises
+        `DocumentPortCallError` on transport failure.
         """
 
 
@@ -660,6 +846,20 @@ class RuntimeServices:
     # `ctx.services.document_search`; the port takes scope parameters only — the
     # per-turn binding and raw access token stay private to the adapter.
     document_search: DocumentSearchPort | None = None
+    # Per-agent-instance config-asset storage (#1903, RFC §3.4/§3.8): the
+    # save-time path stores uploaded asset binaries here (keys only in the
+    # stored config); the turn-time path fetches them back. Same doctrine as
+    # `document_search` — identity/team/instance bind privately in the adapter.
+    agent_assets: AgentAssetPort | None = None
+    # Original-bytes fetch of a corpus document by uid (#1903 image support).
+    document_content: DocumentContentPort | None = None
+    # Author folder string → DOCUMENT tag id resolution (#1903 image support);
+    # used at save/analyze time to validate image folders.
+    document_folders: DocumentFolderPort | None = None
+    # Companion document-access ports (same doctrine and optionality):
+    # scoped folder/document tree listing and on-demand summarization.
+    document_tree: DocumentTreePort | None = None
+    document_summarize: DocumentSummarizePort | None = None
 
 
 InputModelT = TypeVar("InputModelT", bound=BaseModel)

{fred_sdk-3.3.4 → fred_sdk-3.3.5}/fred_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fred-sdk
-Version: 3.3.4
+Version: 3.3.5
 Summary: Authoring SDK for Fred agents — graph, ReAct, and team agent primitives.
 Author-email: Thales <noreply@thalesgroup.com>
 License: Apache-2.0

{fred_sdk-3.3.4 → fred_sdk-3.3.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fred-sdk"
-version = "3.3.4"
+version = "3.3.5"
 description = "Authoring SDK for Fred agents — graph, ReAct, and team agent primitives."
 readme = "README.md"
 requires-python = ">=3.12,<3.13"

{fred_sdk-3.3.4 → fred_sdk-3.3.5}/tests/test_capability_contracts.py

@@ -42,6 +42,7 @@ from fred_sdk.contracts.capability import (
     SidePanelSpec,
     StoredCapabilityConfig,
     TeamScopePolicy,
+    ToolCarrierMiddleware,
     UploadedFile,
     chat_part_kind,
 )
@@ -103,6 +104,24 @@ class _MinimalCapability(AgentCapability[_Config, _Config, EmptyModel]):
         return []
 
 
+class _ToolsOnlyCapability(AgentCapability[_Config, _Config, EmptyModel]):
+    """Implements only `tools()` — relies on the default `middleware()` wrap
+    (CAPAB-02: the primary authoring surface, execution-model-agnostic)."""
+
+    manifest = _manifest(id="tools_only_cap")
+    ConfigModel = _Config
+
+    def tools(self, ctx: CapabilityContext[_Config, EmptyModel]) -> list[Any]:
+        from langchain_core.tools import tool
+
+        @tool
+        def echo(text: str) -> str:
+            """Echo text back."""
+            return text
+
+        return [echo]
+
+
 def _identity() -> CapabilityIdentity:
     return CapabilityIdentity(user_id="user-1", session_id="session-1")
 
@@ -152,6 +171,50 @@ def test_default_chat_controls_and_hitl_specs_are_empty() -> None:
     assert list(cap.hitl_specs()) == []
 
 
+def test_default_tools_is_empty() -> None:
+    # `tools()` is the primary authoring surface (CAPAB-02); a capability that
+    # doesn't implement it (e.g. a middleware()-only, ReAct-specific one) gets
+    # the empty default, never an AttributeError.
+    cap = _FullCapability()
+    ctx = CapabilityContext(
+        identity=_identity(),
+        config=_StoredConfig(),
+        turn_options=_TurnOptions(),
+        services=RuntimeServices(),
+    )
+    assert list(cap.tools(ctx)) == []
+
+
+def test_default_middleware_wraps_tools_in_tool_carrier_middleware() -> None:
+    cap = _ToolsOnlyCapability()
+    ctx = CapabilityContext(
+        identity=_identity(),
+        config=_Config(),
+        turn_options=EmptyModel(),
+        services=RuntimeServices(),
+    )
+    (middleware,) = cap.middleware(ctx)
+    assert isinstance(middleware, ToolCarrierMiddleware)
+    assert [t.name for t in middleware.tools] == ["echo"]
+
+
+def test_default_middleware_is_empty_when_tools_is_empty() -> None:
+    # A capability implementing neither tools() nor middleware() (both base
+    # class defaults) contributes nothing — not a crash.
+    class _BareCapability(AgentCapability[_Config, _Config, EmptyModel]):
+        manifest = _manifest(id="bare_cap")
+        ConfigModel = _Config
+
+    cap = _BareCapability()
+    ctx = CapabilityContext(
+        identity=_identity(),
+        config=_Config(),
+        turn_options=EmptyModel(),
+        services=RuntimeServices(),
+    )
+    assert list(cap.middleware(ctx)) == []
+
+
 def test_empty_model_forbids_fields() -> None:
     with pytest.raises(ValidationError):
         EmptyModel.model_validate({"unexpected": 1})
@@ -271,6 +334,34 @@ def test_manifest_defaults() -> None:
     assert manifest.state_models == []
     assert manifest.router is None
     assert manifest.team_scope is TeamScopePolicy.ADMIN_GATED
+    assert manifest.execution_models == ("react", "graph")
+
+
+def test_manifest_execution_models_can_be_declared_react_only() -> None:
+    # CAPAB-02: a middleware()-only capability (a ReAct-specific hook tools()
+    # cannot express) must declare this explicitly — the default claims both.
+    manifest = _manifest(execution_models=("react",))
+    assert manifest.execution_models == ("react",)
+
+
+def test_manifest_rejects_empty_execution_models() -> None:
+    with pytest.raises(ValidationError):
+        _manifest(execution_models=())
+
+
+def test_manifest_rejects_execution_models_without_react() -> None:
+    # No capability runtime need is Graph-only: tools() is the only
+    # Graph-visible surface and it feeds the ReAct binding identically —
+    # there is no equivalent "ReAct-only" mechanism in reverse.
+    with pytest.raises(ValidationError, match="react"):
+        _manifest(execution_models=("graph",))
+
+
+def test_catalog_entry_carries_execution_models() -> None:
+    manifest = _manifest(execution_models=("react",))
+    entry = CapabilityCatalogEntry.from_manifest(manifest)
+    assert entry.execution_models == ("react",)
+    assert CapabilityCatalogEntry.model_validate_json(entry.model_dump_json()) == entry
 
 
 def test_manifest_rejects_blank_id() -> None:

{fred_sdk-3.3.4 → fred_sdk-3.3.5}/tests/test_document_search_port_1906.py

@@ -54,6 +54,7 @@ class _FakePort(DocumentSearchPort):
         library_tag_ids=None,
         document_uids=None,
         search_policy=None,
+        attachments_only: bool = False,
     ) -> DocumentSearchResult:
         self.calls.append(
             {
@@ -62,6 +63,7 @@ class _FakePort(DocumentSearchPort):
                 "library_tag_ids": library_tag_ids,
                 "document_uids": document_uids,
                 "search_policy": search_policy,
+                "attachments_only": attachments_only,
             }
         )
         return DocumentSearchResult(hits=(_hit("d1"),))