npm install @a2x/sdk

# Pick one (or more)
npm install @google/genai        # Google Gemini
npm install @anthropic-ai/sdk    # Anthropic Claude
npm install openai               # OpenAI GPT

import { LlmAgent, toA2x } from '@a2x/sdk';
import { GoogleProvider } from '@a2x/sdk/google';
 
const agent = new LlmAgent({
  name: 'my_assistant',
  description: 'A helpful assistant.',
  instruction: 'You are a helpful assistant.',
  provider: new GoogleProvider({
    model: 'gemini-2.5-flash',
    apiKey: process.env.GOOGLE_API_KEY!,
  }),
});
 
const app = toA2x(agent, {
  port: 4000,
  defaultUrl: 'http://localhost:4000/a2a',
});

import { GoogleProvider } from '@a2x/sdk/google';
 
const provider = new GoogleProvider({
  model: 'gemini-2.5-flash',
  apiKey: process.env.GOOGLE_API_KEY!,
});

import { AnthropicProvider } from '@a2x/sdk/anthropic';
 
const provider = new AnthropicProvider({
  model: 'claude-sonnet-4-20250514',
  apiKey: process.env.ANTHROPIC_API_KEY!,
});

import { OpenAIProvider } from '@a2x/sdk/openai';
 
const provider = new OpenAIProvider({
  model: 'gpt-4o',
  apiKey: process.env.OPENAI_API_KEY!,
});

import {
  LlmAgent,
  InMemoryRunner,
  AgentExecutor,
  StreamingMode,
  InMemoryTaskStore,
  A2XAgent,
  DefaultRequestHandler,
  createSSEStream,
} from '@a2x/sdk';
import type { RequestContext } from '@a2x/sdk';
import { GoogleProvider } from '@a2x/sdk/google';
 
// 1. Define your agent
const agent = new LlmAgent({
  name: 'my_agent',
  description: 'My A2A agent.',
  instruction: 'You are a helpful assistant.',
  provider: new GoogleProvider({
    model: 'gemini-2.5-flash',
    apiKey: process.env.GOOGLE_API_KEY!,
  }),
});
 
// 2. Wire up the runtime
const runner = new InMemoryRunner({ agent, appName: agent.name });
const executor = new AgentExecutor({
  runner,
  runConfig: { streamingMode: StreamingMode.SSE },
});
const taskStore = new InMemoryTaskStore();
 
// 3. Create A2XAgent (auto-extracts name, description, streaming from runtime)
const a2xAgent = new A2XAgent({ taskStore, executor })
  .setDefaultUrl('https://my-agent.example.com/a2a')
  .addSkill({
    id: 'chat',
    name: 'Chat',
    description: 'General conversation',
    tags: ['chat'],
  });
 
// 4. Create the request handler
const handler = new DefaultRequestHandler(a2xAgent);

import express from 'express';
 
const app = express();
app.use(express.json());
 
app.get('/.well-known/agent.json', (req, res) => {
  res.json(handler.getAgentCard());
});
 
app.post('/a2a', async (req, res) => {
  const context: RequestContext = { headers: req.headers, query: req.query };
  const result = await handler.handle(req.body, context);
 
  if (result && typeof result === 'object' && Symbol.asyncIterator in result) {
    res.setHeader('Content-Type', 'text/event-stream');
    res.setHeader('Cache-Control', 'no-cache');
    const stream = createSSEStream(result);
    const reader = stream.getReader();
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      res.write(typeof value === 'string' ? value : new TextDecoder().decode(value));
    }
    res.end();
  } else {
    res.json(result);
  }
});
 
app.listen(4000);

export async function GET() {
  return Response.json(handler.getAgentCard());
}
 
export async function POST(request: Request) {
  const body = await request.json();
  const result = await handler.handle(body);
 
  if (result && typeof result === 'object' && Symbol.asyncIterator in result) {
    const stream = createSSEStream(result);
    return new Response(stream, {
      headers: { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache' },
    });
  }
  return Response.json(result);
}

import { A2XClient } from '@a2x/sdk/client';
 
const client = new A2XClient('https://agent.example.com/.well-known/agent.json');
 
// Send a message
const task = await client.sendMessage({
  message: { role: 'user', parts: [{ text: 'Hello!' }] },
});
 
// Stream a response
for await (const event of client.sendMessageStream({
  message: { role: 'user', parts: [{ text: 'Tell me a story' }] },
})) {
  console.log(event);
}
 
// Task management
const existing = await client.getTask('task-id');
const canceled = await client.cancelTask('task-id');

import { FunctionTool } from '@a2x/sdk';
 
const weatherTool = new FunctionTool({
  name: 'get_weather',
  description: 'Get weather for a location',
  parameters: {
    type: 'object',
    properties: {
      location: { type: 'string', description: 'City name' },
    },
    required: ['location'],
  },
  execute: async ({ location }) => {
    return { temp: 72, condition: 'sunny', location };
  },
});
 
const agent = new LlmAgent({
  name: 'weather_bot',
  description: 'Weather assistant',
  instruction: 'Use the get_weather tool to answer weather questions.',
  provider,
  tools: [weatherTool],
});

import { AgentTool } from '@a2x/sdk';
 
const researchAgent = new LlmAgent({ /* ... */ });
 
const mainAgent = new LlmAgent({
  name: 'orchestrator',
  description: 'Orchestrates sub-agents',
  instruction: 'Delegate research tasks to the research agent.',
  provider,
  tools: [new AgentTool({ agent: researchAgent })],
});

import { ApiKeyAuthorization, HttpBearerAuthorization } from '@a2x/sdk';
 
a2xAgent
  .addSecurityScheme('apiKey', new ApiKeyAuthorization({
    in: 'header',
    name: 'x-api-key',
    keys: ['your-secret-key'],
  }))
  .addSecurityScheme('bearer', new HttpBearerAuthorization({
    validator: async (token) => {
      const valid = token === process.env.AUTH_TOKEN;
      return { authenticated: valid };
    },
  }))
  // OR logic: either scheme satisfies auth
  .addSecurityRequirement({ apiKey: [] })
  .addSecurityRequirement({ bearer: [] });

npm install x402 viem

import { X402PaymentExecutor, X402_EXTENSION_URI } from '@a2x/sdk/x402';
 
const executor = new X402PaymentExecutor(innerExecutor, {
  accepts: [{
    network: 'base-sepolia',
    amount: '10000',                                   // 0.01 USDC (6 decimals)
    asset: '0x036CbD53842c5426634e7929541eC2318f3dCF7e', // USDC on Base Sepolia
    payTo: process.env.MERCHANT_ADDRESS!,
  }],
});
 
const agent = new A2XAgent({ taskStore, executor })
  .addExtension({ uri: X402_EXTENSION_URI, required: true });

import { A2XClient } from '@a2x/sdk/client';
import { X402Client } from '@a2x/sdk/x402';
import { privateKeyToAccount } from 'viem/accounts';
 
const x402 = new X402Client(new A2XClient(url), {
  signer: privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`),
});
const task = await x402.sendMessage({ message: { role: 'user', parts: [{ text: '...' }] } });

const cardV10 = a2xAgent.getAgentCard();       // v1.0 (default)
const cardV03 = a2xAgent.getAgentCard('0.3');   // v0.3