@xingjisoft/neutrino 0.2.1 → 0.4.0

package/dist/llm/client.js

@@ -1,4 +1,4 @@
-import { INTENSITY_PARAMS, modelUsesReasoning } from "../config.js";
+import { INTENSITY_PARAMS, intensityForModel, modelUsesReasoning } from "../config.js";
 import { HttpStatusError, describeError, isRetriableFailure, retryDelayMs, retryPolicy, waitBeforeRetry, } from "./retry.js";
 // Callers import `describeError` from this module; it lives next to the
 // classification helpers that share the same "is this a dropped connection?"
@@ -25,12 +25,21 @@ const SUMMARY_SYSTEM_PROMPT = "You compress the conversation history of an AI co
  */
 async function postStream(url, init) {
     const controller = new AbortController();
+    const abort = () => controller.abort(init.signal?.reason);
+    if (init.signal?.aborted)
+        abort();
+    else
+        init.signal?.addEventListener("abort", abort, { once: true });
     const timer = setTimeout(() => controller.abort(new Error(`request timed out after ${CONNECT_TIMEOUT_MS / 1000}s`)), CONNECT_TIMEOUT_MS);
     try {
         return await fetch(url, { ...init, signal: controller.signal });
     }
     finally {
         clearTimeout(timer);
+        // The caller's stream controller is aborted in streamTurn's finally, so
+        // this listener also covers cancellation after the response headers.
+        if (controller.signal.aborted)
+            init.signal?.removeEventListener("abort", abort);
     }
 }
 /** The policy a stream will actually use, with any per-call override applied. */
@@ -47,6 +56,7 @@ async function pauseForRetry(attempt, policy, error, options) {
     return waitBeforeRetry(attempt - 1, policy, options.cancelled);
 }
 export class LLMClient {
+    professional;
     model;
     provider;
     intensity;
@@ -60,11 +70,18 @@ export class LLMClient {
      * call, so the agent loops attach it to that message.
      */
     reasoningContent = "";
-    constructor(model, provider, intensity) {
+    anthropicContent = [];
+    constructor(model, provider, intensity, options = {}) {
         this.model = model;
         this.provider = provider;
-        this.intensity = intensity;
-        const params = INTENSITY_PARAMS[intensity] ?? INTENSITY_PARAMS["High"];
+        this.professional = options.professional === true;
+        // Final safety net: even a stale UI, a saved session or a hand-edited
+        // selection can never send a level this model does not declare.
+        this.intensity = this.professional ? intensity.trim().toLowerCase() || "high" : intensityForModel(model, intensity);
+        const sampling = this.professional
+            ? this.intensity.charAt(0).toUpperCase() + this.intensity.slice(1)
+            : this.intensity;
+        const params = INTENSITY_PARAMS[sampling] ?? INTENSITY_PARAMS["High"];
         this.temperature = params.temperature;
         this.top_p = params.top_p;
     }
@@ -105,15 +122,37 @@ export class LLMClient {
         this.toolCalls = [];
         this.usage = null;
         this.reasoningContent = "";
+        this.anthropicContent = [];
+        const controller = new AbortController();
+        const abort = () => controller.abort(options.signal?.reason);
+        if (options.signal?.aborted)
+            abort();
+        else
+            options.signal?.addEventListener("abort", abort, { once: true });
+        const cancelled = () => controller.signal.aborted || options.cancelled?.() === true;
+        const timer = options.cancelled ? setInterval(() => {
+            if (options.cancelled?.())
+                controller.abort();
+        }, 100) : null;
+        const requestOptions = { ...options, signal: controller.signal, cancelled };
         try {
+            if (controller.signal.aborted)
+                return;
             if (this.provider === "Anthropic") {
-                yield* this.streamAnthropic(messages, options);
+                yield* this.streamAnthropic(messages, tools, requestOptions);
                 return;
             }
-            yield* this.streamOpenAI(messages, tools, options);
+            yield* this.streamOpenAI(messages, tools, requestOptions);
         }
         catch (e) {
-            yield `\n[Error: ${describeError(e)}]`;
+            if (!cancelled())
+                yield `\n[Error: ${describeError(e)}]`;
+        }
+        finally {
+            if (timer)
+                clearInterval(timer);
+            options.signal?.removeEventListener("abort", abort);
+            controller.abort();
         }
     }
     /**
@@ -135,7 +174,7 @@ export class LLMClient {
             this.reasoningContent = "";
             let produced = false;
             try {
-                for await (const token of this.openAIAttempt(messages, tools)) {
+                for await (const token of this.openAIAttempt(messages, tools, options)) {
                     produced = true;
                     yield token;
                 }
@@ -172,7 +211,7 @@ export class LLMClient {
             : message);
     }
     /** A single streaming attempt; see `streamOpenAI` for the retry policy. */
-    async *openAIAttempt(messages, tools) {
+    async *openAIAttempt(messages, tools, options) {
         const url = this.model.url.replace(/\/+$/, "") + "/chat/completions";
         const headers = {
             "Content-Type": "application/json",
@@ -181,10 +220,12 @@ export class LLMClient {
         const payload = {
             model: this.model.name,
             messages: this.wireMessages(messages),
-            temperature: this.temperature,
-            top_p: this.top_p,
-            stream: true,
-            stream_options: { include_usage: true },
+            ...(this.professional ? { reasoning_effort: this.intensity } : {
+                temperature: this.temperature,
+                top_p: this.top_p,
+            }),
+            stream: this.model.supports_streaming !== false,
+            ...(this.model.supports_streaming !== false ? { stream_options: { include_usage: true } } : {}),
         };
         if (tools && tools.length)
             payload.tools = tools;
@@ -192,6 +233,7 @@ export class LLMClient {
             method: "POST",
             headers,
             body: JSON.stringify(payload),
+            signal: options.signal,
         });
         if (!resp.ok) {
             // Thrown rather than printed: a 502/503/504/429 is as transient as a
@@ -200,6 +242,24 @@ export class LLMClient {
             const body = await resp.text().catch(() => "");
             throw new HttpStatusError(resp.status, body.slice(0, 500));
         }
+        if (this.model.supports_streaming === false || resp.headers.get("content-type")?.includes("application/json")) {
+            const body = await resp.json();
+            const message = body.choices?.[0]?.message;
+            if (!message)
+                throw new Error("endpoint did not return a valid model completion");
+            this.reasoningContent = message.reasoning_content ?? message.reasoning ?? "";
+            this.toolCalls = (message.tool_calls ?? []).map((call) => ({
+                id: call.id, name: call.function.name, arguments: call.function.arguments,
+            }));
+            if (body.usage) {
+                const prompt = body.usage.prompt_tokens ?? 0;
+                const completion = body.usage.completion_tokens ?? 0;
+                this.usage = { prompt, completion, total: body.usage.total_tokens ?? prompt + completion };
+            }
+            if (message.content)
+                yield message.content;
+            return;
+        }
         if (!resp.body) {
             yield "\n[Error: empty response body]";
             return;
@@ -288,13 +348,14 @@ export class LLMClient {
             .map((k) => toolCallsByIndex[k]);
     }
     /** Anthropic counterpart of `streamOpenAI`, with the same retry policy. */
-    async *streamAnthropic(messages, options) {
+    async *streamAnthropic(messages, tools, options) {
         const policy = resolvePolicy(options);
         for (let attempt = 1;; attempt++) {
             this.toolCalls = [];
+            this.anthropicContent = [];
             let produced = false;
             try {
-                for await (const token of this.anthropicAttempt(messages)) {
+                for await (const token of this.anthropicAttempt(messages, tools, options)) {
                     produced = true;
                     yield token;
                 }
@@ -309,34 +370,71 @@ export class LLMClient {
         }
     }
     /** A single streaming attempt; see `streamAnthropic` for the retry policy. */
-    async *anthropicAttempt(messages) {
+    async *anthropicAttempt(messages, tools, options) {
         const url = this.model.url.replace(/\/+$/, "") + "/messages";
         const headers = {
             "Content-Type": "application/json",
             "x-api-key": this.model.api_key,
             "anthropic-version": "2023-06-01",
         };
-        let systemMsg;
+        const systemMessages = [];
         const chatMessages = [];
         for (const m of messages) {
-            if (m.role === "system")
-                systemMsg = m.content ?? "";
+            if (m.role === "system") {
+                if (m.content)
+                    systemMessages.push(m.content);
+                continue;
+            }
+            let blocks;
+            const role = m.role === "assistant" ? "assistant" : "user";
+            if (m.role === "tool") {
+                blocks = [{ type: "tool_result", tool_use_id: m.tool_call_id, content: m.content ?? "" }];
+            }
+            else if (m.role === "assistant" && m.anthropic_content?.length) {
+                blocks = m.anthropic_content;
+            }
+            else {
+                blocks = m.content ? [{ type: "text", text: m.content }] : [];
+                for (const raw of m.tool_calls ?? []) {
+                    const call = raw;
+                    let input;
+                    try {
+                        input = JSON.parse(call.function.arguments);
+                    }
+                    catch {
+                        input = { value: call.function.arguments };
+                    }
+                    blocks.push({ type: "tool_use", id: call.id, name: call.function.name, input });
+                }
+            }
+            if (!blocks.length)
+                continue;
+            const previous = chatMessages.at(-1);
+            if (previous?.role === role)
+                previous.content.push(...blocks);
             else
-                chatMessages.push({ role: m.role, content: m.content ?? "" });
+                chatMessages.push({ role, content: [...blocks] });
         }
         const payload = {
             model: this.model.name,
             messages: chatMessages,
             max_tokens: 4096,
-            temperature: this.temperature,
-            stream: true,
+            ...(this.professional ? { output_config: { effort: this.intensity } } : { temperature: this.temperature }),
+            stream: this.model.supports_streaming !== false,
         };
-        if (systemMsg)
-            payload.system = systemMsg;
+        if (systemMessages.length)
+            payload.system = systemMessages.join("\n\n");
+        if (tools?.length)
+            payload.tools = tools.map((tool) => ({
+                name: tool.function.name,
+                description: tool.function.description,
+                input_schema: tool.function.parameters,
+            }));
         const resp = await postStream(url, {
             method: "POST",
             headers,
             body: JSON.stringify(payload),
+            signal: options.signal,
         });
         if (!resp.ok) {
             // Thrown rather than printed: a 502/503/504/429 is as transient as a
@@ -345,6 +443,21 @@ export class LLMClient {
             const body = await resp.text().catch(() => "");
             throw new HttpStatusError(resp.status, body.slice(0, 500));
         }
+        if (this.model.supports_streaming === false || resp.headers.get("content-type")?.includes("application/json")) {
+            const body = await resp.json();
+            if (!Array.isArray(body.content))
+                throw new Error("endpoint did not return a valid model completion");
+            this.captureAnthropicContent(body.content);
+            if (body.usage) {
+                const prompt = body.usage.input_tokens ?? 0;
+                const completion = body.usage.output_tokens ?? 0;
+                this.usage = { prompt, completion, total: prompt + completion };
+            }
+            for (const block of body.content)
+                if (block.type === "text" && typeof block.text === "string")
+                    yield block.text;
+            return;
+        }
         if (!resp.body) {
             yield "\n[Error: empty response body]";
             return;
@@ -353,6 +466,8 @@ export class LLMClient {
         const decoder = new TextDecoder();
         let buf = "";
         let stopped = false;
+        const blocks = {};
+        const toolArguments = {};
         try {
             while (!stopped) {
                 const { done, value } = await reader.read();
@@ -378,11 +493,42 @@ export class LLMClient {
                     catch {
                         continue;
                     }
-                    const type = chunk.type;
+                    const event = chunk;
+                    const type = event.type;
+                    if (type === "error")
+                        throw new Error(event.error?.message ?? "Anthropic stream failed");
+                    if (type === "message_start") {
+                        const input = event.message?.usage?.input_tokens ?? 0;
+                        const output = event.message?.usage?.output_tokens ?? 0;
+                        this.usage = { prompt: input, completion: output, total: input + output };
+                    }
+                    else if (type === "message_delta" && event.usage) {
+                        const prompt = this.usage?.prompt ?? 0;
+                        const completion = event.usage.output_tokens ?? this.usage?.completion ?? 0;
+                        this.usage = { prompt, completion, total: prompt + completion };
+                    }
+                    else if (type === "content_block_start") {
+                        blocks[event.index ?? 0] = { ...event.content_block };
+                        if (event.content_block?.type === "tool_use")
+                            toolArguments[event.index ?? 0] = "";
+                        if (typeof event.content_block?.text === "string" && event.content_block.text)
+                            yield event.content_block.text;
+                    }
                     if (type === "content_block_delta") {
-                        const text = chunk.delta?.text;
-                        if (text)
-                            yield text;
+                        const index = event.index ?? 0;
+                        const block = blocks[index] ??= { type: "text", text: "" };
+                        if (event.delta?.text) {
+                            block.text = String(block.text ?? "") + event.delta.text;
+                            yield event.delta.text;
+                        }
+                        if (event.delta?.partial_json)
+                            toolArguments[index] = (toolArguments[index] ?? "") + event.delta.partial_json;
+                        if (event.delta?.thinking) {
+                            block.thinking = String(block.thinking ?? "") + event.delta.thinking;
+                            this.reasoningContent += event.delta.thinking;
+                        }
+                        if (event.delta?.signature)
+                            block.signature = String(block.signature ?? "") + event.delta.signature;
                     }
                     else if (type === "message_stop") {
                         stopped = true;
@@ -399,5 +545,28 @@ export class LLMClient {
                 // Already closed / errored; nothing left to release.
             }
         }
+        const content = Object.keys(blocks).map(Number).sort((a, b) => a - b).map((index) => {
+            const block = blocks[index];
+            if (block.type === "tool_use") {
+                const raw = toolArguments[index];
+                if (raw) {
+                    try {
+                        block.input = JSON.parse(raw);
+                    }
+                    catch {
+                        block.input = { value: raw };
+                    }
+                }
+            }
+            return block;
+        });
+        this.captureAnthropicContent(content);
+    }
+    captureAnthropicContent(blocks) {
+        this.anthropicContent = blocks;
+        this.reasoningContent = blocks.filter((block) => block.type === "thinking").map((block) => String(block.thinking ?? "")).join("");
+        this.toolCalls = blocks.filter((block) => block.type === "tool_use").map((block) => ({
+            id: String(block.id ?? ""), name: String(block.name ?? ""), arguments: JSON.stringify(block.input ?? {}),
+        }));
     }
 }

package/dist/llm/subagent.js

@@ -44,10 +44,43 @@ export async function runSubAgent(options) {
     ];
     let report = "";
     let calls = 0;
+    let lastPromptTokens = 0;
     const aborted = (rounds) => ({ report, aborted: true, exhausted: false, rounds, calls });
     for (let round = 1; round <= maxRounds; round++) {
         if (options.cancelled?.())
             return aborted(round - 1);
+        const capacity = options.contextWindow;
+        if (capacity && messages.length > 2 &&
+            Math.max(lastPromptTokens, Math.ceil(JSON.stringify(messages).length / 3)) >= capacity * 0.8) {
+            // Only split at an assistant boundary: every retained tool result must
+            // still have the assistant/tool_calls message that produced it.
+            const starts = messages.flatMap((message, index) => index >= 2 && message.role === "assistant" ? [index] : []);
+            let keep = starts.length > 1 ? starts.at(-1) : messages.length;
+            if (JSON.stringify(messages.slice(keep)).length > capacity)
+                keep = messages.length;
+            const head = messages.slice(2, keep);
+            if (head.length) {
+                options.onProgress?.("compressing context");
+                const compressor = options.createClient();
+                const transcript = JSON.stringify(head);
+                // A single tool can produce more text than the role can hold. Bound
+                // the compression request itself, retaining its beginning and end.
+                const budget = Math.max(256, Math.floor(capacity * 0.6));
+                const input = transcript.length > budget
+                    ? `${transcript.slice(0, Math.floor(budget / 2))}\n[Earlier activity truncated for compression]\n${transcript.slice(-Math.floor(budget / 2))}`
+                    : transcript;
+                const summary = await compressor.summarize(input, { cancelled: options.cancelled, onRetry: options.onRetry });
+                if (compressor.usage)
+                    options.onUsage?.(compressor.usage);
+                if (options.cancelled?.())
+                    return aborted(round - 1);
+                messages.splice(2, keep - 2, {
+                    role: "assistant",
+                    content: summary || "Earlier specialist activity was compressed. Inspect the working directory for any evidence needed to continue.",
+                });
+                lastPromptTokens = 0;
+            }
+        }
         options.onProgress?.("thinking");
         const client = options.createClient();
         let content = "";
@@ -59,8 +92,10 @@ export async function runSubAgent(options) {
                 return aborted(round - 1);
             content += chunk;
         }
-        if (client.usage)
+        if (client.usage) {
             options.onUsage?.(client.usage);
+            lastPromptTokens = client.usage.prompt;
+        }
         const toolCalls = client.toolCalls;
         if (content.trim())
             report = content.trim();
@@ -71,6 +106,7 @@ export async function runSubAgent(options) {
                 // A tool-call turn must carry the thinking that produced it back to a
                 // thinking-mode endpoint, or its next request is rejected.
                 ...(client.reasoningContent ? { reasoning_content: client.reasoningContent } : {}),
+                ...(client.anthropicContent?.length ? { anthropic_content: client.anthropicContent } : {}),
                 ...(toolCalls.length > 0
                     ? {
                         tool_calls: toolCalls.map((call) => ({

package/dist/pro/agents.js

@@ -0,0 +1,104 @@
+import { LLMClient } from "../llm/client.js";
+import { buildSubAgentTask, formatSubAgentResult, runSubAgent } from "../llm/subagent.js";
+import { DELEGATE_TOOL, getSubAgentToolDefinitions } from "../llm/tools.js";
+import { ACTIVE_PRO_ROLES, PRO_ROLES, loadProPrompt } from "./config.js";
+export const PRO_AGENT_TOOL = "call_pro_agent";
+const CALL_AGENT = {
+    type: "function",
+    function: {
+        name: PRO_AGENT_TOOL,
+        description: "Ask a specialist agent to perform a self-contained task in its own context, using the same working directory and approval gate. " +
+            "Use thinking_model for reasoning, front_output_model for UI, backend_output_model for other code, modeling_model for modeling, " +
+            "plan_model for planning, confirm_model for read-only review, or main_model for coordination. Specialists can call other specialists within the configured recursion depth.",
+        parameters: {
+            type: "object",
+            properties: {
+                role: { type: "string", enum: [...ACTIVE_PRO_ROLES] },
+                task: { type: "string", description: "Complete task, expected deliverables and acceptance criteria." },
+                context: { type: "string", description: "Relevant evidence, constraints and decisions; the agent cannot see the parent's conversation." },
+                reason: { type: "string", description: "Why this specialist is needed for the user's request." },
+            },
+            required: ["role", "task", "reason"],
+        },
+    },
+};
+/** All Pro agents can call the same specialists; the runtime enforces depth. */
+export function getProToolDefinitions() {
+    return [...getSubAgentToolDefinitions(), CALL_AGENT];
+}
+/** A resolved model team belongs to one task; substitutions never touch disk. */
+export class ProAgentTeam {
+    options;
+    maxDepth;
+    constructor(options) {
+        this.options = options;
+        this.maxDepth = Number.isSafeInteger(options.maxDepth) && options.maxDepth > 0 ? options.maxDepth : 10;
+    }
+    client(role) {
+        const selection = this.options.models[role];
+        if (!selection)
+            throw new Error(`Pro agent ${role} is unavailable`);
+        return new LLMClient(selection.model, selection.provider, selection.intensity, { professional: true });
+    }
+    async call(role, task, context = "", depth = 1, readOnly = false) {
+        if (!PRO_ROLES.includes(role))
+            return "[Error: unknown Pro agent role]";
+        if (role === "genimage_model")
+            return "[Error: image generation is reserved and is not enabled]";
+        if (this.options.cancelled())
+            return "[Pro agent stopped: the turn was paused or replaced.]";
+        if (!Number.isSafeInteger(depth) || depth < 0 || depth > this.maxDepth) {
+            return `[Error: Pro agent recursion limit (${this.maxDepth}) reached. Complete the work without further delegation.]`;
+        }
+        if (typeof task !== "string" || !task.trim())
+            return "[Error: a Pro agent needs a nonempty task]";
+        const selection = this.options.models[role];
+        if (!selection)
+            return `[Error: Pro agent ${role} is unavailable]`;
+        // Reviewers are always read-only, including when consulted as specialists.
+        const onlyRead = readOnly || role === "confirm_model";
+        const tools = getProToolDefinitions().filter((tool) => !onlyRead ||
+            ["read_file", "list_files", PRO_AGENT_TOOL].includes(tool.function.name));
+        const names = new Set(tools.map((tool) => tool.function.name));
+        const label = `${role} · ${selection.model.name} · ${depth}/${this.maxDepth}`;
+        try {
+            const result = await runSubAgent({
+                createClient: () => this.client(role),
+                system: `${loadProPrompt(role)}\n\nDelegation depth: ${depth}/${this.maxDepth}. ` +
+                    (onlyRead ? "This consultation is read-only. Do not modify files or execute commands, including through another agent." :
+                        "Use the shared approval gate for every tool call. Return a self-contained report with changes, evidence and unresolved work."),
+                task: buildSubAgentTask({ task, context, cwd: this.options.cwd }),
+                tools,
+                contextWindow: selection.context_window,
+                approve: (name, args) => {
+                    if (!names.has(name) && name !== DELEGATE_TOOL)
+                        return Promise.resolve({
+                            approved: false, source: "input", reason: "This tool is not available to this Pro agent",
+                        });
+                    return this.options.approve(name, args);
+                },
+                execute: async (name, args) => {
+                    if (name === PRO_AGENT_TOOL || name === DELEGATE_TOOL) {
+                        const nextRole = typeof args.role === "string" ? args.role : "backend_output_model";
+                        const nextTask = typeof args.task === "string" ? args.task : "";
+                        const nextContext = typeof args.context === "string" ? args.context : "";
+                        const report = await this.call(nextRole, nextTask, nextContext, depth + 1, onlyRead);
+                        this.options.onProgress?.(label);
+                        return report;
+                    }
+                    if (!names.has(name))
+                        return "[Error: tool is unavailable to this Pro agent]";
+                    return this.options.execute(name, args);
+                },
+                cancelled: this.options.cancelled,
+                onUsage: this.options.onUsage,
+                onRetry: this.options.onRetry,
+                onProgress: (activity) => this.options.onProgress?.(`${label} · ${activity}`),
+            });
+            return formatSubAgentResult(result);
+        }
+        finally {
+            this.options.onProgress?.(null);
+        }
+    }
+}

package/dist/pro/config.js

@@ -0,0 +1,88 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { PRO_DIR, loadConfig } from "../config.js";
+/** Provider URLs and credentials stay in the shared, ordinary model catalogue. */
+export const PRO_MODEL_FILE = path.join(PRO_DIR, "model.json");
+const ASSET_DIR = fileURLToPath(new URL("../../assets/pro/", import.meta.url));
+export const PRO_ROLES = [
+    "main_model", "thinking_model", "front_output_model", "backend_output_model",
+    "confirm_model", "genimage_model", "plan_model", "modeling_model",
+];
+export const ACTIVE_PRO_ROLES = PRO_ROLES.filter((role) => role !== "genimage_model");
+export const PRO_ROLE_LABELS = {
+    main_model: "Main", thinking_model: "Reasoning", front_output_model: "Frontend",
+    backend_output_model: "Backend", confirm_model: "Approval", genimage_model: "Image generation",
+    plan_model: "Planning", modeling_model: "Modeling",
+};
+/** Copy the bundled template byte-for-byte, exclusively on first use. */
+export function ensureProModels() {
+    fs.mkdirSync(PRO_DIR, { recursive: true });
+    try {
+        fs.copyFileSync(path.join(ASSET_DIR, "model-template.json"), PRO_MODEL_FILE, fs.constants.COPYFILE_EXCL);
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+}
+export function loadProModels() {
+    ensureProModels();
+    let value;
+    try {
+        value = JSON.parse(fs.readFileSync(PRO_MODEL_FILE, "utf8"));
+    }
+    catch {
+        throw new Error("Pro model.json is not valid JSON; fix ~/.neutrino/pro/model.json");
+    }
+    if (!value || typeof value !== "object" || !Array.isArray(value.tier) ||
+        value.tier.length === 0) {
+        throw new Error("Pro model.json must contain a nonempty tier array");
+    }
+    const names = new Set();
+    for (const preset of value.tier) {
+        if (!preset || typeof preset !== "object" || typeof preset.name !== "string" || !preset.name.trim() ||
+            names.has(preset.name) || typeof preset.chinese_name !== "string" || !Array.isArray(preset["model-setting"])) {
+            throw new Error("Each Pro preset needs a unique name, chinese_name and model-setting array");
+        }
+        names.add(preset.name);
+        const roles = new Set();
+        for (const setting of preset["model-setting"]) {
+            if (!setting || typeof setting !== "object" || !PRO_ROLES.includes(setting.type) || roles.has(setting.type) ||
+                typeof setting.provider !== "string" || (setting.model !== null && typeof setting.model !== "string") ||
+                typeof setting.intensity !== "string" ||
+                !Number.isSafeInteger(setting.context_window) || setting.context_window < 1) {
+                throw new Error(`Invalid model-setting in Pro preset ${preset.name}`);
+            }
+            roles.add(setting.type);
+        }
+    }
+    return value;
+}
+export function requireProPreset(value) {
+    if (typeof value !== "string" || !loadProModels().tier.some((preset) => preset.name === value)) {
+        throw new Error("Unknown Pro preset");
+    }
+    return value;
+}
+export function defaultProPreset() {
+    const presets = loadProModels().tier;
+    const preferred = loadConfig("pro").pro_preset;
+    return presets.find((preset) => preset.name === preferred)?.name ??
+        presets.find((preset) => preset.name === "medium")?.name ??
+        presets.find((preset) => preset.name !== "custom")?.name ?? presets[0].name;
+}
+export const DEFAULT_PRO_RECURSION_DEPTH = 10;
+export const MAX_PRO_RECURSION_DEPTH = 100;
+export function proMaxRecursionDepth() {
+    const configured = loadConfig("pro").pro_max_recursion_depth;
+    return typeof configured === "number" && Number.isSafeInteger(configured) &&
+        configured >= 1 && configured <= MAX_PRO_RECURSION_DEPTH ? configured : DEFAULT_PRO_RECURSION_DEPTH;
+}
+/** Every agent prompt lives in the requested assets/pro directory. */
+export function loadProPrompt(role) {
+    if (!PRO_ROLES.includes(role))
+        throw new Error("Unknown Pro role");
+    return fs.readFileSync(path.join(ASSET_DIR, "common.txt"), "utf8") + "\n\n" +
+        fs.readFileSync(path.join(ASSET_DIR, `${role}.txt`), "utf8");
+}