babelgate 0.0.0 → 1.1.1

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

@@ -0,0 +1,418 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geminiAdapter = void 0;
+exports.toCanonicalRequest = toCanonicalRequest;
+exports.fromCanonicalRequest = fromCanonicalRequest;
+exports.toCanonicalResponse = toCanonicalResponse;
+exports.mapFinishReason = mapFinishReason;
+exports.fromCanonicalResponse = fromCanonicalResponse;
+exports.toCanonicalModelList = toCanonicalModelList;
+exports.fromCanonicalModelList = fromCanonicalModelList;
+exports.mapToGeminiFinishReason = mapToGeminiFinishReason;
+exports.toCanonicalError = toCanonicalError;
+exports.fromCanonicalError = fromCanonicalError;
+const crypto_1 = require("crypto");
+const canonical_error_1 = require("../../utils/canonical-error");
+const errors_1 = require("../../utils/errors");
+const ids_1 = require("../../utils/ids");
+const gemini_stream_1 = require("./gemini.stream");
+const gemini_tools_1 = require("./gemini.tools");
+/**
+ * Gemini FinishReason values — duplicated locally so the SDK stays a
+ * type-only dependency. These are stable API constants (string enum
+ * values), not implementation details.
+ */
+const FinishReason = {
+    STOP: "STOP",
+    MAX_TOKENS: "MAX_TOKENS",
+    SAFETY: "SAFETY",
+    RECITATION: "RECITATION",
+    BLOCKLIST: "BLOCKLIST",
+    PROHIBITED_CONTENT: "PROHIBITED_CONTENT",
+    SPII: "SPII",
+    IMAGE_SAFETY: "IMAGE_SAFETY",
+};
+exports.geminiAdapter = {
+    toCanonicalRequest,
+    fromCanonicalRequest,
+    toCanonicalResponse,
+    fromCanonicalResponse,
+    toCanonicalModelList,
+    fromCanonicalModelList,
+    toCanonicalError,
+    fromCanonicalError,
+    createStreamDecoder: gemini_stream_1.createStreamDecoder,
+    createStreamEncoder: gemini_stream_1.createStreamEncoder,
+};
+// ============ REQUEST: Gemini → Canonical ============
+function toCanonicalRequest(request) {
+    const messages = [];
+    let systemPrompt;
+    const ids = (0, ids_1.createIdGenerator)();
+    // pending call ids per function name, for matching functionResponses
+    const pendingCalls = new Map();
+    // Extract system instruction
+    if (request.systemInstruction) {
+        systemPrompt = extractTextFromInstruction(request.systemInstruction);
+    }
+    // Convert contents to messages
+    for (const content of request.contents) {
+        const parts = content.parts ?? [];
+        const otherParts = parts.filter((p) => !(0, gemini_tools_1.isFunctionResponsePart)(p));
+        if (content.role === "model") {
+            const toolCalls = (0, gemini_tools_1.toCanonicalToolCalls)(otherParts, ids);
+            for (const call of toolCalls) {
+                (0, gemini_tools_1.recordCallId)(pendingCalls, call.function.name, call.id);
+            }
+            messages.push({
+                role: "assistant",
+                content: extractContentParts({
+                    role: content.role,
+                    parts: otherParts.filter((p) => !(0, gemini_tools_1.isFunctionCallPart)(p)),
+                }),
+                ...(toolCalls.length > 0 && { toolCalls }),
+            });
+        }
+        else {
+            messages.push(...(0, gemini_tools_1.toCanonicalToolMessages)(parts, pendingCalls));
+            if (otherParts.length > 0) {
+                messages.push({
+                    role: "user",
+                    content: extractContentParts({
+                        role: content.role,
+                        parts: otherParts,
+                    }),
+                });
+            }
+        }
+    }
+    const result = {
+        model: "gemini-pro",
+        messages,
+        ...(systemPrompt && { systemPrompt }),
+    };
+    // Convert tool definitions
+    const tools = (0, gemini_tools_1.toCanonicalTools)(request.tools);
+    if (tools) {
+        result.tools = tools;
+    }
+    // Convert tool config
+    const toolChoice = (0, gemini_tools_1.toCanonicalToolChoice)(request.toolConfig);
+    if (toolChoice !== undefined) {
+        result.toolChoice = toolChoice;
+    }
+    // Convert generation config
+    if (request.generationConfig) {
+        const gc = request.generationConfig;
+        result.config = {
+            ...(gc.temperature !== undefined && { temperature: gc.temperature }),
+            ...(gc.maxOutputTokens !== undefined && {
+                maxTokens: gc.maxOutputTokens,
+            }),
+            ...(gc.topP !== undefined && { topP: gc.topP }),
+            ...(gc.topK !== undefined && { topK: gc.topK }),
+            ...(gc.stopSequences && { stopSequences: gc.stopSequences }),
+            ...(gc.candidateCount !== undefined && {
+                candidateCount: gc.candidateCount,
+            }),
+        };
+    }
+    return result;
+}
+function extractTextFromInstruction(instruction) {
+    if (!instruction)
+        return "";
+    if (typeof instruction === "string")
+        return instruction;
+    if ("text" in instruction && typeof instruction.text === "string") {
+        return instruction.text;
+    }
+    if ("parts" in instruction) {
+        return instruction.parts
+            .filter((p) => "text" in p)
+            .map((p) => p.text)
+            .join("");
+    }
+    return "";
+}
+function extractContentParts(content) {
+    if (!content.parts || content.parts.length === 0) {
+        return "";
+    }
+    // If all parts are text, join them
+    const allText = content.parts.every((p) => "text" in p);
+    if (allText) {
+        return content.parts
+            .filter((p) => "text" in p)
+            .map((p) => p.text)
+            .join("");
+    }
+    // Mixed content
+    return content.parts.map((part) => {
+        if ("text" in part) {
+            return { type: "text", text: part.text };
+        }
+        if ("inlineData" in part && part.inlineData) {
+            return {
+                type: "image",
+                image: {
+                    data: part.inlineData.data,
+                    mimeType: part.inlineData
+                        .mimeType,
+                },
+            };
+        }
+        return { type: "text", text: "" };
+    });
+}
+// ============ REQUEST: Canonical → Gemini ============
+function fromCanonicalRequest(request) {
+    // toolCallId → function name, resolved from earlier assistant messages
+    const callNames = new Map();
+    const contents = [];
+    for (const m of request.messages) {
+        if (m.role === "system")
+            continue;
+        if (m.role === "assistant") {
+            const calls = m.toolCalls ?? [];
+            let parts = convertToParts(m.content);
+            for (const call of calls) {
+                callNames.set(call.id, call.function.name);
+            }
+            if (calls.length > 0) {
+                parts = parts.filter((p) => !("text" in p && p.text === ""));
+                parts.push(...calls.map(gemini_tools_1.functionCallPart));
+            }
+            contents.push({ role: "model", parts });
+        }
+        else if (m.role === "tool") {
+            const name = m.toolCallId
+                ? callNames.get(m.toolCallId)
+                : undefined;
+            if (!name) {
+                throw new errors_1.ValidationError(`Tool result "${m.toolCallId ?? ""}" has no matching assistant tool call`);
+            }
+            (0, gemini_tools_1.appendFunctionResponsePart)(contents, (0, gemini_tools_1.functionResponsePart)(name, m.content));
+        }
+        else {
+            contents.push({
+                role: mapRoleToGemini(m.role),
+                parts: convertToParts(m.content),
+            });
+        }
+    }
+    const result = {
+        contents,
+    };
+    // Tool definitions; parameters filtered to Google's documented
+    // schema subset (spec §3.4)
+    const tools = (0, gemini_tools_1.toGeminiTools)(request.tools);
+    if (tools) {
+        result.tools = tools;
+    }
+    // Tool choice → functionCallingConfig
+    const toolConfig = (0, gemini_tools_1.toGeminiToolConfig)(request.toolChoice);
+    if (toolConfig) {
+        result.toolConfig = toolConfig;
+    }
+    // Add system instruction
+    const systemMsg = request.messages.find((m) => m.role === "system");
+    if (systemMsg || request.systemPrompt) {
+        const systemText = request.systemPrompt ||
+            (typeof systemMsg?.content === "string" ? systemMsg.content : "");
+        if (systemText) {
+            result.systemInstruction = {
+                role: "user",
+                parts: [{ text: systemText }],
+            };
+        }
+    }
+    // Add generation config
+    if (request.config) {
+        const c = request.config;
+        result.generationConfig = {
+            ...(c.temperature !== undefined && { temperature: c.temperature }),
+            ...(c.maxTokens !== undefined && { maxOutputTokens: c.maxTokens }),
+            ...(c.topP !== undefined && { topP: c.topP }),
+            ...(c.topK !== undefined && { topK: c.topK }),
+            ...(c.stopSequences && { stopSequences: c.stopSequences }),
+            ...(c.candidateCount !== undefined && {
+                candidateCount: c.candidateCount,
+            }),
+        };
+    }
+    return result;
+}
+function mapRoleToGemini(role) {
+    return role === "assistant" ? "model" : "user";
+}
+function convertToParts(content) {
+    if (typeof content === "string") {
+        return [{ text: content }];
+    }
+    return content.map((part) => {
+        if (part.type === "text") {
+            return { text: part.text || "" };
+        }
+        if (part.type === "image" && part.image) {
+            return {
+                inlineData: {
+                    mimeType: part.image.mimeType,
+                    data: part.image.data,
+                },
+            };
+        }
+        return { text: "" };
+    });
+}
+// ============ RESPONSE: Gemini → Canonical ============
+function toCanonicalResponse(response, model, ids = (0, ids_1.createIdGenerator)()) {
+    const candidate = response.candidates?.[0];
+    const content = candidate?.content;
+    const parts = content?.parts ?? [];
+    const text = parts
+        .filter((p) => "text" in p)
+        .map((p) => p.text)
+        .join("");
+    const toolCalls = (0, gemini_tools_1.toCanonicalToolCalls)(parts, ids);
+    return {
+        id: `gemini-${(0, crypto_1.randomUUID)()}`,
+        model,
+        message: {
+            role: "assistant",
+            content: text,
+            ...(toolCalls.length > 0 && { toolCalls }),
+        },
+        finishReason: toolCalls.length > 0
+            ? "tool_call"
+            : mapFinishReason(candidate?.finishReason),
+        usage: response.usageMetadata
+            ? {
+                inputTokens: response.usageMetadata.promptTokenCount ?? 0,
+                outputTokens: response.usageMetadata.candidatesTokenCount ?? 0,
+                totalTokens: response.usageMetadata.totalTokenCount ?? 0,
+            }
+            : undefined,
+    };
+}
+function mapFinishReason(reason) {
+    switch (reason) {
+        case FinishReason.STOP:
+        case "STOP":
+            return "stop";
+        case FinishReason.MAX_TOKENS:
+        case "MAX_TOKENS":
+            return "length";
+        case FinishReason.SAFETY:
+        case "SAFETY":
+        case FinishReason.RECITATION:
+        case "RECITATION":
+        case FinishReason.BLOCKLIST:
+        case "BLOCKLIST":
+        case FinishReason.PROHIBITED_CONTENT:
+        case "PROHIBITED_CONTENT":
+        case FinishReason.SPII:
+        case "SPII":
+        case FinishReason.IMAGE_SAFETY:
+        case "IMAGE_SAFETY":
+            return "content_filter";
+        default:
+            return "stop";
+    }
+}
+// ============ RESPONSE: Canonical → Gemini ============
+function fromCanonicalResponse(response) {
+    const content = typeof response.message.content === "string"
+        ? response.message.content
+        : "";
+    const toolCalls = response.message.toolCalls ?? [];
+    const parts = toolCalls.length > 0 && content === ""
+        ? toolCalls.map(gemini_tools_1.functionCallPart)
+        : [{ text: content }, ...toolCalls.map(gemini_tools_1.functionCallPart)];
+    return {
+        candidates: [
+            {
+                content: {
+                    role: "model",
+                    parts,
+                },
+                finishReason: mapToGeminiFinishReason(response.finishReason),
+                index: 0,
+            },
+        ],
+        usageMetadata: response.usage
+            ? {
+                promptTokenCount: response.usage.inputTokens,
+                candidatesTokenCount: response.usage.outputTokens,
+                totalTokenCount: response.usage.totalTokens,
+            }
+            : undefined,
+    };
+}
+function toCanonicalModelList(response) {
+    const res = response;
+    return {
+        models: (res.models ?? [])
+            .filter((m) => Boolean(m.name))
+            .map((m) => ({
+            // "models/gemini-2.0-flash" → "gemini-2.0-flash"
+            id: m.name.replace(/^models\//, ""),
+            displayName: m.displayName,
+        })),
+    };
+}
+function fromCanonicalModelList(list) {
+    return {
+        models: list.models.map((m) => ({
+            name: `models/${m.id}`,
+            displayName: m.displayName,
+        })),
+    };
+}
+function mapToGeminiFinishReason(reason) {
+    switch (reason) {
+        case "stop":
+            return FinishReason.STOP;
+        case "length":
+            return FinishReason.MAX_TOKENS;
+        case "content_filter":
+            return FinishReason.SAFETY;
+        default:
+            return FinishReason.STOP;
+    }
+}
+// ============ ERRORS ============
+const GEMINI_ERROR_STATUS = {
+    invalid_request: "INVALID_ARGUMENT",
+    authentication: "UNAUTHENTICATED",
+    permission: "PERMISSION_DENIED",
+    not_found: "NOT_FOUND",
+    request_too_large: "RESOURCE_EXHAUSTED",
+    rate_limit: "RESOURCE_EXHAUSTED",
+    unsupported: "UNIMPLEMENTED",
+    upstream: "INTERNAL",
+    unavailable: "UNAVAILABLE",
+    timeout: "DEADLINE_EXCEEDED",
+    internal: "INTERNAL",
+};
+function toCanonicalError(status, body) {
+    const err = body?.error;
+    const message = typeof err?.message === "string" && err.message.length > 0
+        ? err.message
+        : `Upstream gemini returned ${status}`;
+    const details = err?.details;
+    const keyInvalid = Array.isArray(details) &&
+        details.some((d) => typeof d === "object" &&
+            d !== null &&
+            d.reason === "API_KEY_INVALID");
+    return (0, canonical_error_1.makeCanonicalError)(keyInvalid ? "authentication" : (0, canonical_error_1.kindFromStatus)(status), message);
+}
+function fromCanonicalError(err) {
+    return {
+        error: {
+            code: err.status,
+            message: err.message,
+            status: GEMINI_ERROR_STATUS[err.kind],
+        },
+    };
+}

package/dist/transformers/adapters/gemini.schema.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Filter a JSON Schema down to the subset the Gemini API documents for
+ * function-declaration `parameters` (and responseSchema), spec §3.4.
+ * Source: https://ai.google.dev/api/generate-content#Schema
+ * (read 2026-10-27) — the documented fields minus `default`, which the
+ * doc itself marks "accepted and ignored" (owner decision 2026-10-27).
+ * Returns a new object; the input is never mutated.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toGeminiSchema = toGeminiSchema;
+const ALLOWED_KEYS = new Set([
+    "type",
+    "format",
+    "title",
+    "description",
+    "nullable",
+    "enum",
+    "maxItems",
+    "minItems",
+    "properties",
+    "required",
+    "minProperties",
+    "maxProperties",
+    "minLength",
+    "maxLength",
+    "pattern",
+    "example",
+    "anyOf",
+    "propertyOrdering",
+    "items",
+    "minimum",
+    "maximum",
+]);
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toGeminiSchema(schema) {
+    const out = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (!ALLOWED_KEYS.has(key))
+            continue;
+        if (key === "properties" && isPlainObject(value)) {
+            const properties = {};
+            for (const [name, sub] of Object.entries(value)) {
+                properties[name] = isPlainObject(sub) ? toGeminiSchema(sub) : sub;
+            }
+            out[key] = properties;
+        }
+        else if (key === "items" && isPlainObject(value)) {
+            out[key] = toGeminiSchema(value);
+        }
+        else if (key === "anyOf" && Array.isArray(value)) {
+            out[key] = value.map((sub) => isPlainObject(sub) ? toGeminiSchema(sub) : sub);
+        }
+        else {
+            out[key] = value;
+        }
+    }
+    return out;
+}