agentic-fabriq-sdk 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

af_cli/commands/tools.py

@@ -13,7 +13,7 @@ app = typer.Typer(help="Tool management commands")
 
 @app.command()
 def list(
-    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+    format: str = typer.Option("table", "--format", help="Output format"),
 ):
     """List your tool connections (configured and connected tools)."""
     try:
@@ -56,7 +56,7 @@ def list(
 @app.command()
 def get(
     connection_id: str = typer.Argument(..., help="Connection ID (e.g., 'google', 'slack')"),
-    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+    format: str = typer.Option("table", "--format", help="Output format"),
 ):
     """Get tool connection details."""
     try:
@@ -121,24 +121,98 @@ def get(
 
 @app.command()
 def invoke(
-    tool_id: str = typer.Argument(..., help="Tool ID"),
-    method: str = typer.Option(..., "--method", "-m", help="Tool method to invoke"),
-    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+    tool_identifier: str = typer.Argument(..., help="Tool name (e.g., 'slack') or UUID"),
+    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."""
+    """Invoke a tool by name or UUID.
+    
+    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
+    """
     try:
+        # Parse parameters if provided
+        parameters = {}
+        if params:
+            import json as json_lib
+            try:
+                parameters = json_lib.loads(params)
+            except json_lib.JSONDecodeError as e:
+                error(f"Invalid JSON in --params: {e}")
+                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)
+            
             data = {
                 "method": method,
-                "parameters": {},
+                "parameters": parameters,
                 "context": {},
             }
             
-            info(f"Invoking tool {tool_id} method {method}...")
+            info(f"Invoking tool {tool_identifier} method {method}...")
             response = client.post(f"/api/v1/tools/{tool_id}/invoke", data)
             
             success("Tool invoked successfully")
-            print_output(response, format_type=format)
+            
+            # For tool invocations, show the result in a more readable format
+            if format == "json":
+                import json as json_lib
+                print(json_lib.dumps(response, indent=2))
+            elif format == "yaml":
+                import yaml
+                print(yaml.dump(response, default_flow_style=False))
+            else:
+                # For table format, show just the result field nicely
+                result = response.get("result", {})
+                print("\n📊 Result:")
+                print_output(result, format_type="json")
             
     except Exception as e:
         error(f"Failed to invoke tool: {e}")
@@ -150,30 +224,28 @@ 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)"),
+    method: str = typer.Option(..., "--method", help="Connection method: 'api_credentials' or 'oauth'"),
     
-    # 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)"),
+    # API credentials method fields (can be either a token OR client_id/secret)
+    token: str = typer.Option(None, "--token", help="API token (for simple token-based auth like Notion, Slack bot)"),
+    client_id: str = typer.Option(None, "--client-id", help="OAuth client ID (for app-based auth like Google, Slack)"),
+    client_secret: str = typer.Option(None, "--client-secret", help="OAuth client secret (for app-based auth)"),
     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"
+      # Notion (api_credentials method - single token)
+      afctl tools add notion --connection-id notion-work --method api_credentials --token "secret_abc123"
       
-      # Google (credentials method - OAuth app)
-      afctl tools add google --connection-id google-work --method credentials \\
+      # Google (api_credentials method - OAuth app)
+      afctl tools add google_drive --connection-id google-work --method api_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..."
+      # Slack bot (api_credentials method - single token)
+      afctl tools add slack --connection-id slack-bot --method api_credentials --token "xoxb-123..."
     """
     try:
         from af_cli.core.config import get_config
@@ -202,23 +274,24 @@ def add(
                 raise typer.Exit(1)
             
             # Validate method
-            if method not in ["api", "credentials", "oauth"]:
-                error("Method must be 'api', 'credentials', or 'oauth'")
+            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")
+            # Validate api_credentials method requirements
+            if method == "api_credentials":
+                # Must have either token OR (client_id + client_secret)
+                has_token = bool(token)
+                has_oauth_creds = bool(client_id and client_secret)
+                
+                if not has_token and not has_oauth_creds:
+                    error("api_credentials method requires either:")
+                    info("  • --token (for simple token auth like Notion, Slack bot)")
+                    info("  • --client-id and --client-secret (for OAuth app auth like Google)")
+                    info("")
+                    info(f"Examples:")
+                    info(f"  afctl tools add {tool} --connection-id {connection_id} --method api_credentials --token YOUR_TOKEN")
+                    info(f"  afctl tools add {tool} --connection-id {connection_id} --method api_credentials --client-id ID --client-secret SECRET")
                     raise typer.Exit(1)
             
             info(f"Creating connection: {connection_id}")
@@ -236,51 +309,59 @@ def add(
             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":
+            # Step 2: Store credentials based on what was provided
+            if method == "api_credentials":
                 # 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!")
+                if token:
+                    # Simple token-based auth (Notion, Slack bot, etc.)
+                    info("Storing API token...")
+                    
+                    # 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 token stored")
+                    success(f"✅ Connection '{connection_id}' is ready to use!")
+                    
+                elif client_id and client_secret:
+                    # OAuth app credentials (Google, Slack app, etc.)
+                    # 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 == "oauth":
+                # OAuth flow (legacy, redirect to api_credentials)
+                error("The 'oauth' method is deprecated. Please use 'api_credentials' instead.")
+                info("All credential storage now uses the 'api_credentials' method.")
+                raise typer.Exit(1)
             
             # Show helpful info
             info("")
@@ -320,14 +401,7 @@ def connect(
             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
+            # 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)?")
@@ -413,7 +487,7 @@ def connect(
 @app.command()
 def disconnect(
     connection_id: str = typer.Argument(..., help="Connection ID to disconnect"),
-    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+    force: bool = typer.Option(False, "--force", help="Skip confirmation"),
 ):
     """Disconnect a tool (remove credentials but keep connection entry)."""
     try:
@@ -466,7 +540,7 @@ def disconnect(
 @app.command()
 def remove(
     connection_id: str = typer.Argument(..., help="Connection ID to remove"),
-    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+    force: bool = typer.Option(False, "--force", help="Skip confirmation"),
 ):
     """Remove a tool connection completely (delete entry and credentials)."""
     try:

af_cli/main.py

@@ -10,6 +10,7 @@ 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
 from af_cli.commands.mcp_servers import app as mcp_servers_app
@@ -31,6 +32,7 @@ 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")
 app.add_typer(secrets_app, name="secrets", help="Secret management commands")
 
@@ -85,19 +87,16 @@ def init(
     gateway_url: str = typer.Option(
         "https://dashboard.agenticfabriq.com",
         "--gateway-url",
-        "-g",
         help="Gateway URL"
     ),
     tenant_id: Optional[str] = typer.Option(
         None,
         "--tenant-id",
-        "-t",
         help="Tenant ID"
     ),
     force: bool = typer.Option(
         False,
         "--force",
-        "-f",
         help="Force initialization, overwrite existing config"
     ),
 ):
@@ -134,25 +133,21 @@ def main(
     config_file: Optional[str] = typer.Option(
         None,
         "--config",
-        "-c",
         help="Path to configuration file"
     ),
     gateway_url: Optional[str] = typer.Option(
         None,
         "--gateway-url",
-        "-g",
         help="Gateway URL"
     ),
     tenant_id: Optional[str] = typer.Option(
         None,
         "--tenant-id",
-        "-t",
         help="Tenant ID"
     ),
     verbose: bool = typer.Option(
         False,
         "--verbose",
-        "-v",
         help="Enable verbose output"
     ),
 ):

af_sdk/__init__.py

@@ -23,6 +23,14 @@ from .models.types import (
 from .transport.http import HTTPClient
 from .fabriq_client import FabriqClient
 from .models.audit import AuditEvent
+from .auth import (
+    get_application_client,
+    load_application_config,
+    save_application_config,
+    list_applications,
+    delete_application_config,
+    ApplicationNotFoundError,
+)
 
 __version__ = "1.0.0"
 
@@ -44,6 +52,13 @@ __all__ = [
     "HTTPClient",
     "FabriqClient",
     "AuditEvent",
+    # Application auth helpers
+    "get_application_client",
+    "load_application_config",
+    "save_application_config",
+    "list_applications",
+    "delete_application_config",
+    "ApplicationNotFoundError",
 ] 
 
 # Lazy expose dx submodule under af_sdk.dx

af_sdk/auth/__init__.py

@@ -11,6 +11,15 @@ from .oauth import (
     TokenValidator,
 )
 from .token_cache import TokenManager, VaultClient
+from .applications import (
+    get_application_client,
+    load_application_config,
+    save_application_config,
+    list_applications,
+    delete_application_config,
+    ApplicationNotFoundError,
+    AuthenticationError,
+)
 
 # DPoP helper will be provided from af_sdk.auth.dpop
 try:
@@ -28,4 +37,11 @@ __all__ = [
     "TokenManager",
     "VaultClient",
     "create_dpop_proof",
+    "get_application_client",
+    "load_application_config",
+    "save_application_config",
+    "list_applications",
+    "delete_application_config",
+    "ApplicationNotFoundError",
+    "AuthenticationError",
 ]