Hooks with any agent SDK

from gatewaysdk.hooks import HookRun

run = HookRun.from_config("gateway-hooks.toml")
run.seed(entities)                                  # the task's people, before the agent starts
guarded = run.wrap({"lookup_email": lookup_email, "web_search": web_search})
# ... register guarded["lookup_email"] wherever your SDK takes a tool implementation ...
verdict = run.end(report)                           # run_end: the outgoing scan, the findings

import { HookRun } from "@withgateway/sdk/hooks";

const run = await HookRun.fromConfig("gateway-hooks.toml");
run.seed(entities);
const guarded = run.wrapTools({ lookup_email: lookupEmail, web_search: webSearch });
const verdict = await run.end(report);

from agents import Agent, Runner, function_tool

guarded = run.wrap({"lookup_email": _lookup_email})

@function_tool
def lookup_email(email: str) -> dict:
    """Breach records for one email address."""
    return guarded["lookup_email"](email=email)

agent = Agent(name="investigator", instructions=run.alias.rewrite_instruction(task), tools=[lookup_email])
result = Runner.run_sync(agent, "Start with the subject's email.")
verdict = run.end(result.final_output)

import { generateText, tool } from "ai";
import { z } from "zod";

const impls = run.wrapTools({
  lookup_email: async ({ email }: { email: string }) => lookupEmail(email),
});

const result = await generateText({
  model,
  system: run.alias.rewriteInstruction(task),
  tools: {
    lookup_email: tool({
      description: "Breach records for one email address.",
      inputSchema: z.object({ email: z.string() }),
      execute: impls.lookup_email,
    }),
  },
  prompt: "Start with the subject's email.",
});
const verdict = await run.end(result.text);

import anthropic

client = anthropic.Anthropic()
tools = {**run.tools(), **run.wrap({"lookup_email": lookup_email})}
definitions = run.tool_definitions(shape="anthropic") + [LOOKUP_EMAIL_DEFINITION]

messages = [{"role": "user", "content": run.alias.rewrite_instruction(task)}]
while True:
    turn = client.messages.create(model=MODEL, tools=definitions, messages=messages, max_tokens=8000)
    messages.append({"role": "assistant", "content": turn.content})
    if turn.stop_reason != "tool_use":
        break
    results = []
    for block in turn.content:
        if block.type == "tool_use":
            answer = tools[block.name](**block.input)          # the rules ran around this
            results.append({"type": "tool_result", "tool_use_id": block.id, "content": json.dumps(answer)})
    messages.append({"role": "user", "content": results})
verdict = run.end(turn.content[-1].text)

from langchain_core.tools import StructuredTool
from pydantic import BaseModel

class LookupEmail(BaseModel):
    email: str

guarded = run.wrap({"lookup_email": lookup_email})
tool = StructuredTool.from_function(
    func=lambda email: guarded["lookup_email"](email=email),
    name="lookup_email", description="Breach records for one email address.", args_schema=LookupEmail,
)

from mcp.server.fastmcp import FastMCP

server = FastMCP("vendor")
guarded = run.wrap({"lookup_email": _lookup_email})

@server.tool()
def lookup_email(email: str) -> dict:
    """Breach records for one email address."""
    return guarded["lookup_email"](email=email)