agentic-fabriq-sdk 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

af_cli/commands/auth.py

@@ -98,9 +98,12 @@ def login(
         # Extract and save token data
         token_data = token_storage.extract_token_info(tokens)
         
-        # Override tenant_id if provided
+        # Override tenant_id if provided, otherwise use default for Keycloak JWTs
         if tenant_id:
             token_data.tenant_id = tenant_id
+        elif not token_data.tenant_id:
+            # Keycloak JWTs don't have tenant_id, use the same default as the backend
+            token_data.tenant_id = "550e8400-e29b-41d4-a716-446655440000"
         
         # Save tokens
         token_storage.save(token_data)
@@ -109,8 +112,7 @@ def login(
         config.access_token = token_data.access_token
         config.refresh_token = token_data.refresh_token
         config.token_expires_at = token_data.expires_at
-        if token_data.tenant_id:
-            config.tenant_id = token_data.tenant_id
+        config.tenant_id = token_data.tenant_id  # Always set tenant_id
         config.save()
         
         # Display success message
@@ -190,7 +192,7 @@ def status():
     
     if not token_data:
         warning("Not authenticated")
-        info("Run 'af auth login' to authenticate")
+        info("Run 'afctl auth login' to authenticate")
         return
     
     # Create status table
@@ -242,9 +244,9 @@ def status():
     # Show recommendations
     if is_expired:
         if token_data.refresh_token:
-            info("Token has expired. Run 'af auth refresh' to get a new token")
+            info("Token has expired. Run 'afctl auth refresh' to get a new token")
         else:
-            info("Token has expired. Run 'af auth login' to re-authenticate")
+            info("Token has expired. Run 'afctl auth login' to re-authenticate")
 
 
 @app.command()
@@ -270,7 +272,7 @@ def refresh(
     
     if not token_data or not token_data.refresh_token:
         error("No refresh token available")
-        info("Run 'af auth login' to authenticate")
+        info("Run 'afctl auth login' to authenticate")
         raise typer.Exit(1)
     
     try:
@@ -304,7 +306,7 @@ def refresh(
         
     except Exception as e:
         error(f"Token refresh failed: {e}")
-        error("Please run 'af auth login' to re-authenticate")
+        error("Please run 'afctl auth login' to re-authenticate")
         
         # Clear invalid tokens
         token_storage.delete()
@@ -366,7 +368,7 @@ def whoami():
     
     if not token_data:
         warning("Not authenticated")
-        info("Run 'af auth login' to authenticate")
+        info("Run 'afctl auth login' to authenticate")
         return
     
     # Create user info table

af_cli/commands/config.py

@@ -93,7 +93,7 @@ def reset():
     config.clear_auth()
     
     # Reset to defaults
-    config.gateway_url = "http://localhost:8000"
+    config.gateway_url = "https://dashboard.agenticfabriq.com"
     config.tenant_id = None
     config.output_format = "table"
     

af_cli/commands/tools.py

@@ -6,7 +6,7 @@ Tool management commands for the Agentic Fabric CLI.
 import typer
 
 from af_cli.core.client import get_client
-from af_cli.core.output import error, info, print_output, success, warning
+from af_cli.core.output import debug, error, info, print_output, success, warning
 
 app = typer.Typer(help="Tool management commands")
 
@@ -15,45 +15,107 @@ app = typer.Typer(help="Tool management commands")
 def list(
     format: str = typer.Option("table", "--format", "-f", help="Output format"),
 ):
-    """List tools."""
+    """List your tool connections (configured and connected tools)."""
     try:
         with get_client() as client:
-            response = client.get("/api/v1/tools")
-            tools = response["tools"]
+            connections = client.get("/api/v1/user-connections")
             
-            if not tools:
-                warning("No tools found")
+            if not connections:
+                warning("No tool connections found. Add connections in the dashboard UI.")
                 return
             
+            # Format for better display
+            display_data = []
+            for conn in connections:
+                # Format tool name nicely (e.g., "google_docs" -> "Google Docs")
+                tool_name = conn.get("tool", "N/A").replace("_", " ").title()
+                
+                # Status indicator
+                status = "✓ Connected" if conn.get("connected") else "○ Configured"
+                
+                display_data.append({
+                    "Tool": tool_name,
+                    "ID": conn.get("connection_id", "N/A"),
+                    "Name": conn.get("display_name") or conn.get("connection_id", "N/A"),
+                    "Status": status,
+                    "Method": conn.get("method", "oauth"),
+                    "Added": conn.get("created_at", "N/A")[:10] if conn.get("created_at") else "N/A",
+                })
+            
             print_output(
-                tools,
+                display_data,
                 format_type=format,
-                title="Tools"
+                title="Your Tool Connections"
             )
             
     except Exception as e:
-        error(f"Failed to list tools: {e}")
+        error(f"Failed to list tool connections: {e}")
         raise typer.Exit(1)
 
 
 @app.command()
 def get(
-    tool_id: str = typer.Argument(..., help="Tool ID"),
+    connection_id: str = typer.Argument(..., help="Connection ID (e.g., 'google', 'slack')"),
     format: str = typer.Option("table", "--format", "-f", help="Output format"),
 ):
-    """Get tool details."""
+    """Get tool connection details."""
     try:
         with get_client() as client:
-            tool = client.get(f"/api/v1/tools/{tool_id}")
+            # Get all user connections and find the matching one
+            connections = client.get("/api/v1/user-connections")
+            
+            # Find the specific connection
+            connection = None
+            for conn in connections:
+                if conn.get("connection_id") == connection_id or conn.get("tool") == connection_id:
+                    connection = conn
+                    break
+            
+            if not connection:
+                error(f"Connection '{connection_id}' not found")
+                info("Available connections:")
+                for conn in connections:
+                    info(f"  - {conn.get('tool')} (ID: {conn.get('connection_id')})")
+                raise typer.Exit(1)
+            
+            # Format tool name nicely
+            tool_name = connection.get("tool", "N/A").replace("_", " ").title()
+            
+            # Format the connection details for display
+            details = {
+                "Tool": tool_name,
+                "Connection ID": connection.get("connection_id", "N/A"),
+                "Display Name": connection.get("display_name") or connection.get("connection_id", "N/A"),
+                "Status": "✓ Connected" if connection.get("connected") else "○ Configured",
+                "Method": connection.get("method", "oauth"),
+                "Created": connection.get("created_at", "N/A"),
+                "Updated": connection.get("updated_at", "N/A"),
+            }
+            
+            # Add tool-specific fields if present
+            if connection.get("team_name"):
+                details["Team Name"] = connection.get("team_name")
+            if connection.get("team_id"):
+                details["Team ID"] = connection.get("team_id")
+            if connection.get("bot_user_id"):
+                details["Bot User ID"] = connection.get("bot_user_id")
+            if connection.get("email"):
+                details["Email"] = connection.get("email")
+            if connection.get("login"):
+                details["GitHub Login"] = connection.get("login")
+            if connection.get("workspace_name"):
+                details["Workspace Name"] = connection.get("workspace_name")
+            if connection.get("scopes"):
+                details["Scopes"] = ", ".join(connection.get("scopes", []))
             
             print_output(
-                tool,
+                details,
                 format_type=format,
-                title=f"Tool {tool_id}"
+                title=f"{tool_name} Connection Details"
             )
             
     except Exception as e:
-        error(f"Failed to get tool: {e}")
+        error(f"Failed to get tool connection: {e}")
         raise typer.Exit(1)
 
 
@@ -80,4 +142,364 @@ def invoke(
             
     except Exception as e:
         error(f"Failed to invoke tool: {e}")
+        raise typer.Exit(1)
+
+
+@app.command()
+def add(
+    tool: str = typer.Argument(..., help="Tool name (google_drive, google_slides, slack, notion, github, etc.)"),
+    connection_id: str = typer.Option(..., "--connection-id", help="Unique connection ID"),
+    display_name: str = typer.Option(None, "--display-name", help="Human-readable name"),
+    method: str = typer.Option(..., "--method", help="Connection method: 'api', 'credentials', or 'oauth'"),
+    
+    # API method fields
+    token: str = typer.Option(None, "--token", help="API token (for api method)"),
+    
+    # Credentials method fields
+    client_id: str = typer.Option(None, "--client-id", help="OAuth client ID (for credentials method)"),
+    client_secret: str = typer.Option(None, "--client-secret", help="OAuth client secret (for credentials method)"),
+    redirect_uri: str = typer.Option(None, "--redirect-uri", help="OAuth redirect URI (optional, auto-generated)"),
+):
+    """
+    Add a new tool connection with credentials.
+    
+    Examples:
+      # Notion (api method - single token)
+      afctl tools add notion --connection-id notion-work --method api --token "secret_abc123"
+      
+      # Google (credentials method - OAuth app)
+      afctl tools add google --connection-id google-work --method credentials \\
+        --client-id "123.apps.googleusercontent.com" \\
+        --client-secret "GOCSPX-abc123"
+      
+      # Slack bot (api method)
+      afctl tools add slack --connection-id slack-bot --method api --token "xoxb-123..."
+    """
+    try:
+        from af_cli.core.config import get_config
+        
+        with get_client() as client:
+            # Validate tool name - check for common mistakes
+            if tool.lower() == "google":
+                error("❌ Invalid tool name: 'google'")
+                info("")
+                info("Please specify the exact Google Workspace tool:")
+                info("  • google_drive    - Google Drive")
+                info("  • google_docs     - Google Docs")
+                info("  • google_sheets   - Google Sheets")
+                info("  • google_slides   - Google Slides")
+                info("  • gmail           - Gmail")
+                info("  • google_calendar - Google Calendar")
+                info("  • google_meet     - Google Meet")
+                info("  • google_forms    - Google Forms")
+                info("  • google_classroom - Google Classroom")
+                info("  • google_people   - Google People (Contacts)")
+                info("  • google_chat     - Google Chat")
+                info("  • google_tasks    - Google Tasks")
+                info("")
+                info("Example:")
+                info(f"  afctl tools add google_drive --connection-id {connection_id} --method {method}")
+                raise typer.Exit(1)
+            
+            # Validate method
+            if method not in ["api", "credentials", "oauth"]:
+                error("Method must be 'api', 'credentials', or 'oauth'")
+                raise typer.Exit(1)
+            
+            # Validate API method requirements
+            if method == "api":
+                if not token:
+                    error("API method requires --token")
+                    info(f"Example: afctl tools add {tool} --connection-id {connection_id} --method api --token YOUR_TOKEN")
+                    raise typer.Exit(1)
+            
+            # Validate credentials method requirements
+            elif method == "credentials":
+                if not client_id or not client_secret:
+                    error("Credentials method requires --client-id and --client-secret")
+                    info(f"Example: afctl tools add {tool} --connection-id {connection_id} --method credentials \\")
+                    info(f"  --client-id YOUR_CLIENT_ID --client-secret YOUR_CLIENT_SECRET")
+                    raise typer.Exit(1)
+            
+            info(f"Creating connection: {connection_id}")
+            info(f"Tool: {tool}")
+            info(f"Method: {method}")
+            
+            # Step 1: Create connection metadata
+            connection_data = {
+                "tool": tool,
+                "connection_id": connection_id,
+                "display_name": display_name or connection_id,
+                "method": method,
+            }
+            
+            client.post("/api/v1/user-connections", data=connection_data)
+            success(f"✅ Connection entry created: {connection_id}")
+            
+            # Step 2: Store credentials based on method
+            if method == "credentials" or method == "oauth":
+                # Determine the API base tool name (Google tools all use "google")
+                api_tool_name = "google" if (tool.startswith("google_") or tool == "gmail") else tool
+                
+                # Auto-generate redirect_uri if not provided
+                if not redirect_uri:
+                    config = get_config()
+                    redirect_uri = f"{config.gateway_url}/api/v1/tools/{api_tool_name}/oauth/callback"
+                    info(f"Using default redirect URI: {redirect_uri}")
+                
+                # Store OAuth app config
+                info("Storing OAuth app credentials...")
+                config_payload = {
+                    "client_id": client_id,
+                    "client_secret": client_secret,
+                }
+                if redirect_uri:
+                    config_payload["redirect_uri"] = redirect_uri
+                
+                client.post(
+                    f"/api/v1/tools/{api_tool_name}/config?connection_id={connection_id}",
+                    data=config_payload
+                )
+                success("✅ OAuth app credentials stored")
+                info("")
+                info(f"Next: Run 'afctl tools connect {connection_id}' to complete OAuth setup")
+                
+            elif method == "api":
+                # Store API token directly
+                info("Storing API credentials...")
+                
+                # Tool-specific endpoint and payload mappings
+                if tool == "notion":
+                    # Notion uses /config endpoint with integration_token field
+                    endpoint = f"/api/v1/tools/{tool}/config?connection_id={connection_id}"
+                    cred_payload = {"integration_token": token}
+                else:
+                    # Generic tools use /connection endpoint with api_token field
+                    endpoint = f"/api/v1/tools/{tool}/connection?connection_id={connection_id}"
+                    cred_payload = {"api_token": token}
+                
+                client.post(endpoint, data=cred_payload)
+                success("✅ API credentials stored")
+                success(f"✅ Connection '{connection_id}' is ready to use!")
+            
+            # Show helpful info
+            info("")
+            info("View your connections:")
+            info(f"  • List all: afctl tools list")
+            info(f"  • View details: afctl tools get {connection_id}")
+            
+    except Exception as e:
+        error(f"Failed to add connection: {e}")
+        raise typer.Exit(1)
+
+
+@app.command()
+def connect(
+    connection_id: str = typer.Argument(..., help="Connection ID to connect"),
+):
+    """Complete OAuth connection (open browser for authorization)."""
+    try:
+        import webbrowser
+        import time
+        
+        with get_client() as client:
+            # Get connection info
+            connections = client.get("/api/v1/user-connections")
+            
+            connection = None
+            for conn in connections:
+                if conn.get("connection_id") == connection_id:
+                    connection = conn
+                    break
+            
+            if not connection:
+                error(f"Connection '{connection_id}' not found")
+                info("Run 'afctl tools list' to see available connections")
+                raise typer.Exit(1)
+            
+            tool = connection["tool"]
+            method = connection["method"]
+            
+            # Only credentials/oauth method needs OAuth completion
+            if method not in ["credentials", "oauth"]:
+                error(f"Connection '{connection_id}' uses '{method}' method")
+                info("Only 'credentials' or 'oauth' method connections need OAuth setup")
+                info("API connections are already connected after 'afctl tools add'")
+                raise typer.Exit(1)
+            
+            # Check if already connected
+            if connection.get("connected"):
+                warning(f"Connection '{connection_id}' is already connected")
+                confirm = typer.confirm("Do you want to reconnect (re-authorize)?")
+                if not confirm:
+                    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
+            
+            # Initiate OAuth flow
+            info(f"Initiating OAuth for {tool}...")
+            
+            # For Google tools, pass the specific tool_type parameter
+            tool_type_param = f"&tool_type={tool}" if tool != api_tool_name else ""
+            
+            result = client.post(
+                f"/api/v1/tools/{api_tool_name}/connect/initiate?connection_id={connection_id}{tool_type_param}",
+                data={}
+            )
+            
+            debug(f"Backend response: {result}")
+            
+            # Different tools use different field names for the auth URL
+            auth_url = (
+                result.get("authorization_url") or 
+                result.get("auth_url") or 
+                result.get("oauth_url")
+            )
+            
+            if not auth_url:
+                error("Failed to get authorization URL from backend")
+                error(f"Response keys: {list(result.keys())}")
+                debug(f"Full response: {result}")
+                raise typer.Exit(1)
+            
+            info("Opening browser for authentication...")
+            info("")
+            info(f"If browser doesn't open, visit: {auth_url}")
+            
+            # Open browser
+            webbrowser.open(auth_url)
+            
+            info("")
+            info("Waiting for authorization...")
+            info("(Complete the login in your browser)")
+            
+            # Poll for connection completion
+            max_attempts = 120  # 2 minutes
+            for attempt in range(max_attempts):
+                time.sleep(1)
+                
+                # Check connection status
+                connections = client.get("/api/v1/user-connections")
+                for conn in connections:
+                    if conn.get("connection_id") == connection_id:
+                        if conn.get("connected"):
+                            info("")
+                            success(f"✅ Successfully connected to {tool}!")
+                            
+                            # Show connection details
+                            info(f"Connection ID: {connection_id}")
+                            if conn.get("email"):
+                                info(f"Email: {conn['email']}")
+                            if conn.get("team_name"):
+                                info(f"Team: {conn['team_name']}")
+                            if conn.get("login"):
+                                info(f"GitHub: {conn['login']}")
+                            
+                            return
+                        break
+            
+            # Timeout
+            error("")
+            error("Timeout: Authorization not completed within 2 minutes")
+            info("Please try again or check your browser")
+            raise typer.Exit(1)
+            
+    except Exception as e:
+        error(f"Failed to connect: {e}")
+        raise typer.Exit(1)
+
+
+@app.command()
+def disconnect(
+    connection_id: str = typer.Argument(..., help="Connection ID to disconnect"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+):
+    """Disconnect a tool (remove credentials but keep connection entry)."""
+    try:
+        with get_client() as client:
+            # Get connection info
+            connections = client.get("/api/v1/user-connections")
+            
+            connection = None
+            for conn in connections:
+                if conn.get("connection_id") == connection_id:
+                    connection = conn
+                    break
+            
+            if not connection:
+                error(f"Connection '{connection_id}' not found")
+                raise typer.Exit(1)
+            
+            tool = connection["tool"]
+            tool_display = connection.get("display_name") or connection_id
+            
+            # Check if connected
+            if not connection.get("connected"):
+                error(f"Connection '{connection_id}' is already disconnected")
+                info(f"Use 'afctl tools get {connection_id}' to view status")
+                raise typer.Exit(1)
+            
+            # Confirm
+            if not force:
+                warning(f"This will remove OAuth tokens/credentials for '{tool_display}'")
+                info("You can reconnect later with 'afctl tools connect'")
+                confirm = typer.confirm(f"Disconnect {tool} connection '{connection_id}'?")
+                if not confirm:
+                    info("Cancelled")
+                    return
+            
+            # Delete connection credentials
+            client.delete(
+                f"/api/v1/tools/{tool}/connection?connection_id={connection_id}"
+            )
+            
+            success(f"✅ Disconnected: {connection_id}")
+            info("Connection entry preserved.")
+            info(f"Run 'afctl tools connect {connection_id}' to reconnect.")
+            
+    except Exception as e:
+        error(f"Failed to disconnect: {e}")
+        raise typer.Exit(1)
+
+
+@app.command()
+def remove(
+    connection_id: str = typer.Argument(..., help="Connection ID to remove"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+):
+    """Remove a tool connection completely (delete entry and credentials)."""
+    try:
+        with get_client() as client:
+            # Get connection info
+            connections = client.get("/api/v1/user-connections")
+            
+            connection = None
+            for conn in connections:
+                if conn.get("connection_id") == connection_id:
+                    connection = conn
+                    break
+            
+            if not connection:
+                error(f"Connection '{connection_id}' not found")
+                raise typer.Exit(1)
+            
+            tool = connection["tool"]
+            tool_display = connection.get("display_name") or connection_id
+            
+            # Confirm
+            if not force:
+                warning("⚠️  This will permanently delete the connection and credentials")
+                confirm = typer.confirm(f"Remove {tool} connection '{tool_display}'?")
+                if not confirm:
+                    info("Cancelled")
+                    return
+            
+            # Delete connection entry (backend will cascade delete credentials)
+            client.delete(f"/api/v1/user-connections/{connection_id}")
+            
+            success(f"✅ Removed: {connection_id}")
+            
+    except Exception as e:
+        error(f"Failed to remove: {e}")
         raise typer.Exit(1) 

af_cli/core/client.py

@@ -33,7 +33,7 @@ class AFClient:
         debug(f"Response: {response.status_code} {response.url}")
         
         if response.status_code == 401:
-            error("Authentication failed. Please run 'af auth login'")
+            error("Authentication failed. Please run 'afctl auth login'")
             raise typer.Exit(1)
         
         if response.status_code == 403:
@@ -43,12 +43,16 @@ class AFClient:
         if response.status_code >= 400:
             try:
                 error_data = response.json()
-                error_message = error_data.get("message", "Unknown error")
+                # Try different error message fields (FastAPI uses "detail")
+                error_message = error_data.get("detail") or error_data.get("message") or "Unknown error"
                 error(f"API Error: {error_message}")
-                if self.config.verbose and "details" in error_data:
-                    debug(f"Error details: {json.dumps(error_data['details'], indent=2)}")
+                # Always show full response for debugging
+                debug(f"Response status: {response.status_code}")
+                debug(f"Request URL: {response.url}")
+                debug(f"Full response: {json.dumps(error_data, indent=2)}")
             except:
-                error(f"HTTP Error: {response.status_code} {response.text}")
+                error(f"HTTP Error: {response.status_code}")
+                debug(f"Response text: {response.text}")
             raise typer.Exit(1)
         
         try:

af_cli/core/output.py

@@ -55,12 +55,12 @@ def print_table(
     if columns is None:
         columns = list(data[0].keys())
     
-    # Create table
-    table = Table(title=title)
+    # Create table with expand to fill terminal width and show grid lines
+    table = Table(title=title, expand=True, show_lines=True)
     
-    # Add columns
+    # Add columns with no_wrap to prevent text wrapping
     for column in columns:
-        table.add_column(column.replace("_", " ").title(), style="cyan")
+        table.add_column(column.replace("_", " ").title(), style="cyan", no_wrap=True)
     
     # Add rows
     for row in data:

af_cli/main.py

@@ -68,7 +68,7 @@ def status():
     if config.access_token:
         table.add_row("Authentication", "✅ Authenticated", f"Tenant: {config.tenant_id}")
     else:
-        table.add_row("Authentication", "❌ Not authenticated", "Run 'af auth login'")
+        table.add_row("Authentication", "❌ Not authenticated", "Run 'afctl auth login'")
     
     # Check configuration
     config_path = config.config_file
@@ -83,7 +83,7 @@ def status():
 @app.command()
 def init(
     gateway_url: str = typer.Option(
-        "http://localhost:8000",
+        "https://dashboard.agenticfabriq.com",
         "--gateway-url",
         "-g",
         help="Gateway URL"
@@ -125,7 +125,7 @@ def init(
     if tenant_id:
         info(f"Tenant ID: {tenant_id}")
     else:
-        info("Run 'af auth login' to authenticate")
+        info("Run 'afctl auth login' to authenticate")
 
 
 @app.callback()

{agentic_fabriq_sdk-0.1.6.dist-info → agentic_fabriq_sdk-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-fabriq-sdk
-Version: 0.1.6
+Version: 0.1.8
 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
@@ -90,8 +90,8 @@ DX orchestration:
 ```python
 from af_sdk.dx import ToolFabric, AgentFabric, Agent, tool
 
-slack = ToolFabric(provider="slack", base_url="http://localhost:8000", access_token=TOKEN, tenant_id=TENANT)
-agents = AgentFabric(base_url="http://localhost:8000", access_token=TOKEN, tenant_id=TENANT)
+slack = ToolFabric(provider="slack", base_url="https://dashboard.agenticfabriq.com", access_token=TOKEN, tenant_id=TENANT)
+agents = AgentFabric(base_url="https://dashboard.agenticfabriq.com", access_token=TOKEN, tenant_id=TENANT)
 
 @tool
 def echo(x: str) -> str:
@@ -101,7 +101,7 @@ bot = Agent(
     system_prompt="demo",
     tools=[echo],
     agents=agents.get_agents(["summarizer"]),
-    base_url="http://localhost:8000",
+    base_url="https://dashboard.agenticfabriq.com",
     access_token=TOKEN,
     tenant_id=TENANT,
     provider_fabrics={"slack": slack},

{agentic_fabriq_sdk-0.1.6.dist-info → agentic_fabriq_sdk-0.1.8.dist-info}/RECORD

@@ -1,18 +1,18 @@
 af_cli/__init__.py,sha256=F2T4x4H3VIdmTjHRyV5DkaRvbZcdHYzAWD2hxtTplE4,188
 af_cli/commands/__init__.py,sha256=Qngm2Yks6oTKazlxCZA_tIAHXwHoU6Oc7Pw5BGkA7W4,49
 af_cli/commands/agents.py,sha256=EBAZgY5YbcR6npN0m7n1YB3WUTnW050Dd6FfORn0TtQ,8433
-af_cli/commands/auth.py,sha256=nPJYHJiAi1G_trbgZsDao_omhRZk777J0eceVxapuBg,11826
-af_cli/commands/config.py,sha256=IbIlwDHeVGsa0nY6XxZw_7nqh_jUKUH3M7oe92zcrAk,2545
+af_cli/commands/auth.py,sha256=EuVIuTzpQ6eC6Tq9rdBF83HpfN-Jb4O0Ep_CLwhorUo,12071
+af_cli/commands/config.py,sha256=vKTYc9noPNQQe4rhS2V9def1kzDtjB14ptWKJpdxUlQ,2559
 af_cli/commands/mcp_servers.py,sha256=kr2MskqtwdA1434_9oEyEydlZ5Ycq8a1Vt5wSC0AqRE,2420
 af_cli/commands/secrets.py,sha256=_XvtST9G7US_0MqHywSqRdp2FXUr76OTiD-SH4WXoJU,3472
-af_cli/commands/tools.py,sha256=GVNJgs4E2l9gQp4oPOcJh4IQxx0HdX-xe0wk4DitZm0,2273
+af_cli/commands/tools.py,sha256=9wPXpemZh9YDCVKdIgvGFzlxMwSy0BuNg50Fs1DU6y0,21188
 af_cli/core/__init__.py,sha256=cQ0H7rGfaMISQPhoNe4Xfu_EKU2TqRVt2OMI7tPea5U,51
-af_cli/core/client.py,sha256=B5Q4bTMAzSdG3Xh46scH9pj89MGvDvjVQCq4IYTDPnU,3693
+af_cli/core/client.py,sha256=BELf6889BOzOWP6kCk4hSY4DolIATB0YNpui38l7EaI,3939
 af_cli/core/config.py,sha256=zTrbZTtBZqG5Ktsbomr1w4u9uKdyc1nUieXIZLYsvIk,7355
 af_cli/core/oauth.py,sha256=sCzo97TZyx8sLmo0GYv53P3zoABK6htRCivHhRpPRdI,18162
-af_cli/core/output.py,sha256=s0lSvQbqpam1QHIdtUjZPfJ2GVSH5aYjKq60QY7DO3M,4674
+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=shhGqDUSY1pBXA5QIxBj04Y9pMYdd7mCGBqsjBq49p4,5148
+af_cli/main.py,sha256=EdZk87HkL8jJwqn5flrbz3ecMIBy6XbrUxvvMAC7Koc,5168
 af_sdk/__init__.py,sha256=gZ7nGfDRMJzPiIFrfcKytYt0cyVVPorOQaWq5X3fL0M,1262
 af_sdk/auth/__init__.py,sha256=WUtbNo1KS6Jm-2ssCo21mwBmMKRxT2HtjnfXZeIKSQg,703
 af_sdk/auth/dpop.py,sha256=s0uiyxxuzsVQNtSexji1htJoxrALwlf1P9507xa-M3Y,1285
@@ -34,7 +34,7 @@ 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.6.dist-info/METADATA,sha256=nI_bwhX6XBBMx7idHBEePLu6RzFJhDs-5zeWknDSZsk,3122
-agentic_fabriq_sdk-0.1.6.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-agentic_fabriq_sdk-0.1.6.dist-info/entry_points.txt,sha256=XUO2EaJhUtUS5pwVIkhemC-nEeFbKgXXLW97gQCCGm8,41
-agentic_fabriq_sdk-0.1.6.dist-info/RECORD,,
+agentic_fabriq_sdk-0.1.8.dist-info/METADATA,sha256=QenHN2T37YomL0BrwUdLZGEcpHNkl_-AFmTXy3lDmWw,3164
+agentic_fabriq_sdk-0.1.8.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+agentic_fabriq_sdk-0.1.8.dist-info/entry_points.txt,sha256=XUO2EaJhUtUS5pwVIkhemC-nEeFbKgXXLW97gQCCGm8,41
+agentic_fabriq_sdk-0.1.8.dist-info/RECORD,,