Connectors

Connectors parse raw HTTP requests into structured actions. Each connector knows the API schema for a specific service and maps HTTP method + URL path to an action type like github.pr.merge or stripe.charge.create.

Built-in connectors

GitHub

Action types

GitHub Enterprise Server (GHE)

GitHub Enterprise is supported. When adding the GitHub connector in the dashboard gateway wizard, set the custom base URL to your GHE instance (e.g., https://github.yourcompany.com/api/v3). All action types work the same as with api.github.com.

OpenAI / Anthropic

Action types (OpenAI)

Azure OpenAI workaround

Azure OpenAI uses different endpoints ({resource}.openai.azure.com). Use the generic connector in the dashboard wizard with the domain set to your Azure resource endpoint. Actions will be parsed as generic.post, generic.get, etc. For richer action types, a dedicated Azure OpenAI connector is planned.

Stripe

Action types (selection)

Slack

Action types (selection)

Generic HTTP

The generic connector works with any HTTP API. It parses actions based on HTTP method only.

Adding a generic connector

Add a generic connector in the dashboard gateway wizard. Specify the target domain(s) and paste your API key. The default auth header is Authorization: Bearer {token}. You can configure a custom auth header (e.g., X-API-Key) in the connector settings.

Action counting

Each HTTP request through the generic connector counts as one action, regardless of the response. This is the same as structured connectors - one request = one action.

Semantic limitations

The generic connector cannot parse domain-specific action types. A POST to any endpoint is generic.post. For richer action types and risk hints, use a structured connector or build a custom one.

Webhook

The webhook connector sends HTTP requests to arbitrary endpoints. It's designed for outbound webhook integrations where your agent triggers external services.

Adding a webhook connector

Add a webhook connector in the dashboard gateway wizard. Specify the target domain(s) and paste your webhook secret or API key.

MCP (JSON-RPC tool calls)

The MCP connector parses JSON-RPC 2.0 tools/call messages into structured actions, giving you per-tool permissions and risk scoring for MCP (Model Context Protocol) traffic.

Action types

Risk is scored by tool name heuristics: names containing delete/execute/deploy = high, create/write/send = medium, read/get/list = low.

Adding an MCP connector

Add an MCP connector in the dashboard gateway wizard. Specify the MCP server hostname and paste your auth token.

Per-tool permissions

Set permissions in the dashboard gateway wizard access rules step. Use custom patterns to control individual tools:

• mcp.tools.* - allow all tool calls
• mcp.tools.read_* - allow read-only tools
• mcp.tools.delete_* - block destructive tools

For full MCP documentation including risk scoring, permission patterns, and examples, see MCP Connector.

Custom connector development

You can build custom connectors in Go to add domain-specific action parsing for APIs that don't have a built-in connector.

Connector interface

Every connector implements this Go interface:

// internal/connectors/interface.go
type Connector interface {
    // Name returns the connector identifier (e.g., "github", "stripe")
    Name() string
 
    // Domains returns the list of domains this connector handles
    Domains() []string
 
    // ParseAction parses an HTTP request into a structured action
    ParseAction(req *http.Request) (*Action, error)
 
    // InjectCredentials adds authentication to the outbound request
    InjectCredentials(req *http.Request, cred *Credential) error
}
 
type Action struct {
    Type        string            // e.g., "github.pr.merge"
    Resource    Resource
    Parameters  map[string]any
    RiskHints   map[string]any
}

Example: Custom Jira connector

package jira
 
import (
    "net/http"
    "strings"
 
    "github.com/tameflare/tameflare/apps/gateway-v2/internal/connectors"
)
 
type JiraConnector struct{}
 
func (c *JiraConnector) Name() string {
    return "jira"
}
 
func (c *JiraConnector) Domains() []string {
    return []string{"your-org.atlassian.net"}
}
 
func (c *JiraConnector) ParseAction(req *http.Request) (*connectors.Action, error) {
    path := req.URL.Path
    method := req.Method
 
    var actionType string
    switch {
    case method == "POST" && strings.Contains(path, "/rest/api/3/issue"):
        actionType = "jira.issue.create"
    case method == "PUT" && strings.Contains(path, "/rest/api/3/issue"):
        actionType = "jira.issue.update"
    case method == "DELETE" && strings.Contains(path, "/rest/api/3/issue"):
        actionType = "jira.issue.delete"
    case method == "POST" && strings.Contains(path, "/rest/api/3/issue") && strings.Contains(path, "/transitions"):
        actionType = "jira.issue.transition"
    default:
        actionType = "jira." + strings.ToLower(method)
    }
 
    return &connectors.Action{
        Type: actionType,
        Resource: connectors.Resource{
            Provider: "jira",
        },
        RiskHints: map[string]any{
            "irreversible": method == "DELETE",
        },
    }, nil
}
 
func (c *JiraConnector) InjectCredentials(req *http.Request, cred *connectors.Credential) error {
    req.Header.Set("Authorization", "Basic "+cred.Token)
    return nil
}

Registering a custom connector

Add your connector to the registry in internal/connectors/registry.go:

func NewRegistry() *Registry {
    r := &Registry{connectors: make(map[string]Connector)}
    r.Register(&github.GitHubConnector{})
    r.Register(&openai.OpenAIConnector{})
    r.Register(&stripe.StripeConnector{})
    r.Register(&slack.SlackConnector{})
    r.Register(&generic.GenericConnector{})
    r.Register(&jira.JiraConnector{})  // Your custom connector
    return r
}

Rebuild the gateway after adding a connector:

cd apps/gateway-v2 && go build -o gateway ./cmd/gateway

Next steps

• Proxy Behavior - headers, streaming, protocol support
• MCP Connector - full MCP documentation
• Integration Guide - connecting your agent to TameFlare
• Writing Policies - create rules for connector actions