Vercel AI SDK + Gonka AI — AI applications in TypeScript for pennies

JoinGonka API key: sign up at gate.joingonka.ai/register — to get you started we're giving away 3M free tokens. In the Dashboard, create a key with the jg- prefix.

Installing packages. For a custom OpenAI-compatible endpoint, the Vercel AI SDK recommends the @ai-sdk/openai-compatible provider:

npm install ai @ai-sdk/openai-compatible

Minimal setup — create a provider instance with createOpenAICompatible and call generateText:

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { generateText } from 'ai';

const gonka = createOpenAICompatible({
  name: 'gonka',
  baseURL: 'https://gate.joingonka.ai/v1',
  apiKey: process.env.GONKA_API_KEY, // jg-your-key
});

const { text } = await generateText({
  model: gonka('MiniMaxAI/MiniMax-M2.7'),
  prompt: 'Explain what a decentralized inference network is',
});

console.log(text);

The apiKey parameter automatically adds the Authorization: Bearer jg-your-key header — no separate configuration needed. Keep the key in the GONKA_API_KEY environment variable (for example, in .env.local), not in your code.

Alternative — the @ai-sdk/openai package with the createOpenAI({ baseURL, apiKey }) factory. Both approaches work; for endpoints that don't belong to OpenAI, the AI SDK documentation specifically recommends @ai-sdk/openai-compatible — it doesn't drag in extra OpenAI-specific assumptions.

The main highlight of the Vercel AI SDK is streaming responses. The streamText function starts streaming tokens immediately, and the toUIMessageStreamResponse() helper returns a ready-made stream straight from a route handler in the Next.js App Router.

Server handler app/api/chat/route.ts:

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { streamText, convertToModelMessages, type UIMessage } from 'ai';

const gonka = createOpenAICompatible({
  name: 'gonka',
  baseURL: 'https://gate.joingonka.ai/v1',
  apiKey: process.env.GONKA_API_KEY,
});

// allow streaming for up to 30 seconds
export const maxDuration = 30;

export async function POST(req: Request) {
  const { messages }: { messages: UIMessage[] } = await req.json();

  const result = streamText({
    model: gonka('MiniMaxAI/MiniMax-M2.7'),
    system: 'You are a helpful assistant. Answer briefly and to the point.',
    messages: convertToModelMessages(messages),
    maxOutputTokens: 8192, // Gateway output cap
  });

  return result.toUIMessageStreamResponse();
}

On the client, wire up the useChat hook from @ai-sdk/react — it talks to /api/chat on its own and renders the message stream. Meanwhile, the backend talks to Gonka instead of OpenAI.

Script without a UI (Node, async iterator over the stream):

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { streamText } from 'ai';

const gonka = createOpenAICompatible({
  name: 'gonka',
  baseURL: 'https://gate.joingonka.ai/v1',
  apiKey: process.env.GONKA_API_KEY,
});

const result = streamText({
  model: gonka('MiniMaxAI/MiniMax-M2.7'),
  prompt: 'Write a haiku about distributed computing',
});

for await (const chunk of result.textStream) {
  process.stdout.write(chunk);
}

Model parameters. Three models are available through the Gateway: 180K token context for MiniMax M2.7, 380K for DeepSeek V4 Flash, and 390K for GLM-5.3 Flash; the response ceiling (maxOutputTokens) is 8192 for MiniMax M2.7 and GLM-5.3 Flash, and 32768 for DeepSeek V4 Flash:

• MiniMaxAI/MiniMax-M2.7 — the default (MiniMax M2.7);
• deepseek-ai/DeepSeek-V4-Flash-0731 (DeepSeek V4 Flash, 380K context);
• zai-org/GLM-5.3-Flash (GLM-5.3 Flash, a reasoning model — it thinks before it answers).

If maxOutputTokens isn't set, the Gateway returns up to 1500 tokens by default for a non-stream request — for streaming chats, it's best to specify the value explicitly.

The Vercel AI SDK typically sits behind an interactive interface — chat, agent, or in-app assistant. Each message carries the dialogue history, and each agent step carries tool context. Therefore, the actual cost is calculated not by a single request, but by the production load. Let's compare typical scenarios:

The JoinGonka price is about $0.0062 per 1M input tokens, with output being roughly three times more expensive. For an application with thousands of requests per day, this is the difference between a bill of hundreds of dollars and a bill of mere cents. The free 3M tokens are enough to run your project's first requests.

The Vercel AI SDK describes tools declaratively through a tools object and a zod schema. The network's models support native function calling, so the AI SDK receives structured tool_calls without parsing text responses. The stopWhen: stepCountIs(n) parameter allows several steps in a row — the model calls a tool, gets the result, and continues.

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { generateText, tool, stepCountIs } from 'ai';
import { z } from 'zod';

const gonka = createOpenAICompatible({
  name: 'gonka',
  baseURL: 'https://gate.joingonka.ai/v1',
  apiKey: process.env.GONKA_API_KEY,
});

const { text } = await generateText({
  model: gonka('MiniMaxAI/MiniMax-M2.7'),
  stopWhen: stepCountIs(5),
  tools: {
    weather: tool({
      description: 'Get the weather in a city',
      inputSchema: z.object({ city: z.string() }),
      execute: async ({ city }) => ({ city, tempC: 17 }),
    }),
  },
  prompt: 'What is the weather in Moscow? Answer in one sentence.',
});

console.log(text);

The model calls the weather tool, gets the result, and forms the final answer. The whole cycle costs about $0.000048 through Gonka versus $0.03-0.10 with Anthropic or OpenAI. For agentic applications where every user request unfolds into 5-10 steps, the production savings add up to thousands of dollars a month.

If you're building an AI application in Python, check out the LangChain guide — it takes the same approach through the OpenAI-compatible class.