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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-fabriq-sdk
-Version: 0.1.17
+Version: 0.1.18
 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

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

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

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

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

agentic_fabriq_sdk-0.1.18/af_sdk/dx/__init__.py

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

agentic_fabriq_sdk-0.1.18/af_sdk/dx/runtime.py

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

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

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

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

@@ -184,18 +184,6 @@ class FabriqClient:
         r = await self._http.post(f"/proxy/mcp/{server_id}/invoke", json={"payload": payload, "raw": raw}, headers=self._extra_headers)
         return r.json()
 
-    # -----------------
-    # Agents
-    # -----------------
-    async def list_agents(self, *, page: int = 1, page_size: int = 20, sort_by: str = "name", sort_order: str = "asc") -> Dict[str, Any]:
-        params: Dict[str, Any] = {"page": page, "page_size": page_size, "sort_by": sort_by, "sort_order": sort_order}
-        r = await self._http.get("/agents", params=params, headers=self._extra_headers)
-        return r.json()
-
-    async def invoke_agent(self, *, agent_id: str, params: Dict[str, Any], raw: bool = False) -> Dict[str, Any]:
-        r = await self._http.post(f"/proxy/agents/{agent_id}/invoke", json={"params": params, "raw": raw}, headers=self._extra_headers)
-        return r.json()
-
     # -----------------
     # Secrets (Gateway-backed Vault)
     # -----------------

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

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

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

@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "agentic-fabriq-sdk"
-version = "0.1.17"
+version = "0.1.18"
 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.17/af_cli/commands/agents.py

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

agentic_fabriq_sdk-0.1.17/af_sdk/auth/application.py

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

agentic_fabriq_sdk-0.1.17/af_sdk/dx/__init__.py

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

agentic_fabriq_sdk-0.1.17/af_sdk/dx/runtime.py

@@ -1,170 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-import os
-import httpx
-
-
-def _base_headers(token: str, tenant_id: Optional[str]) -> Dict[str, str]:
-    headers = {"Authorization": f"Bearer {token}"}
-    if tenant_id:
-        headers["X-Tenant-Id"] = tenant_id
-    # Dev helper: allow overriding scopes from env for local testing
-    debug_scopes = os.getenv("FABRIQ_DEBUG_SCOPES")
-    if debug_scopes is not None:
-        headers["X-Debug-Scopes"] = debug_scopes
-    return headers
-
-
-class ToolFabric:
-    """Thin facade over Fabriq provider proxy endpoints (e.g., Slack).
-
-    This class lets developers think in terms of a "fabric" of tools provided
-    by a vendor, while under the hood we call the Gateway proxy endpoints.
-    """
-
-    def __init__(self, *, provider: str, base_url: str, access_token: str, tenant_id: Optional[str] = None):
-        self.provider = provider
-        self.base_url = base_url.rstrip("/")
-        self.token = access_token
-        self.tenant_id = tenant_id
-
-    def get_tools(self, names: List[str]) -> List[str]:
-        # Placeholder: simply returns opaque method identifiers as strings the Agent understands
-        return [f"{self.provider}:{name}" for name in names]
-
-    def invoke(self, action: str, params: Dict[str, Any]) -> Dict[str, Any]:
-        url = f"{self.base_url}/api/v1/proxy/{self.provider}/{action}"
-        with httpx.Client(timeout=30.0) as c:
-            r = c.post(url, json=params, headers=_base_headers(self.token, self.tenant_id))
-            r.raise_for_status()
-            return r.json()
-
-
-class MCPServer:
-    """Facade for an MCP server registered in Fabriq (proxy layer)."""
-
-    def __init__(self, *, server_id: str, base_url: str, access_token: str, tenant_id: Optional[str] = None):
-        self.server_id = server_id
-        self.base_url = base_url.rstrip("/")
-        self.token = access_token
-        self.tenant_id = tenant_id
-
-    def get_tools(self, names: List[str]) -> List[str]:
-        return [f"mcp:{self.server_id}:{name}" for name in names]
-
-    def invoke(self, tool: str, args: Dict[str, Any]) -> Dict[str, Any]:
-        url = f"{self.base_url}/api/v1/proxy/mcp/{self.server_id}/invoke"
-        payload = {"payload": {"tool": tool, "args": args}}
-        with httpx.Client(timeout=60.0) as c:
-            r = c.post(url, json=payload, headers=_base_headers(self.token, self.tenant_id))
-            r.raise_for_status()
-            return r.json()
-
-
-class AgentFabric:
-    """Future-facing A2A discovery placeholder.
-
-    Today it simply stores identifiers of other agents by id.
-    """
-
-    def __init__(self, *, base_url: str, access_token: str, tenant_id: Optional[str] = None):
-        self.base_url = base_url.rstrip("/")
-        self.token = access_token
-        self.tenant_id = tenant_id
-
-    def get_agents(self, ids: List[str]) -> List[str]:
-        return ids
-
-    def invoke_agent(self, agent_id: str, input: Dict[str, Any]) -> Dict[str, Any]:
-        url = f"{self.base_url}/api/v1/agents/{agent_id}/invoke"
-        with httpx.Client(timeout=60.0) as c:
-            r = c.post(url, json={"input": input, "context": {}}, headers=_base_headers(self.token, self.tenant_id))
-            r.raise_for_status()
-            return r.json()
-
-
-class Agent:
-    """Minimal orchestrator that can call tools and agents.
-
-    tools: a mixed list of
-      - wrapped local functions decorated with @tool (call directly), or
-      - string references produced by ToolFabric/MCPServer (we route accordingly).
-    agents: a list of agent ids discoverable via AgentFabric.get_agents().
-    """
-
-    def __init__(
-        self,
-        *,
-        system_prompt: str,
-        tools: List[Any],
-        agents: List[str],
-        base_url: str,
-        access_token: str,
-        tenant_id: Optional[str] = None,
-        provider_fabrics: Optional[Dict[str, ToolFabric]] = None,
-        mcp_servers: Optional[Dict[str, MCPServer]] = None,
-        agent_fabric: Optional[AgentFabric] = None,
-    ) -> None:
-        self.system_prompt = system_prompt
-        self.tools = tools
-        self.agents = agents
-        self.base_url = base_url.rstrip("/")
-        self.token = access_token
-        self.tenant_id = tenant_id
-        self.provider_fabrics = provider_fabrics or {}
-        self.mcp_servers = mcp_servers or {}
-        self.agent_fabric = agent_fabric or AgentFabric(base_url=base_url, access_token=access_token, tenant_id=tenant_id)
-
-    def _is_wrapped_tool(self, obj: Any) -> bool:
-        return hasattr(obj, "_af_tool")
-
-    def run(self, instruction: str) -> str:
-        # Super-minimal router: if instruction mentions "slack" and "summary",
-        # fetch recent messages via a slack ToolFabric and send to a summarizer agent.
-        inst = instruction.lower()
-        if "slack" in inst and "summary" in inst:
-            slack: Optional[ToolFabric] = self.provider_fabrics.get("slack")
-            if not slack:
-                return "No slack ToolFabric configured."
-            # Find a channel id (prefer env, else pick first from channels.list)
-            channel_id = os.getenv("SLACK_DEFAULT_CHANNEL")
-            if not channel_id:
-                try:
-                    ch_resp = slack.invoke("channels.list", {})
-                    channels = (ch_resp.get("channels") or ch_resp.get("items") or [])
-                    if channels:
-                        channel_id = channels[0].get("id")
-                except Exception:
-                    channel_id = None
-            if not channel_id:
-                return "Could not determine a Slack channel id; set SLACK_DEFAULT_CHANNEL or ensure channels.list works."
-
-            # Fetch messages
-            hist = slack.invoke("conversations.history", {"channel": channel_id, "limit": 50})
-            # Gateway proxy normalizes to { items: [...] }, but also returns provider-shape under raw
-            messages = hist.get("items") or hist.get("messages") or []
-            if not messages:
-                return "No Slack messages available or Slack is not connected. Connect Slack in the UI (Tools tab) for the active tenant or set SLACK_DEFAULT_CHANNEL."
-            lines = [m.get("text", "").strip() for m in messages if m.get("text")]
-            corpus = "\n".join(lines)
-            # Call first collaborator agent named 'summarizer' if present
-            target = next((a for a in self.agents if a == "summarizer"), None)
-            if not target:
-                return "No summarizer agent configured."
-            result = self.agent_fabric.invoke_agent(target, {"text": corpus})
-            # result shape: { output, metadata, logs, status }
-            return result.get("output") or str(result)
-
-        # Fallback: try local tools if any
-        for t in self.tools:
-            if self._is_wrapped_tool(t):
-                try:
-                    out = t(instruction)  # type: ignore[misc]
-                    if isinstance(out, str) and out:
-                        return out
-                except Exception:
-                    pass
-        return "No handler matched the instruction."
-
-