TypeScript SDK

Use the official OpenAI TypeScript SDK with GonkaGate. Works with Node.js, Deno, and browsers.

Installation

Install the official OpenAI npm package:

terminal

npm install openai

Configuration

Configure the client to use GonkaGate's API endpoint:

config.ts

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.gonkagate.com/v1",
  apiKey: "gp-your-api-key", // Get from dashboard
});

Basic Usage

Make your first chat completion request:

basic-usage.ts

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.gonkagate.com/v1",
  apiKey: "gp-your-api-key",
});

const response = await client.chat.completions.create({
  model: "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "Hello, how are you?" },
  ],
  temperature: 0.7,
  max_tokens: 1000,
});

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

Streaming

Stream responses for real-time output:

streaming.ts

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.gonkagate.com/v1",
  apiKey: "gp-your-api-key",
});

const stream = await client.chat.completions.create({
  model: "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
  messages: [{ role: "user", content: "Write a poem about AI" }],
  stream: true,
});

for await (const chunk of stream) {
  const content = chunk.choices[0]?.delta?.content || "";
  process.stdout.write(content);

  // Final chunk contains usage
  if (chunk.usage) {
    console.log(`\n\nCost: $${(chunk.usage as any).total_cost_usd}`);
  }
}

TypeScript Types

Extend types for GonkaGate-specific usage fields:

types.ts

// Extended usage type with GonkaGate cost fields
interface GonkaGateUsage {
  prompt_tokens: number;
  completion_tokens: number;
  total_tokens: number;
  base_cost_usd: number;
  platform_fee_usd: number;
  total_cost_usd: number;
}

// Type assertion for usage
const response = await client.chat.completions.create({
  model: "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
  messages: [{ role: "user", content: "Hello!" }],
});

const usage = response.usage as GonkaGateUsage;
console.log(`Cost: $${usage.total_cost_usd.toFixed(6)}`);

React Integration

Build a chat interface with React hooks:

use-chat.ts

"use client";

import { useState } from "react";

interface Message {
  role: "user" | "assistant";
  content: string;
}

export function useChat() {
  const [messages, setMessages] = useState<Message[]>([]);
  const [isLoading, setIsLoading] = useState(false);

  const sendMessage = async (content: string) => {
    const userMessage: Message = { role: "user", content };
    setMessages((prev) => [...prev, userMessage]);
    setIsLoading(true);

    try {
      const response = await fetch("/api/chat", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          messages: [...messages, userMessage],
        }),
      });

      const data = await response.json();
      const assistantMessage: Message = {
        role: "assistant",
        content: data.content,
      };
      setMessages((prev) => [...prev, assistantMessage]);
    } finally {
      setIsLoading(false);
    }
  };

  return { messages, sendMessage, isLoading };
}

Next.js Integration

Create an API route in Next.js:

app/api/chat/route.ts

// app/api/chat/route.ts
import OpenAI from "openai";
import { NextResponse } from "next/server";

const client = new OpenAI({
  baseURL: "https://api.gonkagate.com/v1",
  apiKey: process.env.GONKAGATE_API_KEY,
});

export async function POST(request: Request) {
  const { messages } = await request.json();

  const response = await client.chat.completions.create({
    model: "Qwen/Qwen3-235B-A22B-Instruct-2507-FP8",
    messages,
  });

  return NextResponse.json({
    content: response.choices[0].message.content,
    usage: response.usage,
  });
}