@infersec/conduit 1.25.2 → 1.26.1

package/README.md

@@ -10,14 +10,15 @@ npx @infersec/conduit --engine <type> --key <api-key> --source <source-id>
 
 ### Flags
 
-| Flag        | Required | Default                        | Notes                                      |
-| ----------- | -------- | ------------------------------ | ------------------------------------------ |
-| `--engine`  | Yes      | -                              | Engine type (matches `ENGINE`).            |
-| `--key`     | Yes      | -                              | API key (matches `API_KEY`).               |
-| `--source`  | Yes      | -                              | Inference source ID (matches `SOURCE`).    |
-| `--api-url` | No       | `https://api.infersec.ai`      | API base URL (matches `API_URL`).          |
-| `--port`    | No       | `9505`                         | Port to listen on (matches `PORT`).        |
-| `--root`    | No       | `$HOME/.cache/infersec/iagent` | Root directory (matches `ROOT_DIRECTORY`). |
+| Flag           | Required | Default                        | Notes                                                                                  |
+| -------------- | -------- | ------------------------------ | -------------------------------------------------------------------------------------- |
+| `--engine`     | Yes      | -                              | Engine type (matches `ENGINE`).                                                        |
+| `--key`        | Yes      | -                              | API key (matches `API_KEY`).                                                           |
+| `--source`     | Yes      | -                              | Inference source ID (matches `SOURCE`).                                                |
+| `--api-url`    | No       | `https://api.infersec.ai`      | API base URL (matches `API_URL`).                                                      |
+| `--port`       | No       | `9505`                         | Port to listen on (matches `PORT`).                                                    |
+| `--root`       | No       | `$HOME/.cache/infersec/iagent` | Root directory (matches `ROOT_DIRECTORY`).                                             |
+| `--start-mode` | No       | `auto`                         | Startup mode (matches `START_MODE`): `auto` starts engine, `idle` leaves conduit idle. |
 
 ### Examples
 
@@ -36,5 +37,6 @@ npx @infersec/conduit --engine <type> --key <api-key> --source <source-id>
 | `API_URL`        | No       | `https://api.infersec.ai`      | API base URL (matches `--api-url`).       |
 | `PORT`           | No       | `9505`                         | Port to listen on (matches `--port`).     |
 | `ROOT_DIRECTORY` | No       | `$HOME/.cache/infersec/iagent` | Root directory (matches `--root`).        |
+| `START_MODE`     | No       | `auto`                         | Startup mode (matches `--start-mode`).    |
 
 CLI flags override environment variables when both are provided.

package/dist/application.d.ts

@@ -7,4 +7,7 @@ export declare function createApplication({ abortController, apiClient, configur
     apiClient: APIClient;
     configuration: Configuration;
     logger: Logger;
-}): Promise<Application>;
+}): Promise<{
+    app: Application;
+    shutdown: () => Promise<void>;
+}>;

package/dist/cli.js

@@ -6,7 +6,7 @@ const __dirname = __pathDirname(__filename);
 
 import { parseArgs } from 'node:util';
 import 'node:crypto';
-import { a as asError, s as startInferenceAgent } from './start-BJ-o7I20.js';
+import { a as asError, s as startInferenceAgent } from './start-PzV0cQI5.js';
 import 'argon2';
 import 'node:child_process';
 import 'node:stream';
@@ -68,6 +68,7 @@ Options:
   --key <value>           API key (or API_KEY)
   --port <number>         Port to listen on (or PORT)
   --root <path>           Root directory (or ROOT_DIRECTORY)
+  --start-mode <mode>     Startup mode: auto|idle (or START_MODE)
   --source <id>           Inference source ID (or SOURCE)
   -h, --help          Show this help message
 `;
@@ -94,6 +95,9 @@ async function run() {
             root: {
                 type: "string"
             },
+            "start-mode": {
+                type: "string"
+            },
             source: {
                 type: "string"
             }
@@ -119,6 +123,9 @@ async function run() {
     if (values.root) {
         configurationOverrides.rootDirectory = values.root;
     }
+    if (values["start-mode"]) {
+        configurationOverrides.startMode = values["start-mode"];
+    }
     if (values.port) {
         const port = Number.parseInt(values.port, 10);
         if (Number.isNaN(port)) {

package/dist/configuration.d.ts

@@ -1,4 +1,10 @@
 import { LLMEngine, ULID } from "@infersec/definitions";
+import { z } from "zod";
+declare const StartModeSchema: z.ZodEnum<{
+    idle: "idle";
+    auto: "auto";
+}>;
+export type StartMode = z.infer<typeof StartModeSchema>;
 export interface Configuration {
     agentEngineType: LLMEngine;
     apiKey: string;
@@ -6,6 +12,7 @@ export interface Configuration {
     inferenceSourceID: ULID;
     port: number;
     rootDirectory: string;
+    startMode: StartMode;
 }
 export interface ConfigurationOverrides {
     agentEngineType?: string;
@@ -14,7 +21,9 @@ export interface ConfigurationOverrides {
     inferenceSourceID?: ULID;
     port?: number;
     rootDirectory?: string;
+    startMode?: string;
 }
 export declare function getConfiguration({ overrides }?: {
     overrides?: ConfigurationOverrides;
 }): Configuration;
+export {};

package/dist/index.js

@@ -5,7 +5,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 
 import 'node:crypto';
-import { s as startInferenceAgent, a as asError } from './start-BJ-o7I20.js';
+import { s as startInferenceAgent, a as asError } from './start-PzV0cQI5.js';
 import 'argon2';
 import 'node:child_process';
 import 'node:stream';

package/dist/modelManagement/ModelManager.d.ts

@@ -8,6 +8,7 @@ interface ModelManagerEvents {
     engineReady: () => void;
     engineTerminated: () => void;
 }
+type EngineLifecycleState = "errored" | "running" | "starting" | "stopped" | "stopping";
 export declare class ModelManager extends EventEmitter<ModelManagerEvents> {
     readonly engine: LLMEngine;
     readonly model: LLMModel;
@@ -16,6 +17,8 @@ export declare class ModelManager extends EventEmitter<ModelManagerEvents> {
     readonly contextLength: number | null;
     protected readonly logger: Logger;
     private engineProcess;
+    private lifecycleState;
+    private stopRequested;
     protected readonly modelsDirectory: string;
     constructor({ contextLength, engine, logger, model, parallelism, root }: {
         contextLength?: number | null;
@@ -30,7 +33,13 @@ export declare class ModelManager extends EventEmitter<ModelManagerEvents> {
         onDownloadProgress?: (update: ModelDownloadProgressUpdate) => void;
     }): Promise<void>;
     start(): Promise<void>;
+    stop(): Promise<void>;
+    get canStart(): boolean;
+    get canStop(): boolean;
+    get state(): EngineLifecycleState;
     private isEngineReady;
     private waitForEngineReady;
+    private bindEngineProcessEvents;
+    private startEngineProcess;
 }
 export {};

package/dist/{start-BJ-o7I20.js → start-PzV0cQI5.js}

@@ -14797,6 +14797,9 @@ const ConduitStateSchema = z
     z.object({
         state: z.literal("bootingEngine")
     }),
+    z.object({
+        state: z.literal("stoppingEngine")
+    }),
     z.object({
         state: z.literal("offline")
     }),
@@ -14897,6 +14900,38 @@ const API_SERVICE_CONDUIT_API_REFERENCE = {
             }
         }
     },
+    "/conduit/api/v1/source/:sourceID/engine/start": {
+        POST: {
+            auth: {
+                type: "api-key"
+            },
+            parameters: {
+                sourceID: ULIDSchema
+            },
+            response: {
+                schema: object({
+                    acknowledged: literal(true)
+                }),
+                type: "rest"
+            }
+        }
+    },
+    "/conduit/api/v1/source/:sourceID/engine/stop": {
+        POST: {
+            auth: {
+                type: "api-key"
+            },
+            parameters: {
+                sourceID: ULIDSchema
+            },
+            response: {
+                schema: object({
+                    acknowledged: literal(true)
+                }),
+                type: "rest"
+            }
+        }
+    },
     "/conduit/api/v1/source/:sourceID/requests/:requestID/chunk": {
         POST: {
             auth: {
@@ -15176,7 +15211,35 @@ const CompletionCreateParamsSchema = object({
     user: string$1().optional()
 });
 
-const API_CLIENT_INFERENCE_AGENT_API_REFERENCE = {
+const API_CLIENT_CONDUIT_GENERAL_REFERENCE = {
+    "/conduit/engine/start": {
+        POST: {
+            auth: {
+                type: "none"
+            },
+            response: {
+                schema: object({
+                    acknowledged: literal(true)
+                }),
+                type: "rest"
+            }
+        }
+    },
+    "/conduit/engine/stop": {
+        POST: {
+            auth: {
+                type: "none"
+            },
+            response: {
+                schema: object({
+                    acknowledged: literal(true)
+                }),
+                type: "rest"
+            }
+        }
+    }
+};
+const API_CLIENT_CONDUIT_OPENAI_REFERENCE = {
     "/v1/chat/completions": {
         POST: {
             auth: {
@@ -98567,26 +98630,6 @@ async function startVLLM({ targetDirectory }) {
             "1"
         ]
     });
-    processManager.on("error", err => {
-        this.emit("engineError", new ProcessExecutionError({
-            code: null,
-            error: err,
-            message: `Process error: ${VLLM_EXECUTABLE}: ${processManager.stderr}`,
-            signal: null
-        }));
-    });
-    processManager.on("stopped", (code, signal) => {
-        if (code === 0) {
-            this.emit("engineTerminated");
-        }
-        else {
-            this.emit("engineError", new ProcessExecutionError({
-                code,
-                message: `Process stopped: ${VLLM_EXECUTABLE}: ${processManager.stderr}`,
-                signal
-            }));
-        }
-    });
     await processManager.start();
     return processManager;
 }
@@ -108137,26 +108180,6 @@ async function startLlamacpp({ targetDirectory }) {
         command: LLAMACPP_EXECUTABLE,
         args
     });
-    processManager.on("error", err => {
-        this.emit("engineError", new ProcessExecutionError({
-            code: null,
-            error: err,
-            message: `Process error: ${LLAMACPP_EXECUTABLE}: ${processManager.stderr}`,
-            signal: null
-        }));
-    });
-    processManager.on("stopped", (code, signal) => {
-        if (code === 0) {
-            this.emit("engineTerminated");
-        }
-        else {
-            this.emit("engineError", new ProcessExecutionError({
-                code,
-                message: `Process stopped: ${LLAMACPP_EXECUTABLE}: ${processManager.stderr}`,
-                signal
-            }));
-        }
-    });
     await processManager.start();
     return processManager;
 }
@@ -108169,6 +108192,8 @@ class ModelManager extends EventEmitter {
     contextLength;
     logger;
     engineProcess = null;
+    lifecycleState = "stopped";
+    stopRequested = false;
     modelsDirectory;
     constructor({ contextLength, engine, logger, model, parallelism, root }) {
         super();
@@ -108257,57 +108282,66 @@ class ModelManager extends EventEmitter {
         }
     }
     async start() {
-        if (this.engineProcess) {
+        if (this.lifecycleState !== "stopped") {
             throw new UnknownError({
-                message: "Cannot start LLM engine: engine process already running"
+                message: `Cannot start LLM engine: Invalid state: ${this.lifecycleState}`
             });
         }
+        this.lifecycleState = "starting";
+        this.stopRequested = false;
         this.logger.info("Starting LLM engine", {
             agentEngineType: this.engine
         });
-        switch (this.engine) {
-            case "llama.cpp":
-                this.engineProcess = await startLlamacpp.call(this, {
-                    targetDirectory: join(this.modelsDirectory, this.uniqueName)
-                });
-                break;
-            case "vllm":
-                this.engineProcess = await startVLLM.call(this, {
-                    targetDirectory: join(this.modelsDirectory, this.uniqueName)
-                });
-                break;
-            // case "ollama":
-            //     this.engineProcess = await startOllama.call(this);
-            //     this.logger.info("Started LLM engine", {
-            //         agentEngineType: this.engine
-            //     });
-            //     return;
-            default: {
-                const engineType = this.engine;
-                throw new ConfigurationInvalidError({
-                    message: `Cannot load local model: Invalid or unsupported engine: ${engineType}`
-                });
-            }
-        }
-        this.engineProcess.on("stderr", line => {
-            console.error(`[${this.engine}]: ${line}`);
-        });
-        this.engineProcess.on("stdout", line => {
-            console.log(`[${this.engine}]: ${line}`);
-        });
-        this.logger.info("Started LLM engine", {
-            agentEngineType: this.engine
-        });
         try {
+            this.engineProcess = await this.startEngineProcess();
+            this.bindEngineProcessEvents(this.engineProcess);
+            this.logger.info("Started LLM engine", {
+                agentEngineType: this.engine
+            });
             await this.waitForEngineReady();
         }
         catch (error) {
             const err = error instanceof Error ? error : new Error(String(error));
+            if (this.stopRequested) {
+                throw err;
+            }
+            this.lifecycleState = "errored";
             this.emit("engineError", err);
             throw err;
         }
+        this.lifecycleState = "running";
         this.emit("engineReady");
     }
+    async stop() {
+        if (this.lifecycleState === "stopping") {
+            throw new UnknownError({
+                message: "Cannot stop LLM engine: already stopping"
+            });
+        }
+        if (this.lifecycleState !== "running" && this.lifecycleState !== "starting") {
+            throw new UnknownError({
+                message: `Cannot stop LLM engine: Invalid state: ${this.lifecycleState}`
+            });
+        }
+        const processManager = this.engineProcess;
+        if (!processManager) {
+            throw new UnknownError({
+                message: "Cannot stop LLM engine: engine process not running"
+            });
+        }
+        this.lifecycleState = "stopping";
+        this.stopRequested = true;
+        await processManager.stop();
+    }
+    get canStart() {
+        return this.lifecycleState === "stopped";
+    }
+    get canStop() {
+        return this.lifecycleState === "running" || this.lifecycleState === "starting";
+    }
+    get state() {
+        return this.lifecycleState;
+    }
     async isEngineReady() {
         switch (this.engine) {
             case "llama.cpp":
@@ -108332,6 +108366,12 @@ class ModelManager extends EventEmitter {
         const pollIntervalMs = 2000;
         const start = Date.now();
         while (Date.now() - start < maxWaitMs) {
+            if (this.lifecycleState === "stopping") {
+                throw new Error("LLM engine startup interrupted by stop request");
+            }
+            if (!this.engineProcess) {
+                throw new Error("LLM engine process exited before readiness checks completed");
+            }
             const ready = await this.isEngineReady();
             if (ready) {
                 return;
@@ -108340,6 +108380,78 @@ class ModelManager extends EventEmitter {
         }
         throw new Error("LLM engine failed readiness checks within timeout");
     }
+    bindEngineProcessEvents(processManager) {
+        let hasTerminated = false;
+        processManager.on("stderr", line => {
+            console.error(`[${this.engine}]: ${line}`);
+        });
+        processManager.on("stdout", line => {
+            console.log(`[${this.engine}]: ${line}`);
+        });
+        processManager.on("error", err => {
+            if (hasTerminated) {
+                return;
+            }
+            hasTerminated = true;
+            if (this.stopRequested) {
+                this.engineProcess = null;
+                this.lifecycleState = "stopped";
+                this.stopRequested = false;
+                this.emit("engineTerminated");
+                return;
+            }
+            this.engineProcess = null;
+            this.lifecycleState = "errored";
+            this.emit("engineError", new ProcessExecutionError({
+                code: null,
+                error: err,
+                message: `Process error: ${this.engine}: ${processManager.stderr}`,
+                signal: null
+            }));
+        });
+        processManager.on("stopped", (code, signal) => {
+            if (hasTerminated) {
+                return;
+            }
+            hasTerminated = true;
+            this.engineProcess = null;
+            if (this.stopRequested) {
+                this.lifecycleState = "stopped";
+                this.stopRequested = false;
+                this.emit("engineTerminated");
+                return;
+            }
+            if (code === 0) {
+                this.lifecycleState = "stopped";
+                this.emit("engineTerminated");
+                return;
+            }
+            this.lifecycleState = "errored";
+            this.emit("engineError", new ProcessExecutionError({
+                code,
+                message: `Process stopped: ${this.engine}: ${processManager.stderr}`,
+                signal
+            }));
+        });
+    }
+    async startEngineProcess() {
+        switch (this.engine) {
+            case "llama.cpp":
+                return startLlamacpp.call(this, {
+                    targetDirectory: join(this.modelsDirectory, this.uniqueName)
+                });
+            case "vllm":
+                return startVLLM.call(this, {
+                    targetDirectory: join(this.modelsDirectory, this.uniqueName)
+                });
+            default: {
+                const engineType = this.engine;
+                throw new ConfigurationInvalidError({
+                    message: `Cannot load local model: Invalid or unsupported engine: ${engineType}`
+                });
+            }
+        }
+    }
 }
 
 function sleep(ms) {
@@ -108774,6 +108886,13 @@ class ConduitStateReportManager {
     reportDownloadProgress() {
         this.scheduleConduitStateReport();
     }
+    async reportNow() {
+        if (this.pendingConduitStateReport) {
+            clearTimeout(this.pendingConduitStateReport);
+            this.pendingConduitStateReport = null;
+        }
+        await this.triggerConduitStateReport();
+    }
     reportStateChange() {
         if (this.pendingConduitStateReport) {
             clearTimeout(this.pendingConduitStateReport);
@@ -118681,15 +118800,6 @@ async function createApplication({ abortController, apiClient, configuration, lo
         parallelism: conduitConfiguration.parallelism ?? null,
         root: configuration.rootDirectory
     });
-    conduitStateManager.setState({
-        modelFileName,
-        modelName,
-        state: "downloadingModelFiles",
-        totalProgress: {
-            file: 0,
-            total: 0
-        }
-    });
     const conduitStateReportManager = new ConduitStateReportManager({
         apiClient,
         conduitStateManager,
@@ -118698,6 +118808,30 @@ async function createApplication({ abortController, apiClient, configuration, lo
         stateIntervalMs: 30000
     });
     await conduitStateReportManager.start();
+    const setIdleState = ({ reason }) => {
+        conduitStateManager.setState({
+            reason,
+            state: "idle"
+        });
+        conduitStateReportManager.reportStateChange();
+    };
+    const setOnlineState = () => {
+        if (conduitStateManager.getState().state === "online") {
+            return;
+        }
+        conduitStateManager.setState({
+            modelName,
+            state: "online"
+        });
+        conduitStateReportManager.reportStateChange();
+    };
+    const setErrorState = ({ error }) => {
+        conduitStateManager.setState({
+            error,
+            state: "error"
+        });
+        conduitStateReportManager.reportStateChange();
+    };
     let lastDownloadKey = "";
     const reportDownloadProgress = (update) => {
         const filePercent = update.file.total > 0 ? Math.floor((update.file.bytes / update.file.total) * 100) : 0;
@@ -118721,14 +118855,75 @@ async function createApplication({ abortController, apiClient, configuration, lo
         });
         conduitStateReportManager.reportDownloadProgress();
     };
-    await modelManager.prepare({
-        onDownloadProgress: reportDownloadProgress
+    let stopRequestedByControl = false;
+    async function startEngine() {
+        logger.info("Engine start requested");
+        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();
+    }
+    async function stopEngine({ reason }) {
+        if (!modelManager.canStop) {
+            throw new Error("Engine is not in a stoppable state");
+        }
+        stopRequestedByControl = true;
+        conduitStateManager.setState({
+            state: "stoppingEngine"
+        });
+        await conduitStateReportManager.reportNow();
+        logger.info("Stopping engine process");
+        await modelManager.stop();
+        logger.info("Engine process stopped");
+        setIdleState({ reason });
+    }
+    modelManager.on("engineError", err => {
+        logger.error("LLM engine error", {
+            error: err
+        });
+        stopRequestedByControl = false;
+        setErrorState({ error: err.message });
     });
-    conduitStateManager.setState({
-        state: "bootingEngine"
+    modelManager.on("engineTerminated", () => {
+        if (stopRequestedByControl) {
+            stopRequestedByControl = false;
+            setIdleState({ reason: "Remote shutdown requested" });
+            return;
+        }
+        conduitStateManager.setState({
+            state: "offline"
+        });
+        conduitStateReportManager.reportStateChange();
     });
-    conduitStateReportManager.reportStateChange();
-    await modelManager.start();
+    modelManager.on("engineReady", () => {
+        setOnlineState();
+    });
+    if (configuration.startMode === "idle") {
+        setIdleState({ reason: "Startup mode is idle" });
+    }
+    else {
+        await startEngine().catch(error => {
+            const parsedError = asError(error);
+            logger.error("Failed starting LLM engine", {
+                error: parsedError
+            });
+            setErrorState({ error: parsedError.message });
+        });
+    }
     // #region API routes
     const app = express();
     const publicRouter = createRouter();
@@ -118736,6 +118931,96 @@ async function createApplication({ abortController, apiClient, configuration, lo
     publicRouter.get("/health", (_req, res) => {
         res.status(200).send("OK");
     });
+    implementAPIReference({
+        api: {
+            "/conduit/engine/start": {
+                POST: async () => {
+                    if (conduitStateManager.getState().state !== "idle") {
+                        return {
+                            status: 409,
+                            statusText: "Engine can only be started from idle state"
+                        };
+                    }
+                    if (!modelManager.canStart) {
+                        return {
+                            status: 409,
+                            statusText: `Engine cannot be started from current state: ${modelManager.state}`
+                        };
+                    }
+                    try {
+                        logger.info("Received remote engine start request");
+                        await startEngine();
+                        return {
+                            body: {
+                                acknowledged: true
+                            },
+                            status: 202
+                        };
+                    }
+                    catch (error) {
+                        if (stopRequestedByControl || modelManager.state === "stopped") {
+                            return {
+                                status: 409,
+                                statusText: "Engine start was interrupted"
+                            };
+                        }
+                        const parsedError = asError(error);
+                        setErrorState({ error: parsedError.message });
+                        return {
+                            status: 500,
+                            statusText: parsedError.message
+                        };
+                    }
+                }
+            },
+            "/conduit/engine/stop": {
+                POST: async () => {
+                    const sourceState = conduitStateManager.getState().state;
+                    if (sourceState !== "bootingEngine" && sourceState !== "online") {
+                        return {
+                            status: 409,
+                            statusText: "Engine can only be stopped while booting or online"
+                        };
+                    }
+                    if (!modelManager.canStop) {
+                        return {
+                            status: 409,
+                            statusText: `Engine cannot be stopped from current state: ${modelManager.state}`
+                        };
+                    }
+                    try {
+                        logger.info("Received remote engine stop request");
+                        stopEngine({
+                            reason: "Remote shutdown requested"
+                        }).catch(error => {
+                            const parsedError = asError(error);
+                            logger.error("Remote engine stop request failed", {
+                                error: parsedError
+                            });
+                            setErrorState({ error: parsedError.message });
+                        });
+                        return {
+                            body: {
+                                acknowledged: true
+                            },
+                            status: 202
+                        };
+                    }
+                    catch (error) {
+                        const parsedError = asError(error);
+                        setErrorState({ error: parsedError.message });
+                        return {
+                            status: 500,
+                            statusText: parsedError.message
+                        };
+                    }
+                }
+            }
+        },
+        logger,
+        mount: publicRouter,
+        reference: API_CLIENT_CONDUIT_GENERAL_REFERENCE
+    });
     implementAPIReference({
         api: {
             "/v1/chat/completions": {
@@ -118793,39 +119078,7 @@ async function createApplication({ abortController, apiClient, configuration, lo
         },
         logger,
         mount: publicRouter,
-        reference: API_CLIENT_INFERENCE_AGENT_API_REFERENCE
-    });
-    let activeRequests = 0;
-    const setOnlineState = () => {
-        if (conduitStateManager.getState().state === "online") {
-            return;
-        }
-        conduitStateManager.setState({
-            modelName,
-            state: "online"
-        });
-        conduitStateReportManager.reportStateChange();
-    };
-    modelManager.on("engineError", err => {
-        logger.error("LLM engine error", {
-            error: err
-        });
-        conduitStateManager.setState({
-            error: err.message,
-            state: "error"
-        });
-        conduitStateReportManager.reportStateChange();
-        abortController.abort(err);
-    });
-    modelManager.on("engineTerminated", () => {
-        conduitStateManager.setState({
-            state: "offline"
-        });
-        conduitStateReportManager.reportStateChange();
-        abortController.abort();
-    });
-    modelManager.on("engineReady", () => {
-        setOnlineState();
+        reference: API_CLIENT_CONDUIT_OPENAI_REFERENCE
     });
     handleSSERequests({
         apiURL: configuration.apiURL,
@@ -118839,16 +119092,10 @@ async function createApplication({ abortController, apiClient, configuration, lo
             });
         },
         onRequestEnd: () => {
-            activeRequests = Math.max(0, activeRequests - 1);
-            if (activeRequests === 0) {
-                setOnlineState();
-            }
+            return;
         },
         onRequestStart: () => {
-            activeRequests += 1;
-            if (activeRequests === 1) {
-                setOnlineState();
-            }
+            return;
         },
         reportMetrics: apiClient.reportPromptMetrics,
         signal: abortController.signal
@@ -118857,7 +119104,55 @@ async function createApplication({ abortController, apiClient, configuration, lo
             error: asError(error)
         });
     });
-    return app;
+    let shutdownPromise = null;
+    async function shutdown() {
+        if (shutdownPromise) {
+            await shutdownPromise;
+            return;
+        }
+        shutdownPromise = (async () => {
+            logger.info("Conduit shutdown requested");
+            if (modelManager.canStop) {
+                conduitStateManager.setState({
+                    state: "stoppingEngine"
+                });
+                try {
+                    await conduitStateReportManager.reportNow();
+                }
+                catch (error) {
+                    logger.warn("Failed to report stopping conduit state", {
+                        error: asError(error)
+                    });
+                }
+                try {
+                    await modelManager.stop();
+                }
+                catch (error) {
+                    logger.warn("Failed to stop model process during shutdown", {
+                        error: asError(error)
+                    });
+                }
+            }
+            conduitStateManager.setState({
+                state: "offline"
+            });
+            try {
+                await conduitStateReportManager.reportNow();
+            }
+            catch (error) {
+                logger.warn("Failed to report offline conduit state", {
+                    error: asError(error)
+                });
+            }
+            conduitStateReportManager.stop();
+            abortController.abort();
+        })();
+        await shutdownPromise;
+    }
+    return {
+        app,
+        shutdown
+    };
     // #endregion
 }
 function getConduitModelFileName(configuration) {
@@ -118868,6 +119163,7 @@ function getConduitModelName(configuration) {
     return configuration.targetModel.id;
 }
 
+const StartModeSchema = _enum(["auto", "idle"]);
 function getConfiguration({ overrides } = {}) {
     const agentEngineTypeValue = overrides?.agentEngineType ?? readEnvString("ENGINE");
     const agentEngineType = LLMEngineSchema.parse(agentEngineTypeValue);
@@ -118881,13 +119177,16 @@ function getConfiguration({ overrides } = {}) {
     }
     const defaultRootDirectory = join(process.env.HOME ?? "/tmp", ".cache", "infersec", "iagent");
     const rootDirectory = overrides?.rootDirectory ?? readEnvStringOptional("ROOT_DIRECTORY", defaultRootDirectory);
+    const startModeValue = overrides?.startMode ?? readEnvStringOptional("START_MODE", "auto");
+    const startMode = StartModeSchema.parse(startModeValue);
     return {
         agentEngineType,
         apiKey,
         apiURL,
         inferenceSourceID,
         port,
-        rootDirectory
+        rootDirectory,
+        startMode
     };
 }
 
@@ -118906,15 +119205,20 @@ async function startInferenceAgent({ configurationOverrides }) {
         inferenceSourceID: configuration.inferenceSourceID
     });
     logger.info("Starting web server");
-    const app = await createApplication({ abortController, apiClient, configuration, logger });
+    const { app, shutdown } = await createApplication({
+        abortController,
+        apiClient,
+        configuration,
+        logger
+    });
     await new Promise(resolve => {
         app.listen(configuration.port, () => {
             logger.info("Server listening", { port: configuration.port });
             resolve();
         });
     });
-    process.on("SIGINT", createSignalShutdown({ logger }));
-    process.on("SIGTERM", createSignalShutdown({ logger }));
+    process.on("SIGINT", createSignalShutdown({ logger, shutdown }));
+    process.on("SIGTERM", createSignalShutdown({ logger, shutdown }));
     abortController.signal.addEventListener("abort", () => {
         if (abortController.signal.reason instanceof Error) {
             process.exit(1);
@@ -118922,13 +119226,18 @@ async function startInferenceAgent({ configurationOverrides }) {
         process.exit(0);
     });
 }
-function createSignalShutdown({ logger }) {
+function createSignalShutdown({ logger, shutdown }) {
+    let shutdownPromise = null;
     return (signal) => {
         Promise.resolve()
             .then(async () => {
             logger.info("Received shutdown signal", {
                 signal
             });
+            if (!shutdownPromise) {
+                shutdownPromise = shutdown();
+            }
+            await shutdownPromise;
             await sleep(500);
             process.exit(0);
         })

package/dist/state/ConduitStateReportManager.d.ts

@@ -21,6 +21,7 @@ export declare class ConduitStateReportManager {
     start(): Promise<void>;
     stop(): void;
     reportDownloadProgress(): void;
+    reportNow(): Promise<void>;
     reportStateChange(): void;
     private sendConduitState;
     private triggerConduitStateReport;

package/package.json

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