@infersec/conduit 1.112.1 → 1.114.0

package/dist/cli.js

@@ -19886,6 +19886,7 @@ object$5({
 });
 
 const LLMEngineSchema = _enum$1([
+    "custom",
     "exllamav3",
     "llama.cpp",
     "mlx-lm",
@@ -19894,8 +19895,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
@@ -19954,14 +19972,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,
@@ -19972,6 +19994,32 @@ object$5({
     sizeBytes: number$1().int().nonnegative().nullable()
 });
 
+const EngineExecutionErrorTypeSchema = _enum$1([
+    "config",
+    "crash",
+    "oom",
+    "prompt",
+    "unknown"
+]);
+const EngineExecutionReportPayloadSchema = object$5({
+    avgTps: number$1().nonnegative().finite().default(0),
+    completionTokens: number$1().int().nonnegative().default(0),
+    durationMs: number$1().int().nonnegative().default(0),
+    engineType: LLMEngineSchema.nullable(),
+    engineVersion: string$2().max(64).nullable().default(null),
+    errorDetail: string$2().max(2048).nullable().default(null),
+    errorType: EngineExecutionErrorTypeSchema.nullable(),
+    extraArgs: array$1(tuple([string$2().min(1).max(128), string$2().max(512)]))
+        .max(256)
+        .default([]),
+    finishedAtISO: string$2().datetime({ offset: true }),
+    peakTps: number$1().nonnegative().finite().nullable().default(null),
+    promptTokens: number$1().int().nonnegative().default(0),
+    runAtISO: string$2().datetime({ offset: true }),
+    success: boolean$1(),
+    ttftMs: number$1().int().nonnegative().default(0),
+    totalTokens: number$1().int().nonnegative().default(0)
+});
 const InferenceAgentLLMMetricsPayloadSchema = object$5({
     bytes: number$1().int().nonnegative(),
     completionTokens: number$1().int().nonnegative(),
@@ -20310,6 +20358,23 @@ const API_SERVICE_CONDUIT_API_REFERENCE = {
             }
         }
     },
+    "/conduit/api/v1/source/:sourceID/engine/execution": {
+        POST: {
+            auth: {
+                type: "api-key"
+            },
+            body: EngineExecutionReportPayloadSchema,
+            parameters: {
+                sourceID: ULIDSchema
+            },
+            response: {
+                schema: object$5({
+                    acknowledged: literal(true)
+                }),
+                type: "rest"
+            }
+        }
+    },
     "/conduit/api/v1/source/:sourceID/requests/:requestID/chunk": {
         POST: {
             auth: {
@@ -21062,7 +21127,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()
 });
@@ -21111,7 +21177,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()
 });
@@ -21235,6 +21301,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,
@@ -21243,11 +21310,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()
@@ -22053,6 +22138,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,
@@ -111702,6 +111792,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");
@@ -111712,7 +111823,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
@@ -111730,6 +111846,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;
 }
 
@@ -111743,10 +111877,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);
@@ -113767,6 +113902,19 @@ function createAPIClient({ apiKey, apiURL, inferenceSourceID, logger }) {
                 route: "/conduit/api/v1/source/:sourceID/state"
             });
         },
+        reportEngineExecution: async (payload) => {
+            await fetchByReference({
+                baseURL: apiURL,
+                body: payload,
+                fetch: fetchWithAPIKey,
+                method: "POST",
+                parameters: {
+                    sourceID: inferenceSourceID
+                },
+                reference: API_SERVICE_CONDUIT_API_REFERENCE,
+                route: "/conduit/api/v1/source/:sourceID/engine/execution"
+            });
+        },
         reportPromptMetrics: async (payload) => {
             await fetchByReference({
                 baseURL: apiURL,
@@ -117733,6 +117881,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");
         }
@@ -124630,7 +124781,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") {
@@ -125545,7 +125696,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)}`;
 }
 
@@ -125621,12 +125776,16 @@ class ModelManager extends EventEmitter {
     uniqueName;
     contextLength;
     logger;
+    discoveredModelNames = [];
     engineProcess = null;
     healthPollInterval = null;
     lastEngineError = null;
     lifecycleState = "stopped";
     downloadLockHandle = null;
     stopRequested = false;
+    lastEngineExitCode = null;
+    lastEngineExitSignal = null;
+    reachedRunningState = false;
     modelsDirectory;
     constructor({ contextLength, engineConfig, enginePort, engineType, logger, model, root }) {
         super();
@@ -125650,6 +125809,7 @@ class ModelManager extends EventEmitter {
     }
     async fetchOpenAI(path, opts) {
         switch (this.engine) {
+            case "custom":
             case "exllamav3":
             case "llama.cpp":
             case "mlx-lm":
@@ -125657,6 +125817,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(() => {
@@ -125667,7 +125830,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: {
@@ -125702,6 +125865,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":
@@ -125749,12 +125917,17 @@ class ModelManager extends EventEmitter {
         this.lifecycleState = "starting";
         this.lastEngineError = null;
         this.stopRequested = false;
+        this.lastEngineExitCode = null;
+        this.lastEngineExitSignal = null;
+        this.reachedRunningState = false;
         this.logger.info("Starting LLM engine", {
             agentEngineType: this.engine
         });
         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
             });
@@ -125773,13 +125946,17 @@ class ModelManager extends EventEmitter {
             if (!alreadyEmitted) {
                 this.emit("engineError", err);
             }
-            if (this.engineProcess) {
+            if (this.engineProcess || this.engine === "custom") {
                 this.startHealthPoll();
             }
             throw err;
         }
         this.lifecycleState = "running";
+        this.reachedRunningState = true;
         this.emit("engineReady");
+        if (this.engine === "custom") {
+            this.startHealthPoll();
+        }
     }
     async stop() {
         if (this.lifecycleState === "stopping") {
@@ -125800,9 +125977,12 @@ class ModelManager extends EventEmitter {
         this.clearHealthPoll();
         const processManager = this.engineProcess;
         if (!processManager) {
+            this.stopRequested = true;
+            this.reachedRunningState = false;
             this.lifecycleState = "stopped";
             return;
         }
+        this.reachedRunningState = false;
         this.lifecycleState = "stopping";
         this.stopRequested = true;
         await processManager.stop();
@@ -125815,11 +125995,34 @@ class ModelManager extends EventEmitter {
             this.lifecycleState === "starting" ||
             this.lifecycleState === "errored");
     }
+    get lastExitCode() {
+        return this.lastEngineExitCode;
+    }
+    get lastExitSignal() {
+        return this.lastEngineExitSignal;
+    }
     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;
+        return typeof baseUrl === "string" && baseUrl.length > 0 ? baseUrl : null;
+    }
     async checkEngineReadiness() {
         switch (this.engine) {
+            case "custom": {
+                return this.checkCustomReadiness();
+            }
             case "llama.cpp": {
                 return this.checkLlamacppReadiness();
             }
@@ -125836,6 +126039,51 @@ class ModelManager extends EventEmitter {
                 return "ready";
         }
     }
+    async checkCustomReadiness() {
+        const baseURL = this.customBaseURL;
+        if (!baseURL) {
+            return "unreachable";
+        }
+        try {
+            const response = await undiciExports.fetch(joinURL(baseURL, "/v1/models"), {
+                method: "GET",
+                signal: AbortSignal.timeout(5000)
+            });
+            if (response.status === 503) {
+                return "loading";
+            }
+            if (!response.ok) {
+                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.warn("Custom engine endpoint exposed no models via /v1/models", {
+                    engineBaseURL: baseURL
+                });
+                return "loading";
+            }
+            if (modelIDs.join("\n") !== this.discoveredModelNames.join("\n")) {
+                this.logger.info("Discovered models on custom engine endpoint", {
+                    engineBaseURL: baseURL,
+                    models: modelIDs
+                });
+                this.discoveredModelNames = modelIDs;
+            }
+            return "ready";
+        }
+        catch (_error) {
+            return "unreachable";
+        }
+    }
     async checkGenericHealthReadiness() {
         try {
             const response = await undiciExports.fetch(joinURL(`http://localhost:${this.enginePort}`, "/health"), {
@@ -125891,18 +126139,24 @@ 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();
         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));
@@ -125920,18 +126174,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.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(() => {
@@ -125956,6 +126224,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)
@@ -125993,6 +126270,8 @@ class ModelManager extends EventEmitter {
             }));
         });
         processManager.on("stopped", (code, signal) => {
+            this.lastEngineExitCode = code;
+            this.lastEngineExitSignal = signal;
             if (hasTerminated) {
                 return;
             }
@@ -126020,6 +126299,8 @@ class ModelManager extends EventEmitter {
     async startEngineProcess() {
         const targetDir = join(this.modelsDirectory, this.uniqueName);
         switch (this.engine) {
+            case "custom":
+                return null;
             case "exllamav3":
                 return startExllamav3.call(this, {
                     enginePort: this.enginePort,
@@ -126060,6 +126341,69 @@ class ModelManager extends EventEmitter {
     }
 }
 
+// Ordered most-specific first: a message mentioning a prompt-size failure should classify as
+// "prompt" even if it also touches memory text; memory outranks config because OOM kills frequently
+// emit sparse stderr. These are heuristics, not exhaustively enumerated engine vocabularies.
+const OOM_PATTERNS = [
+    /CUDA out of memory/i,
+    /No available memory for the cache blocks/i,
+    /\bOOMKilled\b/,
+    /out of memory/i,
+    /MemoryError/i,
+    /Cannot allocate memory/i
+];
+const PROMPT_PATTERNS = [
+    /prompt is too long/i,
+    /maximum context length exceeded/i,
+    /too many tokens/i
+];
+const CONFIG_PATTERNS = [
+    /unrecognized argument/i,
+    /invalid argument/i,
+    /error while loading state_dict/i,
+    /Architecture not understood/i,
+    /No such file or directory/i
+];
+/**
+ * Coarse engine-failure classification used only to fill `engine_execution.error_type`. Exit code and
+ * terminating signal are consulted FIRST (SIGKILL/SIGSEGV are reliable OOM signals regardless of
+ * how much stderr the engine produced); the message text then refines the category. Anything
+ * unrecognized is "unknown".
+ */
+function classifyEngineFailure({ error, exitCode, signal }) {
+    // 137 = SIGKILL (kernel OOM-killer), 139 = SIGSEGV (illegal memory access). Treat both as OOM
+    // so that memory-pressure deaths do not degrade to "unknown" when stderr is truncated.
+    if (exitCode === 137 || exitCode === 139) {
+        return "oom";
+    }
+    // Direct OS kills (SIGKILL/SIGSEGV) leave no meaningful exit code; honor them like 137/139.
+    if (signal === "SIGKILL" || signal === "SIGSEGV") {
+        return "oom";
+    }
+    const text = `${error.message}`.slice(0, 4000);
+    for (const pattern of PROMPT_PATTERNS) {
+        if (pattern.test(text)) {
+            return "prompt";
+        }
+    }
+    for (const pattern of OOM_PATTERNS) {
+        if (pattern.test(text)) {
+            return "oom";
+        }
+    }
+    for (const pattern of CONFIG_PATTERNS) {
+        if (pattern.test(text)) {
+            return "config";
+        }
+    }
+    // A process that exited abnormally with no recognizable diagnostic: treat as a crash rather
+    // than "unknown" so the two buckets distinguish "we saw nothing" from "it died badly".
+    if (exitCode !== null && exitCode !== 0) {
+        return "crash";
+    }
+    return "unknown";
+}
+
 const EXCEPTION_LINE_PATTERN = /([A-Za-z_][A-Za-z0-9_]*(?:Error|Exception)):\s*(.+)/;
 const FALLBACK_DETAIL_MAX_LENGTH = 300;
 const FALLBACK_RAW_MAX_LENGTH = 500;
@@ -126268,8 +126612,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 PassThrough();
     passThrough.on("error", (error) => {
         logger.error("Engine response stream error", {
@@ -126281,53 +126626,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");
@@ -126423,6 +126776,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",
@@ -126465,9 +126821,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 PassThrough();
     passThrough.on("error", (error) => {
         logger.error("Engine response stream error", {
@@ -126523,7 +126881,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({
@@ -126583,6 +126946,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();
     });
@@ -126719,7 +127100,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 {
@@ -126728,6 +127109,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 });
     }
@@ -126784,8 +127168,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);
@@ -126903,7 +127294,8 @@ async function proxyEmbeddingsRoute({ body, conduitConfiguration, endpointId, lo
         onComplete: onMonitoringComplete,
         requestBodyBytes,
         requestPath: "/v1/embeddings",
-        requestStartedAt
+        requestStartedAt,
+        responseModelName: servedModelName ? clientModelName : null
     });
     return {
         body: monitoredResponse.stream,
@@ -126928,8 +127320,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;
@@ -127069,7 +127463,8 @@ async function proxyOpenAIStreamingRoute({ body, conduitConfiguration, endpointI
             onComplete: onMonitoringComplete,
             requestBodyBytes,
             requestPath: path,
-            requestStartedAt
+            requestStartedAt,
+            responseModelName: servedModelName ? clientModelName : null
         })
         : monitorEngineResponseSingle({
             agentEngineType: engineType ?? "unknown",
@@ -127081,7 +127476,8 @@ async function proxyOpenAIStreamingRoute({ body, conduitConfiguration, endpointI
             onComplete: onMonitoringComplete,
             requestBodyBytes,
             requestPath: path,
-            requestStartedAt
+            requestStartedAt,
+            responseModelName: servedModelName ? clientModelName : null
         });
     return {
         body: monitoredResponse.stream,
@@ -138371,6 +138767,122 @@ 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. Secret-like option values are masked before pairing so they
+ * never reach execution reports.
+ */
+function pairExtraArgs(tokens) {
+    if (!Array.isArray(tokens)) {
+        return [];
+    }
+    // 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) {
+        const token = list[index];
+        if (typeof token !== "string" || token.length === 0 || !token.startsWith("-")) {
+            index++;
+            continue;
+        }
+        const separator = token.indexOf("=");
+        if (separator > -1) {
+            const arg = token.slice(0, separator);
+            if (arg.length > 0) {
+                pairs.push([arg, token.slice(separator + 1)]);
+            }
+            index++;
+            continue;
+        }
+        const next = list[index + 1];
+        const consumesNext = typeof next === "string" && next.length > 0 && !next.startsWith("-");
+        if (consumesNext) {
+            pairs.push([token, next]);
+            index += 2;
+        }
+        else {
+            pairs.push([token, ""]);
+            index++;
+        }
+    }
+    return pairs.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0);
+}
+/**
+ * Files AT MOST ONE engine_execution report per engine startup. `beginStartup(runAt)` re-arms the
+ * latch on every fresh model start (initial boot or cycle) and stamps the startup epoch used as the
+ * row's `run_at`. Whichever of the three report* paths fires first wins: startup failure, in-flight
+ * crash, or first successful full prompt completion.
+ */
+class EngineExecutionReporter {
+    options;
+    currentStartupAt = null;
+    reportedForCurrentStartup = false;
+    constructor(options) {
+        this.options = options;
+    }
+    /** Re-arms the latch; the stamp becomes the row's `run_at` (moment startup began). */
+    beginStartup(runAt) {
+        this.currentStartupAt = runAt;
+        this.reportedForCurrentStartup = false;
+    }
+    /** Reports a startup failure (rejected prepare/start, readiness timeout, pre-ready death). */
+    async reportStartupFailure(report) {
+        await this.file(report, false);
+    }
+    /** Reports a spontaneous crash of an engine that had reached the running state. */
+    async reportRuntimeCrash(report) {
+        await this.file(report, false);
+    }
+    /** Reports the first fully-responded, token-bearing prompt completion since startup. */
+    async reportSuccess(report) {
+        await this.file(report, true);
+    }
+    async file(report, success) {
+        if (this.reportedForCurrentStartup || this.currentStartupAt === null) {
+            return;
+        }
+        // Latch BEFORE the network call: a thrown POST cannot double-file for this startup.
+        this.reportedForCurrentStartup = true;
+        const context = this.options.buildContext();
+        const payload = {
+            avgTps: report.throughput.avgTps,
+            completionTokens: report.usage.completionTokens,
+            durationMs: report.durationMs,
+            engineType: context.engineType,
+            engineVersion: context.engineVersion,
+            errorDetail: success ? null : report.errorDetail,
+            errorType: success ? null : report.errorType,
+            extraArgs: context.extraArgsPairs,
+            finishedAtISO: new Date().toISOString(),
+            peakTps: report.throughput.peakTps,
+            promptTokens: report.usage.promptTokens,
+            runAtISO: this.currentStartupAt.toISOString(),
+            success,
+            ttftMs: report.ttftMs,
+            totalTokens: report.usage.totalTokens
+        };
+        try {
+            await this.options.report(payload);
+            this.options.logger.info("Engine execution outcome reported", {
+                inferenceSourceID: this.options.sourceLabel,
+                success
+            });
+        }
+        catch (error) {
+            // Losing one report is preferable to filing two; the latch stays latched.
+            this.options.logger.warn("Failed to report engine execution outcome", {
+                error: asError(error),
+                inferenceSourceID: this.options.sourceLabel,
+                success
+            });
+        }
+    }
+}
+
 async function createApplication({ abortController, apiClient, configuration, logger }) {
     ensureDockerValidEnv();
     logger.info("Fetching conduit configuration");
@@ -138402,6 +138914,87 @@ async function createApplication({ abortController, apiClient, configuration, lo
             error: asError(error)
         });
     }
+    const reporter = new EngineExecutionReporter({
+        buildContext: () => {
+            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,
+                sglang: machine?.sglangVersion ?? null,
+                "tensorrt-llm": machine?.tensorrtLlmVersion ?? null,
+                vllm: machine?.vllmVersion ?? null
+            };
+            return {
+                engineType,
+                engineVersion: versions[engineType] ?? null,
+                extraArgsPairs: pairExtraArgs(conduitConfiguration.engineConfig?.extraArgs)
+            };
+        },
+        logger,
+        report: payload => apiClient.reportEngineExecution(payload),
+        sourceLabel: configuration.inferenceSourceID
+    });
+    // Intercept the prompt-metrics chokepoint so the first fully-responded, token-bearing prompt of
+    // each fresh startup files the one-shot engine_execution success report. Handlers close over the
+    // SAME `apiClient` object and read `reportPromptMetrics` at request-dispatch time (which always
+    // follows this point), so the wrapped method is what they invoke.
+    const rawReportPromptMetrics = apiClient.reportPromptMetrics;
+    apiClient.reportPromptMetrics = async (payload) => {
+        if (payload.successful && payload.completionTokens > 0 && payload.latencyMs > 0) {
+            // The one-shot report is kicked off and its settlement attached HERE (before any await): if the
+            // metrics path throws below, the report promise must still be able to log its own rejection.
+            const successReport = reporter
+                .reportSuccess({
+                durationMs: payload.latencyMs,
+                errorDetail: null,
+                errorType: null,
+                throughput: {
+                    avgTps: payload.tokensPerSecond,
+                    peakTps: null
+                },
+                ttftMs: payload.timeToFirstTokenMs ?? 0,
+                usage: {
+                    completionTokens: payload.completionTokens,
+                    promptTokens: payload.promptTokens,
+                    totalTokens: payload.totalTokens
+                }
+            })
+                .catch(error => {
+                logger.warn("Engine execution success report failed", {
+                    error: asError(error)
+                });
+            });
+            await rawReportPromptMetrics(payload);
+            await successReport;
+            return;
+        }
+        await rawReportPromptMetrics(payload);
+    };
+    const SECRET_ARG_MASK_PATTERN = /(-{1,2}[A-Za-z0-9_.]*(?:api[-_]?key|hf[-_]?token|token)(?:\s+|[=:]))\S+/gi;
+    // Assembles the payload shared by the startup-failure and runtime-crash report paths. Stderr
+    // may echo secrets, so mask `--api-key`/token-looking args before they reach the DB.
+    function buildCrashReport(error, exitCode, signal) {
+        const classification = classifyEngineFailure({ error, exitCode, signal });
+        const raw = normalizeEngineError(error.message);
+        const masked = raw.replace(SECRET_ARG_MASK_PATTERN, "$1***");
+        return {
+            durationMs: 0,
+            errorDetail: masked.slice(0, 2048),
+            errorType: classification,
+            ttftMs: 0,
+            throughput: {
+                avgTps: 0,
+                peakTps: null
+            },
+            usage: {
+                completionTokens: 0,
+                promptTokens: 0,
+                totalTokens: 0
+            }
+        };
+    }
     const conduitStateManager = new ConduitStateManager({
         initialState: {
             state: "initialising"
@@ -138453,6 +139046,17 @@ async function createApplication({ abortController, apiClient, configuration, lo
             });
             stopRequestedByControl = false;
             setErrorState({ error: normalizeEngineError(err.message) });
+            // Spontaneous death of a SERVING engine → crash report, suppressed by the latch if the
+            // startup's one-shot outcome was already filed. Startup-path failures report from
+            // `startEngine`'s catch; this listener is the RUNTIME-crash path only.
+            if (modelManager.wasRunning && !err.message.includes("interrupted by stop request")) {
+                const crashReport = buildCrashReport(err, modelManager.lastExitCode, modelManager.lastExitSignal);
+                reporter.reportRuntimeCrash(crashReport).catch(crashReportError => {
+                    logger.warn("Engine execution crash report failed", {
+                        error: asError(crashReportError)
+                    });
+                });
+            }
         });
         modelManager.on("engineReady", () => {
             setOnlineState();
@@ -138512,24 +139116,40 @@ async function createApplication({ abortController, apiClient, configuration, lo
     };
     async function startEngine() {
         logger.info("Engine start requested");
-        conduitStateManager.setState({
-            modelFileName,
-            modelName,
-            state: "downloadingModelFiles",
-            totalProgress: {
-                file: 0,
-                total: 0
+        reporter.beginStartup(new Date());
+        try {
+            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();
+            await modelManager.start();
+        }
+        catch (error) {
+            const parsedError = asError(error);
+            // Operator-initiated aborts are not startup failures worth reporting.
+            if (!parsedError.message.includes("interrupted by stop request")) {
+                const startupReport = buildCrashReport(parsedError, modelManager.lastExitCode, modelManager.lastExitSignal);
+                reporter.reportStartupFailure(startupReport).catch(startupReportError => {
+                    logger.warn("Engine execution startup report failed", {
+                        error: asError(startupReportError)
+                    });
+                });
             }
-        });
-        await conduitStateReportManager.reportNow();
-        await modelManager.prepare({
-            onDownloadProgress: reportDownloadProgress
-        });
-        conduitStateManager.setState({
-            state: "bootingEngine"
-        });
-        await conduitStateReportManager.reportNow();
-        await modelManager.start();
+            throw error;
+        }
     }
     async function stopEngine({ reason }) {
         if (!modelManager.canStop) {
@@ -138785,7 +139405,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",
@@ -138796,7 +139420,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;