agentic-fabriq-sdk 0.1.17__tar.gz → 0.1.19__tar.gz

{agentic_fabriq_sdk-0.1.17 → agentic_fabriq_sdk-0.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-fabriq-sdk
-Version: 0.1.17
+Version: 0.1.19
 Summary: Agentic Fabriq SDK: high-level client, CLI tool, DX helpers, and auth for AI agents
 License: Apache-2.0
 Keywords: fabriq,agentic-fabriq,sdk,ai,agents,agentic,fabric,cli
@@ -17,7 +17,7 @@ Classifier: Typing :: Typed
 Requires-Dist: PyJWT (>=2.8.0)
 Requires-Dist: PyYAML (>=6.0.0)
 Requires-Dist: aiohttp (>=3.9.0)
-Requires-Dist: click (>=8.0.0)
+Requires-Dist: click (>=8.1.0)
 Requires-Dist: cryptography (>=41.0.0)
 Requires-Dist: httpx (>=0.25.0)
 Requires-Dist: keyring (>=25.0.0)
@@ -27,7 +27,7 @@ Requires-Dist: opentelemetry-instrumentation-httpx (>=0.41b0)
 Requires-Dist: pydantic (>=2.4.0)
 Requires-Dist: rich (>=13.7.0)
 Requires-Dist: stevedore (>=5.1.0)
-Requires-Dist: typer[all] (>=0.12.0)
+Requires-Dist: typer[all] (>=0.20.0)
 Requires-Dist: typing-extensions (>=4.0.0)
 Project-URL: Documentation, https://docs.agentic-fabric.org
 Project-URL: Homepage, https://github.com/agentic-fabric/agentic-fabric

{agentic_fabriq_sdk-0.1.17 → agentic_fabriq_sdk-0.1.19}/af_cli/commands/tools.py

@@ -121,17 +121,20 @@ def get(
 
 @app.command()
 def invoke(
-    tool_identifier: str = typer.Argument(..., help="Tool name (e.g., 'slack') or UUID"),
+    connection_id: str = typer.Argument(..., help="Connection ID (e.g., 'slacker', 'gurt')"),
     method: str = typer.Option(..., "--method", help="Tool method to invoke"),
     params: str = typer.Option(None, "--params", help="JSON string of method parameters (e.g., '{\"channel\": \"test\", \"text\": \"Hello\"}')"),
     format: str = typer.Option("json", "--format", help="Output format (json, table, yaml)"),
 ):
-    """Invoke a tool by name or UUID.
+    """Invoke a tool using its connection ID.
+    
+    The connection ID identifies which specific tool connection to use.
+    Run 'afctl tools list' to see your connection IDs.
     
     Examples:
-        afctl tools invoke slack --method get_channels
-        afctl tools invoke slack --method post_message --params '{"channel": "test", "text": "Hello!"}'
-        afctl tools invoke c17b55af-18f8-49be-b9e9-44b1d1be429e --method get_channels
+        afctl tools invoke slacker --method get_channels
+        afctl tools invoke slacker --method post_message --params '{"channel": "test", "text": "Hello!"}'
+        afctl tools invoke gurt --method list_files
     """
     try:
         # Parse parameters if provided
@@ -145,59 +148,29 @@ def invoke(
                 raise typer.Exit(1)
         
         with get_client() as client:
-            # Try to resolve tool name to UUID if not already a UUID
-            tool_id = tool_identifier
-            try:
-                from uuid import UUID
-                UUID(tool_identifier)
-                # It's already a UUID, use it directly
-            except ValueError:
-                # Not a UUID, try to look up by name
-                info(f"Looking up tool '{tool_identifier}'...")
-                try:
-                    tools_response = client.get("/api/v1/tools")
-                    
-                    # Handle different response formats
-                    if isinstance(tools_response, dict) and "tools" in tools_response:
-                        tools = tools_response["tools"]
-                    elif isinstance(tools_response, dict) and "items" in tools_response:
-                        tools = tools_response["items"]
-                    elif hasattr(tools_response, '__iter__') and not isinstance(tools_response, (str, dict)):
-                        tools = list(tools_response)
-                    else:
-                        tools = []
-                    
-                    # Find tool by name (case-insensitive)
-                    matching_tools = [t for t in tools if isinstance(t, dict) and t.get("name", "").lower() == tool_identifier.lower()]
-                    
-                    if not matching_tools:
-                        error(f"Tool '{tool_identifier}' not found. Available tools:")
-                        for t in tools:
-                            if isinstance(t, dict):
-                                print(f"  - {t.get('name')} (ID: {t.get('id')})")
-                        raise typer.Exit(1)
-                    
-                    if len(matching_tools) > 1:
-                        error(f"Multiple tools found with name '{tool_identifier}':")
-                        for t in matching_tools:
-                            print(f"  - {t.get('name')} (ID: {t.get('id')})")
-                        error("Please use the UUID instead.")
-                        raise typer.Exit(1)
-                    
-                    tool_id = matching_tools[0].get("id")
-                    info(f"Resolved '{tool_identifier}' to tool ID: {tool_id}")
-                except Exception as lookup_error:
-                    error(f"Failed to look up tool: {lookup_error}")
-                    raise typer.Exit(1)
+            info(f"Invoking connection '{connection_id}' with method '{method}'...")
             
+            # Verify connection exists
+            connections = client.get("/api/v1/user-connections")
+            connection = next((c for c in connections if c.get("connection_id") == connection_id), None)
+            
+            if not connection:
+                error(f"Connection '{connection_id}' not found")
+                info("Available connections:")
+                for conn in connections:
+                    info(f"  - {conn.get('connection_id')} ({conn.get('tool')})")
+                raise typer.Exit(1)
+            
+            tool_name = connection.get("tool")
+            debug(f"Connection '{connection_id}' uses tool '{tool_name}'")
+            
+            # Use the connection-based invoke endpoint (auto-creates tool if needed)
             data = {
                 "method": method,
                 "parameters": parameters,
-                "context": {},
             }
             
-            info(f"Invoking tool {tool_identifier} method {method}...")
-            response = client.post(f"/api/v1/tools/{tool_id}/invoke", data)
+            response = client.post(f"/api/v1/tools/connections/{connection_id}/invoke", data)
             
             success("Tool invoked successfully")
             
@@ -349,8 +322,11 @@ def add(
                     if redirect_uri:
                         config_payload["redirect_uri"] = redirect_uri
                     
+                    # For Google tools, pass tool_type parameter to prevent duplicates
+                    tool_type_param = f"&tool_type={tool}" if api_tool_name == "google" else ""
+                    
                     client.post(
-                        f"/api/v1/tools/{api_tool_name}/config?connection_id={connection_id}",
+                        f"/api/v1/tools/{api_tool_name}/config?connection_id={connection_id}{tool_type_param}",
                         data=config_payload
                     )
                     success("✅ OAuth app credentials stored")
@@ -523,9 +499,15 @@ def disconnect(
                     info("Cancelled")
                     return
             
+            # Determine the API base tool name (Google tools all use "google")
+            api_tool_name = "google" if (tool.startswith("google_") or tool == "gmail") else tool
+            
+            # For Google tools, pass tool_type parameter
+            tool_type_param = f"&tool_type={tool}" if api_tool_name == "google" else ""
+            
             # Delete connection credentials
             client.delete(
-                f"/api/v1/tools/{tool}/connection?connection_id={connection_id}"
+                f"/api/v1/tools/{api_tool_name}/connection?connection_id={connection_id}{tool_type_param}"
             )
             
             success(f"✅ Disconnected: {connection_id}")

{agentic_fabriq_sdk-0.1.17 → agentic_fabriq_sdk-0.1.19}/af_cli/core/client.py

@@ -86,6 +86,35 @@ class AFClient:
         
         return self._handle_response(response)
     
+    def try_post(self, path: str, data: Optional[Dict] = None) -> tuple[bool, int, Optional[Dict[str, Any]]]:
+        """Make POST request without exiting on error. Returns (success, status_code, response_data)."""
+        url = urljoin(self.config.gateway_url, path)
+        debug(f"POST {url}")
+        
+        try:
+            response = self.client.post(
+                path,
+                json=data,
+                headers=self._get_headers(),
+            )
+            
+            debug(f"Response: {response.status_code} {response.url}")
+            
+            if response.status_code >= 400:
+                try:
+                    error_data = response.json()
+                    return False, response.status_code, error_data
+                except:
+                    return False, response.status_code, {"detail": response.text}
+            
+            try:
+                return True, response.status_code, response.json()
+            except:
+                return True, response.status_code, {"message": "Success"}
+                
+        except Exception as e:
+            return False, 0, {"detail": str(e)}
+    
     def put(self, path: str, data: Optional[Dict] = None) -> Dict[str, Any]:
         """Make PUT request."""
         url = urljoin(self.config.gateway_url, path)

{agentic_fabriq_sdk-0.1.17 → agentic_fabriq_sdk-0.1.19}/af_cli/main.py

@@ -9,7 +9,6 @@ import typer
 from rich.console import Console
 from rich.table import Table
 
-from af_cli.commands.agents import app as agents_app
 from af_cli.commands.applications import app as applications_app
 from af_cli.commands.auth import app as auth_app
 from af_cli.commands.config import app as config_app
@@ -30,7 +29,6 @@ console = Console()
 # Add subcommands
 app.add_typer(auth_app, name="auth", help="Authentication commands")
 app.add_typer(config_app, name="config", help="Configuration commands")
-app.add_typer(agents_app, name="agents", help="Agent management commands")
 app.add_typer(tools_app, name="tools", help="Tool management commands")
 app.add_typer(applications_app, name="applications", help="Application management commands")
 app.add_typer(mcp_servers_app, name="mcp-servers", help="MCP server management commands")

{agentic_fabriq_sdk-0.1.17 → agentic_fabriq_sdk-0.1.19}/af_sdk/__init__.py

@@ -15,8 +15,6 @@ from .exceptions import (
     ValidationError,
 )
 from .models.types import (
-    AgentInvokeRequest,
-    AgentInvokeResult,
     ToolInvokeRequest,
     ToolInvokeResult,
 )
@@ -45,8 +43,6 @@ __all__ = [
     "ConnectorError",
     "NotFoundError",
     "ValidationError",
-    "AgentInvokeRequest",
-    "AgentInvokeResult",
     "ToolInvokeRequest",
     "ToolInvokeResult",
     "HTTPClient",

agentic_fabriq_sdk-0.1.19/af_sdk/dx/__init__.py

@@ -0,0 +1,10 @@
+from .decorators import tool
+from .runtime import ToolFabric, MCPServer
+
+__all__ = [
+  "tool",
+  "ToolFabric",
+  "MCPServer",
+]
+
+

agentic_fabriq_sdk-0.1.19/af_sdk/dx/runtime.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+import os
+import httpx
+
+
+def _base_headers(token: str, tenant_id: Optional[str]) -> Dict[str, str]:
+    headers = {"Authorization": f"Bearer {token}"}
+    if tenant_id:
+        headers["X-Tenant-Id"] = tenant_id
+    # Dev helper: allow overriding scopes from env for local testing
+    debug_scopes = os.getenv("FABRIQ_DEBUG_SCOPES")
+    if debug_scopes is not None:
+        headers["X-Debug-Scopes"] = debug_scopes
+    return headers
+
+
+class ToolFabric:
+    """Thin facade over Fabriq provider proxy endpoints (e.g., Slack).
+
+    This class lets developers think in terms of a "fabric" of tools provided
+    by a vendor, while under the hood we call the Gateway proxy endpoints.
+    """
+
+    def __init__(self, *, provider: str, base_url: str, access_token: str, tenant_id: Optional[str] = None):
+        self.provider = provider
+        self.base_url = base_url.rstrip("/")
+        self.token = access_token
+        self.tenant_id = tenant_id
+
+    def get_tools(self, names: List[str]) -> List[str]:
+        # Placeholder: simply returns opaque method identifiers as strings the Agent understands
+        return [f"{self.provider}:{name}" for name in names]
+
+    def invoke(self, action: str, params: Dict[str, Any]) -> Dict[str, Any]:
+        url = f"{self.base_url}/api/v1/proxy/{self.provider}/{action}"
+        with httpx.Client(timeout=30.0) as c:
+            r = c.post(url, json=params, headers=_base_headers(self.token, self.tenant_id))
+            r.raise_for_status()
+            return r.json()
+
+
+class MCPServer:
+    """Facade for an MCP server registered in Fabriq (proxy layer)."""
+
+    def __init__(self, *, server_id: str, base_url: str, access_token: str, tenant_id: Optional[str] = None):
+        self.server_id = server_id
+        self.base_url = base_url.rstrip("/")
+        self.token = access_token
+        self.tenant_id = tenant_id
+
+    def get_tools(self, names: List[str]) -> List[str]:
+        return [f"mcp:{self.server_id}:{name}" for name in names]
+
+    def invoke(self, tool: str, args: Dict[str, Any]) -> Dict[str, Any]:
+        url = f"{self.base_url}/api/v1/proxy/mcp/{self.server_id}/invoke"
+        payload = {"payload": {"tool": tool, "args": args}}
+        with httpx.Client(timeout=60.0) as c:
+            r = c.post(url, json=payload, headers=_base_headers(self.token, self.tenant_id))
+            r.raise_for_status()
+            return r.json()
+
+

{agentic_fabriq_sdk-0.1.17 → agentic_fabriq_sdk-0.1.19}/af_sdk/events.py

@@ -35,17 +35,6 @@ class EventMetadata(BaseModel):
     trace_id: Optional[str] = None
 
 
-class AgentEvent(BaseModel):
-    """Agent lifecycle event"""
-    event_type: str  # registered, updated, deleted, invoked
-    agent_id: str
-    agent_name: str
-    agent_type: str
-    tenant_id: str
-    metadata: EventMetadata
-    payload: Dict[str, Any] = Field(default_factory=dict)
-
-
 class ToolEvent(BaseModel):
     """Tool lifecycle event"""
     event_type: str  # registered, updated, deleted, invoked
@@ -81,7 +70,7 @@ class SecretEvent(BaseModel):
     payload: Dict[str, Any] = Field(default_factory=dict)
 
 
-Event = Union[AgentEvent, ToolEvent, InvocationEvent, SecretEvent]
+Event = Union[ToolEvent, InvocationEvent, SecretEvent]
 
 
 class EventStreamConfig(BaseModel):
@@ -127,25 +116,10 @@ class EventPublisher:
         payload: Optional[Dict] = None,
         correlation_id: Optional[str] = None
     ):
-        """Publish agent lifecycle event"""
-        metadata = EventMetadata(
-            source=source,
-            correlation_id=correlation_id,
-            tenant_id=tenant_id
-        )
-        
-        event = AgentEvent(
-            event_type=event_type,
-            agent_id=agent_id,
-            agent_name=agent_name,
-            agent_type=agent_type,
-            tenant_id=tenant_id,
-            metadata=metadata,
-            payload=payload or {}
-        )
-        
-        subject = f"agents.{event_type}.{tenant_id}"
-        await self._publish_event(subject, event)
+        """Publish agent lifecycle event - DEPRECATED"""
+        # Agent events have been removed from the SDK
+        # This method is kept for backward compatibility but does nothing
+        pass
         
     async def publish_tool_event(
         self,
@@ -284,19 +258,15 @@ class EventSubscriber:
         
     async def subscribe_to_agent_events(
         self,
-        handler: Callable[[AgentEvent], Awaitable[None]],
+        handler: Callable,
         tenant_id: Optional[str] = None,
         event_type: Optional[str] = None,
         consumer_name: str = "agent-events-consumer"
     ):
-        """Subscribe to agent events"""
-        subject = "agents.*"
-        if tenant_id:
-            subject += f".{tenant_id}"
-        if event_type:
-            subject = f"agents.{event_type}.*"
-            
-        await self._subscribe(subject, handler, consumer_name, AgentEvent)
+        """Subscribe to agent events - DEPRECATED"""
+        # Agent events have been removed from the SDK
+        # This method is kept for backward compatibility but does nothing
+        pass
         
     async def subscribe_to_tool_events(
         self,
@@ -641,16 +611,10 @@ async def publish_agent_registered(
     tenant_id: str,
     payload: Optional[Dict] = None
 ):
-    """Convenience function to publish agent registered event"""
-    await publisher.publish_agent_event(
-        event_type="registered",
-        agent_id=agent_id,
-        agent_name=agent_name,
-        agent_type=agent_type,
-        tenant_id=tenant_id,
-        source="af_gateway",
-        payload=payload
-    )
+    """Convenience function to publish agent registered event - DEPRECATED"""
+    # Agent events have been removed from the SDK
+    # This function is kept for backward compatibility but does nothing
+    pass
 
 
 async def publish_invocation_started(

{agentic_fabriq_sdk-0.1.17 → agentic_fabriq_sdk-0.1.19}/af_sdk/fabriq_client.py

@@ -85,6 +85,7 @@ class FabriqClient:
         method: str,
         parameters: Optional[Dict[str, Any]] = None,
         context: Optional[Dict[str, Any]] = None,
+        connection_id: Optional[str] = None,
     ) -> Dict[str, Any]:
         """Invoke a tool by name or UUID.
         
@@ -93,6 +94,7 @@ class FabriqClient:
             method: Method name to invoke
             parameters: Method parameters
             context: Additional context
+            connection_id: Specific connection ID to use (for multi-connection tools)
             
         Returns:
             Tool invocation result
@@ -101,6 +103,8 @@ class FabriqClient:
             result = await client.invoke_tool("slack", method="get_channels")
             result = await client.invoke_tool("slack", method="post_message", 
                                              parameters={"channel": "test", "text": "Hello!"})
+            result = await client.invoke_tool("slack", method="get_channels",
+                                             connection_id="slacker")
         """
         # Try to resolve tool name to UUID if not already a UUID
         tool_id = tool_identifier
@@ -142,10 +146,70 @@ class FabriqClient:
         body = {"method": method}
         if parameters is not None:
             body["parameters"] = parameters
-        if context is not None:
-            body["context"] = context
+        
+        # Add connection_id to context if provided
+        if context is not None or connection_id is not None:
+            ctx = (context or {}).copy()
+            if connection_id is not None:
+                ctx["connection_id"] = connection_id
+            body["context"] = ctx
+        
         r = await self._http.post(f"/tools/{tool_id}/invoke", json=body, headers=self._extra_headers)
         return r.json()
+    
+    async def invoke_connection(
+        self,
+        connection_id: str,
+        *,
+        method: str,
+        parameters: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Invoke a tool using its connection ID (preferred method).
+        
+        This uses the connection_id (like 'slacker', 'gurt') to automatically
+        find and invoke the correct tool with the right credentials.
+        
+        Args:
+            connection_id: Connection identifier (e.g., 'slacker', 'gurt')
+            method: Method name to invoke
+            parameters: Method parameters
+            
+        Returns:
+            Tool invocation result
+            
+        Examples:
+            result = await client.invoke_connection("slacker", method="get_channels")
+            result = await client.invoke_connection("slacker", method="post_message",
+                                                   parameters={"channel": "test", "text": "Hello!"})
+            result = await client.invoke_connection("gurt", method="list_files")
+        """
+        # This uses the tool invocation with connection_id in context
+        # which is supported by current production servers
+        body = {
+            "method": method,
+            "parameters": parameters or {},
+            "context": {"connection_id": connection_id}
+        }
+        
+        # First, get the connection to find the tool name
+        connections_resp = await self._http.get("/user-connections", headers=self._extra_headers)
+        connections = connections_resp.json()
+        
+        connection = next((c for c in connections if c.get("connection_id") == connection_id), None)
+        if not connection:
+            raise ValueError(f"Connection '{connection_id}' not found")
+        
+        tool_name = connection.get("tool")
+        
+        # Look up the tool by name to get its UUID
+        result = await self.invoke_tool(
+            tool_name,
+            method=method,
+            parameters=parameters,
+            connection_id=connection_id
+        )
+        
+        return result
 
     # -----------------
     # MCP Servers
@@ -184,18 +248,6 @@ class FabriqClient:
         r = await self._http.post(f"/proxy/mcp/{server_id}/invoke", json={"payload": payload, "raw": raw}, headers=self._extra_headers)
         return r.json()
 
-    # -----------------
-    # Agents
-    # -----------------
-    async def list_agents(self, *, page: int = 1, page_size: int = 20, sort_by: str = "name", sort_order: str = "asc") -> Dict[str, Any]:
-        params: Dict[str, Any] = {"page": page, "page_size": page_size, "sort_by": sort_by, "sort_order": sort_order}
-        r = await self._http.get("/agents", params=params, headers=self._extra_headers)
-        return r.json()
-
-    async def invoke_agent(self, *, agent_id: str, params: Dict[str, Any], raw: bool = False) -> Dict[str, Any]:
-        r = await self._http.post(f"/proxy/agents/{agent_id}/invoke", json={"params": params, "raw": raw}, headers=self._extra_headers)
-        return r.json()
-
     # -----------------
     # Secrets (Gateway-backed Vault)
     # -----------------

{agentic_fabriq_sdk-0.1.17 → agentic_fabriq_sdk-0.1.19}/af_sdk/models/__init__.py

@@ -3,10 +3,6 @@ Data models for Agentic Fabric SDK.
 """
 
 from .types import (
-    Agent,
-    AgentCreate,
-    AgentInvokeRequest,
-    AgentInvokeResult,
     ErrorResponse,
     HealthResponse,
     McpServer,
@@ -25,10 +21,6 @@ from .types import (
 )
 
 __all__ = [
-    "Agent",
-    "AgentCreate",
-    "AgentInvokeRequest",
-    "AgentInvokeResult",
     "Tool",
     "ToolInvokeRequest",
     "ToolInvokeResult",

{agentic_fabriq_sdk-0.1.17 → agentic_fabriq_sdk-0.1.19}/af_sdk/models/types.py

@@ -9,56 +9,6 @@ from uuid import UUID
 from pydantic import BaseModel, Field
 
 
-class Agent(BaseModel):
-    """Agent model."""
-
-    id: str
-    name: str
-    description: Optional[str] = None
-    owner: str
-    tenant_id: str
-    group_path: Optional[str] = None
-    endpoint_url: Optional[str] = None
-    auth_type: Optional[str] = None
-    scopes: List[str] = Field(default_factory=list)
-    metadata: Dict[str, Any] = Field(default_factory=dict)
-    created_at: datetime
-    updated_at: datetime
-
-
-class AgentCreate(BaseModel):
-    """Request model for creating an agent."""
-
-    id: str
-    name: str
-    description: Optional[str] = None
-    endpoint_url: Optional[str] = None
-    auth_type: Optional[str] = None
-    scopes: List[str] = Field(default_factory=list)
-    metadata: Dict[str, Any] = Field(default_factory=dict)
-    group_path: Optional[str] = None
-
-
-class AgentInvokeRequest(BaseModel):
-    """Request model for invoking an agent."""
-
-    input: str
-    params: Dict[str, Any] = Field(default_factory=dict)
-    max_tokens: Optional[int] = None
-    temperature: Optional[float] = None
-    stream: bool = False
-
-
-class AgentInvokeResult(BaseModel):
-    """Result model for agent invocation."""
-
-    output: str
-    logs: List[str] = Field(default_factory=list)
-    usage: Optional[Dict[str, Any]] = None
-    metadata: Dict[str, Any] = Field(default_factory=dict)
-    status: str = "success"
-
-
 class Tool(BaseModel):
     """Tool model."""
 

{agentic_fabriq_sdk-0.1.17 → agentic_fabriq_sdk-0.1.19}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "agentic-fabriq-sdk"
-version = "0.1.17"
+version = "0.1.19"
 description = "Agentic Fabriq SDK: high-level client, CLI tool, DX helpers, and auth for AI agents"
 readme = "README.md"
 license = "Apache-2.0"
@@ -43,11 +43,11 @@ aiohttp = ">=3.9.0"
 # Plugin/extension system
 stevedore = ">=5.1.0"
 # CLI dependencies
-typer = {extras = ["all"], version = ">=0.12.0"}
+typer = {extras = ["all"], version = ">=0.20.0"}
 rich = ">=13.7.0"
 keyring = ">=25.0.0"
 cryptography = ">=41.0.0"
-click = ">=8.0.0"
+click = ">=8.1.0"
 PyYAML = ">=6.0.0"
 
 [tool.poetry.scripts]