@infersec/conduit 1.74.1 → 1.76.0

package/dist/benchmark/provision.d.ts

@@ -9,7 +9,7 @@ export declare function provisionResources(options: {
     apiUrl: string;
     apiKey: string;
     contextLength: number;
-    engine: "llama.cpp" | "vllm";
+    engine: "exllamav3" | "llama.cpp" | "mlx-lm" | "sglang" | "tensorrt-llm" | "vllm";
     format: string;
     parallelism: number;
     quantization: string | null;

package/dist/benchmark/types.d.ts

@@ -17,7 +17,7 @@ export interface TestEntry {
     };
     concurrency: number;
     contextLength: number;
-    engine: "llama.cpp" | "vllm";
+    engine: "exllamav3" | "llama.cpp" | "mlx-lm" | "sglang" | "tensorrt-llm" | "vllm";
     format: string;
     generate: boolean;
     parallelism: number;

package/dist/cli.js

@@ -4348,13 +4348,29 @@ function getEffectiveContextLength({ contextLength, engineConfig, engineType })
     if (contextLength === null || contextLength <= 0) {
         return null;
     }
-    if (engineType === "llama.cpp" && engineConfig) {
-        const parallelism = engineConfig?.parallelism;
-        if (typeof parallelism === "number" && parallelism > 0) {
-            return contextLength / parallelism;
+    if (!engineConfig) {
+        return contextLength;
+    }
+    switch (engineType) {
+        case "llama.cpp": {
+            const parallelism = engineConfig.parallelism;
+            if (typeof parallelism === "number" && parallelism > 0) {
+                return contextLength / parallelism;
+            }
+            return contextLength;
+        }
+        case "sglang":
+        case "tensorrt-llm":
+        case "vllm": {
+            const tensorParallelSize = engineConfig.tensorParallelSize;
+            if (typeof tensorParallelSize === "number" && tensorParallelSize > 0) {
+                return contextLength / tensorParallelSize;
+            }
+            return contextLength;
         }
+        default:
+            return contextLength;
     }
-    return contextLength;
 }
 
 function asError(error) {
@@ -19889,7 +19905,14 @@ object({
     PATCH: APIEndpointSchema.optional()
 });
 
-const LLMEngineSchema = _enum(["llama.cpp", "vllm"]);
+const LLMEngineSchema = _enum([
+    "exllamav3",
+    "llama.cpp",
+    "mlx-lm",
+    "sglang",
+    "tensorrt-llm",
+    "vllm"
+]);
 const LlamacppEngineConfigSchema = object({
     batchSize: number$1().int().positive().nullable().optional(),
     cacheTypeK: string$1().nullable().optional(),
@@ -19908,19 +19931,59 @@ const VLLMEngineConfigSchema = object({
     extraArgs: array(string$1()).optional(),
     tensorParallelSize: number$1().int().positive().optional()
 });
+const SGLangEngineConfigSchema = object({
+    device: string$1().optional(),
+    dtype: string$1().optional(),
+    extraArgs: array(string$1()).optional(),
+    tensorParallelSize: number$1().int().positive().optional()
+});
+const TensorRTLLMEngineConfigSchema = object({
+    backend: _enum(["_autodeploy", "pytorch", "tensorrt"]).optional(),
+    dtype: string$1().optional(),
+    extraArgs: array(string$1()).optional(),
+    tensorParallelSize: number$1().int().positive().optional()
+});
+const Exllamav3EngineConfigSchema = object({
+    cacheMode: _enum(["fp16", "q4", "q6", "q8"]).optional(),
+    extraArgs: array(string$1()).optional(),
+    gpuSplit: string$1().optional(),
+    maxSeqLen: number$1().int().positive().optional()
+});
+const MLXLMEngineConfigSchema = object({
+    extraArgs: array(string$1()).optional(),
+    maxKvSize: number$1().int().positive().optional(),
+    trustRemoteCode: boolean$1().optional()
+});
 const EngineConfigSchema = discriminatedUnion("type", [
+    object({ config: Exllamav3EngineConfigSchema, type: literal("exllamav3") }),
     object({ config: LlamacppEngineConfigSchema, type: literal("llama.cpp") }),
+    object({ config: MLXLMEngineConfigSchema, type: literal("mlx-lm") }),
+    object({ config: SGLangEngineConfigSchema, type: literal("sglang") }),
+    object({
+        config: TensorRTLLMEngineConfigSchema,
+        type: literal("tensorrt-llm")
+    }),
     object({ config: VLLMEngineConfigSchema, type: literal("vllm") })
 ]);
 const LLMModelFormatSchema = _enum([
-    // VLLM
+    // VLLM / SGLang / TensorRT-LLM
     "safetensors",
     "pytorch",
     "awq",
     "gptq",
     // Llama.cpp
-    "gguf"
+    "gguf",
+    // ExLlamaV3
+    "exl3",
+    "exl2",
+    // MLX-LM
+    "mlx"
 ]);
+object({
+    nativeAnthropicMessages: boolean$1(),
+    supportsEmbeddings: boolean$1(),
+    supportsVision: boolean$1()
+});
 const LLMModelTaskTypeSchema = _enum(["text-generation", "embeddings"]);
 const LLMModelSchema = object({
     format: LLMModelFormatSchema,
@@ -19980,6 +20043,7 @@ const InferenceAgentMachineMetadataSchema = object({
         model: string$1().nullable(),
         physicalCores: number$1().int().positive().nullable()
     }),
+    exllamav3Version: string$1().nullable(),
     gpus: array(InferenceAgentMachineGPUSchema),
     hostname: string$1(),
     llamaCppVersion: string$1().nullable(),
@@ -19988,6 +20052,7 @@ const InferenceAgentMachineMetadataSchema = object({
         availableBytes: number$1().int().nonnegative().nullable(),
         totalBytes: number$1().int().nonnegative().nullable()
     }),
+    mlxlmVersion: string$1().nullable(),
     os: object({
         arch: string$1(),
         platform: string$1(),
@@ -19995,6 +20060,8 @@ const InferenceAgentMachineMetadataSchema = object({
         type: string$1().nullable(),
         version: string$1().nullable()
     }),
+    sglangVersion: string$1().nullable(),
+    tensorrtLlmVersion: string$1().nullable(),
     vllmVersion: string$1().nullable()
 });
 const InferenceAgentMachineReportPayloadSchema = object({
@@ -20969,6 +21036,10 @@ object({
 });
 const EngineOutputSchema = object({
     created: string$1(),
+    exllamav3CacheMode: string$1().nullable(),
+    exllamav3ExtraArgs: array(string$1()),
+    exllamav3GpuSplit: string$1().nullable(),
+    exllamav3MaxSeqLen: number$1().nullable(),
     id: ULIDSchema,
     llamacppBatchSize: number$1().nullable(),
     llamacppCacheTypeK: string$1().nullable(),
@@ -20980,7 +21051,18 @@ const EngineOutputSchema = object({
     llamacppParallelism: number$1(),
     llamacppTensorSplit: string$1().nullable(),
     llamacppUbatchSize: number$1().nullable(),
+    mlxlmExtraArgs: array(string$1()),
+    mlxlmMaxKvSize: number$1().nullable(),
+    mlxlmTrustRemoteCode: boolean$1(),
     name: string$1(),
+    sglangDevice: string$1().nullable(),
+    sglangDtype: string$1().nullable(),
+    sglangExtraArgs: array(string$1()),
+    sglangTensorParallelSize: number$1(),
+    trtllmBackend: string$1().nullable(),
+    trtllmDtype: string$1().nullable(),
+    trtllmExtraArgs: array(string$1()),
+    trtllmTensorParallelSize: number$1(),
     type: LLMEngineSchema,
     updated: string$1(),
     vllmDevice: string$1().nullable(),
@@ -20989,6 +21071,10 @@ const EngineOutputSchema = object({
     vllmTensorParallelSize: number$1()
 });
 object({
+    exllamav3CacheMode: string$1().nullable().optional(),
+    exllamav3ExtraArgs: array(string$1()).optional(),
+    exllamav3GpuSplit: string$1().nullable().optional(),
+    exllamav3MaxSeqLen: number$1().int().positive().nullable().optional(),
     llamacppBatchSize: number$1().int().positive().nullable().optional(),
     llamacppCacheTypeK: string$1().nullable().optional(),
     llamacppCacheTypeV: string$1().nullable().optional(),
@@ -20999,7 +21085,18 @@ object({
     llamacppParallelism: number$1().int().positive().optional(),
     llamacppTensorSplit: string$1().nullable().optional(),
     llamacppUbatchSize: number$1().int().positive().nullable().optional(),
+    mlxlmExtraArgs: array(string$1()).optional(),
+    mlxlmMaxKvSize: number$1().int().positive().nullable().optional(),
+    mlxlmTrustRemoteCode: boolean$1().optional(),
     name: ResourceNameSchema,
+    sglangDevice: string$1().nullable().optional(),
+    sglangDtype: string$1().nullable().optional(),
+    sglangExtraArgs: array(string$1()).optional(),
+    sglangTensorParallelSize: number$1().int().positive().optional(),
+    trtllmBackend: string$1().nullable().optional(),
+    trtllmDtype: string$1().nullable().optional(),
+    trtllmExtraArgs: array(string$1()).optional(),
+    trtllmTensorParallelSize: number$1().int().positive().optional(),
     type: LLMEngineSchema,
     vllmDevice: string$1().nullable().optional(),
     vllmDtype: string$1().nullable().optional(),
@@ -21007,6 +21104,10 @@ object({
     vllmTensorParallelSize: number$1().int().positive().optional()
 });
 object({
+    exllamav3CacheMode: string$1().nullable().optional(),
+    exllamav3ExtraArgs: array(string$1()).optional(),
+    exllamav3GpuSplit: string$1().nullable().optional(),
+    exllamav3MaxSeqLen: number$1().int().positive().nullable().optional(),
     llamacppBatchSize: number$1().int().positive().nullable().optional(),
     llamacppCacheTypeK: string$1().nullable().optional(),
     llamacppCacheTypeV: string$1().nullable().optional(),
@@ -21017,7 +21118,18 @@ object({
     llamacppParallelism: number$1().int().positive().optional(),
     llamacppTensorSplit: string$1().nullable().optional(),
     llamacppUbatchSize: number$1().int().positive().nullable().optional(),
+    mlxlmExtraArgs: array(string$1()).optional(),
+    mlxlmMaxKvSize: number$1().int().positive().nullable().optional(),
+    mlxlmTrustRemoteCode: boolean$1().optional(),
     name: ResourceNameSchema.optional(),
+    sglangDevice: string$1().nullable().optional(),
+    sglangDtype: string$1().nullable().optional(),
+    sglangExtraArgs: array(string$1()).optional(),
+    sglangTensorParallelSize: number$1().int().positive().optional(),
+    trtllmBackend: string$1().nullable().optional(),
+    trtllmDtype: string$1().nullable().optional(),
+    trtllmExtraArgs: array(string$1()).optional(),
+    trtllmTensorParallelSize: number$1().int().positive().optional(),
     type: LLMEngineSchema.optional(),
     vllmDevice: string$1().nullable().optional(),
     vllmDtype: string$1().nullable().optional(),
@@ -21090,6 +21202,39 @@ object({
     }
 });
 
+const ENGINE_API_COMPATIBILITY = {
+    exllamav3: {
+        nativeAnthropicMessages: false,
+        supportsEmbeddings: false,
+        supportsVision: true
+    },
+    "llama.cpp": {
+        nativeAnthropicMessages: true,
+        supportsEmbeddings: true,
+        supportsVision: true
+    },
+    "mlx-lm": {
+        nativeAnthropicMessages: false,
+        supportsEmbeddings: false,
+        supportsVision: false
+    },
+    sglang: {
+        nativeAnthropicMessages: false,
+        supportsEmbeddings: true,
+        supportsVision: true
+    },
+    "tensorrt-llm": {
+        nativeAnthropicMessages: false,
+        supportsEmbeddings: true,
+        supportsVision: true
+    },
+    vllm: {
+        nativeAnthropicMessages: true,
+        supportsEmbeddings: true,
+        supportsVision: true
+    }
+};
+
 object({
     accountID: ULIDSchema.optional(),
     email: string$1().email(),
@@ -116639,6 +116784,43 @@ async function downloadFileWithRange({ accessToken, filePath, fileSize, modelSlu
     throw new Error(errorMessage);
 }
 
+const EXLLAMAV3_EXECUTABLE = process.env.EXLLAMAV3_EXECUTABLE ?? "python3";
+const SERVER_SCRIPT = join(import.meta.dirname, "server.py");
+const DEFAULT_EXLLAMAV3_CONTEXT_LENGTH = 4096;
+async function startExllamav3({ enginePort, targetDirectory }) {
+    const contextLength = Math.max(1, this.contextLength ?? DEFAULT_EXLLAMAV3_CONTEXT_LENGTH);
+    const engineConfig = this.engineConfig;
+    const cacheMode = typeof engineConfig?.cacheMode === "string" ? engineConfig.cacheMode : "q4";
+    const gpuSplit = typeof engineConfig?.gpuSplit === "string" ? engineConfig.gpuSplit : null;
+    const maxSeqLen = typeof engineConfig?.maxSeqLen === "number" ? engineConfig.maxSeqLen : contextLength;
+    const args = [
+        SERVER_SCRIPT,
+        "--model",
+        targetDirectory,
+        "--host",
+        "127.0.0.1",
+        "--port",
+        String(enginePort),
+        "--cache-mode",
+        cacheMode,
+        "--max-seq-len",
+        String(maxSeqLen)
+    ];
+    if (gpuSplit) {
+        args.push("--gpu-split", gpuSplit);
+    }
+    const extraArgs = engineConfig?.extraArgs;
+    if (Array.isArray(extraArgs) && extraArgs.every((v) => typeof v === "string")) {
+        args.push(...extraArgs);
+    }
+    const processManager = new ProcessManager({
+        command: EXLLAMAV3_EXECUTABLE,
+        args
+    });
+    await processManager.start();
+    return processManager;
+}
+
 const DEFAULT_LLAMACPP_GPU_LAYERS = 999;
 const LLAMACPP_START_ARGS = ["--host", "0.0.0.0", "--jinja"];
 const LLAMACPP_EXECUTABLE = process.env.LLAMACPP_EXECUTABLE ?? "llama-server";
@@ -116738,6 +116920,46 @@ async function startLlamacpp({ enginePort, targetDirectory }) {
     return processManager;
 }
 
+const MLXLM_EXECUTABLE = process.env.MLXLM_EXECUTABLE ?? "python3";
+const DEFAULT_MLXLM_CONTEXT_LENGTH = 4096;
+async function startMLXLM({ enginePort, targetDirectory }) {
+    if (this.model.taskType === "embeddings") {
+        throw new Error("MLX-LM engine does not support embeddings task type");
+    }
+    const contextLength = Math.max(1, this.contextLength ?? DEFAULT_MLXLM_CONTEXT_LENGTH);
+    const engineConfig = this.engineConfig;
+    const args = [
+        "-m",
+        "mlx_lm.server",
+        "--model",
+        targetDirectory,
+        "--host",
+        "127.0.0.1",
+        "--port",
+        String(enginePort),
+        "--context-length",
+        String(contextLength)
+    ];
+    const maxKvSize = typeof engineConfig?.maxKvSize === "number" ? engineConfig.maxKvSize : null;
+    if (maxKvSize !== null) {
+        args.push("--max-kv-size", String(maxKvSize));
+    }
+    const trustRemoteCode = engineConfig?.trustRemoteCode === true;
+    if (trustRemoteCode || process.env.MLXLM_TRUST_REMOTE_CODE === "true") {
+        args.push("--trust-remote-code");
+    }
+    const extraArgs = engineConfig?.extraArgs;
+    if (Array.isArray(extraArgs) && extraArgs.every((v) => typeof v === "string")) {
+        args.push(...extraArgs);
+    }
+    const processManager = new ProcessManager({
+        command: MLXLM_EXECUTABLE,
+        args
+    });
+    await processManager.start();
+    return processManager;
+}
+
 const SAFE_CHARS = /[a-zA-Z0-9\-_.]/;
 const SEPARATOR = "__";
 function sanitizeSegment(value) {
@@ -116762,6 +116984,95 @@ function createModelStorageKey(model) {
     return `${model.source.type}${SEPARATOR}${sanitizeSegment(identifier)}`;
 }
 
+const SGLANG_START_ARGS = ["-m", "sglang.launch_server", "--host", "127.0.0.1"];
+const SGLANG_EXECUTABLE = process.env.SGLANG_EXECUTABLE ?? "python3";
+const DEFAULT_SGLANG_CONTEXT_LENGTH = 2048;
+async function startSGLang({ enginePort, targetDirectory }) {
+    const contextLength = Math.max(1, this.contextLength ?? DEFAULT_SGLANG_CONTEXT_LENGTH);
+    const engineConfig = this.engineConfig;
+    const device = typeof engineConfig?.device === "string" ? engineConfig.device : undefined;
+    const dtype = typeof engineConfig?.dtype === "string" ? engineConfig.dtype : undefined;
+    const tensorParallelSize = typeof engineConfig?.tensorParallelSize === "number" ? engineConfig.tensorParallelSize : 1;
+    const args = [
+        ...SGLANG_START_ARGS,
+        "--port",
+        String(enginePort),
+        "--model-path",
+        targetDirectory,
+        "--served-model-name",
+        this.model.id,
+        "--context-length",
+        String(contextLength),
+        "--tp-size",
+        String(tensorParallelSize)
+    ];
+    if (this.model.taskType === "embeddings") {
+        args.push("--task", "embed");
+    }
+    if (device) {
+        args.push("--device", device);
+    }
+    if (dtype) {
+        args.push("--dtype", dtype);
+    }
+    const extraArgs = engineConfig?.extraArgs;
+    if (Array.isArray(extraArgs) && extraArgs.every((v) => typeof v === "string")) {
+        args.push(...extraArgs);
+    }
+    if (this.model.multimodalEnabled) {
+        args.push("--limit-mm-per-prompt", process.env.SGLANG_MM_LIMIT ?? '{"image":5}');
+    }
+    if (process.env.SGLANG_TRUST_REMOTE_CODE === "true") {
+        args.push("--trust-remote-code");
+    }
+    const processManager = new ProcessManager({
+        command: SGLANG_EXECUTABLE,
+        args
+    });
+    await processManager.start();
+    return processManager;
+}
+
+const TRTLLM_EXECUTABLE = process.env.TRTLLM_EXECUTABLE ?? "trtllm-serve";
+const DEFAULT_TRTLLM_CONTEXT_LENGTH = 2048;
+async function startTensorRTLLM({ enginePort, targetDirectory }) {
+    const contextLength = Math.max(1, this.contextLength ?? DEFAULT_TRTLLM_CONTEXT_LENGTH);
+    const engineConfig = this.engineConfig;
+    const backend = typeof engineConfig?.backend === "string" ? engineConfig.backend : "pytorch";
+    const dtype = typeof engineConfig?.dtype === "string" ? engineConfig.dtype : undefined;
+    const tensorParallelSize = typeof engineConfig?.tensorParallelSize === "number" ? engineConfig.tensorParallelSize : 1;
+    const args = [
+        "serve",
+        targetDirectory,
+        "--host",
+        "127.0.0.1",
+        "--port",
+        String(enginePort),
+        "--backend",
+        backend,
+        "--max-seq-len",
+        String(contextLength),
+        "--tp-size",
+        String(tensorParallelSize)
+    ];
+    if (this.model.taskType === "embeddings") {
+        args.push("--task", "embed");
+    }
+    if (dtype) {
+        args.push("--dtype", dtype);
+    }
+    const extraArgs = engineConfig?.extraArgs;
+    if (Array.isArray(extraArgs) && extraArgs.every((v) => typeof v === "string")) {
+        args.push(...extraArgs);
+    }
+    const processManager = new ProcessManager({
+        command: TRTLLM_EXECUTABLE,
+        args
+    });
+    await processManager.start();
+    return processManager;
+}
+
 const ENGINE_FETCH_TIMEOUT_MS$1 = 7200000;
 const DOWNLOAD_LOCK_TIMEOUT_MS = 20 * 60 * 1000;
 const DOWNLOAD_LOCK_POLL_INTERVAL_MS = 5000;
@@ -116795,7 +117106,11 @@ class ModelManager extends EventEmitter {
     }
     async fetchOpenAI(path, opts) {
         switch (this.engine) {
+            case "exllamav3":
             case "llama.cpp":
+            case "mlx-lm":
+            case "sglang":
+            case "tensorrt-llm":
             case "vllm": {
                 this.logger.debug(`Fetching from engine: ${path}`);
                 const callerSignal = opts?.signal;
@@ -116843,7 +117158,11 @@ class ModelManager extends EventEmitter {
             modelID: this.model.id
         });
         switch (this.engine) {
+            case "exllamav3":
             case "llama.cpp":
+            case "mlx-lm":
+            case "sglang":
+            case "tensorrt-llm":
             case "vllm":
                 if (this.model.source.type !== "huggingface") {
                     throw new Error(`Model source not implemented: ${this.model.source.type}`);
@@ -116950,10 +117269,34 @@ class ModelManager extends EventEmitter {
             case "vllm": {
                 return this.checkVLLMReadiness();
             }
+            case "exllamav3":
+            case "mlx-lm":
+            case "sglang":
+            case "tensorrt-llm": {
+                return this.checkGenericHealthReadiness();
+            }
             default:
                 return "ready";
         }
     }
+    async checkGenericHealthReadiness() {
+        try {
+            const response = await undiciExports.fetch(joinURL(`http://localhost:${this.enginePort}`, "/health"), {
+                method: "GET",
+                signal: AbortSignal.timeout(5000)
+            });
+            if (response.status === 503) {
+                return "loading";
+            }
+            if (response.ok) {
+                return "ready";
+            }
+            return "loading";
+        }
+        catch (_error) {
+            return "unreachable";
+        }
+    }
     async checkLlamacppReadiness() {
         try {
             const response = await undiciExports.fetch(joinURL(`http://localhost:${this.enginePort}`, "/health"), {
@@ -117150,16 +117493,37 @@ class ModelManager extends EventEmitter {
         });
     }
     async startEngineProcess() {
+        const targetDir = join(this.modelsDirectory, this.uniqueName);
         switch (this.engine) {
+            case "exllamav3":
+                return startExllamav3.call(this, {
+                    enginePort: this.enginePort,
+                    targetDirectory: targetDir
+                });
             case "llama.cpp":
                 return startLlamacpp.call(this, {
                     enginePort: this.enginePort,
-                    targetDirectory: join(this.modelsDirectory, this.uniqueName)
+                    targetDirectory: targetDir
+                });
+            case "mlx-lm":
+                return startMLXLM.call(this, {
+                    enginePort: this.enginePort,
+                    targetDirectory: targetDir
+                });
+            case "sglang":
+                return startSGLang.call(this, {
+                    enginePort: this.enginePort,
+                    targetDirectory: targetDir
+                });
+            case "tensorrt-llm":
+                return startTensorRTLLM.call(this, {
+                    enginePort: this.enginePort,
+                    targetDirectory: targetDir
                 });
             case "vllm":
                 return startVLLM.call(this, {
                     enginePort: this.enginePort,
-                    targetDirectory: join(this.modelsDirectory, this.uniqueName)
+                    targetDirectory: targetDir
                 });
             default: {
                 const engineType = this.engine;
@@ -118227,6 +118591,189 @@ function createPostEmbeddingsHandler(options) {
     return createConduitOpenAIAPIReferenceHandlers(options)["/v1/embeddings"].POST;
 }
 
+function engineSupportsNativeAnthropic(engineType) {
+    if (!engineType)
+        return false;
+    return ENGINE_API_COMPATIBILITY[engineType]?.nativeAnthropicMessages ?? false;
+}
+function translateAnthropicRequestToOpenAI(body) {
+    const parsed = JSON.parse(body);
+    const messages = Array.isArray(parsed.messages) ? parsed.messages : [];
+    const openaiMessages = [];
+    const system = parsed.system;
+    if (typeof system === "string" && system.length > 0) {
+        openaiMessages.push({ content: system, role: "system" });
+    }
+    else if (Array.isArray(system)) {
+        const textParts = system
+            .filter((b) => {
+            const block = b;
+            return block?.type === "text" && typeof block.text === "string";
+        })
+            .map((b) => b.text);
+        if (textParts.length > 0) {
+            openaiMessages.push({ content: textParts.join("\n"), role: "system" });
+        }
+    }
+    for (const msg of messages) {
+        const m = msg;
+        const role = m.role;
+        const content = m.content;
+        if (typeof content === "string") {
+            openaiMessages.push({ content, role });
+            continue;
+        }
+        if (!Array.isArray(content)) {
+            openaiMessages.push({ content: content ?? "", role });
+            continue;
+        }
+        if (role === "assistant") {
+            const toolCalls = [];
+            const textParts = [];
+            for (const block of content) {
+                const b = block;
+                if (b.type === "text" && typeof b.text === "string") {
+                    textParts.push(b.text);
+                }
+                else if (b.type === "tool_use") {
+                    toolCalls.push({
+                        function: {
+                            arguments: JSON.stringify(b.input ?? {}),
+                            name: b.name
+                        },
+                        id: b.id,
+                        type: "function"
+                    });
+                }
+            }
+            openaiMessages.push({
+                content: textParts.join("") || null,
+                role,
+                ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {})
+            });
+        }
+        else if (role === "user") {
+            const textParts = [];
+            const toolResults = [];
+            for (const block of content) {
+                const b = block;
+                if (b.type === "text" && typeof b.text === "string") {
+                    textParts.push(b.text);
+                }
+                else if (b.type === "tool_result") {
+                    toolResults.push({
+                        content: typeof b.content === "string"
+                            ? b.content
+                            : JSON.stringify(b.content ?? ""),
+                        role: "tool",
+                        tool_call_id: b.tool_use_id
+                    });
+                }
+            }
+            if (textParts.length > 0) {
+                openaiMessages.push({ content: textParts.join("\n"), role });
+            }
+            for (const tr of toolResults) {
+                openaiMessages.push(tr);
+            }
+        }
+        else {
+            openaiMessages.push({ content: JSON.stringify(content), role });
+        }
+    }
+    const result = {
+        max_tokens: parsed.max_tokens ?? 4096,
+        messages: openaiMessages,
+        model: parsed.model,
+        stream: parsed.stream ?? false
+    };
+    if (typeof parsed.temperature === "number")
+        result.temperature = parsed.temperature;
+    if (typeof parsed.top_p === "number")
+        result.top_p = parsed.top_p;
+    if (Array.isArray(parsed.stop_sequences))
+        result.stop = parsed.stop_sequences;
+    if (Array.isArray(parsed.tools)) {
+        result.tools = parsed.tools.map((tool) => {
+            const t = tool;
+            return {
+                function: {
+                    ...(typeof t.description === "string" ? { description: t.description } : {}),
+                    name: t.name,
+                    parameters: t.input_schema ?? {}
+                },
+                type: "function"
+            };
+        });
+    }
+    if (parsed.tool_choice && typeof parsed.tool_choice === "object") {
+        const tc = parsed.tool_choice;
+        if (tc.type === "auto")
+            result.tool_choice = "auto";
+        else if (tc.type === "any")
+            result.tool_choice = "required";
+        else if (tc.type === "tool" && typeof tc.name === "string") {
+            result.tool_choice = { function: { name: tc.name }, type: "function" };
+        }
+    }
+    return { body: JSON.stringify(result), path: "/v1/chat/completions" };
+}
+function translateOpenAIResponseToAnthropic({ body, model }) {
+    const parsed = JSON.parse(body);
+    const choices = Array.isArray(parsed.choices) ? parsed.choices : [];
+    const choice = choices[0];
+    const message = choice?.message;
+    const content = [];
+    if (message) {
+        if (typeof message.content === "string" && message.content.length > 0) {
+            content.push({ text: message.content, type: "text" });
+        }
+        if (Array.isArray(message.tool_calls)) {
+            for (const tc of message.tool_calls) {
+                const call = tc;
+                const fn = call.function;
+                const argsRaw = typeof fn?.arguments === "string" ? fn.arguments : "{}";
+                let parsedInput = {};
+                try {
+                    parsedInput = JSON.parse(argsRaw);
+                }
+                catch {
+                    parsedInput = {};
+                }
+                content.push({
+                    id: call.id,
+                    input: parsedInput,
+                    name: fn?.name,
+                    type: "tool_use"
+                });
+            }
+        }
+    }
+    const finishReason = choice?.finish_reason;
+    let stopReason = "end_turn";
+    if (finishReason === "length")
+        stopReason = "max_tokens";
+    else if (finishReason === "tool_calls")
+        stopReason = "tool_use";
+    else if (finishReason === "stop")
+        stopReason = "end_turn";
+    const usage = parsed.usage;
+    const result = {
+        content,
+        id: parsed.id,
+        model,
+        role: "assistant",
+        stop_reason: stopReason,
+        stop_sequence: null,
+        type: "message",
+        usage: {
+            input_tokens: usage?.prompt_tokens ?? 0,
+            output_tokens: usage?.completion_tokens ?? 0
+        }
+    };
+    return JSON.stringify(result);
+}
+
 function isPlainObject$1(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -118297,6 +118844,106 @@ function extractAnthropicNonStreamUsage(body) {
         return null;
     }
 }
+function extractOpenAIUsageFromJSON(body) {
+    try {
+        const parsed = JSON.parse(body);
+        if (!isPlainObject$1(parsed) || !isPlainObject$1(parsed.usage))
+            return null;
+        const usage = parsed.usage;
+        return {
+            inputTokens: typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : null,
+            outputTokens: typeof usage.completion_tokens === "number" ? usage.completion_tokens : null
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function assembleOpenAISSE(body) {
+    const lines = body.split("\n");
+    let content = "";
+    let promptTokens = null;
+    let completionTokens = null;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data:"))
+            continue;
+        const payload = trimmed.slice(5).trim();
+        if (payload === "[DONE]")
+            continue;
+        try {
+            const parsed = JSON.parse(payload);
+            if (!isPlainObject$1(parsed))
+                continue;
+            const choices = parsed.choices;
+            if (Array.isArray(choices) && choices.length > 0) {
+                const choice = choices[0];
+                const delta = choice.delta;
+                if (delta && typeof delta.content === "string") {
+                    content += delta.content;
+                }
+            }
+            const usage = parsed.usage;
+            if (usage) {
+                if (typeof usage.prompt_tokens === "number")
+                    promptTokens = usage.prompt_tokens;
+                if (typeof usage.completion_tokens === "number")
+                    completionTokens = usage.completion_tokens;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return { completionTokens, content, promptTokens };
+}
+function translateOpenAIStreamToAnthropicSSE(body, model) {
+    const assembled = assembleOpenAISSE(body);
+    const content = assembled?.content ?? "";
+    const inputTokens = assembled?.promptTokens ?? 0;
+    const outputTokens = assembled?.completionTokens ?? 0;
+    const events = [];
+    const messageId = `msg_${Date.now()}`;
+    events.push(`event: message_start\ndata: ${JSON.stringify({
+        message: {
+            content: [],
+            id: messageId,
+            input_tokens: inputTokens,
+            model,
+            output_tokens: outputTokens,
+            role: "assistant",
+            stop_reason: null,
+            type: "message",
+            usage: { input_tokens: inputTokens, output_tokens: 0 }
+        },
+        type: "message_start"
+    })}`);
+    events.push(`event: content_block_start\ndata: ${JSON.stringify({
+        content_block: { text: "", type: "text" },
+        index: 0,
+        type: "content_block_start"
+    })}`);
+    const chunkSize = 20;
+    for (let i = 0; i < content.length; i += chunkSize) {
+        const textChunk = content.slice(i, i + chunkSize);
+        events.push(`event: content_block_delta\ndata: ${JSON.stringify({
+            delta: { text: textChunk, type: "text_delta" },
+            index: 0,
+            type: "content_block_delta"
+        })}`);
+    }
+    events.push(`event: content_block_stop\ndata: ${JSON.stringify({
+        index: 0,
+        type: "content_block_stop"
+    })}`);
+    events.push(`event: message_delta\ndata: ${JSON.stringify({
+        delta: { stop_reason: "end_turn", stop_sequence: null },
+        type: "message_delta",
+        usage: { output_tokens: outputTokens }
+    })}`);
+    events.push('event: message_stop\ndata: {"type":"message_stop"}');
+    return events.join("\n\n") + "\n\n";
+}
 async function proxyAnthropicStreamingRoute({ body, conduitConfiguration, endpointId, logger, modelID, modelManager, reportMetrics, signal }) {
     function reportMetricsSafe(payload) {
         reportMetrics(payload).catch(error => {
@@ -118307,10 +118954,17 @@ async function proxyAnthropicStreamingRoute({ body, conduitConfiguration, endpoi
         });
     }
     const engineType = conduitConfiguration.engineConfig?.type ?? null;
+    const needsTranslation = !engineSupportsNativeAnthropic(engineType);
     const { bytes: requestBodyBytes, payload: serializedBody } = serializeRequestBody(body);
     const requestStartedAt = Date.now();
     const requestBody = JSON.parse(serializedBody);
     const streamRequested = requestBody.stream === true;
+    const targetPath = needsTranslation
+        ? translateAnthropicRequestToOpenAI(serializedBody).path
+        : "/v1/messages";
+    const targetBody = needsTranslation
+        ? translateAnthropicRequestToOpenAI(serializedBody).body
+        : serializedBody;
     const onMonitoringComplete = ({ durationMs, error, responseBytes, usage }) => {
         const promptTokens = normalizeTokenCount(usage?.inputTokens);
         const completionTokens = normalizeTokenCount(usage?.outputTokens);
@@ -118339,8 +118993,8 @@ async function proxyAnthropicStreamingRoute({ body, conduitConfiguration, endpoi
         });
     };
     const response = await modelManager
-        .fetchOpenAI("/v1/messages", {
-        body: serializedBody,
+        .fetchOpenAI(targetPath, {
+        body: targetBody,
         headers: {
             "Content-Type": "application/json"
         },
@@ -118447,73 +119101,157 @@ async function proxyAnthropicStreamingRoute({ body, conduitConfiguration, endpoi
     }
     const rawBody = Readable.fromWeb(response.body);
     if (streamRequested) {
-        let buffer = "";
-        rawBody.on("data", (chunk) => {
-            const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-            responseBytes += chunkBuffer.length;
-            buffer += chunkBuffer.toString("utf8");
-            const lines = buffer.split("\n");
-            buffer = lines.pop() ?? "";
-            for (const line of lines) {
-                const extracted = extractAnthropicStreamUsage(line.trim());
-                if (extracted?.inputTokens !== undefined && extracted.inputTokens !== null) {
-                    usage.inputTokens = extracted.inputTokens;
+        if (needsTranslation) {
+            const chunks = [];
+            rawBody.on("data", (chunk) => {
+                const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                responseBytes += chunkBuffer.length;
+                chunks.push(chunkBuffer);
+            });
+            rawBody.once("end", () => {
+                const fullBody = Buffer.concat(chunks).toString("utf8");
+                if (!response.ok) {
+                    passThrough.write(fullBody);
+                    responseBytes = Buffer.byteLength(fullBody, "utf8");
+                    logEngineMetrics({
+                        agentEngineType: engineType ?? "unknown",
+                        level: "error",
+                        logger,
+                        requestBodyBytes,
+                        requestPath: "/v1/messages",
+                        responseBytes,
+                        usage: null
+                    });
+                    finalize(upstreamError);
+                    passThrough.end();
+                    return;
                 }
-                if (extracted?.outputTokens !== undefined && extracted.outputTokens !== null) {
-                    usage.outputTokens = extracted.outputTokens;
+                const modelId = requestBody.model ?? "unknown";
+                const assembled = assembleOpenAISSE(fullBody);
+                if (assembled) {
+                    usage.inputTokens = assembled.promptTokens;
+                    usage.outputTokens = assembled.completionTokens;
                 }
-            }
-            passThrough.write(chunkBuffer);
-        });
-        rawBody.once("error", err => {
-            const normalizedError = asError(err);
-            logEngineMetrics({
-                agentEngineType: engineType ?? "unknown",
-                error: normalizedError,
-                level: "error",
-                logger,
-                requestBodyBytes,
-                requestPath: "/v1/messages",
-                responseBytes,
-                usage: null
+                try {
+                    const anthropicSSE = translateOpenAIStreamToAnthropicSSE(fullBody, modelId);
+                    const output = Buffer.from(anthropicSSE, "utf8");
+                    responseBytes = output.length;
+                    passThrough.write(output);
+                }
+                catch (translateError) {
+                    const normalizedTranslateError = asError(translateError);
+                    logEngineMetrics({
+                        agentEngineType: engineType ?? "unknown",
+                        error: normalizedTranslateError,
+                        level: "error",
+                        logger,
+                        requestBodyBytes,
+                        requestPath: "/v1/messages",
+                        responseBytes,
+                        usage: null
+                    });
+                    finalize(normalizedTranslateError);
+                    passThrough.destroy(normalizedTranslateError);
+                    return;
+                }
+                logEngineMetrics({
+                    agentEngineType: engineType ?? "unknown",
+                    level: upstreamError ? "error" : "info",
+                    logger,
+                    requestBodyBytes,
+                    requestPath: "/v1/messages",
+                    responseBytes,
+                    usage: null
+                });
+                finalize(upstreamError);
+                passThrough.end();
             });
-            finalize(normalizedError);
-            passThrough.destroy(normalizedError);
-        });
-        rawBody.once("end", () => {
-            logEngineMetrics({
-                agentEngineType: engineType ?? "unknown",
-                level: upstreamError ? "error" : "info",
-                logger,
-                requestBodyBytes,
-                requestPath: "/v1/messages",
-                responseBytes,
-                usage: null
+            rawBody.once("error", err => {
+                const normalizedError = asError(err);
+                finalize(normalizedError);
+                passThrough.destroy(normalizedError);
             });
-            finalize(upstreamError);
-            passThrough.end();
-        });
-        rawBody.once("close", () => {
-            if (completed) {
+            rawBody.once("close", () => {
+                if (completed) {
+                    if (!passThrough.writableEnded)
+                        passThrough.end();
+                    return;
+                }
+                const closeError = new Error("Engine response stream closed before completion");
+                finalize(closeError);
                 if (!passThrough.writableEnded)
                     passThrough.end();
-                return;
-            }
-            const closeError = new Error("Engine response stream closed before completion");
-            logEngineMetrics({
-                agentEngineType: engineType ?? "unknown",
-                error: closeError,
-                level: "error",
-                logger,
-                requestBodyBytes,
-                requestPath: "/v1/messages",
-                responseBytes,
-                usage: null
             });
-            finalize(closeError);
-            if (!passThrough.writableEnded)
+        }
+        else {
+            let buffer = "";
+            rawBody.on("data", (chunk) => {
+                const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                responseBytes += chunkBuffer.length;
+                buffer += chunkBuffer.toString("utf8");
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    const extracted = extractAnthropicStreamUsage(line.trim());
+                    if (extracted?.inputTokens !== undefined && extracted.inputTokens !== null) {
+                        usage.inputTokens = extracted.inputTokens;
+                    }
+                    if (extracted?.outputTokens !== undefined && extracted.outputTokens !== null) {
+                        usage.outputTokens = extracted.outputTokens;
+                    }
+                }
+                passThrough.write(chunkBuffer);
+            });
+            rawBody.once("error", err => {
+                const normalizedError = asError(err);
+                logEngineMetrics({
+                    agentEngineType: engineType ?? "unknown",
+                    error: normalizedError,
+                    level: "error",
+                    logger,
+                    requestBodyBytes,
+                    requestPath: "/v1/messages",
+                    responseBytes,
+                    usage: null
+                });
+                finalize(normalizedError);
+                passThrough.destroy(normalizedError);
+            });
+            rawBody.once("end", () => {
+                logEngineMetrics({
+                    agentEngineType: engineType ?? "unknown",
+                    level: upstreamError ? "error" : "info",
+                    logger,
+                    requestBodyBytes,
+                    requestPath: "/v1/messages",
+                    responseBytes,
+                    usage: null
+                });
+                finalize(upstreamError);
                 passThrough.end();
-        });
+            });
+            rawBody.once("close", () => {
+                if (completed) {
+                    if (!passThrough.writableEnded)
+                        passThrough.end();
+                    return;
+                }
+                const closeError = new Error("Engine response stream closed before completion");
+                logEngineMetrics({
+                    agentEngineType: engineType ?? "unknown",
+                    error: closeError,
+                    level: "error",
+                    logger,
+                    requestBodyBytes,
+                    requestPath: "/v1/messages",
+                    responseBytes,
+                    usage: null
+                });
+                finalize(closeError);
+                if (!passThrough.writableEnded)
+                    passThrough.end();
+            });
+        }
     }
     else {
         const chunks = [];
@@ -118521,7 +119259,6 @@ async function proxyAnthropicStreamingRoute({ body, conduitConfiguration, endpoi
             const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
             responseBytes += chunkBuffer.length;
             chunks.push(chunkBuffer);
-            passThrough.write(chunkBuffer);
         });
         rawBody.once("error", err => {
             const normalizedError = asError(err);
@@ -118540,11 +119277,48 @@ async function proxyAnthropicStreamingRoute({ body, conduitConfiguration, endpoi
         });
         rawBody.once("end", () => {
             const fullBody = Buffer.concat(chunks).toString("utf8");
-            const extractedUsage = extractAnthropicNonStreamUsage(fullBody);
-            if (extractedUsage) {
-                usage.inputTokens = extractedUsage.inputTokens;
-                usage.outputTokens = extractedUsage.outputTokens;
+            let outputBody = fullBody;
+            if (needsTranslation && response.ok) {
+                const modelId = requestBody.model ?? "unknown";
+                try {
+                    outputBody = translateOpenAIResponseToAnthropic({
+                        body: fullBody,
+                        model: modelId
+                    });
+                }
+                catch (translateError) {
+                    const normalizedTranslateError = asError(translateError);
+                    logEngineMetrics({
+                        agentEngineType: engineType ?? "unknown",
+                        error: normalizedTranslateError,
+                        level: "error",
+                        logger,
+                        requestBodyBytes,
+                        requestPath: "/v1/messages",
+                        responseBytes,
+                        usage: null
+                    });
+                    finalize(normalizedTranslateError);
+                    passThrough.destroy(normalizedTranslateError);
+                    return;
+                }
+            }
+            if (needsTranslation) {
+                const extractedUsage = extractOpenAIUsageFromJSON(fullBody);
+                if (extractedUsage) {
+                    usage.inputTokens = extractedUsage.inputTokens;
+                    usage.outputTokens = extractedUsage.outputTokens;
+                }
+            }
+            else {
+                const extractedUsage = extractAnthropicNonStreamUsage(fullBody);
+                if (extractedUsage) {
+                    usage.inputTokens = extractedUsage.inputTokens;
+                    usage.outputTokens = extractedUsage.outputTokens;
+                }
             }
+            passThrough.write(outputBody);
+            responseBytes = Buffer.byteLength(outputBody, "utf8");
             logEngineMetrics({
                 agentEngineType: engineType ?? "unknown",
                 level: upstreamError ? "error" : "info",
@@ -118579,9 +119353,17 @@ async function proxyAnthropicStreamingRoute({ body, conduitConfiguration, endpoi
                 passThrough.end();
         });
     }
+    const responseHeaders = Object.fromEntries(response.headers.entries());
+    if (needsTranslation) {
+        delete responseHeaders["content-length"];
+        delete responseHeaders["content-encoding"];
+        responseHeaders["content-type"] = streamRequested
+            ? "text/event-stream"
+            : "application/json";
+    }
     return {
         body: passThrough,
-        headers: Object.fromEntries(response.headers.entries()),
+        headers: responseHeaders,
         status: response.status
     };
 }
@@ -128382,6 +129164,58 @@ async function detectVLLMVersion() {
         return null;
     }
 }
+async function detectSGLangVersion() {
+    try {
+        const { stdout } = await execa(process.env.SGLANG_EXECUTABLE ?? "python3", [
+            "-c",
+            "import importlib.metadata as md; print(md.version('sglang'))"
+        ]);
+        const version = stdout.trim();
+        return version.length > 0 ? version : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function detectTensorRTLLMVersion() {
+    try {
+        const { stdout } = await execa(process.env.TRTLLM_EXECUTABLE ?? "python3", [
+            "-c",
+            "import importlib.metadata as md; print(md.version('tensorrt_llm'))"
+        ]);
+        const version = stdout.trim();
+        return version.length > 0 ? version : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function detectExllamav3Version() {
+    try {
+        const { stdout } = await execa(process.env.EXLLAMAV3_EXECUTABLE ?? "python3", [
+            "-c",
+            "import importlib.metadata as md; print(md.version('exllamav3'))"
+        ]);
+        const version = stdout.trim();
+        return version.length > 0 ? version : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function detectMLXLMVersion() {
+    try {
+        const { stdout } = await execa(process.env.MLXLM_EXECUTABLE ?? "python3", [
+            "-c",
+            "import importlib.metadata as md; print(md.version('mlx-lm'))"
+        ]);
+        const version = stdout.trim();
+        return version.length > 0 ? version : null;
+    }
+    catch {
+        return null;
+    }
+}
 function normalizeMegabytes(value) {
     if (typeof value !== "number" || Number.isNaN(value)) {
         return null;
@@ -128668,6 +129502,7 @@ async function collectMachineMetadata() {
             model: cpuInfo?.brand ?? null,
             physicalCores: cpuInfo?.physicalCores ?? null
         },
+        exllamav3Version: await detectExllamav3Version(),
         gpus,
         hostname: os.hostname(),
         llamaCppVersion: await detectLlamaCppVersion(),
@@ -128676,6 +129511,7 @@ async function collectMachineMetadata() {
             availableBytes: memInfo?.available ?? null,
             totalBytes: memInfo?.total ?? null
         },
+        mlxlmVersion: await detectMLXLMVersion(),
         os: {
             arch: osInfo?.arch ?? os.arch(),
             platform: osInfo?.platform ?? os.platform(),
@@ -128683,6 +129519,8 @@ async function collectMachineMetadata() {
             type: osInfo?.kernel ?? null,
             version: osInfo?.build ?? null
         },
+        sglangVersion: await detectSGLangVersion(),
+        tensorrtLlmVersion: await detectTensorRTLLMVersion(),
         vllmVersion: await detectVLLMVersion()
     };
     return machineMetadata;

package/dist/modelManagement/ModelManager.d.ts

@@ -42,6 +42,7 @@ export declare class ModelManager extends EventEmitter<ModelManagerEvents> {
     get canStop(): boolean;
     get state(): EngineLifecycleState;
     private checkEngineReadiness;
+    private checkGenericHealthReadiness;
     private checkLlamacppReadiness;
     private checkVLLMReadiness;
     private waitForEngineReady;

package/dist/modelManagement/exllamav3/index.d.ts

@@ -0,0 +1,6 @@
+import { ProcessManager } from "@infersec/utils";
+import type { ModelManager } from "../ModelManager.js";
+export declare function startExllamav3(this: ModelManager, { enginePort, targetDirectory }: {
+    enginePort: number;
+    targetDirectory: string;
+}): Promise<ProcessManager>;

package/dist/modelManagement/mlxlm.d.ts

@@ -0,0 +1,6 @@
+import { ProcessManager } from "@infersec/utils";
+import type { ModelManager } from "./ModelManager.js";
+export declare function startMLXLM(this: ModelManager, { enginePort, targetDirectory }: {
+    enginePort: number;
+    targetDirectory: string;
+}): Promise<ProcessManager>;

package/dist/modelManagement/sglang.d.ts

@@ -0,0 +1,6 @@
+import { ProcessManager } from "@infersec/utils";
+import type { ModelManager } from "./ModelManager.js";
+export declare function startSGLang(this: ModelManager, { enginePort, targetDirectory }: {
+    enginePort: number;
+    targetDirectory: string;
+}): Promise<ProcessManager>;

package/dist/modelManagement/tensorrtllm.d.ts

@@ -0,0 +1,6 @@
+import { ProcessManager } from "@infersec/utils";
+import type { ModelManager } from "./ModelManager.js";
+export declare function startTensorRTLLM(this: ModelManager, { enginePort, targetDirectory }: {
+    enginePort: number;
+    targetDirectory: string;
+}): Promise<ProcessManager>;

package/dist/utils/anthropicTranslator/index.d.ts

@@ -0,0 +1,13 @@
+import type { EngineConfig, LLMEngine } from "@infersec/definitions";
+import { ENGINE_API_COMPATIBILITY } from "@infersec/definitions";
+export declare function engineSupportsNativeAnthropic(engineType: LLMEngine | null): boolean;
+export declare function translateAnthropicRequestToOpenAI(body: string): {
+    body: string;
+    path: string;
+};
+export declare function translateOpenAIResponseToAnthropic({ body, model }: {
+    body: string;
+    model: string;
+}): string;
+export { ENGINE_API_COMPATIBILITY };
+export type { EngineConfig };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@infersec/conduit",
   "description": "End user conduit agent for connecting local LLMs to the cloud.",
-  "version": "1.74.1",
+  "version": "1.76.0",
   "bin": {
     "infersec-conduit": "./dist/cli.js"
   },