AI Framework Adapters

AgentKit actions are framework-agnostic. Define an action once, then export it as a tool for any of the five supported AI frameworks using a single adapter function.

Supported Frameworks

Adapter	Function	Target Framework
OpenAI	`toOpenAITools()`	OpenAI Function Calling
LangChain	`toLangChainToolDefs()`	LangChain Tools
MCP	`toMcpTools()`	Model Context Protocol
Vercel AI	`toVercelAITools()`	Vercel AI SDK
OpenAI Agents	`toOpenAIAgentsTools()`	OpenAI Agents SDK

Using the ActionProvider

The ActionProvider class has built-in methods for each framework. After registering your actions, call the appropriate method:

src/export-tools.ts

import { ActionProvider } from '@goatnetwork/agentkit/providers';
import { walletBalanceAction, NoopWalletReadAdapter } from '@goatnetwork/agentkit/plugins';

const provider = new ActionProvider();
provider.register(walletBalanceAction(new NoopWalletReadAdapter()));

// Export for any framework
const openaiTools     = provider.openAITools();
const langchainDefs   = provider.langChainToolDefs();
const mcpTools        = provider.mcpTools();
const vercelTools     = provider.vercelAITools();
const agentsTools     = provider.openAIAgentsTools();

You can optionally filter by network:

Network filtering

// Only actions that support goat-mainnet
const mainnetTools = provider.openAITools('goat-mainnet');

OpenAI Function Calling

OpenAI Integration

import { ActionProvider } from '@goatnetwork/agentkit/providers';

const tools = provider.openAITools();
// Returns: Array<{ type: 'function', function: { name, description, parameters } }>

// Use with the OpenAI SDK
const response = await openai.chat.completions.create({
  model: 'gpt-4',
  messages: [...],
  tools: tools,
});

Output Format

OpenAI tool format

[
  {
    "type": "function",
    "function": {
      "name": "wallet.balance",
      "description": "Query wallet balance (native token when tokenAddress absent, ERC20 otherwise)",
      "parameters": {
        "type": "object",
        "properties": {
          "address": { "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" },
          "tokenAddress": { "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$" }
        },
        "required": ["address"]
      }
    }
  }
]

LangChain

LangChain Integration

const toolDefs = provider.langChainToolDefs();
// Returns: Array<{ name, description, schema }>

// Use with LangChain's tool infrastructure

Model Context Protocol (MCP)

MCP Integration

const mcpTools = provider.mcpTools();
// Returns: Array<{ name, description, inputSchema }>

// Serve as an MCP tool server

Vercel AI SDK

Vercel AI Integration

const tools = provider.vercelAITools();
// Returns: Array<{ name, description, parameters }>

// Use with the Vercel AI SDK

OpenAI Agents SDK

OpenAI Agents SDK Integration

const tools = provider.openAIAgentsTools();
// Returns: Array<{ name, description, params_json_schema }>

Using the Low-Level Adapter Functions

You can also use the adapter functions directly with a custom tool manifest:

Low-level adapter usage

import { buildToolManifest } from '@goatnetwork/agentkit/providers';
import { toOpenAITools } from '@goatnetwork/agentkit/adapters';

// Build manifest from a list of actions
const actions = provider.list();
const manifest = buildToolManifest(actions);

// Convert to any framework format
const tools = toOpenAITools(manifest);

Available Adapter Functions

Imports

import {
  toOpenAITools,
  toLangChainToolDefs,
  toMcpTools,
  toVercelAITools,
  toOpenAIAgentsTools,
} from '@goatnetwork/agentkit/adapters';

Tool Manifest

All adapters operate on the same intermediate ToolManifestItem format:

ToolManifestItem

interface ToolManifestItem {
  name: string;
  description: string;
  riskLevel: string;
  requiresConfirmation: boolean;
  networks: string[];
  inputSchema?: Record<string, unknown>;  // JSON Schema
}

When you define a Zod schema on an action, AgentKit automatically converts it to JSON Schema for the tool manifest using zod-to-json-schema. This means your Zod validations (string patterns, min/max, enums) are faithfully represented in the tool definitions that LLMs see.

Handling Tool Calls

When your AI framework invokes a tool, route the call back through the ExecutionRuntime:

Tool call handler pattern

async function handleToolCall(
  toolName: string,
  toolInput: unknown,
  runtime: ExecutionRuntime,
  provider: ActionProvider,
  context: ActionContext,
) {
  const action = provider.get(toolName);
  const result = await runtime.run(action, context, toolInput, {
    confirmed: true,  // Or implement a confirmation flow
  });

  if (!result.ok) {
    return { error: result.error, errorCode: result.errorCode };
  }
  return result.output;
}

The adapter functions only generate tool definitions (schemas). Actual action execution always goes through the ExecutionRuntime, which enforces policy, validation, retries, and all other runtime guarantees.

On this page