anthropic-gateway 1.0.0

package/vendor/dist/converters/xmlStreaming.js

@@ -0,0 +1,258 @@
+"use strict";
+// XML Streaming Converter: OpenAI text stream → Anthropic SSE with XML tool call detection
+// Uses buffered approach: accumulates complete tool calls before emitting
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamXmlOpenAIToAnthropic = streamXmlOpenAIToAnthropic;
+const tools_1 = require("./tools");
+const tokenUsage_1 = require("../utils/tokenUsage");
+const errorLog_1 = require("../utils/errorLog");
+// Regex patterns
+const THINK_BLOCK_PATTERN = /<think>[\s\S]*?<\/think>/g;
+const TOOL_CODE_PATTERN = /<tool_code\s+name\s*=\s*"([^"]+)"\s*>([\s\S]*?)<\/\s*tool_code\s*>/i;
+const NESTED_TOOL_PATTERN = /<tool\s+name="[^"]*">\s*/g;
+const CLOSE_TOOL_PATTERN = /<\/tool>\s*/g;
+/**
+ * Transform OpenAI streaming response (with XML tool calls) to Anthropic SSE format.
+ * Uses BUFFERED approach: waits for complete tool calls before emitting.
+ */
+async function streamXmlOpenAIToAnthropic(openaiStream, reply, originalModel, provider = '') {
+    const state = {
+        messageId: `msg_${Date.now().toString(36)}`,
+        model: originalModel,
+        responseModel: '',
+        provider,
+        contentBlockIndex: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cachedInputTokens: 0,
+        hasStarted: false,
+        buffer: '',
+        toolCallsEmitted: 0,
+    };
+    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);
+        }
+        // Final flush - emit any remaining text
+        flushRemainingContent(state, raw);
+        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
+    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 textDelta = choice.delta?.content || '';
+    if (!textDelta)
+        return;
+    // Add to buffer
+    state.buffer += textDelta;
+    // Process buffer for complete tool calls
+    processBuffer(state, raw);
+}
+function processBuffer(state, raw) {
+    // Keep processing until no more complete tool calls are found
+    while (true) {
+        // Remove <think> blocks from consideration
+        const cleanBuffer = state.buffer.replace(THINK_BLOCK_PATTERN, '');
+        // Check for complete tool call
+        const toolMatch = cleanBuffer.match(TOOL_CODE_PATTERN);
+        if (!toolMatch) {
+            // No complete tool call found, exit loop
+            break;
+        }
+        const [fullMatch, toolName, rawArgs] = toolMatch;
+        const matchStart = cleanBuffer.indexOf(fullMatch);
+        // Get text BEFORE the tool call
+        const textBeforeTool = cleanBuffer.substring(0, matchStart);
+        const cleanText = textBeforeTool.trim();
+        // Emit text block if there's content
+        if (cleanText.length > 0) {
+            emitTextBlock(cleanText, state, raw);
+        }
+        // Clean and emit tool use block
+        const cleanArgs = cleanToolArgs(rawArgs);
+        emitToolUseBlock(toolName, cleanArgs, state, raw);
+        // Update buffer: remove everything up to and including the tool call
+        // We need to find the position in the ORIGINAL buffer (with think blocks)
+        const originalMatchEnd = state.buffer.indexOf('</tool_code>') + '</tool_code>'.length;
+        state.buffer = state.buffer.substring(originalMatchEnd);
+    }
+}
+function flushRemainingContent(state, raw) {
+    // Clean remaining buffer
+    const cleanBuffer = state.buffer.replace(THINK_BLOCK_PATTERN, '').trim();
+    // Get any remaining text
+    const remainingText = cleanBuffer.trim();
+    if (remainingText.length > 0) {
+        emitTextBlock(remainingText, state, raw);
+    }
+}
+function cleanToolArgs(args) {
+    let cleaned = args;
+    // Remove nested <tool name="..."> tags
+    cleaned = cleaned.replace(NESTED_TOOL_PATTERN, '');
+    // Remove </tool> closing tags
+    cleaned = cleaned.replace(CLOSE_TOOL_PATTERN, '');
+    // Remove any leading ToolName\n pattern
+    cleaned = cleaned.replace(/^[A-Za-z_][A-Za-z0-9_]*\s*\n/, '');
+    return cleaned.trim();
+}
+function emitTextBlock(text, state, raw) {
+    // Start text block
+    const startEvent = {
+        type: 'content_block_start',
+        index: state.contentBlockIndex,
+        content_block: { type: 'text', text: '' },
+    };
+    sendSSE(startEvent, raw);
+    // Send text delta
+    const deltaEvent = {
+        type: 'content_block_delta',
+        index: state.contentBlockIndex,
+        delta: { type: 'text_delta', text },
+    };
+    sendSSE(deltaEvent, raw);
+    // Stop text block
+    const stopEvent = {
+        type: 'content_block_stop',
+        index: state.contentBlockIndex,
+    };
+    sendSSE(stopEvent, raw);
+    state.contentBlockIndex++;
+}
+function emitToolUseBlock(toolName, args, state, raw) {
+    const toolId = (0, tools_1.generateToolUseId)();
+    // Start tool_use block
+    const startEvent = {
+        type: 'content_block_start',
+        index: state.contentBlockIndex,
+        content_block: {
+            type: 'tool_use',
+            id: toolId,
+            name: toolName,
+            input: {},
+        },
+    };
+    sendSSE(startEvent, raw);
+    // Send complete input as single delta
+    const deltaEvent = {
+        type: 'content_block_delta',
+        index: state.contentBlockIndex,
+        delta: {
+            type: 'input_json_delta',
+            partial_json: args,
+        },
+    };
+    sendSSE(deltaEvent, raw);
+    // Stop tool_use block
+    const stopEvent = {
+        type: 'content_block_stop',
+        index: state.contentBlockIndex,
+    };
+    sendSSE(stopEvent, raw);
+    state.contentBlockIndex++;
+    state.toolCallsEmitted++;
+}
+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 finishStream(state, raw) {
+    // Determine stop reason
+    const stopReason = state.toolCallsEmitted > 0 ? '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=xmlStreaming.js.map

package/vendor/dist/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateClaudeSettings = exports.updateClaudeJson = exports.configExists = exports.preserveProxyAuthToken = exports.ensureProxyAuthToken = exports.saveConfig = exports.loadConfig = exports.findAvailablePort = exports.createServer = void 0;
+// Main library exports
+__exportStar(require("./types"), exports);
+__exportStar(require("./converters"), exports);
+var server_1 = require("./server");
+Object.defineProperty(exports, "createServer", { enumerable: true, get: function () { return server_1.createServer; } });
+Object.defineProperty(exports, "findAvailablePort", { enumerable: true, get: function () { return server_1.findAvailablePort; } });
+var config_1 = require("./utils/config");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_1.loadConfig; } });
+Object.defineProperty(exports, "saveConfig", { enumerable: true, get: function () { return config_1.saveConfig; } });
+Object.defineProperty(exports, "ensureProxyAuthToken", { enumerable: true, get: function () { return config_1.ensureProxyAuthToken; } });
+Object.defineProperty(exports, "preserveProxyAuthToken", { enumerable: true, get: function () { return config_1.preserveProxyAuthToken; } });
+Object.defineProperty(exports, "configExists", { enumerable: true, get: function () { return config_1.configExists; } });
+Object.defineProperty(exports, "updateClaudeJson", { enumerable: true, get: function () { return config_1.updateClaudeJson; } });
+Object.defineProperty(exports, "updateClaudeSettings", { enumerable: true, get: function () { return config_1.updateClaudeSettings; } });
+//# sourceMappingURL=index.js.map

package/vendor/dist/server/handlers.js

@@ -0,0 +1,184 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMessagesHandler = createMessagesHandler;
+const openai_1 = __importDefault(require("openai"));
+const crypto_1 = require("crypto");
+const request_1 = require("../converters/request");
+const provider_1 = require("../utils/provider");
+const response_1 = require("../converters/response");
+const streaming_1 = require("../converters/streaming");
+const xmlStreaming_1 = require("../converters/xmlStreaming");
+const validation_1 = require("../utils/validation");
+const logger_1 = require("../utils/logger");
+const tokenUsage_1 = require("../utils/tokenUsage");
+const errorLog_1 = require("../utils/errorLog");
+// Request ID counter for unique identification
+let requestIdCounter = 0;
+function generateRequestId() {
+    requestIdCounter++;
+    const timestamp = Date.now().toString(36);
+    const counter = requestIdCounter.toString(36).padStart(4, '0');
+    return `req_${timestamp}_${counter}`;
+}
+function matchesProxyToken(value, expectedToken) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    const received = Buffer.from(value);
+    const expected = Buffer.from(expectedToken);
+    return received.length === expected.length && (0, crypto_1.timingSafeEqual)(received, expected);
+}
+function isAuthenticated(request, expectedToken) {
+    const authorization = request.headers.authorization;
+    if (typeof authorization === 'string' && authorization.startsWith('Bearer ')) {
+        return matchesProxyToken(authorization.slice('Bearer '.length), expectedToken);
+    }
+    return matchesProxyToken(request.headers['x-api-key'], expectedToken);
+}
+/**
+ * Handle POST /v1/messages requests
+ */
+function createMessagesHandler(config) {
+    const isAzure = (0, provider_1.isAzureOpenAIEndpoint)(config.baseUrl);
+    const openai = new openai_1.default({
+        baseURL: config.baseUrl,
+        apiKey: config.apiKey,
+    });
+    return async (request, reply) => {
+        const requestId = generateRequestId();
+        const log = logger_1.logger.withRequestId(requestId);
+        // Add request ID to response headers for client tracing
+        reply.header('X-Request-Id', requestId);
+        if (!isAuthenticated(request, config.proxyAuthToken)) {
+            const errorResponse = (0, response_1.createErrorResponse)(new Error('Invalid proxy authentication token'), 401);
+            reply.code(401).send({ error: errorResponse.error });
+            return;
+        }
+        try {
+            // Validate request before processing
+            const validation = (0, validation_1.validateAnthropicRequest)(request.body);
+            if (!validation.valid) {
+                const errorMessage = (0, validation_1.formatValidationErrors)(validation.errors);
+                log.warn('Invalid request', { errors: validation.errors });
+                const errorResponse = (0, response_1.createErrorResponse)(new Error(errorMessage), 400);
+                reply.code(400).send({ error: errorResponse.error });
+                return;
+            }
+            const anthropicRequest = request.body;
+            const targetModel = anthropicRequest.model;
+            const isStreaming = anthropicRequest.stream ?? false;
+            log.info(`→ ${targetModel} [sent]`);
+            // Determine tool calling style from config
+            const toolStyle = config.toolFormat || 'native';
+            // Convert request to OpenAI format
+            const openaiRequest = (0, request_1.convertRequestToOpenAI)(anthropicRequest, targetModel, toolStyle, isAzure);
+            // Log tool calling mode when tools are present
+            if (toolStyle === 'xml' && anthropicRequest.tools?.length) {
+                log.info(`Using XML tool calling mode (${anthropicRequest.tools.length} tools)`);
+            }
+            if (isStreaming) {
+                if (toolStyle === 'xml') {
+                    await handleXmlStreamingRequest(openai, openaiRequest, reply, anthropicRequest.model, config.baseUrl, log);
+                }
+                else {
+                    await handleStreamingRequest(openai, openaiRequest, reply, anthropicRequest.model, config.baseUrl, log);
+                }
+            }
+            else {
+                await handleNonStreamingRequest(openai, openaiRequest, reply, anthropicRequest.model, config.baseUrl, log);
+            }
+            log.info(`← ${targetModel} [received]`);
+        }
+        catch (error) {
+            const body = request.body;
+            handleError(error, reply, log, {
+                requestId,
+                provider: config.baseUrl,
+                modelName: body?.model ?? 'unknown',
+                streaming: body?.stream ?? false,
+            });
+        }
+    };
+}
+/**
+ * Handle non-streaming API request
+ */
+async function handleNonStreamingRequest(openai, openaiRequest, reply, originalModel, provider, log) {
+    log.debug('Making non-streaming request');
+    const response = await openai.chat.completions.create({
+        ...openaiRequest,
+        stream: false,
+    });
+    log.debug('Response received', {
+        finishReason: response.choices[0]?.finish_reason,
+        usage: response.usage,
+    });
+    // Record token usage
+    if (response.usage) {
+        (0, tokenUsage_1.recordUsage)({
+            provider,
+            modelName: originalModel,
+            model: response.model,
+            inputTokens: response.usage.prompt_tokens,
+            outputTokens: response.usage.completion_tokens,
+            cachedInputTokens: response.usage.prompt_tokens_details?.cached_tokens,
+            streaming: false,
+        });
+    }
+    const anthropicResponse = (0, response_1.convertResponseToAnthropic)(response, originalModel);
+    reply.send(anthropicResponse);
+}
+/**
+ * Handle streaming API request
+ */
+async function handleStreamingRequest(openai, openaiRequest, reply, originalModel, provider, log) {
+    log.debug('Making streaming request');
+    const stream = await openai.chat.completions.create({
+        ...openaiRequest,
+        stream: true,
+    });
+    reply.hijack();
+    await (0, streaming_1.streamOpenAIToAnthropic)(stream, reply, originalModel, provider);
+    log.debug('Streaming completed');
+}
+/**
+ * Handle XML streaming API request (for models without native tool calling)
+ */
+async function handleXmlStreamingRequest(openai, openaiRequest, reply, originalModel, provider, log) {
+    log.debug('Making XML streaming request (experimental)');
+    const stream = await openai.chat.completions.create({
+        ...openaiRequest,
+        stream: true,
+    });
+    reply.hijack();
+    await (0, xmlStreaming_1.streamXmlOpenAIToAnthropic)(stream, reply, originalModel, provider);
+    log.debug('XML streaming completed');
+}
+/**
+ * Handle errors and send appropriate response
+ */
+function handleError(caughtError, reply, log, context) {
+    const error = caughtError instanceof Error
+        ? caughtError
+        : new Error(typeof caughtError === 'string' ? caughtError : 'Unknown request failure');
+    const rawStatus = typeof caughtError === 'object' && caughtError !== null && 'status' in caughtError
+        ? caughtError.status
+        : undefined;
+    const statusCode = typeof rawStatus === 'number' &&
+        Number.isInteger(rawStatus) &&
+        rawStatus >= 400 &&
+        rawStatus <= 599
+        ? rawStatus
+        : 500;
+    log.error('Request failed', error, { statusCode });
+    // Record error to file if context is available
+    if (context) {
+        (0, errorLog_1.recordError)(error, context);
+    }
+    const errorResponse = (0, response_1.createErrorResponse)(error, statusCode);
+    reply.code(errorResponse.status).send({ error: errorResponse.error });
+}
+//# sourceMappingURL=handlers.js.map

package/vendor/dist/server/index.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = createServer;
+exports.findAvailablePort = findAvailablePort;
+// Fastify proxy server setup
+const fastify_1 = __importDefault(require("fastify"));
+const handlers_1 = require("./handlers");
+const logger_1 = require("../utils/logger");
+// Default graceful shutdown timeout in milliseconds
+const DEFAULT_SHUTDOWN_TIMEOUT = 10000;
+/**
+ * Create the proxy server with configured routes
+ */
+function createServer(config) {
+    if (typeof config.proxyAuthToken !== 'string' || config.proxyAuthToken.length === 0) {
+        throw new Error('proxyAuthToken is required to start the Claude Adapter server');
+    }
+    const app = (0, fastify_1.default)({ logger: false });
+    // Health check endpoint
+    app.get('/health', async (_request, _reply) => {
+        return { status: 'ok', adapter: 'claude-adapter' };
+    });
+    // Main messages endpoint (matches Anthropic API)
+    app.post('/v1/messages', (0, handlers_1.createMessagesHandler)(config));
+    return {
+        app,
+        start: async (port) => {
+            try {
+                await app.listen({ port, host: '127.0.0.1' });
+                const address = app.server.address();
+                const actualPort = typeof address === 'object' && address ? address.port : port;
+                const url = `http://127.0.0.1:${actualPort}`;
+                return url;
+            }
+            catch (err) {
+                if (err.code === 'EADDRINUSE') {
+                    throw new Error(`Port ${port} is already in use. Try a different port.`);
+                }
+                throw err;
+            }
+        },
+        stop: async (timeout = DEFAULT_SHUTDOWN_TIMEOUT) => {
+            // Create a timeout promise for force shutdown
+            let timeoutId;
+            const forceShutdown = new Promise((resolve) => {
+                timeoutId = setTimeout(() => {
+                    logger_1.logger.warn('Graceful shutdown timeout exceeded, forcing close');
+                    resolve();
+                }, timeout);
+            });
+            try {
+                // Race between graceful close and timeout
+                await Promise.race([app.close(), forceShutdown]);
+            }
+            finally {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+            }
+        },
+    };
+}
+/**
+ * Find an available port starting from the preferred port
+ */
+async function findAvailablePort(preferredPort) {
+    const net = await Promise.resolve().then(() => __importStar(require('net')));
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.listen(preferredPort, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : preferredPort;
+            server.close(() => resolve(port));
+        });
+        server.on('error', () => {
+            // Port is in use, try next port
+            resolve(findAvailablePort(preferredPort + 1));
+        });
+    });
+}
+//# sourceMappingURL=index.js.map

package/vendor/dist/types/anthropic.js

@@ -0,0 +1,4 @@
+"use strict";
+// Anthropic API Types for Messages endpoint
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=anthropic.js.map

package/vendor/dist/types/config.js

@@ -0,0 +1,4 @@
+"use strict";
+// Configuration types for claude-adapter
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=config.js.map

package/vendor/dist/types/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Type exports
+__exportStar(require("./anthropic"), exports);
+__exportStar(require("./openai"), exports);
+__exportStar(require("./config"), exports);
+//# sourceMappingURL=index.js.map

package/vendor/dist/types/openai.js

@@ -0,0 +1,4 @@
+"use strict";
+// OpenAI Chat Completions API Types
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=openai.js.map