Architecture Overview

import { ShieldAgentClient } from '@shieldagent/sdk';

const client = new ShieldAgentClient({
  baseUrl: 'https://proxy.shieldagent.io',
  apiKey: '{your-api-key}',
});

// Call client.scan() before executing each agent request:
async function handleAgentRequest(agentId: string, method: string, path: string, body: unknown) {
  const verdict = await client.scan({
    tenantId: '{your-tenant-id}',
    agentId,              // optional — omit if you cannot identify the caller
    toolName: `api:${method}:${path}`,
    params: { method, path, body },
    context: { transport: 'rest' },
  });

  if (verdict.action === 'block') {
    // YOU must enforce this — ShieldAgent cannot block on your behalf
    throw new Error(`Request blocked by ShieldAgent: ${verdict.reason}`);
  }

  if (verdict.action === 'human_review') {
    return { status: 'pending_review', reviewId: verdict.reviewId };
  }

  // verdict.action === 'allow' — safe to execute
  return executeRequest(method, path, body);
}

from shieldagent import ShieldAgentClient

client = ShieldAgentClient(
    base_url="https://proxy.shieldagent.io",
    api_key="{your-api-key}",
)

# Call client.scan() before executing each agent request:
async def handle_agent_request(agent_id: str, method: str, path: str, body: dict):
    verdict = await client.scan(
        tenant_id="{your-tenant-id}",
        agent_id=agent_id,          # optional — omit if you cannot identify the caller
        tool_name=f"api:{method}:{path}",
        params={"method": method, "path": path, "body": body},
        context={"transport": "rest"},
    )

    if verdict.action == "block":
        # YOU must enforce this — ShieldAgent cannot block on your behalf
        raise HTTPException(status_code=403, detail=verdict.reason)

    if verdict.action == "human_review":
        return {"status": "pending_review", "review_id": verdict.review_id}

    # Execute the request
    return execute_request(method, path, body)

import { ShieldAgentClient } from '@shieldagent/sdk';

const client = new ShieldAgentClient({
  baseUrl: 'https://proxy.shieldagent.io',
  apiKey: '{your-api-key}',
});

// Call client.scan() before every tool handler:
async function handleToolCall(toolName: string, params: unknown, clientName?: string) {
  const verdict = await client.scan({
    tenantId: '{your-tenant-id}',
    // agentId is optional — MCP protocol does not expose agent identity
    clientHint: clientName,   // pass MCP clientInfo.name for best-effort agent matching
    toolName,
    params,
    context: { transport: 'mcp' },
  });

  if (verdict.action === 'block') {
    // YOU must enforce this — ShieldAgent cannot block on your behalf
    throw new Error(`Tool blocked by ShieldAgent: ${verdict.reason}`);
  }

  if (verdict.action === 'human_review') {
    return { status: 'pending_review', reviewId: verdict.reviewId };
  }

  // verdict.action === 'allow' — safe to execute the handler
  return executeToolHandler(toolName, params);
}

from shieldagent import ShieldAgentClient

client = ShieldAgentClient(
    base_url="https://proxy.shieldagent.io",
    api_key="{your-api-key}",
)

# Call client.scan() before every tool handler:
async def handle_tool_call(
    tool_name: str, params: dict, client_name: str | None = None
):
    verdict = await client.scan(
        tenant_id="{your-tenant-id}",
        # agent_id is optional — MCP protocol does not expose agent identity
        client_hint=client_name,    # pass MCP clientInfo.name for best-effort matching
        tool_name=tool_name,
        params=params,
        context={"transport": "mcp"},
    )

    if verdict.action == "block":
        # YOU must enforce this — ShieldAgent cannot block on your behalf
        raise MCPError(f"Tool blocked by ShieldAgent: {verdict.reason}")

    if verdict.action == "human_review":
        return {"status": "pending_review", "review_id": verdict.review_id}

    # Execute the tool handler
    return execute_tool(tool_name, params)