agentic-fabriq-sdk 0.1.23__tar.gz → 0.1.25__tar.gz

{agentic_fabriq_sdk-0.1.23 → agentic_fabriq_sdk-0.1.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-fabriq-sdk
-Version: 0.1.23
+Version: 0.1.25
 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
@@ -88,15 +88,34 @@ async def main():
         tools = await af.list_tools()
         agents = await af.list_agents()
         
-        # Invoke tools using connection ID
+        # Invoke Slack tools
         result = await af.invoke_connection("my-slack", method="get_channels")
         
-        # Or post a message
+        # Post a Slack message
         await af.invoke_connection(
             "my-slack",
             method="post_message",
             parameters={"channel": "test", "text": "Hello from SDK!"}
         )
+        
+        # Get Gmail emails
+        result = await af.invoke_connection(
+            "gmail_work",
+            method="get_emails",
+            parameters={"max_results": 10, "q": "is:unread"}
+        )
+        emails = result.get("emails", [])
+        
+        # Send an email
+        await af.invoke_connection(
+            "gmail_work",
+            method="send_email",
+            parameters={
+                "to": "recipient@example.com",
+                "subject": "Hello from SDK",
+                "body": "This email was sent via Agentic Fabric SDK!"
+            }
+        )
 ```
 
 DX orchestration:

{agentic_fabriq_sdk-0.1.23 → agentic_fabriq_sdk-0.1.25}/README.md

@@ -52,15 +52,34 @@ async def main():
         tools = await af.list_tools()
         agents = await af.list_agents()
         
-        # Invoke tools using connection ID
+        # Invoke Slack tools
         result = await af.invoke_connection("my-slack", method="get_channels")
         
-        # Or post a message
+        # Post a Slack message
         await af.invoke_connection(
             "my-slack",
             method="post_message",
             parameters={"channel": "test", "text": "Hello from SDK!"}
         )
+        
+        # Get Gmail emails
+        result = await af.invoke_connection(
+            "gmail_work",
+            method="get_emails",
+            parameters={"max_results": 10, "q": "is:unread"}
+        )
+        emails = result.get("emails", [])
+        
+        # Send an email
+        await af.invoke_connection(
+            "gmail_work",
+            method="send_email",
+            parameters={
+                "to": "recipient@example.com",
+                "subject": "Hello from SDK",
+                "body": "This email was sent via Agentic Fabric SDK!"
+            }
+        )
 ```
 
 DX orchestration:

agentic_fabriq_sdk-0.1.25/af_cli/__init__.py

@@ -0,0 +1,17 @@
+"""
+Agentic Fabric CLI Tool
+
+A command-line interface for managing Agentic Fabric resources including
+agents, tools, and administrative operations.
+"""
+
+try:
+    from importlib.metadata import version, PackageNotFoundError
+    try:
+        __version__ = version("agentic-fabriq-sdk")
+    except PackageNotFoundError:
+        # Fallback if package is not installed
+        __version__ = "0.0.0-dev"
+except ImportError:
+    # Fallback for Python < 3.8 (though we require 3.11+)
+    __version__ = "0.0.0-dev" 

{agentic_fabriq_sdk-0.1.23 → agentic_fabriq_sdk-0.1.25}/af_cli/commands/applications.py

@@ -18,17 +18,21 @@ app = typer.Typer(help="Manage registered applications")
 console = Console()
 
 
-@app.command("create")
-def create_application(
+@app.command("register")
+def register_application(
     app_id: str = typer.Option(..., "--app-id", help="Application identifier (no spaces)"),
     connections: str = typer.Option(..., "--connections", help="Tool connections (format: 'tool1:conn-id,tool2:conn-id')"),
     scopes: Optional[str] = typer.Option(None, "--scopes", help="Scopes (format: 'scope1,scope2,scope3')"),
 ):
     """
-    Register a new application.
+    Step 1: Register a new application (returns activation token).
+    
+    This registers your application and returns a temporary activation token
+    that expires in 1 hour. Use this token with 'afctl applications connect'
+    to complete the setup and save credentials locally.
     
     Example:
-        afctl applications create \\
+        afctl applications register \\
             --app-id my-slack-bot \\
             --connections slack:my-slack-conn,github:my-github-conn \\
             --scopes slack:read,slack:write,github:repo:read
@@ -58,10 +62,10 @@ def create_application(
         for conn_id in tool_connections:
             tool_connections[conn_id] = scope_list
     
-    # Make API request
+    # Make API request to register (returns activation token)
     try:
         response = httpx.post(
-            f"{config.gateway_url}/api/v1/applications",
+            f"{config.gateway_url}/api/v1/applications/register",
             headers={"Authorization": f"Bearer {config.access_token}"},
             json={
                 "app_id": app_id,
@@ -83,6 +87,76 @@ def create_application(
         
         data = response.json()
         
+        # Display activation token
+        console.print("\n✅ Application registered successfully!", style="green bold")
+        console.print(f"\n📋 App ID: {data['app_id']}", style="cyan")
+        console.print(f"\n🔑 Activation Token:", style="yellow bold")
+        console.print(f"   {data['activation_token']}", style="yellow")
+        console.print(f"\n⏰ Token expires: {data['expires_at'][:19]} UTC", style="white")
+        console.print(f"   (Valid for 1 hour)", style="dim")
+        
+        console.print("\n📋 Next Steps:", style="cyan bold")
+        console.print(f"   1. Navigate to your project directory", style="white")
+        console.print(f"   2. Make sure you're authenticated: afctl auth login", style="white")
+        console.print(f"   3. Run the connect command:", style="white")
+        console.print(f"\n      afctl applications connect {app_id} --token <activation-token>", style="green")
+        console.print(f"\n⚠️  Save the activation token! It expires in 1 hour and can only be used once.", style="yellow bold")
+        
+    except httpx.HTTPError as e:
+        console.print(f"❌ Network error: {e}", style="red")
+        raise typer.Exit(1)
+
+
+@app.command("connect")
+def connect_application(
+    app_id: str = typer.Argument(..., help="Application identifier"),
+    token: str = typer.Option(..., "--token", help="Activation token from registration"),
+):
+    """
+    Step 2: Connect/activate an application (saves credentials locally).
+    
+    Uses the activation token from 'afctl applications register' to activate
+    the application and save credentials to the current directory.
+    
+    Example:
+        afctl applications connect my-slack-bot --token <activation-token>
+    """
+    config = get_config()
+    
+    if not config.is_authenticated():
+        console.print("❌ Not authenticated. Run 'afctl auth login' first.", style="red")
+        raise typer.Exit(1)
+    
+    # Make API request to activate (returns final credentials)
+    try:
+        response = httpx.post(
+            f"{config.gateway_url}/api/v1/applications/activate",
+            headers={"Authorization": f"Bearer {config.access_token}"},
+            json={"activation_token": token},
+            timeout=30.0
+        )
+        
+        if response.status_code == 404:
+            console.print("❌ Invalid or expired activation token", style="red")
+            console.print("   The token may have expired (valid for 1 hour) or was already used.", style="yellow")
+            console.print("   Register again with 'afctl applications register'", style="white")
+            raise typer.Exit(1)
+        elif response.status_code == 403:
+            console.print("❌ This activation token does not belong to you", style="red")
+            raise typer.Exit(1)
+        elif response.status_code != 201:
+            error_detail = response.text
+            try:
+                error_json = response.json()
+                error_detail = error_json.get("detail", response.text)
+            except:
+                pass
+            
+            console.print(f"❌ Failed to activate application: {error_detail}", style="red")
+            raise typer.Exit(1)
+        
+        data = response.json()
+        
         # Save credentials locally
         from af_sdk import save_application_config
         
@@ -99,7 +173,7 @@ def create_application(
         app_file = save_application_config(data["app_id"], app_config)
         
         # Display success
-        console.print("\n✅ Application registered successfully!", style="green bold")
+        console.print("\n✅ Application activated successfully!", style="green bold")
         console.print(f"\n📋 App ID: {data['app_id']}", style="cyan")
         console.print(f"🔑 Secret Key: {data['secret_key']}", style="yellow")
         console.print(f"\n💾 Credentials saved to: {app_file}", style="green")
@@ -116,24 +190,59 @@ def create_application(
 @app.command("list")
 def list_applications(
     format: str = typer.Option("table", "--format", help="Output format (table, json, yaml)"),
+    sync: bool = typer.Option(True, "--sync/--no-sync", help="Sync with server and remove orphaned local files"),
 ):
     """
     List all registered applications.
     
-    Shows applications from both:
-    - Local config files (~/.af/applications/)
-    - Server (via API)
+    Shows applications from local config files (~/.af/applications/) and optionally
+    syncs with the server to remove any local files for applications that have been
+    deleted from the server (e.g., via the UI).
     """
     config = get_config()
     
     # Load from local config first
-    from af_sdk import list_applications as list_local_apps
+    from af_sdk import list_applications as list_local_apps, delete_application_config
     
     local_apps = list_local_apps()
     
+    # If sync is enabled and user is authenticated, check server and clean up orphans
+    if sync and config.is_authenticated():
+        try:
+            response = httpx.get(
+                f"{config.gateway_url}/api/v1/applications",
+                headers={"Authorization": f"Bearer {config.access_token}"},
+                timeout=30.0
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                server_apps = data.get("applications", [])
+                server_app_ids = {app["app_id"] for app in server_apps}
+                
+                # Find and remove orphaned local files
+                orphaned = []
+                for local_app in local_apps[:]:  # Copy list to modify during iteration
+                    if local_app["app_id"] not in server_app_ids:
+                        orphaned.append(local_app["app_id"])
+                        # Delete orphaned local config
+                        delete_application_config(local_app["app_id"])
+                        # Remove from local_apps list
+                        local_apps.remove(local_app)
+                
+                if orphaned:
+                    console.print(f"🧹 Cleaned up {len(orphaned)} orphaned local file(s): {', '.join(orphaned)}", style="yellow")
+            
+        except httpx.HTTPError as e:
+            # If server check fails, just show local apps with a warning
+            console.print(f"⚠️  Could not sync with server: {e}", style="yellow")
+        except Exception as e:
+            # Silently continue if sync fails
+            pass
+    
     if format == "table":
         if not local_apps:
-            console.print("No applications registered locally.", style="yellow")
+            console.print("No applications registered.", style="yellow")
             return
         
         table = Table(title="Registered Applications")

{agentic_fabriq_sdk-0.1.23 → agentic_fabriq_sdk-0.1.25}/af_cli/commands/auth.py

@@ -53,15 +53,16 @@ def login(
         "--tenant-id",
         help="Tenant ID (optional, can be extracted from JWT)"
     ),
-    browser: bool = typer.Option(
-        True,
-        help="Open browser for authentication"
-    ),
     keycloak_url: Optional[str] = typer.Option(
         None,
         "--keycloak-url",
         help="Keycloak URL (default: https://auth.agenticfabriq.com or from config)"
     ),
+    yes: bool = typer.Option(
+        False,
+        "--yes",
+        help="Skip confirmation when already authenticated"
+    ),
 ):
     """
     Login to Agentic Fabric using OAuth2/PKCE flow.
@@ -80,7 +81,7 @@ def login(
         info(f"Already authenticated as: {user_display}")
         info(f"Tenant: {existing_token.tenant_id or 'Unknown'}")
         
-        if not typer.confirm("Do you want to login again?"):
+        if not yes and not typer.confirm("Do you want to login again?"):
             return
     
     try:
@@ -89,8 +90,8 @@ def login(
         
         # Perform login
         console.print()
-        # Use direct localhost redirect until branded page is deployed
-        tokens = oauth_client.login(open_browser=browser, timeout=300, use_hosted_callback=False)
+        # Always open browser for authentication
+        tokens = oauth_client.login(open_browser=True, timeout=300, use_hosted_callback=False)
         
         # Extract and save token data
         token_data = token_storage.extract_token_info(tokens)

{agentic_fabriq_sdk-0.1.23 → agentic_fabriq_sdk-0.1.25}/af_cli/commands/config.py

@@ -12,12 +12,14 @@ app = typer.Typer(help="Configuration commands")
 
 @app.command()
 def show(
-    format: str = typer.Option("table", "--format", help="Output format"),
+    format: str = typer.Option(None, "--format", help="Output format (overrides configured default)"),
 ):
     """Show current configuration."""
-    import os
     config = get_config()
     
+    # Use provided format, or fall back to configured output_format
+    display_format = format if format else config.output_format
+    
     config_data = {
         "gateway_url": config.gateway_url,
         "keycloak_url": config.keycloak_url,
@@ -25,13 +27,12 @@ def show(
         "authenticated": "Yes" if config.is_authenticated() else "No",
         "config_file": config.config_file,
         "output_format": config.output_format,
-        "env_gateway_url": os.getenv("AF_GATEWAY_URL", "Not set"),
-        "env_keycloak_url": os.getenv("AF_KEYCLOAK_URL", "Not set"),
+        "page_size": config.page_size,
     }
     
     print_output(
         config_data,
-        format_type=format,
+        format_type=display_format,
         title="Configuration"
     )
 
@@ -44,15 +45,20 @@ def set(
     """Set configuration value."""
     config = get_config()
     
+    # Note: tenant_id is not settable - it comes from authentication
     valid_keys = {
         "gateway_url": "gateway_url",
-        "tenant_id": "tenant_id",
+        "keycloak_url": "keycloak_url",
         "output_format": "output_format",
+        "page_size": "page_size",
     }
     
     if key not in valid_keys:
         error(f"Invalid configuration key: {key}")
         error(f"Valid keys: {', '.join(valid_keys.keys())}")
+        if key == "tenant_id":
+            error("Note: tenant_id cannot be set manually. It comes from authentication.")
+            error("Run 'afctl auth login' to authenticate with a specific tenant.")
         raise typer.Exit(1)
     
     # Set the value
@@ -69,27 +75,46 @@ def get(
     """Get configuration value."""
     config = get_config()
     
+    # All readable config keys
     valid_keys = {
         "gateway_url": "gateway_url",
+        "keycloak_url": "keycloak_url",
+        "keycloak_realm": "keycloak_realm",
+        "keycloak_client_id": "keycloak_client_id",
         "tenant_id": "tenant_id",
         "output_format": "output_format",
+        "page_size": "page_size",
+        "config_file": "config_file",
+        "verbose": "verbose",
+        "authenticated": "is_authenticated",  # Special: calls method
     }
     
     if key not in valid_keys:
         error(f"Invalid configuration key: {key}")
-        error(f"Valid keys: {', '.join(valid_keys.keys())}")
+        error(f"Valid keys: {', '.join(sorted(valid_keys.keys()))}")
         raise typer.Exit(1)
     
-    value = getattr(config, valid_keys[key])
-    info(f"{key}: {value}")
+    # Handle special keys that are methods
+    if key == "authenticated":
+        value = "Yes" if config.is_authenticated() else "No"
+    else:
+        value = getattr(config, valid_keys[key])
+    
+    # Display value
+    if value is None:
+        info(f"{key}: (not set)")
+    else:
+        info(f"{key}: {value}")
 
 
 @app.command()
-def reset():
+def reset(
+    yes: bool = typer.Option(False, "--yes", help="Skip confirmation"),
+):
     """Reset configuration to defaults."""
     config = get_config()
     
-    if not typer.confirm("Are you sure you want to reset configuration to defaults?"):
+    if not yes and not typer.confirm("Are you sure you want to reset configuration to defaults?"):
         info("Reset cancelled")
         return
     
@@ -100,6 +125,7 @@ def reset():
     config.gateway_url = "https://dashboard.agenticfabriq.com"
     config.tenant_id = None
     config.output_format = "table"
+    config.page_size = 20
     
     config.save()
     

{agentic_fabriq_sdk-0.1.23 → agentic_fabriq_sdk-0.1.25}/af_cli/commands/tools.py

@@ -14,14 +14,105 @@ app = typer.Typer(help="Tool management commands")
 @app.command()
 def list(
     format: str = typer.Option("table", "--format", help="Output format"),
+    page: int = typer.Option(1, "--page", help="Page number (starts from 1)", min=1),
+    page_size: int = typer.Option(None, "--page-size", help="Number of items per page (1-100). When specified, becomes the new default.", min=1, max=100),
+    search: str = typer.Option(None, "--search", help="Search query (searches tool IDs from registry like 'gmail', 'slack', and user connection names)"),
+    tool_filter: str = typer.Option(None, "--tool", help="Filter by tool type from registry (e.g., 'gmail' shows Gmail connections, 'google' shows all Google tools)"),
 ):
-    """List your tool connections (configured and connected tools)."""
+    """List your tool connections (configured and connected tools).
+
+    The command supports pagination and search to help you navigate large numbers
+    of connections efficiently.
+
+    Examples:
+      # List all connections (default: page 1, 20 per page)
+      afctl tools list
+
+      # List first page with 10 items per page
+      afctl tools list --page 1 --page-size 10
+
+      # Search for tool types (exact match against registry - shows all connections of that type)
+      afctl tools list --search gmail     # Shows all Gmail connections
+      afctl tools list --search google    # Shows all Google Workspace tools
+      afctl tools list --search slack     # Shows all Slack connections
+      afctl tools list --search notion    # Shows all Notion connections
+      afctl tools list --search github    # Shows all GitHub connections
+
+      # Filter by tool type (shows all connections of that tool)
+      afctl tools list --tool gmail       # Shows all Gmail connections
+      afctl tools list --tool google      # Shows all Google Workspace tools
+      afctl tools list --tool slack       # Shows all Slack connections
+
+      # Search and paginate together
+      afctl tools list --search google --page 1 --page-size 5
+
+      # Find connections by name (fallback search)
+      afctl tools list --search work      # Connections with "work" in name
+      afctl tools list --search personal # Connections with "personal" in name
+
+      # Combined search and filtering (AND logic - must match both)
+      afctl tools list --tool google --search gmail     # Google tools containing "gmail"
+      afctl tools list --search drive --tool google     # Google tools with "drive"
+      afctl tools list --search team --tool slack       # Slack connections with "team"
+
+    Pagination:
+      - Pages start from 1
+      - Page size range: 1-100 items
+      - Shows helpful tips when more results are available
+
+    Search:
+      - **Primary**: Searches available tool IDs from registry (e.g., "gmail" matches "gmail", "google" matches "google_drive")
+      - **Secondary**: Searches user connection IDs and display names (e.g., "gmail" matches "gmail_work")
+      - Case-insensitive matching
+      - Shows all connections matching the search criteria
+
+    Tool Filtering:
+      - Filters by tool type from connector registry
+      - Shows all user connections for that tool type
+      - "google" shows all Google Workspace tools (Drive, Docs, Sheets, Gmail, etc.)
+      - "gmail" shows only Gmail connections
+      - "slack" shows only Slack connections
+      - Combines with search and pagination
+    """
     try:
+        from af_cli.core.config import get_config
+        config = get_config()
+        
+        # Use provided page_size, or fall back to configured default
+        if page_size is None:
+            page_size = config.page_size
+        else:
+            # Save the new page_size as default
+            config.page_size = page_size
+            config.save()
+        
         with get_client() as client:
-            connections = client.get("/api/v1/user-connections")
+            # Build query parameters - always include all params for clarity
+            params = {
+                "page": page,
+                "page_size": page_size,
+            }
+            if search:
+                params["search"] = search
+            if tool_filter:
+                params["tool_filter"] = tool_filter
             
+            debug(f"Requesting connections with params: {params}")
+            connections = client.get("/api/v1/user-connections", params=params)
+            
+            debug(f"Received {len(connections) if connections else 0} connections from API")
+
             if not connections:
-                warning("No tool connections found. Add connections in the dashboard UI.")
+                if page > 1:
+                    # User requested a page beyond available data
+                    error(f"Page {page} is out of range.")
+                    info(f"Try 'afctl tools list --page 1' to see available connections.")
+                    if search or tool_filter:
+                        info(f"Or adjust your search/filter criteria to see more results.")
+                elif search or tool_filter:
+                    warning(f"No tool connections found matching your criteria. Try adjusting your search or filter.")
+                else:
+                    warning("No tool connections found. Add connections in the dashboard UI.")
                 return
             
             # Format for better display
@@ -42,11 +133,37 @@ def list(
                     "Added": conn.get("created_at", "N/A")[:10] if conn.get("created_at") else "N/A",
                 })
             
+            # Show pagination and filter info
+            total_info = ""
+            if page != 1 or page_size != 20 or search or tool_filter:
+                total_info = f" (Page {page}, {len(connections)} shown"
+                if search:
+                    total_info += f", Search: '{search}'"
+                if tool_filter:
+                    total_info += f", Tool: '{tool_filter}'"
+                total_info += ")"
+            
+            # Add summary info if filters are active
+            if search or tool_filter:
+                filter_parts = []
+                if search:
+                    filter_parts.append(f"search='{search}'")
+                if tool_filter:
+                    filter_parts.append(f"tool='{tool_filter}'")
+                info(f"🔍 Filtered results: {' AND '.join(filter_parts)}")
+
             print_output(
                 display_data,
                 format_type=format,
-                title="Your Tool Connections"
+                title=f"Your Tool Connections{total_info}"
             )
+
+            # Show helpful tips for pagination
+            if len(connections) == page_size:
+                info(f"💡 Showing {len(connections)} results. Use --page {page + 1} to see more results")
+            
+            if not search and not tool_filter:
+                info(f"💡 Tip: Use --search <term> to search, or --tool <type> to filter by tool type")
             
     except Exception as e:
         error(f"Failed to list tool connections: {e}")
@@ -215,6 +332,12 @@ def add(
       # Google (oauth3 method - uses platform OAuth, no credentials needed)
       afctl tools add google_drive --connection-id google-work --method oauth3
       
+      # Slack (oauth3 method - uses platform OAuth, no credentials needed)
+      afctl tools add slack --connection-id slack-work --method oauth3
+      
+      # Notion (oauth3 method - uses platform OAuth, no credentials needed)
+      afctl tools add notion --connection-id notion-work --method oauth3
+      
       # Google (api_credentials method - your own OAuth app)
       afctl tools add google_drive --connection-id google-work --method api_credentials \\
         --client-id "123.apps.googleusercontent.com" \\
@@ -254,10 +377,10 @@ def add(
                 error("Method must be 'api_credentials', 'oauth3', or 'oauth'")
                 raise typer.Exit(1)
             
-            # Validate oauth3 method is only for Google tools
+            # Validate oauth3 method is only for Google, Slack, and Notion tools
             if method == "oauth3":
-                if not (tool.startswith("google_") or tool == "gmail"):
-                    error("oauth3 method is only available for Google Workspace tools")
+                if not (tool.startswith("google_") or tool == "gmail" or tool == "slack" or tool == "notion"):
+                    error("oauth3 method is only available for Google Workspace tools, Slack, and Notion")
                     info("For other tools, use 'api_credentials' method")
                     raise typer.Exit(1)
             
@@ -297,7 +420,7 @@ def add(
                 # OAuth3 uses platform credentials - no need to store user credentials
                 success("✅ Connection configured with platform OAuth")
                 info("")
-                info(f"Next: Run 'afctl tools connect {connection_id}' to authenticate with your Google account")
+                info(f"Next: Run 'afctl tools connect {connection_id}' to authenticate")
             
             elif method == "api_credentials":
                 # Determine the API base tool name (Google tools all use "google")
@@ -369,6 +492,7 @@ def add(
 @app.command()
 def connect(
     connection_id: str = typer.Argument(..., help="Connection ID to connect"),
+    yes: bool = typer.Option(False, "--yes", help="Skip confirmation when reconnecting"),
 ):
     """Complete OAuth connection (open browser for authorization)."""
     try:
@@ -396,18 +520,26 @@ def connect(
             # Check if connection is already set up (has credentials stored)
             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
+                if not yes:
+                    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" for API credentials, "google_oauth" for oauth3
+            # - Notion uses "notion" for API credentials, "notion_oauth" for oauth3
+            if tool.startswith("google_") or tool == "gmail":
+                api_tool_name = "google_oauth" if method == "oauth3" else "google"
+            elif tool == "notion":
+                api_tool_name = "notion_oauth" if method == "oauth3" else "notion"
+            else:
+                api_tool_name = 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 ""
+            tool_type_param = f"&tool_type={tool}" if (tool.startswith("google_") or tool == "gmail") else ""
             
             # For oauth3 method, pass the method parameter to use platform credentials
             method_param = f"&method={method}" if method == "oauth3" else ""

{agentic_fabriq_sdk-0.1.23 → agentic_fabriq_sdk-0.1.25}/af_cli/core/client.py

@@ -63,7 +63,12 @@ class AFClient:
     def get(self, path: str, params: Optional[Dict] = None) -> Dict[str, Any]:
         """Make GET request."""
         url = urljoin(self.config.gateway_url, path)
-        debug(f"GET {url}")
+        if params:
+            # Show params in debug output
+            param_str = "&".join(f"{k}={v}" for k, v in params.items())
+            debug(f"GET {url}?{param_str}")
+        else:
+            debug(f"GET {url}")
         
         response = self.client.get(
             path,

{agentic_fabriq_sdk-0.1.23 → agentic_fabriq_sdk-0.1.25}/af_cli/core/config.py

@@ -13,7 +13,7 @@ from pydantic import BaseModel, Field
 class CLIConfig(BaseModel):
     """CLI configuration model."""
     
-    # Gateway settings (support environment variable override)
+        # Gateway settings (support environment variable override)
     gateway_url: str = Field(
         default_factory=lambda: os.getenv("AF_GATEWAY_URL", "https://dashboard.agenticfabriq.com"),
         description="Gateway URL"
@@ -39,6 +39,7 @@ class CLIConfig(BaseModel):
     config_file: str = Field(default="", description="Configuration file path")
     verbose: bool = Field(default=False, description="Verbose output")
     output_format: str = Field(default="table", description="Output format (table, json, yaml)")
+    page_size: int = Field(default=20, description="Default page size for list commands")
     
     def __init__(self, **data):
         super().__init__(**data)

{agentic_fabriq_sdk-0.1.23 → agentic_fabriq_sdk-0.1.25}/af_cli/main.py

@@ -12,8 +12,6 @@ from rich.table import Table
 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
-from af_cli.commands.mcp_servers import app as mcp_servers_app
-from af_cli.commands.secrets import app as secrets_app
 from af_cli.commands.tools import app as tools_app
 from af_cli.core.config import get_config
 from af_cli.core.output import success, error, info
@@ -31,8 +29,6 @@ app.add_typer(auth_app, name="auth", help="Authentication commands")
 app.add_typer(config_app, name="config", help="Configuration 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")
-app.add_typer(secrets_app, name="secrets", help="Secret management commands")
 
 
 @app.command()
@@ -92,19 +88,19 @@ def init(
         "--tenant-id",
         help="Tenant ID"
     ),
-    force: bool = typer.Option(
+    yes: bool = typer.Option(
         False,
-        "--force",
-        help="Force initialization, overwrite existing config"
+        "--yes",
+        help="Skip confirmation and overwrite existing config"
     ),
 ):
     """Initialize CLI configuration."""
     config = get_config()
     
     # Check if config exists
-    if os.path.exists(config.config_file) and not force:
+    if os.path.exists(config.config_file) and not yes:
         error(f"Configuration already exists at {config.config_file}")
-        error("Use --force to overwrite")
+        error("Use --yes to overwrite")
         raise typer.Exit(1)
     
     # Create config directory if it doesn't exist
@@ -152,7 +148,7 @@ def main(
     """
     Agentic Fabric CLI - Manage your connectivity hub.
     
-    The CLI provides commands for managing agents, tools, MCP servers, and secrets
+    The CLI provides commands for managing tool connections and applications
     in your Agentic Fabric deployment.
     """
     # Configure global options

{agentic_fabriq_sdk-0.1.23 → agentic_fabriq_sdk-0.1.25}/af_sdk/auth/oauth.py

@@ -47,6 +47,9 @@ def oauth_required(*, scopes: List[str], refresh_if_expired: bool = True):
                     refresh_if_expired=refresh_if_expired,
                 )
 
+                # Log token info (first 20 chars for debugging)
+                ctx.logger.info(f"OAuth decorator injecting token for {tool_id}: {token[:20]}...")
+
                 # Inject Authorization header
                 headers = kwargs.setdefault("headers", {})
                 headers.setdefault("Authorization", f"Bearer {token}")

{agentic_fabriq_sdk-0.1.23 → agentic_fabriq_sdk-0.1.25}/af_sdk/connectors/__init__.py

@@ -7,7 +7,6 @@ from .base import (
     BaseConnector,
     ConnectorContext,
     HTTPConnectorMixin,
-    MCPConnector,
     ToolConnector,
 )
 from .registry import ConnectorRegistry
@@ -16,7 +15,6 @@ __all__ = [
     "BaseConnector",
     "ToolConnector",
     "AgentConnector",
-    "MCPConnector",
     "ConnectorContext",
     "HTTPConnectorMixin",
     "ConnectorRegistry",

{agentic_fabriq_sdk-0.1.23 → agentic_fabriq_sdk-0.1.25}/af_sdk/connectors/base.py

@@ -105,7 +105,7 @@ class ToolConnector(BaseConnector):
 
 
 class AgentConnector(BaseConnector):
-    """Base class for agent connectors that speak A2A or MCP."""
+    """Base class for agent connectors that speak A2A."""
 
     AGENT_ID: str = ""
 
@@ -144,47 +144,6 @@ class AgentConnector(BaseConnector):
         return True
 
 
-class MCPConnector(BaseConnector):
-    """Base class for MCP (Model Context Protocol) connectors."""
-
-    MCP_VERSION: str = "1.0"
-    SERVER_NAME: str = ""
-
-    def __init__(self, ctx: ConnectorContext):
-        super().__init__(ctx)
-        if not self.SERVER_NAME:
-            raise ConnectorError("SERVER_NAME must be set in MCP connector subclass")
-
-    @abc.abstractmethod
-    async def list_tools(self) -> list[Dict[str, Any]]:
-        """List available tools from the MCP server."""
-        pass
-
-    @abc.abstractmethod
-    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Any:
-        """Call a specific tool on the MCP server."""
-        pass
-
-    async def invoke(self, method: str, **kwargs) -> Any:
-        """Generic invoke method for MCP connectors."""
-        if method == "list_tools":
-            return await self.list_tools()
-        elif method == "call_tool":
-            return await self.call_tool(
-                kwargs.get("tool_name", ""), kwargs.get("arguments", {})
-            )
-        else:
-            raise ConnectorError(f"Unknown method: {method}")
-
-    async def get_server_info(self) -> Dict[str, Any]:
-        """Get MCP server information."""
-        return {
-            "name": self.SERVER_NAME,
-            "version": self.MCP_VERSION,
-            "tools": await self.list_tools(),
-        }
-
-
 class HTTPConnectorMixin:
     """Mixin for connectors that make HTTP requests."""
 
@@ -204,10 +163,18 @@ class HTTPConnectorMixin:
         url = f"{self.base_url.rstrip('/')}/{path.lstrip('/')}"
         request_headers = {**self.default_headers, **(headers or {})}
 
+        # Log request details for debugging
+        auth_header = request_headers.get("Authorization", "")
+        auth_preview = f"{auth_header[:30]}..." if auth_header else "None"
+        self.logger.info(f"[HTTP Request] {method} {url}")
+        self.logger.info(f"[HTTP Request] Authorization: {auth_preview}")
+        self.logger.info(f"[HTTP Request] Headers: {list(request_headers.keys())}")
+
         try:
             response = await self.session.request(
                 method, url, headers=request_headers, **kwargs
             )
+            self.logger.info(f"[HTTP Response] Status: {response.status_code}")
             response.raise_for_status()
             return response
         except httpx.HTTPError as e:

{agentic_fabriq_sdk-0.1.23 → agentic_fabriq_sdk-0.1.25}/af_sdk/dx/__init__.py

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

{agentic_fabriq_sdk-0.1.23 → agentic_fabriq_sdk-0.1.25}/af_sdk/dx/runtime.py

@@ -40,25 +40,3 @@ class ToolFabric:
             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.23 → agentic_fabriq_sdk-0.1.25}/af_sdk/fabriq_client.py

@@ -3,7 +3,6 @@ FabriqClient: High-level async helper for Agentic Fabric Gateway.
 
 This client wraps common Gateway API flows so agent developers can:
 - List and invoke tools
-- Register and invoke MCP servers (via proxy)
 - Invoke agents (via proxy)
 - Manage per-user secrets via the Gateway-backed Vault API
 
@@ -120,43 +119,6 @@ class FabriqClient:
         )
         return r.json()
 
-    # -----------------
-    # MCP Servers
-    # -----------------
-    async def register_mcp_server(
-        self,
-        *,
-        name: str,
-        base_url: str,
-        description: Optional[str] = None,
-        auth_type: str = "API_KEY",
-        source: str = "STATIC",
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        body: Dict[str, Any] = {
-            "name": name,
-            "base_url": base_url,
-            "auth_type": auth_type,
-            "source": source,
-        }
-        if description is not None:
-            body["description"] = description
-        if metadata is not None:
-            body["metadata"] = metadata
-        r = await self._http.post("/mcp/servers", json=body, headers=self._extra_headers)
-        return r.json()
-
-    async def list_mcp_servers(self, *, page: int = 1, page_size: int = 20, search: Optional[str] = None) -> Dict[str, Any]:
-        params: Dict[str, Any] = {"page": page, "page_size": page_size}
-        if search:
-            params["search"] = search
-        r = await self._http.get("/mcp/servers", params=params, headers=self._extra_headers)
-        return r.json()
-
-    async def invoke_mcp(self, *, server_id: str, payload: Dict[str, Any], raw: bool = False) -> Dict[str, Any]:
-        r = await self._http.post(f"/proxy/mcp/{server_id}/invoke", json={"payload": payload, "raw": raw}, headers=self._extra_headers)
-        return r.json()
-
     # -----------------
     # Secrets (Gateway-backed Vault)
     # -----------------

{agentic_fabriq_sdk-0.1.23 → agentic_fabriq_sdk-0.1.25}/af_sdk/models/__init__.py

@@ -5,8 +5,6 @@ Data models for Agentic Fabric SDK.
 from .types import (
     ErrorResponse,
     HealthResponse,
-    McpServer,
-    McpServerCreate,
     MetricsResponse,
     OAuthToken,
     PaginatedResponse,
@@ -24,8 +22,6 @@ __all__ = [
     "Tool",
     "ToolInvokeRequest",
     "ToolInvokeResult",
-    "McpServer",
-    "McpServerCreate",
     "Secret",
     "SecretMetadata",
     "SecretPutRequest",

{agentic_fabriq_sdk-0.1.23 → agentic_fabriq_sdk-0.1.25}/af_sdk/models/types.py

@@ -75,28 +75,6 @@ class ToolInvokeResult(BaseModel):
     headers: Dict[str, str] = Field(default_factory=dict)
 
 
-class McpServer(BaseModel):
-    """MCP Server model."""
-
-    id: UUID
-    base_url: str
-    auth_type: str = Field(description="One of: API_KEY, MTLS, OIDC")
-    source: str = Field(description="One of: STATIC, DISCOVERED, SLACK, CONFIG")
-    tenant_id: str
-    metadata: Dict[str, Any] = Field(default_factory=dict)
-    created_at: datetime
-    updated_at: datetime
-
-
-class McpServerCreate(BaseModel):
-    """Request model for creating an MCP server."""
-
-    base_url: str
-    auth_type: str = Field(description="One of: API_KEY, MTLS, OIDC")
-    source: str = Field(description="One of: STATIC, DISCOVERED, SLACK, CONFIG")
-    metadata: Dict[str, Any] = Field(default_factory=dict)
-
-
 class Secret(BaseModel):
     """Secret model."""
 

{agentic_fabriq_sdk-0.1.23 → agentic_fabriq_sdk-0.1.25}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "agentic-fabriq-sdk"
-version = "0.1.23"
+version = "0.1.25"
 description = "Agentic Fabriq SDK: high-level client, CLI tool, DX helpers, and auth for AI agents"
 readme = "README.md"
 license = "Apache-2.0"

agentic_fabriq_sdk-0.1.23/af_cli/__init__.py

@@ -1,8 +0,0 @@
-"""
-Agentic Fabric CLI Tool
-
-A command-line interface for managing Agentic Fabric resources including
-agents, tools, MCP servers, and administrative operations.
-"""
-
-__version__ = "1.0.0" 

agentic_fabriq_sdk-0.1.23/af_cli/commands/mcp_servers.py

@@ -1,83 +0,0 @@
-"""
-MCP server 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
-
-app = typer.Typer(help="MCP server management commands")
-
-
-@app.command()
-def list(
-    format: str = typer.Option("table", "--format", help="Output format"),
-):
-    """List MCP servers."""
-    try:
-        with get_client() as client:
-            response = client.get("/api/v1/mcp-servers")
-            servers = response["servers"]
-            
-            if not servers:
-                warning("No MCP servers found")
-                return
-            
-            print_output(
-                servers,
-                format_type=format,
-                title="MCP Servers"
-            )
-            
-    except Exception as e:
-        error(f"Failed to list MCP servers: {e}")
-        raise typer.Exit(1)
-
-
-@app.command()
-def get(
-    server_id: str = typer.Argument(..., help="MCP server ID"),
-    format: str = typer.Option("table", "--format", help="Output format"),
-):
-    """Get MCP server details."""
-    try:
-        with get_client() as client:
-            server = client.get(f"/api/v1/mcp-servers/{server_id}")
-            
-            print_output(
-                server,
-                format_type=format,
-                title=f"MCP Server {server_id}"
-            )
-            
-    except Exception as e:
-        error(f"Failed to get MCP server: {e}")
-        raise typer.Exit(1)
-
-
-@app.command()
-def create(
-    name: str = typer.Option(..., "--name", help="MCP server name"),
-    base_url: str = typer.Option(..., "--base-url", help="Base URL"),
-    auth_type: str = typer.Option("API_KEY", "--auth-type", help="Authentication type"),
-):
-    """Create a new MCP server."""
-    try:
-        with get_client() as client:
-            data = {
-                "name": name,
-                "base_url": base_url,
-                "auth_type": auth_type,
-                "source": "STATIC",
-            }
-            
-            server = client.post("/api/v1/mcp-servers", data)
-            
-            success(f"MCP server created: {server['id']}")
-            info(f"Name: {server['name']}")
-            info(f"Base URL: {server['base_url']}")
-            
-    except Exception as e:
-        error(f"Failed to create MCP server: {e}")
-        raise typer.Exit(1) 

agentic_fabriq_sdk-0.1.23/af_cli/commands/secrets.py

@@ -1,109 +0,0 @@
-"""
-Secret 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
-
-app = typer.Typer(help="Secret management commands")
-
-
-@app.command()
-def get(
-    path: str = typer.Argument(..., help="Secret path"),
-    format: str = typer.Option("table", "--format", help="Output format"),
-):
-    """Get a secret."""
-    try:
-        with get_client() as client:
-            secret = client.get(f"/api/v1/secrets/{path}")
-            
-            # Don't display the actual secret value in table format
-            if format == "table":
-                display_data = {
-                    "path": secret["path"],
-                    "description": secret.get("description", ""),
-                    "version": secret["version"],
-                    "created_at": secret["created_at"],
-                    "updated_at": secret["updated_at"],
-                }
-                print_output(display_data, format_type=format, title=f"Secret {path}")
-                info("Use --format=json to see the secret value")
-            else:
-                print_output(secret, format_type=format)
-            
-    except Exception as e:
-        error(f"Failed to get secret: {e}")
-        raise typer.Exit(1)
-
-
-@app.command()
-def create(
-    path: str = typer.Argument(..., help="Secret path"),
-    value: str = typer.Option(..., "--value", help="Secret value"),
-    description: str = typer.Option("", "--description", help="Secret description"),
-):
-    """Create a new secret."""
-    try:
-        with get_client() as client:
-            data = {
-                "value": value,
-                "description": description,
-            }
-            
-            secret = client.post(f"/api/v1/secrets/{path}", data)
-            
-            success(f"Secret created: {secret['path']}")
-            info(f"Version: {secret['version']}")
-            
-    except Exception as e:
-        error(f"Failed to create secret: {e}")
-        raise typer.Exit(1)
-
-
-@app.command()
-def update(
-    path: str = typer.Argument(..., help="Secret path"),
-    value: str = typer.Option(..., "--value", help="Secret value"),
-    description: str = typer.Option("", "--description", help="Secret description"),
-):
-    """Update a secret."""
-    try:
-        with get_client() as client:
-            data = {
-                "value": value,
-                "description": description,
-            }
-            
-            secret = client.put(f"/api/v1/secrets/{path}", data)
-            
-            success(f"Secret updated: {secret['path']}")
-            info(f"Version: {secret['version']}")
-            
-    except Exception as e:
-        error(f"Failed to update secret: {e}")
-        raise typer.Exit(1)
-
-
-@app.command()
-def delete(
-    path: str = typer.Argument(..., help="Secret path"),
-    force: bool = typer.Option(False, "--force", help="Force deletion"),
-):
-    """Delete a secret."""
-    try:
-        if not force:
-            if not typer.confirm(f"Are you sure you want to delete secret {path}?"):
-                info("Deletion cancelled")
-                return
-        
-        with get_client() as client:
-            client.delete(f"/api/v1/secrets/{path}")
-            
-            success(f"Secret deleted: {path}")
-            
-    except Exception as e:
-        error(f"Failed to delete secret: {e}")
-        raise typer.Exit(1)