@infersec/conduit 1.113.0 → 1.114.1

package/dist/cli.sea.cjs

@@ -19900,6 +19900,7 @@ object$5({
 });
 
 const LLMEngineSchema = _enum$1([
+    "custom",
     "exllamav3",
     "llama.cpp",
     "mlx-lm",
@@ -19908,8 +19909,25 @@ const LLMEngineSchema = _enum$1([
     "vllm"
 ]);
 const EngineConfigSchema = object$5({
+    baseUrl: string$2().url().nullable().default(null),
     extraArgs: array$1(string$2()),
     type: LLMEngineSchema
+})
+    .superRefine((config, ctx) => {
+    if (config.type === "custom" && config.baseUrl === null) {
+        ctx.addIssue({
+            code: "custom",
+            message: "Engine type 'custom' requires a base URL",
+            path: ["baseUrl"]
+        });
+    }
+    if (config.type !== "custom" && config.baseUrl !== null) {
+        ctx.addIssue({
+            code: "custom",
+            message: "Base URL is only valid for engine type 'custom'",
+            path: ["baseUrl"]
+        });
+    }
 });
 const LLMModelFormatSchema = _enum$1([
     // VLLM / SGLang / TensorRT-LLM
@@ -19968,14 +19986,18 @@ const LLMModelSchema = object$5({
     id: string$2().min(1),
     multimodalEnabled: boolean$1(),
     source: discriminatedUnion("type", [
+        // Custom engines: no local model record, serving is external
         object$5({
-            irid: IRIDSchema,
-            type: literal("storage")
+            type: literal("external")
         }),
         object$5({
             modelSecret: string$2().min(1).nullable(),
             slug: string$2().min(1),
             type: literal("huggingface")
+        }),
+        object$5({
+            irid: IRIDSchema,
+            type: literal("storage")
         })
     ]),
     taskType: LLMModelTaskTypeSchema,
@@ -21119,7 +21141,8 @@ const CreateModelResponseSchema = object$5({
 const CreateSourceBodySchema = object$5({
     contextLength: number$1().int().positive().max(1048576).optional(),
     engineId: ULIDSchema,
-    modelID: ULIDSchema,
+    // Optional for custom engines, which serve externally managed models
+    modelID: ULIDSchema.nullable().optional(),
     name: ResourceNameSchema,
     quantizationLabel: string$2().min(1).max(128).optional()
 });
@@ -21168,7 +21191,7 @@ const SourceDetailResponseSchema = object$5({
 const UpdateSourceBodySchema = object$5({
     contextLength: number$1().int().positive().nullable().optional(),
     engineId: ULIDSchema.nullable().optional(),
-    modelID: ULIDSchema.optional(),
+    modelID: ULIDSchema.nullable().optional(),
     name: ResourceNameSchema.optional(),
     quantizationLabel: string$2().min(1).max(128).nullable().optional()
 });
@@ -21292,6 +21315,7 @@ const CreateEndpointResponseSchema = object$5({
     id: ULIDSchema
 });
 const EngineOutputSchema = object$5({
+    baseUrl: string$2().nullable(),
     created: string$2(),
     extraArgs: array$1(string$2()),
     id: ULIDSchema,
@@ -21300,11 +21324,29 @@ const EngineOutputSchema = object$5({
     updated: string$2()
 });
 const CreateEngineBodySchema = object$5({
+    baseUrl: string$2().url().nullable().optional(),
     extraArgs: array$1(string$2()).optional(),
     name: ResourceNameSchema,
     type: LLMEngineSchema
+})
+    .superRefine((body, ctx) => {
+    if (body.type === "custom" && !body.baseUrl) {
+        ctx.addIssue({
+            code: "custom",
+            message: "Engine type 'custom' requires a base URL",
+            path: ["baseUrl"]
+        });
+    }
+    if (body.type !== "custom" && body.baseUrl) {
+        ctx.addIssue({
+            code: "custom",
+            message: "Base URL is only valid for engine type 'custom'",
+            path: ["baseUrl"]
+        });
+    }
 });
 const UpdateEngineBodySchema = object$5({
+    baseUrl: string$2().url().nullable().optional(),
     extraArgs: array$1(string$2()).optional(),
     name: ResourceNameSchema.optional(),
     type: LLMEngineSchema.optional()
@@ -22110,6 +22152,11 @@ const RecommendedModelSchema = object$5({
 const recommendedModels = RecommendedModelSchema.array().parse(modelsData);
 
 const ENGINE_API_COMPATIBILITY = {
+    custom: {
+        nativeAnthropicMessages: false,
+        supportsEmbeddings: true,
+        supportsVision: true
+    },
     exllamav3: {
         nativeAnthropicMessages: false,
         supportsEmbeddings: false,
@@ -111759,6 +111806,27 @@ function registerEndpointCommands({ program }) {
 }
 
 const ENGINE_TYPES = LLMEngineSchema.options;
+function isValidURL(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === "http:" || url.protocol === "https:";
+    }
+    catch (_error) {
+        return false;
+    }
+}
+function validateEngineBaseURL({ baseUrl, type }) {
+    if (type === "custom" && !baseUrl) {
+        throw new Error("Engine type 'custom' requires --base-url");
+    }
+    if (baseUrl !== undefined && type !== "custom") {
+        throw new Error("--base-url is only valid for engine type 'custom'");
+    }
+    if (baseUrl !== undefined && baseUrl !== "" && !isValidURL(baseUrl)) {
+        throw new Error(`Invalid --base-url value: ${baseUrl}`);
+    }
+    return baseUrl === "" ? null : (baseUrl ?? null);
+}
 function buildEngineCreateBody(options) {
     if (!options.name) {
         throw new Error("--name is required");
@@ -111769,7 +111837,12 @@ function buildEngineCreateBody(options) {
     if (!ENGINE_TYPES.includes(options.type)) {
         throw new Error(`Invalid engine type: ${options.type} (expected one of: ${ENGINE_TYPES.join(", ")})`);
     }
+    const baseUrl = validateEngineBaseURL({
+        baseUrl: options.baseUrl,
+        type: options.type
+    });
     return {
+        baseUrl,
         extraArgs: options.arg ?? [],
         name: options.name,
         type: options.type
@@ -111787,6 +111860,24 @@ function buildEngineUpdateBody(options) {
     }
     if (options.arg !== undefined)
         body.extraArgs = options.arg;
+    if (options.baseUrl !== undefined) {
+        const targetType = body.type;
+        if (targetType !== undefined) {
+            body.baseUrl = validateEngineBaseURL({
+                baseUrl: options.baseUrl,
+                type: targetType
+            });
+        }
+        else if (options.baseUrl === "") {
+            body.baseUrl = null;
+        }
+        else if (!isValidURL(options.baseUrl)) {
+            throw new Error(`Invalid --base-url value: ${options.baseUrl}`);
+        }
+        else {
+            body.baseUrl = options.baseUrl;
+        }
+    }
     return body;
 }
 
@@ -111800,10 +111891,11 @@ function registerEngineCommands({ program }) {
         .description("Create or update an inference engine resource")
         .option("--api-url <url>", "API base URL (required, no environment variable fallback)")
         .option("--arg <flag>", 'Raw engine CLI flag, repeatable (eg --arg "--flash-attn on")', collect, [])
+        .option("--base-url <url>", "Base URL of an external OpenAI-compatible server (engine type 'custom' only)")
         .option("--id <ulid>", "Target an existing engine by ID (requires --update)")
         .option("--key <value>", "API key (required, no environment variable fallback)")
         .option("--name <name>", "Engine name (matched by --update)")
-        .option("--type <type>", "Engine type: llama.cpp|vllm|sglang|tensorrt-llm|mlx-lm|exllamav3")
+        .option("--type <type>", "Engine type: llama.cpp|vllm|sglang|tensorrt-llm|mlx-lm|exllamav3|custom")
         .option("--update", "Update an existing engine matched by name (or --id) instead of erroring")
         .action(async (options) => {
         const { apiURL, apiKey } = resolveManagementConnection(options);
@@ -117803,6 +117895,9 @@ async function getChatTemplateEngineArgs({ engine, model, targetDirectory }) {
         return [];
     const flag = FLAG_BASED_ENGINE_ARGS[engine];
     if (!flag) {
+        if (engine === "custom") {
+            console.warn("[chatTemplate] Custom engines manage their own serving; ignoring chat template override");
+        }
         if (engine === "tensorrt-llm") {
             console.warn("[chatTemplate] TensorRT-LLM does not support chat template overrides; ignoring");
         }
@@ -124700,7 +124795,7 @@ function matchesQuantizationVariant({ filePath, variant }) {
     return segments.slice(0, -1).some(segment => matcher.test(segment));
 }
 async function findQuantizedModelTarget({ model, path }) {
-    if (model.source.type === "storage") {
+    if (model.source.type !== "huggingface") {
         throw new Error("Model storage not supported yet");
     }
     if (model.format !== "gguf") {
@@ -125615,7 +125710,11 @@ function sanitizeSegment(value) {
         .replace(new RegExp(`${SEPARATOR}{2,}`, "g"), SEPARATOR);
 }
 function createModelStorageKey(model) {
-    const identifier = model.source.type === "huggingface" ? model.source.slug : model.source.irid;
+    const identifier = model.source.type === "huggingface"
+        ? model.source.slug
+        : model.source.type === "storage"
+            ? model.source.irid
+            : model.id;
     return `${model.source.type}${SEPARATOR}${sanitizeSegment(identifier)}`;
 }
 
@@ -125691,8 +125790,11 @@ class ModelManager extends EventEmitter {
     uniqueName;
     contextLength;
     logger;
+    discoveredModelNames = [];
+    customProbeCount = 0;
     engineProcess = null;
     healthPollInterval = null;
+    lastCustomReadinessReport = null;
     lastEngineError = null;
     lifecycleState = "stopped";
     downloadLockHandle = null;
@@ -125723,6 +125825,7 @@ class ModelManager extends EventEmitter {
     }
     async fetchOpenAI(path, opts) {
         switch (this.engine) {
+            case "custom":
             case "exllamav3":
             case "llama.cpp":
             case "mlx-lm":
@@ -125730,6 +125833,9 @@ class ModelManager extends EventEmitter {
             case "tensorrt-llm":
             case "vllm": {
                 this.logger.debug(`Fetching from engine: ${path}`);
+                const baseURL = this.engine === "custom"
+                    ? this.requireCustomBaseURL()
+                    : `http://localhost:${this.enginePort}`;
                 const callerSignal = opts?.signal;
                 const controller = new AbortController();
                 const timeout = setTimeout(() => {
@@ -125740,7 +125846,7 @@ class ModelManager extends EventEmitter {
                     : controller.signal;
                 try {
                     const fetchStartedAt = Date.now();
-                    const response = await undiciExports.fetch(joinURL(`http://localhost:${this.enginePort}`, path), {
+                    const response = await undiciExports.fetch(joinURL(baseURL, path), {
                         ...opts,
                         dispatcher: ENGINE_AGENT,
                         headers: {
@@ -125775,6 +125881,11 @@ class ModelManager extends EventEmitter {
             modelID: this.model.id
         });
         switch (this.engine) {
+            case "custom":
+                if (this.model.chatTemplate) {
+                    this.logger.warn("Chat template overrides are ignored for custom engines: the remote server manages its own serving");
+                }
+                break;
             case "exllamav3":
             case "llama.cpp":
             case "mlx-lm":
@@ -125830,7 +125941,9 @@ class ModelManager extends EventEmitter {
         });
         try {
             this.engineProcess = await this.startEngineProcess();
-            this.bindEngineProcessEvents(this.engineProcess);
+            if (this.engineProcess) {
+                this.bindEngineProcessEvents(this.engineProcess);
+            }
             this.logger.info("Started LLM engine", {
                 agentEngineType: this.engine
             });
@@ -125849,7 +125962,7 @@ class ModelManager extends EventEmitter {
             if (!alreadyEmitted) {
                 this.emit("engineError", err);
             }
-            if (this.engineProcess) {
+            if (this.engineProcess || this.engine === "custom") {
                 this.startHealthPoll();
             }
             throw err;
@@ -125857,6 +125970,9 @@ class ModelManager extends EventEmitter {
         this.lifecycleState = "running";
         this.reachedRunningState = true;
         this.emit("engineReady");
+        if (this.engine === "custom") {
+            this.startHealthPoll();
+        }
     }
     async stop() {
         if (this.lifecycleState === "stopping") {
@@ -125877,6 +125993,8 @@ class ModelManager extends EventEmitter {
         this.clearHealthPoll();
         const processManager = this.engineProcess;
         if (!processManager) {
+            this.stopRequested = true;
+            this.reachedRunningState = false;
             this.lifecycleState = "stopped";
             return;
         }
@@ -125902,11 +126020,27 @@ class ModelManager extends EventEmitter {
     get state() {
         return this.lifecycleState;
     }
+    get resolvedServedModelName() {
+        if (this.engine !== "custom")
+            return null;
+        return this.discoveredModelNames[0] ?? null;
+    }
     get wasRunning() {
         return this.reachedRunningState;
     }
+    get customBaseURL() {
+        if (this.engine !== "custom")
+            return null;
+        const baseUrl = this.engineConfig?.baseUrl;
+        if (typeof baseUrl !== "string" || baseUrl.length === 0)
+            return null;
+        return baseUrl.replace(/\/+$/, "");
+    }
     async checkEngineReadiness() {
         switch (this.engine) {
+            case "custom": {
+                return this.checkCustomReadiness();
+            }
             case "llama.cpp": {
                 return this.checkLlamacppReadiness();
             }
@@ -125923,6 +126057,98 @@ class ModelManager extends EventEmitter {
                 return "ready";
         }
     }
+    async checkCustomReadiness() {
+        const baseURL = this.customBaseURL;
+        if (!baseURL) {
+            this.reportCustomReadinessChange("unreachable", "", "no base URL configured");
+            return "unreachable";
+        }
+        const probeURL = joinURL(baseURL, "/v1/models");
+        this.customProbeCount++;
+        try {
+            const response = await undiciExports.fetch(probeURL, {
+                method: "GET",
+                signal: AbortSignal.timeout(5000)
+            });
+            if (response.status === 503) {
+                this.logger.debug("Custom engine probe: server loading", {
+                    attempt: this.customProbeCount,
+                    probeURL
+                });
+                this.reportCustomReadinessChange("loading", baseURL, "server loading (HTTP 503)");
+                return "loading";
+            }
+            if (!response.ok) {
+                const reason = `HTTP ${response.status} from /v1/models`;
+                this.logger.debug("Custom engine probe: not ready", {
+                    attempt: this.customProbeCount,
+                    probeURL,
+                    reason
+                });
+                this.reportCustomReadinessChange("unreachable", baseURL, reason);
+                return "unreachable";
+            }
+            const payload = (await response.json());
+            const models = Array.isArray(payload.data) ? payload.data : [];
+            const modelIDs = models
+                .map(model => {
+                if (model === null || typeof model !== "object")
+                    return null;
+                const id = model.id;
+                return typeof id === "string" ? id : null;
+            })
+                .filter((id) => id !== null);
+            if (modelIDs.length === 0) {
+                this.logger.debug("Custom engine probe: no models exposed yet", {
+                    attempt: this.customProbeCount,
+                    probeURL
+                });
+                this.reportCustomReadinessChange("loading", baseURL, "/v1/models returned no models");
+                return "loading";
+            }
+            if (modelIDs.join("\n") !== this.discoveredModelNames.join("\n")) {
+                this.discoveredModelNames = modelIDs;
+                this.logger.info("Discovered models on custom engine endpoint", {
+                    engineBaseURL: baseURL,
+                    models: modelIDs,
+                    selectedModel: modelIDs[0]
+                });
+            }
+            return "ready";
+        }
+        catch (error) {
+            const reason = asError(error).message;
+            this.logger.debug("Custom engine probe: request failed", {
+                attempt: this.customProbeCount,
+                probeURL,
+                reason
+            });
+            this.reportCustomReadinessChange("unreachable", baseURL, reason);
+            return "unreachable";
+        }
+    }
+    reportCustomReadinessChange(readiness, baseURL, reason) {
+        const key = `${readiness}:${reason}`;
+        if (key === this.lastCustomReadinessReport) {
+            // Same outcome as the last report: surface a heartbeat every 15
+            // attempts (~30s while booting) so progress stays visible.
+            if (this.customProbeCount % 15 === 0) {
+                this.logger.info("Still waiting for custom engine endpoint", {
+                    attempt: this.customProbeCount,
+                    engineBaseURL: baseURL,
+                    reason
+                });
+            }
+            return;
+        }
+        this.lastCustomReadinessReport = key;
+        this.logger.warn(readiness === "loading"
+            ? "Custom engine endpoint is loading — waiting for /v1/models to expose a model"
+            : "Custom engine endpoint unreachable — verify the server is running and reachable from conduit", {
+            engineBaseURL: baseURL,
+            reason
+        });
+    }
     async checkGenericHealthReadiness() {
         try {
             const response = await undiciExports.fetch(joinURL(`http://localhost:${this.enginePort}`, "/health"), {
@@ -125978,23 +126204,41 @@ class ModelManager extends EventEmitter {
         }
     }
     async waitForEngineReady() {
-        const maxWaitMs = 15 * 60 * 1000;
+        const maxWaitMs = Number.parseInt(process.env.ENGINE_STARTUP_TIMEOUT_MS ?? "", 10) || 15 * 60 * 1000;
         const pollIntervalMs = 2000;
         const start = Date.now();
+        if (this.engine === "custom") {
+            this.logger.info(`Connecting to external OpenAI-compatible server at ${this.customBaseURL ?? "(no base URL configured)"} — serving begins once /v1/models exposes a model`, {
+                engineBaseURL: this.customBaseURL ?? ""
+            });
+        }
         while (Date.now() - start < maxWaitMs) {
-            if (this.lifecycleState === "stopping") {
+            if (this.lifecycleState === "stopping" || this.stopRequested) {
                 throw new Error("LLM engine startup interrupted by stop request");
             }
-            if (!this.engineProcess) {
+            if (!this.engineProcess && this.engine !== "custom") {
                 throw new Error("LLM engine process exited before readiness checks completed");
             }
             const readiness = await this.checkEngineReadiness();
             if (readiness === "ready") {
+                // A stop() may have landed while the readiness request was
+                // in flight; re-check before declaring ready.
+                const lifecycleState = this.lifecycleState;
+                if (lifecycleState === "stopping" || this.stopRequested) {
+                    throw new Error("LLM engine startup interrupted by stop request");
+                }
                 return;
             }
             await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
         }
         const stderrTail = this.engineProcess?.stderr?.slice(-1e3);
+        if (this.engine === "custom") {
+            const baseURL = this.customBaseURL ?? "(missing)";
+            const discovered = this.discoveredModelNames;
+            throw new Error(discovered.length > 0
+                ? `Custom engine endpoint at ${baseURL} exposed models (${discovered.join(", ")}) but never reported ready within ${Math.round(maxWaitMs / 1000)}s`
+                : `Custom engine endpoint at ${baseURL} did not expose a model via /v1/models within ${Math.round(maxWaitMs / 1000)}s. Verify the server is running and reachable from conduit (if conduit runs in a container, use the host address instead of localhost)`);
+        }
         throw new Error(stderrTail
             ? `LLM engine failed readiness checks within timeout. Last engine output:\n${stderrTail}`
             : "LLM engine failed readiness checks within timeout");
@@ -126007,19 +126251,32 @@ class ModelManager extends EventEmitter {
     }
     startHealthPoll() {
         this.clearHealthPoll();
-        this.logger.info("Starting background health poll for errored engine");
+        this.logger.info("Starting background engine health poll", {
+            agentEngineType: this.engine
+        });
         this.healthPollInterval = setInterval(() => {
-            if (!this.engineProcess) {
+            if (!this.engineProcess && this.engine !== "custom") {
                 this.clearHealthPoll();
                 return;
             }
             this.checkEngineReadiness()
                 .then(readiness => {
                 if (readiness === "ready") {
-                    this.clearHealthPoll();
-                    this.lifecycleState = "running";
-                    this.reachedRunningState = true;
-                    this.emit("engineReady");
+                    if (this.lifecycleState === "errored" ||
+                        this.lifecycleState === "starting") {
+                        this.lifecycleState = "running";
+                        this.reachedRunningState = true;
+                        this.emit("engineReady");
+                    }
+                    if (this.engine !== "custom") {
+                        this.clearHealthPoll();
+                    }
+                    return;
+                }
+                if (this.engine === "custom" &&
+                    readiness === "unreachable" &&
+                    this.lifecycleState === "running") {
+                    this.recordEngineError(new Error(`Custom engine endpoint unreachable: ${this.customBaseURL}`));
                 }
             })
                 .catch(() => {
@@ -126044,6 +126301,15 @@ class ModelManager extends EventEmitter {
         this.lastEngineError = err;
         this.emit("engineError", err);
     }
+    requireCustomBaseURL() {
+        const baseURL = this.customBaseURL;
+        if (!baseURL) {
+            throw new ConfigurationInvalidError({
+                message: "Custom engine requires a base URL"
+            });
+        }
+        return baseURL;
+    }
     async releaseDownloadLock() {
         const handle = this.downloadLockHandle;
         if (!handle)
@@ -126110,6 +126376,8 @@ class ModelManager extends EventEmitter {
     async startEngineProcess() {
         const targetDir = path$1.join(this.modelsDirectory, this.uniqueName);
         switch (this.engine) {
+            case "custom":
+                return null;
             case "exllamav3":
                 return startExllamav3.call(this, {
                     enginePort: this.enginePort,
@@ -126421,8 +126689,9 @@ function isEngineUsageChunk(value) {
     }
     return true;
 }
-function monitorEngineResponseStream({ agentEngineType, body, contextLength, engineConfig, engineType, logger, onComplete, requestBodyBytes, requestPath, requestStartedAt }) {
+function monitorEngineResponseStream({ agentEngineType, body, contextLength, engineConfig, engineType, logger, onComplete, requestBodyBytes, requestPath, requestStartedAt, responseModelName }) {
     const startedAt = requestStartedAt ?? Date.now();
+    const clientModelName = responseModelName ?? null;
     const passThrough = new require$$0$8.PassThrough();
     passThrough.on("error", (error) => {
         logger.error("Engine response stream error", {
@@ -126434,53 +126703,61 @@ function monitorEngineResponseStream({ agentEngineType, body, contextLength, eng
     let firstChunkAt = null;
     let usage = null;
     let buffer = "";
+    let pendingFragment = "";
     let completed = false;
-    function modifyChunkWithUsage(chunk) {
-        const text = chunk.toString("utf8");
-        const lines = text.split("\n");
-        const modifiedLines = [];
-        for (const rawLine of lines) {
-            const line = rawLine.trim();
-            if (!line.startsWith("data:")) {
-                modifiedLines.push(rawLine);
-                continue;
+    function rewriteDataLine(rawLine) {
+        const line = rawLine.trim();
+        if (!line.startsWith("data:")) {
+            return rawLine;
+        }
+        const payload = line.slice(5).trim();
+        if (!payload || payload === "[DONE]") {
+            return rawLine;
+        }
+        try {
+            const parsed = JSON.parse(payload);
+            let modified = false;
+            if (coerceToolCallArguments(parsed)) {
+                modified = true;
             }
-            const payload = line.slice(5).trim();
-            if (!payload || payload === "[DONE]") {
-                modifiedLines.push(rawLine);
-                continue;
+            if (clientModelName !== null &&
+                typeof parsed.model === "string" &&
+                parsed.model !== clientModelName) {
+                parsed.model = clientModelName;
+                modified = true;
             }
-            try {
-                const parsed = JSON.parse(payload);
-                let modified = false;
-                if (coerceToolCallArguments(parsed)) {
+            if (parsed.usage) {
+                const usageChunk = parsed.usage;
+                const effectiveContext = getEffectiveContextLength({
+                    contextLength,
+                    engineConfig,
+                    engineType
+                });
+                if (usageChunk.context_usage === undefined &&
+                    usageChunk.prompt_tokens !== undefined &&
+                    effectiveContext !== null) {
+                    usageChunk.context_usage = usageChunk.prompt_tokens / effectiveContext;
                     modified = true;
                 }
-                if (parsed.usage) {
-                    const usageChunk = parsed.usage;
-                    const effectiveContext = getEffectiveContextLength({
-                        contextLength,
-                        engineConfig,
-                        engineType
-                    });
-                    if (usageChunk.context_usage === undefined &&
-                        usageChunk.prompt_tokens !== undefined &&
-                        effectiveContext !== null) {
-                        usageChunk.context_usage = usageChunk.prompt_tokens / effectiveContext;
-                        modified = true;
-                    }
-                }
-                if (modified) {
-                    modifiedLines.push("data: " + JSON.stringify(parsed));
-                    continue;
-                }
             }
-            catch (_error) {
-                // Ignore malformed chunks
+            if (modified) {
+                return "data: " + JSON.stringify(parsed);
             }
-            modifiedLines.push(rawLine);
         }
-        return Buffer.from(modifiedLines.join("\n"), "utf8");
+        catch (_error) {
+            // Ignore malformed chunks
+        }
+        return rawLine;
+    }
+    // SSE events can split across transport chunks: hold back the trailing
+    // (newline-less) fragment and only rewrite complete data lines, so a
+    // partial JSON event is never forwarded with its upstream model name.
+    function modifyChunkWithUsage(chunk, flush = false) {
+        const combined = pendingFragment + chunk.toString("utf8");
+        const lines = combined.split("\n");
+        pendingFragment = flush ? "" : (lines.pop() ?? "");
+        const modifiedLines = lines.map(rewriteDataLine);
+        return Buffer.from(modifiedLines.length > 0 ? modifiedLines.join("\n") + (flush ? "" : "\n") : "", "utf8");
     }
     function parseUsageFromBuffer() {
         const lines = buffer.split("\n");
@@ -126576,6 +126853,9 @@ function monitorEngineResponseStream({ agentEngineType, body, contextLength, eng
         if (buffer.length > 0) {
             parseUsageFromBuffer();
         }
+        if (pendingFragment.length > 0) {
+            passThrough.write(modifyChunkWithUsage(Buffer.from("", "utf8"), true));
+        }
         logEngineMetrics({
             agentEngineType,
             level: "info",
@@ -126618,9 +126898,11 @@ function monitorEngineResponseStream({ agentEngineType, body, contextLength, eng
         stream: passThrough
     };
 }
-function monitorEngineResponseSingle({ agentEngineType, body, contextLength, engineConfig, engineType, logger, onComplete, requestBodyBytes, requestPath, requestStartedAt }) {
+function monitorEngineResponseSingle({ agentEngineType, body, contextLength, engineConfig, engineType, logger, onComplete, requestBodyBytes, requestPath, requestStartedAt, responseModelName }) {
     const maxUsageCaptureBytes = 1024 * 1024;
     const startedAt = requestStartedAt ?? Date.now();
+    const clientModelName = responseModelName ?? null;
+    const rewriteBuffer = clientModelName !== null ? [] : null;
     const passThrough = new require$$0$8.PassThrough();
     passThrough.on("error", (error) => {
         logger.error("Engine response stream error", {
@@ -126676,7 +126958,12 @@ function monitorEngineResponseSingle({ agentEngineType, body, contextLength, eng
                 usageChunks.length = 0;
             }
         }
-        passThrough.write(chunkBuffer);
+        if (rewriteBuffer) {
+            rewriteBuffer.push(chunkBuffer);
+        }
+        else {
+            passThrough.write(chunkBuffer);
+        }
     });
     body.once("error", err => {
         logEngineMetrics({
@@ -126736,6 +127023,24 @@ function monitorEngineResponseSingle({ agentEngineType, body, contextLength, eng
             responseBytes,
             usage
         });
+        if (rewriteBuffer) {
+            const original = Buffer.concat(rewriteBuffer);
+            let output = original;
+            try {
+                const parsed = JSON.parse(original.toString("utf8"));
+                if (parsed !== null &&
+                    typeof parsed === "object" &&
+                    typeof parsed.model === "string" &&
+                    parsed.model !== clientModelName) {
+                    parsed.model = clientModelName;
+                    output = Buffer.from(JSON.stringify(parsed), "utf8");
+                }
+            }
+            catch (_error) {
+                // Non-JSON body: pass through untouched
+            }
+            passThrough.write(output);
+        }
         finalize(null);
         passThrough.end();
     });
@@ -126872,7 +127177,7 @@ function applyChatTemplateKwargs({ body, model }) {
     }
     return payload;
 }
-function serializeRequestBody$1(body, { model, path } = {}) {
+function serializeRequestBody$1(body, { model, path, servedModelName } = {}) {
     if (!isPlainObject$a(body)) {
         const payload = typeof body === "string" ? body : JSON.stringify(body);
         return {
@@ -126881,6 +127186,9 @@ function serializeRequestBody$1(body, { model, path } = {}) {
         };
     }
     let requestPayload = { ...body };
+    if (servedModelName) {
+        requestPayload.model = servedModelName;
+    }
     if (path === "/v1/chat/completions" && model) {
         requestPayload = applyChatTemplateKwargs({ body: requestPayload, model });
     }
@@ -126937,8 +127245,15 @@ async function proxyEmbeddingsRoute({ body, conduitConfiguration, endpointId, lo
     }
     const engineType = conduitConfiguration.engineConfig?.type ?? null;
     const engineConfig = conduitConfiguration.engineConfig ?? null;
+    const servedModelName = modelManager.resolvedServedModelName;
+    const clientModelName = isPlainObject$a(body) && typeof body.model === "string" ? body.model : null;
     const serializedBody = isPlainObject$a(body)
-        ? JSON.stringify(body)
+        ? JSON.stringify(servedModelName
+            ? {
+                ...body,
+                model: servedModelName
+            }
+            : body)
         : typeof body === "string"
             ? body
             : JSON.stringify(body);
@@ -127056,14 +127371,27 @@ async function proxyEmbeddingsRoute({ body, conduitConfiguration, endpointId, lo
         onComplete: onMonitoringComplete,
         requestBodyBytes,
         requestPath: "/v1/embeddings",
-        requestStartedAt
+        requestStartedAt,
+        responseModelName: servedModelName ? clientModelName : null
     });
     return {
         body: monitoredResponse.stream,
-        headers: Object.fromEntries(response.headers.entries()),
+        headers: buildProxyResponseHeaders(response.headers, Boolean(servedModelName)),
         status: response.status
     };
 }
+/**
+ * Forwards upstream headers, dropping content-length when the response body
+ * is rewritten (model-name substitution changes its length; a stale
+ * content-length desyncs the stream and aborts downstream readers).
+ */
+function buildProxyResponseHeaders(headers, rewriteActive) {
+    const forwarded = Object.fromEntries(headers.entries());
+    if (rewriteActive) {
+        delete forwarded["content-length"];
+    }
+    return forwarded;
+}
 async function proxyOpenAIStreamingRoute({ body, conduitConfiguration, endpointId, logger, modelID, modelManager, path, reportMetrics, signal }) {
     function normalizeTokenCount(value) {
         if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
@@ -127081,8 +127409,10 @@ async function proxyOpenAIStreamingRoute({ body, conduitConfiguration, endpointI
     }
     const engineType = conduitConfiguration.engineConfig?.type ?? null;
     const engineConfig = conduitConfiguration.engineConfig ?? null;
+    const servedModelName = modelManager.resolvedServedModelName;
+    const clientModelName = isPlainObject$a(body) && typeof body.model === "string" ? body.model : null;
     const effectiveBody = modelManager.model.multimodalEnabled ? body : stripImagesFromBody(body);
-    const { bytes: requestBodyBytes, payload: serializedBody } = serializeRequestBody$1(effectiveBody, { model: modelManager.model, path });
+    const { bytes: requestBodyBytes, payload: serializedBody } = serializeRequestBody$1(effectiveBody, { model: modelManager.model, path, servedModelName });
     const requestStartedAt = Date.now();
     const requestBody = JSON.parse(serializedBody);
     const streamRequested = requestBody.stream === true;
@@ -127222,7 +127552,8 @@ async function proxyOpenAIStreamingRoute({ body, conduitConfiguration, endpointI
             onComplete: onMonitoringComplete,
             requestBodyBytes,
             requestPath: path,
-            requestStartedAt
+            requestStartedAt,
+            responseModelName: servedModelName ? clientModelName : null
         })
         : monitorEngineResponseSingle({
             agentEngineType: engineType ?? "unknown",
@@ -127234,11 +127565,12 @@ async function proxyOpenAIStreamingRoute({ body, conduitConfiguration, endpointI
             onComplete: onMonitoringComplete,
             requestBodyBytes,
             requestPath: path,
-            requestStartedAt
+            requestStartedAt,
+            responseModelName: servedModelName ? clientModelName : null
         });
     return {
         body: monitoredResponse.stream,
-        headers: Object.fromEntries(response.headers.entries()),
+        headers: buildProxyResponseHeaders(response.headers, Boolean(servedModelName)),
         status: response.status
     };
 }
@@ -158743,13 +159075,16 @@ async function detectDockerVersion() {
  * Flattens flat CLI extra-arg tokens into [arg, value] pairs, sorted by ARG NAME (ascending, ties by
  * value). `--flag=value` pairs split on the first `=`; a bare `--flag` consumes the following token
  * as its value when that token does not start with "-" (classic CLI convention); anything else
- * (flags, non-strings) is dropped.
+ * (flags, non-strings) is dropped. Secret-like option values are masked before pairing so they
+ * never reach execution reports.
  */
 function pairExtraArgs(tokens) {
     if (!Array.isArray(tokens)) {
         return [];
     }
-    const list = tokens;
+    // Non-string tokens become empty strings: they keep their position as a
+    // non-consumable barrier while allowing secret masking over string tokens.
+    const list = redactSecretArgs(tokens.map(token => (typeof token === "string" ? token : "")));
     const pairs = [];
     let index = 0;
     while (index < list.length) {
@@ -158885,9 +159220,9 @@ async function createApplication({ abortController, apiClient, configuration, lo
     }
     const reporter = new EngineExecutionReporter({
         buildContext: () => {
-            const engineType = (conduitConfiguration.engineConfig?.type ??
-                "llama.cpp");
+            const engineType = conduitConfiguration.engineConfig?.type ?? "llama.cpp";
             const versions = {
+                custom: null,
                 exllamav3: machine?.exllamav3Version ?? null,
                 "llama.cpp": machine?.llamaCppVersion ?? null,
                 "mlx-lm": machine?.mlxlmVersion ?? null,
@@ -159087,23 +159422,33 @@ async function createApplication({ abortController, apiClient, configuration, lo
         logger.info("Engine start requested");
         reporter.beginStartup(new Date());
         try {
-            conduitStateManager.setState({
-                modelFileName,
-                modelName,
-                state: "downloadingModelFiles",
-                totalProgress: {
-                    file: 0,
-                    total: 0
-                }
-            });
-            await conduitStateReportManager.reportNow();
+            if (modelManager.engine === "custom") {
+                conduitStateManager.setState({
+                    state: "bootingEngine"
+                });
+                await conduitStateReportManager.reportNow();
+            }
+            else {
+                conduitStateManager.setState({
+                    modelFileName,
+                    modelName,
+                    state: "downloadingModelFiles",
+                    totalProgress: {
+                        file: 0,
+                        total: 0
+                    }
+                });
+                await conduitStateReportManager.reportNow();
+            }
             await modelManager.prepare({
                 onDownloadProgress: reportDownloadProgress
             });
-            conduitStateManager.setState({
-                state: "bootingEngine"
-            });
-            await conduitStateReportManager.reportNow();
+            if (modelManager.engine !== "custom") {
+                conduitStateManager.setState({
+                    state: "bootingEngine"
+                });
+                await conduitStateReportManager.reportNow();
+            }
             await modelManager.start();
         }
         catch (error) {
@@ -159374,7 +159719,11 @@ function createModelManagerFromConfig(conduitConfiguration, configuration, logge
     return new ModelManager({
         contextLength: conduitConfiguration.contextLength ?? null,
         engineConfig: engineConfig
-            ? { extraArgs: engineConfig.extraArgs, type: engineConfig.type }
+            ? {
+                baseUrl: engineConfig.baseUrl ?? null,
+                extraArgs: engineConfig.extraArgs,
+                type: engineConfig.type
+            }
             : null,
         enginePort: configuration.enginePort,
         engineType: engineConfig?.type ?? "llama.cpp",
@@ -159385,7 +159734,11 @@ function createModelManagerFromConfig(conduitConfiguration, configuration, logge
 }
 function getConduitModelFileName(configuration) {
     const { source } = configuration.targetModel;
-    return source.type === "huggingface" ? source.slug : source.irid;
+    if (source.type === "huggingface")
+        return source.slug;
+    if (source.type === "storage")
+        return source.irid;
+    return configuration.targetModel.id;
 }
 function getConduitModelName(configuration) {
     return configuration.targetModel.id;
@@ -364053,16 +364406,15 @@ function buildSourceCreateBody(options) {
     if (!options.engine) {
         throw new Error("--engine is required (engine ID from `engine create`)");
     }
-    if (!options.model) {
-        throw new Error("--model is required (model ID from `models create`)");
-    }
     validateULID({ flagName: "--engine", value: options.engine });
-    validateULID({ flagName: "--model", value: options.model });
     const body = {
         engineId: options.engine,
-        modelID: options.model,
+        modelID: options.model ?? null,
         name: options.name
     };
+    if (options.model !== undefined) {
+        validateULID({ flagName: "--model", value: options.model });
+    }
     if (options.quant !== undefined) {
         validateQuant(options.quant);
         body.quantizationLabel = options.quant;
@@ -364104,7 +364456,7 @@ function registerSourceCommands({ program }) {
         .option("--engine <id>", "Engine ID to run this source with (required)")
         .option("--id <ulid>", "Target an existing source by ID (requires --update)")
         .option("--key <value>", "API key (required, no environment variable fallback)")
-        .option("--model <id>", "Model ID to serve (required)")
+        .option("--model <id>", "Model ID to serve (required unless the engine type is custom)")
         .option("--name <name>", "Source name (matched by --update)")
         .option("--quant <label>", "Quantization variant label (eg Q4_K_M)")
         .option("--update", "Update an existing source matched by name (or --id) instead of erroring")