copilot-router 1.0.0

package/dist/routes/anthropic/stream-translation.js

@@ -0,0 +1,136 @@
+import { mapOpenAIStopReasonToAnthropic } from "./utils.js";
+function isToolBlockOpen(state) {
+    if (!state.contentBlockOpen)
+        return false;
+    return Object.values(state.toolCalls).some((tc) => tc.anthropicBlockIndex === state.contentBlockIndex);
+}
+export function translateChunkToAnthropicEvents(chunk, state) {
+    const events = [];
+    if (chunk.choices.length === 0)
+        return events;
+    const choice = chunk.choices[0];
+    const { delta } = choice;
+    if (!state.messageStartSent) {
+        events.push({
+            type: "message_start",
+            message: {
+                id: chunk.id,
+                type: "message",
+                role: "assistant",
+                content: [],
+                model: chunk.model,
+                stop_reason: null,
+                stop_sequence: null,
+                usage: {
+                    input_tokens: (chunk.usage?.prompt_tokens ?? 0) -
+                        (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+                    output_tokens: 0,
+                    ...(chunk.usage?.prompt_tokens_details?.cached_tokens !== undefined && {
+                        cache_read_input_tokens: chunk.usage.prompt_tokens_details.cached_tokens,
+                    }),
+                },
+            },
+        });
+        state.messageStartSent = true;
+    }
+    if (delta.content) {
+        if (isToolBlockOpen(state)) {
+            events.push({
+                type: "content_block_stop",
+                index: state.contentBlockIndex,
+            });
+            state.contentBlockIndex++;
+            state.contentBlockOpen = false;
+        }
+        if (!state.contentBlockOpen) {
+            events.push({
+                type: "content_block_start",
+                index: state.contentBlockIndex,
+                content_block: {
+                    type: "text",
+                    text: "",
+                },
+            });
+            state.contentBlockOpen = true;
+        }
+        events.push({
+            type: "content_block_delta",
+            index: state.contentBlockIndex,
+            delta: {
+                type: "text_delta",
+                text: delta.content,
+            },
+        });
+    }
+    if (delta.tool_calls) {
+        for (const toolCall of delta.tool_calls) {
+            if (toolCall.id && toolCall.function?.name) {
+                if (state.contentBlockOpen) {
+                    events.push({
+                        type: "content_block_stop",
+                        index: state.contentBlockIndex,
+                    });
+                    state.contentBlockIndex++;
+                    state.contentBlockOpen = false;
+                }
+                const anthropicBlockIndex = state.contentBlockIndex;
+                state.toolCalls[toolCall.index] = {
+                    id: toolCall.id,
+                    name: toolCall.function.name,
+                    anthropicBlockIndex,
+                };
+                events.push({
+                    type: "content_block_start",
+                    index: anthropicBlockIndex,
+                    content_block: {
+                        type: "tool_use",
+                        id: toolCall.id,
+                        name: toolCall.function.name,
+                        input: {},
+                    },
+                });
+                state.contentBlockOpen = true;
+            }
+            if (toolCall.function?.arguments) {
+                const toolCallInfo = state.toolCalls[toolCall.index];
+                if (toolCallInfo) {
+                    events.push({
+                        type: "content_block_delta",
+                        index: toolCallInfo.anthropicBlockIndex,
+                        delta: {
+                            type: "input_json_delta",
+                            partial_json: toolCall.function.arguments,
+                        },
+                    });
+                }
+            }
+        }
+    }
+    if (choice.finish_reason) {
+        if (state.contentBlockOpen) {
+            events.push({
+                type: "content_block_stop",
+                index: state.contentBlockIndex,
+            });
+            state.contentBlockOpen = false;
+        }
+        events.push({
+            type: "message_delta",
+            delta: {
+                stop_reason: mapOpenAIStopReasonToAnthropic(choice.finish_reason),
+                stop_sequence: null,
+            },
+            usage: {
+                input_tokens: (chunk.usage?.prompt_tokens ?? 0) -
+                    (chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+                output_tokens: chunk.usage?.completion_tokens ?? 0,
+                ...(chunk.usage?.prompt_tokens_details?.cached_tokens !== undefined && {
+                    cache_read_input_tokens: chunk.usage.prompt_tokens_details.cached_tokens,
+                }),
+            },
+        }, {
+            type: "message_stop",
+        });
+    }
+    return events;
+}

package/dist/routes/anthropic/translation.d.ts

@@ -0,0 +1,4 @@
+import { type ChatCompletionResponse, type ChatCompletionsPayload } from "../../services/copilot/create-chat-completions.js";
+import { type AnthropicMessagesPayload, type AnthropicResponse } from "./types.js";
+export declare function translateToOpenAI(payload: AnthropicMessagesPayload): ChatCompletionsPayload;
+export declare function translateToAnthropic(response: ChatCompletionResponse): AnthropicResponse;

package/dist/routes/anthropic/translation.js

@@ -0,0 +1,241 @@
+import { mapOpenAIStopReasonToAnthropic } from "./utils.js";
+// Payload translation
+export function translateToOpenAI(payload) {
+    return {
+        model: translateModelName(payload.model),
+        messages: translateAnthropicMessagesToOpenAI(payload.messages, payload.system),
+        max_tokens: payload.max_tokens,
+        stop: payload.stop_sequences,
+        stream: payload.stream,
+        temperature: payload.temperature,
+        top_p: payload.top_p,
+        user: payload.metadata?.user_id,
+        tools: translateAnthropicToolsToOpenAI(payload.tools),
+        tool_choice: translateAnthropicToolChoiceToOpenAI(payload.tool_choice),
+    };
+}
+function translateModelName(model) {
+    // Claude models
+    if (model.startsWith("claude-sonne-4.5") || model.startsWith("claude-sonnet-4-5")) {
+        return "claude-sonnet-4.5";
+    }
+    else if (model.startsWith("claude-opus-4.5") || model.startsWith("claude-opus-4-5")) {
+        return "claude-opus-4.5";
+    }
+    else if (model.startsWith("claude-haiku-4.5") || model.startsWith("claude-haiku-4-5")) {
+        return "claude-haiku-4.5";
+    }
+    // GPT models
+    else if (model.startsWith("gpt-5.2-codex") || model.startsWith("gpt-5-2-codex")) {
+        return "gpt-5.2-codex";
+    }
+    else if (model.startsWith("gpt-5.2") || model.startsWith("gpt-5-2")) {
+        return "gpt-5.2";
+    }
+    // Gemini models
+    else if (model.startsWith("gemini-3-pro") || model.startsWith("gemini-3.0-pro")) {
+        return "gemini-3-pro-preview";
+    }
+    return model;
+}
+function translateAnthropicMessagesToOpenAI(anthropicMessages, system) {
+    const systemMessages = handleSystemPrompt(system);
+    const otherMessages = anthropicMessages.flatMap((message) => message.role === "user"
+        ? handleUserMessage(message)
+        : handleAssistantMessage(message));
+    return [...systemMessages, ...otherMessages];
+}
+function handleSystemPrompt(system) {
+    if (!system)
+        return [];
+    if (typeof system === "string") {
+        return [{ role: "system", content: system }];
+    }
+    else {
+        const systemText = system.map((block) => block.text).join("\n\n");
+        return [{ role: "system", content: systemText }];
+    }
+}
+function handleUserMessage(message) {
+    const newMessages = [];
+    if (Array.isArray(message.content)) {
+        const toolResultBlocks = message.content.filter((block) => block.type === "tool_result");
+        const otherBlocks = message.content.filter((block) => block.type !== "tool_result");
+        for (const block of toolResultBlocks) {
+            newMessages.push({
+                role: "tool",
+                tool_call_id: block.tool_use_id,
+                content: mapContent(block.content),
+            });
+        }
+        if (otherBlocks.length > 0) {
+            newMessages.push({
+                role: "user",
+                content: mapContent(otherBlocks),
+            });
+        }
+    }
+    else {
+        newMessages.push({
+            role: "user",
+            content: mapContent(message.content),
+        });
+    }
+    return newMessages;
+}
+function handleAssistantMessage(message) {
+    if (!Array.isArray(message.content)) {
+        return [
+            {
+                role: "assistant",
+                content: mapContent(message.content),
+            },
+        ];
+    }
+    const toolUseBlocks = message.content.filter((block) => block.type === "tool_use");
+    const textBlocks = message.content.filter((block) => block.type === "text");
+    const thinkingBlocks = message.content.filter((block) => block.type === "thinking");
+    const allTextContent = [
+        ...textBlocks.map((b) => b.text),
+        ...thinkingBlocks.map((b) => b.thinking),
+    ].join("\n\n");
+    return toolUseBlocks.length > 0
+        ? [
+            {
+                role: "assistant",
+                content: allTextContent || null,
+                tool_calls: toolUseBlocks.map((toolUse) => ({
+                    id: toolUse.id,
+                    type: "function",
+                    function: {
+                        name: toolUse.name,
+                        arguments: JSON.stringify(toolUse.input),
+                    },
+                })),
+            },
+        ]
+        : [
+            {
+                role: "assistant",
+                content: mapContent(message.content),
+            },
+        ];
+}
+function mapContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return null;
+    const hasImage = content.some((block) => block.type === "image");
+    if (!hasImage) {
+        return content
+            .filter((block) => block.type === "text" || block.type === "thinking")
+            .map((block) => (block.type === "text" ? block.text : block.thinking))
+            .join("\n\n");
+    }
+    const contentParts = [];
+    for (const block of content) {
+        switch (block.type) {
+            case "text":
+                contentParts.push({ type: "text", text: block.text });
+                break;
+            case "thinking":
+                contentParts.push({ type: "text", text: block.thinking });
+                break;
+            case "image":
+                contentParts.push({
+                    type: "image_url",
+                    image_url: {
+                        url: `data:${block.source.media_type};base64,${block.source.data}`,
+                    },
+                });
+                break;
+        }
+    }
+    return contentParts;
+}
+function translateAnthropicToolsToOpenAI(anthropicTools) {
+    if (!anthropicTools)
+        return undefined;
+    return anthropicTools.map((tool) => ({
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.input_schema,
+        },
+    }));
+}
+function translateAnthropicToolChoiceToOpenAI(anthropicToolChoice) {
+    if (!anthropicToolChoice)
+        return undefined;
+    switch (anthropicToolChoice.type) {
+        case "auto":
+            return "auto";
+        case "any":
+            return "required";
+        case "tool":
+            if (anthropicToolChoice.name) {
+                return { type: "function", function: { name: anthropicToolChoice.name } };
+            }
+            return undefined;
+        case "none":
+            return "none";
+        default:
+            return undefined;
+    }
+}
+// Response translation
+export function translateToAnthropic(response) {
+    const allTextBlocks = [];
+    const allToolUseBlocks = [];
+    let stopReason = null;
+    stopReason = response.choices[0]?.finish_reason ?? stopReason;
+    for (const choice of response.choices) {
+        const textBlocks = getAnthropicTextBlocks(choice.message.content);
+        const toolUseBlocks = getAnthropicToolUseBlocks(choice.message.tool_calls);
+        allTextBlocks.push(...textBlocks);
+        allToolUseBlocks.push(...toolUseBlocks);
+        if (choice.finish_reason === "tool_calls" || stopReason === "stop") {
+            stopReason = choice.finish_reason;
+        }
+    }
+    return {
+        id: response.id,
+        type: "message",
+        role: "assistant",
+        model: response.model,
+        content: [...allTextBlocks, ...allToolUseBlocks],
+        stop_reason: mapOpenAIStopReasonToAnthropic(stopReason),
+        stop_sequence: null,
+        usage: {
+            input_tokens: (response.usage?.prompt_tokens ?? 0) -
+                (response.usage?.prompt_tokens_details?.cached_tokens ?? 0),
+            output_tokens: response.usage?.completion_tokens ?? 0,
+            ...(response.usage?.prompt_tokens_details?.cached_tokens !== undefined && {
+                cache_read_input_tokens: response.usage.prompt_tokens_details.cached_tokens,
+            }),
+        },
+    };
+}
+function getAnthropicTextBlocks(messageContent) {
+    if (typeof messageContent === "string") {
+        return [{ type: "text", text: messageContent }];
+    }
+    if (Array.isArray(messageContent)) {
+        return messageContent
+            .filter((part) => part.type === "text")
+            .map((part) => ({ type: "text", text: part.text }));
+    }
+    return [];
+}
+function getAnthropicToolUseBlocks(toolCalls) {
+    if (!toolCalls)
+        return [];
+    return toolCalls.map((toolCall) => ({
+        type: "tool_use",
+        id: toolCall.id,
+        name: toolCall.function.name,
+        input: JSON.parse(toolCall.function.arguments),
+    }));
+}

package/dist/routes/anthropic/types.d.ts

@@ -0,0 +1,165 @@
+export interface AnthropicMessagesPayload {
+    model: string;
+    messages: Array<AnthropicMessage>;
+    max_tokens: number;
+    system?: string | Array<AnthropicTextBlock>;
+    metadata?: {
+        user_id?: string;
+    };
+    stop_sequences?: Array<string>;
+    stream?: boolean;
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    tools?: Array<AnthropicTool>;
+    tool_choice?: {
+        type: "auto" | "any" | "tool" | "none";
+        name?: string;
+    };
+    thinking?: {
+        type: "enabled";
+        budget_tokens?: number;
+    };
+    service_tier?: "auto" | "standard_only";
+}
+export interface AnthropicTextBlock {
+    type: "text";
+    text: string;
+}
+export interface AnthropicImageBlock {
+    type: "image";
+    source: {
+        type: "base64";
+        media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        data: string;
+    };
+}
+export interface AnthropicToolResultBlock {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+    is_error?: boolean;
+}
+export interface AnthropicToolUseBlock {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+export interface AnthropicThinkingBlock {
+    type: "thinking";
+    thinking: string;
+}
+export type AnthropicUserContentBlock = AnthropicTextBlock | AnthropicImageBlock | AnthropicToolResultBlock;
+export type AnthropicAssistantContentBlock = AnthropicTextBlock | AnthropicToolUseBlock | AnthropicThinkingBlock;
+export interface AnthropicUserMessage {
+    role: "user";
+    content: string | Array<AnthropicUserContentBlock>;
+}
+export interface AnthropicAssistantMessage {
+    role: "assistant";
+    content: string | Array<AnthropicAssistantContentBlock>;
+}
+export type AnthropicMessage = AnthropicUserMessage | AnthropicAssistantMessage;
+export interface AnthropicTool {
+    name: string;
+    description?: string;
+    input_schema: Record<string, unknown>;
+}
+export interface AnthropicResponse {
+    id: string;
+    type: "message";
+    role: "assistant";
+    content: Array<AnthropicAssistantContentBlock>;
+    model: string;
+    stop_reason: "end_turn" | "max_tokens" | "stop_sequence" | "tool_use" | "pause_turn" | "refusal" | null;
+    stop_sequence: string | null;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_creation_input_tokens?: number;
+        cache_read_input_tokens?: number;
+        service_tier?: "standard" | "priority" | "batch";
+    };
+}
+export interface AnthropicMessageStartEvent {
+    type: "message_start";
+    message: Omit<AnthropicResponse, "content" | "stop_reason" | "stop_sequence"> & {
+        content: [];
+        stop_reason: null;
+        stop_sequence: null;
+    };
+}
+export interface AnthropicContentBlockStartEvent {
+    type: "content_block_start";
+    index: number;
+    content_block: {
+        type: "text";
+        text: string;
+    } | (Omit<AnthropicToolUseBlock, "input"> & {
+        input: Record<string, unknown>;
+    }) | {
+        type: "thinking";
+        thinking: string;
+    };
+}
+export interface AnthropicContentBlockDeltaEvent {
+    type: "content_block_delta";
+    index: number;
+    delta: {
+        type: "text_delta";
+        text: string;
+    } | {
+        type: "input_json_delta";
+        partial_json: string;
+    } | {
+        type: "thinking_delta";
+        thinking: string;
+    } | {
+        type: "signature_delta";
+        signature: string;
+    };
+}
+export interface AnthropicContentBlockStopEvent {
+    type: "content_block_stop";
+    index: number;
+}
+export interface AnthropicMessageDeltaEvent {
+    type: "message_delta";
+    delta: {
+        stop_reason?: AnthropicResponse["stop_reason"];
+        stop_sequence?: string | null;
+    };
+    usage?: {
+        input_tokens?: number;
+        output_tokens: number;
+        cache_creation_input_tokens?: number;
+        cache_read_input_tokens?: number;
+    };
+}
+export interface AnthropicMessageStopEvent {
+    type: "message_stop";
+}
+export interface AnthropicPingEvent {
+    type: "ping";
+}
+export interface AnthropicErrorEvent {
+    type: "error";
+    error: {
+        type: string;
+        message: string;
+    };
+}
+export type AnthropicStreamEventData = AnthropicMessageStartEvent | AnthropicContentBlockStartEvent | AnthropicContentBlockDeltaEvent | AnthropicContentBlockStopEvent | AnthropicMessageDeltaEvent | AnthropicMessageStopEvent | AnthropicPingEvent | AnthropicErrorEvent;
+export interface AnthropicStreamState {
+    messageStartSent: boolean;
+    contentBlockIndex: number;
+    contentBlockOpen: boolean;
+    toolCalls: {
+        [openAIToolIndex: number]: {
+            id: string;
+            name: string;
+            anthropicBlockIndex: number;
+        };
+    };
+}

package/dist/routes/anthropic/types.js

@@ -0,0 +1,2 @@
+// Anthropic API Types
+export {};

package/dist/routes/anthropic/utils.d.ts

@@ -0,0 +1,2 @@
+import { type AnthropicResponse } from "./types.js";
+export declare function mapOpenAIStopReasonToAnthropic(finishReason: "stop" | "length" | "tool_calls" | "content_filter" | null): AnthropicResponse["stop_reason"];

package/dist/routes/anthropic/utils.js

@@ -0,0 +1,12 @@
+export function mapOpenAIStopReasonToAnthropic(finishReason) {
+    if (finishReason === null) {
+        return null;
+    }
+    const stopReasonMap = {
+        stop: "end_turn",
+        length: "max_tokens",
+        tool_calls: "tool_use",
+        content_filter: "end_turn",
+    };
+    return stopReasonMap[finishReason];
+}

package/dist/routes/auth/routes.d.ts

@@ -0,0 +1,2 @@
+import { OpenAPIHono } from "@hono/zod-openapi";
+export declare function registerAuthRoutes(app: OpenAPIHono): void;