@agenthippo-ai/agenthippo 1.110.11 → 1.110.19

package/out/engines/custom.js

@@ -1,680 +0,0 @@
-"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.deliverModelRoutingEnv = deliverModelRoutingEnv;
-exports.buildRunnerChildEnv = buildRunnerChildEnv;
-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 runtime_1 = require("../cli/runtime");
-const customRegistry_1 = require("./customRegistry");
-const paths_1 = require("../agentpack/paths");
-const credential_context_1 = require("../cli/credential-context");
-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;
-}
-/**
- * Deliver the per-turn model-routing values into the env vars a manifest declares
- * (`model.apiKeyEnvVar` / `baseUrlEnvVar` / `openaiBaseUrlEnvVar`).
- *
- * NON-CLOBBERING: a var already set in the host's own ambient env is left alone. Two reasons:
- * (1) it preserves the effective behavior deployments already relied on — the old
- *     `{...turn.env, ...process.env}` child-env spread accidentally let ambient values win,
- *     and operators' engine-owned keys (e.g. a real CURSOR_API_KEY vs a stale manifest that
- *     wrongly declared it as a delivery slot) must keep winning after that spread is fixed;
- * (2) it makes the manifest contract safe by construction: mis-declaring an operator-owned
- *     credential as a delivery slot can shadow nothing.
- * The flip side is documented on CustomEngineModelConfig: ambient-exporting a genuine
- * delivery var (e.g. LITELLM_API_KEY in serve's shell) shadows per-turn rotation.
- */
-function deliverModelRoutingEnv(env, manifest, routing, ambientEnv, logger) {
-    const deliver = (envVar, value, label) => {
-        if (!envVar || !value) {
-            return;
-        }
-        if (ambientEnv[envVar]?.trim()) {
-            logger?.info(`[AgentIDE] Custom engine "${manifest.id}": ${envVar} already set in ambient env — keeping the operator's value, skipping per-turn ${label} delivery`);
-            return;
-        }
-        env[envVar] = value;
-    };
-    deliver(manifest.model?.apiKeyEnvVar, routing.apiKey, 'API key');
-    deliver(manifest.model?.baseUrlEnvVar, routing.baseUrl, 'base URL');
-    deliver(manifest.model?.openaiBaseUrlEnvVar, routing.openaiBaseUrl, 'OpenAI base URL');
-}
-function buildRunnerChildEnv(manifest, turn, probeImport) {
-    const childEnv = {
-        // Per-turn values WIN over the host's ambient env. turn.env starts from a spread of
-        // process.env, so for undeclared vars this is identical either way; the difference is
-        // deliberate per-turn state (AGENTHIPPO_* control vars, the data-plane turn nonce,
-        // session paths, manifest-declared deliveries) which must never be reverted by a
-        // same-named var in the host's own environment. Ambient-vs-delivery precedence for
-        // manifest credential vars is decided earlier, in deliverModelRoutingEnv (non-clobber).
-        ...process.env,
-        ...turn.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);
-        // Per-user, on the same rule claude and codex use. This engine had NO user scoping at all
-        // — in serve or in a sandbox — so on a multi-user deployment every custom engine's home
-        // (its config, caches, and whatever the engine chooses to persist) was one shared
-        // directory. `home` is the one that needed it: engineSessionDir is already per session.
-        // No verified user ⇒ unchanged path, so the IDE and single-tenant CLI are unaffected.
-        const engineHomeDir = (0, paths_1.userScopedEngineHomeFromKey)(path.join(engineBaseDir, 'home'), (0, credential_context_1.resolveEngineHomeUserKey)(options.engineHomeUserKey));
-        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);
-        // A custom engine isn't pinned to one vendor — infer its direct provider from the model
-        // (e.g. openclaw's litellm/* routes through the proxy anyway; a claude-* model → Anthropic).
-        // The engine's manifest still decides which env var receives the resolved key.
-        const routing = (0, utils_1.resolveApiRouting)(options, this.config, (0, utils_1.inferModelProvider)(options.modelId), 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',
-        };
-        delete env[runtime_1.OPENCLAW_GATEWAY_TOKEN_ENV];
-        delete env['AGENTHIPPO_DATA_PLANE_TOKEN'];
-        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,
-                policyVersion: options.policyVersion,
-                packDigest: options.packDigest,
-                instanceId: options.instanceId,
-                engineVersion: options.engineVersion,
-                tier: options.tier,
-            });
-            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;
-        }
-        deliverModelRoutingEnv(env, manifest, { apiKey: routingApiKey, baseUrl: routingBaseUrl, openaiBaseUrl: routingOpenAIBaseUrl }, process.env, runtime.logger);
-        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());
-        // `env` is this turn's child env — URL servers resolve bearerTokenEnv (turn nonce)
-        // from it in memory, so per-turn auth never lands in a shared file.
-        const mcpServers = (0, mcp_1.formatInlineMcpServers)(resolvedMcp, env);
-        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;