babelgate 0.0.0 → 1.1.1

package/dist/transformers/index.js

@@ -0,0 +1,110 @@
+"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.PROVIDER_ROUTES = exports.PROVIDER_PATHS = exports.adapters = void 0;
+exports.transformRequest = transformRequest;
+exports.transformResponse = transformResponse;
+exports.getTransformers = getTransformers;
+exports.toCanonical = toCanonical;
+exports.fromCanonical = fromCanonical;
+const errors_1 = require("../utils/errors");
+const adapters_1 = require("./adapters");
+// Re-export adapters
+var adapters_2 = require("./adapters");
+Object.defineProperty(exports, "adapters", { enumerable: true, get: function () { return adapters_2.adapters; } });
+Object.defineProperty(exports, "PROVIDER_PATHS", { enumerable: true, get: function () { return adapters_2.PROVIDER_PATHS; } });
+Object.defineProperty(exports, "PROVIDER_ROUTES", { enumerable: true, get: function () { return adapters_2.PROVIDER_ROUTES; } });
+__exportStar(require("../types/canonical.types"), exports);
+/**
+ * Transform a request from source provider format to target provider format.
+ * Uses canonical format as intermediate representation.
+ *
+ * Flow: Source Request → Canonical → Target Request
+ */
+function transformRequest(sourceProvider, targetProvider, request) {
+    const sourceAdapter = adapters_1.adapters[sourceProvider];
+    const targetAdapter = adapters_1.adapters[targetProvider];
+    if (!sourceAdapter) {
+        throw new errors_1.ConfigurationError(`Unknown source provider: ${sourceProvider}`, {
+            availableProviders: Object.keys(adapters_1.adapters),
+        });
+    }
+    if (!targetAdapter) {
+        throw new errors_1.ConfigurationError(`Unknown target provider: ${targetProvider}`, {
+            availableProviders: Object.keys(adapters_1.adapters),
+        });
+    }
+    // Source → Canonical → Target
+    const canonical = sourceAdapter.toCanonicalRequest(request);
+    return targetAdapter.fromCanonicalRequest(canonical);
+}
+/**
+ * Transform a response from target provider format back to source provider format.
+ * Uses canonical format as intermediate representation.
+ *
+ * Flow: Target Response → Canonical → Source Response
+ */
+function transformResponse(sourceProvider, targetProvider, response, model) {
+    const sourceAdapter = adapters_1.adapters[sourceProvider];
+    const targetAdapter = adapters_1.adapters[targetProvider];
+    if (!sourceAdapter) {
+        throw new errors_1.ConfigurationError(`Unknown source provider: ${sourceProvider}`, {
+            availableProviders: Object.keys(adapters_1.adapters),
+        });
+    }
+    if (!targetAdapter) {
+        throw new errors_1.ConfigurationError(`Unknown target provider: ${targetProvider}`, {
+            availableProviders: Object.keys(adapters_1.adapters),
+        });
+    }
+    // Target → Canonical → Source
+    const canonical = targetAdapter.toCanonicalResponse(response, model);
+    return sourceAdapter.fromCanonicalResponse(canonical);
+}
+/**
+ * Get transformer functions for a source-target pair.
+ * Returns functions that handle the full transformation pipeline.
+ */
+function getTransformers(sourceProvider, targetProvider) {
+    return {
+        transformRequest: (request) => transformRequest(sourceProvider, targetProvider, request),
+        transformResponse: (response, model) => transformResponse(sourceProvider, targetProvider, response, model),
+    };
+}
+/**
+ * Convert any provider request to canonical format.
+ */
+function toCanonical(provider, request) {
+    const adapter = adapters_1.adapters[provider];
+    if (!adapter) {
+        throw new errors_1.ConfigurationError(`Unknown provider: ${provider}`, {
+            availableProviders: Object.keys(adapters_1.adapters),
+        });
+    }
+    return adapter.toCanonicalRequest(request);
+}
+/**
+ * Convert canonical request to any provider format.
+ */
+function fromCanonical(provider, request) {
+    const adapter = adapters_1.adapters[provider];
+    if (!adapter) {
+        throw new errors_1.ConfigurationError(`Unknown provider: ${provider}`, {
+            availableProviders: Object.keys(adapters_1.adapters),
+        });
+    }
+    return adapter.fromCanonicalRequest(request);
+}

package/dist/types/anthropic.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/canonical.schema.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalStreamEventSchema = exports.canonicalModelListSchema = exports.canonicalModelSchema = exports.canonicalErrorSchema = exports.canonicalErrorKindSchema = exports.canonicalResponseSchema = exports.canonicalUsageSchema = exports.finishReasonSchema = exports.canonicalRequestSchema = exports.canonicalToolChoiceSchema = exports.canonicalToolSchema = exports.canonicalConfigSchema = exports.canonicalMessageSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Zod schemas mirroring canonical.types.ts.
+ * Used for runtime contract validation of adapter outputs.
+ */
+const roleSchema = zod_1.z.enum(["system", "user", "assistant", "tool"]);
+const mimeTypeSchema = zod_1.z.enum([
+    "image/jpeg",
+    "image/png",
+    "image/gif",
+    "image/webp",
+]);
+const imageSchema = zod_1.z.object({
+    data: zod_1.z.string(),
+    mimeType: mimeTypeSchema,
+});
+const contentPartSchema = zod_1.z
+    .object({
+    type: zod_1.z.enum(["text", "image"]),
+    text: zod_1.z.string().optional(),
+    image: imageSchema.optional(),
+})
+    .refine((p) => (p.type === "text" ? p.text !== undefined : true), {
+    message: "content part of type 'text' must have text",
+});
+const toolCallSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    type: zod_1.z.literal("function"),
+    function: zod_1.z.object({
+        name: zod_1.z.string(),
+        arguments: zod_1.z.string(),
+    }),
+});
+exports.canonicalMessageSchema = zod_1.z.object({
+    role: roleSchema,
+    content: zod_1.z.union([zod_1.z.string(), zod_1.z.array(contentPartSchema)]),
+    toolCalls: zod_1.z.array(toolCallSchema).optional(),
+    toolCallId: zod_1.z.string().optional(),
+    isError: zod_1.z.boolean().optional(),
+    name: zod_1.z.string().optional(),
+});
+exports.canonicalConfigSchema = zod_1.z.object({
+    temperature: zod_1.z.number().optional(),
+    maxTokens: zod_1.z.number().int().positive().optional(),
+    topP: zod_1.z.number().optional(),
+    topK: zod_1.z.number().int().positive().optional(),
+    stopSequences: zod_1.z.array(zod_1.z.string()).optional(),
+    candidateCount: zod_1.z.number().int().positive().optional(),
+    seed: zod_1.z.number().optional(),
+    frequencyPenalty: zod_1.z.number().optional(),
+    presencePenalty: zod_1.z.number().optional(),
+    contextWindow: zod_1.z.number().int().positive().optional(),
+});
+const functionSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    parameters: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+});
+exports.canonicalToolSchema = zod_1.z.object({
+    type: zod_1.z.literal("function"),
+    function: functionSchema,
+});
+exports.canonicalToolChoiceSchema = zod_1.z.union([
+    zod_1.z.enum(["auto", "none", "required"]),
+    zod_1.z.object({
+        type: zod_1.z.literal("function"),
+        function: zod_1.z.object({ name: zod_1.z.string() }),
+    }),
+]);
+exports.canonicalRequestSchema = zod_1.z.object({
+    model: zod_1.z.string().min(1),
+    messages: zod_1.z.array(exports.canonicalMessageSchema).min(1),
+    systemPrompt: zod_1.z.string().optional(),
+    config: exports.canonicalConfigSchema.optional(),
+    tools: zod_1.z.array(exports.canonicalToolSchema).optional(),
+    toolChoice: exports.canonicalToolChoiceSchema.optional(),
+    stream: zod_1.z.boolean().optional(),
+});
+exports.finishReasonSchema = zod_1.z.enum([
+    "stop",
+    "length",
+    "tool_call",
+    "content_filter",
+    "error",
+    "unknown",
+]);
+exports.canonicalUsageSchema = zod_1.z.object({
+    inputTokens: zod_1.z.number().int().nonnegative(),
+    outputTokens: zod_1.z.number().int().nonnegative(),
+    totalTokens: zod_1.z.number().int().nonnegative(),
+});
+exports.canonicalResponseSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1),
+    model: zod_1.z.string().min(1),
+    message: exports.canonicalMessageSchema,
+    finishReason: exports.finishReasonSchema,
+    usage: exports.canonicalUsageSchema.optional(),
+    created: zod_1.z.number().optional(),
+});
+// ============ ERRORS ============
+exports.canonicalErrorKindSchema = zod_1.z.enum([
+    "invalid_request",
+    "authentication",
+    "permission",
+    "not_found",
+    "request_too_large",
+    "rate_limit",
+    "unsupported",
+    "upstream",
+    "unavailable",
+    "timeout",
+    "internal",
+]);
+exports.canonicalErrorSchema = zod_1.z.object({
+    kind: exports.canonicalErrorKindSchema,
+    status: zod_1.z.number().int(),
+    message: zod_1.z.string(),
+    retryAfterSeconds: zod_1.z.number().optional(),
+});
+// ============ MODEL LIST ============
+exports.canonicalModelSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1),
+    displayName: zod_1.z.string().optional(),
+    created: zod_1.z.number().optional(),
+    ownedBy: zod_1.z.string().optional(),
+});
+exports.canonicalModelListSchema = zod_1.z.object({
+    models: zod_1.z.array(exports.canonicalModelSchema),
+});
+// ============ STREAMING ============
+const streamIndexSchema = zod_1.z.number().int().nonnegative();
+exports.canonicalStreamEventSchema = zod_1.z.discriminatedUnion("type", [
+    zod_1.z.object({
+        type: zod_1.z.literal("message_start"),
+        id: zod_1.z.string(),
+        model: zod_1.z.string(),
+    }),
+    zod_1.z.object({ type: zod_1.z.literal("text_delta"), text: zod_1.z.string() }),
+    zod_1.z.object({
+        type: zod_1.z.literal("tool_call_start"),
+        index: streamIndexSchema,
+        id: zod_1.z.string(),
+        name: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal("tool_call_delta"),
+        index: streamIndexSchema,
+        argumentsDelta: zod_1.z.string(),
+    }),
+    zod_1.z.object({ type: zod_1.z.literal("tool_call_end"), index: streamIndexSchema }),
+    zod_1.z.object({ type: zod_1.z.literal("usage"), usage: exports.canonicalUsageSchema }),
+    zod_1.z.object({
+        type: zod_1.z.literal("message_end"),
+        finishReason: exports.finishReasonSchema,
+    }),
+    zod_1.z.object({ type: zod_1.z.literal("error"), error: exports.canonicalErrorSchema }),
+]);

package/dist/types/canonical.types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Canonical LLM API Types
+ *
+ * Provider-agnostic format that serves as the intermediate representation
+ * for transforming between different LLM API formats.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/gemini.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/ollama.types.js

@@ -0,0 +1,4 @@
+"use strict";
+// Ollama API types
+// Reference: https://github.com/ollama/ollama/blob/main/docs/api.md
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/openai.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/canonical-error.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CANONICAL_ERROR_STATUS = void 0;
+exports.kindFromStatus = kindFromStatus;
+exports.makeCanonicalError = makeCanonicalError;
+exports.parseRetryAfter = parseRetryAfter;
+/** HTTP status the client sees for each canonical kind (spec §3.3). */
+exports.CANONICAL_ERROR_STATUS = {
+    invalid_request: 400,
+    authentication: 401,
+    permission: 403,
+    not_found: 404,
+    request_too_large: 413,
+    rate_limit: 429,
+    internal: 500,
+    unsupported: 501,
+    upstream: 502,
+    unavailable: 503,
+    timeout: 504,
+};
+/** Map an HTTP status to the canonical kind (spec §3.3). */
+function kindFromStatus(status) {
+    switch (status) {
+        case 400:
+        case 422:
+            return "invalid_request";
+        case 401:
+            return "authentication";
+        case 403:
+            return "permission";
+        case 404:
+            return "not_found";
+        case 413:
+            return "request_too_large";
+        case 429:
+            return "rate_limit";
+        case 500:
+            return "internal";
+        case 501:
+            return "unsupported";
+        case 503:
+        case 529:
+            return "unavailable";
+        case 504:
+            return "timeout";
+        default:
+            if (status >= 500)
+                return "upstream";
+            if (status >= 400)
+                return "invalid_request";
+            return "internal";
+    }
+}
+function makeCanonicalError(kind, message, retryAfterSeconds) {
+    return {
+        kind,
+        status: exports.CANONICAL_ERROR_STATUS[kind],
+        message,
+        ...(retryAfterSeconds !== undefined && { retryAfterSeconds }),
+    };
+}
+/**
+ * Parse an upstream `Retry-After` header into whole seconds.
+ * delta-seconds pass through; an HTTP-date becomes seconds from `now`
+ * (minimum 1); anything unrecognised is dropped.
+ */
+function parseRetryAfter(header, now = new Date()) {
+    if (!header)
+        return undefined;
+    const trimmed = header.trim();
+    if (/^\d+$/.test(trimmed))
+        return parseInt(trimmed, 10);
+    const date = Date.parse(trimmed);
+    if (Number.isNaN(date))
+        return undefined;
+    return Math.max(1, Math.ceil((date - now.getTime()) / 1000));
+}

package/dist/utils/errors.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationError = exports.AuthError = exports.NotSupportedError = exports.UpstreamError = exports.TransformError = exports.ValidationError = exports.ProxyError = void 0;
+const canonical_error_1 = require("./canonical-error");
+class ProxyError extends Error {
+    statusCode;
+    code;
+    context;
+    constructor(message, statusCode = 500, code = "PROXY_ERROR", context) {
+        super(message);
+        this.statusCode = statusCode;
+        this.code = code;
+        this.context = context;
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+    /** Canonical form used to render this error in the client's dialect. */
+    toCanonical() {
+        return (0, canonical_error_1.makeCanonicalError)((0, canonical_error_1.kindFromStatus)(this.statusCode), this.message);
+    }
+    toJSON() {
+        return {
+            error: {
+                message: this.message,
+                code: this.code,
+                status: this.statusCode,
+                ...(process.env.NODE_ENV !== "production" && this.context
+                    ? { details: this.context }
+                    : {}),
+            },
+        };
+    }
+}
+exports.ProxyError = ProxyError;
+class ValidationError extends ProxyError {
+    constructor(message, context) {
+        super(message, 400, "VALIDATION_ERROR", context);
+    }
+}
+exports.ValidationError = ValidationError;
+class TransformError extends ProxyError {
+    constructor(message, context) {
+        super(message, 500, "TRANSFORM_ERROR", context);
+    }
+}
+exports.TransformError = TransformError;
+class UpstreamError extends ProxyError {
+    upstreamStatus;
+    upstreamBody;
+    /**
+     * Client-facing rendering computed by proxy.service's upstream mapping
+     * (spec §3.3). When set it wins over the default status-derived kind.
+     */
+    clientError;
+    /** Seconds from the upstream Retry-After header (set on 429/503). */
+    retryAfterSeconds;
+    constructor(message, upstreamStatus, upstreamBody, context, statusCode = 502) {
+        // upstreamBody stays a field (for the §3.3 log summary) but is kept
+        // out of `context`: context is serialized into non-production
+        // `details` and an upstream body may echo keys or completion text.
+        super(message, statusCode, "UPSTREAM_ERROR", {
+            ...context,
+            upstreamStatus,
+        });
+        this.upstreamStatus = upstreamStatus;
+        this.upstreamBody = upstreamBody;
+    }
+    toCanonical() {
+        return this.clientError ?? super.toCanonical();
+    }
+}
+exports.UpstreamError = UpstreamError;
+/**
+ * 501 — the client asked for something the proxy refuses by design
+ * (streaming, unsupported provider methods). Canonical kind
+ * `unsupported` via the default toCanonical().
+ */
+class NotSupportedError extends ProxyError {
+    constructor(message, context) {
+        super(message, 501, "NOT_SUPPORTED", context);
+    }
+}
+exports.NotSupportedError = NotSupportedError;
+class AuthError extends ProxyError {
+    constructor(message, context) {
+        super(message, 401, "UNAUTHORIZED", context);
+    }
+}
+exports.AuthError = AuthError;
+class ConfigurationError extends ProxyError {
+    constructor(message, context) {
+        super(message, 500, "CONFIGURATION_ERROR", context);
+    }
+}
+exports.ConfigurationError = ConfigurationError;

package/dist/utils/ids.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIdGenerator = createIdGenerator;
+exports.sequentialIds = sequentialIds;
+const crypto_1 = require("crypto");
+/**
+ * Random-suffix ID generator (spec §3.4: `call_<n>`-style generated
+ * tool-call IDs) — the default injected into decoders/adapters.
+ */
+function createIdGenerator(prefix = "call_") {
+    return () => `${prefix}${(0, crypto_1.randomBytes)(9).toString("base64url")}`;
+}
+/** Deterministic `call_0`, `call_1`, … — used in tests and fixtures. */
+function sequentialIds(prefix = "call_") {
+    let next = 0;
+    return () => `${prefix}${next++}`;
+}

package/dist/utils/logger.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+exports.loggerOptions = loggerOptions;
+const pino_1 = __importDefault(require("pino"));
+function canResolvePinoPretty() {
+    try {
+        require.resolve("pino-pretty");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function loggerOptions(env, canResolve) {
+    const isProduction = env.NODE_ENV === "production";
+    return {
+        level: env.LOG_LEVEL || (isProduction ? "info" : "debug"),
+        transport: !isProduction && canResolve()
+            ? {
+                target: "pino-pretty",
+                options: {
+                    colorize: true,
+                    translateTime: "SYS:standard",
+                    ignore: "pid,hostname",
+                },
+            }
+            : undefined,
+    };
+}
+exports.logger = (0, pino_1.default)(loggerOptions(process.env, canResolvePinoPretty));

package/dist/utils/model-map.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseModelMap = parseModelMap;
+exports.applyModelMap = applyModelMap;
+const errors_1 = require("./errors");
+/** `*` matches any run of characters; every other character is literal. */
+function globToRegExp(pattern) {
+    const escaped = pattern
+        .replace(/[.+?^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*");
+    return new RegExp(`^${escaped}$`);
+}
+/**
+ * Comma-separated `glob=model` entries → ordered rules. An entry that
+ * isn't `glob=model` (empty pattern or model, no `=`) is a configuration
+ * error — it fails at startup, not at request time.
+ */
+function parseModelMap(value) {
+    if (value === undefined || value.trim() === "")
+        return [];
+    return value.split(",").map((raw) => {
+        const entry = raw.trim();
+        const eq = entry.indexOf("=");
+        const pattern = eq === -1 ? "" : entry.slice(0, eq).trim();
+        const model = eq === -1 ? "" : entry.slice(eq + 1).trim();
+        if (pattern === "" || model === "") {
+            throw new errors_1.ConfigurationError(`MODEL_MAP entry "${entry}" must be glob=model`);
+        }
+        return { pattern, model };
+    });
+}
+/** First matching rule wins; no match leaves the model unchanged. */
+function applyModelMap(model, rules) {
+    for (const rule of rules) {
+        if (globToRegExp(rule.pattern).test(model))
+            return rule.model;
+    }
+    return model;
+}