@toothfairyai/tfcode 1.0.23 → 1.0.25

package/package.json

@@ -1,22 +1,33 @@
 {
   "name": "@toothfairyai/tfcode",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "bin": {
-  "tfcode": "./bin/tfcode.js"
-},
-"scripts": {
-"postinstall": "node ./postinstall.mjs"
-},
-"license": "MIT",
-"optionalDependencies": {
-  "@toothfairyai/tfcode-linux-arm64": "1.0.23",
-  "@toothfairyai/tfcode-linux-x64": "1.0.23",
-  "@toothfairyai/tfcode-darwin-arm64": "1.0.23",
-  "@toothfairyai/tfcode-darwin-x64": "1.0.23",
-  "@toothfairyai/tfcode-windows-x64": "1.0.23"
-},
-"engines": {
-"node": ">=18"
-},
-"homepage": "https://toothfairyai.com/developers/tfcode"
-}
+    "tfcode": "./bin/tfcode.js"
+  },
+  "scripts": {
+    "postinstall": "node ./postinstall.mjs"
+  },
+  "license": "MIT",
+  "optionalDependencies": {
+    "@toothfairyai/tfcode-linux-arm64": "1.0.25",
+    "@toothfairyai/tfcode-windows-x64": "1.0.25",
+    "@toothfairyai/tfcode-linux-x64-baseline-musl": "1.0.25",
+    "@toothfairyai/tfcode-darwin-x64-baseline": "1.0.25",
+    "@toothfairyai/tfcode-linux-x64-musl": "1.0.25",
+    "@toothfairyai/tfcode-windows-x64-baseline": "1.0.25",
+    "@toothfairyai/tfcode-linux-arm64-musl": "1.0.25",
+    "@toothfairyai/tfcode-windows-arm64": "1.0.25",
+    "@toothfairyai/tfcode-linux-x64": "1.0.25",
+    "@toothfairyai/tfcode-darwin-x64": "1.0.25",
+    "@toothfairyai/tfcode-linux-x64-baseline": "1.0.25",
+    "@toothfairyai/tfcode-darwin-arm64": "1.0.25"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://toothfairyai.com/developers/tfcode",
+  "repository": {
+    "type": "git",
+    "url": "https://gitea.toothfairyai.com/ToothFairyAI/tf_code.git"
+  }
+}

package/python/tf_sync/__init__.py

@@ -0,0 +1,21 @@
+"""
+tf-sync: ToothFairyAI workspace sync layer for tfcode
+"""
+
+from tf_sync.agents import sync_agents
+from tf_sync.mcp import sync_mcp_servers
+from tf_sync.tools import sync_tools, ToolType
+from tf_sync.config import TFConfig, load_config, validate_credentials, get_region_urls
+
+__all__ = [
+    "sync_agents",
+    "sync_mcp_servers", 
+    "sync_tools",
+    "ToolType",
+    "TFConfig",
+    "load_config",
+    "validate_credentials",
+    "get_region_urls",
+]
+
+__version__ = "0.1.0"

package/python/tf_sync/agents.py

@@ -0,0 +1,39 @@
+"""
+Agent sync module for tfcode.
+
+NOTE: This module is reserved for future implementation.
+Currently, tfcode only syncs tools (MCP, Skills, Database, Functions).
+Agent sync will be added in a later phase.
+"""
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from tf_sync.config import TFConfig
+
+
+class AgentSyncResult(BaseModel):
+    """Result of agent sync operation."""
+    
+    success: bool
+    agents: list[dict[str, Any]] = []
+    error: str | None = None
+
+
+def sync_agents(config: TFConfig) -> AgentSyncResult:
+    """
+    Sync agents from ToothFairyAI workspace.
+    
+    NOTE: Currently not implemented. Reserved for future use.
+    
+    Args:
+        config: TFConfig instance
+    
+    Returns:
+        AgentSyncResult (currently always returns not implemented)
+    """
+    return AgentSyncResult(
+        success=False,
+        error="Agent sync not yet implemented. Use tools sync for now.",
+    )

package/python/tf_sync/config.py

@@ -0,0 +1,221 @@
+"""
+Configuration management for tfcode ToothFairyAI integration.
+Uses the official ToothFairyAI Python SDK for multi-region support.
+"""
+
+import os
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field, SecretStr
+from toothfairyai import ToothFairyClient
+from toothfairyai.errors import ToothFairyError
+
+
+class Region(str, Enum):
+    DEV = "dev"
+    AU = "au"
+    EU = "eu"
+    US = "us"
+
+
+class ToolType(str, Enum):
+    MCP_SERVER = "mcp_server"
+    AGENT_SKILL = "agent_skill"
+    CODER_AGENT = "coder_agent"
+    DATABASE_SCRIPT = "database_script"
+    API_FUNCTION = "api_function"
+    PROMPT = "prompt"
+
+
+class FunctionRequestType(str, Enum):
+    GET = "get"
+    POST = "post"
+    PUT = "put"
+    DELETE = "delete"
+    PATCH = "patch"
+    CUSTOM = "custom"
+    GRAPHQL_QUERY = "graphql_query"
+    GRAPHQL_MUTATION = "graphql_mutation"
+
+
+# Region-specific URL configurations
+REGION_URLS = {
+    Region.DEV: {
+        "base_url": "https://api.toothfairylab.link",
+        "ai_url": "https://ai.toothfairylab.link",
+        "ai_stream_url": "https://ais.toothfairylab.link",
+        "mcp_url": "https://mcp.toothfairylab.link/sse",
+        "mcp_proxy_url": "https://mcp-proxy.toothfairylab.link",
+    },
+    Region.AU: {
+        "base_url": "https://api.toothfairyai.com",
+        "ai_url": "https://ai.toothfairyai.com",
+        "ai_stream_url": "https://ais.toothfairyai.com",
+        "mcp_url": "https://mcp.toothfairyai.com/sse",
+        "mcp_proxy_url": "https://mcp-proxy.toothfairyai.com",
+    },
+    Region.EU: {
+        "base_url": "https://api.eu.toothfairyai.com",
+        "ai_url": "https://ai.eu.toothfairyai.com",
+        "ai_stream_url": "https://ais.eu.toothfairyai.com",
+        "mcp_url": "https://mcp.eu.toothfairyai.com/sse",
+        "mcp_proxy_url": "https://mcp-proxy.eu.toothfairyai.com",
+    },
+    Region.US: {
+        "base_url": "https://api.us.toothfairyai.com",
+        "ai_url": "https://ai.us.toothfairyai.com",
+        "ai_stream_url": "https://ais.us.toothfairyai.com",
+        "mcp_url": "https://mcp.us.toothfairyai.com/sse",
+        "mcp_proxy_url": "https://mcp-proxy.us.toothfairyai.com",
+    },
+}
+
+
+def get_region_urls(region: Region) -> dict[str, str]:
+    """Get URLs for a specific region."""
+    return REGION_URLS.get(region, REGION_URLS[Region.AU])
+
+
+class TFConfig(BaseModel):
+    """ToothFairyAI workspace configuration."""
+    
+    workspace_id: str
+    api_key: SecretStr
+    region: Region = Region.AU
+    enabled: bool = True
+    
+    sync_interval: int = Field(default=3600, ge=60)
+    mcp_proxy_timeout: int = Field(default=30000, ge=1000)
+    
+    _client: Optional[ToothFairyClient] = None
+    
+    def get_client(self) -> ToothFairyClient:
+        """
+        Get or create a ToothFairyClient instance configured for this region.
+        
+        Returns:
+            ToothFairyClient configured with region-specific URLs
+        """
+        if self._client is None:
+            urls = get_region_urls(self.region)
+            self._client = ToothFairyClient(
+                api_key=self.api_key.get_secret_value(),
+                workspace_id=self.workspace_id,
+                base_url=urls["base_url"],
+                ai_url=urls["ai_url"],
+                ai_stream_url=urls["ai_stream_url"],
+            )
+        return self._client
+    
+    @property
+    def mcp_sse_url(self) -> str:
+        """Get the MCP SSE endpoint URL for this region."""
+        return get_region_urls(self.region)["mcp_url"]
+    
+    @property
+    def mcp_proxy_url(self) -> str:
+        """Get the MCP proxy URL for this region."""
+        return get_region_urls(self.region)["mcp_proxy_url"]
+
+
+class CredentialValidationResult(BaseModel):
+    """Result of credential validation."""
+    success: bool
+    workspace_id: Optional[str] = None
+    workspace_name: Optional[str] = None
+    error: Optional[str] = None
+
+
+def load_config(
+    workspace_id: Optional[str] = None,
+    api_key: Optional[str] = None,
+    region: Optional[Region] = None,
+) -> TFConfig:
+    """
+    Load ToothFairyAI configuration from environment or parameters.
+    
+    Args:
+        workspace_id: Workspace UUID (defaults to TF_WORKSPACE_ID env var)
+        api_key: API key (defaults to TF_API_KEY env var)
+        region: Region (defaults to TF_REGION env var or 'au')
+    
+    Returns:
+        TFConfig instance
+    
+    Raises:
+        ValueError: If required configuration is missing
+    """
+    ws_id = workspace_id or os.environ.get("TF_WORKSPACE_ID")
+    key = api_key or os.environ.get("TF_API_KEY")
+    
+    # Parse region from env or use provided/default
+    region_str = os.environ.get("TF_REGION", "au")
+    reg = region or Region(region_str)
+    
+    if not ws_id:
+        raise ValueError("TF_WORKSPACE_ID not set. Set environment variable or pass workspace_id.")
+    if not key:
+        raise ValueError("TF_API_KEY not set. Set environment variable or pass api_key.")
+    
+    return TFConfig(
+        workspace_id=ws_id,
+        api_key=SecretStr(key),
+        region=reg,
+    )
+
+
+def validate_credentials(config: TFConfig) -> CredentialValidationResult:
+    """
+    Validate ToothFairyAI credentials using the SDK.
+    
+    Args:
+        config: TFConfig instance
+    
+    Returns:
+        CredentialValidationResult indicating success or failure
+    """
+    try:
+        client = config.get_client()
+        
+        # Test connection by listing chats (lightweight operation)
+        if client.test_connection():
+            return CredentialValidationResult(
+                success=True,
+                workspace_id=config.workspace_id,
+                workspace_name="Connected",
+            )
+        else:
+            return CredentialValidationResult(
+                success=False,
+                error="Connection test failed. Check credentials and region.",
+            )
+            
+    except ToothFairyError as e:
+        error_msg = str(e)
+        
+        if "401" in error_msg or "Unauthorized" in error_msg:
+            return CredentialValidationResult(
+                success=False,
+                error="Invalid API key. Check TF_API_KEY environment variable.",
+            )
+        elif "403" in error_msg or "Forbidden" in error_msg:
+            return CredentialValidationResult(
+                success=False,
+                error="API access not allowed. Business or Enterprise subscription required.",
+            )
+        elif "404" in error_msg or "Not Found" in error_msg:
+            return CredentialValidationResult(
+                success=False,
+                error="Workspace not found. Check TF_WORKSPACE_ID environment variable.",
+            )
+        else:
+            return CredentialValidationResult(
+                success=False,
+                error=f"API error: {error_msg}",
+            )
+    except Exception as e:
+        return CredentialValidationResult(
+            success=False,
+            error=f"Unexpected error: {str(e)}",
+        )

package/python/tf_sync/mcp.py

@@ -0,0 +1,41 @@
+"""
+MCP server sync module for tfcode.
+
+NOTE: MCP servers are not currently exposed via the ToothFairyAI SDK.
+This module is reserved for future implementation when MCP server
+discovery is added to the SDK.
+
+For now, MCP servers should be configured manually via tfcode.json.
+"""
+
+from pydantic import BaseModel
+
+from tf_sync.config import TFConfig
+from tf_sync.tools import SyncedTool, ToolType
+
+
+class MCPServerSyncResult(BaseModel):
+    """Result of MCP server sync operation."""
+    
+    success: bool
+    servers: list[SyncedTool] = []
+    error: str | None = None
+
+
+def sync_mcp_servers(config: TFConfig) -> MCPServerSyncResult:
+    """
+    Sync MCP servers from ToothFairyAI workspace.
+    
+    NOTE: Currently not supported. MCP servers are not exposed via the SDK.
+    Configure MCP servers manually in tfcode.json instead.
+    
+    Args:
+        config: TFConfig instance
+    
+    Returns:
+        MCPServerSyncResult with error message
+    """
+    return MCPServerSyncResult(
+        success=False,
+        error="MCP server sync not available via SDK. Configure MCP servers in tfcode.json.",
+    )

package/python/tf_sync/tools.py

@@ -0,0 +1,282 @@
+"""
+Tool sync module for tfcode.
+Syncs tools from ToothFairyAI workspace using the official SDK.
+
+SDK Structure:
+- agent_functions: API Functions (with request_type)
+- connections: Provider connections (openai, anthropic, etc.)
+- agents: TF workspace agents
+- prompts: Prompt templates (with available_to_agents mapping)
+"""
+
+from typing import Any, Optional, List
+
+from pydantic import BaseModel
+from toothfairyai.types import AgentFunction
+
+from tf_sync.config import TFConfig, ToolType, FunctionRequestType
+
+
+class SyncedTool(BaseModel):
+    """A tool synced from ToothFairyAI workspace."""
+    
+    id: str
+    name: str
+    description: Optional[str] = None
+    tool_type: ToolType
+    
+    is_mcp_server: bool = False
+    is_agent_skill: bool = False
+    is_database_script: bool = False
+    
+    request_type: Optional[FunctionRequestType] = None
+    url: Optional[str] = None
+    tools: list[str] = []
+    
+    authorisation_type: Optional[str] = None
+    
+    auth_via: str = "tf_proxy"
+    
+    # Coder agent specific fields for prompting/model configuration
+    interpolation_string: Optional[str] = None
+    goals: Optional[str] = None
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    llm_base_model: Optional[str] = None
+    llm_provider: Optional[str] = None
+
+
+class SyncedPrompt(BaseModel):
+    """A prompt template synced from ToothFairyAI workspace."""
+    
+    id: str
+    label: str
+    interpolation_string: str
+    prompt_type: Optional[str] = None
+    available_to_agents: Optional[List[str]] = None
+    description: Optional[str] = None
+
+
+class ToolSyncResult(BaseModel):
+    """Result of tool sync operation."""
+    
+    success: bool
+    tools: list[SyncedTool] = []
+    prompts: list[SyncedPrompt] = []
+    by_type: dict[str, int] = {}
+    error: Optional[str] = None
+
+
+def classify_tool(func: AgentFunction) -> ToolType:
+    """
+    Classify a tool based on its properties.
+    
+    Types:
+    - AGENT_SKILL: is_agent_skill=True
+    - API_FUNCTION: has request_type
+    
+    Args:
+        func: AgentFunction from TF SDK
+    
+    Returns:
+        ToolType enum value
+    """
+    # Agent skills have is_agent_skill=True
+    if getattr(func, 'is_agent_skill', None) is True:
+        return ToolType.AGENT_SKILL
+    
+    # All agent_functions with request_type are API Functions
+    if func.request_type:
+        return ToolType.API_FUNCTION
+    
+    return ToolType.API_FUNCTION
+
+
+def parse_function(func: AgentFunction) -> SyncedTool:
+    """
+    Parse AgentFunction from SDK into SyncedTool.
+    
+    Args:
+        func: AgentFunction from TF SDK
+    
+    Returns:
+        SyncedTool instance
+    """
+    tool_type = classify_tool(func)
+    
+    request_type_enum = None
+    if func.request_type:
+        try:
+            request_type_enum = FunctionRequestType(func.request_type)
+        except ValueError:
+            pass
+    
+    # API Functions may have user-provided auth (authorisation_type)
+    # or may use TF proxy
+    auth_via = "user_provided" if func.authorisation_type == "api_key" else "tf_proxy"
+    
+    # Agent skills use skill script
+    if tool_type == ToolType.AGENT_SKILL:
+        auth_via = "tf_skill"
+    
+    return SyncedTool(
+        id=func.id,
+        name=func.name,
+        description=func.description,
+        tool_type=tool_type,
+        request_type=request_type_enum,
+        url=func.url,
+        authorisation_type=func.authorisation_type,
+        auth_via=auth_via,
+        is_agent_skill=tool_type == ToolType.AGENT_SKILL,
+    )
+
+
+def parse_agent(agent) -> SyncedTool:
+    """
+    Parse Agent from SDK into SyncedTool.
+    
+    Coder agents (mode='coder') are CODER_AGENT type, not skills.
+    
+    Args:
+        agent: Agent from TF SDK
+    
+    Returns:
+        SyncedTool instance with full agent configuration
+    """
+    return SyncedTool(
+        id=agent.id,
+        name=agent.label or f"agent_{agent.id[:8]}",
+        description=agent.description,
+        tool_type=ToolType.CODER_AGENT,
+        is_agent_skill=False,
+        auth_via="tf_agent",
+        # Agent prompting configuration
+        interpolation_string=getattr(agent, 'interpolation_string', None),
+        goals=getattr(agent, 'goals', None),
+        # Agent model configuration
+        temperature=getattr(agent, 'temperature', None),
+        max_tokens=getattr(agent, 'max_tokens', None),
+        llm_base_model=getattr(agent, 'llm_base_model', None),
+        llm_provider=getattr(agent, 'llm_provider', None),
+    )
+
+
+def parse_prompt(prompt) -> SyncedPrompt:
+    """
+    Parse Prompt from SDK into SyncedPrompt.
+    
+    Args:
+        prompt: Prompt from TF SDK
+    
+    Returns:
+        SyncedPrompt instance
+    """
+    return SyncedPrompt(
+        id=prompt.id,
+        label=prompt.label,
+        interpolation_string=prompt.interpolation_string,
+        prompt_type=getattr(prompt, 'prompt_type', None),
+        available_to_agents=getattr(prompt, 'available_to_agents', None),
+        description=getattr(prompt, 'description', None),
+    )
+
+
+def sync_tools(config: TFConfig) -> ToolSyncResult:
+    """
+    Sync all tools from ToothFairyAI workspace using SDK.
+    
+    Includes:
+    - Agent Functions (API Functions with request_type)
+    - Agent Skills (functions with is_agent_skill=True)
+    - Coder Agents (agents with mode='coder')
+    - Prompts (prompt templates with available_to_agents mapping)
+    
+    Args:
+        config: TFConfig instance
+    
+    Returns:
+        ToolSyncResult with synced tools and prompts
+    """
+    try:
+        client = config.get_client()
+        
+        # Sync agent functions (API auto-paginates up to 5000)
+        func_result = client.agent_functions.list()
+        tools = [parse_function(f) for f in func_result.items]
+        
+        # Sync coder agents (API auto-paginates up to 5000)
+        try:
+            agents_result = client.agents.list()
+            for agent in agents_result.items:
+                if getattr(agent, 'mode', None) == 'coder':
+                    tools.append(parse_agent(agent))
+        except Exception:
+            pass
+        
+        # Sync prompts (API auto-paginates up to 5000)
+        prompts = []
+        try:
+            prompts_result = client.prompts.list()
+            prompts = [parse_prompt(p) for p in prompts_result.items]
+        except Exception:
+            pass
+        
+        by_type = {}
+        for tool in tools:
+            type_name = tool.tool_type.value
+            by_type[type_name] = by_type.get(type_name, 0) + 1
+        
+        if prompts:
+            by_type['prompt'] = len(prompts)
+        
+        return ToolSyncResult(
+            success=True,
+            tools=tools,
+            prompts=prompts,
+            by_type=by_type,
+        )
+        
+    except Exception as e:
+        return ToolSyncResult(
+            success=False,
+            error=f"Sync failed: {str(e)}",
+        )
+
+
+def sync_tools_by_type(
+    config: TFConfig,
+    tool_types: Optional[list[ToolType]] = None,
+) -> ToolSyncResult:
+    """
+    Sync tools of specific types from ToothFairyAI workspace.
+    
+    Args:
+        config: TFConfig instance
+        tool_types: List of ToolType to sync (None = all)
+    
+    Returns:
+        ToolSyncResult with filtered tools
+    """
+    result = sync_tools(config)
+    
+    if not result.success or not tool_types:
+        return result
+    
+    filtered = [t for t in result.tools if t.tool_type in tool_types]
+    
+    by_type = {}
+    for tool in filtered:
+        type_name = tool.tool_type.value
+        by_type[type_name] = by_type.get(type_name, 0) + 1
+    
+    return ToolSyncResult(
+        success=True,
+        tools=filtered,
+        by_type=by_type,
+    )
+
+
+def sync_api_functions_only(config: TFConfig) -> ToolSyncResult:
+    """Sync only API Functions (has requestType)."""
+    return sync_tools_by_type(config, [ToolType.API_FUNCTION])