@infersec/conduit 1.112.1 → 1.114.0

package/dist/commands/engineOptions.d.ts

@@ -2,6 +2,7 @@ import type { CreateEngineBody, UpdateEngineBody } from "../managementClient/ind
 import type { ManagementCommandOptions } from "./managementOptions.js";
 export interface EngineCreateCommandOptions extends ManagementCommandOptions {
     arg?: string[];
+    baseUrl?: string;
     type?: string;
 }
 export declare function buildEngineCreateBody(options: EngineCreateCommandOptions): CreateEngineBody;

package/dist/modelManagement/ModelManager.d.ts

@@ -18,12 +18,16 @@ export declare class ModelManager extends EventEmitter<ModelManagerEvents> {
     private uniqueName;
     readonly contextLength: number | null;
     protected readonly logger: Logger;
+    private discoveredModelNames;
     private engineProcess;
     private healthPollInterval;
     private lastEngineError;
     private lifecycleState;
     private downloadLockHandle;
     private stopRequested;
+    private lastEngineExitCode;
+    private lastEngineExitSignal;
+    private reachedRunningState;
     protected readonly modelsDirectory: string;
     constructor({ contextLength, engineConfig, enginePort, engineType, logger, model, root }: {
         contextLength?: number | null;
@@ -43,8 +47,14 @@ export declare class ModelManager extends EventEmitter<ModelManagerEvents> {
     stop(): Promise<void>;
     get canStart(): boolean;
     get canStop(): boolean;
+    get lastExitCode(): number | null;
+    get lastExitSignal(): NodeJS.Signals | null;
     get state(): EngineLifecycleState;
+    get resolvedServedModelName(): string | null;
+    get wasRunning(): boolean;
+    private get customBaseURL();
     private checkEngineReadiness;
+    private checkCustomReadiness;
     private checkGenericHealthReadiness;
     private checkLlamacppReadiness;
     private checkVLLMReadiness;
@@ -54,6 +64,7 @@ export declare class ModelManager extends EventEmitter<ModelManagerEvents> {
     private get lockFilePath();
     private acquireDownloadLock;
     private recordEngineError;
+    private requireCustomBaseURL;
     private releaseDownloadLock;
     private bindEngineProcessEvents;
     private startEngineProcess;

package/dist/modelManagement/classifyEngineError.d.ts

@@ -0,0 +1,12 @@
+import { EngineExecutionErrorType } from "@infersec/definitions";
+/**
+ * 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".
+ */
+export declare function classifyEngineFailure({ error, exitCode, signal }: {
+    error: Error;
+    exitCode: number | null;
+    signal?: NodeJS.Signals | null;
+}): EngineExecutionErrorType;

package/dist/reporting/engineExecutionReporter.d.ts

@@ -0,0 +1,55 @@
+import { EngineExecutionErrorType, EngineExecutionReportPayload, LLMEngine } from "@infersec/definitions";
+import { Logger } from "@infersec/logger";
+export interface EngineExecutionReportSource {
+    durationMs: number;
+    errorDetail: string | null;
+    errorType: EngineExecutionErrorType | null;
+    ttftMs: number;
+    throughput: {
+        avgTps: number;
+        peakTps: number | null;
+    };
+    usage: {
+        completionTokens: number;
+        promptTokens: number;
+        totalTokens: number;
+    };
+}
+/**
+ * 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.
+ */
+export declare function pairExtraArgs(tokens: unknown): Array<[string, string]>;
+/**
+ * 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.
+ */
+export declare class EngineExecutionReporter {
+    private readonly options;
+    private currentStartupAt;
+    private reportedForCurrentStartup;
+    constructor(options: {
+        buildContext: () => {
+            engineType: LLMEngine;
+            engineVersion: string | null;
+            extraArgsPairs: Array<[string, string]>;
+        };
+        logger: Logger;
+        report: (payload: EngineExecutionReportPayload) => Promise<void>;
+        sourceLabel: string;
+    });
+    /** Re-arms the latch; the stamp becomes the row's `run_at` (moment startup began). */
+    beginStartup(runAt: Date): void;
+    /** Reports a startup failure (rejected prepare/start, readiness timeout, pre-ready death). */
+    reportStartupFailure(report: EngineExecutionReportSource): Promise<void>;
+    /** Reports a spontaneous crash of an engine that had reached the running state. */
+    reportRuntimeCrash(report: EngineExecutionReportSource): Promise<void>;
+    /** Reports the first fully-responded, token-bearing prompt completion since startup. */
+    reportSuccess(report: EngineExecutionReportSource): Promise<void>;
+    private file;
+}

package/dist/reporting/index.d.ts

@@ -0,0 +1 @@
+export { EngineExecutionReporter, type EngineExecutionReportSource, pairExtraArgs } from "./engineExecutionReporter.js";

package/dist/requestHandlers/createConduitAnthropicAPIReferenceHandlers.d.ts

@@ -86,7 +86,7 @@ export declare function createPostMessagesHandler(options: {
             budget_tokens: number;
             type: "enabled";
         } | undefined;
-        tool_choice?: "none" | "any" | "auto" | {
+        tool_choice?: "any" | "none" | "auto" | {
             type: "auto";
             disable_parallel_tool_use?: boolean | undefined;
         } | {

package/dist/utils/engineMetrics.d.ts

@@ -27,6 +27,7 @@ interface MonitorEngineResponseOptions extends EngineMetricsLoggerOptions {
     engineType: string;
     onComplete?: (result: EngineMetricsCompletion) => void | Promise<void>;
     requestStartedAt?: number;
+    responseModelName?: string | null;
 }
 interface EngineMetricsLogOptions extends EngineMetricsLoggerOptions {
     error?: Error;
@@ -37,7 +38,7 @@ interface EngineMetricsLogOptions extends EngineMetricsLoggerOptions {
 interface MonitorEngineResponseResult {
     stream: Readable;
 }
-export declare function monitorEngineResponseStream({ agentEngineType, body, contextLength, engineConfig, engineType, logger, onComplete, requestBodyBytes, requestPath, requestStartedAt }: MonitorEngineResponseOptions): MonitorEngineResponseResult;
-export declare function monitorEngineResponseSingle({ agentEngineType, body, contextLength, engineConfig, engineType, logger, onComplete, requestBodyBytes, requestPath, requestStartedAt }: MonitorEngineResponseOptions): MonitorEngineResponseResult;
+export declare function monitorEngineResponseStream({ agentEngineType, body, contextLength, engineConfig, engineType, logger, onComplete, requestBodyBytes, requestPath, requestStartedAt, responseModelName }: MonitorEngineResponseOptions): MonitorEngineResponseResult;
+export declare function monitorEngineResponseSingle({ agentEngineType, body, contextLength, engineConfig, engineType, logger, onComplete, requestBodyBytes, requestPath, requestStartedAt, responseModelName }: MonitorEngineResponseOptions): MonitorEngineResponseResult;
 export declare function logEngineMetrics({ agentEngineType, error, level, logger, requestBodyBytes, requestPath, responseBytes, usage }: EngineMetricsLogOptions): void;
 export {};

package/dist/utils/openai.d.ts

@@ -19,6 +19,14 @@ export declare function applyChatTemplateKwargs({ body, model }: {
     body: PlainObject;
     model: LLMModel;
 }): PlainObject;
+export declare function serializeRequestBody(body: unknown, { model, path, servedModelName }?: {
+    model?: LLMModel;
+    path?: string;
+    servedModelName?: string | null;
+}): {
+    bytes: number;
+    payload: string;
+};
 export declare function proxyEmbeddingsRoute({ body, conduitConfiguration, endpointId, logger, modelID, modelManager, reportMetrics, signal }: {
     body: unknown;
     conduitConfiguration: InferenceAgentConfiguration;

package/package.json

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