Integrations

The Flint AI TypeScript SDK supports the same integrations as the Python SDK. Standard LLM clients use wrap(), while Google ADK uses a dedicated plugin.

Integration	Method
OpenAI	`wrap()`
Anthropic	`wrap()`
Google GenAI	`wrap()`
LangChain (`ChatOpenAI`, `ChatAnthropic`, `ChatGoogleGenerativeAI`)	`wrap()`
Google ADK	`ADKGuardrailsPlugin`

OpenAI

Wrap an OpenAI client to route completions through the guardrails proxy.

import OpenAI from "openai";
import { wrap } from "@sandboxaq/flintai-sdk-ts";

const client = new OpenAI({ apiKey: "your-openai-api-key" });
wrap(client, {
  gatewayUrl: "https://app.flintai.dev",
  apiKey: "your-flintai-api-key",
});

const response = await client.chat.completions.create({
  model: "gpt-4",
  messages: [{ role: "user", content: "Hello" }],
});

After wrapping, use the client exactly as before — the SDK redirects traffic transparently.

Anthropic

Wrap an Anthropic client the same way.

import Anthropic from "@anthropic-ai/sdk";
import { wrap } from "@sandboxaq/flintai-sdk-ts";

const client = new Anthropic({ apiKey: "your-anthropic-api-key" });
wrap(client, {
  gatewayUrl: "https://app.flintai.dev",
  apiKey: "your-flintai-api-key",
});

const message = await client.messages.create({
  model: "claude-sonnet-4-20250514",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello" }],
});

Google GenAI

Wrap a GoogleGenAI client. Set your Gemini key the way you normally would (shown here on the client). The SDK does not require any additional LLM provider key of its own.

import { GoogleGenAI } from "@google/genai";
import { wrap } from "@sandboxaq/flintai-sdk-ts";

const client = new GoogleGenAI({ apiKey: "your-gemini-api-key" });
wrap(client, {
  gatewayUrl: "https://app.flintai.dev",
  apiKey: "your-flintai-api-key",
});

const response = await client.models.generateContent({
  model: "gemini-2.5-flash",
  contents: "Hello",
});

The SDK normalizes the gateway URL with a trailing slash for Google GenAI — do not add one yourself.

LangChain

wrap() auto-detects LangChain chat models, extracts the underlying SDK client, and applies guardrails routing. Supported models:

ChatOpenAI (from @langchain/openai)
ChatAnthropic (from @langchain/anthropic)
ChatGoogleGenerativeAI (from @langchain/google-genai)

import { ChatOpenAI } from "@langchain/openai";
import { wrap } from "@sandboxaq/flintai-sdk-ts";

const llm = new ChatOpenAI({ model: "gpt-4" });
wrap(llm, {
  gatewayUrl: "https://app.flintai.dev",
  apiKey: "your-flintai-api-key",
});

const response = await llm.invoke("Hello");

ChatAnthropic
ChatGoogleGenerativeAI

import { ChatAnthropic } from "@langchain/anthropic";
import { wrap } from "@sandboxaq/flintai-sdk-ts";

const llm = new ChatAnthropic({ model: "claude-sonnet-4-20250514" });
wrap(llm, {
  gatewayUrl: "https://app.flintai.dev",
  apiKey: "your-flintai-api-key",
});

const response = await llm.invoke("Hello");

import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
import { wrap } from "@sandboxaq/flintai-sdk-ts";

const llm = new ChatGoogleGenerativeAI({ model: "gemini-2.5-flash" });
wrap(llm, {
  gatewayUrl: "https://app.flintai.dev",
  apiKey: "your-flintai-api-key",
});

const response = await llm.invoke("Hello");

Google ADK

ADK agents lazily create their GenAI client at runtime, so wrap() cannot be used. Use ADKGuardrailsPlugin to configure guardrails routing at the agent level:

import { ADKGuardrailsPlugin } from "@sandboxaq/flintai-sdk-ts/plugins/adk";
import { Agent } from "@google/adk";

const plugin = new ADKGuardrailsPlugin({
  gatewayUrl: "https://app.flintai.dev",
  apiKey: "your-flintai-api-key",
});

const agent = new Agent({
  model: "gemini-2.5-flash",
  generateContentConfig: plugin.contentConfig,
  beforeModelCallback: plugin.beforeModelCallback,
  onModelErrorCallback: ADKGuardrailsPlugin.onModelError,
});

The plugin handles three concerns:

Routing — contentConfig directs LLM traffic through the guardrails proxy.
Identity — beforeModelCallback attaches the ADK session ID as an X-Agent-Session-Id header on each call.
Error handling — the static ADKGuardrailsPlugin.onModelError converts guardrails blocks into an LlmResponse the agent can handle gracefully.

See Usage for the contentConfig cloning caveat.

Version compatibility

Pin your provider SDK to the tested ranges to avoid breakage from private API changes:

Provider package	Supported range
`openai`	`^6.41.0`
`@anthropic-ai/sdk`	`^0.100.1`
`@google/genai`	`^2.8.0`
`@google/adk`	`^1.2.0`
`@langchain/openai`	`^1.4.7`
`@langchain/anthropic`	`^1.4.0`
`@langchain/google-genai`	`^2.1.31`

For the three LLM SDKs, wrap() resolves the installed version and throws if it falls outside the supported range.

Known limitations

Private attribute mutation — wrap() redirects traffic by rewriting each client’s base URL and injecting the guardrails headers (X-FlintAI-API-Key, X-Guardrails-Policy-Id). For OpenAI and Anthropic this uses the internal _options.defaultHeaders, and for Google the internal apiClient.clientOptions.httpOptions. These internal attributes are not part of the providers’ public APIs and may change without notice, so pin your provider SDK versions to the tested ranges.
Google GenAI URL normalization — the Google GenAI SDK requires a trailing slash on the base URL. The SDK adds it automatically — do not add one to gatewayUrl.
Multiple provider keys in environment — if several provider API keys are set (OPENAI_API_KEY, ANTHROPIC_API_KEY, GOOGLE_API_KEY), auto-detection fails. Pass provider explicitly to init().

Overview

Get started

Discovery

Evaluation

SDK

Rules

Resources

OpenAI

Anthropic

Google GenAI

LangChain

Google ADK

Version compatibility

Known limitations

Next steps

Usage

Configuration

​OpenAI

​Anthropic

​Google GenAI

​LangChain

​Google ADK

​Version compatibility

​Known limitations

​Next steps

Usage

Configuration

OpenAI

Anthropic

Google GenAI

LangChain

Google ADK

Version compatibility

Known limitations

Next steps