hoomanjs 1.32.0 → 1.34.0

package/dist/configure/app.js

@@ -3,14 +3,14 @@ import { useCallback, useEffect, useMemo, useState } from "react";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { Box, Text, useApp, useInput } from "ink";
 import { LlmProvider, } from "../core/config.js";
-import { McpOAuthConfigSchema, } from "../core/mcp/oauth/types.js";
+import { McpOAuthConfigSchema } from "../core/mcp/oauth/types.js";
 import { McpTransportSchema, } from "../core/mcp/types.js";
-import { instructionsMdPath, } from "../core/utils/paths.js";
+import { instructionsMdPath } from "../core/utils/paths.js";
 import { BusyScreen } from "./components/BusyScreen.js";
 import { MenuScreen } from "./components/MenuScreen.js";
 import { PromptForm } from "./components/PromptForm.js";
 import { openFileInEditor } from "./open-in-editor.js";
-import { DEFAULT_INSTRUCTIONS, compactJson, folderNameForSkill, paramsPreview, normalizeOptional, noticeColor, parseOptionalBoolean, parseNumber, parseObjectRecord, maskSensitiveParamsForDisplay, parseStringArray, parseStringRecord, transportSummary, truncate, } from "./utils.js";
+import { DEFAULT_INSTRUCTIONS, compactJson, folderNameForSkill, paramsPreview, normalizeOptional, noticeColor, parseOptionalBoolean, parseNumber, maskSensitiveParamsForDisplay, parseStringArray, parseStringRecord, transportSummary, truncate, } from "./utils.js";
 const PROMPT_LABELS = {
     behaviour: "Behaviour",
     communication: "Communication",
@@ -24,36 +24,496 @@ const SEARCH_PROVIDER_LABELS = {
     serper: "Serper",
     tavily: "Tavily",
 };
+const MCP_STDIO_FIELDS = [
+    { key: "name", label: "Server name", placeholder: "filesystem" },
+    { key: "command", label: "Command", placeholder: "npx" },
+    {
+        key: "args",
+        label: "Arguments",
+        placeholder: '["-y", "@modelcontextprotocol/server-filesystem"]',
+        note: "Provide a JSON array of strings, or leave as [].",
+    },
+    {
+        key: "env",
+        label: "Environment variables",
+        placeholder: '{"API_KEY":"..."}',
+        note: "Optional JSON object with string values.",
+    },
+    {
+        key: "cwd",
+        label: "Working directory",
+        placeholder: "/absolute/path",
+        note: "Optional working directory for the subprocess.",
+    },
+];
+const MCP_REMOTE_BASE_FIELDS = [
+    { key: "name", label: "Server name", placeholder: "my-remote-server" },
+    { key: "url", label: "URL", placeholder: "https://example.com/mcp" },
+    {
+        key: "headers",
+        label: "Headers",
+        placeholder: '{"Authorization":"Bearer ..."}',
+        note: "Optional JSON object with string values.",
+    },
+    {
+        key: "oauthEnabled",
+        label: "Enable OAuth? (yes/no)",
+        placeholder: "no",
+        note: "Choose yes for servers that use OAuth 2.0/2.1 or dynamic client registration.",
+    },
+];
+const MCP_REMOTE_OAUTH_FIELDS = [
+    { key: "clientId", label: "OAuth client ID", placeholder: "client-id" },
+    {
+        key: "clientSecret",
+        label: "OAuth client secret",
+        placeholder: "secret",
+        note: "Stored in mcp.json only if you enter a value.",
+    },
+    { key: "scopes", label: "OAuth scopes", placeholder: '["read","write"]' },
+    {
+        key: "audiences",
+        label: "OAuth audiences",
+        placeholder: '["https://api.example.com"]',
+    },
+    {
+        key: "callbackPort",
+        label: "OAuth callback port",
+        placeholder: "19876",
+    },
+    {
+        key: "redirectUri",
+        label: "OAuth redirect URI",
+        placeholder: "http://127.0.0.1:19876/mcp/oauth/callback",
+    },
+    {
+        key: "issuer",
+        label: "OAuth issuer",
+        placeholder: "https://auth.example.com",
+    },
+    {
+        key: "authorizationUrl",
+        label: "OAuth authorization URL override",
+        placeholder: "https://auth.example.com/authorize",
+    },
+    {
+        key: "tokenUrl",
+        label: "OAuth token URL override",
+        placeholder: "https://auth.example.com/token",
+    },
+    {
+        key: "registrationUrl",
+        label: "OAuth registration URL override",
+        placeholder: "https://auth.example.com/register",
+    },
+    {
+        key: "tokenParamName",
+        label: "OAuth token param name",
+        placeholder: "access_token",
+    },
+];
+function isTruthyToggle(value) {
+    const normalized = value?.trim().toLowerCase();
+    return normalized !== undefined
+        ? ["y", "yes", "true", "1", "on"].includes(normalized)
+        : false;
+}
+function formatDraftFieldValue(field, value) {
+    const normalized = value ?? "";
+    if (!normalized.trim()) {
+        return "not set";
+    }
+    if (field.key === "clientSecret" ||
+        field.key === "env" ||
+        field.key === "headers") {
+        return paramsPreview(normalized);
+    }
+    return truncate(normalized, 44);
+}
 const SUPPORTED_PROVIDER_TYPES = [
     LlmProvider.Anthropic,
+    LlmProvider.Azure,
     LlmProvider.Bedrock,
     LlmProvider.Google,
     LlmProvider.Groq,
+    LlmProvider.Minimax,
     LlmProvider.Moonshot,
     LlmProvider.Ollama,
     LlmProvider.OpenAI,
+    LlmProvider.OpenRouter,
     LlmProvider.Xai,
 ];
-function providerParamsTemplate(provider) {
+const DEFAULT_MODEL_BY_PROVIDER = {
+    [LlmProvider.Anthropic]: "claude-sonnet-4-6",
+    [LlmProvider.Azure]: "gpt-5.4-mini",
+    [LlmProvider.Bedrock]: "anthropic.claude-sonnet-4-6",
+    [LlmProvider.Google]: "gemini-2.5-flash",
+    [LlmProvider.Groq]: "openai/gpt-oss-20b",
+    [LlmProvider.Minimax]: "MiniMax-M3",
+    [LlmProvider.Moonshot]: "kimi-k2.7-code",
+    [LlmProvider.Ollama]: "gemma4:e4b",
+    [LlmProvider.OpenAI]: "gpt-5.5",
+    [LlmProvider.OpenRouter]: "google/gemma-4-26b-a4b-it:free",
+    [LlmProvider.Xai]: "grok-4.3",
+};
+function defaultModelForProviderType(provider) {
+    return DEFAULT_MODEL_BY_PROVIDER[provider];
+}
+function providerOptionsTemplate(provider) {
     switch (provider) {
         case LlmProvider.Anthropic:
             return { apiKey: "" };
+        case LlmProvider.Azure:
+            return {};
         case LlmProvider.Bedrock:
             return { region: "us-west-2" };
         case LlmProvider.Google:
             return { apiKey: "" };
         case LlmProvider.Groq:
             return { apiKey: "" };
+        case LlmProvider.Minimax:
+            return { apiKey: "" };
         case LlmProvider.Moonshot:
             return { apiKey: "" };
         case LlmProvider.Ollama:
             return {};
         case LlmProvider.OpenAI:
             return { apiKey: "" };
+        case LlmProvider.OpenRouter:
+            return { apiKey: "" };
         case LlmProvider.Xai:
             return { apiKey: "" };
     }
 }
+const PROVIDER_FIELD_DEFINITIONS = {
+    [LlmProvider.Anthropic]: [
+        {
+            key: "apiKey",
+            label: "API key",
+            kind: "string",
+            placeholder: "sk-ant-...",
+            sensitive: true,
+        },
+        {
+            key: "baseURL",
+            label: "Base URL",
+            kind: "string",
+            placeholder: "https://api.anthropic.com",
+        },
+        {
+            key: "headers",
+            label: "Headers",
+            kind: "stringRecord",
+            placeholder: '{"x-my-header":"value"}',
+        },
+        {
+            key: "thinking",
+            label: "Thinking",
+            kind: "anthropicThinking",
+            placeholder: "adaptive",
+            note: 'Allowed: "disabled", "adaptive", or blank to clear.',
+        },
+    ],
+    [LlmProvider.Azure]: [
+        {
+            key: "resourceName",
+            label: "Resource name",
+            kind: "string",
+            placeholder: "your-resource-name",
+            note: "Used to build the Azure OpenAI base URL when `baseURL` is not set.",
+        },
+        {
+            key: "baseURL",
+            label: "Base URL",
+            kind: "string",
+            placeholder: "https://your-resource-name.openai.azure.com/openai",
+            note: "Optional override for the Azure OpenAI endpoint prefix. When set, it takes precedence over `resourceName`.",
+        },
+        {
+            key: "apiKey",
+            label: "API key",
+            kind: "string",
+            placeholder: "...",
+            sensitive: true,
+        },
+        {
+            key: "headers",
+            label: "Headers",
+            kind: "stringRecord",
+            placeholder: '{"x-my-header":"value"}',
+        },
+        {
+            key: "apiVersion",
+            label: "API version",
+            kind: "string",
+            placeholder: "preview",
+            note: "Leave blank to use the AI SDK default API version.",
+        },
+        {
+            key: "useDeploymentBasedUrls",
+            label: "Deployment-based URLs",
+            kind: "optionalBoolean",
+            placeholder: "false",
+            note: "Allowed: yes/no/true/false. Leave blank to use the AI SDK default.",
+        },
+    ],
+    [LlmProvider.Bedrock]: [
+        {
+            key: "region",
+            label: "Region",
+            kind: "string",
+            placeholder: "us-west-2",
+        },
+        {
+            key: "credentials",
+            label: "Static credentials",
+            kind: "bedrockCredentials",
+            note: "Set both access key ID and secret access key together, or leave blank to rely on the AWS default credential chain.",
+        },
+        {
+            key: "sessionToken",
+            label: "Session token",
+            kind: "string",
+            placeholder: "...",
+            sensitive: true,
+        },
+        {
+            key: "apiKey",
+            label: "API key",
+            kind: "string",
+            placeholder: "...",
+            sensitive: true,
+        },
+    ],
+    [LlmProvider.Google]: [
+        {
+            key: "apiKey",
+            label: "API key",
+            kind: "string",
+            placeholder: "...",
+            sensitive: true,
+        },
+    ],
+    [LlmProvider.Groq]: [
+        {
+            key: "apiKey",
+            label: "API key",
+            kind: "string",
+            placeholder: "gsk_...",
+            sensitive: true,
+        },
+        {
+            key: "baseURL",
+            label: "Base URL",
+            kind: "string",
+            placeholder: "https://api.groq.com/openai/v1",
+        },
+        {
+            key: "headers",
+            label: "Headers",
+            kind: "stringRecord",
+            placeholder: '{"x-my-header":"value"}',
+        },
+    ],
+    [LlmProvider.Minimax]: [
+        {
+            key: "apiKey",
+            label: "API key",
+            kind: "string",
+            placeholder: "...",
+            sensitive: true,
+        },
+        {
+            key: "headers",
+            label: "Headers",
+            kind: "stringRecord",
+            placeholder: '{"x-my-header":"value"}',
+        },
+        {
+            key: "thinking",
+            label: "Thinking",
+            kind: "anthropicThinking",
+            placeholder: "adaptive",
+            note: 'Allowed: "disabled", "adaptive", or blank to clear.',
+        },
+    ],
+    [LlmProvider.Moonshot]: [
+        {
+            key: "apiKey",
+            label: "API key",
+            kind: "string",
+            placeholder: "...",
+            sensitive: true,
+        },
+        {
+            key: "baseURL",
+            label: "Base URL",
+            kind: "string",
+            placeholder: "https://api.moonshot.ai/v1",
+            note: "Leave blank to use the default Moonshot API base URL.",
+        },
+        {
+            key: "headers",
+            label: "Headers",
+            kind: "stringRecord",
+            placeholder: '{"x-my-header":"value"}',
+        },
+    ],
+    [LlmProvider.Ollama]: [
+        {
+            key: "baseURL",
+            label: "Base URL",
+            kind: "string",
+            placeholder: "http://127.0.0.1:11434",
+        },
+        {
+            key: "thinking",
+            label: "Thinking",
+            kind: "ollamaThinking",
+            placeholder: "medium",
+            note: 'Allowed: yes/no/true/false or "high", "medium", "low". Leave blank to clear.',
+        },
+    ],
+    [LlmProvider.OpenAI]: [
+        {
+            key: "apiKey",
+            label: "API key",
+            kind: "string",
+            placeholder: "sk-...",
+            sensitive: true,
+        },
+        {
+            key: "baseURL",
+            label: "Base URL",
+            kind: "string",
+            placeholder: "https://api.openai.com/v1",
+        },
+        {
+            key: "headers",
+            label: "Headers",
+            kind: "stringRecord",
+            placeholder: '{"x-my-header":"value"}',
+        },
+    ],
+    [LlmProvider.OpenRouter]: [
+        {
+            key: "apiKey",
+            label: "API key",
+            kind: "string",
+            placeholder: "sk-or-...",
+            sensitive: true,
+        },
+        {
+            key: "baseURL",
+            label: "Base URL",
+            kind: "string",
+            placeholder: "https://openrouter.ai/api/v1",
+            note: "Leave blank to use the default OpenRouter API base URL.",
+        },
+        {
+            key: "headers",
+            label: "Headers",
+            kind: "stringRecord",
+            placeholder: '{"HTTP-Referer":"https://example.com","X-Title":"Hooman"}',
+            note: "Optional extra headers such as attribution metadata for OpenRouter.",
+        },
+    ],
+    [LlmProvider.Xai]: [
+        {
+            key: "apiKey",
+            label: "API key",
+            kind: "string",
+            placeholder: "...",
+            sensitive: true,
+        },
+        {
+            key: "baseURL",
+            label: "Base URL",
+            kind: "string",
+            placeholder: "https://api.x.ai/v1",
+        },
+        {
+            key: "headers",
+            label: "Headers",
+            kind: "stringRecord",
+            placeholder: '{"x-my-header":"value"}',
+        },
+    ],
+};
+const LLM_FIELD_DEFINITIONS = [
+    {
+        key: "temperature",
+        label: "Temperature",
+        kind: "optionalNumber",
+        placeholder: "0.7",
+        note: "Leave blank to clear.",
+    },
+    {
+        key: "maxTokens",
+        label: "Max tokens",
+        kind: "optionalInteger",
+        placeholder: "4096",
+        note: "Leave blank to clear.",
+    },
+];
+function formatTypedFieldValue(definition, value) {
+    if (value === undefined) {
+        return "not set";
+    }
+    if (definition.sensitive) {
+        return "[REDACTED]";
+    }
+    if (definition.kind === "bedrockCredentials") {
+        return value ? "[REDACTED]" : "not set";
+    }
+    if (definition.kind === "stringRecord") {
+        return paramsPreview(value);
+    }
+    return truncate(String(value), 44);
+}
+function parseTypedFieldValue(input, definition) {
+    switch (definition.kind) {
+        case "string":
+            return normalizeOptional(input);
+        case "stringRecord":
+            return parseStringRecord(input, definition.label);
+        case "optionalBoolean":
+            return parseOptionalBoolean(input, definition.label);
+        case "optionalNumber":
+            return normalizeOptional(input) === undefined
+                ? undefined
+                : parseNumber(input, definition.label);
+        case "optionalInteger":
+            return normalizeOptional(input) === undefined
+                ? undefined
+                : parseNumber(input, definition.label, {
+                    integer: true,
+                    min: 1,
+                });
+        case "bedrockCredentials":
+            return undefined;
+        case "anthropicThinking": {
+            const value = normalizeOptional(input);
+            if (value === undefined) {
+                return undefined;
+            }
+            if (value === "disabled" || value === "adaptive") {
+                return value;
+            }
+            throw new Error(`${definition.label} must be "disabled" or "adaptive".`);
+        }
+        case "ollamaThinking": {
+            const value = normalizeOptional(input);
+            if (value === undefined) {
+                return undefined;
+            }
+            if (value === "high" || value === "medium" || value === "low") {
+                return value;
+            }
+            return parseOptionalBoolean(value, definition.label);
+        }
+    }
+}
 /** On/off display for tool rows (`Tool • Yes` / `Tool • No`). */
 const yesNo = (on) => (on ? "Yes" : "No");
 export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, }) {
@@ -63,6 +523,7 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
     const [notice, setNotice] = useState(null);
     const [busyMessage, setBusyMessage] = useState(null);
     const [revision, setRevision] = useState(0);
+    const [mcpDraft, setMcpDraft] = useState(null);
     const [installedSkills, setInstalledSkills] = useState([]);
     const [searchResults, setSearchResults] = useState([]);
     const [mcpAuthStatuses, setMcpAuthStatuses] = useState({});
@@ -138,6 +599,12 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
             setPrompt(null);
             return;
         }
+        if (screen.kind === "mcp-stdio-edit" ||
+            screen.kind === "mcp-remote-edit") {
+            setMcpDraft(null);
+            setScreen({ kind: "mcp" });
+            return;
+        }
         if (screen.kind === "mcp-delete-confirm") {
             setScreen({ kind: "mcp" });
             return;
@@ -154,9 +621,21 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
             setScreen({ kind: "config-provider-edit", name: screen.name });
             return;
         }
+        if (screen.kind === "config-provider-anthropic-thinking" ||
+            screen.kind === "config-provider-ollama-thinking") {
+            setScreen({ kind: "config-provider-edit", name: screen.name });
+            return;
+        }
+        if (screen.kind === "config-provider-add-type") {
+            setScreen({ kind: "config-providers" });
+            return;
+        }
         if (screen.kind !== "home") {
             setScreen({ kind: "home" });
+            return;
         }
+        onExit();
+        exit();
     }, { isActive: true });
     const setSuccess = useCallback((text) => {
         setNotice({ kind: "success", text });
@@ -180,21 +659,33 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
         refresh();
         setSuccess(message);
     }, [config, refresh, setSuccess]);
-    const patchLlm = useCallback((name, patch) => config.llms.map((m) => m.name === name ? { ...m, options: { ...m.options, ...patch } } : m), [config]);
+    const patchLlm = useCallback((name, patch) => config.llms.map((m) => m.name === name
+        ? {
+            ...m,
+            options: {
+                ...m.options,
+                ...patch,
+            },
+        }
+        : m), [config]);
     const renameLlm = useCallback((oldName, newName) => config.llms.map((m) => m.name === oldName ? { ...m, name: newName } : m), [config]);
     const setDefaultLlm = useCallback((name) => config.llms.map((m) => ({ ...m, default: m.name === name })), [config]);
-    const addLlm = useCallback((name) => [
-        ...config.llms,
-        {
-            name,
-            options: {
-                provider: config.providers[0]?.name ?? LlmProvider.Ollama,
-                model: "gemma4:e4b",
-                params: {},
+    const addLlm = useCallback((name) => {
+        const providerName = config.providers[0]?.name ?? "Ollama";
+        const providerType = config.providers.find((provider) => provider.name === providerName)
+            ?.provider ?? LlmProvider.Ollama;
+        return [
+            ...config.llms,
+            {
+                name,
+                provider: providerName,
+                options: {
+                    model: defaultModelForProviderType(providerType),
+                },
+                default: false,
             },
-            default: false,
-        },
-    ], [config]);
+        ];
+    }, [config]);
     const removeLlm = useCallback((name) => config.llms.filter((m) => m.name !== name), [config]);
     const patchProvider = useCallback((name, patch) => config.providers.map((provider) => provider.name === name
         ? {
@@ -202,29 +693,25 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
             options: {
                 ...provider.options,
                 ...patch,
-                params: patch.params ?? provider.options.params,
             },
         }
         : provider), [config]);
     const renameProvider = useCallback((oldName, newName) => ({
         providers: config.providers.map((provider) => provider.name === oldName ? { ...provider, name: newName } : provider),
-        llms: config.llms.map((llm) => llm.options.provider === oldName
+        llms: config.llms.map((llm) => llm.provider === oldName
             ? {
                 ...llm,
-                options: {
-                    ...llm.options,
-                    provider: newName,
-                },
+                provider: newName,
             }
             : llm),
     }), [config]);
-    const addProvider = useCallback((name) => [
+    const addProvider = useCallback((name, provider) => [
         ...config.providers,
         {
             name,
+            provider,
             options: {
-                provider: LlmProvider.Ollama,
-                params: providerParamsTemplate(LlmProvider.Ollama),
+                ...providerOptionsTemplate(provider),
             },
         },
     ], [config]);
@@ -246,307 +733,173 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
             });
         }
     }, [prompt]);
-    const promptForStdio = useCallback((name, initial) => {
-        const mode = initial ? "Edit" : "Add";
-        promptValue({
-            title: `${mode} stdio server`,
-            label: "Command",
-            initialValue: initial?.command ?? "",
-            placeholder: "npx",
-            onSubmit: async (commandValue) => {
-                const command = commandValue.trim();
-                if (!command) {
-                    throw new Error("Command is required.");
-                }
-                promptValue({
-                    title: `${mode} stdio server`,
-                    label: "Arguments",
-                    note: 'Example: ["-y", "@modelcontextprotocol/server-filesystem"]',
-                    initialValue: compactJson(initial?.args ?? []),
-                    placeholder: "[]",
-                    onSubmit: async (argsValue) => {
-                        const args = parseStringArray(argsValue, "Arguments");
-                        promptValue({
-                            title: `${mode} stdio server`,
-                            label: "Environment variables (optional)",
-                            initialValue: initial?.env ? compactJson(initial.env) : "",
-                            placeholder: '{"API_KEY":"..."}',
-                            onSubmit: async (envValue) => {
-                                const env = parseStringRecord(envValue, "Environment variables");
-                                promptValue({
-                                    title: `${mode} stdio server`,
-                                    label: "Working directory (optional)",
-                                    initialValue: initial?.cwd ?? "",
-                                    placeholder: "/absolute/path",
-                                    onSubmit: async (cwdValue) => {
-                                        const transport = McpTransportSchema.parse({
-                                            type: "stdio",
-                                            command,
-                                            ...(args.length > 0 ? { args } : {}),
-                                            ...(env && Object.keys(env).length > 0 ? { env } : {}),
-                                            ...(normalizeOptional(cwdValue)
-                                                ? { cwd: normalizeOptional(cwdValue) }
-                                                : {}),
-                                        });
-                                        if (initial) {
-                                            mcpConfig.update(name, transport);
-                                            setSuccess(`Updated MCP server "${name}".`);
-                                        }
-                                        else {
-                                            mcpConfig.add(name, transport);
-                                            setSuccess(`Added MCP server "${name}".`);
-                                        }
-                                        setPrompt(null);
-                                        setScreen({ kind: "mcp" });
-                                        refresh();
-                                    },
-                                });
-                            },
-                        });
-                    },
-                });
-            },
+    const persistMcpTransport = useCallback((currentName, nextName, transport) => {
+        if (!nextName) {
+            throw new Error("Server name is required.");
+        }
+        if (currentName && currentName !== nextName && mcpConfig.get(nextName)) {
+            throw new Error(`MCP server "${nextName}" already exists.`);
+        }
+        if (!currentName) {
+            mcpConfig.add(nextName, transport);
+            setSuccess(`Added MCP server "${nextName}".`);
+        }
+        else if (currentName === nextName) {
+            mcpConfig.update(currentName, transport);
+            setSuccess(`Updated MCP server "${currentName}".`);
+        }
+        else {
+            mcpConfig.add(nextName, transport);
+            mcpConfig.remove(currentName);
+            setSuccess(`Renamed MCP server "${currentName}" to "${nextName}".`);
+        }
+        setMcpDraft(null);
+        setScreen({ kind: "mcp" });
+        refresh();
+    }, [mcpConfig, refresh, setSuccess]);
+    const openMcpStdioEditor = useCallback((currentName, initial) => {
+        setMcpDraft({
+            name: currentName ?? "",
+            command: initial?.command ?? "",
+            args: compactJson(initial?.args ?? []),
+            env: initial?.env ? compactJson(initial.env) : "",
+            cwd: initial?.cwd ?? "",
         });
-    }, [mcpConfig, promptValue, refresh, setSuccess]);
-    const promptForRemote = useCallback((name, type, initial) => {
-        const mode = initial ? "Edit" : "Add";
-        const persistRemote = (url, headers, oauth) => {
-            const transport = McpTransportSchema.parse({
-                type,
-                url,
-                ...(headers && Object.keys(headers).length > 0 ? { headers } : {}),
-                ...(oauth ? { oauth } : {}),
-            });
-            if (initial) {
-                mcpConfig.update(name, transport);
-                setSuccess(`Updated MCP server "${name}".`);
-            }
-            else {
-                mcpConfig.add(name, transport);
-                setSuccess(`Added MCP server "${name}".`);
-            }
-            setPrompt(null);
-            setScreen({ kind: "mcp" });
-            refresh();
-        };
-        const promptForOAuthDetails = (url, headers, oauthEnabled) => {
-            if (!oauthEnabled) {
-                persistRemote(url, headers, undefined);
-                return;
-            }
-            promptValue({
-                title: `${mode} ${type} server`,
-                label: "OAuth client ID (optional)",
-                initialValue: initial?.oauth?.clientId ?? "",
-                placeholder: "client-id",
-                onSubmit: async (clientIdValue) => {
-                    promptValue({
-                        title: `${mode} ${type} server`,
-                        label: "OAuth client secret (optional)",
-                        initialValue: initial?.oauth?.clientSecret ?? "",
-                        placeholder: "secret",
-                        note: "Stored in mcp.json only if you enter a value.",
-                        onSubmit: async (clientSecretValue) => {
-                            promptValue({
-                                title: `${mode} ${type} server`,
-                                label: "OAuth scopes (optional)",
-                                initialValue: initial?.oauth?.scopes
-                                    ? compactJson(initial.oauth.scopes)
-                                    : "",
-                                placeholder: '["read","write"]',
-                                onSubmit: async (scopesValue) => {
-                                    promptValue({
-                                        title: `${mode} ${type} server`,
-                                        label: "OAuth audiences (optional)",
-                                        initialValue: initial?.oauth?.audiences
-                                            ? compactJson(initial.oauth.audiences)
-                                            : "",
-                                        placeholder: '["https://api.example.com"]',
-                                        onSubmit: async (audiencesValue) => {
-                                            promptValue({
-                                                title: `${mode} ${type} server`,
-                                                label: "OAuth callback port (optional)",
-                                                initialValue: initial?.oauth?.callbackPort !== undefined
-                                                    ? String(initial.oauth.callbackPort)
-                                                    : "",
-                                                placeholder: "19876",
-                                                onSubmit: async (callbackPortValue) => {
-                                                    promptValue({
-                                                        title: `${mode} ${type} server`,
-                                                        label: "OAuth redirect URI (optional)",
-                                                        initialValue: initial?.oauth?.redirectUri ?? "",
-                                                        placeholder: "http://127.0.0.1:19876/mcp/oauth/callback",
-                                                        onSubmit: async (redirectUriValue) => {
-                                                            promptValue({
-                                                                title: `${mode} ${type} server`,
-                                                                label: "OAuth issuer (optional)",
-                                                                initialValue: initial?.oauth?.issuer ?? "",
-                                                                placeholder: "https://auth.example.com",
-                                                                onSubmit: async (issuerValue) => {
-                                                                    promptValue({
-                                                                        title: `${mode} ${type} server`,
-                                                                        label: "OAuth authorization URL override (optional)",
-                                                                        initialValue: initial?.oauth?.authorizationUrl ?? "",
-                                                                        placeholder: "https://auth.example.com/authorize",
-                                                                        onSubmit: async (authorizationUrlValue) => {
-                                                                            promptValue({
-                                                                                title: `${mode} ${type} server`,
-                                                                                label: "OAuth token URL override (optional)",
-                                                                                initialValue: initial?.oauth?.tokenUrl ?? "",
-                                                                                placeholder: "https://auth.example.com/token",
-                                                                                onSubmit: async (tokenUrlValue) => {
-                                                                                    promptValue({
-                                                                                        title: `${mode} ${type} server`,
-                                                                                        label: "OAuth registration URL override (optional)",
-                                                                                        initialValue: initial?.oauth
-                                                                                            ?.registrationUrl ?? "",
-                                                                                        placeholder: "https://auth.example.com/register",
-                                                                                        onSubmit: async (registrationUrlValue) => {
-                                                                                            promptValue({
-                                                                                                title: `${mode} ${type} server`,
-                                                                                                label: "OAuth token param name (optional)",
-                                                                                                initialValue: initial?.oauth
-                                                                                                    ?.tokenParamName ?? "",
-                                                                                                placeholder: "access_token",
-                                                                                                onSubmit: async (tokenParamNameValue) => {
-                                                                                                    const scopes = parseStringArray(scopesValue, "OAuth scopes");
-                                                                                                    const audiences = parseStringArray(audiencesValue, "OAuth audiences");
-                                                                                                    const callbackPort = normalizeOptional(callbackPortValue) !== undefined
-                                                                                                        ? parseNumber(callbackPortValue, "OAuth callback port", {
-                                                                                                            integer: true,
-                                                                                                            min: 1,
-                                                                                                            max: 65535,
-                                                                                                        })
-                                                                                                        : undefined;
-                                                                                                    const oauth = McpOAuthConfigSchema.parse({
-                                                                                                        enabled: true,
-                                                                                                        ...(normalizeOptional(clientIdValue)
-                                                                                                            ? {
-                                                                                                                clientId: normalizeOptional(clientIdValue),
-                                                                                                            }
-                                                                                                            : {}),
-                                                                                                        ...(normalizeOptional(clientSecretValue)
-                                                                                                            ? {
-                                                                                                                clientSecret: normalizeOptional(clientSecretValue),
-                                                                                                            }
-                                                                                                            : {}),
-                                                                                                        ...(scopes.length > 0
-                                                                                                            ? { scopes }
-                                                                                                            : {}),
-                                                                                                        ...(audiences.length >
-                                                                                                            0
-                                                                                                            ? { audiences }
-                                                                                                            : {}),
-                                                                                                        ...(callbackPort !==
-                                                                                                            undefined
-                                                                                                            ? { callbackPort }
-                                                                                                            : {}),
-                                                                                                        ...(normalizeOptional(redirectUriValue)
-                                                                                                            ? {
-                                                                                                                redirectUri: normalizeOptional(redirectUriValue),
-                                                                                                            }
-                                                                                                            : {}),
-                                                                                                        ...(normalizeOptional(issuerValue)
-                                                                                                            ? {
-                                                                                                                issuer: normalizeOptional(issuerValue),
-                                                                                                            }
-                                                                                                            : {}),
-                                                                                                        ...(normalizeOptional(authorizationUrlValue)
-                                                                                                            ? {
-                                                                                                                authorizationUrl: normalizeOptional(authorizationUrlValue),
-                                                                                                            }
-                                                                                                            : {}),
-                                                                                                        ...(normalizeOptional(tokenUrlValue)
-                                                                                                            ? {
-                                                                                                                tokenUrl: normalizeOptional(tokenUrlValue),
-                                                                                                            }
-                                                                                                            : {}),
-                                                                                                        ...(normalizeOptional(registrationUrlValue)
-                                                                                                            ? {
-                                                                                                                registrationUrl: normalizeOptional(registrationUrlValue),
-                                                                                                            }
-                                                                                                            : {}),
-                                                                                                        ...(normalizeOptional(tokenParamNameValue)
-                                                                                                            ? {
-                                                                                                                tokenParamName: normalizeOptional(tokenParamNameValue),
-                                                                                                            }
-                                                                                                            : {}),
-                                                                                                    });
-                                                                                                    persistRemote(url, headers, oauth);
-                                                                                                },
-                                                                                            });
-                                                                                        },
-                                                                                    });
-                                                                                },
-                                                                            });
-                                                                        },
-                                                                    });
-                                                                },
-                                                            });
-                                                        },
-                                                    });
-                                                },
-                                            });
-                                        },
-                                    });
-                                },
-                            });
-                        },
-                    });
-                },
-            });
-        };
-        promptValue({
-            title: `${mode} ${type} server`,
-            label: "URL",
-            initialValue: initial?.url ?? "",
-            placeholder: "https://example.com/mcp",
-            onSubmit: async (urlValue) => {
-                const url = urlValue.trim();
-                if (!url) {
-                    throw new Error("URL is required.");
-                }
-                promptValue({
-                    title: `${mode} ${type} server`,
-                    label: "Headers (optional)",
-                    initialValue: initial?.headers ? compactJson(initial.headers) : "",
-                    placeholder: '{"Authorization":"Bearer ..."}',
-                    onSubmit: async (headersValue) => {
-                        const headers = parseStringRecord(headersValue, "Headers");
-                        promptValue({
-                            title: `${mode} ${type} server`,
-                            label: "Enable OAuth? (yes/no)",
-                            initialValue: initial?.oauth ? "yes" : "no",
-                            placeholder: "no",
-                            note: "Choose yes for servers that use OAuth 2.0/2.1 or dynamic client registration.",
-                            onSubmit: async (oauthEnabledValue) => {
-                                const oauthEnabled = parseOptionalBoolean(oauthEnabledValue, "Enable OAuth");
-                                promptForOAuthDetails(url, headers, oauthEnabled);
-                            },
-                        });
-                    },
-                });
-            },
+        setScreen({ kind: "mcp-stdio-edit", originalName: currentName });
+    }, []);
+    const openMcpRemoteEditor = useCallback((type, currentName, initial) => {
+        setMcpDraft({
+            name: currentName ?? "",
+            url: initial?.url ?? "",
+            headers: initial?.headers ? compactJson(initial.headers) : "",
+            oauthEnabled: initial?.oauth ? "yes" : "no",
+            clientId: initial?.oauth?.clientId ?? "",
+            clientSecret: initial?.oauth?.clientSecret ?? "",
+            scopes: initial?.oauth?.scopes ? compactJson(initial.oauth.scopes) : "",
+            audiences: initial?.oauth?.audiences
+                ? compactJson(initial.oauth.audiences)
+                : "",
+            callbackPort: initial?.oauth?.callbackPort !== undefined
+                ? String(initial.oauth.callbackPort)
+                : "",
+            redirectUri: initial?.oauth?.redirectUri ?? "",
+            issuer: initial?.oauth?.issuer ?? "",
+            authorizationUrl: initial?.oauth?.authorizationUrl ?? "",
+            tokenUrl: initial?.oauth?.tokenUrl ?? "",
+            registrationUrl: initial?.oauth?.registrationUrl ?? "",
+            tokenParamName: initial?.oauth?.tokenParamName ?? "",
+        });
+        setScreen({
+            kind: "mcp-remote-edit",
+            transportType: type,
+            originalName: currentName,
         });
-    }, [mcpConfig, promptValue, refresh, setSuccess]);
-    const promptForServerName = useCallback((type) => {
+    }, []);
+    const updateMcpDraftField = useCallback((key, value) => {
+        setMcpDraft((current) => current ? { ...current, [key]: value } : current);
+    }, []);
+    const editMcpDraftField = useCallback((field, initialValue) => {
         promptValue({
-            title: `Add ${type} server`,
-            label: "Server name",
-            placeholder: "filesystem",
-            onSubmit: async (nameValue) => {
-                const name = nameValue.trim();
-                if (!name) {
-                    throw new Error("Server name is required.");
-                }
-                if (type === "stdio") {
-                    promptForStdio(name);
-                    return;
-                }
-                promptForRemote(name, type);
+            title: `Update ${field.label}`,
+            label: field.label,
+            initialValue,
+            placeholder: field.placeholder,
+            note: field.note,
+            onSubmit: async (value) => {
+                updateMcpDraftField(field.key, value);
+                setPrompt(null);
             },
         });
-    }, [promptForRemote, promptForStdio, promptValue]);
+    }, [promptValue, updateMcpDraftField]);
+    const saveMcpStdioDraft = useCallback((originalName) => {
+        const values = mcpDraft ?? {};
+        const name = (values.name ?? "").trim();
+        const command = (values.command ?? "").trim();
+        if (!name) {
+            throw new Error("Server name is required.");
+        }
+        if (!command) {
+            throw new Error("Command is required.");
+        }
+        const args = parseStringArray(values.args ?? "", "Arguments");
+        const env = parseStringRecord(values.env ?? "", "Environment variables");
+        const cwd = normalizeOptional(values.cwd ?? "");
+        const transport = McpTransportSchema.parse({
+            type: "stdio",
+            command,
+            ...(args.length > 0 ? { args } : {}),
+            ...(env && Object.keys(env).length > 0 ? { env } : {}),
+            ...(cwd ? { cwd } : {}),
+        });
+        persistMcpTransport(originalName, name, transport);
+    }, [mcpDraft, persistMcpTransport]);
+    const saveMcpRemoteDraft = useCallback((transportType, originalName) => {
+        const values = mcpDraft ?? {};
+        const name = (values.name ?? "").trim();
+        const url = (values.url ?? "").trim();
+        if (!name) {
+            throw new Error("Server name is required.");
+        }
+        if (!url) {
+            throw new Error("URL is required.");
+        }
+        const headers = parseStringRecord(values.headers ?? "", "Headers");
+        const oauthEnabled = parseOptionalBoolean(values.oauthEnabled ?? "", "Enable OAuth");
+        const scopes = parseStringArray(values.scopes ?? "", "OAuth scopes");
+        const audiences = parseStringArray(values.audiences ?? "", "OAuth audiences");
+        const callbackPort = normalizeOptional(values.callbackPort ?? "") !== undefined
+            ? parseNumber(values.callbackPort ?? "", "OAuth callback port", {
+                integer: true,
+                min: 1,
+                max: 65535,
+            })
+            : undefined;
+        const oauth = oauthEnabled
+            ? McpOAuthConfigSchema.parse({
+                enabled: true,
+                ...(normalizeOptional(values.clientId ?? "")
+                    ? { clientId: normalizeOptional(values.clientId ?? "") }
+                    : {}),
+                ...(normalizeOptional(values.clientSecret ?? "")
+                    ? { clientSecret: normalizeOptional(values.clientSecret ?? "") }
+                    : {}),
+                ...(scopes.length > 0 ? { scopes } : {}),
+                ...(audiences.length > 0 ? { audiences } : {}),
+                ...(callbackPort !== undefined ? { callbackPort } : {}),
+                ...(normalizeOptional(values.redirectUri ?? "")
+                    ? { redirectUri: normalizeOptional(values.redirectUri ?? "") }
+                    : {}),
+                ...(normalizeOptional(values.issuer ?? "")
+                    ? { issuer: normalizeOptional(values.issuer ?? "") }
+                    : {}),
+                ...(normalizeOptional(values.authorizationUrl ?? "")
+                    ? {
+                        authorizationUrl: normalizeOptional(values.authorizationUrl ?? ""),
+                    }
+                    : {}),
+                ...(normalizeOptional(values.tokenUrl ?? "")
+                    ? { tokenUrl: normalizeOptional(values.tokenUrl ?? "") }
+                    : {}),
+                ...(normalizeOptional(values.registrationUrl ?? "")
+                    ? {
+                        registrationUrl: normalizeOptional(values.registrationUrl ?? ""),
+                    }
+                    : {}),
+                ...(normalizeOptional(values.tokenParamName ?? "")
+                    ? {
+                        tokenParamName: normalizeOptional(values.tokenParamName ?? ""),
+                    }
+                    : {}),
+            })
+            : undefined;
+        const transport = McpTransportSchema.parse({
+            type: transportType,
+            url,
+            ...(headers && Object.keys(headers).length > 0 ? { headers } : {}),
+            ...(oauth ? { oauth } : {}),
+        });
+        persistMcpTransport(originalName, name, transport);
+    }, [mcpDraft, persistMcpTransport]);
     const llmSummary = useCallback((entry) => {
         const compactModelId = (model) => {
             if (model.length <= 23) {
@@ -556,16 +909,17 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
         };
         const resolved = config.resolveLlm(entry.name);
         if (!resolved) {
-            return `${entry.options.provider}/${compactModelId(entry.options.model)}`;
+            return `${entry.provider}/${compactModelId(entry.options.model)}`;
         }
-        return `${entry.options.provider} -> ${resolved.options.provider}/${compactModelId(resolved.options.model)}`;
+        return `${entry.provider} -> ${resolved.provider}/${compactModelId(resolved.llmOptions.model)}`;
     }, [config]);
-    const providerUsageCount = useCallback((name) => config.llms.filter((llm) => llm.options.provider === name).length, [config]);
+    const providerUsageCount = useCallback((name) => config.llms.filter((llm) => llm.provider === name).length, [config]);
     const renderHome = () => {
+        const defaultLlm = config.llms.find((m) => m.default) ?? config.llms[0];
         const items = [
             {
-                label: "Inference",
-                value: () => setScreen({ kind: "config" }),
+                label: "General",
+                value: () => setScreen({ kind: "config-general" }),
             },
             {
                 label: "Instructions • edit instructions.md",
@@ -590,6 +944,10 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
                     }
                 },
             },
+            {
+                label: defaultLlm ? `Models • ${defaultLlm.name}` : "Models",
+                value: () => setScreen({ kind: "config" }),
+            },
             {
                 label: `MCP servers • ${mcpServers.length} configured`,
                 value: () => setScreen({ kind: "mcp" }),
@@ -599,16 +957,16 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
                 value: () => setScreen({ kind: "skills" }),
             },
             {
-                label: "Exit",
+                label: "Back",
                 value: () => {
                     onExit();
                     exit();
                 },
             },
         ];
-        return (_jsx(MenuScreen, { title: configData.name, description: `inference: ${llmSummary(config.llms.find((m) => m.default) ?? config.llms[0])}`, items: items, footerHint: "enter: select | ctrl+c: exit" }));
+        return (_jsx(MenuScreen, { title: configData.name, description: `models: ${llmSummary(config.llms.find((m) => m.default) ?? config.llms[0])}`, items: items, footerHint: "enter: select | esc: back" }));
     };
-    const renderConfigMenu = () => {
+    const renderGeneralMenu = () => {
         const enabledPrompts = Object.values(configData.prompts).filter(Boolean).length;
         const totalPrompts = Object.keys(configData.prompts).length;
         const items = [
@@ -628,17 +986,6 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
                     },
                 }),
             },
-            {
-                label: (() => {
-                    const def = config.llms.find((m) => m.default) ?? config.llms[0];
-                    return `LLMs • ${config.llms.length} configured (default: ${def.name})`;
-                })(),
-                value: () => setScreen({ kind: "config-llms" }),
-            },
-            {
-                label: `Providers • ${config.providers.length} configured`,
-                value: () => setScreen({ kind: "config-providers" }),
-            },
             {
                 label: `Prompts • ${enabledPrompts}/${totalPrompts} enabled`,
                 value: () => setScreen({ kind: "config-prompts" }),
@@ -694,7 +1041,25 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
                 value: () => setScreen({ kind: "home" }),
             },
         ];
-        return (_jsx(MenuScreen, { title: "Configuration", description: "Edit the same values loaded from ~/.hooman/config.json.", items: items }));
+        return (_jsx(MenuScreen, { title: "General", description: "Manage app-wide settings loaded from ~/.hooman/config.json.", items: items }));
+    };
+    const renderConfigMenu = () => {
+        const defaultLlm = config.llms.find((m) => m.default) ?? config.llms[0];
+        const items = [
+            {
+                label: `LLMs • ${config.llms.length} configured (default: ${defaultLlm.name})`,
+                value: () => setScreen({ kind: "config-llms" }),
+            },
+            {
+                label: `Providers • ${config.providers.length} configured`,
+                value: () => setScreen({ kind: "config-providers" }),
+            },
+            {
+                label: "Back",
+                value: () => setScreen({ kind: "home" }),
+            },
+        ];
+        return (_jsx(MenuScreen, { title: "Models", description: "Manage configured providers and LLMs from ~/.hooman/config.json.", items: items }));
     };
     const renderToolsConfigMenu = () => {
         const items = [
@@ -789,7 +1154,7 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
             },
             {
                 label: "Back",
-                value: () => setScreen({ kind: "config" }),
+                value: () => setScreen({ kind: "config-general" }),
             },
         ];
         return (_jsx(MenuScreen, { title: "Tools", description: "Enable, disable, and configure built-in tools.", items: items }));
@@ -797,7 +1162,7 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
     const renderProvidersMenu = () => {
         const providerItems = config.providers.map((provider) => ({
             key: `provider:${provider.name}`,
-            label: `${provider.name} • ${provider.options.provider} • ${providerUsageCount(provider.name)} model(s)`,
+            label: `${provider.name} • ${provider.provider} • ${providerUsageCount(provider.name)} model(s)`,
             boldSubstring: provider.name,
             value: () => setScreen({ kind: "config-provider-edit", name: provider.name }),
         }));
@@ -816,9 +1181,8 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
                         if (config.providers.some((provider) => provider.name === name)) {
                             throw new Error(`A provider named "${name}" already exists.`);
                         }
-                        updateConfig({ providers: addProvider(name) }, `Added provider "${name}" with an Ollama scaffold.`);
                         setPrompt(null);
-                        setScreen({ kind: "config-provider-edit", name });
+                        setScreen({ kind: "config-provider-add-type", name });
                     },
                 }),
             },
@@ -840,6 +1204,8 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
             return null;
         }
         const usageCount = providerUsageCount(entry.name);
+        const providerFields = PROVIDER_FIELD_DEFINITIONS[entry.provider];
+        const providerOptions = entry.options;
         const items = [
             {
                 label: `Name • ${entry.name}`,
@@ -866,23 +1232,90 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
                 }),
             },
             {
-                label: `Type • ${entry.options.provider}`,
+                label: `Type • ${entry.provider}`,
                 value: () => setScreen({ kind: "config-provider-type", name: entry.name }),
             },
-            {
-                label: `Params • ${paramsPreview(entry.options.params)}`,
-                value: () => promptValue({
-                    title: "Update provider params",
-                    label: "Parameters",
-                    initialValue: compactJson(entry.options.params),
-                    placeholder: '{"apiKey":"..."}',
-                    onSubmit: async (value) => {
-                        const params = parseObjectRecord(value, "Provider params");
-                        updateConfig({ providers: patchProvider(entry.name, { params }) }, "Updated provider params.");
-                        setPrompt(null);
-                    },
-                }),
-            },
+            ...providerFields.map((definition) => ({
+                key: `provider-field:${entry.name}:${definition.key}`,
+                label: `${definition.label} • ${formatTypedFieldValue(definition, definition.kind === "bedrockCredentials"
+                    ? providerOptions.accessKeyId && providerOptions.secretAccessKey
+                    : providerOptions[definition.key])}`,
+                value: () => {
+                    if (definition.kind === "anthropicThinking") {
+                        setScreen({
+                            kind: "config-provider-anthropic-thinking",
+                            name: entry.name,
+                        });
+                        return;
+                    }
+                    if (definition.kind === "ollamaThinking") {
+                        setScreen({
+                            kind: "config-provider-ollama-thinking",
+                            name: entry.name,
+                        });
+                        return;
+                    }
+                    if (definition.kind === "bedrockCredentials") {
+                        promptValue({
+                            title: "Update static credentials",
+                            label: "Access key ID",
+                            initialValue: typeof providerOptions.accessKeyId === "string"
+                                ? providerOptions.accessKeyId
+                                : "",
+                            placeholder: "AKIA...",
+                            note: definition.note,
+                            onSubmit: async (accessKeyIdValue) => {
+                                promptValue({
+                                    title: "Update static credentials",
+                                    label: "Secret access key",
+                                    initialValue: typeof providerOptions.secretAccessKey === "string"
+                                        ? providerOptions.secretAccessKey
+                                        : "",
+                                    placeholder: "...",
+                                    onSubmit: async (secretAccessKeyValue) => {
+                                        const accessKeyId = normalizeOptional(accessKeyIdValue);
+                                        const secretAccessKey = normalizeOptional(secretAccessKeyValue);
+                                        if ((accessKeyId === undefined) !==
+                                            (secretAccessKey === undefined)) {
+                                            throw new Error("Access key ID and secret access key must be provided together.");
+                                        }
+                                        updateConfig({
+                                            providers: patchProvider(entry.name, {
+                                                accessKeyId,
+                                                secretAccessKey,
+                                            }),
+                                        }, `Updated static credentials for "${entry.name}".`);
+                                        setPrompt(null);
+                                    },
+                                });
+                            },
+                        });
+                        return;
+                    }
+                    promptValue({
+                        title: `Update ${definition.label}`,
+                        label: definition.label,
+                        initialValue: definition.kind === "stringRecord"
+                            ? providerOptions[definition.key]
+                                ? compactJson(providerOptions[definition.key])
+                                : ""
+                            : providerOptions[definition.key] !== undefined
+                                ? String(providerOptions[definition.key])
+                                : "",
+                        placeholder: definition.placeholder,
+                        note: definition.note,
+                        onSubmit: async (value) => {
+                            const nextValue = parseTypedFieldValue(value, definition);
+                            updateConfig({
+                                providers: patchProvider(entry.name, {
+                                    [definition.key]: nextValue,
+                                }),
+                            }, `Updated ${definition.label.toLowerCase()} for "${entry.name}".`);
+                            setPrompt(null);
+                        },
+                    });
+                },
+            })),
             ...(usageCount > 0
                 ? []
                 : [
@@ -904,6 +1337,75 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
                 ? `Used by ${usageCount} model(s). Rename updates references automatically; delete is disabled while in use.`
                 : "Edit shared provider settings or delete this provider.", items: items }));
     };
+    const renderAnthropicThinkingMenu = () => {
+        if (screen.kind !== "config-provider-anthropic-thinking") {
+            return null;
+        }
+        const entry = config.providers.find((provider) => provider.name === screen.name);
+        if (!entry) {
+            return null;
+        }
+        const current = "thinking" in entry.options ? entry.options.thinking : undefined;
+        const items = [
+            {
+                label: current === undefined ? "Not set • current" : "Not set (clear value)",
+                value: () => {
+                    updateConfig({ providers: patchProvider(entry.name, { thinking: undefined }) }, `Cleared thinking for "${entry.name}".`);
+                    setScreen({ kind: "config-provider-edit", name: entry.name });
+                },
+            },
+            {
+                label: current === "disabled" ? "disabled • current" : "disabled",
+                value: () => {
+                    updateConfig({ providers: patchProvider(entry.name, { thinking: "disabled" }) }, `Updated thinking for "${entry.name}" to "disabled".`);
+                    setScreen({ kind: "config-provider-edit", name: entry.name });
+                },
+            },
+            {
+                label: current === "adaptive" ? "adaptive • current" : "adaptive",
+                value: () => {
+                    updateConfig({ providers: patchProvider(entry.name, { thinking: "adaptive" }) }, `Updated thinking for "${entry.name}" to "adaptive".`);
+                    setScreen({ kind: "config-provider-edit", name: entry.name });
+                },
+            },
+            {
+                label: "Back",
+                value: () => setScreen({ kind: "config-provider-edit", name: entry.name }),
+            },
+        ];
+        return (_jsx(MenuScreen, { title: `Choose Thinking • ${entry.name}`, description: 'Pick one of the allowed values: "disabled", "adaptive", or clear it.', items: items }));
+    };
+    const renderOllamaThinkingMenu = () => {
+        if (screen.kind !== "config-provider-ollama-thinking") {
+            return null;
+        }
+        const entry = config.providers.find((provider) => provider.name === screen.name);
+        if (!entry) {
+            return null;
+        }
+        const current = "thinking" in entry.options ? entry.options.thinking : undefined;
+        const items = [
+            {
+                label: current === undefined ? "Not set • current" : "Not set (clear value)",
+                value: () => {
+                    updateConfig({ providers: patchProvider(entry.name, { thinking: undefined }) }, `Cleared thinking for "${entry.name}".`);
+                    setScreen({ kind: "config-provider-edit", name: entry.name });
+                },
+            },
+            ...[false, true, "low", "medium", "high"].map((value) => ({
+                label: current === value ? `${String(value)} • current` : String(value),
+                value: () => {
+                    updateConfig({ providers: patchProvider(entry.name, { thinking: value }) }, `Updated thinking for "${entry.name}" to "${String(value)}".`);
+                    setScreen({ kind: "config-provider-edit", name: entry.name });
+                },
+            })),
+            {
+                label: "Back",
+                value: () => setScreen({ kind: "config-provider-edit", name: entry.name }),
+            },
+        ];
+        return (_jsx(MenuScreen, { title: `Choose Thinking • ${entry.name}`, description: 'Pick one of the allowed values: clear, false, true, "low", "medium", or "high".', items: items }));
+    };
     const renderProviderTypeMenu = () => {
         if (screen.kind !== "config-provider-type") {
             return null;
@@ -915,16 +1417,17 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
         }
         const items = [
             ...SUPPORTED_PROVIDER_TYPES.map((provider) => ({
-                label: provider === entry.options.provider
-                    ? `${provider} • current`
-                    : provider,
+                label: provider === entry.provider ? `${provider} • current` : provider,
                 value: () => {
                     updateConfig({
-                        providers: patchProvider(entry.name, {
-                            provider,
-                            params: providerParamsTemplate(provider),
-                        }),
-                    }, `Updated provider type for "${entry.name}" to "${provider}" and scaffolded params.`);
+                        providers: config.providers.map((item) => item.name === entry.name
+                            ? {
+                                ...item,
+                                provider,
+                                options: providerOptionsTemplate(provider),
+                            }
+                            : item),
+                    }, `Updated provider type for "${entry.name}" to "${provider}" and scaffolded options.`);
                     setScreen({ kind: "config-provider-edit", name: entry.name });
                 },
             })),
@@ -935,6 +1438,26 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
         ];
         return (_jsx(MenuScreen, { title: `Choose Provider Type • ${entry.name}`, description: "Pick which runtime provider this shared config targets.", items: items }));
     };
+    const renderProviderAddTypeMenu = () => {
+        if (screen.kind !== "config-provider-add-type") {
+            return null;
+        }
+        const { name } = screen;
+        const items = [
+            ...SUPPORTED_PROVIDER_TYPES.map((provider) => ({
+                label: provider,
+                value: () => {
+                    updateConfig({ providers: addProvider(name, provider) }, `Added provider "${name}" as "${provider}".`);
+                    setScreen({ kind: "config-provider-edit", name });
+                },
+            })),
+            {
+                label: "Back",
+                value: () => setScreen({ kind: "config-providers" }),
+            },
+        ];
+        return (_jsx(MenuScreen, { title: `Choose Provider Type • ${name}`, description: "Pick the runtime provider before creating this shared config.", items: items }));
+    };
     const renderProviderDeleteConfirm = () => {
         if (screen.kind !== "config-provider-delete-confirm") {
             return null;
@@ -1007,6 +1530,7 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
         }
         const isOnly = config.llms.length === 1;
         const isDefault = entry.default;
+        const llmOptions = entry.options;
         const items = [
             {
                 label: `Name • ${entry.name}`,
@@ -1033,7 +1557,7 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
                 }),
             },
             {
-                label: `Provider • ${entry.options.provider}`,
+                label: `Provider • ${entry.provider}`,
                 value: () => setScreen({ kind: "config-llm-provider", name: entry.name }),
             },
             {
@@ -1042,6 +1566,12 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
                     title: "Update model id",
                     label: "Model",
                     initialValue: entry.options.model,
+                    note: (() => {
+                        const providerType = config.providers.find((provider) => provider.name === entry.provider)?.provider;
+                        return providerType
+                            ? `Suggested default for ${providerType}: ${defaultModelForProviderType(providerType)}`
+                            : undefined;
+                    })(),
                     onSubmit: async (value) => {
                         const model = value.trim();
                         if (!model) {
@@ -1052,20 +1582,28 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
                     },
                 }),
             },
-            {
-                label: `Params • ${paramsPreview(entry.options.params)}`,
+            ...LLM_FIELD_DEFINITIONS.map((definition) => ({
+                key: `llm-field:${entry.name}:${definition.key}`,
+                label: `${definition.label} • ${formatTypedFieldValue(definition, llmOptions[definition.key])}`,
                 value: () => promptValue({
-                    title: "Update LLM params",
-                    label: "Parameters",
-                    initialValue: compactJson(entry.options.params),
-                    placeholder: '{"temperature":0.7}',
+                    title: `Update ${definition.label}`,
+                    label: definition.label,
+                    initialValue: llmOptions[definition.key] !== undefined
+                        ? String(llmOptions[definition.key])
+                        : "",
+                    placeholder: definition.placeholder,
+                    note: definition.note,
                     onSubmit: async (value) => {
-                        const params = parseObjectRecord(value, "LLM params");
-                        updateConfig({ llms: patchLlm(entry.name, { params }) }, "Updated LLM params.");
+                        const nextValue = parseTypedFieldValue(value, definition);
+                        updateConfig({
+                            llms: patchLlm(entry.name, {
+                                [definition.key]: nextValue,
+                            }),
+                        }, `Updated ${definition.label.toLowerCase()} for "${entry.name}".`);
                         setPrompt(null);
                     },
                 }),
-            },
+            })),
             {
                 label: isDefault ? "Default • yes" : "Set as default",
                 value: () => {
@@ -1109,11 +1647,22 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
         }
         const items = [
             ...config.providers.map((provider) => ({
-                label: provider.name === entry.options.provider
+                label: provider.name === entry.provider
                     ? `${provider.name} • current`
-                    : `${provider.name} • ${provider.options.provider}`,
+                    : `${provider.name} • ${provider.provider}`,
                 value: () => {
-                    updateConfig({ llms: patchLlm(entry.name, { provider: provider.name }) }, `Updated provider for "${entry.name}" to "${provider.name}".`);
+                    updateConfig({
+                        llms: config.llms.map((llm) => llm.name === entry.name
+                            ? {
+                                ...llm,
+                                provider: provider.name,
+                                options: {
+                                    ...llm.options,
+                                    model: defaultModelForProviderType(provider.provider),
+                                },
+                            }
+                            : llm),
+                    }, `Updated provider for "${entry.name}" to "${provider.name}" and scaffolded its default model.`);
                     setScreen({ kind: "config-llm-edit", name: entry.name });
                 },
             })),
@@ -1167,7 +1716,7 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
             }),
             {
                 label: "Back",
-                value: () => setScreen({ kind: "config-tools" }),
+                value: () => setScreen({ kind: "config-general" }),
             },
         ];
         return (_jsx(MenuScreen, { title: "Prompts", description: "Choose which bundled harness prompt sections are included in future sessions.", items: items }));
@@ -1248,6 +1797,58 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
         ];
         return (_jsx(MenuScreen, { title: "Search", description: "Configure web search provider and credentials.", items: items }));
     };
+    const renderMcpStdioEditMenu = () => {
+        if (screen.kind !== "mcp-stdio-edit" || !mcpDraft) {
+            return null;
+        }
+        const items = [
+            ...MCP_STDIO_FIELDS.map((field) => ({
+                key: `mcp-stdio:${field.key}`,
+                label: `${field.label} • ${formatDraftFieldValue(field, mcpDraft[field.key])}`,
+                value: () => editMcpDraftField(field, mcpDraft[field.key] ?? ""),
+            })),
+            {
+                label: "Save",
+                value: () => saveMcpStdioDraft(screen.originalName),
+            },
+            {
+                label: "Back",
+                value: () => {
+                    setMcpDraft(null);
+                    setScreen({ kind: "mcp" });
+                },
+            },
+        ];
+        return (_jsx(MenuScreen, { title: `${screen.originalName ? "Edit" : "Add"} stdio server`, description: "Select a field to edit, then save when you're done.", items: items }));
+    };
+    const renderMcpRemoteEditMenu = () => {
+        if (screen.kind !== "mcp-remote-edit" || !mcpDraft) {
+            return null;
+        }
+        const fields = [
+            ...MCP_REMOTE_BASE_FIELDS,
+            ...(isTruthyToggle(mcpDraft.oauthEnabled) ? MCP_REMOTE_OAUTH_FIELDS : []),
+        ];
+        const items = [
+            ...fields.map((field) => ({
+                key: `mcp-remote:${field.key}`,
+                label: `${field.label} • ${formatDraftFieldValue(field, mcpDraft[field.key])}`,
+                value: () => editMcpDraftField(field, mcpDraft[field.key] ?? ""),
+            })),
+            {
+                label: "Save",
+                value: () => saveMcpRemoteDraft(screen.transportType, screen.originalName),
+            },
+            {
+                label: "Back",
+                value: () => {
+                    setMcpDraft(null);
+                    setScreen({ kind: "mcp" });
+                },
+            },
+        ];
+        return (_jsx(MenuScreen, { title: `${screen.originalName ? "Edit" : "Add"} ${screen.transportType} server`, description: "Select a field to edit, then save when you're done.", items: items }));
+    };
     const renderMcpMenu = () => {
         const serverItems = mcpServers.map((server) => {
             const oauthStatus = mcpAuthStatuses[server.name];
@@ -1262,10 +1863,10 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
                     : undefined,
                 value: () => {
                     if (server.transport.type === "stdio") {
-                        promptForStdio(server.name, server.transport);
+                        openMcpStdioEditor(server.name, server.transport);
                     }
                     else {
-                        promptForRemote(server.name, server.transport.type, server.transport);
+                        openMcpRemoteEditor(server.transport.type, server.name, server.transport);
                     }
                 },
             };
@@ -1273,15 +1874,15 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
         const items = [
             {
                 label: "Add stdio server",
-                value: () => promptForServerName("stdio"),
+                value: () => openMcpStdioEditor(),
             },
             {
                 label: "Add streamable HTTP server",
-                value: () => promptForServerName("streamable-http"),
+                value: () => openMcpRemoteEditor("streamable-http"),
             },
             {
                 label: "Add SSE server",
-                value: () => promptForServerName("sse"),
+                value: () => openMcpRemoteEditor("sse"),
             },
             ...serverItems,
             {
@@ -1483,14 +2084,22 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
         switch (screen.kind) {
             case "home":
                 return renderHome();
+            case "config-general":
+                return renderGeneralMenu();
             case "config":
                 return renderConfigMenu();
             case "config-providers":
                 return renderProvidersMenu();
+            case "config-provider-add-type":
+                return renderProviderAddTypeMenu();
             case "config-provider-edit":
                 return renderProviderEditMenu();
             case "config-provider-type":
                 return renderProviderTypeMenu();
+            case "config-provider-anthropic-thinking":
+                return renderAnthropicThinkingMenu();
+            case "config-provider-ollama-thinking":
+                return renderOllamaThinkingMenu();
             case "config-provider-delete-confirm":
                 return renderProviderDeleteConfirm();
             case "config-llms":
@@ -1511,6 +2120,10 @@ export function ConfigureApp({ config, mcpConfig, mcpManager, skills, onExit, })
                 return renderSearchProviderMenu();
             case "mcp":
                 return renderMcpMenu();
+            case "mcp-stdio-edit":
+                return renderMcpStdioEditMenu();
+            case "mcp-remote-edit":
+                return renderMcpRemoteEditMenu();
             case "mcp-delete-confirm":
                 return renderMcpDeleteConfirm();
             case "skills":