remdb 0.3.118__py3-none-any.whl → 0.3.141__py3-none-any.whl

rem/agentic/agents/sse_simulator.py

@@ -265,6 +265,8 @@ async def stream_simulator_events(
             message_id=message_id,
             in_reply_to=in_reply_to,
             session_id=session_id,
+            # Session info
+            session_name="SSE Demo Session",
             # Quality indicators
             confidence=0.95,
             sources=["rem/api/routers/chat/sse_events.py", "rem/agentic/agents/sse_simulator.py"],

rem/agentic/context.py

@@ -2,10 +2,18 @@
 Agent execution context and configuration.
 
 Design pattern for session context that can be constructed from:
-- HTTP headers (X-User-Id, X-Session-Id, X-Model-Name)
+- HTTP headers (X-User-Id, X-Session-Id, X-Model-Name, X-Is-Eval, etc.)
 - Direct instantiation for testing/CLI
 
-Key Design Pattern 
+Headers Mapping:
+    X-User-Id        → context.user_id
+    X-Tenant-Id      → context.tenant_id (default: "default")
+    X-Session-Id     → context.session_id
+    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)
+
+Key Design Pattern:
 - AgentContext is passed to agent factory, not stored in agents
 - Enables session tracking across API, CLI, and test execution
 - Supports header-based configuration override (model, schema URI)
@@ -66,6 +74,11 @@ class AgentContext(BaseModel):
         description="Agent schema URI (e.g., 'rem-agents-query-agent')",
     )
 
+    is_eval: bool = Field(
+        default=False,
+        description="Whether this is an evaluation session (set via X-Is-Eval header)",
+    )
+
     model_config = {"populate_by_name": True}
 
     @staticmethod
@@ -126,6 +139,7 @@ class AgentContext(BaseModel):
         - X-Session-Id: Session identifier
         - X-Model-Name: Model override
         - X-Agent-Schema: Agent schema URI
+        - X-Is-Eval: Whether this is an evaluation session (true/false)
 
         Args:
             headers: Dictionary of HTTP headers (case-insensitive)
@@ -138,17 +152,23 @@ class AgentContext(BaseModel):
                 "X-User-Id": "user123",
                 "X-Tenant-Id": "acme-corp",
                 "X-Session-Id": "sess-456",
-                "X-Model-Name": "anthropic:claude-opus-4-20250514"
+                "X-Model-Name": "anthropic:claude-opus-4-20250514",
+                "X-Is-Eval": "true"
             }
             context = AgentContext.from_headers(headers)
         """
         # Normalize header keys to lowercase for case-insensitive lookup
         normalized = {k.lower(): v for k, v in headers.items()}
 
+        # Parse X-Is-Eval header (accepts "true", "1", "yes" as truthy)
+        is_eval_str = normalized.get("x-is-eval", "").lower()
+        is_eval = is_eval_str in ("true", "1", "yes")
+
         return cls(
             user_id=normalized.get("x-user-id"),
             tenant_id=normalized.get("x-tenant-id", "default"),
             session_id=normalized.get("x-session-id"),
             default_model=normalized.get("x-model-name") or settings.llm.default_model,
             agent_schema_uri=normalized.get("x-agent-schema"),
+            is_eval=is_eval,
         )

rem/agentic/mcp/tool_wrapper.py

@@ -107,27 +107,138 @@ def create_mcp_tool_wrapper(
         return Tool(tool_func)
 
 
-def create_resource_tool(uri: str, usage: str) -> Tool:
+def create_resource_tool(uri: str, usage: str = "", mcp_server: Any = None) -> Tool:
     """
     Build a Tool instance from an MCP resource URI.
 
-    This is a placeholder for now. A real implementation would create a
-    tool that reads the content of the resource URI.
+    Creates a tool that fetches the resource content when called.
+    Resources declared in agent YAML become callable tools - this eliminates
+    the artificial MCP distinction between tools and resources.
+
+    Supports both:
+    - Concrete URIs: "rem://schemas" -> tool with no parameters
+    - Template URIs: "patient-profile://field/{field_key}" -> tool with field_key parameter
 
     Args:
-        uri: The resource URI (e.g., "rem://resources/some-id").
-        usage: The description of how to use the tool.
+        uri: The resource URI (concrete or template with {variable} placeholders).
+        usage: The description of what this resource provides.
+        mcp_server: Optional FastMCP server instance to resolve resources from.
+            If provided, resources are resolved from this server's registry.
+            If not provided, falls back to REM's built-in load_resource().
 
     Returns:
-        A Pydantic AI Tool instance.
-    """
-    # Placeholder function that would read the resource
-    def read_resource():
-        """Reads content from a resource URI."""
-        return f"Content of {uri}"
+        A Pydantic AI Tool instance that fetches the resource.
 
-    read_resource.__name__ = f"read_{uri.replace('://', '_').replace('/', '_')}"
-    read_resource.__doc__ = usage
+    Example:
+        # Concrete URI -> no-param tool
+        tool = create_resource_tool("rem://schemas", "List all agent schemas")
 
-    logger.info(f"Built resource tool: {read_resource.__name__} (uri: {uri})")
-    return Tool(read_resource)
+        # Template URI -> parameterized tool
+        tool = create_resource_tool("patient-profile://field/{field_key}", "Get field definition", mcp_server=mcp)
+        # Agent calls: get_patient_profile_field(field_key="safety.suicidality")
+    """
+    import json
+    import re
+
+    # Extract template variables from URI (e.g., {field_key}, {domain_name})
+    template_vars = re.findall(r'\{([^}]+)\}', uri)
+
+    # Parse URI to create function name (strip template vars for cleaner name)
+    clean_uri = re.sub(r'\{[^}]+\}', '', uri)
+    parts = clean_uri.replace("://", "_").replace("-", "_").replace("/", "_").replace(".", "_")
+    parts = re.sub(r'_+', '_', parts).strip('_')  # Clean up multiple underscores
+    func_name = f"get_{parts}"
+
+    # Build description including parameter info
+    description = usage or f"Fetch {uri} resource"
+    if template_vars:
+        param_desc = ", ".join(template_vars)
+        description = f"{description}\n\nParameters: {param_desc}"
+
+    if template_vars:
+        # Template URI -> create parameterized tool
+        async def wrapper(**kwargs: Any) -> str:
+            """Fetch MCP resource with substituted parameters."""
+            import asyncio
+            import inspect
+
+            # Try to resolve from MCP server's resource templates first
+            if mcp_server is not None:
+                try:
+                    # Get resource templates from MCP server
+                    templates = await mcp_server.get_resource_templates()
+                    if uri in templates:
+                        template = templates[uri]
+                        # Call the template's underlying function directly
+                        # The fn expects the template variables as kwargs
+                        fn_result = template.fn(**kwargs)
+                        # Handle both sync and async functions
+                        if inspect.iscoroutine(fn_result):
+                            fn_result = await fn_result
+                        if isinstance(fn_result, str):
+                            return fn_result
+                        return json.dumps(fn_result, indent=2)
+                except Exception as e:
+                    logger.warning(f"Failed to resolve resource {uri} from MCP server: {e}")
+
+            # Fallback: substitute template variables and use load_resource
+            resolved_uri = uri
+            for var in template_vars:
+                if var in kwargs:
+                    resolved_uri = resolved_uri.replace(f"{{{var}}}", str(kwargs[var]))
+                else:
+                    return json.dumps({"error": f"Missing required parameter: {var}"})
+
+            from rem.api.mcp_router.resources import load_resource
+            result = await load_resource(resolved_uri)
+            if isinstance(result, str):
+                return result
+            return json.dumps(result, indent=2)
+
+        # Build parameter annotations for Pydantic AI
+        wrapper.__name__ = func_name
+        wrapper.__doc__ = description
+        # Add type hints for parameters
+        wrapper.__annotations__ = {var: str for var in template_vars}
+        wrapper.__annotations__['return'] = str
+
+        logger.info(f"Built parameterized resource tool: {func_name} (uri: {uri}, params: {template_vars})")
+    else:
+        # Concrete URI -> no-param tool
+        async def wrapper(**kwargs: Any) -> str:
+            """Fetch MCP resource and return contents."""
+            import asyncio
+            import inspect
+
+            if kwargs:
+                logger.warning(f"Resource tool {func_name} called with unexpected kwargs: {list(kwargs.keys())}")
+
+            # Try to resolve from MCP server's resources first
+            if mcp_server is not None:
+                try:
+                    resources = await mcp_server.get_resources()
+                    if uri in resources:
+                        resource = resources[uri]
+                        # Call the resource's underlying function
+                        fn_result = resource.fn()
+                        if inspect.iscoroutine(fn_result):
+                            fn_result = await fn_result
+                        if isinstance(fn_result, str):
+                            return fn_result
+                        return json.dumps(fn_result, indent=2)
+                except Exception as e:
+                    logger.warning(f"Failed to resolve resource {uri} from MCP server: {e}")
+
+            # Fallback to load_resource
+            from rem.api.mcp_router.resources import load_resource
+            result = await load_resource(uri)
+            if isinstance(result, str):
+                return result
+            return json.dumps(result, indent=2)
+
+        wrapper.__name__ = func_name
+        wrapper.__doc__ = description
+
+        logger.info(f"Built resource tool: {func_name} (uri: {uri})")
+
+    return Tool(wrapper)

rem/agentic/otel/setup.py

@@ -158,6 +158,7 @@ def setup_instrumentation() -> None:
             base_exporter = GRPCExporter(
                 endpoint=settings.otel.collector_endpoint,
                 timeout=settings.otel.export_timeout,
+                insecure=settings.otel.insecure,
             )
         else:  # http
             base_exporter = HTTPExporter(