babelgate 0.0.0 → 1.1.0

package/dist/transformers/adapters/anthropic.adapter.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anthropicAdapter = void 0;
+exports.toCanonicalRequest = toCanonicalRequest;
+exports.fromCanonicalRequest = fromCanonicalRequest;
+exports.toCanonicalResponse = toCanonicalResponse;
+exports.mapFinishReason = mapFinishReason;
+exports.fromCanonicalResponse = fromCanonicalResponse;
+exports.toCanonicalModelList = toCanonicalModelList;
+exports.fromCanonicalModelList = fromCanonicalModelList;
+exports.mapToAnthropicStopReason = mapToAnthropicStopReason;
+exports.toCanonicalError = toCanonicalError;
+exports.fromCanonicalError = fromCanonicalError;
+const crypto_1 = require("crypto");
+const canonical_error_1 = require("../../utils/canonical-error");
+const logger_1 = require("../../utils/logger");
+const anthropic_messages_1 = require("./anthropic.messages");
+const anthropic_stream_1 = require("./anthropic.stream");
+exports.anthropicAdapter = {
+    toCanonicalRequest,
+    fromCanonicalRequest,
+    toCanonicalResponse,
+    fromCanonicalResponse,
+    toCanonicalModelList,
+    fromCanonicalModelList,
+    toCanonicalError,
+    fromCanonicalError,
+    createStreamDecoder: anthropic_stream_1.createStreamDecoder,
+    createStreamEncoder: anthropic_stream_1.createStreamEncoder,
+};
+// ============ REQUEST: Anthropic → Canonical ============
+/**
+ * Claude Code fields with no canonical equivalent are dropped safely
+ * (spec §3.5) — a debug line names the dropped thing, never its content.
+ */
+function logDropped(request) {
+    if (request.thinking !== undefined) {
+        logger_1.logger.debug('Dropping request field "thinking" (no canonical equivalent)');
+    }
+    if (request.metadata !== undefined) {
+        logger_1.logger.debug('Dropping request field "metadata" (no canonical equivalent)');
+    }
+    if (hasCacheControl(request)) {
+        logger_1.logger.debug('Dropping "cache_control" fields (no canonical equivalent)');
+    }
+}
+/** cache_control may sit on any block, tool or system part (§3.5). */
+function hasCacheControl(value) {
+    if (Array.isArray(value))
+        return value.some(hasCacheControl);
+    if (value !== null && typeof value === "object") {
+        const obj = value;
+        if ("cache_control" in obj)
+            return true;
+        return Object.values(obj).some(hasCacheControl);
+    }
+    return false;
+}
+function toCanonicalRequest(request) {
+    logDropped(request);
+    const messages = request.messages.flatMap((m) => (0, anthropic_messages_1.toCanonicalMessage)(m));
+    // §3.5: a system array's text blocks join with a blank line.
+    const systemPrompt = !request.system
+        ? undefined
+        : typeof request.system === "string"
+            ? request.system
+            : request.system
+                .filter((b) => b.type === "text")
+                .map((b) => b.text)
+                .join("\n\n");
+    // Add system as first message if present
+    if (systemPrompt !== undefined) {
+        messages.unshift({
+            role: "system",
+            content: systemPrompt,
+        });
+    }
+    const result = {
+        model: request.model,
+        messages,
+        // Canonical treats absent and stream:false identically — only an
+        // explicit true turns streaming on.
+        ...(request.stream === true && { stream: true }),
+        ...(request.tools && { tools: request.tools.map(anthropic_messages_1.toCanonicalTool) }),
+        ...(request.tool_choice && {
+            toolChoice: (0, anthropic_messages_1.toCanonicalToolChoice)(request.tool_choice),
+        }),
+        ...(systemPrompt !== undefined && { systemPrompt }),
+        config: {
+            maxTokens: request.max_tokens,
+            ...(request.temperature !== undefined && {
+                temperature: request.temperature,
+            }),
+            ...(request.top_p !== undefined && { topP: request.top_p }),
+            ...(request.top_k !== undefined && { topK: request.top_k }),
+            ...(request.stop_sequences && { stopSequences: request.stop_sequences }),
+        },
+    };
+    return result;
+}
+// ============ REQUEST: Canonical → Anthropic ============
+function fromCanonicalRequest(request) {
+    const nonSystem = request.messages.filter((m) => m.role !== "system");
+    const messages = [];
+    for (let i = 0; i < nonSystem.length; i++) {
+        const m = nonSystem[i];
+        if (m.role === "tool") {
+            // Merge the run of consecutive tool messages into ONE user
+            // message of tool_result blocks (spec §3.4).
+            const results = [];
+            while (i < nonSystem.length && nonSystem[i].role === "tool") {
+                results.push((0, anthropic_messages_1.toToolResultBlock)(nonSystem[i]));
+                i++;
+            }
+            i--;
+            messages.push({ role: "user", content: results });
+            continue;
+        }
+        messages.push((0, anthropic_messages_1.toMessageParam)(m));
+    }
+    const systemPrompt = request.systemPrompt ||
+        request.messages.find((m) => m.role === "system")?.content;
+    const result = {
+        model: request.model,
+        messages,
+        max_tokens: request.config?.maxTokens ?? 4096,
+        ...(systemPrompt &&
+            typeof systemPrompt === "string" && { system: systemPrompt }),
+        ...(request.config?.temperature !== undefined && {
+            temperature: request.config.temperature,
+        }),
+        ...(request.config?.topP !== undefined && { top_p: request.config.topP }),
+        ...(request.config?.topK !== undefined && { top_k: request.config.topK }),
+        ...(request.config?.stopSequences && {
+            stop_sequences: request.config.stopSequences,
+        }),
+        ...(request.tools && { tools: request.tools.map(anthropic_messages_1.toAnthropicTool) }),
+        ...(request.toolChoice && {
+            tool_choice: (0, anthropic_messages_1.toAnthropicToolChoice)(request.toolChoice),
+        }),
+    };
+    if (request.stream !== undefined) {
+        result.stream = request.stream;
+    }
+    return result;
+}
+// ============ RESPONSE: Anthropic → Canonical ============
+function toCanonicalResponse(response, model) {
+    const textContent = response.content
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("");
+    const toolCalls = response.content
+        .filter((block) => block.type === "tool_use")
+        .map((block) => ({
+        id: block.id,
+        type: "function",
+        function: {
+            name: block.name,
+            arguments: JSON.stringify(block.input ?? {}),
+        },
+    }));
+    return {
+        id: response.id || `anthropic-${(0, crypto_1.randomUUID)()}`,
+        model,
+        message: {
+            role: "assistant",
+            content: textContent,
+            ...(toolCalls.length > 0 && { toolCalls }),
+        },
+        finishReason: mapFinishReason(response.stop_reason),
+        usage: {
+            inputTokens: response.usage.input_tokens,
+            outputTokens: response.usage.output_tokens,
+            totalTokens: response.usage.input_tokens + response.usage.output_tokens,
+        },
+    };
+}
+function mapFinishReason(reason) {
+    switch (reason) {
+        case "end_turn":
+            return "stop";
+        case "max_tokens":
+            return "length";
+        case "tool_use":
+            return "tool_call";
+        default:
+            return "stop";
+    }
+}
+// ============ RESPONSE: Canonical → Anthropic ============
+function fromCanonicalResponse(response) {
+    const text = typeof response.message.content === "string"
+        ? response.message.content
+        : "";
+    // Text comes before tool_use blocks (spec §3.4).
+    const content = [];
+    if (text) {
+        content.push({ type: "text", text });
+    }
+    for (const tc of response.message.toolCalls ?? []) {
+        content.push((0, anthropic_messages_1.toToolUseBlock)(tc));
+    }
+    if (content.length === 0) {
+        content.push({ type: "text", text: "" });
+    }
+    return {
+        id: response.id || `msg_${(0, crypto_1.randomUUID)()}`,
+        type: "message",
+        role: "assistant",
+        content: content,
+        model: response.model,
+        stop_reason: mapToAnthropicStopReason(response.finishReason),
+        stop_sequence: null,
+        usage: {
+            input_tokens: response.usage?.inputTokens ?? 0,
+            output_tokens: response.usage?.outputTokens ?? 0,
+        },
+    };
+}
+function toCanonicalModelList(response) {
+    const res = response;
+    return {
+        models: (res.data ?? [])
+            .filter((m) => Boolean(m.id))
+            .map((m) => ({
+            id: m.id,
+            displayName: m.display_name,
+            // ISO timestamp → Unix seconds
+            created: m.created_at
+                ? Math.floor(Date.parse(m.created_at) / 1000)
+                : undefined,
+        })),
+    };
+}
+function fromCanonicalModelList(list) {
+    return {
+        data: list.models.map((m) => ({
+            id: m.id,
+            display_name: m.displayName,
+            created_at: m.created
+                ? new Date(m.created * 1000).toISOString()
+                : undefined,
+            type: "model",
+        })),
+        has_more: false,
+    };
+}
+function mapToAnthropicStopReason(reason) {
+    switch (reason) {
+        case "stop":
+            return "end_turn";
+        case "length":
+            return "max_tokens";
+        case "tool_call":
+            return "tool_use";
+        default:
+            return "end_turn";
+    }
+}
+// ============ ERRORS ============
+const ANTHROPIC_ERROR_TYPE = {
+    invalid_request: "invalid_request_error",
+    authentication: "authentication_error",
+    permission: "permission_error",
+    not_found: "not_found_error",
+    request_too_large: "request_too_large",
+    rate_limit: "rate_limit_error",
+    unsupported: "api_error",
+    upstream: "api_error",
+    unavailable: "overloaded_error",
+    timeout: "timeout_error",
+    internal: "api_error",
+};
+function toCanonicalError(status, body) {
+    const err = body?.error;
+    const message = typeof err?.message === "string" && err.message.length > 0
+        ? err.message
+        : `Upstream anthropic returned ${status}`;
+    return (0, canonical_error_1.makeCanonicalError)((0, canonical_error_1.kindFromStatus)(status), message);
+}
+function fromCanonicalError(err) {
+    return {
+        type: "error",
+        error: {
+            type: ANTHROPIC_ERROR_TYPE[err.kind],
+            message: err.message,
+        },
+    };
+}
+// Message/tool conversion lives in ./anthropic.messages; streaming in
+// ./anthropic.stream — re-exported on the adapter above.

package/dist/transformers/adapters/anthropic.messages.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCanonicalMessage = toCanonicalMessage;
+exports.toCanonicalTool = toCanonicalTool;
+exports.toCanonicalToolChoice = toCanonicalToolChoice;
+exports.toMessageParam = toMessageParam;
+exports.toToolResultBlock = toToolResultBlock;
+exports.toToolUseBlock = toToolUseBlock;
+exports.toAnthropicTool = toAnthropicTool;
+exports.toAnthropicToolChoice = toAnthropicToolChoice;
+const tool_args_1 = require("../../utils/tool-args");
+const errors_1 = require("../../utils/errors");
+const logger_1 = require("../../utils/logger");
+// ============ Anthropic → Canonical ============
+/**
+ * One Anthropic message → one or more canonical messages (spec §3.4):
+ * a user message's tool_result blocks become one canonical tool message
+ * each (in order), followed by a user message for any remaining
+ * text/image blocks. Assistant tool_use blocks become toolCalls.
+ */
+function toCanonicalMessage(m) {
+    if (typeof m.content === "string" || !Array.isArray(m.content)) {
+        return [
+            {
+                role: m.role,
+                content: typeof m.content === "string" ? m.content : "",
+            },
+        ];
+    }
+    const blocks = m.content;
+    const toolResults = blocks.filter((b) => b.type === "tool_result");
+    const toolUses = blocks.filter((b) => b.type === "tool_use");
+    const rest = blocks.filter((b) => b.type !== "tool_result" && b.type !== "tool_use");
+    if (m.role === "user" && toolResults.length > 0) {
+        const out = toolResults.map((r) => ({
+            role: "tool",
+            toolCallId: r.tool_use_id,
+            content: toolResultContentToString(r.content),
+            ...(r.is_error === true && { isError: true }),
+        }));
+        if (rest.length > 0) {
+            out.push({ role: "user", content: extractContent(rest) });
+        }
+        return out;
+    }
+    const msg = {
+        role: m.role,
+        content: extractContent(rest),
+    };
+    if (toolUses.length > 0) {
+        msg.toolCalls = toolUses.map(toolUseToCanonical);
+    }
+    return [msg];
+}
+/**
+ * tool_result.content is a string or an array of blocks (spec §3.4). Text
+ * blocks join with "\n"; canonical tool results carry no images, so any
+ * other block type is a 400 naming it — never a silent drop.
+ */
+function toolResultContentToString(content) {
+    if (content === undefined) {
+        return "";
+    }
+    if (typeof content === "string") {
+        return content;
+    }
+    return content
+        .map((block) => {
+        if (block.type === "text") {
+            return block.text;
+        }
+        throw new errors_1.ValidationError(`Unsupported content block type "${block.type}" in tool_result`);
+    })
+        .join("\n");
+}
+function toolUseToCanonical(block) {
+    return {
+        id: block.id,
+        type: "function",
+        function: {
+            name: block.name,
+            arguments: JSON.stringify(block.input ?? {}),
+        },
+    };
+}
+function toCanonicalTool(tool) {
+    if (!("name" in tool)) {
+        // Server-side toolsets have no canonical equivalent — 400 naming
+        // the type rather than silently dropping the declaration.
+        throw new errors_1.ValidationError(`Unsupported tool type "${tool.type}" in tools[]`);
+    }
+    const fn = { name: tool.name };
+    if ("description" in tool && typeof tool.description === "string") {
+        fn.description = tool.description;
+    }
+    if ("input_schema" in tool && tool.input_schema) {
+        fn.parameters = tool.input_schema;
+    }
+    return { type: "function", function: fn };
+}
+// auto→auto, any→required, tool{name}→function choice, none→none (§3.4).
+function toCanonicalToolChoice(choice) {
+    if ("disable_parallel_tool_use" in choice &&
+        choice.disable_parallel_tool_use !== undefined) {
+        logger_1.logger.debug('Dropping tool_choice field "disable_parallel_tool_use" (no canonical equivalent)');
+    }
+    switch (choice.type) {
+        case "auto":
+            return "auto";
+        case "any":
+            return "required";
+        case "none":
+            return "none";
+        case "tool":
+            return { type: "function", function: { name: choice.name } };
+    }
+}
+/**
+ * §3.5: `thinking`/`redacted_thinking` blocks are dropped safely (debug
+ * log names the type only); any other unrecognised block type is a 400
+ * naming it — Claude Code blocks we can't honour must fail loudly, not
+ * silently turn into empty text.
+ */
+function extractContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    const parts = [];
+    for (const block of content) {
+        if (block.type === "text") {
+            parts.push({ type: "text", text: block.text });
+            continue;
+        }
+        if (block.type === "image" && "source" in block) {
+            const source = block.source;
+            if (source.type === "base64" && source.data) {
+                parts.push({
+                    type: "image",
+                    image: {
+                        data: source.data,
+                        mimeType: (source.media_type ||
+                            "image/png"),
+                    },
+                });
+            }
+            else {
+                // image without a usable base64 source keeps the old placeholder
+                parts.push({ type: "text", text: "" });
+            }
+            continue;
+        }
+        if (block.type === "thinking" || block.type === "redacted_thinking") {
+            logger_1.logger.debug(`Dropping content block "${block.type}" (no canonical equivalent)`);
+            continue;
+        }
+        throw new errors_1.ValidationError(`Unsupported content block type "${block.type}"`);
+    }
+    return parts.length > 0 ? parts : "";
+}
+// ============ Canonical → Anthropic ============
+function toMessageParam(m) {
+    const content = convertToAnthropicContent(m.content);
+    if (m.role !== "assistant" || !m.toolCalls || m.toolCalls.length === 0) {
+        return { role: m.role === "assistant" ? "assistant" : "user", content };
+    }
+    // Assistant message: text (and other content blocks) first, then the
+    // tool_use blocks (spec §3.4).
+    const blocks = typeof content === "string"
+        ? content
+            ? [{ type: "text", text: content }]
+            : []
+        : content;
+    return {
+        role: "assistant",
+        content: [...blocks, ...m.toolCalls.map(toToolUseBlock)],
+    };
+}
+function toToolResultBlock(m) {
+    return {
+        type: "tool_result",
+        tool_use_id: m.toolCallId ?? "",
+        content: convertToAnthropicContent(m.content),
+        // is_error is sent only when true; Anthropic defaults it to false.
+        ...(m.isError === true && { is_error: true }),
+    };
+}
+function toToolUseBlock(tc) {
+    const parsed = (0, tool_args_1.parseToolArguments)(tc.function.arguments);
+    if (!parsed.valid) {
+        logger_1.logger.warn("Tool call arguments are not valid JSON; sending _invalid_arguments wrapper");
+    }
+    return {
+        type: "tool_use",
+        id: tc.id,
+        name: tc.function.name,
+        input: parsed.args,
+    };
+}
+function toAnthropicTool(tool) {
+    return {
+        name: tool.function.name,
+        ...(tool.function.description && {
+            description: tool.function.description,
+        }),
+        input_schema: {
+            type: "object",
+            ...(tool.function.parameters ?? {}),
+        },
+    };
+}
+// auto→auto, required→any, none→none, function choice→tool{name} (§3.4).
+function toAnthropicToolChoice(choice) {
+    if (typeof choice === "object") {
+        return { type: "tool", name: choice.function.name };
+    }
+    switch (choice) {
+        case "auto":
+            return { type: "auto" };
+        case "required":
+            return { type: "any" };
+        case "none":
+            return { type: "none" };
+    }
+}
+function convertToAnthropicContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    const blocks = content.map((part) => {
+        if (part.type === "text") {
+            return { type: "text", text: part.text || "" };
+        }
+        if (part.type === "image" && part.image) {
+            return {
+                type: "image",
+                source: {
+                    type: "base64",
+                    media_type: validateMediaType(part.image.mimeType),
+                    data: part.image.data,
+                },
+            };
+        }
+        return { type: "text", text: "" };
+    });
+    // If only one text block, return as string
+    if (blocks.length === 1 && blocks[0].type === "text") {
+        return blocks[0].text;
+    }
+    return blocks;
+}
+function validateMediaType(type) {
+    const validTypes = [
+        "image/jpeg",
+        "image/png",
+        "image/gif",
+        "image/webp",
+    ];
+    return validTypes.includes(type)
+        ? type
+        : "image/png";
+}