@agenthippo-ai/agenthippo 0.1.0

package/out/engines/custom.js

@@ -0,0 +1,632 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomEngine = void 0;
+exports.resolveCustomEngineLoadStrategy = resolveCustomEngineLoadStrategy;
+exports.probeCustomEngineImport = probeCustomEngineImport;
+const node_child_process_1 = require("node:child_process");
+const node_readline_1 = require("node:readline");
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const url_1 = require("url");
+const base_1 = require("./base");
+const customRegistry_1 = require("./customRegistry");
+const paths_1 = require("../agentpack/paths");
+const utils_1 = require("../utils");
+const resolveNodeBinary_1 = require("../utils/resolveNodeBinary");
+const customEngineIpc_1 = require("./customEngineIpc");
+const persistentEngineWorker_1 = require("./persistentEngineWorker");
+const session_1 = require("../session");
+const mcp_1 = require("../mcp");
+const ACTIVE_SESSION_IDLE_TTL_MS = 1000 * 60 * 30; // 30 minutes
+function resolveCustomEngineLoadStrategy() {
+    const raw = process.env.AGENTHIPPO_CUSTOM_ENGINE_LOAD?.trim().toLowerCase();
+    if (raw === 'a' || raw === 'in-process' || raw === 'inprocess') {
+        return 'in-process';
+    }
+    if (raw === 'c' || raw === 'node-subprocess' || raw === 'node' || raw === 'b' || raw === 'bun-subprocess' || raw === 'bun') {
+        return 'node-subprocess';
+    }
+    // Default (IDE + CLI): a persistent worker keeps the engine/SDK warm but isolated from the
+    // host process, so a poisoned SDK is fixed by recycling one child instead of reloading.
+    return 'persistent-worker';
+}
+function resolveRequestedEngineId(options) {
+    const fromRequest = options.engineId?.trim();
+    if (fromRequest && fromRequest !== 'claude' && fromRequest !== 'codex') {
+        return fromRequest;
+    }
+    return undefined;
+}
+function getConfiguredAdditionalEngineDir(runtime) {
+    return runtime.configProvider?.get('agentide', 'additionalEngineDir');
+}
+function prependNodePath(env, engineDir) {
+    const engineNodeModules = path.join(engineDir, 'node_modules');
+    const existing = env.NODE_PATH?.trim();
+    env.NODE_PATH = existing
+        ? `${engineNodeModules}${path.delimiter}${existing}`
+        : engineNodeModules;
+}
+function buildRunnerChildEnv(manifest, turn, probeImport) {
+    const childEnv = {
+        ...turn.env,
+        ...process.env,
+        AGENTHIPPO_ENGINE_ENTRY: manifest.entryPath,
+        AGENTHIPPO_MESSAGE: turn.message,
+        AGENTHIPPO_WORKSPACE_ROOT: turn.workspaceRoot,
+        AGENTHIPPO_MODEL_ID: turn.modelId,
+        AGENTHIPPO_CONVERSATION_KEY: turn.session.key,
+        AGENTHIPPO_IS_EPHEMERAL: turn.session.isEphemeral ? 'true' : 'false',
+    };
+    if (probeImport) {
+        childEnv.AGENTHIPPO_CUSTOM_ENGINE_PROBE = 'import';
+    }
+    if (turn.session.nativeSessionId?.trim()) {
+        childEnv.AGENTHIPPO_NATIVE_SESSION_ID = turn.session.nativeSessionId.trim();
+    }
+    if (manifest.engineExport) {
+        childEnv.AGENTHIPPO_ENGINE_EXPORT = manifest.engineExport;
+    }
+    const mcpJson = turn.mcpServers ? (0, mcp_1.serializeInlineMcpServers)(turn.mcpServers) : undefined;
+    if (mcpJson) {
+        childEnv[mcp_1.AGENTHIPPO_MCP_SERVERS_ENV] = mcpJson;
+    }
+    prependNodePath(childEnv, manifest.manifestDir);
+    return childEnv;
+}
+async function runCustomEngineViaNodeSubprocess(manifest, turn, emitter, probeImport, signal) {
+    let runnerPath;
+    try {
+        const { ensureNodeRunnerScriptPath } = await import('./customEngineRunnerEmbed.js');
+        runnerPath = await ensureNodeRunnerScriptPath();
+    }
+    catch (err) {
+        throw new Error(`Custom engine Node runner not available: ${err instanceof Error ? err.message : String(err)}. Rebuild the agenthippo CLI.`);
+    }
+    const nodeBin = await (0, resolveNodeBinary_1.resolveNodeBinary)();
+    turn.runtime.logger.info(`[AgentIDE] Custom engine Node runner: ${nodeBin}`);
+    const childEnv = buildRunnerChildEnv(manifest, turn, probeImport);
+    if (process.platform === 'win32' && nodeBin === process.execPath && !nodeBin.toLowerCase().endsWith('\\node.exe')) {
+        childEnv.ELECTRON_RUN_AS_NODE = '1';
+    }
+    (0, resolveNodeBinary_1.prependPathDir)(childEnv, path.dirname(nodeBin));
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(nodeBin, [runnerPath], {
+            cwd: manifest.manifestDir,
+            env: childEnv,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stderr = '';
+        let nativeSessionId;
+        let lineChain = Promise.resolve();
+        const stdoutRl = (0, node_readline_1.createInterface)({ input: child.stdout });
+        stdoutRl.on('line', line => {
+            lineChain = lineChain.then(async () => {
+                const id = await (0, customEngineIpc_1.applyRunnerEvent)(emitter, line);
+                if (id) {
+                    nativeSessionId = id;
+                }
+            }).catch(err => {
+                stdoutRl.close();
+                child.kill();
+                reject(err);
+            });
+        });
+        child.stderr?.on('data', chunk => { stderr += String(chunk); });
+        const onAbort = () => {
+            child.kill('SIGTERM');
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+        child.on('error', reject);
+        child.on('close', code => {
+            signal?.removeEventListener('abort', onAbort);
+            stdoutRl.close();
+            void lineChain.finally(() => {
+                if (code === 0) {
+                    resolve(nativeSessionId ? { nativeSessionId } : undefined);
+                }
+                else {
+                    const detail = stderr.trim() || `Custom engine Node runner exited with code ${code}`;
+                    reject(new Error(detail));
+                }
+            });
+        });
+    });
+}
+/**
+ * Probe whether a strategy can import the engine entry (and @cursor/sdk deps).
+ */
+async function probeCustomEngineImport(manifest, strategy) {
+    try {
+        if (strategy === 'in-process') {
+            await loadEngineModule(manifest);
+            return { strategy, ok: true };
+        }
+        const noopEmitter = {
+            text: async () => { },
+            thinking: async () => { },
+            toolStart: async () => { },
+            toolEnd: async () => { },
+            progress: async () => { },
+            question: async () => ({ selected: [], freeText: null }),
+            error: async () => { },
+            done: async () => { },
+        };
+        const minimalTurn = {
+            message: '',
+            modelId: manifest.model?.defaultModel ?? 'auto',
+            workspaceRoot: manifest.searchRoot,
+            additionalDirectories: [],
+            permissions: { fileAccess: 'full' },
+            env: { ...process.env },
+            routing: { useLiteLLM: false },
+            session: {
+                key: 'probe',
+                chatSessionId: 'probe',
+                contextSessionId: 'probe',
+                isEphemeral: true,
+                engineHomeDir: manifest.manifestDir,
+                engineSessionDir: manifest.manifestDir,
+            },
+            agent: { id: 'probe' },
+            emitter: noopEmitter,
+            runtime: { logger: { info: () => { }, warn: () => { }, error: () => { }, debug: () => { } } },
+        };
+        await runCustomEngineViaNodeSubprocess(manifest, minimalTurn, noopEmitter, true);
+        return { strategy, ok: true };
+    }
+    catch (err) {
+        return {
+            strategy,
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+async function loadEngineModule(manifest) {
+    const { entryPath, id, engineExport } = manifest;
+    try {
+        await fs_1.promises.access(entryPath);
+    }
+    catch {
+        throw new Error(`Custom engine "${id}" entry not found: ${entryPath}`);
+    }
+    const previousCwd = process.cwd();
+    const previousNodePath = process.env.NODE_PATH;
+    try {
+        process.chdir(manifest.manifestDir);
+        prependNodePath(process.env, manifest.manifestDir);
+        const entryStat = await fs_1.promises.stat(entryPath).catch(() => undefined);
+        const moduleUrl = `${(0, url_1.pathToFileURL)(entryPath).href}?mtime=${entryStat?.mtimeMs ?? Date.now()}`;
+        const mod = await (new Function('u', 'return import(u)')(moduleUrl));
+        const exported = (engineExport ? (mod[engineExport] ?? mod.default?.[engineExport]) : undefined) ??
+            mod.default;
+        if (!exported) {
+            const exportDesc = engineExport ? `"${engineExport}"` : 'default export';
+            throw new Error(`Custom engine "${id}": ${exportDesc} not found in ${entryPath}. ` +
+                'Export a class or object with a run(turn) method.');
+        }
+        const instance = typeof exported === 'function'
+            ? new exported()
+            : exported;
+        validateEngineShape(id, instance);
+        return instance;
+    }
+    finally {
+        process.chdir(previousCwd);
+        if (previousNodePath === undefined) {
+            delete process.env.NODE_PATH;
+        }
+        else {
+            process.env.NODE_PATH = previousNodePath;
+        }
+    }
+}
+function validateEngineShape(id, instance) {
+    if (typeof instance !== 'object' ||
+        instance === null ||
+        typeof instance.run !== 'function') {
+        throw new Error(`Custom engine "${id}" export must be a class or object with a run(turn) method.`);
+    }
+}
+function safePathSegment(value) {
+    return value.replace(/[<>:"/\\|?*\x00-\x1F]/g, '_').slice(0, 160) || 'session';
+}
+function maybeRuntimeContextSuffix(turn) {
+    const lines = [];
+    if (turn.session.contextFilePath) {
+        lines.push(`context_file: ${path.relative(turn.workspaceRoot, turn.session.contextFilePath)}`);
+    }
+    if (turn.session.terminalLogPath) {
+        lines.push(`terminal_log: ${path.relative(turn.workspaceRoot, turn.session.terminalLogPath)}`);
+    }
+    if (turn.session.attachmentsDir) {
+        lines.push(`attachments_dir: ${path.relative(turn.workspaceRoot, turn.session.attachmentsDir)}`);
+    }
+    const outboundFile = turn.env.AGENTHIPPO_GATEWAY_OUTBOUND_FILE?.trim();
+    if (outboundFile) {
+        lines.push(`gateway_outbound_file: ${outboundFile}`);
+    }
+    const activeAgent = turn.env.AGENTHIPPO_ACTIVE_AGENT?.trim();
+    if (activeAgent) {
+        lines.push(`active_agent: ${activeAgent}`);
+    }
+    if (lines.length === 0) {
+        return '';
+    }
+    return [
+        '<agenthippo_runtime_context>',
+        ...lines,
+        '</agenthippo_runtime_context>',
+    ].join('\n');
+}
+const MTIME_CACHE_TTL_MS = 5_000;
+class CustomEngine {
+    config;
+    getBundledBasePromptsDir;
+    id = 'custom';
+    displayName = 'Custom Engine';
+    instances = new Map();
+    activeSessions = new Map();
+    mtimeCache = new Map();
+    workerPool = new persistentEngineWorker_1.PersistentEngineWorkerPool();
+    constructor(config, getBundledBasePromptsDir = () => undefined) {
+        this.config = config;
+        this.getBundledBasePromptsDir = getBundledBasePromptsDir;
+    }
+    async getCachedMtime(filePath) {
+        const now = Date.now();
+        const cached = this.mtimeCache.get(filePath);
+        if (cached && now - cached.fetchedAt < MTIME_CACHE_TTL_MS) {
+            return cached.mtime;
+        }
+        const mtime = (await fs_1.promises.stat(filePath).catch(() => undefined))?.mtimeMs ?? 0;
+        this.mtimeCache.set(filePath, { mtime, fetchedAt: now });
+        return mtime;
+    }
+    async buildCacheKey(manifest) {
+        const [manifestMtime, entryMtime] = await Promise.all([
+            this.getCachedMtime(manifest.manifestPath),
+            this.getCachedMtime(manifest.entryPath),
+        ]);
+        return [
+            manifest.id,
+            manifest.manifestPath,
+            manifestMtime,
+            manifest.entryPath,
+            entryMtime,
+        ].join('\0');
+    }
+    async stream(message, options, emitter, runtime, signal) {
+        const requestedId = resolveRequestedEngineId(options);
+        const manifest = (0, customRegistry_1.resolveCustomEngineManifest)(options.workspaceRoot, requestedId, getConfiguredAdditionalEngineDir(runtime), (mPath, err) => runtime.logger.warn(`[AgentIDE] Skipping malformed custom engine manifest ${mPath}: ${err instanceof Error ? err.message : String(err)}`));
+        const providerId = `custom:${manifest.id}`;
+        const convo = (0, session_1.buildConversationKey)(providerId, options);
+        await (0, session_1.withConversationLock)(convo.key, async () => {
+            const strategy = resolveCustomEngineLoadStrategy();
+            const turn = await this.buildTurn(manifest, message, options, emitter, runtime, convo.key, convo.chatSessionId, convo.isEphemeral, signal);
+            runtime.logger.info(`[AgentIDE] Custom engine "${manifest.id}" strategy=${strategy} entry=${manifest.entryPath}`);
+            let result;
+            if (strategy === 'in-process') {
+                const { engine } = await this.getOrLoadInstance(manifest, runtime);
+                const previousCwd = process.cwd();
+                const previousNodePath = process.env.NODE_PATH;
+                try {
+                    process.chdir(manifest.manifestDir);
+                    prependNodePath(process.env, manifest.manifestDir);
+                    result = await engine.run(turn);
+                }
+                finally {
+                    process.chdir(previousCwd);
+                    if (previousNodePath === undefined) {
+                        delete process.env.NODE_PATH;
+                    }
+                    else {
+                        process.env.NODE_PATH = previousNodePath;
+                    }
+                }
+            }
+            else if (strategy === 'persistent-worker') {
+                result = await this.runViaPersistentWorker(manifest, turn, emitter, signal);
+            }
+            else {
+                result = await runCustomEngineViaNodeSubprocess(manifest, turn, emitter, false, signal);
+            }
+            const returnedNativeSessionId = result?.nativeSessionId?.trim();
+            const nativeSessionId = returnedNativeSessionId || turn.session.nativeSessionId;
+            this.activeSessions.set(convo.key, {
+                nativeSessionId,
+                lastUsedAt: Date.now(),
+            });
+            if (returnedNativeSessionId) {
+                await (0, base_1.persistSessionIfNeeded)(providerId, convo, returnedNativeSessionId, options);
+            }
+            else {
+                (0, base_1.touchSessionIfNeeded)(convo);
+            }
+        }, {
+            signal,
+            timeoutMs: session_1.DEFAULT_CONVERSATION_LOCK_TIMEOUT_MS,
+            label: `custom.${manifest.id}.run`,
+        });
+    }
+    async getOrLoadInstance(manifest, runtime) {
+        const cacheKey = await this.buildCacheKey(manifest);
+        const existing = this.instances.get(cacheKey);
+        if (existing) {
+            return existing;
+        }
+        // Evict stale instances for the same engine id (file changed since last load)
+        for (const [key, inst] of this.instances.entries()) {
+            if (inst.manifest.id === manifest.id) {
+                try {
+                    inst.engine.dispose?.();
+                }
+                catch { /* best-effort */ }
+                this.instances.delete(key);
+            }
+        }
+        runtime.logger.info(`[AgentIDE] Loading custom engine "${manifest.id}" from ${manifest.entryPath}`);
+        const engine = await loadEngineModule(manifest);
+        const instance = { engine, manifest, cacheKey };
+        this.instances.set(cacheKey, instance);
+        return instance;
+    }
+    /** Run a turn on a long-lived per-engine worker child (default strategy). */
+    async runViaPersistentWorker(manifest, turn, emitter, signal) {
+        const { ensureNodeRunnerScriptPath } = await import('./customEngineRunnerEmbed.js');
+        const runnerPath = await ensureNodeRunnerScriptPath();
+        const nodeBin = await (0, resolveNodeBinary_1.resolveNodeBinary)();
+        turn.runtime.logger.info(`[AgentIDE] Custom engine persistent worker: ${nodeBin}`);
+        const runEnv = buildRunnerChildEnv(manifest, turn, false);
+        const spawnEnv = { ...runEnv, AGENTHIPPO_RUNNER_MODE: 'persistent' };
+        // If we spawn the Electron host executable as our "node" (Cursor.exe/Code.exe), ensure it
+        // behaves like Node in the child process.
+        if (process.platform === 'win32' && nodeBin === process.execPath && !nodeBin.toLowerCase().endsWith('\\node.exe')) {
+            spawnEnv.ELECTRON_RUN_AS_NODE = '1';
+        }
+        (0, resolveNodeBinary_1.prependPathDir)(spawnEnv, path.dirname(nodeBin));
+        const cacheKey = await this.buildCacheKey(manifest);
+        return this.workerPool.run({
+            cacheKey,
+            runnerPath,
+            nodeBin,
+            cwd: manifest.manifestDir,
+            spawnEnv,
+            logger: turn.runtime.logger,
+            label: `custom.${manifest.id}`,
+        }, runEnv, emitter, signal);
+    }
+    clearInstances(engineId) {
+        for (const [key, { engine, manifest }] of this.instances.entries()) {
+            if (engineId && manifest.id !== engineId) {
+                continue;
+            }
+            try {
+                engine.dispose?.();
+            }
+            catch { /* best-effort */ }
+            this.instances.delete(key);
+        }
+    }
+    async buildTurn(manifest, message, options, emitter, runtime, conversationKey, chatSessionId, isEphemeral, signal) {
+        const modelId = options.modelId?.trim() || manifest.model?.defaultModel?.trim();
+        if (!modelId) {
+            throw new Error(`Custom engine "${manifest.id}" requires a model selection. Add a "model.defaultModel" to the engine manifest or select a model explicitly.`);
+        }
+        const agentId = options.agentPackId ?? paths_1.AGENT_CONSTANTS.DEFAULT_AGENT_ID;
+        const contextSessionId = options.contextSessionId?.trim() || options.sessionId?.trim() || chatSessionId;
+        const sessionDirName = safePathSegment(contextSessionId);
+        const customBaseDir = this.config.customEnginesStoragePath
+            ?? path.join(this.config.storagePath, paths_1.AGENT_CONSTANTS.AGENTS_DIR, agentId, 'custom');
+        const engineBaseDir = path.join(customBaseDir, manifest.id);
+        const engineHomeDir = path.join(engineBaseDir, 'home');
+        const engineSessionDir = path.join(engineBaseDir, paths_1.AGENT_CONSTANTS.SESSIONS_DIR, sessionDirName);
+        await fs_1.promises.mkdir(engineHomeDir, { recursive: true });
+        await fs_1.promises.mkdir(engineSessionDir, { recursive: true });
+        const workspaceSessionDir = path.join(options.workspaceRoot, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, paths_1.AGENT_CONSTANTS.SESSIONS_DIR, contextSessionId);
+        const contextFilePath = path.join(workspaceSessionDir, paths_1.AGENT_CONSTANTS.CONTEXT_MD);
+        const terminalLogPath = path.join(workspaceSessionDir, 'terminal.md');
+        const attachmentsDir = path.join(workspaceSessionDir, 'attachments');
+        const nativeSessionId = this.activeSessions.get(conversationKey)?.nativeSessionId ??
+            (0, base_1.getPersistedSessionId)(`custom:${manifest.id}`, conversationKey);
+        const routing = (0, utils_1.resolveApiRouting)(options, this.config.litellmApiKey, this.config.litellmBaseUrl, runtime.configProvider);
+        const routingApiKey = routing.apiKey?.trim() || undefined;
+        const routingBaseUrl = routing.baseUrl?.trim() || undefined;
+        const routingOpenAIBaseUrl = routing.openaiBaseUrl?.trim() || undefined;
+        const rulesFilePath = manifest.workspaceSync?.enabled
+            ? path.join(options.workspaceRoot, manifest.workspaceSync.dir, manifest.workspaceSync.rulesFile)
+            : undefined;
+        const skillsDir = manifest.workspaceSync?.enabled && manifest.workspaceSync.includeSkills
+            ? path.join(options.workspaceRoot, manifest.workspaceSync.dir, paths_1.AGENT_CONSTANTS.SKILLS_DIR)
+            : undefined;
+        const rulesDir = manifest.workspaceSync?.enabled && manifest.workspaceSync.includeRules
+            ? path.join(options.workspaceRoot, manifest.workspaceSync.dir, paths_1.AGENT_CONSTANTS.RULES_DIR)
+            : undefined;
+        const env = {
+            ...process.env,
+            ...(runtime.cliEnvPatch ?? {}),
+            AGENTHIPPO_ENGINE_ID: manifest.id,
+            AGENTHIPPO_ENGINE_HOME: engineHomeDir,
+            AGENTHIPPO_ENGINE_SESSION_DIR: engineSessionDir,
+            AGENTHIPPO_CONTEXT_SESSION_ID: contextSessionId,
+            AGENTHIPPO_CONTEXT_EXPORT_PATH: contextFilePath,
+            AGENTHIPPO_TERMINAL_LOG_PATH: terminalLogPath,
+            AGENTHIPPO_ATTACHMENTS_DIR: attachmentsDir,
+            AGENTHIPPO_ACTIVE_AGENT: agentId,
+            AGENT_ID: agentId,
+            AGENTHIPPO_MODEL_ID: modelId,
+            AGENTHIPPO_USE_LITELLM: routing.useLiteLLM ? 'true' : 'false',
+        };
+        prependNodePath(env, manifest.manifestDir);
+        if (routingApiKey) {
+            env.AGENTHIPPO_API_KEY = routingApiKey;
+        }
+        if (routingBaseUrl) {
+            env.AGENTHIPPO_BASE_URL = routingBaseUrl;
+        }
+        if (routingOpenAIBaseUrl) {
+            env.AGENTHIPPO_OPENAI_BASE_URL = routingOpenAIBaseUrl;
+        }
+        if (routing.useLiteLLM) {
+            env.AGENTHIPPO_LITELLM_API_KEY = routingApiKey ?? 'sk-dummy';
+            env.AGENTIDE_LITELLM_API_KEY = routingApiKey ?? 'sk-dummy';
+            if (routingBaseUrl) {
+                env.AGENTHIPPO_LITELLM_BASE_URL = routingBaseUrl;
+                env.AGENTIDE_LITELLM_BASE_URL = routingBaseUrl;
+            }
+            const litellmMetadataHeaders = (0, base_1.buildLiteLLMMetadataHeaders)(true, {
+                sessionId: options.sessionId,
+                analyticsUserId: options.analyticsUserId,
+                analyticsProjectId: (0, base_1.resolveAnalyticsProjectId)(options.analyticsProjectId, options.workspaceRoot),
+                agentId,
+                agentVersion: options.agentPackVersion ?? 'workspace',
+                source: 'agenthippo',
+                engine: `custom:${manifest.id}`,
+                requestId: options.requestId,
+            });
+            if (litellmMetadataHeaders.length > 0) {
+                env.AGENTHIPPO_LITELLM_METADATA_HEADERS = litellmMetadataHeaders.join('\n');
+            }
+        }
+        if (options.agentPackVersion) {
+            env.AGENTHIPPO_AGENT_VERSION = options.agentPackVersion;
+            env.AGENTIDE_AGENT_VERSION = options.agentPackVersion;
+        }
+        if (manifest.homeEnvVar) {
+            env[manifest.homeEnvVar] = engineHomeDir;
+        }
+        if (manifest.model?.apiKeyEnvVar && routingApiKey) {
+            env[manifest.model.apiKeyEnvVar] = routingApiKey;
+        }
+        if (manifest.model?.baseUrlEnvVar && routingBaseUrl) {
+            env[manifest.model.baseUrlEnvVar] = routingBaseUrl;
+        }
+        if (manifest.model?.openaiBaseUrlEnvVar && routingOpenAIBaseUrl) {
+            env[manifest.model.openaiBaseUrlEnvVar] = routingOpenAIBaseUrl;
+        }
+        if ((routingBaseUrl && (0, utils_1.applyLocalTlsBypass)(env, routingBaseUrl))
+            || (routingOpenAIBaseUrl && routingOpenAIBaseUrl !== routingBaseUrl && (0, utils_1.applyLocalTlsBypass)(env, routingOpenAIBaseUrl))) {
+            runtime.logger.info(`[AgentIDE] Disabling TLS verification for local HTTPS (${manifest.id})`);
+        }
+        const routingDescription = routing.useLiteLLM
+            ? 'LiteLLM proxy'
+            : (routingBaseUrl ? 'custom provider' : 'native provider');
+        runtime.logger.info(`[AgentIDE] Custom engine "${manifest.id}" routing: ${routingDescription}, baseUrl=${routingBaseUrl || 'default'}, model=${modelId}`);
+        const resolvedMcp = await (0, mcp_1.loadMcpServers)(agentId, options.workspaceRoot, this.getBundledBasePromptsDir());
+        const mcpServers = (0, mcp_1.formatInlineMcpServers)(resolvedMcp);
+        if (resolvedMcp.length > 0) {
+            runtime.logger.debug(`[AgentIDE] Custom engine "${manifest.id}" MCP (${agentId}): ${resolvedMcp.map(s => s.name).join(', ')}`);
+        }
+        let turnMessage = message;
+        const baseTurn = {
+            message: turnMessage,
+            modelId,
+            workspaceRoot: options.workspaceRoot,
+            additionalDirectories: options.additionalDirectories ?? [],
+            permissions: options.permissions ?? { fileAccess: 'workspace-write' },
+            env,
+            routing: {
+                useLiteLLM: routing.useLiteLLM,
+                ...(routingApiKey ? { apiKey: routingApiKey } : {}),
+                ...(routingBaseUrl ? { baseUrl: routingBaseUrl } : {}),
+                ...(routingOpenAIBaseUrl ? { openaiBaseUrl: routingOpenAIBaseUrl } : {}),
+            },
+            session: {
+                key: conversationKey,
+                chatSessionId,
+                contextSessionId,
+                isEphemeral,
+                engineHomeDir,
+                engineSessionDir,
+                nativeSessionId,
+                contextFilePath,
+                terminalLogPath,
+                attachmentsDir,
+            },
+            agent: {
+                id: agentId,
+                version: options.agentPackVersion,
+                rulesFilePath,
+                skillsDir,
+                rulesDir,
+            },
+            ...(Object.keys(mcpServers).length > 0 ? { mcpServers } : {}),
+            emitter,
+            runtime: {
+                ...runtime,
+                invalidateEngineInstance: () => this.clearInstances(manifest.id),
+            },
+            signal,
+        };
+        if (manifest.promptInjection.mode === 'message-suffix') {
+            const suffix = maybeRuntimeContextSuffix(baseTurn);
+            if (suffix) {
+                turnMessage = `${message}\n\n${suffix}`;
+                baseTurn.message = turnMessage;
+            }
+        }
+        return baseTurn;
+    }
+    onMaintenance(logger) {
+        const now = Date.now();
+        for (const [key, entry] of this.activeSessions.entries()) {
+            if (now - entry.lastUsedAt > ACTIVE_SESSION_IDLE_TTL_MS) {
+                this.activeSessions.delete(key);
+                logger.info(`[AgentIDE] Closed idle custom engine session (key=${key}, idleMs=${now - entry.lastUsedAt})`);
+            }
+        }
+        for (const { engine, manifest } of this.instances.values()) {
+            try {
+                engine.onMaintenance?.(logger);
+            }
+            catch (err) {
+                logger.warn(`[AgentIDE] Custom engine "${manifest.id}" onMaintenance error: ${err}`);
+            }
+        }
+        this.workerPool.onMaintenance();
+    }
+    dispose() {
+        this.clearInstances();
+        this.workerPool.disposeAll();
+        this.activeSessions.clear();
+        this.mtimeCache.clear();
+    }
+}
+exports.CustomEngine = CustomEngine;