agentic-fabriq-sdk 0.1.17__py3-none-any.whl → 0.1.19__py3-none-any.whl

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}")

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)

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")

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",

af_sdk/dx/__init__.py

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

af_sdk/dx/runtime.py

@@ -62,109 +62,3 @@ class MCPServer:
             return r.json()
 
 
-class AgentFabric:
-    """Future-facing A2A discovery placeholder.
-
-    Today it simply stores identifiers of other agents by id.
-    """
-
-    def __init__(self, *, base_url: str, access_token: str, tenant_id: Optional[str] = None):
-        self.base_url = base_url.rstrip("/")
-        self.token = access_token
-        self.tenant_id = tenant_id
-
-    def get_agents(self, ids: List[str]) -> List[str]:
-        return ids
-
-    def invoke_agent(self, agent_id: str, input: Dict[str, Any]) -> Dict[str, Any]:
-        url = f"{self.base_url}/api/v1/agents/{agent_id}/invoke"
-        with httpx.Client(timeout=60.0) as c:
-            r = c.post(url, json={"input": input, "context": {}}, headers=_base_headers(self.token, self.tenant_id))
-            r.raise_for_status()
-            return r.json()
-
-
-class Agent:
-    """Minimal orchestrator that can call tools and agents.
-
-    tools: a mixed list of
-      - wrapped local functions decorated with @tool (call directly), or
-      - string references produced by ToolFabric/MCPServer (we route accordingly).
-    agents: a list of agent ids discoverable via AgentFabric.get_agents().
-    """
-
-    def __init__(
-        self,
-        *,
-        system_prompt: str,
-        tools: List[Any],
-        agents: List[str],
-        base_url: str,
-        access_token: str,
-        tenant_id: Optional[str] = None,
-        provider_fabrics: Optional[Dict[str, ToolFabric]] = None,
-        mcp_servers: Optional[Dict[str, MCPServer]] = None,
-        agent_fabric: Optional[AgentFabric] = None,
-    ) -> None:
-        self.system_prompt = system_prompt
-        self.tools = tools
-        self.agents = agents
-        self.base_url = base_url.rstrip("/")
-        self.token = access_token
-        self.tenant_id = tenant_id
-        self.provider_fabrics = provider_fabrics or {}
-        self.mcp_servers = mcp_servers or {}
-        self.agent_fabric = agent_fabric or AgentFabric(base_url=base_url, access_token=access_token, tenant_id=tenant_id)
-
-    def _is_wrapped_tool(self, obj: Any) -> bool:
-        return hasattr(obj, "_af_tool")
-
-    def run(self, instruction: str) -> str:
-        # Super-minimal router: if instruction mentions "slack" and "summary",
-        # fetch recent messages via a slack ToolFabric and send to a summarizer agent.
-        inst = instruction.lower()
-        if "slack" in inst and "summary" in inst:
-            slack: Optional[ToolFabric] = self.provider_fabrics.get("slack")
-            if not slack:
-                return "No slack ToolFabric configured."
-            # Find a channel id (prefer env, else pick first from channels.list)
-            channel_id = os.getenv("SLACK_DEFAULT_CHANNEL")
-            if not channel_id:
-                try:
-                    ch_resp = slack.invoke("channels.list", {})
-                    channels = (ch_resp.get("channels") or ch_resp.get("items") or [])
-                    if channels:
-                        channel_id = channels[0].get("id")
-                except Exception:
-                    channel_id = None
-            if not channel_id:
-                return "Could not determine a Slack channel id; set SLACK_DEFAULT_CHANNEL or ensure channels.list works."
-
-            # Fetch messages
-            hist = slack.invoke("conversations.history", {"channel": channel_id, "limit": 50})
-            # Gateway proxy normalizes to { items: [...] }, but also returns provider-shape under raw
-            messages = hist.get("items") or hist.get("messages") or []
-            if not messages:
-                return "No Slack messages available or Slack is not connected. Connect Slack in the UI (Tools tab) for the active tenant or set SLACK_DEFAULT_CHANNEL."
-            lines = [m.get("text", "").strip() for m in messages if m.get("text")]
-            corpus = "\n".join(lines)
-            # Call first collaborator agent named 'summarizer' if present
-            target = next((a for a in self.agents if a == "summarizer"), None)
-            if not target:
-                return "No summarizer agent configured."
-            result = self.agent_fabric.invoke_agent(target, {"text": corpus})
-            # result shape: { output, metadata, logs, status }
-            return result.get("output") or str(result)
-
-        # Fallback: try local tools if any
-        for t in self.tools:
-            if self._is_wrapped_tool(t):
-                try:
-                    out = t(instruction)  # type: ignore[misc]
-                    if isinstance(out, str) and out:
-                        return out
-                except Exception:
-                    pass
-        return "No handler matched the instruction."
-
-

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(

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)
     # -----------------

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",

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.dist-info → agentic_fabriq_sdk-0.1.19.dist-info}/METADATA

@@ -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.dist-info → agentic_fabriq_sdk-0.1.19.dist-info}/RECORD

@@ -1,22 +1,20 @@
 af_cli/__init__.py,sha256=F2T4x4H3VIdmTjHRyV5DkaRvbZcdHYzAWD2hxtTplE4,188
 af_cli/commands/__init__.py,sha256=Qngm2Yks6oTKazlxCZA_tIAHXwHoU6Oc7Pw5BGkA7W4,49
-af_cli/commands/agents.py,sha256=XkXL0eB6miWteK-EUet-kkEqVib3L4USncMrJmmnFjY,8325
 af_cli/commands/applications.py,sha256=o6P-rJHO3tdqOQTBksntlVO7Y6hoDSPQp_9nB1azwzc,11958
 af_cli/commands/auth.py,sha256=gz7DLiTTV0nv2DnKaa7_9nLHevCWslG54rRKRA1alx0,11967
 af_cli/commands/config.py,sha256=_k4ixGZfa7Yl_yUL-W1jeMQzykFcPcbw20Yr1v6_ShM,2748
 af_cli/commands/mcp_servers.py,sha256=1hEb4tX80dYb-j_2Z3gDud_v1FcMxl83syJ2N2eLWzI,2390
 af_cli/commands/secrets.py,sha256=z_rHfn8-KEonTC5dioBgH7sc1ppMOltFVFz-58Nqwa0,3436
-af_cli/commands/tools.py,sha256=CUbqxl1UGdoOzz6h-Gp5mrXFeq7CQ7GQDUXathzQIWQ,25428
+af_cli/commands/tools.py,sha256=2D8b6WwgKflk6JOoRxi-1j9k08mwLNeKlaUU8eOqPxs,24525
 af_cli/core/__init__.py,sha256=cQ0H7rGfaMISQPhoNe4Xfu_EKU2TqRVt2OMI7tPea5U,51
-af_cli/core/client.py,sha256=BELf6889BOzOWP6kCk4hSY4DolIATB0YNpui38l7EaI,3939
+af_cli/core/client.py,sha256=AYNWdCMNtDx7LOGXwoS7_rruss479T0lD6PZ1hG5dMA,5082
 af_cli/core/config.py,sha256=fwLUF0blNII2RKdFlJ3Hat51vwwNyxpIkU_HvViz8To,8538
 af_cli/core/oauth.py,sha256=sCzo97TZyx8sLmo0GYv53P3zoABK6htRCivHhRpPRdI,18162
 af_cli/core/output.py,sha256=tL5z7M-tLu2M1Yl8O4M7OPP7iQivC1b_YUUB468Od5Y,4811
 af_cli/core/token_storage.py,sha256=WhOQLx5_9pn2lAlFX01Y5DmWO7B9BJYfEkASCsBQwaI,7738
-af_cli/main.py,sha256=mNDMG4K0837I4je2eVB0o_T23PukBjYRRxVGbqIWBPA,5228
-af_sdk/__init__.py,sha256=KHJn2RkgM2W7bKSshPtgAIHWBluoApoDXaLBUjA02dI,1667
+af_cli/main.py,sha256=zFbbUhgmpGRp9VBGOyzSIK4NlguGsBI_SqZchyOu5Xc,5100
+af_sdk/__init__.py,sha256=uKLl3Sqlg_TgmGZtI0Tt14JNXIhdHSb6dplw6acBDvU,1569
 af_sdk/auth/__init__.py,sha256=laIiIwgxy0mEgRoXEakoEs7BuUYnyrlzHJbdf8Sqa5E,1137
-af_sdk/auth/application.py,sha256=kg5wSbhkQj00vje8_f1mgKVD7ax4b8vKAn_npkI9Bms,7451
 af_sdk/auth/applications.py,sha256=tJ4UMvCJF73i55_4uqsBM04GxDHk5X0SQRWdHVJDcNM,7452
 af_sdk/auth/dpop.py,sha256=s0uiyxxuzsVQNtSexji1htJoxrALwlf1P9507xa-M3Y,1285
 af_sdk/auth/oauth.py,sha256=WRTrrBzs9ieiNnWfxagP6Ag4oI9k0soYjEkjfS2y5Lg,8120
@@ -24,20 +22,20 @@ af_sdk/auth/token_cache.py,sha256=X36E6K0lWqMAqlJXC3i343y8oy-uFm1q-FEdVKXdL1Y,11
 af_sdk/connectors/__init__.py,sha256=8SDknAjPH5Swk3fJZRh6Mi19zDZQO7vcej3BzOdHGCc,411
 af_sdk/connectors/base.py,sha256=m3NtB4ozPtfjjs6t91OCLjCsj1xtzyK7jc7ox-HooPg,7319
 af_sdk/connectors/registry.py,sha256=ZH0wYIZBqDnTWJ_IhfwZzifO5r3Rkb0VlEyXDhrGWIY,8799
-af_sdk/dx/__init__.py,sha256=LcvKe05nOXpqmEpRpTuW7KIaWz22b4Y-TG75-9WzL_k,178
+af_sdk/dx/__init__.py,sha256=oiLKoDKu8I62hGj3AKzvZu8WlZbGHb_80qlmxkVWc-k,130
 af_sdk/dx/decorators.py,sha256=o_EmvE_8pp2vTgMJMgfTy5SXG_24yabuKdoytah02Hk,1294
-af_sdk/dx/runtime.py,sha256=4vuPoH-kioTIHxlobrrK1pHvmeFmAIkM7wvKNTJIJ8I,7111
-af_sdk/events.py,sha256=vPlDQHuRQ5eVOchfheAHnKXhoEyJFFqL83_5oliyi3A,23525
+af_sdk/dx/runtime.py,sha256=5oowtdWtTr12odBz6pXKexSVKf2smfQDw71-jBDKr8A,2471
+af_sdk/events.py,sha256=onz1wWwATpm71HFfcEJLhvXBDSmE0M9RC92lMS-Sd3k,22609
 af_sdk/exceptions.py,sha256=ZVjjBeq17CGK69N2OTkVTjPXqXSI_gA7cZk9rCvARcI,4381
-af_sdk/fabriq_client.py,sha256=L836WmMrsQsiOXIrLbCv5EddCrTNsyB0VNc2XEmfJzQ,9678
-af_sdk/models/__init__.py,sha256=_iLKq4SFuxAS-rp1ytq4RN3daAvAUz59wqmfEstwd28,865
+af_sdk/fabriq_client.py,sha256=jYimCc310_1kt3MbFdvHQOH0gja6jh8pniwu17okH4o,11567
+af_sdk/models/__init__.py,sha256=nSjgNEyYILZ6WIQF-oG5IT0CWV7JGuE0xNLw8sHPshM,707
 af_sdk/models/audit.py,sha256=_wRahNV7M7ftc2AHFf7J3WzIJ5cUyZhFn_lZX9NITp8,1476
-af_sdk/models/types.py,sha256=Hiwi97xpfvmE-U78-_ft998iBFi4atu6ceCbJBZ-eF0,6435
+af_sdk/models/types.py,sha256=DPrl7XuFSYRrc8el8OX-ZNcZrIZwl8rTR9cH01uZFaU,5106
 af_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 af_sdk/transport/__init__.py,sha256=HsOc6MmlxIS-PSYC_-6E36-dZYyT_auZeoXvGzVAqeg,104
 af_sdk/transport/http.py,sha256=QB3eqQbwug95QHf5PG_714NKtlTjV9PzVTo8izJCylc,13203
 af_sdk/vault.py,sha256=QVNGigIw8ND5sVXt05gvUY222b5-i9EbzLWNsDGdOU4,17926
-agentic_fabriq_sdk-0.1.17.dist-info/METADATA,sha256=-vUv4DYhFC_MFAabwOnQh3VglGqssolr7rlXLA1f4Hg,3658
-agentic_fabriq_sdk-0.1.17.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-agentic_fabriq_sdk-0.1.17.dist-info/entry_points.txt,sha256=XUO2EaJhUtUS5pwVIkhemC-nEeFbKgXXLW97gQCCGm8,41
-agentic_fabriq_sdk-0.1.17.dist-info/RECORD,,
+agentic_fabriq_sdk-0.1.19.dist-info/METADATA,sha256=pyoPnROyDWvxMf9JbXScRIXSlLGl7xiAQfEtDYeUwTE,3658
+agentic_fabriq_sdk-0.1.19.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+agentic_fabriq_sdk-0.1.19.dist-info/entry_points.txt,sha256=XUO2EaJhUtUS5pwVIkhemC-nEeFbKgXXLW97gQCCGm8,41
+agentic_fabriq_sdk-0.1.19.dist-info/RECORD,,

af_cli/commands/agents.py

@@ -1,238 +0,0 @@
-"""
-Agent management commands for the Agentic Fabric CLI.
-"""
-
-from typing import Optional
-
-import typer
-
-from af_cli.core.client import get_client
-from af_cli.core.output import error, info, print_output, success, warning, prompt_confirm
-
-app = typer.Typer(help="Agent management commands")
-
-
-@app.command()
-def list(
-    page: int = typer.Option(1, "--page", help="Page number"),
-    page_size: int = typer.Option(20, "--page-size", help="Page size"),
-    search: Optional[str] = typer.Option(None, "--search", help="Search query"),
-    format: str = typer.Option("table", "--format", help="Output format"),
-):
-    """List agents."""
-    try:
-        with get_client() as client:
-            params = {
-                "page": page,
-                "page_size": page_size,
-            }
-            
-            if search:
-                params["search"] = search
-            
-            response = client.get("/api/v1/agents", params=params)
-
-            # Support both new (items/total) and legacy (agents/total) shapes
-            if isinstance(response, dict):
-                if "items" in response:
-                    agents = response.get("items", [])
-                    total = response.get("total", len(agents))
-                elif "agents" in response:
-                    agents = response.get("agents", [])
-                    total = response.get("total", len(agents))
-                else:
-                    agents = []
-                    total = 0
-            elif isinstance(response, list):
-                agents = response
-                total = len(agents)
-            else:
-                agents = []
-                total = 0
-            
-            if not agents:
-                warning("No agents found")
-                return
-            
-            # Format agent data for display
-            display_data = []
-            for agent in agents:
-                display_data.append({
-                    "id": agent.get("id"),
-                    "name": agent.get("name"),
-                    "version": agent.get("version"),
-                    "protocol": agent.get("protocol"),
-                    "endpoint_url": agent.get("endpoint_url"),
-                    "auth_method": agent.get("auth_method"),
-                    "created_at": (agent.get("created_at") or "")[:19],  # Trim microseconds if present
-                })
-            
-            print_output(
-                display_data,
-                format_type=format,
-                columns=["id", "name", "version", "protocol", "endpoint_url", "auth_method", "created_at"],
-                title=f"Agents ({len(agents)}/{total})"
-            )
-            
-    except Exception as e:
-        error(f"Failed to list agents: {e}")
-        raise typer.Exit(1)
-
-
-@app.command()
-def get(
-    agent_id: str = typer.Argument(..., help="Agent ID"),
-    format: str = typer.Option("table", "--format", help="Output format"),
-):
-    """Get agent details."""
-    try:
-        with get_client() as client:
-            agent = client.get(f"/api/v1/agents/{agent_id}")
-            
-            print_output(
-                agent,
-                format_type=format,
-                title=f"Agent {agent_id}"
-            )
-            
-    except Exception as e:
-        error(f"Failed to get agent: {e}")
-        raise typer.Exit(1)
-
-
-@app.command()
-def create(
-    name: str = typer.Option(..., "--name", help="Agent name"),
-    description: Optional[str] = typer.Option(None, "--description", help="Agent description"),
-    version: str = typer.Option("1.0.0", "--version", help="Agent version"),
-    protocol: str = typer.Option("HTTP", "--protocol", help="Agent protocol"),
-    endpoint_url: str = typer.Option(..., "--endpoint-url", help="Agent endpoint URL"),
-    auth_method: str = typer.Option("OAUTH2", "--auth-method", help="Authentication method"),
-):
-    """Create a new agent."""
-    try:
-        with get_client() as client:
-            data = {
-                "name": name,
-                "description": description,
-                "version": version,
-                "protocol": protocol,
-                "endpoint_url": endpoint_url,
-                "auth_method": auth_method,
-            }
-            
-            agent = client.post("/api/v1/agents", data)
-            
-            success(f"Agent created: {agent['id']}")
-            info(f"Name: {agent['name']}")
-            info(f"Endpoint: {agent['endpoint_url']}")
-            
-    except Exception as e:
-        error(f"Failed to create agent: {e}")
-        raise typer.Exit(1)
-
-
-@app.command()
-def update(
-    agent_id: str = typer.Argument(..., help="Agent ID"),
-    name: Optional[str] = typer.Option(None, "--name", help="Agent name"),
-    description: Optional[str] = typer.Option(None, "--description", help="Agent description"),
-    version: Optional[str] = typer.Option(None, "--version", help="Agent version"),
-    protocol: Optional[str] = typer.Option(None, "--protocol", help="Agent protocol"),
-    endpoint_url: Optional[str] = typer.Option(None, "--endpoint-url", help="Agent endpoint URL"),
-    auth_method: Optional[str] = typer.Option(None, "--auth-method", help="Authentication method"),
-):
-    """Update an agent."""
-    try:
-        with get_client() as client:
-            data = {}
-            
-            if name is not None:
-                data["name"] = name
-            if description is not None:
-                data["description"] = description
-            if version is not None:
-                data["version"] = version
-            if protocol is not None:
-                data["protocol"] = protocol
-            if endpoint_url is not None:
-                data["endpoint_url"] = endpoint_url
-            if auth_method is not None:
-                data["auth_method"] = auth_method
-            
-            if not data:
-                error("No update data provided")
-                raise typer.Exit(1)
-            
-            agent = client.put(f"/api/v1/agents/{agent_id}", data)
-            
-            success(f"Agent updated: {agent['id']}")
-            info(f"Name: {agent['name']}")
-            info(f"Endpoint: {agent['endpoint_url']}")
-            
-    except Exception as e:
-        error(f"Failed to update agent: {e}")
-        raise typer.Exit(1)
-
-
-@app.command()
-def delete(
-    agent_id: str = typer.Argument(..., help="Agent ID"),
-    force: bool = typer.Option(False, "--force", help="Force deletion without confirmation"),
-):
-    """Delete an agent."""
-    try:
-        if not force:
-            if not prompt_confirm(f"Are you sure you want to delete agent {agent_id}?"):
-                info("Deletion cancelled")
-                return
-        
-        with get_client() as client:
-            client.delete(f"/api/v1/agents/{agent_id}")
-            
-            success(f"Agent deleted: {agent_id}")
-            
-    except Exception as e:
-        error(f"Failed to delete agent: {e}")
-        raise typer.Exit(1)
-
-
-@app.command()
-def invoke(
-    agent_id: str = typer.Argument(..., help="Agent ID"),
-    input_text: str = typer.Option(..., "--input", help="Input message for the agent"),
-    format: str = typer.Option("table", "--format", help="Output format"),
-):
-    """Invoke an agent."""
-    try:
-        with get_client() as client:
-            data = {
-                "input": input_text,
-                "parameters": {},
-                "context": {},
-            }
-            
-            info(f"Invoking agent {agent_id}...")
-            response = client.post(f"/api/v1/agents/{agent_id}/invoke", data)
-            
-            success("Agent invoked successfully")
-            
-            # Display response
-            if format == "table":
-                info("Response:")
-                print(response["output"])
-                
-                if response.get("metadata"):
-                    info("\nMetadata:")
-                    print_output(response["metadata"], format_type="yaml")
-                
-                if response.get("logs"):
-                    info("\nLogs:")
-                    for log in response["logs"]:
-                        print(f"  {log}")
-            else:
-                print_output(response, format_type=format)
-            
-    except Exception as e:
-        error(f"Failed to invoke agent: {e}")
-        raise typer.Exit(1) 

af_sdk/auth/application.py

@@ -1,264 +0,0 @@
-"""
-Authentication helpers for Agentic Fabric SDK.
-
-Provides utilities for loading application credentials and creating
-authenticated clients.
-"""
-
-from pathlib import Path
-import json
-import httpx
-from typing import Optional, List, Dict
-import logging
-
-from .fabriq_client import FabriqClient
-
-logger = logging.getLogger(__name__)
-
-
-class ApplicationNotFoundError(Exception):
-    """Raised when an application configuration is not found."""
-    pass
-
-
-class AuthenticationError(Exception):
-    """Raised when authentication fails."""
-    pass
-
-
-async def get_application_client(
-    app_id: str,
-    config_dir: Optional[Path] = None,
-    gateway_url: Optional[str] = None,
-) -> FabriqClient:
-    """
-    Get authenticated FabriqClient for an application.
-    
-    Automatically loads credentials from ~/.af/applications/{app_id}.json
-    and exchanges them for a JWT token.
-    
-    Args:
-        app_id: Application identifier (e.g., "my-slack-bot")
-        config_dir: Optional custom config directory (default: ~/.af)
-        gateway_url: Optional gateway URL override (default: from app config)
-    
-    Returns:
-        Authenticated FabriqClient instance
-    
-    Raises:
-        ApplicationNotFoundError: If application config doesn't exist
-        AuthenticationError: If authentication fails
-    
-    Example:
-        >>> client = await get_application_client("my-slack-bot")
-        >>> result = await client.invoke_tool("slack-uuid", "post_message", {...})
-    """
-    # 1. Load application config
-    try:
-        app_config = load_application_config(app_id, config_dir)
-    except FileNotFoundError as e:
-        raise ApplicationNotFoundError(
-            f"Application '{app_id}' not found. "
-            f"Register it first with: afctl applications create --app-id {app_id} ..."
-        ) from e
-    
-    # Use provided gateway_url or fall back to config
-    base_url = gateway_url or app_config.get("gateway_url", "https://dashboard.agenticfabriq.com")
-    
-    # 2. Exchange credentials for JWT token
-    try:
-        async with httpx.AsyncClient() as http:
-            response = await http.post(
-                f"{base_url}/api/v1/applications/token",
-                json={
-                    "app_id": app_config["app_id"],
-                    "secret_key": app_config["secret_key"]
-                },
-                timeout=30.0
-            )
-            
-            if response.status_code != 200:
-                error_detail = response.text
-                try:
-                    error_json = response.json()
-                    error_detail = error_json.get("detail", response.text)
-                except:
-                    pass
-                
-                raise AuthenticationError(
-                    f"Failed to authenticate application '{app_id}': {error_detail}"
-                )
-            
-            token_data = response.json()
-    except httpx.HTTPError as e:
-        raise AuthenticationError(
-            f"Network error while authenticating application '{app_id}': {e}"
-        ) from e
-    
-    # 3. Create and return authenticated client
-    client = FabriqClient(
-        base_url=base_url,
-        auth_token=token_data["access_token"]
-    )
-    
-    # Store metadata for potential refresh
-    client._app_id = app_id
-    client._expires_in = token_data.get("expires_in", 86400)
-    
-    logger.info(
-        f"Authenticated as application '{app_id}' "
-        f"(user_id={token_data.get('user_id')}, tenant_id={token_data.get('tenant_id')})"
-    )
-    
-    return client
-
-
-def load_application_config(
-    app_id: str,
-    config_dir: Optional[Path] = None
-) -> Dict:
-    """
-    Load application config from disk.
-    
-    Args:
-        app_id: Application identifier
-        config_dir: Optional custom config directory (default: ~/.af)
-    
-    Returns:
-        Application configuration dictionary
-    
-    Raises:
-        FileNotFoundError: If application config doesn't exist
-    
-    Example:
-        >>> config = load_application_config("my-slack-bot")
-        >>> print(config["app_id"], config["created_at"])
-    """
-    if config_dir is None:
-        config_dir = Path.home() / ".af"
-    
-    app_file = config_dir / "applications" / f"{app_id}.json"
-    
-    if not app_file.exists():
-        raise FileNotFoundError(
-            f"Application '{app_id}' not found at {app_file}. "
-            f"Register it with: afctl applications create --app-id {app_id}"
-        )
-    
-    with open(app_file, "r") as f:
-        return json.load(f)
-
-
-def save_application_config(
-    app_id: str,
-    config: Dict,
-    config_dir: Optional[Path] = None
-) -> Path:
-    """
-    Save application config to disk.
-    
-    Args:
-        app_id: Application identifier
-        config: Application configuration dictionary
-        config_dir: Optional custom config directory (default: ~/.af)
-    
-    Returns:
-        Path to saved config file
-    
-    Example:
-        >>> config = {
-        ...     "app_id": "my-bot",
-        ...     "secret_key": "sk_...",
-        ...     "gateway_url": "https://dashboard.agenticfabriq.com"
-        ... }
-        >>> path = save_application_config("my-bot", config)
-    """
-    if config_dir is None:
-        config_dir = Path.home() / ".af"
-    
-    # Create applications directory if it doesn't exist
-    app_dir = config_dir / "applications"
-    app_dir.mkdir(parents=True, exist_ok=True)
-    
-    # Write config file
-    app_file = app_dir / f"{app_id}.json"
-    with open(app_file, "w") as f:
-        json.dump(config, f, indent=2)
-    
-    # Secure the file (user read/write only)
-    app_file.chmod(0o600)
-    
-    logger.info(f"Saved application config to {app_file}")
-    
-    return app_file
-
-
-def list_applications(
-    config_dir: Optional[Path] = None
-) -> List[Dict]:
-    """
-    List all registered applications.
-    
-    Args:
-        config_dir: Optional custom config directory (default: ~/.af)
-    
-    Returns:
-        List of application configuration dictionaries
-    
-    Example:
-        >>> apps = list_applications()
-        >>> for app in apps:
-        ...     print(f"{app['app_id']}: {app.get('name', 'N/A')}")
-    """
-    if config_dir is None:
-        config_dir = Path.home() / ".af"
-    
-    app_dir = config_dir / "applications"
-    
-    if not app_dir.exists():
-        return []
-    
-    apps = []
-    for app_file in sorted(app_dir.glob("*.json")):
-        try:
-            with open(app_file, "r") as f:
-                app_config = json.load(f)
-                apps.append(app_config)
-        except Exception as e:
-            logger.warning(f"Failed to load application config from {app_file}: {e}")
-    
-    return apps
-
-
-def delete_application_config(
-    app_id: str,
-    config_dir: Optional[Path] = None
-) -> bool:
-    """
-    Delete application config from disk.
-    
-    Args:
-        app_id: Application identifier
-        config_dir: Optional custom config directory (default: ~/.af)
-    
-    Returns:
-        True if deleted, False if not found
-    
-    Example:
-        >>> deleted = delete_application_config("my-old-bot")
-        >>> if deleted:
-        ...     print("Deleted successfully")
-    """
-    if config_dir is None:
-        config_dir = Path.home() / ".af"
-    
-    app_file = config_dir / "applications" / f"{app_id}.json"
-    
-    if not app_file.exists():
-        return False
-    
-    app_file.unlink()
-    logger.info(f"Deleted application config: {app_file}")
-    
-    return True
-