@xingjisoft/neutrino 0.2.1 → 0.4.0

package/dist/web/session.js

@@ -10,9 +10,13 @@
  * registers itself in the live hub, so the regular `/api/live/*` endpoints
  * (snapshot, stream, pause, resume, message) work unchanged.
  */
-import { findModel, contextCompressionThreshold, loadConfig, loadPlannerPrompt, loadStepPrompt, loadSubAgentPrompt, normalizeApprovalMode, planFirstEnabled, loadModels, loadPrompt, saveSession, } from "../config.js";
+import { randomUUID } from "node:crypto";
+import { findModel, contextCompressionThreshold, intensityForModel, loadConfig, loadPlannerPrompt, loadStepPrompt, loadSubAgentPrompt, normalizeApprovalMode, planFirstEnabled, loadModels, loadPrompt, saveSession, } from "../config.js";
 import { COMPACT_KEEP, planCompaction, transcriptFor, modelHistory, normalizeContext, } from "../compact.js";
 import { LLMClient, describeError } from "../llm/client.js";
+import { defaultProPreset, loadProModels, loadProPrompt, proMaxRecursionDepth, requireProPreset } from "../pro/config.js";
+import { resolveProTeam, ProPreflightError } from "../pro/preflight.js";
+import { ProAgentTeam, getProToolDefinitions } from "../pro/agents.js";
 import { advancePlan, buildPlannerInput, lastRequestText, needsPlan, parsePlan, planMessage, planTranscript, renderStepDirective, resumePlan, stopPlan, } from "../llm/plan.js";
 import { DELEGATE_TOOL, executeTool, getSubAgentToolDefinitions, getToolDefinitions } from "../llm/tools.js";
 import { buildSubAgentTask, formatSubAgentResult, runSubAgent as runSubAgentTask, } from "../llm/subagent.js";
@@ -31,6 +35,49 @@ const TOOL_PENDING = "…";
 const SUB_AGENT_TOOLS = getSubAgentToolDefinitions();
 /** Marker for the model-only summary, separate from the original transcript. */
 const SUMMARY_PREFIX = "Context was compressed. Summary of the earlier part:";
+/**
+ * A fresh session id in the same shape `saveSession` generates, so a new
+ * browser conversation has a stable identity before its first message exists.
+ */
+export function newSessionId(now = new Date()) {
+    return `${now.toISOString().replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}`;
+}
+/**
+ * Start an empty conversation in a caller-chosen working directory. Nothing is
+ * written to disk until the first message, so an abandoned new-chat dialog
+ * cannot litter the history with empty transcripts.
+ */
+export function createWebSession(cwd, selection, approvalMode, mode = "standard", proPreset) {
+    const now = new Date();
+    const source = {
+        id: newSessionId(now),
+        created_at: now.toISOString(),
+        updated_at: now.toISOString(),
+        model: selection.model.name,
+        provider: selection.provider,
+        intensity: selection.intensity,
+        cwd,
+        title: "",
+        messages: [],
+        tokens: { prompt: 0, completion: 0 },
+        approval_mode: normalizeApprovalMode(approvalMode ?? loadConfig(mode).approval_mode),
+        ...(mode === "pro" ? { pro_preset: requireProPreset(proPreset ?? defaultProPreset()) } : {}),
+    };
+    return new WebSession(source, selection.model, mode);
+}
+/** A preset may need fallback; defer model credentials/availability to preflight. */
+export function proInitialSelection(preset = defaultProPreset()) {
+    const tier = loadProModels().tier.find((entry) => entry.name === requireProPreset(preset));
+    const setting = tier["model-setting"].find((entry) => entry.type === "main_model");
+    const provider = setting?.provider ?? "";
+    const name = setting?.model ?? "";
+    const model = loadModels().providers.find((entry) => entry.name === provider)?.models.find((entry) => entry.name === name);
+    return {
+        provider,
+        model: model ? { ...model } : { name, url: "", api_key: "", supports_streaming: true },
+        intensity: setting?.intensity || "high",
+    };
+}
 function parseArguments(raw) {
     const text = raw?.trim() ?? "";
     if (!text)
@@ -63,15 +110,27 @@ export function resolveModel(modelName, providerName) {
     return { ok: true, model };
 }
 /** Build a web session from a saved transcript, or explain why we cannot. */
-export function resumeSession(source, selection) {
+export function resumeSession(source, selection, mode = "standard") {
+    if (mode === "pro") {
+        try {
+            const initial = proInitialSelection(source.pro_preset ?? defaultProPreset());
+            return { ok: true, session: new WebSession({ ...source, provider: initial.provider,
+                    model: initial.model.name, intensity: initial.intensity }, initial.model, mode) };
+        }
+        catch (error) {
+            return { ok: false, error: describeError(error) };
+        }
+    }
     const updated = selection ? { ...source, ...selection } : source;
     const resolved = resolveModel(updated.model, updated.provider);
     if (!resolved.ok)
         return resolved;
-    return { ok: true, session: new WebSession(updated, resolved.model) };
+    return { ok: true, session: new WebSession(updated, resolved.model, mode) };
 }
 export class WebSession {
     key = null;
+    /** Workspace this conversation belongs to; keeps Pro and standard separate. */
+    mode;
     model;
     provider;
     intensity;
@@ -90,6 +149,10 @@ export class WebSession {
     plan = null;
     /** True while the planner agent is writing the steps. */
     planning = false;
+    proPreset = null;
+    proTeam = null;
+    proState;
+    proAbort = null;
     /** What the sub-agent is doing, or null when none is running. */
     subagent = null;
     saveError = null;
@@ -108,11 +171,16 @@ export class WebSession {
     pendingApproval = null;
     /** Reviewer count while an automated review runs, null otherwise. */
     reviewing = null;
-    constructor(source, model) {
+    constructor(source, model, mode = "standard") {
+        this.mode = mode;
+        if (mode === "pro")
+            this.proPreset = requireProPreset(source.pro_preset ?? defaultProPreset());
         this.model = model;
-        this.approvalMode = normalizeApprovalMode(source.approval_mode ?? loadConfig().approval_mode);
+        this.approvalMode = normalizeApprovalMode(source.approval_mode ?? loadConfig(this.mode).approval_mode);
         this.provider = source.provider;
-        this.intensity = source.intensity;
+        // A transcript saved before the model's limits existed (or before the model
+        // itself was narrowed) must not replay an unsupported sampling level.
+        this.intensity = mode === "pro" ? source.intensity : intensityForModel(model, source.intensity, loadConfig(this.mode).default_intensity);
         this.dir = source.cwd;
         this.sessionId = source.id;
         this.messages = source.messages.slice();
@@ -137,6 +205,7 @@ export class WebSession {
         if (this.disposed)
             return;
         this.disposed = true;
+        this.proAbort?.abort();
         this.turnToken++;
         this.busy = false;
         if (this.pendingApproval) {
@@ -153,6 +222,8 @@ export class WebSession {
         return this.dir;
     }
     liveConfigure(selection) {
+        if (this.mode === "pro")
+            return { ok: false, error: "choose a Pro preset to change professional models" };
         if (this.disposed)
             return { ok: false, error: "this session has ended" };
         if (this.busy || this.pendingApproval) {
@@ -160,13 +231,37 @@ export class WebSession {
         }
         this.model = { ...selection.model };
         this.provider = selection.provider;
-        this.intensity = selection.intensity;
+        this.intensity = intensityForModel(this.model, selection.intensity, loadConfig(this.mode).default_intensity);
         this.save();
         this.publishLive();
         return { ok: true };
     }
+    liveSetProPreset(preset) {
+        if (this.mode !== "pro" || this.disposed)
+            return { ok: false, error: "this is not an active Pro session" };
+        if (this.busy || this.pendingApproval)
+            return { ok: false, error: "pause the current turn before changing presets" };
+        try {
+            this.proPreset = requireProPreset(preset);
+            const initial = proInitialSelection(this.proPreset);
+            this.model = initial.model;
+            this.provider = initial.provider;
+            this.intensity = initial.intensity;
+            this.proTeam = null;
+            this.proState = undefined;
+            this.save();
+            this.publishLive();
+            return { ok: true };
+        }
+        catch (error) {
+            return { ok: false, error: describeError(error) };
+        }
+    }
     liveMeta() {
         return {
+            ...(this.mode === "pro" ? { pro: this.proState ?? {
+                    preset: this.proPreset, checking: false, checkId: "", models: [], fallbacks: [],
+                } } : {}),
             sessionId: this.sessionId,
             title: this.title(),
             provider: this.provider,
@@ -221,6 +316,7 @@ export class WebSession {
         if (this.paused || (!this.busy && !this.queued))
             return;
         this.paused = true;
+        this.proAbort?.abort();
         this.turnToken++;
         // A queued decision would otherwise keep the promise (and the gate) alive.
         if (this.pendingApproval) {
@@ -231,6 +327,13 @@ export class WebSession {
         this.busy = false;
         this.retainStreamingContent();
         this.subagent = null;
+        if (this.proState)
+            this.proState.checking = false;
+        if (this.mode === "pro") {
+            this.reviewing = null;
+            this.retrying = null;
+            this.planning = false;
+        }
         stopPlan(this.plan);
         this.save();
         this.publishLive();
@@ -267,6 +370,43 @@ export class WebSession {
         this.save();
         this.publishLive();
     }
+    /**
+     * Start a fresh chat in the same working directory, mirroring the terminal's
+     * clear shortcut. The finished transcript is checkpointed first and stays on
+     * disk; this session simply moves on under a new id.
+     */
+    liveClear() {
+        if (this.disposed)
+            return;
+        if (!this.checkpoint.flush())
+            return;
+        this.proAbort?.abort();
+        this.proTeam = null;
+        this.proState = undefined;
+        this.turnToken++;
+        if (this.pendingApproval) {
+            const pending = this.pendingApproval;
+            this.pendingApproval = null;
+            pending.resolve(false);
+        }
+        this.busy = false;
+        this.paused = false;
+        this.queued = null;
+        this.compressing = false;
+        this.retrying = null;
+        this.subagent = null;
+        this.reviewing = null;
+        this.streamingContent = null;
+        this.plan = null;
+        this.planning = false;
+        this.messages = [];
+        this.context = null;
+        this.lastPromptTokens = 0;
+        this.saveError = null;
+        this.sessionId = newSessionId();
+        this.publishLive();
+        this.touch();
+    }
     // ---- turn driving ----------------------------------------------------
     send(text) {
         const trimmed = text.trim();
@@ -310,6 +450,8 @@ export class WebSession {
      * pass, exactly as it did before planning existed.
      */
     async runTurn(token, turnMessages, approvalContext) {
+        if (this.mode === "pro")
+            return this.runProTurn(token, turnMessages, approvalContext);
         await this.autoCompress(token);
         if (token !== this.turnToken || this.paused)
             return;
@@ -341,6 +483,127 @@ export class WebSession {
         }
         this.onTurnFinished();
     }
+    /** Freeze one resolved team per task, plan first, then give the whole brief to main. */
+    async runProTurn(token, turnMessages, approvalContext) {
+        const cancelled = () => token !== this.turnToken || this.paused || this.disposed;
+        const controller = new AbortController();
+        this.proAbort = controller;
+        this.proTeam = null;
+        this.plan = null;
+        this.proState = { preset: this.proPreset, checking: true, checkId: randomUUID(), models: [], fallbacks: [] };
+        this.publishLive();
+        try {
+            const resolved = await resolveProTeam(this.proPreset, {
+                signal: controller.signal,
+                onUsage: (usage) => {
+                    if (!cancelled()) {
+                        this.tokens.prompt += usage.prompt;
+                        this.tokens.completion += usage.completion;
+                    }
+                },
+            });
+            if (cancelled())
+                return;
+            this.proState.models = Object.values(resolved.models).map((entry) => ({
+                role: entry.role, provider: entry.provider, model: entry.model.name, intensity: entry.intensity, tier: entry.tier,
+            }));
+            this.proState.fallbacks = resolved.fallbacks;
+            this.proState.checking = false;
+            const team = new ProAgentTeam({
+                models: resolved.models, maxDepth: proMaxRecursionDepth(), cwd: this.dir, cancelled,
+                approve: (name, args) => this.requestApproval(name, args, {
+                    ...approvalContext, context: captureApprovalContext(this.turnView(turnMessages)).context,
+                }),
+                execute: (name, args) => executeTool(name, args, this.dir),
+                onProgress: (label) => { if (!cancelled()) {
+                    this.subagent = label;
+                    this.publishLive();
+                } },
+                onUsage: (usage) => {
+                    if (!cancelled()) {
+                        this.tokens.prompt += usage.prompt;
+                        this.tokens.completion += usage.completion;
+                    }
+                },
+                onRetry: (notice) => { if (!cancelled()) {
+                    this.retrying = notice;
+                    this.publishLive();
+                } },
+            });
+            this.proTeam = team;
+            const main = resolved.models.main_model;
+            this.model = main.model;
+            this.provider = main.provider;
+            this.intensity = main.intensity;
+            this.publishLive();
+            this.planning = true;
+            this.publishLive();
+            const planning = await team.call("plan_model", buildPlannerInput({
+                request: approvalContext.prompt, cwd: this.dir, transcript: planTranscript(turnMessages),
+            }), "Plan the task before execution. Do not modify files or execute commands.", 0, true);
+            if (cancelled())
+                return;
+            this.planning = false;
+            this.subagent = null;
+            this.retrying = null;
+            if (!planning.trim() || /\[Error:|\[Sub-agent .*without.*report/.test(planning)) {
+                throw new Error(`Pro planning failed: ${planning}`);
+            }
+            this.plan = parsePlan(planning);
+            if (!this.plan) {
+                // Standard planning skips single actions; Pro plans every task.
+                try {
+                    const single = JSON.parse(planning.trim().replace(/^```(?:json)?\s*|\s*```$/g, ""));
+                    if (single.steps?.length === 1 && typeof single.steps[0].title === "string" && single.steps[0].title.trim()) {
+                        this.plan = { goal: String(single.goal ?? "").slice(0, 240), steps: [{
+                                    title: single.steps[0].title.slice(0, 160), detail: String(single.steps[0].detail ?? "").slice(0, 400), status: "pending",
+                                }] };
+                    }
+                }
+                catch { /* A useful prose plan can still guide the main agent. */ }
+            }
+            await this.autoCompress(token);
+            if (cancelled())
+                return;
+            this.messages.push({ role: "assistant", content: this.plan ? planMessage(this.plan) : planning });
+            this.save();
+            this.publishLive();
+            const directive = `The planning agent produced this plan for the current user request:\n${planning}\n\n` +
+                "Execute the complete task, using the appropriate professional agents for reasoning, frontend, backend and modeling work. Verify the result and report the outcome.";
+            if (this.plan?.steps.length)
+                this.setStep(0, "active");
+            const finished = await this.agentLoop(this.buildApiMessages(this.turnView(turnMessages), directive), token, approvalContext);
+            if (cancelled())
+                return;
+            if (this.plan) {
+                if (finished)
+                    for (let i = 0; i < this.plan.steps.length; i++)
+                        this.setStep(i, "done");
+                else
+                    this.setStep(0, "failed");
+            }
+        }
+        catch (error) {
+            if (cancelled())
+                return;
+            this.proState.checking = false;
+            this.proState.error = describeError(error);
+            if (error instanceof ProPreflightError)
+                this.proState.fallbacks = error.fallbacks;
+            throw error;
+        }
+        finally {
+            if (!cancelled()) {
+                this.planning = false;
+                this.subagent = null;
+                this.retrying = null;
+                this.proState.checking = false;
+                this.publishLive();
+            }
+        }
+        if (!cancelled())
+            this.onTurnFinished();
+    }
     /**
      * The transcript this turn may see: the messages it started with plus what it
      * added since. A user message queued while the turn runs belongs to the next
@@ -366,7 +629,7 @@ export class WebSession {
      * a plan must improve a turn, never be a new way for one to fail.
      */
     async makePlan(token) {
-        if (!planFirstEnabled())
+        if (!planFirstEnabled(this.mode))
             return null;
         const request = lastRequestText(this.messages);
         if (!request.trim())
@@ -424,8 +687,9 @@ export class WebSession {
     buildApiMessages(messages = this.messages, directive = "") {
         // A step directive extends the system prompt: the plan is an instruction, not
         // something the user just said.
+        const prompt = this.mode === "pro" ? loadProPrompt("main_model") : loadPrompt();
         const api = [
-            { role: "system", content: directive ? `${loadPrompt()}\n\n${directive}` : loadPrompt() },
+            { role: "system", content: directive ? `${prompt}\n\n${directive}` : prompt },
         ];
         for (const m of modelHistory(messages, this.context)) {
             if (m.role === "user" || m.role === "assistant") {
@@ -443,12 +707,13 @@ export class WebSession {
      * the caller owns the turn's end because a planned turn runs this per step.
      */
     async agentLoop(apiMessages, token, approvalContext) {
-        const tools = getToolDefinitions();
+        const tools = this.mode === "pro" ? getProToolDefinitions() : getToolDefinitions();
+        const team = this.proTeam;
         try {
             for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
                 if (token !== this.turnToken || this.paused)
                     return false;
-                const client = new LLMClient(this.model, this.provider, this.intensity);
+                const client = team ? team.client("main_model") : new LLMClient(this.model, this.provider, this.intensity);
                 let text = "";
                 this.streamingContent = "";
                 this.publishLive();
@@ -488,6 +753,7 @@ export class WebSession {
                         role: "assistant",
                         content: text,
                         reasoning_content: client.reasoningContent ?? "",
+                        ...(client.anthropicContent.length ? { anthropic_content: client.anthropicContent } : {}),
                         ...(toolCalls.length > 0
                             ? {
                                 tool_calls: toolCalls.map((call) => ({
@@ -501,8 +767,13 @@ export class WebSession {
                 }
                 this.save();
                 this.publishLive();
-                if (toolCalls.length === 0)
-                    break;
+                if (toolCalls.length === 0) {
+                    if (this.mode === "pro" && !text.trim()) {
+                        this.messages.push({ role: "assistant", content: "[Error: Pro main model returned an empty completion.]" });
+                        return false;
+                    }
+                    return !/\[Error:/.test(text);
+                }
                 for (const call of toolCalls) {
                     if (token !== this.turnToken || this.paused)
                         return false;
@@ -554,7 +825,9 @@ export class WebSession {
                 }
                 this.save();
             }
-            return true;
+            if (this.mode === "pro")
+                this.messages.push({ role: "assistant", content: "[Error: Pro main agent reached its tool round limit before completion.]" });
+            return false;
         }
         catch (err) {
             if (token !== this.turnToken)
@@ -588,15 +861,28 @@ export class WebSession {
         const risk = assessToolCall(tool, args, this.dir);
         if (!risk)
             return { approved: true, source: "prompt", reason: "routine call" };
+        const approvalToken = this.turnToken;
+        const team = this.proTeam;
         const gate = new ApprovalGate({
             askHuman: () => new Promise((resolve) => {
+                if (this.mode === "pro" && (approvalToken !== this.turnToken || this.paused || this.disposed)) {
+                    resolve(false);
+                    return;
+                }
                 this.pendingApproval = { tool, args, risk, resolve };
                 this.publishLive();
             }),
             reviewer: () => this.reviewerModel(),
+            ...(this.mode === "pro" && team ? {
+                createReviewerClient: () => team.client("confirm_model"),
+                reviewerSystemPrompt: () => loadProPrompt("confirm_model"),
+                cancelled: () => approvalToken !== this.turnToken || this.paused || this.disposed,
+            } : {}),
             autoApprovalEnabled: () => this.approvalMode === "auto",
-            extremeAutoApprovalEnabled: () => loadConfig().auto_approve_extreme_risk === true,
+            extremeAutoApprovalEnabled: () => loadConfig(this.mode).auto_approve_extreme_risk === true,
             onReview: (info) => {
+                if (this.mode === "pro" && (approvalToken !== this.turnToken || this.paused || this.disposed))
+                    return;
                 this.reviewing = info
                     ? {
                         total: info.total, round: info.round ?? 1, rounds: info.rounds ?? 1,
@@ -610,7 +896,7 @@ export class WebSession {
     }
     /** Reviewer model: `approval_model` when set, otherwise the chat model. */
     reviewerModel() {
-        const name = String(loadConfig().approval_model ?? "").trim();
+        const name = String(loadConfig(this.mode).approval_model ?? "").trim();
         const found = name ? findModel(name) : null;
         if (found) {
             const usable = resolveModel(found.model.name, found.provider);
@@ -627,6 +913,13 @@ export class WebSession {
      * approval gate and abort signal live.
      */
     async runTool(name, args, toolMsg, token, apiMessages, approvalContext) {
+        if (this.mode === "pro" && (name === "call_pro_agent" || name === DELEGATE_TOOL)) {
+            const team = this.proTeam;
+            if (!team)
+                return "[Error: Pro models have not passed preflight]";
+            return team.call(String(args.role ?? "backend_output_model"), String(args.task ?? ""), `${typeof args.context === "string" ? args.context : ""}\n\nCurrent user request: ${approvalContext.prompt}\n` +
+                captureApprovalContext(apiMessages).context, 1);
+        }
         if (name !== DELEGATE_TOOL)
             return executeTool(name, args, this.dir);
         return this.delegate(args, toolMsg, token, apiMessages, approvalContext);
@@ -674,7 +967,14 @@ export class WebSession {
     }
     // ---- compression -----------------------------------------------------
     compressThreshold() {
-        return contextCompressionThreshold(this.provider, this.model);
+        if (this.mode === "pro") {
+            const setting = this.proState?.models.find((entry) => entry.role === "main_model");
+            const tier = loadProModels().tier.find((entry) => entry.name === setting?.tier);
+            const capacity = tier?.["model-setting"].find((entry) => entry.type === "main_model")?.context_window;
+            if (capacity)
+                return Math.max(1, Math.floor(capacity * 0.8));
+        }
+        return contextCompressionThreshold(this.provider, this.model, this.mode);
     }
     async autoCompress(token) {
         const threshold = this.compressThreshold();
@@ -696,7 +996,7 @@ export class WebSession {
         this.publishLive();
         let summary = "";
         try {
-            summary = await new LLMClient(this.model, this.provider, this.intensity).summarize(transcript, {
+            summary = await (this.proTeam?.client("main_model") ?? new LLMClient(this.model, this.provider, this.intensity)).summarize(transcript, {
                 cancelled: () => token !== this.turnToken || this.paused,
             });
         }
@@ -725,7 +1025,7 @@ export class WebSession {
                 return line.length > 80 ? `${line.slice(0, 77)}…` : line;
             }
         }
-        return "Resumed chat";
+        return "";
     }
     retainStreamingContent() {
         if (this.streamingContent) {
@@ -749,7 +1049,7 @@ export class WebSession {
         if (chat.length === 0)
             return true;
         try {
-            this.sessionId = saveSession(chat, this.model.name, this.provider, this.intensity, this.dir, this.sessionId, this.tokens, this.context, this.approvalMode, this.plan);
+            this.sessionId = saveSession(chat, this.model.name, this.provider, this.intensity, this.dir, this.sessionId, this.tokens, this.context, this.approvalMode, this.plan, this.mode, this.proPreset ?? undefined);
             this.saveError = null;
             return true;
         }