One Interface, All Functions: Simplifying LLM Integration in Node/TS

You’re building a TypeScript app that calls GPT-4, Claude, and Gemini for different tasks. Each one handles function calling differently. You spend more time reading docs and reshaping JSON than actually shipping product. Sound familiar?

‍

As developers working with LLMs, we’ve hit a point where building AI workflows means battling inconsistent interfaces, brittle toolchains, and escalating maintenance costs. But what if you could unify all of that with one clean, typed interface?

‍

The Challenge with Function Calling Today

Function calling – invoking structured functions from an LLM’s response – is a game-changer for automation and agents. It allows AI outputs to drive deterministic logic: book meetings, update records, run scripts.

But here’s the problem: every LLM does it differently.

• OpenAI requires you to register function definitions using a JSON schema.
• Anthropic’s Claude accepts natural language descriptions of functions in its system prompt.
• Google Gemini uses a custom schema embedded in its JSON structure.

This fragmentation makes switching providers painful. You’re locked into specific function formats, error handling styles, and response parsing logic. It’s a nightmare for scaling.

‍

What a Unified Function Interface Looks Like

The ideal abstraction should:

1. Let you define functions once using native TypeScript types.
2. Automatically handle conversion to the appropriate schema for each provider.
3. Return results in a consistent, typed format regardless of which LLM processed the call.

That’s exactly what a unified function interface aims to do. Here’s how it works in practice.

‍

Step 1: Define Functions with TypeScript Types

You shouldn’t have to write JSON schemas by hand. Instead, define your callable functions with TypeScript, just like regular methods:

// Define your function types
type CreateTaskArgs = {
  title: string;
  dueDate?: string;
};
function createTask({ title, dueDate }: CreateTaskArgs): string {
  return `Created task: ${title} ${dueDate ? `(Due: ${dueDate})` : ''}`;
}

With the right tooling, this gets converted automatically into the proper format for OpenAI or Claude behind the scenes.

‍

Step 2: Register the Functions with Your LLM Router

Once your functions are defined, you register them using a single interface:

import { defineFunctions, runWithLLM } from 'anyapi-fn';
const functions = defineFunctions({
  createTask
});

You’re done. Behind the scenes, this generates the right schema and prompt format depending on the selected model.

‍

Step 3: Run the LLM with a Unified Call

Now you can run your prompt and let the LLM decide whether to call a function regardless of the backend model:

import { defineFunctions, runWithLLM } from 'anyapi-fn';
const functions = defineFunctions({
  createTask
});

The result comes back as:

{
  type: 'functionCall',
  name: 'createTask',
  args: { title: 'Finish report', dueDate: '2025-08-27' },
  result: 'Created task: Finish report (Due: 2025-08-27)'
}

Same call structure. Same function format. Just results that work.

‍

Why It Matters for Dev Teams

This abstraction isn’t just “nice to have.” It solves three real problems for engineering teams:

1. Faster Time to Production

You stop reinventing JSON schemas and adapting prompts for every model. Write your logic once, scale it everywhere.

2. Easier Model Swaps

Want to A/B test Claude vs GPT-4? Now you can, without rewriting your logic layer. It’s plug-and-play.

3. Typed Safety + Fewer Bugs

Because you define everything in TypeScript, you get static type checking and autocompletion in your IDE. Say goodbye to brittle runtime parsing.

‍

A Glimpse of the Future: Agentic Workflows

Unified function calling isn’t just about simplifying code. It lays the foundation for more powerful patterns like:

• Multi-step agents: Chain multiple function calls with memory.
• Dynamic routing: Let the model choose which tool to use.
• Serverless automation: Turn LLM calls into infrastructure triggers.

When your function layer is portable, typed, and model-agnostic, you can build faster, safer, and smarter automation.

‍

Where AnyAPI Fits In

If you’re building LLM-powered products and want to avoid provider lock-in, AnyAPI offers a unified layer for function calling, model routing, token streaming, and observability without sacrificing control or customization.

Our developer SDKs for TypeScript, Python, and other stacks are designed to abstract LLM differences and let you focus on product logic, not low-level plumbing.

Whether you’re building tools, agents, or internal apps, AnyAPI helps you ship faster with less friction.

‍