Your AI Agent  →  SynapseX API  →  Gmail / Slack / GitHub / Notion / ...
                      │
                      ├─ OAuth2 flow managed
                      ├─ Tokens encrypted at rest (Fernet)
                      ├─ Per-user connected accounts
                      ├─ Session scoping
                      └─ Tool execution + audit logs

git clone https://github.com/softquantus/synapsex-manager
cd synapsex-manager
cp .env.example .env
# Preencha as credenciais OAuth dos apps que deseja usar

make dev-db        # start PostgreSQL
make install-backend
make migrate       # run Alembic migrations
make seed          # popula app + action catalog
make dev-backend   # API at http://localhost:8000
make dev-frontend  # Dashboard at http://localhost:5173

docker compose up --build

# Register via API
curl -X POST http://localhost:8000/v1/auth/register \
  -H "Content-Type: application/json" \
  -d '{"email":"you@example.com","password":"secret"}'

# Ou use a CLI
synapsex login
synapsex auth create-key "my-agent"
# → sx_live_abc123...

synapsex connect gmail
# Opens browser → user authorizes → connected_account saved

synapsex tools run gmail_send_email \
  --account 01ABC... \
  --input '{"to":"friend@example.com","subject":"Hello","body":"From my agent!"}'

pip install synapsex-sdk
# ou: pip install -e sdk/

import asyncio
from synapsex_sdk import SynapseXClient

sx = SynapseXClient(api_key="sx_live_...")

async def main():
    # List all available tools
    tools = await sx.list_all_tools(["gmail", "slack"])

    # Convert for your AI framework
    anthropic_tools = sx.to_anthropic_tools(tools)
    openai_tools    = sx.to_openai_tools(tools)
    langchain_tools = sx.to_langchain_tools(tools, entity_id="user_42")

    # Execute a tool
    result = await sx.execute(
        "gmail_send_email",
        input={"to": "x@y.com", "subject": "Hi", "body": "Hello from my agent"},
        entity_id="user_42",  # auto-resolves their Gmail account
    )
    result.raise_on_error()
    print(result.output)

asyncio.run(main())

# When user_42 connects their Gmail in your app:
link = await sx.get_connect_link("gmail", entity_id="user_42")
# → redirect user_42 to link

# Later, your agent acts on behalf of user_42:
result = await sx.execute("gmail_send_email", {...}, entity_id="user_42")

npm install @synapsex/sdk
# ou: cd sdk-js && npm install && npm run build

import { SynapseXClient } from "@synapsex/sdk";

const sx = new SynapseXClient({ apiKey: "sx_live_..." });

// Get OAuth link for your end-user
const link = await sx.getConnectLink("gmail", { entityId: "user_42" });

// List tools
const tools = await sx.listAllTools(["gmail", "slack"]);

// Vercel AI SDK — tools with built-in execute()
const vercelTools = sx.toVercelAITools(tools, { entityId: "user_42" });

// Anthropic / OpenAI formats
const anthropicTools = sx.toAnthropicTools(tools);
const openaiTools    = sx.toOpenAITools(tools);

# manifest.py — static metadata seeded into the database
MANIFEST = {
    "id": "linear",
    "name": "Linear",
    "auth_type": "oauth2",
    "oauth_authorize_url": "https://linear.app/oauth/authorize",
    "oauth_token_url": "https://api.linear.app/oauth/token",
    "oauth_scopes": ["read", "write"],
    "oauth_credential_fields": [
        {"name": "client_id",     "label": "Client ID",     "secret": False, "required": True},
        {"name": "client_secret", "label": "Client Secret", "secret": True,  "required": True},
        {"name": "redirect_uri",  "label": "Redirect URI (optional)", "secret": False, "required": False},
    ],
    "actions": [
        {
            "name": "linear_create_issue",
            "display_name": "Create Issue",
            "description": "Create a new issue in a Linear team",
            "tags": ["linear", "write"],
            "input_schema": { "type": "object", "required": ["title"],
                              "properties": {"title": {"type": "string"}} },
        }
    ],
}

# provider.py — execution logic
from src.providers.base import BaseProvider

class LinearProvider(BaseProvider):
    provider_id = "linear"

    async def execute_tool(self, action_name: str, input_data: dict, credentials: dict) -> dict:
        if action_name == "linear_create_issue":
            # call Linear API with credentials["access_token"]
            ...
        raise ValueError(f"Unknown action: {action_name}")

    async def refresh_token(self, credentials: dict) -> dict:
        return credentials  # Linear tokens don't expire; override if needed

# __init__.py — empty, required to make this a Python package

make seed
# O novo provider é seeded no DB e auto-registrado no próximo startup

curl -X PUT http://localhost:8000/v1/admin/providers/linear/credentials \
  -H "Authorization: Bearer $ADMIN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"client_id": "...", "client_secret": "..."}'