AI agents

import { Touchque, TouchqueAgent, generateAgentKey } from '@touchque/node';

const tq = new Touchque(); // TQ_API_KEY / TQ_API_SECRET from the environment

// Once, from your server (an API key with the agents:write scope)
const { privateJwk, publicJwk } = generateAgentKey();   // ES256; 'EdDSA' too
const agent = await tq.agents.create({
  name: 'Invoice bot',
  allowedTypes: ['PAY_INVOICE'],          // the only approvals it may ask for
  publicKey: publicJwk,                   // never the private key
  ownerEmail: 'ada@acme.com',             // accountable; the agent stops if they leave
  platform: 'openai-agents',
});
// agent.id and privateJwk go to the agent's secret store: TQ_AGENT_ID, TQ_AGENT_KEY

// Inside the agent: its own key, DPoP
const me = await new TouchqueAgent().me();

// When something goes wrong
await tq.agents.suspend(agent.id, 'looping');
await tq.agents.setKillSwitch(true, 'incident');   // every agent, at once

from touchque import TouchqueAgent, generate_agent_key

keys = generate_agent_key()
agent = client.agents.create('Invoice bot', ['PAY_INVOICE'], public_key=keys['public_jwk'],
                             owner_email='ada@acme.com', platform='langchain')

me = TouchqueAgent().me()            # TQ_AGENT_ID, TQ_AGENT_KEY  (the touchque-authenticator[agent] extra)

client.agents.suspend(agent['id'], 'looping')
client.agents.set_kill_switch(True, 'incident')

use Touchque\AgentKeys;
use Touchque\TouchqueAgent;

$keys = AgentKeys::generate();
$agent = $tq->agents->create('Invoice bot', ['PAY_INVOICE'], ['publicKey' => $keys['publicJwk'], 'ownerEmail' => 'ada@acme.com']);

$me = (new TouchqueAgent())->me();   // TQ_AGENT_ID, TQ_AGENT_KEY

$tq->agents->suspend($agent['id'], 'looping');
$tq->agents->setKillSwitch(true, 'incident');

keys, _ := touchque.GenerateAgentKey("ES256")
agent, err := client.Agents.Create(touchque.CreateAgentParams{
    Name: "Invoice bot", AllowedTypes: []string{"PAY_INVOICE"}, PublicKey: keys.PublicJWK, OwnerEmail: "ada@acme.com",
})

a, _ := touchque.NewAgent(touchque.AgentConfig{}) // TQ_AGENT_ID, TQ_AGENT_KEY
me, err := a.Me()

client.Agents.Suspend(agent.ID, "looping")
client.Agents.SetKillSwitch(true, "incident")

var keys = AgentKeys.Generate();   // ES256, or AgentKeys.Generate("EdDSA")
var agent = await tq.Agents.CreateAsync(new CreateAgentOptions
{
    Name = "Invoice bot", AllowedTypes = ["PAY_INVOICE"], PublicKey = keys.PublicJwk, OwnerEmail = "ada@acme.com",
});

using var bot = new TouchqueAgent();   // TQ_AGENT_ID, TQ_AGENT_KEY
var me = await bot.MeAsync();

await tq.Agents.SuspendAsync(agent.Id, "looping");
await tq.Agents.SetKillSwitchAsync(true, "incident");

AgentKeys.Pair keys = AgentKeys.generate();   // ES256, or AgentKeys.generate("EdDSA")
JsonNode agent = tq.agents().create(new Agents.CreateOptions("Invoice bot", List.of("PAY_INVOICE"))
    .publicKey(keys.publicJwk()).ownerEmail("ada@acme.com"));

var bot = new TouchqueAgent();   // TQ_AGENT_ID, TQ_AGENT_KEY
JsonNode me = bot.me();

tq.agents().suspend(agent.get("id").asText(), "looping");
tq.agents().setKillSwitch(true, "incident");

keys = Touchque::AgentKeys.generate
agent = tq.agents.create("Invoice bot", ["PAY_INVOICE"], public_key: keys["publicJwk"], owner_email: "ada@acme.com")

me = Touchque::Agent.new.me   # TQ_AGENT_ID, TQ_AGENT_KEY

tq.agents.suspend(agent["id"], reason: "looping")
tq.agents.set_kill_switch(true, reason: "incident")

# Partner: signed request (HMAC), see Authentication
POST /agents
{ "name": "Invoice bot", "allowedTypes": ["PAY_INVOICE"],
  "publicKey": { "kty": "EC", "crv": "P-256", "x": "…", "y": "…" } }

# Agent: its own key, no API key
POST /agents/token
DPoP: <proof JWT>
Content-Type: application/x-www-form-urlencoded

grant_type=client_credentials
&client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer
&client_assertion=<JWT signed by the agent key>

GET /agents/me
Authorization: DPoP tqat_…
DPoP: <proof JWT with ath>

// In the agent: typed details, never free text
const ask = await agent.requestApproval({
  user: 'jane@example.com', type: 'PAY_INVOICE', reason: 'October rent',
  authorizationDetails: [{ type: 'payment_initiation',
    instructedAmount: { currency: 'TRY', amount: '500.00' },
    creditorName: 'Jane Doe', creditorAccount: { iban: 'TR33 0006 1005 1978 6457 8413 26' } }],
});
reply(`Type ${ask.challengeCode} in the Touchque app to approve.`);
const { approvalToken } = await agent.waitForApproval(ask.approvalId);

// In your executor, right before paying: once, only for this
const approval = await tq.agents.redeemApproval(approvalToken, {
  user: 'jane@example.com', type: 'PAY_INVOICE',
  authorizationDetails: { type: 'payment_initiation', instructedAmount: { currency: 'TRY', amount: '500.00' } },
});

ask = agent.request_approval('jane@example.com', 'PAY_INVOICE', [payment], reason='October rent')
token = agent.wait_for_approval(ask['approvalId'])['approvalToken']
approval = client.agents.redeem_approval(token, user='jane@example.com', authorization_details=payment)

$ask = $agent->requestApproval('jane@example.com', 'PAY_INVOICE', [$payment], ['reason' => 'October rent']);
$token = $agent->waitForApproval($ask['approvalId'])['approvalToken'];
$approval = $tq->agents->redeemApproval($token, ['user' => 'jane@example.com', 'authorizationDetails' => $payment]);

ask, _ := a.RequestApproval(touchque.AgentApprovalParams{User: "jane@example.com", Type: "PAY_INVOICE",
    AuthorizationDetails: []map[string]interface{}{payment}, Reason: "October rent"})
done, _ := a.WaitForApproval(ctx, ask.ApprovalID, 0, 0)
approval, err := client.Agents.RedeemApproval(done.ApprovalToken, touchque.ApprovalExpectation{User: "jane@example.com", AuthorizationDetails: payment})

var ask = await bot.RequestApprovalAsync("jane@example.com", "PAY_INVOICE", new[] { payment }, new AgentApprovalOptions { Reason = "October rent" });
var done = await bot.WaitForApprovalAsync(ask.ApprovalId);
var approval = await tq.Agents.RedeemApprovalAsync(done.ApprovalToken!, new ApprovalExpectation { User = "jane@example.com", AuthorizationDetails = payment });

var ask = bot.requestApproval("jane@example.com", "PAY_INVOICE", List.of(payment), new TouchqueAgent.ApprovalOptions().reason("October rent"));
var done = bot.waitForApproval(ask.approvalId(), null, null);
JsonNode approval = tq.agents().redeemApproval(done.approvalToken(), new ApprovalToken.Expectation("jane@example.com", null, payment));

ask = agent.request_approval("jane@example.com", "PAY_INVOICE", [payment], reason: "October rent")
token = agent.wait_for_approval(ask["approvalId"])["approvalToken"]
approval = tq.agents.redeem_approval(token, user: "jane@example.com", authorization_details: payment)

POST /agents/approvals            # agent token + DPoP
{ "externalUsername": "jane@example.com", "type": "PAY_INVOICE", "reason": "October rent",
  "authorizationDetails": [{ "type": "payment_initiation",
    "instructedAmount": { "currency": "TRY", "amount": "500.00" },
    "creditorName": "Jane Doe", "creditorAccount": { "iban": "TR330006100519786457841326" } }] }

GET /agents/approvals/{approvalId}  # → approved + approvalToken

POST /agents/approvals/redeem        # your API key (HMAC)
{ "token": "<approvalToken>" }

import { withTouchqueApproval, currentApproval, touchqueCanUseTool, guardMcpClient } from '@touchque/node';

const policy = { agent, user: 'jane@example.com', type: 'PAY_INVOICE',
  details: ({ iban, amount }) => [{ type: 'payment_initiation',
    instructedAmount: { currency: 'TRY', amount }, creditorAccount: { iban } }],
  onChallenge: (s) => reply(`Type ${s.challengeCode} in the Touchque app.`) };

// LangChain tool(), OpenAI Agents tool(), Vercel AI SDK tool(): same signature
const pay = withTouchqueApproval(async ({ iban, amount }) =>
  bank.pay(iban, amount, currentApproval().approvalToken), policy);

// Claude Agent SDK
query({ prompt, options: { canUseTool: touchqueCanUseTool({ pay: policy }, { tokenField: 'approvalToken' }) } });
// MCP client: the token goes in _meta["touchque/approvalToken"]
const guarded = guardMcpClient(client, { pay: policy });

from touchque import ApprovalPolicy, with_touchque_approval, current_approval

policy = ApprovalPolicy(agent, user='jane@example.com', type='PAY_INVOICE',
                        details=lambda a, tool: [{'type': 'payment_initiation',
                                                  'instructedAmount': {'currency': 'TRY', 'amount': a['amount']},
                                                  'creditorAccount': {'iban': a['iban']}}])

@tool   # LangChain, LlamaIndex, OpenAI Agents (@function_tool): signature kept
@with_touchque_approval(policy)
def pay(iban: str, amount: str) -> str:
    return bank.pay(iban, amount, current_approval()['approvalToken'])

# approve_interruptions_with_touchque(result, {'pay': policy})   OpenAI Agents SDK
# touchque_can_use_tool({'pay': policy})                        Claude Agent SDK
# guard_mcp_session(session, {'pay': policy})                   MCP ClientSession

$done = $agent->requireApproval('jane@example.com', 'PAY_INVOICE', [$payment], [],
    fn ($s) => $reply("Type {$s['challengeCode']} in the Touchque app."));
$bank->pay($iban, $amount, $done['approvalToken']);

done, err := a.RequireApproval(ctx, touchque.AgentApprovalParams{User: "jane@example.com", Type: "PAY_INVOICE",
    AuthorizationDetails: []map[string]interface{}{payment}},
    func(s *touchque.AgentApprovalState) { reply("Type " + s.ChallengeCode + " in the Touchque app.") }, 5*time.Minute)
if err != nil { return err }   // rejected, blocked, expired
bank.Pay(iban, amount, done.ApprovalToken)

var done = await bot.RequireApprovalAsync("jane@example.com", "PAY_INVOICE", new[] { payment },
    onChallenge: s => ReplyAsync($"Type {s.ChallengeCode} in the Touchque app."));   // TouchqueApprovalException when refused
await bank.PayAsync(iban, amount, done.ApprovalToken!);

var done = bot.requireApproval("jane@example.com", "PAY_INVOICE", List.of(payment), null,
    s -> reply("Type " + s.challengeCode() + " in the Touchque app."), null);   // TouchqueApprovalException when refused
bank.pay(iban, amount, done.approvalToken());

done = agent.require_approval("jane@example.com", "PAY_INVOICE", [payment]) do |s|
  reply "Type #{s["challengeCode"]} in the Touchque app."
end   # Touchque::ApprovalError when refused
bank.pay(iban, amount, done["approvalToken"])

import { TouchqueOrgAgent, githubActionsToken } from '@touchque/node';

// With its own key (TQ_ORG_AGENT_ID, TQ_ORG_AGENT_KEY)
const agent = new TouchqueOrgAgent();
const res = await agent.fetch('https://payments.acme.com/invoices', { resource: 'tqapp_…', scope: 'invoices:read' });

// In GitHub Actions, no key to store (permissions: id-token: write)
const ci = new TouchqueOrgAgent({ agentId: 'oagt_…', assertion: githubActionsToken('touchque') });

// For a member: with their own token (RFC 8693) or by asking them on the phone (CIBA)
const forAda = await agent.exchangeToken({ subjectToken: adasAccessToken, resource: 'tqapp_…' });
const ask = await agent.askMember({ loginHint: 'ada@acme.com', bindingMessage: 'Pay invoice 42', authorizationDetails: [payment] });
reply(`Type ${ask.bindingCode} in the Touchque app.`);
const approved = await agent.waitForMember(ask);   // approved.authorizationDetails

// Token vault: the member's own Google account they connected, no refresh token
const google = await agent.getConnectionToken({ subjectToken: adasAccessToken, connection: 'google' });

from touchque import TouchqueOrgAgent, github_actions_token

agent = TouchqueOrgAgent()   # TQ_ORG_AGENT_ID, TQ_ORG_AGENT_KEY
r = agent.request('GET', 'https://payments.acme.com/invoices', resource='tqapp_...', scope='invoices:read')

ci = TouchqueOrgAgent(agent_id='oagt_...', assertion=github_actions_token('touchque'))
google = agent.get_connection_token(adas_access_token, 'google')   # token vault

use Touchque\TouchqueOrgAgent;

$agent = new TouchqueOrgAgent();   // TQ_ORG_AGENT_ID, TQ_ORG_AGENT_KEY
$headers = $agent->authorization('GET', 'https://payments.acme.com/invoices', ['resource' => 'tqapp_...']);

$ci = new TouchqueOrgAgent(['agentId' => 'oagt_...', 'assertion' => TouchqueOrgAgent::githubActionsToken('touchque')]);
$google = $agent->getConnectionToken($adasAccessToken, 'google');   // token vault

agent, _ := touchque.NewOrgAgent(touchque.OrgAgentConfig{}) // TQ_ORG_AGENT_ID, TQ_ORG_AGENT_KEY
req, _ := http.NewRequest("GET", "https://payments.acme.com/invoices", nil)
_ = agent.Authorize(req, "tqapp_…", "invoices:read")

ci, _ := touchque.NewOrgAgent(touchque.OrgAgentConfig{AgentID: "oagt_…", Assertion: touchque.GitHubActionsToken("touchque")})
google, _ := agent.GetConnectionToken(adasAccessToken, "google", "") // token vault

using var agent = new TouchqueOrgAgent();   // TQ_ORG_AGENT_ID, TQ_ORG_AGENT_KEY
var request = new HttpRequestMessage(HttpMethod.Get, "https://payments.acme.com/invoices");
await agent.AuthorizeAsync(request, "tqapp_…", "invoices:read");

using var ci = new TouchqueOrgAgent(new TouchqueOrgAgentOptions { AgentId = "oagt_…", Assertion = TouchqueOrgAgent.GitHubActionsToken("touchque") });
var google = await agent.GetConnectionTokenAsync(adasAccessToken, "google");   // token vault

var agent = new TouchqueOrgAgent();   // TQ_ORG_AGENT_ID, TQ_ORG_AGENT_KEY
var request = agent.authorize(HttpRequest.newBuilder(URI.create("https://payments.acme.com/invoices")),
    "GET", "https://payments.acme.com/invoices", "tqapp_…", "invoices:read");

var ci = new TouchqueOrgAgent(new TouchqueOrgAgent.Options().agentId("oagt_…").assertion(TouchqueOrgAgent.githubActionsToken("touchque")));
var google = agent.getConnectionToken(adasAccessToken, "google", null);   // token vault

agent = Touchque::OrgAgent.new   # TQ_ORG_AGENT_ID, TQ_ORG_AGENT_KEY
headers = agent.authorization("GET", "https://payments.acme.com/invoices", resource: "tqapp_…", scope: "invoices:read")

ci = Touchque::OrgAgent.new(agent_id: "oagt_…", assertion: Touchque::OrgAgent.github_actions_token("touchque"))
google = agent.get_connection_token(adas_access_token, "google")   # token vault

POST https://sso.touchque.com/sso/token
DPoP: <proof>
Content-Type: application/x-www-form-urlencoded

grant_type=client_credentials&client_id=oagt_…
&client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer
&client_assertion=<a JWT signed with its key, or its platform's token>
&resource=tqapp_…&scope=invoices:read

# → { "access_token": "<at+jwt>", "token_type": "DPoP", "expires_in": 300 }

// In the browser (your sign-in page)
import { startClientSignals, addAgentTrap } from '@touchque/web';
const probe = startClientSignals();   // on page load
addAgentTrap(form);   // a field off the screen: people never see it; software that types the word its note asks for is refused
form.onsubmit = () => { form.clientSignals.value = probe.encode(); };

// On your server
const risk = await tq.risk.check({ externalUsername, clientIp, browserProof, clientSignals: req.body.clientSignals });
await tq.login.request({ externalUsername, type: 'LOGIN', clientIp, clientSignals: req.body.clientSignals });
// software at the browser: never silent, number matching; or 403 automated_client

risk = tq.risk.check(user, client_ip=ip, browser_proof=proof, client_signals=form['clientSignals'])
tq.login.request(user, type='LOGIN', client_ip=ip, client_signals=form['clientSignals'])

$risk = $tq->risk->check(['externalUsername' => $user, 'clientIp' => $ip, 'clientSignals' => $_POST['clientSignals']]);
$tq->login->request($user, 'LOGIN', null, $ip, null, false, false, null, null, null, null, null, $_POST['clientSignals']);

risk, _ := tq.Risk.Check(ctx, touchque.RiskCheckOptions{ExternalUsername: user, ClientIP: ip, ClientSignals: r.FormValue("clientSignals")})
_, err := tq.Login.RequestWithOptions(touchque.LoginRequestOptions{ExternalUsername: user, ClientIP: ip, ClientSignals: r.FormValue("clientSignals")})

var risk = await tq.Risk.CheckAsync(new RiskCheckOptions { ExternalUsername = user, ClientIp = ip, ClientSignals = form["clientSignals"] });
await tq.Login.RequestAsync(new LoginRequestOptions { ExternalUsername = user, ClientIp = ip, ClientSignals = form["clientSignals"] });

var risk = tq.risk().check(new Risk.CheckOptions(user).clientIp(ip).clientSignals(request.getParameter("clientSignals")));
tq.login().request(new LoginRequestOptions(user).clientIp(ip).clientSignals(request.getParameter("clientSignals")));

risk = tq.risk.check(user, client_ip: ip, browser_proof: proof, client_signals: params[:clientSignals])
tq.login.request(user, type: "LOGIN", client_ip: ip, client_signals: params[:clientSignals])

# Web Bot Auth: a signed agent's request
Signature-Agent: "https://agent.example"
Signature-Input: sig1=("@authority" "signature-agent");created=…;expires=…;keyid="<JWK thumbprint>";alg="ed25519";nonce="…";tag="web-bot-auth"
Signature: sig1=:…:

# → 403 { "error": "agent_identity_required", "agent": "agent.example", "caseCode": "…" }

import { McpAuth } from '@touchque/node';

const auth = new McpAuth({
    issuer: 'https://sso.touchque.com/mcp',   // Organization → MCP servers
    resource: 'https://mcp.acme.com/mcp',     // exactly as registered
    tools: { search_tickets: 'tickets:read', delete_ticket: 'tickets:delete' },
});
app.use(auth.express());   // serves the metadata; 401 + WWW-Authenticate without a token

// before running a tool
auth.requireTool(req.touchqueMcp, 'delete_ticket');   // 403 insufficient_scope: the client asks the member for more

from touchque import McpAuth, McpAuthError

auth = McpAuth(issuer='https://sso.touchque.com/mcp', resource='https://mcp.acme.com/mcp',
               tools={'search_tickets': 'tickets:read', 'delete_ticket': 'tickets:delete'})

claims = auth.verify(request.method, str(request.url), dict(request.headers))
auth.require_tool(claims, 'delete_ticket')
# FastMCP TokenVerifier: auth.verify_token(token)

use Touchque\McpAuth;

$auth = new McpAuth(['issuer' => 'https://sso.touchque.com/mcp', 'resource' => 'https://mcp.acme.com/mcp',
    'tools' => ['search_tickets' => 'tickets:read', 'delete_ticket' => 'tickets:delete']]);

$claims = $auth->verify($_SERVER['REQUEST_METHOD'], $url, getallheaders());
$auth->requireTool($claims, 'delete_ticket');   // TouchqueMcpAuthException: $e->status, $e->wwwAuthenticate

auth, _ := touchque.NewMcpAuth(touchque.McpAuthConfig{
    Issuer: "https://sso.touchque.com/mcp", Resource: "https://mcp.acme.com/mcp",
    Tools:  map[string]string{"search_tickets": "tickets:read", "delete_ticket": "tickets:delete"},
})
http.Handle("/", auth.Middleware(mcpHandler))

claims := touchque.McpClaimsFrom(r.Context())
if err := auth.RequireTool(claims, "delete_ticket"); err != nil {
    touchque.WriteMcpAuthError(w, err)
}

var auth = new McpAuth(new McpAuthOptions
{
    Issuer = "https://sso.touchque.com/mcp", Resource = "https://mcp.acme.com/mcp",
    Tools = new Dictionary<string, string> { ["search_tickets"] = "tickets:read", ["delete_ticket"] = "tickets:delete" },
});
app.MapTouchqueMcpMetadata(auth);                                   // /.well-known/oauth-protected-resource/mcp
app.MapPost("/mcp", HandleMcp).RequireTouchqueMcp(auth);            // 401 + WWW-Authenticate without a valid token

auth.RequireTool(http.GetTouchqueMcpClaims()!, "delete_ticket");   // TouchqueMcpAuthException: Status, WwwAuthenticate

# application.properties (Spring Boot starter)
touchque.mcp.issuer=https://sso.touchque.com/mcp
touchque.mcp.resource=https://mcp.acme.com/mcp
touchque.mcp.tools.search_tickets=tickets:read
touchque.mcp.tools.delete_ticket=tickets:delete
# → /.well-known/oauth-protected-resource/mcp, and 401 + WWW-Authenticate on /mcp without a valid token

// In the handler:
mcpAuth.requireTool(TouchqueSpring.mcpClaims(request), "delete_ticket");   // TouchqueMcpAuthException: status(), wwwAuthenticate()

auth = Touchque::McpAuth.new(issuer: "https://sso.touchque.com/mcp", resource: "https://mcp.acme.com/mcp",
                             tools: { "search_tickets" => "tickets:read", "delete_ticket" => "tickets:delete" })

claims = auth.verify(request.request_method, request.url, request.headers)
auth.require_tool(claims, "delete_ticket")   # Touchque::McpAuthError: status, www_authenticate

GET https://mcp.acme.com/.well-known/oauth-protected-resource/mcp
# → { "resource": "https://mcp.acme.com/mcp", "authorization_servers": ["https://sso.touchque.com/mcp"] }

GET https://sso.touchque.com/sso/mcp/authorize?response_type=code
  &client_id=https://tool.example/oauth/client.json   # client ID metadata document
  &redirect_uri=…&code_challenge=…&code_challenge_method=S256
  &resource=https://mcp.acme.com/mcp&scope=tickets:read&state=…

POST https://sso.touchque.com/sso/mcp/token
grant_type=authorization_code&code=…&code_verifier=…&resource=https://mcp.acme.com/mcp

# → { "access_token": "<at+jwt>", "token_type": "Bearer", "expires_in": 600, "refresh_token": "…" }

import { requestIdJag, redeemIdJag, IdJagVerifier, verifyAgentCard } from '@touchque/node';

// Your app (an OIDC app with a secret): the member's ID token → ID-JAG → access token
const { assertion } = await requestIdJag({ issuer: 'https://sso.touchque.com', clientId, clientSecret, idToken, audience: 'https://auth.files.example' });
const tokens = await redeemIdJag({ tokenEndpoint: 'https://auth.files.example/token', clientId: 'acme', clientSecret: filesSecret, assertion });

// Your own authorization server (jwt-bearer): used once
const claims = await new IdJagVerifier({ issuer: 'https://sso.touchque.com', audience: 'https://auth.files.example' })
  .verify(form.assertion, { clientId: authenticatedClientId });

// Another agent's A2A card
await verifyAgentCard(card, { cardUrl: 'https://agent.example/.well-known/agent-card.json' });

jag = request_id_jag(issuer='https://sso.touchque.com', client_id=client_id, client_secret=secret,
                     id_token=id_token, audience='https://auth.files.example')
claims = IdJagVerifier(issuer='https://sso.touchque.com', audience='https://auth.files.example') \
    .verify(form['assertion'], client_id=authenticated_client_id)
verify_agent_card(card, card_url='https://agent.example/.well-known/agent-card.json')

$jag = CrossAppAccess::requestIdJag(['issuer' => 'https://sso.touchque.com', 'clientId' => $id, 'clientSecret' => $secret,
    'idToken' => $idToken, 'audience' => 'https://auth.files.example']);
$claims = (new IdJagVerifier(['issuer' => 'https://sso.touchque.com', 'audience' => 'https://auth.files.example']))
    ->verify($_POST['assertion'], $authenticatedClientId);
AgentCard::verify($cardJson, ['cardUrl' => 'https://agent.example/.well-known/agent-card.json']);

jag, err := touchque.RequestIDJAG(ctx, touchque.RequestIDJAGParams{Issuer: "https://sso.touchque.com",
    ClientID: id, ClientSecret: secret, IDToken: idToken, Audience: "https://auth.files.example"})
v, _ := touchque.NewIDJAGVerifier(touchque.IDJAGVerifierConfig{Issuer: "https://sso.touchque.com", Audience: "https://auth.files.example"})
claims, err := v.Verify(ctx, r.PostFormValue("assertion"), authenticatedClientID)
res, err := touchque.VerifyAgentCard(ctx, cardJSON, touchque.VerifyAgentCardOptions{CardURL: "https://agent.example/.well-known/agent-card.json"})

var jag = await CrossAppAccess.RequestIdJagAsync(new() { Issuer = "https://sso.touchque.com", ClientId = id,
    ClientSecret = secret, IdToken = idToken, Audience = "https://auth.files.example" });
var claims = await new IdJagVerifier(new() { Issuer = "https://sso.touchque.com", Audience = "https://auth.files.example" })
    .VerifyAsync(form["assertion"]!, authenticatedClientId);
await AgentCard.VerifyAsync(cardJson, new() { CardUrl = "https://agent.example/.well-known/agent-card.json" });

var jag = CrossAppAccess.requestIdJag(new CrossAppAccess.RequestOptions(id, secret, idToken, "https://auth.files.example")
    .issuer("https://sso.touchque.com"));
var claims = new IdJagVerifier(new IdJagVerifier.Options("https://sso.touchque.com", "https://auth.files.example"))
    .verify(form.get("assertion"), authenticatedClientId);
AgentCard.verify(cardJson, new AgentCard.VerifyOptions().cardUrl("https://agent.example/.well-known/agent-card.json"));

jag = Touchque::CrossAppAccess.request_id_jag(issuer: "https://sso.touchque.com", client_id: id, client_secret: secret,
                                              id_token: id_token, audience: "https://auth.files.example")
claims = Touchque::IdJagVerifier.new(issuer: "https://sso.touchque.com", audience: "https://auth.files.example")
                                .verify(params[:assertion], client_id: authenticated_client_id)
Touchque::AgentCard.verify(card_json, card_url: "https://agent.example/.well-known/agent-card.json")

POST https://sso.touchque.com/sso/token          # the app's client_id + client_secret
grant_type=urn:ietf:params:oauth:grant-type:token-exchange
&requested_token_type=urn:ietf:params:oauth:token-type:id-jag
&subject_token=<ID token>&subject_token_type=urn:ietf:params:oauth:token-type:id_token
&audience=https://auth.files.example&scope=files:read
# → { "access_token": "<ID-JAG>", "issued_token_type": "urn:ietf:params:oauth:token-type:id-jag", "token_type": "N_A", "expires_in": 300 }

POST https://sso.touchque.com/sso/mcp/token      # your own MCP servers
grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer&assertion=<ID-JAG>&resource=https://mcp.acme.com/mcp

// Ask once: at most 5 invoices, 10,000 TRY in total, this IBAN, 24 hours
const m = await agent.requestMandate({
  user: 'jane@example.com', type: 'PAY_INVOICE', maxCount: 5,
  maxTotal: { currency: 'TRY', amount: '10000.00' }, perRequest: '2500.00',
  recipients: ['TR33 0006 1005 1978 6457 8413 26'], validFor: 86400,
});
reply(`Type ${m.challengeCode} in the Touchque app.`);

// Once active: each payment is approved without a push, counted atomically
const ask = await agent.requestApproval({ user: 'jane@example.com', type: 'PAY_INVOICE',
  authorizationDetails: [payment], mandateId: m.mandateId });
// ask.status === "approved", token in the answer; redeemApproval as always

await tq.agents.setPolicy(agentId, { fourEyes: { approvers: ['cfo@acme.com'], above: { TRY: '5000' } } });

m = agent.request_mandate('jane@example.com', 'PAY_INVOICE', 5, {'currency': 'TRY', 'amount': '10000.00'},
                         per_request='2500.00', recipients=[iban], valid_for=86400)
ask = agent.request_approval('jane@example.com', 'PAY_INVOICE', [payment], mandate_id=m['mandateId'])
client.agents.set_policy(agent_id, {'fourEyes': {'approvers': ['cfo@acme.com'], 'above': {'TRY': '5000'}}})

$m = $agent->requestMandate('jane@example.com', 'PAY_INVOICE', 5, ['currency' => 'TRY', 'amount' => '10000.00'],
    ['perRequest' => '2500.00', 'recipients' => [$iban], 'validFor' => 86400]);
$ask = $agent->requestApproval('jane@example.com', 'PAY_INVOICE', [$payment], ['mandateId' => $m['mandateId']]);
$tq->agents->setPolicy($agentId, ['fourEyes' => ['approvers' => ['cfo@acme.com'], 'above' => ['TRY' => '5000']]]);

m, _ := a.RequestMandate(touchque.MandateParams{User: "jane@example.com", Type: "PAY_INVOICE", MaxCount: 5,
    MaxTotal: map[string]string{"currency": "TRY", "amount": "10000.00"}, PerRequest: "2500.00", Recipients: []string{iban}})
ask, _ := a.RequestApproval(touchque.AgentApprovalParams{User: "jane@example.com", Type: "PAY_INVOICE",
    AuthorizationDetails: []map[string]interface{}{payment}, MandateID: m.MandateID})
client.Agents.SetPolicy(agentID, touchque.AgentPolicy{FourEyes: &touchque.FourEyes{Approvers: []string{"cfo@acme.com"},
    Above: map[string]string{"TRY": "5000"}}})

var m = await bot.RequestMandateAsync("jane@example.com", "PAY_INVOICE", 5, new MandateAmount("TRY", "10000.00"),
    new MandateOptions { PerRequest = new MandateAmount("TRY", "2500.00"), Recipients = [iban], ValidFor = 86400 });
var ask = await bot.RequestApprovalAsync("jane@example.com", "PAY_INVOICE", new[] { payment }, new AgentApprovalOptions { MandateId = m.MandateId });
await tq.Agents.SetPolicyAsync(agentId, new AgentPolicy
{
    FourEyes = new FourEyes { Approvers = ["cfo@acme.com"], Above = new Dictionary<string, string> { ["TRY"] = "5000" } },
});

JsonNode m = bot.requestMandate("jane@example.com", "PAY_INVOICE", 5, new TouchqueAgent.MandateAmount("TRY", "10000.00"),
    new TouchqueAgent.MandateOptions().perRequest(new TouchqueAgent.MandateAmount("TRY", "2500.00")).recipients(List.of(iban)).validFor(86400));
var ask = bot.requestApproval("jane@example.com", "PAY_INVOICE", List.of(payment),
    new TouchqueAgent.ApprovalOptions().mandateId(m.get("mandateId").asText()));
tq.agents().setPolicy(agentId, Map.of("fourEyes", Map.of("approvers", List.of("cfo@acme.com"), "above", Map.of("TRY", "5000"))));

m = agent.request_mandate("jane@example.com", "PAY_INVOICE", 5, { currency: "TRY", amount: "10000.00" },
                          per_request: "2500.00", recipients: [iban], valid_for: 86400)
ask = agent.request_approval("jane@example.com", "PAY_INVOICE", [payment], mandate_id: m["mandateId"])
tq.agents.set_policy(agent_id, { fourEyes: { approvers: ["cfo@acme.com"], above: { TRY: "5000" } } })

POST /agents/mandates                 # agent token + DPoP
{ "externalUsername": "jane@example.com", "type": "PAY_INVOICE", "maxCount": 5,
  "maxTotal": { "currency": "TRY", "amount": "10000.00" }, "perRequest": "2500.00",
  "recipients": ["TR330006100519786457841326"], "validFor": 86400 }

POST /agents/approvals                # with "mandateId": "…": no push
POST /agents/mandates/{id}/revoke     # the agent gives it up
POST /agents/{agentId}/mandates/{id}/revoke   # you (HMAC)
PUT  /agents/{agentId}/policy         # { "fourEyes": { "approvers": […], "above": { "TRY": "5000" } } }

{
  "access_token": "tqat_…",
  "token_type": "DPoP",
  "expires_in": 600,
  "scope": "agent:read approvals:request approvals:read"
}