remdb 0.3.202__py3-none-any.whl → 0.3.245__py3-none-any.whl

rem/agentic/README.md

@@ -716,11 +716,45 @@ curl -X POST http://localhost:8000/api/v1/chat/completions \
 
 See `rem/api/README.md` for full SSE event protocol documentation.
 
+## Multi-Agent Orchestration
+
+Agents can delegate work to other agents via the `ask_agent` tool. This enables orchestrator patterns where a parent agent routes to specialists.
+
+### How It Works
+
+1. **Parent agent** calls `ask_agent(agent_name, input_text)`
+2. **Child agent** executes and streams its response
+3. **Child events** bubble up to parent via an event sink (asyncio.Queue in ContextVar)
+4. **All tool calls** are saved to the database for the session
+
+### Key Components
+
+| Component | Location | Purpose |
+|-----------|----------|---------|
+| `ask_agent` tool | `mcp_router/tools.py` | Loads child agent, runs with streaming, pushes events to sink |
+| Event sink | `context.py` | ContextVar holding asyncio.Queue for child→parent event flow |
+| Streaming controller | `streaming.py` | Drains event sink, emits SSE events, saves to DB |
+
+### Event Types
+
+Child agents emit events that the parent streams to the client:
+
+- **`child_tool_start`**: Child is calling a tool (logged, streamed, saved to DB)
+- **`child_content`**: Child's text response (streamed as SSE content delta)
+- **`child_tool_result`**: Tool completed with result (metadata extraction)
+
+### Testing
+
+Integration tests in `tests/integration/test_ask_agent_streaming.py` verify:
+- Child content streams correctly to client
+- Tool calls are persisted to database
+- Multi-turn conversations save all messages
+
 ## Future Work
 
 - [ ] Phoenix evaluator integration
 - [ ] Agent schema registry (load schemas by URI)
 - [ ] Schema validation and versioning
-- [ ] Multi-turn conversation management
-- [ ] Agent composition (agents calling agents)
+- [x] Multi-turn conversation management
+- [x] Agent composition (agents calling agents)
 - [ ] Alternative provider implementations (if needed)

rem/agentic/context.py

@@ -16,6 +16,7 @@ Headers Mapping:
     X-Agent-Schema   → context.agent_schema_uri (default: "rem")
     X-Model-Name     → context.default_model
     X-Is-Eval        → context.is_eval (marks session as evaluation)
+    X-Client-Id      → context.client_id (e.g., "web", "mobile", "cli")
 
 Key Design Pattern:
 - AgentContext is passed to agent factory, not stored in agents
@@ -30,9 +31,10 @@ Multi-Agent Context Propagation:
 - Child agents inherit user_id, tenant_id, session_id, is_eval from parent
 """
 
+import asyncio
 from contextlib import contextmanager
 from contextvars import ContextVar
-from typing import Generator
+from typing import Any, Generator
 
 from loguru import logger
 from pydantic import BaseModel, Field
@@ -46,6 +48,13 @@ _current_agent_context: ContextVar["AgentContext | None"] = ContextVar(
     "current_agent_context", default=None
 )
 
+# Event sink for streaming child agent events to parent
+# When set, child agents (via ask_agent) should push their events here
+# for the parent's streaming loop to proxy to the client
+_parent_event_sink: ContextVar["asyncio.Queue | None"] = ContextVar(
+    "parent_event_sink", default=None
+)
+
 
 def get_current_context() -> "AgentContext | None":
     """
@@ -97,6 +106,70 @@ def agent_context_scope(ctx: "AgentContext") -> Generator["AgentContext", None,
         _current_agent_context.set(previous)
 
 
+# =============================================================================
+# Event Sink for Streaming Multi-Agent Delegation
+# =============================================================================
+
+
+def get_event_sink() -> "asyncio.Queue | None":
+    """
+    Get the parent's event sink for streaming child events.
+
+    Used by ask_agent to push child agent events to the parent's stream.
+    Returns None if not in a streaming context.
+    """
+    return _parent_event_sink.get()
+
+
+def set_event_sink(sink: "asyncio.Queue | None") -> None:
+    """Set the event sink for child agents to push events to."""
+    _parent_event_sink.set(sink)
+
+
+@contextmanager
+def event_sink_scope(sink: "asyncio.Queue") -> Generator["asyncio.Queue", None, None]:
+    """
+    Context manager for scoped event sink setting.
+
+    Used by streaming layer to set up event proxying before tool execution.
+    Child agents (via ask_agent) will push their events to this sink.
+
+    Example:
+        event_queue = asyncio.Queue()
+        with event_sink_scope(event_queue):
+            # ask_agent will push child events to event_queue
+            async for event in tools_stream:
+                ...
+            # Also consume from event_queue
+    """
+    previous = _parent_event_sink.get()
+    _parent_event_sink.set(sink)
+    try:
+        yield sink
+    finally:
+        _parent_event_sink.set(previous)
+
+
+async def push_event(event: Any) -> bool:
+    """
+    Push an event to the parent's event sink (if available).
+
+    Used by ask_agent to proxy child agent events to the parent's stream.
+    Returns True if event was pushed, False if no sink available.
+
+    Args:
+        event: Any streaming event (ToolCallEvent, content chunk, etc.)
+
+    Returns:
+        True if event was pushed to sink, False otherwise
+    """
+    sink = _parent_event_sink.get()
+    if sink is not None:
+        await sink.put(event)
+        return True
+    return False
+
+
 class AgentContext(BaseModel):
     """
     Session and configuration context for agent execution.
@@ -150,6 +223,11 @@ class AgentContext(BaseModel):
         description="Whether this is an evaluation session (set via X-Is-Eval header)",
     )
 
+    client_id: str | None = Field(
+        default=None,
+        description="Client identifier (e.g., 'web', 'mobile', 'cli') set via X-Client-Id header",
+    )
+
     model_config = {"populate_by_name": True}
 
     def child_context(
@@ -160,7 +238,7 @@ class AgentContext(BaseModel):
         """
         Create a child context for nested agent calls.
 
-        Inherits user_id, tenant_id, session_id, is_eval from parent.
+        Inherits user_id, tenant_id, session_id, is_eval, client_id from parent.
         Allows overriding agent_schema_uri and default_model for the child.
 
         Args:
@@ -184,6 +262,7 @@ class AgentContext(BaseModel):
             default_model=model_override or self.default_model,
             agent_schema_uri=agent_schema_uri or self.agent_schema_uri,
             is_eval=self.is_eval,
+            client_id=self.client_id,
         )
 
     @staticmethod
@@ -302,6 +381,7 @@ class AgentContext(BaseModel):
             default_model=normalized.get("x-model-name") or settings.llm.default_model,
             agent_schema_uri=normalized.get("x-agent-schema"),
             is_eval=is_eval,
+            client_id=normalized.get("x-client-id"),
         )
 
     @classmethod
@@ -319,6 +399,7 @@ class AgentContext(BaseModel):
         - X-Model-Name: Model override
         - X-Agent-Schema: Agent schema URI
         - X-Is-Eval: Whether this is an evaluation session (true/false)
+        - X-Client-Id: Client identifier (e.g., "web", "mobile", "cli")
 
         Args:
             headers: Dictionary of HTTP headers (case-insensitive)
@@ -332,7 +413,8 @@ class AgentContext(BaseModel):
                 "X-Tenant-Id": "acme-corp",
                 "X-Session-Id": "sess-456",
                 "X-Model-Name": "anthropic:claude-opus-4-20250514",
-                "X-Is-Eval": "true"
+                "X-Is-Eval": "true",
+                "X-Client-Id": "web"
             }
             context = AgentContext.from_headers(headers)
         """
@@ -350,4 +432,5 @@ class AgentContext(BaseModel):
             default_model=normalized.get("x-model-name") or settings.llm.default_model,
             agent_schema_uri=normalized.get("x-agent-schema"),
             is_eval=is_eval,
+            client_id=normalized.get("x-client-id"),
         )

rem/agentic/context_builder.py

@@ -4,15 +4,12 @@ Centralized context builder for agent execution.
 Session History (ALWAYS loaded with compression):
 - Each chat request is a single message, so session history MUST be recovered
 - Uses SessionMessageStore with compression to keep context efficient
-- Long assistant responses include REM LOOKUP hints: "... [REM LOOKUP session-{id}-msg-{index}] ..."
-- Agent can retrieve full content on-demand using REM LOOKUP
 - Prevents context window bloat while maintaining conversation continuity
 
 User Context (on-demand by default):
-- System message includes REM LOOKUP hint for user profile
-- Agent decides whether to load profile based on query
-- More efficient for queries that don't need personalization
-- Example: "User: sarah@example.com. To load user profile: Use REM LOOKUP \"sarah@example.com\""
+- System message includes user email for context awareness
+- Fails silently if user not found - agent proceeds without user context
+- Example: "User: sarah@example.com"
 
 User Context (auto-inject when enabled):
 - Set CHAT__AUTO_INJECT_USER_CONTEXT=true
@@ -22,8 +19,8 @@ User Context (auto-inject when enabled):
 Design Pattern:
 1. Extract AgentContext from headers (user_id, tenant_id, session_id)
 2. If auto-inject enabled: Load User/Session from database
-3. If auto-inject disabled: Provide REM LOOKUP hints in system message
-4. Construct system message with date + context (injected or hints)
+3. If auto-inject disabled: Show user email for context (fail silently if not found)
+4. Construct system message with date + context
 5. Return complete context ready for agent execution
 
 Integration Points:
@@ -40,11 +37,10 @@ Usage (on-demand, default):
 
     # Messages list structure (on-demand):
     # [
-    #   {"role": "system", "content": "Today's date: 2025-11-22\nUser: sarah@example.com\nTo load user profile: Use REM LOOKUP \"sarah@example.com\"\nSession ID: sess-123\nTo load session history: Use REM LOOKUP messages?session_id=sess-123"},
+    #   {"role": "system", "content": "Today's date: 2025-11-22\n\nUser: sarah@example.com"},
     #   {"role": "user", "content": "What's next for the API migration?"}
     # ]
 
-    # Agent receives hints and can decide to load context if needed
     agent = await create_agent(context=context, ...)
     prompt = "\n".join(msg.content for msg in messages)
     result = await agent.run(prompt)
@@ -52,7 +48,7 @@ Usage (on-demand, default):
 Usage (auto-inject, CHAT__AUTO_INJECT_USER_CONTEXT=true):
     # Messages list structure (auto-inject):
     # [
-    #   {"role": "system", "content": "Today's date: 2025-11-22\n\nUser Context (auto-injected):\nSummary: ...\nInterests: ...\n\nSession History (auto-injected, 5 messages):"},
+    #   {"role": "system", "content": "Today's date: 2025-11-22\n\nUser Context (auto-injected):\nSummary: ...\nInterests: ..."},
     #   {"role": "user", "content": "Previous message"},
     #   {"role": "assistant", "content": "Previous response"},
     #   {"role": "user", "content": "What's next for the API migration?"}
@@ -110,13 +106,11 @@ class ContextBuilder:
 
         Session History (ALWAYS loaded with compression):
         - If session_id provided, session history is ALWAYS loaded using SessionMessageStore
-        - Compression keeps it efficient with REM LOOKUP hints for long messages
-        - Example: "... [Message truncated - REM LOOKUP session-{id}-msg-{index}] ..."
-        - Agent can retrieve full content on-demand using REM LOOKUP
+        - Compression keeps context efficient
 
         User Context (on-demand by default):
-        - System message includes REM LOOKUP hint: "User: {email}. To load user profile: Use REM LOOKUP \"{email}\""
-        - Agent decides whether to load profile based on query
+        - System message includes user email: "User: {email}"
+        - Fails silently if user not found - agent proceeds without user context
 
         User Context (auto-inject when enabled):
         - Set CHAT__AUTO_INJECT_USER_CONTEXT=true
@@ -137,9 +131,9 @@ class ContextBuilder:
 
             # messages structure:
             # [
-            #   {"role": "system", "content": "Today's date: 2025-11-22\nUser: sarah@example.com\nTo load user profile: Use REM LOOKUP \"sarah@example.com\""},
+            #   {"role": "system", "content": "Today's date: 2025-11-22\n\nUser: sarah@example.com"},
             #   {"role": "user", "content": "Previous message"},
-            #   {"role": "assistant", "content": "Start of long response... [REM LOOKUP session-123-msg-1] ...end"},
+            #   {"role": "assistant", "content": "Previous response"},
             #   {"role": "user", "content": "New message"}
             # ]
         """
@@ -158,6 +152,7 @@ class ContextBuilder:
                 default_model=context.default_model,
                 agent_schema_uri=context.agent_schema_uri,
                 is_eval=context.is_eval,
+                client_id=context.client_id,
             )
 
         # Initialize DB if not provided and needed (for user context or session history)
@@ -177,6 +172,10 @@ class ContextBuilder:
             today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
             context_hint = f"Today's date: {today}."
 
+            # Add client identifier if present
+            if context.client_id:
+                context_hint += f"\nClient: {context.client_id}"
+
             # Add user context (auto-inject or on-demand hint)
             if settings.chat.auto_inject_user_context and context.user_id and db:
                 # Auto-inject: Load and include user profile
@@ -189,18 +188,18 @@ class ContextBuilder:
                     context_hint += f"\n\nUser Context (auto-injected):\n{user_context_content}"
                 else:
                     context_hint += "\n\nNo user context available (anonymous or new user)."
-            elif context.user_id:
-                # On-demand: Provide hint to use REM LOOKUP
-                # user_id is UUID5 hash of email - load user to get email for display and LOOKUP
-                user_repo = Repository(User, "users", db=db)
-                user = await user_repo.get_by_id(context.user_id, context.tenant_id)
-                if user and user.email:
-                    # Show email (more useful than UUID) and LOOKUP hint
-                    context_hint += f"\n\nUser: {user.email}"
-                    context_hint += f"\nTo load user profile: Use REM LOOKUP \"{user.email}\""
-                else:
-                    context_hint += f"\n\nUser ID: {context.user_id}"
-                    context_hint += "\nUser profile not available."
+            elif context.user_id and db:
+                # On-demand: Show user email for context (no REM LOOKUP - it requires exact user_id match)
+                # Fail silently if user lookup fails - just proceed without user context
+                try:
+                    user_repo = Repository(User, "users", db=db)
+                    user = await user_repo.get_by_id(context.user_id, context.tenant_id)
+                    if user and user.email:
+                        context_hint += f"\n\nUser: {user.email}"
+                    # If user not found, just proceed without adding user context
+                except Exception as e:
+                    # Fail silently - don't block agent execution if user lookup fails
+                    logger.debug(f"Could not load user context: {e}")
 
             # Add system context hint
             messages.append(ContextMessage(role="system", content=context_hint))
@@ -318,6 +317,7 @@ class ContextBuilder:
         session_id: str | None = None,
         message: str = "Hello",
         model: str | None = None,
+        client_id: str | None = None,
     ) -> tuple[AgentContext, list[ContextMessage]]:
         """
         Build context for testing (no database lookup).
@@ -325,7 +325,7 @@ class ContextBuilder:
         Creates minimal context with:
         - Test user (test@rem.ai)
         - Test tenant
-        - Context hint with date
+        - Context hint with date and client
         - Single user message
 
         Args:
@@ -334,6 +334,7 @@ class ContextBuilder:
             session_id: Optional session ID
             message: User message content
             model: Optional model override
+            client_id: Optional client identifier (e.g., "cli", "test")
 
         Returns:
             Tuple of (AgentContext, messages list)
@@ -341,7 +342,8 @@ class ContextBuilder:
         Example:
             context, messages = await ContextBuilder.build_from_test(
                 user_id="test@rem.ai",
-                message="What's the weather like?"
+                message="What's the weather like?",
+                client_id="cli"
             )
         """
         from ..settings import settings
@@ -352,11 +354,15 @@ class ContextBuilder:
             tenant_id=tenant_id,
             session_id=session_id,
             default_model=model or settings.llm.default_model,
+            client_id=client_id,
         )
 
         # Build minimal messages
         today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
-        context_hint = f"Today's date: {today}.\n\nTest user context: {user_id} (test mode, no profile loaded)."
+        context_hint = f"Today's date: {today}."
+        if client_id:
+            context_hint += f"\nClient: {client_id}"
+        context_hint += f"\n\nTest user context: {user_id} (test mode, no profile loaded)."
 
         messages = [
             ContextMessage(role="system", content=context_hint),

rem/agentic/mcp/tool_wrapper.py

@@ -116,7 +116,7 @@ def create_resource_tool(uri: str, usage: str = "", mcp_server: Any = None) -> T
     the artificial MCP distinction between tools and resources.
 
     Supports both:
-    - Concrete URIs: "rem://schemas" -> tool with no parameters
+    - Concrete URIs: "rem://agents" -> tool with no parameters
     - Template URIs: "patient-profile://field/{field_key}" -> tool with field_key parameter
 
     Args:
@@ -131,7 +131,7 @@ def create_resource_tool(uri: str, usage: str = "", mcp_server: Any = None) -> T
 
     Example:
         # Concrete URI -> no-param tool
-        tool = create_resource_tool("rem://schemas", "List all agent schemas")
+        tool = create_resource_tool("rem://agents", "List all agent schemas")
 
         # Template URI -> parameterized tool
         tool = create_resource_tool("patient-profile://field/{field_key}", "Get field definition", mcp_server=mcp)

rem/agentic/providers/pydantic_ai.py

@@ -357,6 +357,9 @@ def _convert_properties_to_prompt(properties: dict[str, Any]) -> str:
     definition into natural language guidance that informs the agent
     about the expected response structure without forcing JSON output.
 
+    IMPORTANT: The 'answer' field is the OUTPUT to the user. All other
+    fields are INTERNAL tracking that should NOT appear in the output.
+
     Args:
         properties: JSON Schema properties dict
 
@@ -368,45 +371,59 @@ def _convert_properties_to_prompt(properties: dict[str, Any]) -> str:
             "answer": {"type": "string", "description": "The answer"},
             "confidence": {"type": "number", "description": "Confidence 0-1"}
         }
-        # Returns:
-        # "## Response Structure\n\nYour response should include:\n- **answer**: The answer\n..."
+        # Returns guidance that only answer should be output
     """
     if not properties:
         return ""
 
-    lines = ["## Response Guidelines", "", "Your response should address the following elements:"]
-
-    for field_name, field_def in properties.items():
-        field_type = field_def.get("type", "any")
-        description = field_def.get("description", "")
-
-        # Format based on type
-        if field_type == "array":
-            type_hint = "list"
-        elif field_type == "number":
-            type_hint = "number"
-            # Include min/max if specified
-            if "minimum" in field_def or "maximum" in field_def:
-                min_val = field_def.get("minimum", "")
-                max_val = field_def.get("maximum", "")
-                if min_val != "" and max_val != "":
-                    type_hint = f"number ({min_val}-{max_val})"
-        elif field_type == "boolean":
-            type_hint = "yes/no"
-        else:
-            type_hint = field_type
+    # Separate answer (output) from other fields (internal tracking)
+    answer_field = properties.get("answer")
+    internal_fields = {k: v for k, v in properties.items() if k != "answer"}
+
+    lines = ["## Internal Thinking Structure (DO NOT output these labels)"]
+    lines.append("")
+    lines.append("Use this structure to organize your thinking, but ONLY output the answer content:")
+    lines.append("")
+
+    # If there's an answer field, emphasize it's the ONLY output
+    if answer_field:
+        answer_desc = answer_field.get("description", "Your response")
+        lines.append(f"**OUTPUT (what the user sees):** {answer_desc}")
+        lines.append("")
+
+    # Document internal fields for tracking/thinking
+    if internal_fields:
+        lines.append("**INTERNAL (for your tracking only - do NOT include in output):**")
+        for field_name, field_def in internal_fields.items():
+            field_type = field_def.get("type", "any")
+            description = field_def.get("description", "")
+
+            # Format based on type
+            if field_type == "array":
+                type_hint = "list"
+            elif field_type == "number":
+                type_hint = "number"
+                if "minimum" in field_def or "maximum" in field_def:
+                    min_val = field_def.get("minimum", "")
+                    max_val = field_def.get("maximum", "")
+                    if min_val != "" and max_val != "":
+                        type_hint = f"number ({min_val}-{max_val})"
+            elif field_type == "boolean":
+                type_hint = "yes/no"
+            else:
+                type_hint = field_type
 
-        # Build field description
-        field_line = f"- **{field_name}**"
-        if type_hint and type_hint != "string":
-            field_line += f" ({type_hint})"
-        if description:
-            field_line += f": {description}"
+            field_line = f"- {field_name}"
+            if type_hint and type_hint != "string":
+                field_line += f" ({type_hint})"
+            if description:
+                field_line += f": {description}"
 
-        lines.append(field_line)
+            lines.append(field_line)
 
     lines.append("")
-    lines.append("Respond naturally in prose, addressing these elements where relevant.")
+    lines.append("⚠️ CRITICAL: Your response must be ONLY the conversational answer text.")
+    lines.append("Do NOT output field names like 'answer:' or 'diverge_output:' - just the response itself.")
 
     return "\n".join(lines)
 
@@ -664,26 +681,26 @@ async def create_agent(
 
         set_agent_resource_attributes(agent_schema=agent_schema)
 
-    # Extract schema metadata for search_rem tool description suffix
-    # This allows entity schemas to add context-specific notes to the search_rem tool
-    search_rem_suffix = None
-    if metadata:
-        # Check for default_search_table in metadata (set by entity schemas)
-        extra = agent_schema.get("json_schema_extra", {}) if agent_schema else {}
-        default_table = extra.get("default_search_table")
-        has_embeddings = extra.get("has_embeddings", False)
-
-        if default_table:
-            # Build description suffix for search_rem
-            search_rem_suffix = f"\n\nFor this schema, use `search_rem` to query `{default_table}`. "
-            if has_embeddings:
-                search_rem_suffix += f"SEARCH works well on {default_table} (has embeddings). "
-            search_rem_suffix += f"Example: `SEARCH \"your query\" FROM {default_table} LIMIT 10`"
-
     # Add tools from MCP server (in-process, no subprocess)
     # Track loaded MCP servers for resource resolution
     loaded_mcp_server = None
 
+    # Build map of tool_name → schema description from agent schema tools section
+    # This allows agent-specific tool guidance to override/augment MCP tool descriptions
+    schema_tool_descriptions: dict[str, str] = {}
+    tool_configs = metadata.tools if metadata and hasattr(metadata, 'tools') else []
+    for tool_config in tool_configs:
+        if hasattr(tool_config, 'name'):
+            t_name = tool_config.name
+            t_desc = tool_config.description or ""
+        else:
+            t_name = tool_config.get("name", "")
+            t_desc = tool_config.get("description", "")
+        # Skip resource URIs (handled separately below)
+        if t_name and "://" not in t_name and t_desc:
+            schema_tool_descriptions[t_name] = t_desc
+            logger.debug(f"Schema tool description for '{t_name}': {len(t_desc)} chars")
+
     for server_config in mcp_server_configs:
         server_type = server_config.get("type")
         server_id = server_config.get("id", "mcp-server")
@@ -708,8 +725,8 @@ async def create_agent(
                 mcp_tools_dict = await mcp_server.get_tools()
 
                 for tool_name, tool_func in mcp_tools_dict.items():
-                    # Add description suffix to search_rem tool if schema specifies a default table
-                    tool_suffix = search_rem_suffix if tool_name == "search_rem" else None
+                    # Get schema description suffix if agent schema defines one for this tool
+                    tool_suffix = schema_tool_descriptions.get(tool_name)
 
                     wrapped_tool = create_mcp_tool_wrapper(
                         tool_name,
@@ -718,7 +735,7 @@ async def create_agent(
                         description_suffix=tool_suffix,
                     )
                     tools.append(wrapped_tool)
-                    logger.debug(f"Loaded MCP tool: {tool_name}" + (" (with schema suffix)" if tool_suffix else ""))
+                    logger.debug(f"Loaded MCP tool: {tool_name}" + (" (with schema desc)" if tool_suffix else ""))
 
                 logger.info(f"Loaded {len(mcp_tools_dict)} tools from MCP server: {server_id} (in-process)")
 
@@ -732,7 +749,7 @@ async def create_agent(
     # the artificial MCP distinction between tools and resources
     #
     # Supports both concrete and template URIs:
-    # - Concrete: "rem://schemas" -> no-param tool
+    # - Concrete: "rem://agents" -> no-param tool
     # - Template: "patient-profile://field/{field_key}" -> tool with field_key param
     from ..mcp.tool_wrapper import create_resource_tool
 

rem/agentic/schema.py

@@ -79,7 +79,7 @@ class MCPResourceReference(BaseModel):
 
     Example (exact URI):
         {
-            "uri": "rem://schemas",
+            "uri": "rem://agents",
             "name": "Agent Schemas",
             "description": "List all available agent schemas"
         }
@@ -96,7 +96,7 @@ class MCPResourceReference(BaseModel):
         default=None,
         description=(
             "Exact resource URI or URI with query parameters. "
-            "Examples: 'rem://schemas', 'rem://resources?category=drug.*'"
+            "Examples: 'rem://agents', 'rem://resources?category=drug.*'"
         )
     )