API Documentation

from openai import OpenAI

client = OpenAI(
    api_key="sk-your-openai-key",
    base_url="https://api.trustloop.live/v1",          # ← only change
    default_headers={"x-api-key": "tl_your_key"}   # ← add this
)

# All existing code works unchanged — TrustLoop intercepts automatically
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Transfer £5000 to supplier"}],
    tools=[...]
)

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'sk-your-openai-key',
  baseURL: 'https://api.trustloop.live/v1',          // ← only change
  defaultHeaders: { 'x-api-key': 'tl_your_key' }  // ← add this
});

const response = await client.chat.completions.create({
  model: 'gpt-4o-mini',
  messages: [{ role: 'user', content: 'Transfer £5000 to supplier' }],
  tools: [...]
});

curl -X POST https://api.trustloop.live/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-your-openai-key" \
  -H "x-api-key: tl_your_trustloop_key" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [{"role": "user", "content": "Transfer 5000 to supplier"}],
    "tools": [...]
  }'

# Header (recommended)
x-api-key: tl_your_api_key_here

# Query parameter (SSE / browser export)
GET /sse?api_key=tl_your_api_key_here

https://api.trustloop.live

from openai import OpenAI

client = OpenAI(
    api_key="gsk_your_groq_key",
    base_url="https://api.trustloop.live/v1",
    default_headers={
        "x-api-key": "tl_your_key",
        "x-upstream-base": "https://api.groq.com/openai/v1"  # route to Groq
    }
)

import anthropic

client = anthropic.Anthropic(
    api_key="sk-ant-your-key",
    base_url="https://api.trustloop.live/proxy/anthropic",
    default_headers={"x-api-key": "tl_your_key"}
)

import google.generativeai as genai

genai.configure(
    api_key="AIza-your-key",
    client_options={"api_endpoint": "https://api.trustloop.live/proxy/google"}
)
# Pass your TrustLoop key in x-api-key header

{ "choices": [...], "_trustloop": { "status": "allowed", "tool": "read_file" } }

{
  "choices": [{ "message": { "content": "Tool 'delete_file' is blocked by governance policy." } }],
  "_trustloop": { "blocked": true, "tool": "delete_file", "rule": "Block all file deletions" }
}

{
  "choices": [{ "message": { "content": "Action requires human approval. Retry once approved." } }],
  "_trustloop": { "status": "pending_approval", "approval_id": "uuid", "tool": "wire_transfer" }
}

import requests

def trustloop_check(tool_name, args):
    res = requests.post(
        "https://api.trustloop.live/api/intercept",
        headers={"x-api-key": "tl_your_key"},
        json={"tool_name": tool_name, "arguments": args, "agent_name": "my-agent"}
    ).json()
    if not res["allowed"]:
        raise PermissionError(res["message"])

# In your tool executor:
trustloop_check("delete_records", {"table": "customers"})

pip install trustloop-sdk

# With LangChain integration
pip install trustloop-sdk[langchain]

# With CrewAI integration
pip install trustloop-sdk[crewai]

# With async support (httpx)
pip install trustloop-sdk[async]

from trustloop import TrustLoop

tl = TrustLoop(api_key="tl_your_key", agent_name="my-agent")

# Manual check before any action
result = tl.intercept("send_email", {"to": "ceo@bank.com"})
if not result["allowed"]:
    raise RuntimeError(result["message"])

# Or use the decorator — cleaner for existing tools
@tl.guard("delete_records")
def delete_records(table, where):
    ...  # only runs if TrustLoop allows it

from trustloop.integrations.langchain import wrap_tools

# Wrap all LangChain tools in one line — no changes to individual tools
tools = wrap_tools(raw_tools, tl)

agent = create_tool_calling_agent(llm, tools, prompt)

from trustloop.integrations.crewai import governed_tool

@governed_tool(tl)
class SendEmailTool(BaseTool):
    name = "send_email"
    description = "Send an email"

    def _run(self, to, subject, body):
        ...  # intercepted automatically

import TrustLoop from 'trustloop';

const tl = new TrustLoop({ apiKey: 'tl_your_key', agentName: 'my-agent' });

const result = await tl.intercept('send_email', { to: 'ceo@bank.com' });
if (!result.allowed) throw new Error(result.message);

Before taking any sensitive action — sending emails, accessing databases,
calling external APIs, transferring data, modifying files, or any operation
that affects systems outside this conversation — you MUST call the TrustLoop
interceptToolCall action first.

Pass the action name as tool_name and all relevant parameters as arguments.
Set agent_name to the name of this GPT.

- If allowed: true → proceed.
- If allowed: false and status BLOCKED → do NOT proceed. Tell the user:
  "This action was blocked by your organisation's AI governance policy."
- If allowed: false and status PENDING → do NOT proceed. Tell the user:
  "This action requires human approval. Your administrator has been notified."

Never skip this check for sensitive operations.