neoctl 0.2.37 → 0.2.39

package/dist/web/index.js

@@ -1,11 +1,13 @@
 #!/usr/bin/env node
 import { subagentHeader, subagentStatusFacts } from "./status-semantics.js";
+import { handlePromptConfigRequest } from "./prompt-config-protocol.js";
 import http from "node:http";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
+import { readSessionPrompt, updateSessionPrompt, SessionPromptError } from "./session-prompt-protocol.js";
 import { QueryEngine } from "../core/query-engine.js";
 import { InMemoryAppPromptStore } from "../app/app-prompt.js";
 import { InMemoryAppState } from "../app/app-state.js";
@@ -192,6 +194,14 @@ export async function createWebRuntime(options = {}) {
         modelGateway,
         tools,
         contextManagerFactory: (cwd) => new DefaultContextManager({ cwd }),
+        refreshTools: () => {
+            if (!options.resolveGlobalToolOverrides)
+                return;
+            if (runtime)
+                refreshGlobalToolOverrides(runtime);
+            else
+                applyToolOverrides(tools, toolCatalog, normalizeToolOverrides(options.resolveGlobalToolOverrides(), toolCatalog), sessionToolOverrides);
+        },
         additionalPromptSections: [
             ...(options.externalPromptSections ?? []),
             ...activePlugins.flatMap((plugin) => plugin.promptSections ?? []),
@@ -240,6 +250,7 @@ export async function createWebRuntime(options = {}) {
             globalOverrides: globalToolOverrides,
             sessionOverrides: sessionToolOverrides,
             persistGlobal: options.persistGlobalToolOverrides,
+            resolveGlobal: options.resolveGlobalToolOverrides,
             persistSession: options.persistSessionToolOverrides,
             resolveSession: options.resolveSessionToolOverrides,
         },
@@ -277,6 +288,14 @@ function applyToolOverrides(registry, catalog, globalOverrides, sessionOverrides
     for (const tool of catalog)
         registry.setEnabled(tool.name, sessionOverrides[tool.name] ?? globalOverrides[tool.name] ?? true);
 }
+/** Called only at a safe turn boundary or while idle, never during tool execution. */
+export function refreshGlobalToolOverrides(runtime) {
+    const support = runtime.toolSupport;
+    if (!support?.resolveGlobal)
+        return;
+    support.globalOverrides = normalizeToolOverrides(support.resolveGlobal(), support.catalog);
+    applyToolOverrides(runtime.tools, support.catalog, support.globalOverrides, support.sessionOverrides);
+}
 /** Bind only the foreground view; never stop work owned by another session. */
 export function activateSession(runtime) {
     const sessionDir = runtime.engine.snapshot().session?.sessionDir || undefined;
@@ -506,6 +525,12 @@ export class WebRepl {
     snapshot(includeCatalog = false) {
         const backgroundTasks = this.backgroundTasks();
         const engineSnapshot = this.runtime.engine.snapshot();
+        const pendingSessionSettings = this.runtime.engine.getPendingSessionSettings?.() ?? {};
+        // Include retained reasoning alongside a queued model. Explicit undefined is
+        // the default reset and is intentionally omitted by JSON serialization.
+        if (Object.hasOwn(pendingSessionSettings, "model") && !Object.hasOwn(pendingSessionSettings, "reasoning")) {
+            pendingSessionSettings.reasoning = engineSnapshot.reasoning;
+        }
         return {
             lines: this.lines.map(line => line.toolError ? { ...line, toolError: this.runtime.engine.redactDisplayValue?.(line.toolError) ?? line.toolError } : line),
             status: this.status,
@@ -519,6 +544,7 @@ export class WebRepl {
             runningSessionIds: [...this.backgroundSessionRuns.keys()],
             session: engineSnapshot.session,
             modelSettings: { model: engineSnapshot.model, reasoning: engineSnapshot.reasoning },
+            pendingSessionSettings,
             fastMode: this.runtime.engine.isFastMode(),
             appPrompt: this.runtime.engine.getAppPrompt(),
             catalog: includeCatalog ? webCatalog(this.runtime) : undefined,
@@ -552,6 +578,7 @@ export class WebRepl {
         };
     }
     globalTools() {
+        this.runtime.engine.refreshToolsIfIdle();
         const support = this.runtime.toolSupport;
         if (!support)
             return { items: [] };
@@ -563,6 +590,7 @@ export class WebRepl {
         };
     }
     sessionTools() {
+        this.runtime.engine.refreshToolsIfIdle();
         const support = this.runtime.toolSupport;
         const sessionId = this.runtime.engine.snapshot().session?.sessionId;
         if (!support)
@@ -599,11 +627,12 @@ export class WebRepl {
         if (!normalized.ok)
             return normalized;
         try {
+            // Persist before publishing so a failed write never changes active capabilities.
+            if (support.persistGlobal)
+                await support.persistGlobal(normalized.value);
             support.globalOverrides = normalized.value;
             this.syncPluginToolRegistration();
             applyToolOverrides(this.runtime.tools, support.catalog, support.globalOverrides, support.sessionOverrides);
-            if (support.persistGlobal)
-                await support.persistGlobal(support.globalOverrides);
             await this.refreshToolConfiguration();
             return { ok: true, state: this.globalTools() };
         }
@@ -701,12 +730,14 @@ export class WebRepl {
         const support = this.runtime.toolSupport;
         if (!support)
             return;
-        support.sessionOverrides = normalizeToolOverrides(overrides, support.catalog);
-        this.syncPluginToolRegistration();
-        applyToolOverrides(this.runtime.tools, support.catalog, support.globalOverrides, support.sessionOverrides);
+        const normalized = normalizeToolOverrides(overrides, support.catalog);
         const sessionId = this.runtime.engine.snapshot().session?.sessionId;
         if (persist && sessionId && support.persistSession)
-            await support.persistSession(sessionId, support.sessionOverrides);
+            await support.persistSession(sessionId, normalized);
+        support.sessionOverrides = normalized;
+        this.runtime.engine.refreshToolsIfIdle();
+        this.syncPluginToolRegistration();
+        applyToolOverrides(this.runtime.tools, support.catalog, support.globalOverrides, support.sessionOverrides);
         await this.refreshToolConfiguration();
     }
     syncPluginToolRegistration() {
@@ -950,35 +981,105 @@ export class WebRepl {
         }
         return undefined;
     }
+    async refreshSessionSettingMetrics(engine) {
+        const metrics = await engine.contextMetrics();
+        // A request can finish after its owner session was detached/switched.
+        if (this.runtime.engine !== engine)
+            return;
+        this.runtime.initialMetrics = metrics;
+        this.setStatus({ ...this.status, metrics, activityTick: this.status.activityTick + 1 });
+    }
     async setFastMode(enabled) {
+        const engine = this.runtime.engine;
         try {
-            const fastMode = await this.runtime.engine.setFastMode(enabled);
-            this.broadcastSync();
-            return { ok: true, fastMode };
+            const { deferred } = await engine.updateSessionSettings({ fastMode: enabled });
+            if (this.runtime.engine === engine)
+                this.broadcastSync();
+            return { ok: true, fastMode: enabled, deferred };
         }
         catch (error) {
             return actionFailure("FAST_MODE_UPDATE_FAILED", error instanceof Error ? error.message : String(error));
         }
     }
     async setContextWindowK(value) {
-        if (this.busy)
-            return actionFailure("CONTEXT_WINDOW_UPDATE_BLOCKED", "cannot change context window while a response is running");
-        if (typeof value !== "string" || !/^\d+$/u.test(value) || Number(value) <= 0) {
+        if (typeof value !== "string" || !/^\d+$/u.test(value) || Number(value) <= 0 || !Number.isSafeInteger(Number(value) * 1000)) {
             return actionFailure("CONTEXT_WINDOW_INVALID", "context window must be a positive integer in k");
         }
         const contextWindowK = Number(value);
         const contextWindowTokens = contextWindowK * 1000;
+        const engine = this.runtime.engine;
         try {
-            await this.runtime.engine.setContextWindowTokensOverride(contextWindowTokens);
-            const metrics = await this.runtime.engine.contextMetrics();
-            this.runtime.initialMetrics = metrics;
-            this.setStatus({ ...this.status, metrics, activityTick: this.status.activityTick + 1 });
-            return { ok: true, contextWindowK, contextWindowTokens };
+            const { deferred } = await engine.updateSessionSettings({ contextWindowTokens });
+            if (!deferred)
+                await this.refreshSessionSettingMetrics(engine);
+            if (this.runtime.engine === engine)
+                this.broadcastSync();
+            return { ok: true, contextWindowK, contextWindowTokens, deferred };
         }
         catch (error) {
             return actionFailure("CONTEXT_WINDOW_UPDATE_FAILED", error instanceof Error ? error.message : String(error));
         }
     }
+    async setSessionModel(model, reasoning) {
+        if (typeof model !== "string" || !model.trim() || model.length > 256 || /[\s\x00-\x1f]/u.test(model.trim())) {
+            return actionFailure("MODEL_INVALID", "invalid model");
+        }
+        if (reasoning !== undefined && (typeof reasoning !== "string" || !["none", "minimal", "low", "medium", "high", "xhigh", "max", "default", "off"].includes(reasoning))) {
+            return actionFailure("MODEL_INVALID", "invalid reasoning effort");
+        }
+        const engine = this.runtime.engine;
+        const nextModel = model.trim();
+        const current = { ...engine.getModelSettings(), ...engine.getPendingSessionSettings() };
+        const argument = reasoning;
+        const validationError = validateModelReasoningArgument(nextModel, argument);
+        if (validationError)
+            return actionFailure("MODEL_INVALID", validationError);
+        const update = resolveModelReasoningUpdate(argument, current.reasoning, nextModel, nextModel !== current.model);
+        try {
+            // Current engine only: no env write, provider replacement, transcript message,
+            // runtime-context injection or prompt-cache prefix change for UI settings.
+            const { deferred } = await engine.updateSessionSettings({ model: nextModel, ...(update.update ? { reasoning: update.reasoning } : {}) });
+            if (!deferred)
+                await this.refreshSessionSettingMetrics(engine);
+            if (this.runtime.engine === engine)
+                this.broadcastSync();
+            return { ok: true, deferred, modelSettings: { model: nextModel, reasoning: update.reasoning } };
+        }
+        catch (error) {
+            return actionFailure("MODEL_UPDATE_FAILED", error instanceof Error ? error.message : String(error));
+        }
+    }
+    sessionPrompt() {
+        return readSessionPrompt(this.runtime.engine);
+    }
+    async saveSessionPrompt(body) {
+        const engine = this.runtime.engine;
+        const result = await updateSessionPrompt(engine, body);
+        if (this.runtime.engine === engine) {
+            if (!result.deferred)
+                await this.refreshSessionSettingMetrics(engine);
+            this.publishRuntimeContext();
+            this.broadcastSync();
+        }
+        return result;
+    }
+    async compactSession() {
+        const engine = this.runtime.engine;
+        try {
+            const result = await engine.updateSessionSettings({ compact: true });
+            if (this.runtime.engine === engine) {
+                if (result.compaction?.report)
+                    this.appendCompaction(result.compaction.report);
+                if (!result.deferred)
+                    await this.refreshSessionSettingMetrics(engine);
+                this.broadcastSync();
+            }
+            return { ok: true, deferred: result.deferred };
+        }
+        catch (error) {
+            return actionFailure("COMPACTION_FAILED", error instanceof Error ? error.message : String(error));
+        }
+    }
     loginForm(providerValue) {
         const provider = parseLoginProvider(providerValue);
         return createLoginFormPayload(this.runtime.envPath, provider);
@@ -1139,7 +1240,9 @@ export class WebRepl {
                 break;
             offset = history.value.nextOffset;
         } while (true);
-        return records.reverse().map(({ record }) => ({
+        // Output history includes foreground commands too. Only an explicit durable
+        // background transition belongs in this UI; legacy records are not inferred.
+        return records.filter(({ record }) => record.metadata.backgrounded === true).reverse().map(({ record }) => ({
             kind: "terminal", taskId: `terminal:${record.runId}`, type: "终端",
             ownerSessionId: session.sessionId, sessionId: record.runId,
             status: record.lifecycle === "lost" ? "lost" : record.exit?.status ?? "unknown",
@@ -1923,6 +2026,8 @@ async function route(req, res, router) {
             return sendFile(res, highlightAssetPath, "text/javascript; charset=utf-8");
         if (req.method === "GET" && url.pathname === "/vendor/highlight-theme.css")
             return sendFile(res, highlightThemeAssetPath, "text/css; charset=utf-8");
+        if (url.pathname === "/api/prompt-config")
+            return handlePromptConfigRequest(req, res);
         if (req.method === "GET" && url.pathname === "/api/client-info")
             return sendJson(res, router.clientInfo());
         if (req.method === "POST" && url.pathname === "/api/client-reload") {
@@ -2023,6 +2128,32 @@ async function route(req, res, router) {
             const body = await readJsonBody(req);
             return sendJson(res, repl.setAppPrompt(body));
         }
+        if (url.pathname === "/api/session-prompt" && (req.method === "GET" || req.method === "POST")) {
+            res.setHeader("Cache-Control", "no-store");
+            try {
+                if (req.method === "GET")
+                    return sendJson(res, await repl.sessionPrompt());
+                let body;
+                try {
+                    body = await readJsonBody(req);
+                }
+                catch {
+                    return sendJson(res, actionFailure("SESSION_PROMPT_INVALID", "invalid JSON body"), 400);
+                }
+                return sendJson(res, await repl.saveSessionPrompt(body));
+            }
+            catch (error) {
+                const status = error instanceof SessionPromptError ? error.statusCode : 500;
+                const code = status === 409 ? "SESSION_PROMPT_CONFLICT" : status === 400 ? "SESSION_PROMPT_INVALID" : "SESSION_PROMPT_FAILED";
+                return sendJson(res, actionFailure(code, error instanceof Error ? error.message : String(error)), status);
+            }
+        }
+        if (req.method === "POST" && url.pathname === "/api/session-model") {
+            const body = await readJsonBody(req);
+            return sendJson(res, await repl.setSessionModel(body.model, body.reasoning));
+        }
+        if (req.method === "POST" && url.pathname === "/api/compact")
+            return sendJson(res, await repl.compactSession());
         if (req.method === "POST" && url.pathname === "/api/fast-mode") {
             const body = await readJsonBody(req);
             return sendJson(res, await repl.setFastMode(body.enabled === true));
@@ -2149,6 +2280,7 @@ function webCatalog(runtime) {
     return {
         commands: replCommandDefinitions,
         modelIds,
+        modelReasoning: Object.fromEntries(modelIds.map(model => [model, reasoningEffortsForModel(model) ?? []])),
         reasoning: ["none", "minimal", "low", "medium", "high", "xhigh", "max", "default", "off"],
         envPath: runtime.envPath,
     };