akemon 0.3.5 → 0.3.7

package/dist/engine-peripheral.js

@@ -17,8 +17,20 @@ import { callAgent, sendTaskEnd, sendTaskStart, sendTaskStream } from "./relay-c
 import { SIG, sig } from "./types.js";
 import { updateMetrics, pushExecMs } from "./metrics.js";
 import { sendFailureEvent } from "./relay-client.js";
+import { shouldDetachChildProcess, terminateProcessTree } from "./runtime-platform.js";
 import { resolveEngineRoute, } from "./engine-routing.js";
 export const LLM_ENGINES = new Set(["claude", "codex", "opencode", "gemini", "raw"]);
+export function normalizeEngineName(value) {
+    const raw = String(value ?? "").trim();
+    const cleaned = raw.replace(/[\x00-\x1f\x7f]/g, "").trim();
+    if (!cleaned)
+        throw new Error("Invalid engine: must not be empty");
+    return cleaned;
+}
+function engineIdSegment(engine) {
+    const cleaned = engine.replace(/[^a-zA-Z0-9._:-]+/g, "_").replace(/^_+|_+$/g, "");
+    return cleaned || "custom";
+}
 const defaultTaskRelay = {
     sendTaskStart,
     sendTaskStream,
@@ -30,12 +42,15 @@ const defaultTaskRelay = {
 export class EnginePeripheral {
     id;
     name;
+    engineName;
     capabilities = ["text-in", "text-out"];
     tags = ["engine", "llm"];
     config;
     bus = null;
     /** Last execution trace (for error reporting) */
     lastTrace = [];
+    /** Last selected invocation target, used by compute audit logging. */
+    lastInvocation = null;
     /** Active CLI child processes — tracked so SIGTERM handler can kill them. */
     activeChildren = new Set();
     /**
@@ -49,18 +64,17 @@ export class EnginePeripheral {
         for (const child of this.activeChildren) {
             if (!child.pid)
                 continue;
-            console.log(`[engine] shutdown: killing pgid=-${child.pid}`);
-            try {
-                process.kill(-child.pid, "SIGKILL");
-            }
-            catch { }
+            console.log(`[engine] shutdown: terminating process tree pid=${child.pid}`);
+            terminateProcessTree(child.pid, { signal: "SIGKILL" });
         }
         this.activeChildren.clear();
     }
     constructor(config) {
-        this.config = config;
-        this.id = `engine:${config.engine}`;
-        this.name = config.engine === "raw" ? "Local Raw Engine" : `${config.engine} CLI`;
+        const engine = normalizeEngineName(config.engine);
+        this.config = { ...config, engine };
+        this.engineName = engine;
+        this.id = `engine:${engineIdSegment(engine)}`;
+        this.name = engine === "raw" ? "Local Raw Engine" : `${engine} CLI`;
     }
     get connected() {
         return true; // engines are always "available"
@@ -100,19 +114,27 @@ export class EnginePeripheral {
     // ---------------------------------------------------------------------------
     // Unified engine runner
     // ---------------------------------------------------------------------------
-    async runEngine(task, allowAll, extraAllowedTools, signal, origin, routing, taskId, routeRequest) {
+    async runEngine(task, allowAll, extraAllowedTools, signal, origin, routing, taskId, routeRequest, engineResources) {
         const resolution = resolveEngineRoute(routing, { origin, ...routeRequest });
         const entry = resolution.entry;
-        const cfg = entry ? applyRoutingEntry(this.config, entry) : this.config;
+        const cfg = entry ? applyRoutingEntry(this.config, entry, engineResources) : this.config;
+        this.lastInvocation = describeEngineInvocation(cfg, resolution.routeId);
         if (origin && entry) {
-            console.log(`[engine] using ${cfg.engine}${cfg.model ? `/${cfg.model}` : ""} (origin=${origin}, source=${resolution.source})`);
+            const target = cfg.resourceId || cfg.engine;
+            console.log(`[engine] using ${target}${cfg.model ? `/${cfg.model}` : ""} (origin=${origin}, source=${resolution.source})`);
         }
         const t0 = Date.now();
         try {
             if (cfg.engine === "raw") {
                 return await this.runRawEngine(task, cfg);
             }
-            const cmd = buildEngineCommand(cfg.engine, cfg.model, allowAll ?? cfg.allowAll, extraAllowedTools);
+            const cmd = cfg.cliCommand
+                ? buildResourceCliCommand(cfg, allowAll ?? cfg.allowAll, extraAllowedTools)
+                : buildEngineCommand(cfg.engine, cfg.model, allowAll ?? cfg.allowAll, extraAllowedTools);
+            this.lastInvocation = {
+                ...this.lastInvocation,
+                command: [cmd.cmd, ...cmd.args].join(" "),
+            };
             return await runCommand(cmd.cmd, cmd.args, task, cfg.workdir, cmd.stdinMode, signal, this.activeChildren, origin, taskId, cfg.taskRelay ?? defaultTaskRelay, cfg.spawnImpl ?? spawn);
         }
         finally {
@@ -379,8 +401,38 @@ export const RAW_TOOLS = [
  * Resolves rawApiKeyEnv → rawApiKey from environment at call time.
  * Never mutates the base config.
  */
-function applyRoutingEntry(base, entry) {
-    const override = { engine: entry.engine };
+function applyRoutingEntry(base, entry, engineResources) {
+    const resource = entry.resource ? engineResources?.[entry.resource] : undefined;
+    const override = entry.engine ? { engine: entry.engine } : {};
+    if (resource) {
+        override.resourceId = entry.resource;
+        override.resourceKind = resource.kind;
+        if (resource.kind === "cli") {
+            override.engine = `cli:${entry.resource}`;
+            override.cliCommand = resource.command;
+            override.cliArgs = resource.args || [];
+            override.cliStdin = resource.stdin !== false;
+            override.cliModelArg = resource.modelArg;
+            if (resource.allowAll !== undefined)
+                override.allowAll = resource.allowAll;
+            override.model = entry.model ?? resource.defaultModel;
+        }
+        else {
+            override.engine = "raw";
+            override.provider = resource.provider;
+            override.protocol = resource.protocol || "openai_chat_completions";
+            override.rawApiUrl = resource.baseUrl;
+            if (resource.rawMaxRounds !== undefined)
+                override.rawMaxRounds = resource.rawMaxRounds;
+            override.model = entry.model ?? resource.defaultModel;
+            if (resource.apiKeyEnv)
+                override.rawApiKey = process.env[resource.apiKeyEnv] ?? "";
+            else if (resource.apiKey !== undefined)
+                override.rawApiKey = resource.apiKey;
+            else if (resource.credential)
+                override.rawApiKey = process.env[credentialEnvName(resource.credential)] ?? "";
+        }
+    }
     if (entry.model !== undefined)
         override.model = entry.model ?? undefined;
     if (entry.rawApiUrl !== undefined)
@@ -389,6 +441,10 @@ function applyRoutingEntry(base, entry) {
         override.rawMaxRounds = entry.rawMaxRounds;
     if (entry.allowAll !== undefined)
         override.allowAll = entry.allowAll;
+    if (entry.reasoningEffort !== undefined)
+        override.reasoningEffort = entry.reasoningEffort;
+    if (entry.verbosity !== undefined)
+        override.verbosity = entry.verbosity;
     // rawApiKeyEnv takes precedence over rawApiKey (env vars preferred for secrets)
     if (entry.rawApiKeyEnv)
         override.rawApiKey = process.env[entry.rawApiKeyEnv] ?? "";
@@ -396,6 +452,9 @@ function applyRoutingEntry(base, entry) {
         override.rawApiKey = entry.rawApiKey;
     return { ...base, ...override };
 }
+function credentialEnvName(credential) {
+    return `${credential.trim().replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase()}_API_KEY`;
+}
 function buildEngineCommand(engine, model, allowAll, extraAllowedTools) {
     switch (engine) {
         case "claude": {
@@ -428,6 +487,57 @@ function buildEngineCommand(engine, model, allowAll, extraAllowedTools) {
             return { cmd: engine, args: [], stdinMode: true };
     }
 }
+function buildResourceCliCommand(cfg, _allowAll, _extraAllowedTools) {
+    const args = [...(cfg.cliArgs || [])];
+    if (cfg.model && cfg.cliModelArg)
+        args.push(cfg.cliModelArg, cfg.model);
+    return {
+        cmd: cfg.cliCommand || cfg.engine,
+        args,
+        stdinMode: cfg.cliStdin !== false,
+    };
+}
+function describeEngineInvocation(cfg, routeId) {
+    if (cfg.engine === "raw") {
+        const apiUrl = `${cfg.rawApiUrl || "http://localhost:11434/v1"}/chat/completions`;
+        return {
+            routeId,
+            resourceId: cfg.resourceId,
+            resourceKind: cfg.resourceKind,
+            provider: cfg.provider,
+            protocol: cfg.protocol || "openai_chat_completions",
+            engine: cfg.engine,
+            model: cfg.model,
+            reasoningEffort: cfg.reasoningEffort,
+            verbosity: cfg.verbosity,
+            command: `POST ${apiUrl}`,
+        };
+    }
+    if (cfg.cliCommand) {
+        const cmd = buildResourceCliCommand(cfg);
+        return {
+            routeId,
+            resourceId: cfg.resourceId,
+            resourceKind: cfg.resourceKind,
+            engine: cfg.engine,
+            model: cfg.model,
+            reasoningEffort: cfg.reasoningEffort,
+            verbosity: cfg.verbosity,
+            command: [cmd.cmd, ...cmd.args].join(" "),
+        };
+    }
+    const cmd = buildEngineCommand(cfg.engine, cfg.model, cfg.allowAll);
+    return {
+        routeId,
+        resourceId: cfg.resourceId,
+        resourceKind: cfg.resourceKind || "cli",
+        engine: cfg.engine,
+        model: cfg.model,
+        reasoningEffort: cfg.reasoningEffort,
+        verbosity: cfg.verbosity,
+        command: [cmd.cmd, ...cmd.args].join(" "),
+    };
+}
 function runCommand(cmd, args, task, cwd, stdinMode = true, signal, activeChildren, origin, taskId, taskRelay = defaultTaskRelay, spawnImpl = spawn) {
     return new Promise((resolve, reject) => {
         const { CLAUDECODE, ...cleanEnv } = process.env;
@@ -450,7 +560,7 @@ function runCommand(cmd, args, task, cwd, stdinMode = true, signal, activeChildr
                 cwd,
                 env: cleanEnv,
                 stdio: [stdinMode ? "pipe" : "ignore", "pipe", "pipe"],
-                detached: true, // child becomes process-group leader; enables pgid kill
+                detached: shouldDetachChildProcess(),
             });
         }
         catch (err) {
@@ -470,18 +580,9 @@ function runCommand(cmd, args, task, cwd, stdinMode = true, signal, activeChildr
             if (aborted || !child.pid)
                 return;
             aborted = true;
-            console.log(`[${cmd}] aborted, killing pgid=-${child.pid}`);
+            console.log(`[${cmd}] aborted, terminating process tree pid=${child.pid}`);
             sendFailureEvent("engine_abort", cmd, "engine subprocess aborted via signal");
-            try {
-                process.kill(-child.pid, "SIGTERM");
-            }
-            catch { }
-            setTimeout(() => {
-                try {
-                    process.kill(-child.pid, "SIGKILL");
-                }
-                catch { }
-            }, 3000).unref();
+            terminateProcessTree(child.pid, { signal: "SIGTERM", forceAfterMs: 3000 });
         };
         if (signal) {
             if (signal.aborted)

package/dist/engine-routing.js

@@ -42,15 +42,20 @@ export function resolveEngineRoute(routing, request = {}) {
     }
     const route = selectRoute(routing.routes, request);
     if (route) {
+        const entry = stripRouteMetadata(route);
         return {
-            entry: stripRouteMetadata(route),
+            entry,
+            routeId: route.id,
+            resourceId: entry.resource,
             source: "route",
             reason: "matched registry route",
         };
     }
     if (request.origin && routing[request.origin]) {
+        const entry = routing[request.origin];
         return {
-            entry: routing[request.origin],
+            entry,
+            resourceId: entry.resource,
             source: "origin",
             reason: `matched legacy origin route ${request.origin}`,
         };
@@ -58,10 +63,19 @@ export function resolveEngineRoute(routing, request = {}) {
     if (routing.default) {
         return {
             entry: routing.default,
+            resourceId: routing.default.resource,
             source: "default",
             reason: "matched legacy default route",
         };
     }
+    if (routing.defaultResource) {
+        return {
+            entry: { resource: routing.defaultResource },
+            resourceId: routing.defaultResource,
+            source: "default",
+            reason: "matched default resource",
+        };
+    }
     return { entry: null, source: "none", reason: "no matching route" };
 }
 /**
@@ -103,15 +117,24 @@ function selectRoute(routes, request) {
     return best?.route ?? null;
 }
 function routeMatches(route, request) {
-    if (request.origin && route.origins?.length && !route.origins.includes(request.origin))
+    const match = route.match;
+    const origins = match?.origins ?? route.origins;
+    const taskKinds = match?.taskKinds ?? route.taskKinds;
+    const capabilities = match?.requiredCapabilities ?? route.capabilities;
+    const privacy = match?.privacy ?? route.privacy;
+    const maxCost = match?.maxCost ?? route.cost;
+    const maxLatency = match?.maxLatency ?? route.latency;
+    if (request.origin && origins?.length && !origins.includes(request.origin))
+        return false;
+    if (taskKinds?.length && (!request.taskKind || !taskKinds.includes(request.taskKind)))
         return false;
-    if (!hasRequiredCapabilities(route.capabilities, request.requiredCapabilities))
+    if (!hasRequiredCapabilities(capabilities, request.requiredCapabilities))
         return false;
-    if (request.privacy && route.privacy && route.privacy !== request.privacy)
+    if (request.privacy && privacy && privacy !== request.privacy)
         return false;
-    if (request.maxCost && route.cost && tierRank(route.cost) > tierRank(request.maxCost))
+    if (request.maxCost && maxCost && tierRank(maxCost) > tierRank(request.maxCost))
         return false;
-    if (request.maxLatency && route.latency && tierRank(route.latency) > tierRank(request.maxLatency))
+    if (request.maxLatency && maxLatency && tierRank(maxLatency) > tierRank(request.maxLatency))
         return false;
     return true;
 }
@@ -124,23 +147,41 @@ function hasRequiredCapabilities(available, required) {
 }
 function scoreRoute(route, request) {
     let score = route.priority ?? 0;
-    if (request.origin && route.origins?.includes(request.origin))
+    const match = route.match;
+    const origins = match?.origins ?? route.origins;
+    const taskKinds = match?.taskKinds ?? route.taskKinds;
+    const capabilities = match?.requiredCapabilities ?? route.capabilities;
+    const privacy = match?.privacy ?? route.privacy;
+    const cost = match?.maxCost ?? route.cost;
+    const latency = match?.maxLatency ?? route.latency;
+    if (request.taskKind && taskKinds?.includes(request.taskKind))
+        score += 120;
+    if (request.origin && origins?.includes(request.origin))
         score += 100;
-    if (request.origin && !route.origins?.length)
+    if (request.origin && !origins?.length)
         score += 10;
     if (request.requiredCapabilities?.length)
-        score += (route.capabilities?.length || 0) * 2;
-    if (request.privacy && route.privacy === request.privacy)
+        score += (capabilities?.length || 0) * 2;
+    if (request.privacy && privacy === request.privacy)
         score += 20;
-    if (route.cost)
-        score += 6 - tierRank(route.cost);
-    if (route.latency)
-        score += 6 - tierRank(route.latency);
+    if (cost)
+        score += 6 - tierRank(cost);
+    if (latency)
+        score += 6 - tierRank(latency);
     return score;
 }
 function stripRouteMetadata(route) {
-    const { origins: _origins, priority: _priority, ...entry } = route;
-    return entry;
+    const { id, origins: _origins, taskKinds: _taskKinds, priority: _priority, match: _match, use, ...entry } = route;
+    return {
+        ...entry,
+        ...(id ? { routeId: id } : {}),
+        ...(use?.resource ? { resource: use.resource } : {}),
+        ...(use?.model !== undefined ? { model: use.model } : {}),
+        ...(use?.allowAll !== undefined ? { allowAll: use.allowAll } : {}),
+        ...(use?.rawMaxRounds !== undefined ? { rawMaxRounds: use.rawMaxRounds } : {}),
+        ...(use?.reasoningEffort !== undefined ? { reasoningEffort: use.reasoningEffort } : {}),
+        ...(use?.verbosity !== undefined ? { verbosity: use.verbosity } : {}),
+    };
 }
 function tierRank(tier) {
     switch (tier) {