rosetta-ai

Universal translator between AI provider protocols.

Convert between OpenAI Chat Completions, OpenAI Responses, Anthropic Messages, and Google Gemini APIs — with full support for tool calling, multimodal content, extended thinking, web search, grounding, and streaming.

Install

npm install @zenmux/rosetta-ai

How It Works

Each converter follows the gateway pattern: request goes forward (user protocol → backend protocol), while response and stream go backward (backend → user).

User ──request──→ [Converter] ──request──→ Backend
User ←─response── [Converter] ←─response── Backend
User ←──stream─── [Converter] ←──stream─── Backend

One converter instance handles the full round-trip for a single gateway route.

Converters

Converter	User Protocol	Backend Protocol
ChatCompletionToMessagesConverter	OpenAI Chat Completions	Anthropic Messages
ChatCompletionToResponsesConverter	OpenAI Chat Completions	OpenAI Responses
ChatCompletionToGeminiConverter	OpenAI Chat Completions	Google Gemini
MessagesToChatCompletionConverter	Anthropic Messages	OpenAI Chat Completions
MessagesToResponsesConverter	Anthropic Messages	OpenAI Responses
MessagesToGeminiConverter	Anthropic Messages	Google Gemini
ResponsesToChatCompletionConverter	OpenAI Responses	OpenAI Chat Completions
ResponsesToMessagesConverter	OpenAI Responses	Anthropic Messages
ResponsesToGeminiConverter	OpenAI Responses	Google Gemini
GeminiToChatCompletionConverter	Google Gemini	OpenAI Chat Completions
GeminiToMessagesConverter	Google Gemini	Anthropic Messages
GeminiToResponsesConverter	Google Gemini	OpenAI Responses

Usage

OpenAI Chat Completions → Anthropic Messages

import { ChatCompletionToMessagesConverter } from "@zenmux/rosetta-ai";

const converter = new ChatCompletionToMessagesConverter();

// Request: CC → Messages (forward)
const anthropicRequest = converter.convertRequest(openaiRequest);

// Call the backend
const anthropicResponse = await anthropicClient.messages.create(anthropicRequest);

// Response: Messages → CC (backward)
const openaiResponse = converter.convertResponse(anthropicResponse);

// Streaming: Messages stream → CC stream (backward)
const stream = await anthropicClient.messages.create({ ...anthropicRequest, stream: true });
for await (const chunk of converter.convertStream(stream)) {
  // chunk is an OpenAI ChatCompletionChunk
}

Anthropic Messages → OpenAI Chat Completions

import { MessagesToChatCompletionConverter } from "@zenmux/rosetta-ai";

const converter = new MessagesToChatCompletionConverter();

// Request: Messages → CC (forward)
const openaiRequest = converter.convertRequest(anthropicRequest);

// Call the backend
const openaiResponse = await openaiClient.chat.completions.create(openaiRequest);

// Response: CC → Messages (backward)
const anthropicResponse = converter.convertResponse(openaiResponse);

// Streaming: CC stream → Messages stream (backward)
const stream = await openaiClient.chat.completions.create({ ...openaiRequest, stream: true });
for await (const event of converter.convertStream(stream)) {
  // event is an Anthropic RawMessageStreamEvent
}

OpenAI Chat Completions → OpenAI Responses

import { ChatCompletionToResponsesConverter } from "@zenmux/rosetta-ai";

const converter = new ChatCompletionToResponsesConverter();

// Request: CC → Responses (forward)
const responsesRequest = converter.convertRequest(ccRequest);

// Response: Responses → CC (backward)
const ccResponse = converter.convertResponse(responsesResponse);

// Streaming: Responses stream → CC stream (backward)
for await (const chunk of converter.convertStream(responsesStream)) {
  // chunk is an OpenAI ChatCompletionChunk
}

OpenAI Responses → OpenAI Chat Completions

import { ResponsesToChatCompletionConverter } from "@zenmux/rosetta-ai";

const converter = new ResponsesToChatCompletionConverter();

// Request: Responses → CC (forward)
const ccRequest = converter.convertRequest(responsesRequest);

// Response: CC → Responses (backward)
const responsesResponse = converter.convertResponse(ccResponse);

// Streaming: CC stream → Responses stream (backward)
for await (const event of converter.convertStream(ccStream)) {
  // event is a Responses ResponseStreamEvent
}

Anthropic Messages → OpenAI Responses

import { MessagesToResponsesConverter } from "@zenmux/rosetta-ai";

const converter = new MessagesToResponsesConverter();

// Request: Messages → Responses (forward)
const responsesRequest = converter.convertRequest(messagesRequest);

// Response: Responses → Messages (backward)
const messagesResponse = converter.convertResponse(responsesResponse);

// Streaming: Responses stream → Messages stream (backward)
for await (const event of converter.convertStream(responsesStream)) {
  // event is an Anthropic RawMessageStreamEvent
}

OpenAI Responses → Anthropic Messages

import { ResponsesToMessagesConverter } from "@zenmux/rosetta-ai";

const converter = new ResponsesToMessagesConverter();

// Request: Responses → Messages (forward)
const messagesRequest = converter.convertRequest(responsesRequest);

// Response: Messages → Responses (backward)
const responsesResponse = converter.convertResponse(anthropicResponse);

// Streaming: Messages stream → Responses stream (backward)
for await (const event of converter.convertStream(messagesStream)) {
  // event is a Responses ResponseStreamEvent
}

OpenAI Chat Completions → Google Gemini

import { ChatCompletionToGeminiConverter } from "@zenmux/rosetta-ai";
import { GoogleGenAI } from "@google/genai";

const converter = new ChatCompletionToGeminiConverter();
const genai = new GoogleGenAI({ apiKey: "..." });

// Request: CC → Gemini (forward)
const geminiRequest = converter.convertRequest(openaiRequest);

// Call the backend
const geminiResponse = await genai.models.generateContent(geminiRequest);

// Response: Gemini → CC (backward)
const openaiResponse = converter.convertResponse(geminiResponse);

// Streaming: Gemini stream → CC stream (backward)
const stream = await genai.models.generateContentStream(geminiRequest);
for await (const chunk of converter.convertStream(stream)) {
  // chunk is an OpenAI ChatCompletionChunk
}

Anthropic Messages → Google Gemini

import { MessagesToGeminiConverter } from "@zenmux/rosetta-ai";

const converter = new MessagesToGeminiConverter();

// Request: Messages → Gemini (forward)
const geminiRequest = converter.convertRequest(anthropicRequest);

// Response: Gemini → Messages (backward)
const anthropicResponse = converter.convertResponse(geminiResponse);

// Streaming: Gemini stream → Messages stream (backward)
for await (const event of converter.convertStream(geminiStream)) {
  // event is an Anthropic RawMessageStreamEvent
}

OpenAI Responses → Google Gemini

import { ResponsesToGeminiConverter } from "@zenmux/rosetta-ai";

const converter = new ResponsesToGeminiConverter();

// Request: Responses → Gemini (forward)
const geminiRequest = converter.convertRequest(responsesRequest);

// Response: Gemini → Responses (backward)
const responsesResponse = converter.convertResponse(geminiResponse);

// Streaming: Gemini stream → Responses stream (backward)
for await (const event of converter.convertStream(geminiStream)) {
  // event is a Responses ResponseStreamEvent
}

Google Gemini → OpenAI Chat Completions

import { GeminiToChatCompletionConverter } from "@zenmux/rosetta-ai";

const converter = new GeminiToChatCompletionConverter();

// Request: Gemini → CC (forward)
const ccRequest = converter.convertRequest(geminiRequest);

// Response: CC → Gemini (backward)
const geminiResponse = converter.convertResponse(ccResponse);

// Streaming: CC stream → Gemini stream (backward)
for await (const chunk of converter.convertStream(ccStream)) {
  // chunk is a Google GenerateContentResponse
}

Google Gemini → Anthropic Messages

import { GeminiToMessagesConverter } from "@zenmux/rosetta-ai";

const converter = new GeminiToMessagesConverter();

// Request: Gemini → Messages (forward)
const messagesRequest = converter.convertRequest(geminiRequest);

// Response: Messages → Gemini (backward)
const geminiResponse = converter.convertResponse(anthropicResponse);

// Streaming: Messages stream → Gemini stream (backward)
for await (const chunk of converter.convertStream(messagesStream)) {
  // chunk is a Google GenerateContentResponse
}

Google Gemini → OpenAI Responses

import { GeminiToResponsesConverter } from "@zenmux/rosetta-ai";

const converter = new GeminiToResponsesConverter();

// Request: Gemini → Responses (forward)
const responsesRequest = converter.convertRequest(geminiRequest);

// Response: Responses → Gemini (backward)
const geminiResponse = converter.convertResponse(responsesResponse);

// Streaming: Responses stream → Gemini stream (backward)
for await (const chunk of converter.convertStream(responsesStream)) {
  // chunk is a Google GenerateContentResponse
}

Supported Conversions

Chat Completions ↔ Messages

OpenAI Chat Completions	Anthropic Messages
model	model
messages (system/developer/user/assistant/tool)	system + messages (user/assistant with content blocks)
max_tokens / max_completion_tokens	max_tokens
temperature	temperature
top_p	top_p
stop	stop_sequences
tools (function)	tools (custom)
tool_choice (auto/required/none/named)	tool_choice (auto/any/none/tool)
parallel_tool_calls	tool_choice.disable_parallel_tool_use
response_format (json_schema/json_object)	output_config.format
reasoning_effort	thinking (enabled/disabled/adaptive)
user	metadata.user_id
service_tier	service_tier
web_search_options	tools (web_search_20250305)

Chat Completions ↔ Responses

OpenAI Chat Completions	OpenAI Responses
messages	input (ResponseInputItem[])
system / developer messages	instructions
max_completion_tokens	max_output_tokens
tools (function)	tools (function)
tool_choice	tool_choice
response_format	text.format
reasoning_effort	reasoning.effort
web_search_options	tools (web_search)
parallel_tool_calls	parallel_tool_calls
prompt_cache_key / prompt_cache_retention	prompt_cache_key / prompt_cache_retention

Chat Completions → Gemini

OpenAI Chat Completions	Google Gemini
model	model
messages (system/developer)	config.systemInstruction
messages (user/assistant/tool)	contents (user/model roles)
max_tokens / max_completion_tokens	config.maxOutputTokens
temperature	config.temperature
top_p	config.topP
stop	config.stopSequences
tools (function)	config.tools[].functionDeclarations
tool_choice (auto/required/none/named)	config.toolConfig.functionCallingConfig (AUTO/ANY/NONE)
response_format (json_schema/json_object)	config.responseMimeType + config.responseJsonSchema
reasoning_effort	config.thinkingConfig
web_search_options	config.tools (googleSearch)
seed	config.seed
frequency_penalty / presence_penalty	config.frequencyPenalty / config.presencePenalty
logprobs / top_logprobs	config.responseLogprobs / config.logprobs
tool_calls on assistant	functionCall parts on model content
tool role messages	functionResponse parts on user content
image_url (base64)	inlineData
image_url (URL)	fileData
file content part	inlineData / fileData
input_audio	inlineData (audio mime)

Messages ↔ Responses

Anthropic Messages	OpenAI Responses
model	model
system	instructions
messages (user/assistant with content blocks)	input (ResponseInputItem[])
max_tokens	max_output_tokens
temperature	temperature
top_p	top_p
tools (custom)	tools (function)
tools (web_search_20250305)	tools (web_search)
tool_choice (auto/any/none/tool)	tool_choice (auto/required/none/function)
tool_choice.disable_parallel_tool_use	parallel_tool_calls
thinking (enabled/disabled/adaptive)	reasoning.effort
output_config.format (json_schema)	text.format (json_schema)
metadata.user_id	metadata.user_id
service_tier	service_tier
tool_use blocks	function_call items
tool_result blocks	function_call_output items
image blocks (base64/url)	input_image parts
document blocks (base64/url/text)	input_file / input_text parts

Messages ↔ Gemini

Anthropic Messages	Google Gemini
model	model
system	config.systemInstruction
messages (user/assistant with content blocks)	contents (user/model roles)
max_tokens	config.maxOutputTokens
temperature	config.temperature
top_p	config.topP
top_k	config.topK
stop_sequences	config.stopSequences
tools (custom)	config.tools[].functionDeclarations
tools (web_search_20250305)	config.tools (googleSearch)
tool_choice (auto/any/none/tool)	config.toolConfig.functionCallingConfig (AUTO/ANY/NONE)
thinking (enabled/disabled/adaptive)	config.thinkingConfig
output_config.format (json_schema)	config.responseMimeType + config.responseJsonSchema
tool_use blocks	functionCall parts
tool_result blocks	functionResponse parts
image blocks (base64/url)	inlineData / fileData
document blocks (base64/url/text)	inlineData / fileData / text part
thinking blocks (with signature)	thought parts (thoughtSignature)

Responses ↔ Gemini

OpenAI Responses	Google Gemini
model	model
instructions	config.systemInstruction
input (ResponseInputItem[])	contents (user/model roles)
max_output_tokens	config.maxOutputTokens
temperature	config.temperature
top_p	config.topP
tools (function)	config.tools[].functionDeclarations
tools (web_search)	config.tools (googleSearch)
tool_choice	config.toolConfig.functionCallingConfig (AUTO/ANY/NONE)
reasoning.effort	config.thinkingConfig
text.format (json_schema/json_object)	config.responseMimeType + config.responseJsonSchema
include (logprobs)	config.responseLogprobs / config.logprobs
function_call items	functionCall parts
function_call_output items	functionResponse parts

Gemini Response / Stream

Google Gemini	OpenAI / Anthropic
candidates[].finishReason STOP	finish_reason: "stop" / stop_reason: "end_turn"
candidates[].finishReason MAX_TOKENS	finish_reason: "length" / stop_reason: "max_tokens"
candidates[].finishReason SAFETY	finish_reason: "content_filter" / stop_reason: "refusal"
functionCall parts	tool_calls / tool_use blocks / function_call output items
thought parts	reasoning / thinking blocks / reasoning output items
groundingMetadata.groundingChunks	annotations (url_citation) / web_search_tool_result blocks
usageMetadata.promptTokenCount	prompt_tokens / input_tokens
usageMetadata.candidatesTokenCount	completion_tokens / output_tokens
usageMetadata.cachedContentTokenCount	cached_tokens / cache_read_input_tokens
usageMetadata.thoughtsTokenCount	reasoning_tokens
usageMetadata.toolUsePromptTokenCount	added to prompt_tokens / input_tokens

Content Types

OpenAI	Anthropic
Text content	text blocks
image_url (URL or base64 data URI)	image blocks (url or base64 source)
file content part	document blocks (base64/url/text source)
tool_calls on assistant message	tool_use blocks
tool role messages	tool_result blocks in user message
reasoning / reasoning_content	thinking blocks
annotations (url_citation)	web_search_tool_result blocks

Response / Stream

OpenAI	Anthropic
finish_reason: stop/tool_calls/length/content_filter	stop_reason: end_turn/tool_use/max_tokens/refusal
usage.prompt_tokens	usage.input_tokens
usage.completion_tokens	usage.output_tokens
prompt_tokens_details.cached_tokens	cache_read_input_tokens

Streaming includes support for text, tool calls, extended thinking, web search citations, and usage reporting.

Development

npm install          # Install dependencies
npm run typecheck    # Type check
npm run lint         # Lint
npm run test         # Run tests
npm run build        # Build

License

Apache-2.0