neoctl 0.2.53 → 0.2.54

package/dist/web/index.d.ts

@@ -11,7 +11,7 @@ import { QueryEngine } from "../core/query-engine.js";
 import { type AppPromptStore } from "../app/app-prompt.js";
 import { type ModelProviderName } from "../model/config.js";
 import { CommunicationLogger, LoggingModelGateway } from "../model/communication-logger.js";
-import type { ModelUsage, ReasoningConfig, ReasoningEffort } from "../model/model-gateway.js";
+import type { ModelUsage, ReasoningConfig } from "../model/model-gateway.js";
 import { ToolRegistry } from "../tools/registry.js";
 import type { Tool, ToolUseContext } from "../tools/tool.js";
 import { type ToolPresentation } from "../tools/tool-catalog.js";
@@ -451,6 +451,7 @@ export declare class WebRepl {
     isDemo(engine?: QueryEngine): boolean;
     startDemo(expectedSessionId: string): Promise<WebActionResult>;
     private recordDemoInput;
+    private readonly settingsListener;
     constructor(runtime: WebRuntime, demoOptions?: {
         wait?: DemoWait;
     });
@@ -726,6 +727,7 @@ export declare class WebRepl {
         modelSettings: {
             model: string | undefined;
             reasoning: ReasoningConfig | null | undefined;
+            imageInput: boolean | undefined;
         };
         pendingSessionSettings: import("../core/query.js").SessionSettingsPatch & {
             sessionPrompt?: import("../core/session-settings-prompt.js").SessionPromptState | null;
@@ -735,12 +737,16 @@ export declare class WebRepl {
         catalog: {
             commands: import("../repl/commands.js").ReplCommandDefinition[];
             modelIds: string[];
+            modelProtocol: "openai" | "anthropic" | undefined;
             modelReasoning: {
-                [k: string]: ReasoningEffort[];
+                [k: string]: string[];
+            };
+            modelReasoningEnabled: {
+                [k: string]: boolean;
             };
             reasoning: string[];
             envPath: string;
-        } | undefined;
+        };
         interactive: {
             sessions: boolean;
             login: LoginFormPayload;

package/dist/web/index.js

@@ -1,4 +1,11 @@
 #!/usr/bin/env node
+import { trackSettingsGateway } from "../model/settings-sync.js";
+import { observeModelSettings } from "../model/settings-sync.js";
+import { modelProtocols } from "../model/context-window.js";
+import { isReasoningEffort } from "../model/model-gateway.js";
+import { ModelSettingsStore, compositionModelConfig } from "../model/settings-store.js";
+import { registerCompositionTools } from "../model/composition-runtime.js";
+import { handleModelSettingsRequest } from "./model-settings-api.js";
 import { paginateSessions, sessionPageOptions } from "../session/session-pagination.js";
 import { applyToolInputChanges } from "../model/tool-input-stream.js";
 import { toolActivity } from "./tool-activity.js";
@@ -29,7 +36,7 @@ import { loadDefaultDotEnvFiles } from "../model/env.js";
 import { readModelProviderConfig } from "../model/config.js";
 import { findModelMetadata, loadModelCatalog, reasoningEffortsForModel, resolveContextWindowTokens } from "../model/context-window.js";
 import { CommunicationLogger, LoggingModelGateway } from "../model/communication-logger.js";
-import { createModelGatewayFromConfig, createModelGatewayFromProcessEnv } from "../model/provider-factory.js";
+import { createModelGatewayFromConfig } from "../model/provider-factory.js";
 import { ToolRegistry, isToolEnabledByDefault } from "../tools/registry.js";
 import { builtinToolPresentation, toolPresentationForSource } from "../tools/tool-catalog.js";
 import { editTool, writeTool } from "../tools/builtins/edit-tool.js";
@@ -147,9 +154,13 @@ function parseWebArgs(argv) {
 }
 export async function createWebRuntime(options = {}) {
     const envLoad = loadDefaultDotEnvFiles({ override: true });
-    const modelConfig = readModelProviderConfig(process.env);
+    loadModelCatalog();
+    const settingsStore = new ModelSettingsStore();
+    const appliedSettings = settingsStore.read()?.applied;
+    const settingsRevisions = new WeakMap();
+    const modelConfig = appliedSettings ? compositionModelConfig(appliedSettings.composition, appliedSettings.connections) : readModelProviderConfig(process.env);
     const communicationLogger = new CommunicationLogger();
-    const modelGateway = new LoggingModelGateway(createModelGatewayFromProcessEnv(process.env), communicationLogger);
+    const modelGateway = trackSettingsGateway(new LoggingModelGateway(createModelGatewayFromConfig(modelConfig), communicationLogger), appliedSettings?.revision);
     const taskStore = new TaskStore();
     const pluginCatalog = normalizeWebRuntimePlugins(options.externalPlugins);
     const pluginOverrides = normalizePluginOverrides(options.sessionPluginOverrides, pluginCatalog);
@@ -179,6 +190,13 @@ export async function createWebRuntime(options = {}) {
     registerTool(createLoadImageTool(), { source: "builtin" });
     if (modelConfig?.provider === "openai")
         registerTool(createOpenAIImageGenerationTool(), { source: "builtin" });
+    if (appliedSettings)
+        registerCompositionTools(tools, appliedSettings.composition, appliedSettings.connections);
+    for (const name of ["web_search", "image_create"]) {
+        const tool = tools.get(name);
+        if (tool)
+            catalogTool(tool, { source: "builtin" });
+    }
     registerTool(planTool, { source: "builtin" });
     const frameworkFeedback = new FrameworkFeedbackStore(options.frameworkFeedbackDir);
     registerTool(createFrameworkFeedbackTool(frameworkFeedback), { source: "builtin" });
@@ -217,6 +235,41 @@ export async function createWebRuntime(options = {}) {
         tools,
         contextManagerFactory: (cwd) => new DefaultContextManager({ cwd }),
         acquireTurnResources: (engine) => acquireWebPluginTurn(runtime, true, engine),
+        beforeQuery: (engine) => {
+            const applied = settingsStore.read()?.applied;
+            const captureTools = () => {
+                const snapshot = tools.clone();
+                compositionToolSnapshots.set(engine, snapshot);
+                const session = engine.snapshot().session?.sessionId;
+                if (session)
+                    sessionCompositionSnapshots.set(session, new WeakRef(engine));
+            };
+            if (!applied) {
+                if (!compositionToolSnapshots.has(engine))
+                    captureTools();
+                return;
+            }
+            const revision = applied.revision;
+            if (settingsRevisions.get(engine) === revision)
+                return;
+            const config = compositionModelConfig(applied.composition, applied.connections);
+            if (!config)
+                return;
+            const gateway = trackSettingsGateway(new LoggingModelGateway(createModelGatewayFromConfig(config), communicationLogger), revision);
+            engine.setModelProvider({ modelGateway: gateway, model: config.model, reasoning: config.defaultReasoning });
+            effectiveModelProviders.set(engine, config.provider);
+            registerCompositionTools(tools, applied.composition, applied.connections);
+            for (const name of ["web_search", "image_create"]) {
+                const tool = tools.get(name);
+                if (tool)
+                    catalogTool(tool, { source: "builtin" });
+            }
+            runtime.modelGateway = gateway;
+            runtime.agentRuntime.modelGateway = gateway;
+            runtime.defaultReasoning = config.defaultReasoning;
+            settingsRevisions.set(engine, revision);
+            captureTools();
+        },
         refreshTools: (engine) => {
             if (runtime)
                 refreshRuntimePlugins(runtime, engine);
@@ -353,6 +406,8 @@ function resolveRuntimePluginOverrides(runtime, engine, sessionId = engine.snaps
     return support.overrides;
 }
 /** Children acquire independent tools/prompts; they never refresh the parent's in-flight context. */
+const compositionToolSnapshots = new WeakMap();
+const sessionCompositionSnapshots = new Map();
 function acquireWebPluginTurn(runtime, main, engine = runtime.engine, sessionId) {
     if (main) {
         refreshRuntimePlugins(runtime, engine);
@@ -364,6 +419,22 @@ function acquireWebPluginTurn(runtime, main, engine = runtime.engine, sessionId)
     try {
         const catalog = normalizeWebRuntimePlugins(snapshot?.plugins ?? support?.resolveCatalog?.() ?? support?.catalog);
         const tools = buildPluginRegistry(runtime, catalog, overrides);
+        const owner = sessionId ? sessionCompositionSnapshots.get(sessionId)?.deref() : engine;
+        const frozen = owner ? compositionToolSnapshots.get(owner)?.clone() : undefined;
+        if (sessionId && !owner)
+            sessionCompositionSnapshots.delete(sessionId);
+        if (frozen)
+            for (const name of ["web_search", "image_create"]) {
+                const enabled = tools.isEnabled(name) ?? frozen.isEnabled(name);
+                frozen.setEnabled(name, true);
+                const tool = frozen.get(name);
+                tools.unregister(name);
+                if (tool) {
+                    tools.register(tool);
+                    if (enabled === false)
+                        tools.setEnabled(name, false);
+                }
+            }
         return { tools, release: snapshot?.release ?? (() => { }),
             ...(!main ? { promptSections: [...(support?.basePromptSections ?? []), ...activeWebRuntimePlugins(catalog, overrides).flatMap(plugin => plugin.promptSections ?? [])] } : {}) };
     }
@@ -747,9 +818,17 @@ export class WebRepl {
                 this.demoMessageQueues.delete(engine);
         }
     }
+    settingsListener = () => {
+        if (this.deletingSession)
+            return;
+        this.runtime.engine.refreshModelConfigurationIfIdle();
+        for (const subscriber of this.subscribers)
+            this.send(subscriber, "sync", this.snapshot());
+    };
     constructor(runtime, demoOptions = {}) {
         this.runtime = runtime;
         this.demoOptions = demoOptions;
+        observeModelSettings(this.settingsListener);
         const lineId = { current: 0 };
         this.lines = initialLines(runtime, lineId);
         this.lineId = lineId.current;
@@ -830,6 +909,7 @@ export class WebRepl {
     }
     snapshot(includeCatalog = false) {
         const backgroundTasks = this.backgroundTasks();
+        this.runtime.engine.refreshModelConfigurationIfIdle?.();
         const engineSnapshot = this.runtime.engine.snapshot();
         const pendingSessionSettings = this.runtime.engine.getPendingSessionSettings?.() ?? {};
         // Include retained reasoning alongside a queued model. Explicit undefined is
@@ -855,11 +935,11 @@ export class WebRepl {
             backgroundSessionRunCount: this.backgroundSessionRuns.size,
             runningSessionIds: this.runningSessionIds(),
             session: engineSnapshot.session,
-            modelSettings: { model: engineSnapshot.model, reasoning: engineSnapshot.reasoning },
+            modelSettings: { model: engineSnapshot.model, reasoning: engineSnapshot.reasoning, imageInput: findModelMetadata(engineSnapshot.model || "")?.imageInput },
             pendingSessionSettings,
             fastMode: this.runtime.engine.isFastMode(),
             appPrompt: this.runtime.engine.getAppPrompt(),
-            catalog: includeCatalog ? webCatalog(this.runtime) : undefined,
+            catalog: webCatalog(this.runtime),
             interactive: includeCatalog ? webInteractiveCatalog(this.runtime) : undefined,
         };
     }
@@ -1457,11 +1537,15 @@ export class WebRepl {
         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))) {
+        if (reasoning !== undefined && (typeof reasoning !== "string" || !(reasoning === "default" || reasoning === "off" || isReasoningEffort(reasoning)))) {
             return actionFailure("MODEL_INVALID", "invalid reasoning effort");
         }
         const engine = this.runtime.engine;
         const nextModel = model.trim();
+        const provider = effectiveModelProviders.get(engine) ?? readModelProviderConfig()?.provider;
+        const metadata = (engine.getActiveModelCatalog?.() ?? loadModelCatalog()).models.find(m => m.modelIds.includes(nextModel));
+        if (metadata && provider && !modelProtocols(metadata).includes(provider))
+            return actionFailure("MODEL_INVALID", "模型不支持当前主连接接口");
         const current = { ...engine.getModelSettings(), ...engine.getPendingSessionSettings() };
         const argument = reasoning;
         const validationError = validateModelReasoningArgument(nextModel, argument);
@@ -1567,9 +1651,10 @@ export class WebRepl {
     async saveLogin(providerValue, values) {
         const provider = parseLoginProvider(providerValue);
         if (!provider)
-            return actionFailure("LOGIN_INVALID", "provider must be openai");
+            return actionFailure("LOGIN_INVALID", "provider must be openai or anthropic");
         if (dockerEnabled() && !values.apiKey?.trim()) {
-            values = { ...values, apiKey: parseEnvFileSafe(this.runtime.envPath).OPENAI_API_KEY || process.env.OPENAI_API_KEY || "" };
+            const key = provider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
+            values = { ...values, apiKey: parseEnvFileSafe(this.runtime.envPath)[key] || process.env[key] || "" };
         }
         const payload = { ...createLoginFormPayload(this.runtime.envPath, provider), provider, values };
         const validationError = validateLoginFormPayload(payload);
@@ -2963,6 +3048,8 @@ export async function handleWebRequest(req, res, router) {
         }
         if (req.method === "POST" && url.pathname === "/api/sessions/new")
             return sendJson(res, await repl.newSession());
+        if (await handleModelSettingsRequest(req, res, url))
+            return;
         if (req.method === "GET" && url.pathname === "/api/login")
             return sendJson(res, repl.loginForm(url.searchParams.get("provider") ?? undefined));
         if (req.method === "POST" && url.pathname === "/api/login") {
@@ -3083,12 +3170,18 @@ function sanitizeWebAttachments(value) {
         return [];
     });
 }
+const effectiveModelProviders = new WeakMap();
 function webCatalog(runtime) {
-    const modelIds = [...new Set(loadModelCatalog().models.flatMap((model) => model.modelIds.length ? model.modelIds : [model.id]))].sort((left, right) => left.localeCompare(right));
+    const catalog = runtime.engine.getActiveModelCatalog?.() ?? loadModelCatalog();
+    const provider = effectiveModelProviders.get(runtime.engine) ?? readModelProviderConfig()?.provider;
+    const models = catalog.models.filter(model => !provider || modelProtocols(model).includes(provider));
+    const modelIds = [...new Set(models.flatMap(model => model.modelIds.length ? model.modelIds : [model.id]))].sort((left, right) => left.localeCompare(right, "en", { numeric: true }));
     return {
         commands: replCommandDefinitions,
         modelIds,
-        modelReasoning: Object.fromEntries(modelIds.map(model => [model, reasoningEffortsForModel(model) ?? []])),
+        modelProtocol: provider,
+        modelReasoning: Object.fromEntries(modelIds.map(model => [model, reasoningEffortsForModel(model, catalog) ?? []])),
+        modelReasoningEnabled: Object.fromEntries(models.flatMap(m => m.modelIds.map(id => [id, m.reasoning !== false]))),
         reasoning: ["none", "minimal", "low", "medium", "high", "xhigh", "max", "default", "off"],
         envPath: runtime.envPath,
     };
@@ -3448,28 +3541,32 @@ async function persistModelCommandSettings(runtime, command, reasoningUpdate) {
     return { providerChanged: targetProvider !== currentProvider };
 }
 function currentModelProvider() {
-    return "openai";
+    return parseLoginProvider(process.env.MODEL_PROVIDER) ?? "openai";
 }
 function parseLoginProvider(value) {
-    if (value === "openai")
+    if (value === "openai" || value === "anthropic")
         return value;
     return undefined;
 }
-const LOGIN_PROVIDERS = ["openai"];
+const LOGIN_PROVIDERS = ["openai", "anthropic"];
 const SHARED_LOGIN_FIELDS = [
     { key: "reasoningEffort", label: "Reasoning effort", envKey: "MODEL_REASONING_EFFORT", scope: "shared", options: ["", "off", "none", "minimal", "low", "medium", "high", "xhigh", "max"] },
-    { key: "reasoningSummary", label: "Reasoning summary", envKey: "MODEL_REASONING_SUMMARY", scope: "shared", options: ["", "auto", "concise", "detailed"] },
-    { key: "maxOutputTokens", label: "Max output tokens", envKey: "MODEL_MAX_OUTPUT_TOKENS", scope: "shared" },
+    { key: "maxOutputTokens", label: "Max output tokens", envKey: "MODEL_MAX_OUTPUT_TOKENS", scope: "shared", placeholder: "Leave empty for server default" },
     { key: "timeoutMs", label: "Timeout ms", envKey: "MODEL_TIMEOUT_MS", scope: "shared", placeholder: "120000" },
     { key: "streamIdleTimeoutMs", label: "Stream idle timeout ms", envKey: "MODEL_STREAM_IDLE_TIMEOUT_MS", scope: "shared", placeholder: "120000" },
     { key: "maxRetries", label: "Max retries", envKey: "MODEL_MAX_RETRIES", scope: "shared", placeholder: "2" },
 ];
 const LOGIN_FIELD_DEFINITIONS = {
+    anthropic: [
+        { key: "apiKey", label: "API / CPA key", envKey: "ANTHROPIC_API_KEY", scope: "provider", required: true, secret: true },
+        { key: "baseUrl", label: "Base URL", envKey: "ANTHROPIC_BASE_URL", scope: "provider", placeholder: "https://api.anthropic.com" },
+        { key: "model", label: "Model", envKey: "ANTHROPIC_MODEL", scope: "provider", required: true, placeholder: "claude-sonnet-4-6" },
+        ...SHARED_LOGIN_FIELDS.map(field => field.key === "reasoningEffort" ? { ...field, options: ["", "off", "none", "low", "medium", "high", "xhigh", "max"] } : field.key === "maxOutputTokens" ? { ...field, placeholder: "8192" } : field),
+    ],
     openai: [
         { key: "apiKey", label: "API key", envKey: "OPENAI_API_KEY", scope: "provider", required: true, secret: true, placeholder: "sk-..." },
         { key: "baseUrl", label: "Base URL", envKey: "OPENAI_BASE_URL", scope: "provider", placeholder: "https://api.openai.com" },
         { key: "model", label: "Model", envKey: "OPENAI_MODEL", scope: "provider", required: true, placeholder: "gpt-5.6" },
-        { key: "endpoint", label: "Endpoint", envKey: "OPENAI_ENDPOINT", scope: "provider", placeholder: "auto", options: ["auto", "responses", "chat"] },
         ...SHARED_LOGIN_FIELDS,
     ],
 };
@@ -3496,18 +3593,16 @@ function loginValuesForProvider(provider, env) {
         values.baseUrl = defaultBaseUrlForLoginProvider(provider);
     if (!values.model)
         values.model = defaultModelForLoginProvider(provider);
-    if (provider === "openai" && !values.endpoint)
-        values.endpoint = "auto";
     return values;
 }
-function guessLoginProvider(_env) {
-    return currentModelProvider();
+function guessLoginProvider(env) {
+    return env.ANTHROPIC_API_KEY && !env.OPENAI_API_KEY ? "anthropic" : currentModelProvider();
 }
-function defaultBaseUrlForLoginProvider(_provider) {
-    return "https://api.openai.com";
+function defaultBaseUrlForLoginProvider(provider) {
+    return provider === "anthropic" ? "https://api.anthropic.com" : "https://api.openai.com";
 }
-function defaultModelForLoginProvider(_provider) {
-    return "gpt-5.6";
+function defaultModelForLoginProvider(provider) {
+    return provider === "anthropic" ? "claude-sonnet-4-6" : "gpt-5.6";
 }
 function validateLoginFormPayload(payload) {
     for (const field of LOGIN_FIELD_DEFINITIONS[payload.provider]) {
@@ -3522,9 +3617,6 @@ function validateLoginFormPayload(payload) {
         if (value && !Number.isFinite(Number(value)))
             return `${fieldKey} must be a number.`;
     }
-    if (payload.provider === "openai" && payload.values.endpoint === "chat" && payload.values.reasoningSummary?.trim()) {
-        return "Reasoning summary requires the Responses API endpoint.";
-    }
     return undefined;
 }
 async function saveLoginPayloadToEnv(payload) {
@@ -3559,8 +3651,8 @@ function stripEnvQuotes(value) {
         return value.slice(1, -1);
     return value;
 }
-function modelEnvKeyForProvider(_provider) {
-    return "OPENAI_MODEL";
+function modelEnvKeyForProvider(provider) {
+    return provider === "anthropic" ? "ANTHROPIC_MODEL" : "OPENAI_MODEL";
 }
 function envValueForReasoning(reasoning) {
     if (reasoning === null)