@kolisachint/hoocode-agent 0.4.69 → 0.4.71

package/dist/core/agent-session.js

@@ -14,7 +14,7 @@
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, resolve } from "node:path";
-import { clampThinkingLevel, cleanupSessionResources, getSupportedThinkingLevels, isContextOverflow, modelsAreEqual, resetApiProviders, } from "@kolisachint/hoocode-ai";
+import { clampThinkingLevel, cleanupSessionResources, completeSimple, getSupportedThinkingLevels, isContextOverflow, modelsAreEqual, resetApiProviders, } from "@kolisachint/hoocode-ai";
 import { theme } from "../modes/interactive/theme/theme.js";
 import { stripFrontmatter } from "../utils/frontmatter.js";
 import { sleep } from "../utils/sleep.js";
@@ -29,6 +29,10 @@ import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { emitSessionShutdownEvent } from "./extensions/runner.js";
 import { expandPromptTemplate, tryExpandPromptTemplate } from "./prompt-templates.js";
 import { clearProviderExhaustion, isProviderQuotaError, markProviderExhausted } from "./provider-health.js";
+import { LocalInferenceRouter, resolveRoutingMode } from "./routing/local-inference.js";
+import { logLocalInferenceFallback, logRoutingMetrics } from "./routing/metrics.js";
+import { MlxServerManager } from "./routing/mlx-server.js";
+import { buildToolResultPrompt, stripThinkTags, TOOL_RESULT_SYSTEM_PROMPT } from "./routing/tool-result-prompts.js";
 import { CURRENT_SESSION_VERSION, getLatestCompactionEntry } from "./session-manager.js";
 import { createSyntheticSourceInfo } from "./source-info.js";
 import { updateSubagentSkillPaths } from "./subagent-pool-instance.js";
@@ -108,6 +112,12 @@ export class AgentSession {
     _extensionErrorUnsubscriber;
     // Model registry for API key resolution
     _modelRegistry;
+    // Local-inference routing (opt-in via enableLocalInference). Lazily built.
+    _enableLocalInference;
+    _localRouter;
+    _localRouterBuilt = false;
+    _mlxServer;
+    _mlxServerBuilt = false;
     // Tool registry for extension getTools/setTools
     _toolRegistry = new Map();
     _toolDefinitions = new Map();
@@ -126,6 +136,7 @@ export class AgentSession {
         this._customTools = config.customTools ?? [];
         this._cwd = config.cwd;
         this._modelRegistry = config.modelRegistry;
+        this._enableLocalInference = config.enableLocalInference ?? false;
         this._extensionRunnerRef = config.extensionRunnerRef;
         this._initialActiveToolNames = config.initialActiveToolNames;
         this._allowedToolNames = config.allowedToolNames ? new Set(config.allowedToolNames) : undefined;
@@ -148,6 +159,57 @@ export class AgentSession {
     get modelRegistry() {
         return this._modelRegistry;
     }
+    /**
+     * Local-inference router, built lazily from the flag + env + models.json
+     * routing config. Returns undefined when routing is not active.
+     */
+    get localRouter() {
+        if (!this._localRouterBuilt) {
+            this._localRouterBuilt = true;
+            const mode = resolveRoutingMode({
+                enableFlag: this._enableLocalInference,
+                envMode: process.env.HOOCODE_ROUTING_MODE,
+                configMode: this._modelRegistry.getRoutingConfig()?.mode,
+            });
+            this._localRouter =
+                mode === "primary-only"
+                    ? undefined
+                    : LocalInferenceRouter.create({
+                        mode,
+                        config: this._modelRegistry.getRoutingConfig(),
+                        registry: this._modelRegistry,
+                    });
+        }
+        return this._localRouter;
+    }
+    /**
+     * Ensure the harness-managed executor server (if configured) is healthy before
+     * the executor is used. Returns false when routing is inactive or the server
+     * could not be started (caller degrades to primary/raw). Reuses an externally
+     * started server when one is already healthy.
+     */
+    async _ensureExecutorServer(signal) {
+        const router = this.localRouter;
+        if (!router?.isExecutorAvailable())
+            return false;
+        const serverConfig = router.getExecutorConfig()?.server;
+        if (!serverConfig)
+            return true; // user-managed server; assume available
+        if (!this._mlxServerBuilt) {
+            this._mlxServerBuilt = true;
+            const executor = router.getExecutorModel();
+            if (executor) {
+                this._mlxServer = new MlxServerManager({
+                    config: serverConfig,
+                    modelId: executor.id,
+                    baseUrl: executor.baseUrl,
+                });
+            }
+        }
+        if (!this._mlxServer)
+            return false;
+        return this._mlxServer.ensureStarted(signal);
+    }
     async _getRequiredRequestAuth(model) {
         const result = await this._modelRegistry.getApiKeyAndHeaders(model);
         if (!result.ok) {
@@ -199,28 +261,113 @@ export class AgentSession {
         };
         this.agent.afterToolCall = async ({ toolCall, args, result, isError }) => {
             const runner = this._extensionRunner;
-            if (!runner.hasHandlers("tool_result")) {
-                return undefined;
+            let content = result.content;
+            let details = result.details;
+            let resolvedIsError = isError;
+            let changed = false;
+            // Extensions see the real (uncompressed) tool result first.
+            if (runner.hasHandlers("tool_result")) {
+                const hookResult = await runner.emitToolResult({
+                    type: "tool_result",
+                    toolName: toolCall.name,
+                    toolCallId: toolCall.id,
+                    input: args,
+                    content: result.content,
+                    details: result.details,
+                    isError,
+                });
+                if (hookResult) {
+                    content = hookResult.content ?? content;
+                    details = hookResult.details ?? details;
+                    resolvedIsError = hookResult.isError ?? isError;
+                    changed = true;
+                }
             }
-            const hookResult = await runner.emitToolResult({
-                type: "tool_result",
-                toolName: toolCall.name,
-                toolCallId: toolCall.id,
-                input: args,
-                content: result.content,
-                details: result.details,
-                isError,
-            });
-            if (!hookResult) {
-                return undefined;
+            // Optionally compress large read/bash output before it enters context.
+            // Only when local-inference tool-result routing is active; on any
+            // failure the original (uncompressed) content is kept (fallback to raw).
+            if (!resolvedIsError) {
+                const compressed = await this._maybeCompressToolResult(toolCall.name, content);
+                if (compressed) {
+                    content = compressed;
+                    changed = true;
+                }
             }
-            return {
-                content: hookResult.content,
-                details: hookResult.details,
-                isError: hookResult.isError ?? isError,
-            };
+            if (!changed)
+                return undefined;
+            return { content, details, isError: resolvedIsError };
         };
     }
+    /**
+     * Compress a tool result via the local executor when routing is active and the
+     * tool/size qualify. Returns the compressed content blocks, or undefined to
+     * keep the original (no routing, not compressible, too small, or any failure).
+     */
+    async _maybeCompressToolResult(toolName, content) {
+        const router = this.localRouter;
+        if (!router)
+            return undefined;
+        const text = extractTextContent(content);
+        if (text === undefined)
+            return undefined;
+        const bytes = Buffer.byteLength(text, "utf8");
+        if (!router.shouldCompressToolResult(toolName, bytes))
+            return undefined;
+        const executor = router.getExecutorModel();
+        const prompt = buildToolResultPrompt(toolName, text);
+        if (!executor || !prompt)
+            return undefined;
+        const startedAt = Date.now();
+        try {
+            if (!(await this._ensureExecutorServer())) {
+                throw new Error("executor server unavailable");
+            }
+            const { apiKey, headers } = await this._getRequiredRequestAuth(executor);
+            const response = await completeSimple(executor, {
+                systemPrompt: TOOL_RESULT_SYSTEM_PROMPT,
+                messages: [
+                    {
+                        role: "user",
+                        content: [{ type: "text", text: prompt }],
+                        timestamp: Date.now(),
+                    },
+                ],
+            }, { apiKey, headers });
+            if (response.stopReason === "error") {
+                throw new Error(response.errorMessage || "executor error");
+            }
+            const rawSummary = response.content
+                .filter((c) => c.type === "text")
+                .map((c) => c.text)
+                .join("\n");
+            const summary = stripThinkTags(rawSummary);
+            if (summary === "")
+                throw new Error("empty compression");
+            const compressedBytes = Buffer.byteLength(summary, "utf8");
+            // Guard: if the model failed to compress (output not smaller), keep raw.
+            if (compressedBytes >= bytes)
+                return undefined;
+            logRoutingMetrics({
+                turnKind: "tool-result",
+                provider: executor.provider,
+                model: executor.id,
+                latencyMs: Date.now() - startedAt,
+                bytesBefore: bytes,
+                bytesAfter: compressedBytes,
+                fallback: false,
+            });
+            return [
+                {
+                    type: "text",
+                    text: `${summary}\n\n[compressed from ${bytes} to ${compressedBytes} bytes by local executor]`,
+                },
+            ];
+        }
+        catch (error) {
+            logLocalInferenceFallback("tool-result", error);
+            return undefined;
+        }
+    }
     // =========================================================================
     // Event Subscription
     // =========================================================================
@@ -531,6 +678,7 @@ export class AgentSession {
         this._extensionRunner.invalidate("This extension ctx is stale after session replacement or reload. Do not use a captured extension API or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().");
         this._disconnectFromAgent();
         this._eventListeners = [];
+        this._mlxServer?.stop();
         cleanupSessionResources(this.sessionId);
     }
     // =========================================================================
@@ -1317,7 +1465,7 @@ export class AgentSession {
             }
         }
         const generated = extensionCompaction ??
-            (await compact(preparation, model, apiKey, headers, customInstructions, signal, this.thinkingLevel));
+            (await this._compactWithRouting(preparation, model, apiKey, headers, customInstructions, signal));
         if (signal.aborted) {
             return { status: "cancelled" };
         }
@@ -1338,6 +1486,33 @@ export class AgentSession {
             result: { summary, firstKeptEntryId, tokensBefore, tokensAfter: tokensAfter ?? tokensBefore, details },
         };
     }
+    /**
+     * Run compaction, routing the summarization to the local executor model when
+     * local-inference routing is active for summarization. Any executor
+     * failure falls back to the primary model so compaction never hard-fails.
+     */
+    async _compactWithRouting(preparation, primaryModel, apiKey, headers, customInstructions, signal) {
+        const router = this.localRouter;
+        const executor = router?.selectModel("summarization", primaryModel);
+        if (router && executor && executor !== primaryModel) {
+            try {
+                if (!(await this._ensureExecutorServer(signal))) {
+                    throw new Error("executor server unavailable");
+                }
+                const { apiKey: exKey, headers: exHeaders } = await this._getRequiredRequestAuth(executor);
+                return await compact(preparation, executor, exKey, exHeaders, customInstructions, signal, 
+                // Executor runs without thinking (validated config); summary quality
+                // relies on /no_think via the model's promptSuffix compat setting.
+                "off");
+            }
+            catch (error) {
+                if (signal.aborted)
+                    throw error;
+                logLocalInferenceFallback("summarization", error);
+            }
+        }
+        return compact(preparation, primaryModel, apiKey, headers, customInstructions, signal, this.thinkingLevel);
+    }
     /**
      * Manually compact the session context.
      * Aborts current agent operation first.
@@ -2523,4 +2698,19 @@ export class AgentSession {
         return this._extensionRunner;
     }
 }
+/**
+ * Join all text blocks of a tool result. Returns undefined if any non-text
+ * (e.g. image) content is present, since those must not be compressed.
+ */
+function extractTextContent(content) {
+    if (content.length === 0)
+        return undefined;
+    const texts = [];
+    for (const block of content) {
+        if (block.type !== "text")
+            return undefined;
+        texts.push(block.text);
+    }
+    return texts.join("\n");
+}
 //# sourceMappingURL=agent-session.js.map