anthropic-gateway 1.0.0

package/vendor/dist/converters/response.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpstreamResponseError = void 0;
+exports.convertResponseToAnthropic = convertResponseToAnthropic;
+exports.createErrorResponse = createErrorResponse;
+/** An upstream response was structurally unusable for Anthropic conversion. */
+class UpstreamResponseError extends Error {
+    status = 502;
+    constructor(message) {
+        super(message);
+        this.name = 'UpstreamResponseError';
+    }
+}
+exports.UpstreamResponseError = UpstreamResponseError;
+/**
+ * Convert OpenAI Chat Completion response to Anthropic Messages format
+ */
+function convertResponseToAnthropic(openaiResponse, originalModelRequested) {
+    const choice = openaiResponse.choices?.[0];
+    if (!choice?.message) {
+        throw new UpstreamResponseError('Upstream response did not include a completion choice');
+    }
+    const message = choice.message;
+    // Build content blocks
+    const content = [];
+    // Add text content if present
+    if (message.content) {
+        content.push({
+            type: 'text',
+            text: message.content,
+        });
+    }
+    // Add tool use blocks if present
+    if (message.tool_calls && message.tool_calls.length > 0) {
+        for (const toolCall of message.tool_calls) {
+            content.push(convertToolCallToToolUse(toolCall));
+        }
+    }
+    // Map finish reason
+    const stopReason = mapFinishReason(choice.finish_reason);
+    // Build usage
+    const upstreamUsage = openaiResponse.usage;
+    const usage = {
+        input_tokens: upstreamUsage?.prompt_tokens ?? 0,
+        output_tokens: upstreamUsage?.completion_tokens ?? 0,
+        cache_read_input_tokens: upstreamUsage?.prompt_tokens_details?.cached_tokens,
+    };
+    return {
+        id: `msg_${openaiResponse.id}`,
+        type: 'message',
+        role: 'assistant',
+        content,
+        model: originalModelRequested,
+        stop_reason: stopReason,
+        stop_sequence: null,
+        usage,
+    };
+}
+/**
+ * Convert OpenAI tool call to Anthropic tool_use block
+ */
+function convertToolCallToToolUse(toolCall) {
+    let input;
+    try {
+        input = JSON.parse(toolCall.function.arguments);
+    }
+    catch {
+        input = { raw: toolCall.function.arguments };
+    }
+    return {
+        type: 'tool_use',
+        id: toolCall.id,
+        name: toolCall.function.name,
+        input,
+    };
+}
+/**
+ * Map OpenAI finish_reason to Anthropic stop_reason
+ */
+function mapFinishReason(finishReason) {
+    if (!finishReason)
+        return null;
+    switch (finishReason) {
+        case 'stop':
+            return 'end_turn';
+        case 'length':
+            return 'max_tokens';
+        case 'tool_calls':
+            return 'tool_use';
+        case 'content_filter':
+            return 'end_turn'; // Map to end_turn as closest equivalent
+        default:
+            return 'end_turn';
+    }
+}
+/**
+ * Create an error response in Anthropic format
+ */
+function createErrorResponse(error, statusCode = 500) {
+    return {
+        error: {
+            type: mapErrorType(statusCode),
+            message: error.message,
+        },
+        status: statusCode,
+    };
+}
+function mapErrorType(statusCode) {
+    switch (statusCode) {
+        case 400:
+            return 'invalid_request_error';
+        case 401:
+            return 'authentication_error';
+        case 403:
+            return 'permission_error';
+        case 404:
+            return 'not_found_error';
+        case 429:
+            return 'rate_limit_error';
+        case 500:
+        default:
+            return 'api_error';
+    }
+}
+//# sourceMappingURL=response.js.map

package/vendor/dist/converters/streaming.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoundedToolIdRegistry = void 0;
+exports.streamOpenAIToAnthropic = streamOpenAIToAnthropic;
+const tools_1 = require("./tools");
+const tokenUsage_1 = require("../utils/tokenUsage");
+const errorLog_1 = require("../utils/errorLog");
+// Global counter and bounded registry for unique tool IDs within this process.
+let toolIdCounter = 0;
+class BoundedToolIdRegistry {
+    maxEntries;
+    pruneCount;
+    ids = new Set();
+    constructor(maxEntries = 10000, pruneCount = 5000) {
+        this.maxEntries = maxEntries;
+        this.pruneCount = pruneCount;
+    }
+    has(id) {
+        return this.ids.has(id);
+    }
+    /** Reserve an ID and return whether it had not been seen before. */
+    claim(id) {
+        if (this.ids.has(id)) {
+            return false;
+        }
+        this.ids.add(id);
+        if (this.ids.size > this.maxEntries) {
+            const idsToRemove = Math.min(this.pruneCount, this.ids.size);
+            const iterator = this.ids.values();
+            for (let i = 0; i < idsToRemove; i++) {
+                const oldest = iterator.next().value;
+                if (oldest === undefined)
+                    break;
+                this.ids.delete(oldest);
+            }
+        }
+        return true;
+    }
+    get size() {
+        return this.ids.size;
+    }
+}
+exports.BoundedToolIdRegistry = BoundedToolIdRegistry;
+const usedToolIds = new BoundedToolIdRegistry();
+function generateUniqueToolId() {
+    let id;
+    do {
+        toolIdCounter++;
+        const timestamp = Date.now().toString(36);
+        const counter = toolIdCounter.toString(36).padStart(4, '0');
+        const random = Math.random().toString(36).substring(2, 10);
+        id = `call_${timestamp}_${counter}_${random}`;
+    } while (usedToolIds.has(id));
+    usedToolIds.claim(id);
+    return id;
+}
+/**
+ * Transform OpenAI streaming response to Anthropic SSE format
+ */
+async function streamOpenAIToAnthropic(openaiStream, reply, originalModel, provider = '') {
+    const state = {
+        messageId: `msg_${Date.now().toString(36)}`,
+        model: originalModel,
+        responseModel: '',
+        provider,
+        contentBlockIndex: 0,
+        currentToolCalls: new Map(),
+        inputTokens: 0,
+        outputTokens: 0,
+        cachedInputTokens: 0,
+        hasStarted: false,
+        textContent: '',
+        textBlockOpen: false,
+    };
+    // Access the underlying Node.js response for SSE streaming
+    const raw = reply.raw;
+    // Set SSE headers
+    raw.setHeader('Content-Type', 'text/event-stream');
+    raw.setHeader('Cache-Control', 'no-cache');
+    raw.setHeader('Connection', 'keep-alive');
+    raw.setHeader('X-Accel-Buffering', 'no');
+    try {
+        for await (const chunk of openaiStream) {
+            processChunk(chunk, state, raw);
+        }
+        // Send final events
+        finishStream(state, raw);
+    }
+    catch (error) {
+        sendErrorEvent(normalizeStreamingError(error), state, raw);
+    }
+}
+function normalizeStreamingError(error) {
+    return error instanceof Error
+        ? error
+        : new Error(typeof error === 'string' ? error : 'Unknown streaming failure');
+}
+function processChunk(chunk, state, raw) {
+    // Update usage if present
+    if (chunk.usage) {
+        state.inputTokens = chunk.usage.prompt_tokens;
+        state.outputTokens = chunk.usage.completion_tokens;
+        state.cachedInputTokens = chunk.usage.prompt_tokens_details?.cached_tokens ?? 0;
+    }
+    // Capture response model from chunk
+    if (chunk.model && !state.responseModel) {
+        state.responseModel = chunk.model;
+    }
+    const choice = chunk.choices[0];
+    if (!choice)
+        return;
+    // Send message_start on first chunk
+    if (!state.hasStarted) {
+        sendMessageStart(state, raw);
+        state.hasStarted = true;
+    }
+    const delta = choice.delta;
+    // Handle text content
+    if (delta.content) {
+        if (!state.textBlockOpen) {
+            sendContentBlockStart(state.contentBlockIndex, 'text', '', raw);
+            state.textBlockOpen = true;
+        }
+        state.textContent += delta.content;
+        sendTextDelta(state.contentBlockIndex, delta.content, raw);
+    }
+    // Handle tool calls
+    if (delta.tool_calls) {
+        for (const toolCall of delta.tool_calls) {
+            processToolCallDelta(toolCall, state, raw);
+        }
+    }
+    // Handle finish reason
+    if (choice.finish_reason) {
+        if (state.textBlockOpen) {
+            sendContentBlockStop(state.contentBlockIndex, raw);
+            state.textBlockOpen = false;
+            state.textContent = '';
+            state.contentBlockIndex++;
+        }
+        for (const toolCall of state.currentToolCalls.values()) {
+            sendContentBlockStop(toolCall.blockIndex, raw);
+        }
+    }
+}
+function processToolCallDelta(toolCall, state, raw) {
+    const index = toolCall.index;
+    // Check if this is a new tool call
+    if (!state.currentToolCalls.has(index)) {
+        if (state.textBlockOpen) {
+            sendContentBlockStop(state.contentBlockIndex, raw);
+            state.textBlockOpen = false;
+            state.textContent = '';
+            state.contentBlockIndex++;
+        }
+        // IMPORTANT: Use the original OpenAI tool ID to maintain consistency
+        // This ID must match when tool results are sent back
+        // If OpenAI doesn't provide an ID, generate a guaranteed unique one
+        let toolId;
+        if (toolCall.id && usedToolIds.claim(toolCall.id)) {
+            toolId = toolCall.id;
+        }
+        else {
+            toolId = generateUniqueToolId();
+        }
+        const blockIndex = state.contentBlockIndex + index;
+        const newToolCall = {
+            id: toolId,
+            name: toolCall.function?.name || '',
+            arguments: '',
+            blockIndex,
+        };
+        state.currentToolCalls.set(index, newToolCall);
+        sendContentBlockStart(blockIndex, 'tool_use', newToolCall.name, raw, newToolCall.id);
+    }
+    // Update tool call data
+    const currentCall = state.currentToolCalls.get(index);
+    if (toolCall.function?.name) {
+        currentCall.name = toolCall.function.name;
+    }
+    if (toolCall.function?.arguments) {
+        currentCall.arguments += toolCall.function.arguments;
+        sendInputJsonDelta(currentCall.blockIndex, toolCall.function.arguments, raw);
+    }
+}
+function sendMessageStart(state, raw) {
+    const event = {
+        type: 'message_start',
+        message: {
+            id: state.messageId,
+            type: 'message',
+            role: 'assistant',
+            content: [],
+            model: state.model,
+            stop_reason: null,
+            stop_sequence: null,
+            usage: {
+                input_tokens: state.inputTokens,
+                output_tokens: state.outputTokens,
+                cache_read_input_tokens: state.cachedInputTokens,
+            },
+        },
+    };
+    sendSSE(event, raw);
+}
+function sendContentBlockStart(index, type, textOrName, raw, id) {
+    let contentBlock;
+    if (type === 'text') {
+        contentBlock = { type: 'text', text: '' };
+    }
+    else {
+        contentBlock = {
+            type: 'tool_use',
+            id: id || (0, tools_1.generateToolUseId)(),
+            name: textOrName,
+            input: {},
+        };
+    }
+    const event = {
+        type: 'content_block_start',
+        index,
+        content_block: contentBlock,
+    };
+    sendSSE(event, raw);
+}
+function sendTextDelta(index, text, raw) {
+    const event = {
+        type: 'content_block_delta',
+        index,
+        delta: {
+            type: 'text_delta',
+            text,
+        },
+    };
+    sendSSE(event, raw);
+}
+function sendInputJsonDelta(index, partialJson, raw) {
+    const event = {
+        type: 'content_block_delta',
+        index,
+        delta: {
+            type: 'input_json_delta',
+            partial_json: partialJson,
+        },
+    };
+    sendSSE(event, raw);
+}
+function sendContentBlockStop(index, raw) {
+    const event = {
+        type: 'content_block_stop',
+        index,
+    };
+    sendSSE(event, raw);
+}
+function finishStream(state, raw) {
+    // Determine stop reason
+    const hasToolCalls = state.currentToolCalls.size > 0;
+    const stopReason = hasToolCalls ? 'tool_use' : 'end_turn';
+    // Record token usage
+    (0, tokenUsage_1.recordUsage)({
+        provider: state.provider,
+        modelName: state.model,
+        model: state.responseModel || undefined,
+        inputTokens: state.inputTokens,
+        outputTokens: state.outputTokens,
+        cachedInputTokens: state.cachedInputTokens || undefined,
+        streaming: true,
+    });
+    // Send message_delta
+    const deltaEvent = {
+        type: 'message_delta',
+        delta: {
+            stop_reason: stopReason,
+            stop_sequence: null,
+        },
+        usage: {
+            output_tokens: state.outputTokens,
+            cache_read_input_tokens: state.cachedInputTokens,
+        },
+    };
+    sendSSE(deltaEvent, raw);
+    // Send message_stop
+    sendSSE({ type: 'message_stop' }, raw);
+    raw.end();
+}
+function sendErrorEvent(error, state, raw) {
+    // Record error to file
+    (0, errorLog_1.recordError)(error, {
+        requestId: state.messageId,
+        provider: state.provider,
+        modelName: state.model,
+        streaming: true,
+    });
+    const event = {
+        type: 'error',
+        error: {
+            type: 'api_error',
+            message: error.message,
+        },
+    };
+    sendSSE(event, raw);
+    raw.end();
+}
+function sendSSE(data, raw) {
+    raw.write(`event: ${data.type}\n`);
+    raw.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+//# sourceMappingURL=streaming.js.map

package/vendor/dist/converters/tools.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToolsToOpenAI = convertToolsToOpenAI;
+exports.convertToolChoiceToOpenAI = convertToolChoiceToOpenAI;
+exports.generateToolUseId = generateToolUseId;
+/**
+ * Convert Anthropic tool definitions to OpenAI function format
+ */
+function convertToolsToOpenAI(tools) {
+    return tools.map(tool => ({
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.input_schema,
+        },
+    }));
+}
+/**
+ * Convert Anthropic tool choice to OpenAI format
+ */
+function convertToolChoiceToOpenAI(toolChoice) {
+    switch (toolChoice.type) {
+        case 'auto':
+            return 'auto';
+        case 'any':
+            return 'required'; // OpenAI's equivalent - forces tool use
+        case 'tool':
+            if (toolChoice.name) {
+                return {
+                    type: 'function',
+                    function: { name: toolChoice.name },
+                };
+            }
+            return 'auto';
+        default:
+            return 'auto';
+    }
+}
+/**
+ * Generate a unique tool use ID in Anthropic format
+ */
+function generateToolUseId() {
+    const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    let result = 'toolu_';
+    for (let i = 0; i < 24; i++) {
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+}
+//# sourceMappingURL=tools.js.map

package/vendor/dist/converters/xmlPrompt.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateXmlToolInstructions = generateXmlToolInstructions;
+exports.hasXmlToolInstructions = hasXmlToolInstructions;
+/**
+ * Escape special XML characters in a string
+ */
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+/**
+ * Generate XML tool instructions to inject into system prompt.
+ * This enables models without native function calling to use tools via XML output.
+ */
+function generateXmlToolInstructions(tools) {
+    if (!tools || tools.length === 0) {
+        return '';
+    }
+    const toolDefinitions = tools.map(t => {
+        const schemaJson = JSON.stringify(t.input_schema, null, 2);
+        return `- **${t.name}**: ${escapeXml(t.description)}
+  Parameters: ${schemaJson}`;
+    }).join('\n\n');
+    return `
+# TOOL CALLING FORMAT
+
+You are required to use tools to fetch information or perform actions.
+To invoke a tool, you MUST use the following EXACT XML format.
+ANY deviation from this format will cause the tool call to fail.
+
+<tool_code name="TOOL_NAME">
+{"argument_name": "value"}
+</tool_code>
+
+## CRITICAL EXECUTION RULES:
+1. **NO Markdown**: Do NOT wrap the XML in \`\`\`xml or \`\`\` code blocks. Output the raw XML tags directly.
+2. **Valid JSON**: The content between the tags MUST be valid, parseable JSON.
+   - Use double quotes for keys and string values.
+   - No trailing commas.
+   - No comments using // or /*.
+3. **Exact Name Match**: The \`name\` attribute MUST match a tool name from the "Available Tools" list exactly (case-sensitive).
+4. **No Nested Content**: The JSON parameters must be the direct child of \`tool_code\`. Do not nest another \`tool\` or \`function\` tag inside.
+5. **Thinking**: If you need to think or explain your reasoning, do so in text BEFORE the \`<tool_code>\` block. Do NOT put thoughts inside the tool code.
+6. **Multiple Tools**: You may call multiple tools in sequence by outputting multiple \`<tool_code>\` blocks.
+7. **Tool Outputs**: Tool results will be provided to you in the following format:
+<tool_output>
+{result_json_or_text}
+</tool_output>
+
+## EXAMPLE (Correct):
+Thinking: I need to read the file.
+<tool_code name="Read">
+{"file_path": "src/utils.ts"}
+</tool_code>
+
+## EXAMPLES (Incorrect - DO NOT USE):
+Wrapped in code blocks:
+\`\`\`xml
+<tool_code name="Read">...</tool_code>
+\`\`\`
+
+Nested tags:
+<tool_code><tool name="Read">...</tool></tool_code>
+
+Invalid JSON (keys not quoted):
+<tool_code name="Read">
+{file_path: "src/utils.ts"}
+</tool_code>
+
+## Available Tools:
+
+${toolDefinitions}
+`;
+}
+/**
+ * Check if a system prompt already contains XML tool instructions
+ */
+function hasXmlToolInstructions(systemPrompt) {
+    return systemPrompt.includes('# TOOL CALLING FORMAT') &&
+        systemPrompt.includes('<tool_code');
+}
+//# sourceMappingURL=xmlPrompt.js.map