AI Framework Adapters

import { ArcenAgent, toOpenAITools, executeOpenAITool } from "@arcenpay/agent";
import OpenAI from "openai";

const agent = new ArcenAgent({
  privateKey: process.env.AGENT_PRIVATE_KEY!,
  chainId: 5042002, // Arc Testnet (or 8453 for Base, 677 for BOT Chain)
  maxAutoApprove: "5.00",
});

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

// 1. Convert ArcenPay tools to OpenAI format
const tools = toOpenAITools(agent);

const messages: any[] = [
  { role: "user", content: "Check my agent balance and pay for https://app.arcenpay.com/pay/dataset-01" },
];

// 2. Call LLM with tools
const response = await openai.chat.completions.create({
  model: "gpt-4o",
  messages,
  tools,
});

const choice = response.choices[0].message;

// 3. Handle and execute tool calls
if (choice.tool_calls) {
  for (const toolCall of choice.tool_calls) {
    const result = await executeOpenAITool(
      agent,
      toolCall.function.name,
      JSON.parse(toolCall.function.arguments)
    );

    messages.push(choice);
    messages.push({
      role: "tool",
      tool_call_id: toolCall.id,
      content: JSON.stringify(result),
    });
  }

  // 4. Get final response from model
  const finalResponse = await openai.chat.completions.create({
    model: "gpt-4o",
    messages,
  });

  console.log(finalResponse.choices[0].message.content);
}

import { ArcenAgent, toLangChainTools } from "@arcenpay/agent";
import { ChatOpenAI } from "@langchain/openai";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const agent = new ArcenAgent({
  privateKey: process.env.AGENT_PRIVATE_KEY!,
  chainId: 8453,
  maxDailySpend: 50.00,
});

// Generate LangChain tools
const tools = toLangChainTools(agent);

const model = new ChatOpenAI({ model: "gpt-4o" });
const app = createReactAgent({ llm: model, tools });

const result = await app.invoke({
  messages: [{ role: "user", content: "Check my ArcenPay session vault balance." }],
});

console.log(result.messages[result.messages.length - 1].content);

import { ArcenAgent, toVercelTools } from "@arcenpay/agent";
import { openai } from "@ai-sdk/openai";
import { generateText } from "ai";

const agent = new ArcenAgent({
  privateKey: process.env.AGENT_PRIVATE_KEY!,
  chainId: 5042002,
  maxAutoApprove: "2.00",
});

const result = await generateText({
  model: openai("gpt-4o"),
  tools: toVercelTools(agent),
  maxSteps: 5, // Allows autonomous multi-step execution
  prompt: "What is my agent's treasury balance, and can I afford a $1.00 API inference?",
});

console.log(result.text);

import { ArcenAgent, toAnthropicTools, executeAnthropicTool } from "@arcenpay/agent";
import Anthropic from "@anthropic-ai/sdk";

const agent = new ArcenAgent({
  privateKey: process.env.AGENT_PRIVATE_KEY!,
  chainId: 8453,
});

const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
const tools = toAnthropicTools();

const response = await anthropic.messages.create({
  model: "claude-3-5-sonnet-20241022",
  max_tokens: 1024,
  tools: tools as any,
  messages: [{ role: "user", content: "Check my agent's on-chain balance." }],
});

for (const block of response.content) {
  if (block.type === "tool_use") {
    const toolResult = await executeAnthropicTool(agent, block.name, block.input as any);
    console.log("Tool Result:", toolResult);
  }
}

import {
  // Tool Schemas & Generic Dispatcher
  ARCENPAY_AGENT_TOOL_SCHEMAS,
  executeArcenAgentTool,

  // LangChain
  createArcenAgentLangChainTools,
  toLangChainTools,

  // Vercel AI SDK
  createArcenAgentVercelAITools,
  toVercelTools,

  // OpenAI & Kilocode
  createArcenAgentOpenAITools,
  toOpenAITools,
  executeOpenAITool,

  // Anthropic Claude
  createArcenAgentAnthropicTools,
  toAnthropicTools,
  executeAnthropicTool,
} from "@arcenpay/agent";