@vybestack/llxprt-code 0.4.8 → 0.5.0-nightly.251102.6bb3db7a

package/dist/src/ui/commands/setCommand.js

@@ -4,326 +4,685 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { CommandKind, } from './types.js';
-import { ephemeralSettingHelp, parseEphemeralSettingValue, } from '../../settings/ephemeralSettings.js';
-import { parseModelParamValue } from '../../settings/modelParamParser.js';
+import { getRuntimeApi } from '../contexts/RuntimeContext.js';
 // Subcommand for /set unset - removes ephemeral settings or model parameters
-const unsetCommand = {
-    name: 'unset',
-    description: 'remove an ephemeral setting or model parameter',
+/**
+ * Implementation for the /set command that handles both:
+ * - /set modelparam <key> <value>
+ * - /set <ephemeral-key> <value>
+ */
+// Help text for ephemeral settings - these are session-only and saved only via profiles
+const ephemeralSettingHelp = {
+    'context-limit': 'Maximum number of tokens for the context window (e.g., 100000)',
+    'compression-threshold': 'Fraction of context limit that triggers compression (0.0-1.0, e.g., 0.7 for 70%)',
+    'base-url': 'Base URL for API requests',
+    'tool-format': 'Tool format override for the provider',
+    'api-version': 'API version to use',
+    'custom-headers': 'Custom HTTP headers as JSON object',
+    'stream-options': 'Stream options for OpenAI API (default: { include_usage: true })',
+    streaming: 'Enable or disable streaming responses (enabled/disabled, default: enabled)',
+    'shell-replacement': 'Allow command substitution ($(), <(), backticks) in shell commands (default: false)',
+    // Socket configuration for local AI servers (LM Studio, Ollama, etc.)
+    'socket-timeout': 'Request timeout in milliseconds for local AI servers (default: 60000)',
+    'socket-keepalive': 'Enable TCP keepalive for local AI server connections (true/false, default: true)',
+    'socket-nodelay': 'Enable TCP_NODELAY concept for local AI servers (true/false, default: true)',
+    // Tool output limit settings - apply to all tools that can return large outputs
+    'tool-output-max-items': 'Maximum number of items/files/matches returned by tools (default: 50)',
+    'tool-output-max-tokens': 'Maximum tokens in tool output (default: 50000)',
+    'tool-output-truncate-mode': 'How to handle exceeding limits: warn, truncate, or sample (default: warn)',
+    'tool-output-item-size-limit': 'Maximum size per item/file in bytes (default: 524288 = 512KB)',
+    // Final catch-all to prevent context overflow
+    'max-prompt-tokens': 'Maximum tokens allowed in any prompt sent to LLM (default: 200000)',
+    // Emoji filter settings
+    emojifilter: 'Emoji filter mode (allowed, auto, warn, error)',
+    // Retry settings
+    retries: 'Maximum number of retry attempts for API calls (default: varies by provider)',
+    retrywait: 'Initial delay in milliseconds between retry attempts (default: varies by provider)',
+    // Loop prevention settings
+    maxTurnsPerPrompt: 'Maximum number of turns allowed per prompt before stopping (default: 100, -1 for unlimited)',
+};
+/**
+ * Schema-based completion for /set command, redesigned to match P09 test expectations.
+ *
+ * @plan:PLAN-20251013-AUTOCOMPLETE.P10
+ * @requirement:REQ-006
+ * @pseudocode ArgumentSchema.md lines 111-130
+ * - Line 111: literal `unset`
+ * - Line 112: literal `modelparam`
+ * - Line 113: literal `emojifilter`
+ * - Line 114: nested value arg for param name
+ * - Line 115: nested value arg for param value
+ * - Line 116: hint for emoji mode
+ * - Line 117-120: dynamic completers for providers/params
+ *
+ * Note: The P09 test uses a mixed approach: literals for 'unset', 'modelparam', 'emojifilter'
+ * and a single top-level 'value' argument for other settings. This implementation matches that.
+ */
+const toTitleCase = (input) => input
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .replace(/[-_]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .replace(/\b\w/g, (char) => char.toUpperCase());
+const booleanOptions = [
+    { value: 'true', description: 'true' },
+    { value: 'false', description: 'false' },
+];
+const streamingOptions = [
+    { value: 'enabled', description: 'enabled' },
+    { value: 'disabled', description: 'disabled' },
+];
+const emojifilterOptions = [
+    { value: 'allowed', description: 'Allow all emojis' },
+    { value: 'auto', description: 'Automatically filter inappropriate emojis' },
+    { value: 'warn', description: 'Warn about filtered emojis' },
+    { value: 'error', description: 'Error on filtered emojis' },
+];
+const truncateModeOptions = [
+    { value: 'warn', description: 'warn' },
+    { value: 'truncate', description: 'truncate' },
+    { value: 'sample', description: 'sample' },
+];
+const directSettingSpecs = [
+    {
+        value: 'emojifilter',
+        hint: 'filter mode',
+        description: 'filter mode',
+        options: emojifilterOptions,
+    },
+    {
+        value: 'context-limit',
+        hint: 'positive integer (e.g., 100000)',
+    },
+    {
+        value: 'compression-threshold',
+        hint: 'decimal between 0 and 1 (e.g., 0.7)',
+    },
+    {
+        value: 'base-url',
+        hint: 'URL string (e.g., https://api.example.com)',
+    },
+    {
+        value: 'api-version',
+        hint: 'API version (e.g., v1, 2024-05-01)',
+    },
+    {
+        value: 'streaming',
+        hint: 'enabled or disabled',
+        description: 'streaming mode',
+        options: streamingOptions,
+    },
+    {
+        value: 'socket-timeout',
+        hint: 'positive integer in milliseconds (e.g., 60000)',
+    },
+    {
+        value: 'socket-keepalive',
+        hint: 'true or false',
+        description: 'boolean value',
+        options: booleanOptions,
+    },
+    {
+        value: 'socket-nodelay',
+        hint: 'true or false',
+        description: 'boolean value',
+        options: booleanOptions,
+    },
+    {
+        value: 'shell-replacement',
+        hint: 'true or false',
+        description: 'boolean value',
+        options: booleanOptions,
+    },
+    {
+        value: 'tool-output-max-items',
+        hint: 'positive integer (e.g., 50)',
+    },
+    {
+        value: 'tool-output-max-tokens',
+        hint: 'positive integer (e.g., 50000)',
+    },
+    {
+        value: 'tool-output-item-size-limit',
+        hint: 'positive integer (e.g., 1048576)',
+    },
+    {
+        value: 'tool-output-truncate-mode',
+        hint: 'warn, truncate, or sample',
+        description: 'truncate mode',
+        options: truncateModeOptions,
+    },
+    {
+        value: 'max-prompt-tokens',
+        hint: 'positive integer (e.g., 200000)',
+    },
+    {
+        value: 'maxTurnsPerPrompt',
+        hint: 'positive integer or -1 (unlimited)',
+    },
+];
+const createSettingLiteral = (spec) => ({
+    kind: 'literal',
+    value: spec.value,
+    description: `${toTitleCase(spec.value)} option`,
+    next: [
+        {
+            kind: 'value',
+            name: `${spec.value}-value`,
+            description: spec.description ?? `${toTitleCase(spec.value)} value`,
+            hint: spec.hint,
+            options: spec.options,
+            completer: spec.completer,
+        },
+    ],
+});
+const directSettingLiterals = directSettingSpecs.map(createSettingLiteral);
+const directSettingKeys = new Set(directSettingSpecs.map((spec) => spec.value));
+// Stryker disable StringLiteral -- literal descriptions are static UX copy verified via interaction tests.
+const setSchema = [
+    {
+        kind: 'literal',
+        value: 'unset',
+        description: 'Unset option',
+        next: [
+            {
+                kind: 'value',
+                name: 'key',
+                description: 'setting key to remove',
+                completer: async (_ctx, partial) => {
+                    const ephemeralSettings = getRuntimeApi().getEphemeralSettings();
+                    const ephemeralKeys = Object.keys(ephemeralSettings).filter((key) => ephemeralSettings[key] !== undefined);
+                    const specialKeys = [
+                        'modelparam',
+                        'custom-headers',
+                        ...Array.from(directSettingKeys),
+                    ];
+                    const allKeys = Array.from(new Set([...ephemeralKeys, ...specialKeys]));
+                    return allKeys
+                        .filter((key) => key.startsWith(partial))
+                        .map((key) => ({ value: key, description: `setting: ${key}` }));
+                },
+                next: [
+                    {
+                        kind: 'value',
+                        name: 'subkey',
+                        description: 'nested key for specific settings',
+                        hint: async (_ctx, tokens) => {
+                            const key = tokens.tokens[1];
+                            if (key === 'modelparam') {
+                                return 'model parameter name (e.g., temperature, max_tokens)';
+                            }
+                            if (key === 'custom-headers') {
+                                return 'header name (e.g., Authorization)';
+                            }
+                            return 'subkey (optional)';
+                        },
+                        completer: async (ctx, partial, tokens) => {
+                            const key = tokens.tokens[1];
+                            if (key === 'modelparam') {
+                                const params = getRuntimeApi().getActiveModelParams();
+                                const paramNames = Object.keys(params);
+                                return paramNames
+                                    .filter((name) => name.startsWith(partial))
+                                    .map((name) => ({
+                                    value: name,
+                                    description: `Parameter: ${name}`,
+                                }));
+                            }
+                            if (key === 'custom-headers') {
+                                const headers = getRuntimeApi().getEphemeralSettings()['custom-headers'];
+                                if (headers) {
+                                    return Object.keys(headers)
+                                        .filter((name) => name.startsWith(partial))
+                                        .map((name) => ({
+                                        value: name,
+                                        description: `header: ${name}`,
+                                    }));
+                                }
+                            }
+                            return [];
+                        },
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        kind: 'literal',
+        value: 'modelparam',
+        description: 'Model parameter option',
+        next: [
+            {
+                kind: 'value',
+                name: 'param-name',
+                description: 'parameter name',
+                hint: 'parameter name',
+                completer: async (_ctx, partial) => {
+                    const modelParams = getRuntimeApi().getActiveModelParams();
+                    if (modelParams && Object.keys(modelParams).length > 0) {
+                        const paramNames = Object.keys(modelParams);
+                        const matches = paramNames.filter((name) => name.startsWith(partial));
+                        if (matches.length > 0) {
+                            return matches.map((name) => ({
+                                value: name,
+                                description: `Parameter: ${name}`,
+                            }));
+                        }
+                    }
+                    const commonParams = [
+                        'temperature',
+                        'max_tokens',
+                        'top_p',
+                        'top_k',
+                        'frequency_penalty',
+                        'presence_penalty',
+                    ];
+                    return commonParams
+                        .filter((name) => name.startsWith(partial))
+                        .map((name) => ({
+                        value: name,
+                        description: `Parameter: ${name}`,
+                    }));
+                },
+                next: [
+                    {
+                        kind: 'value',
+                        name: 'param-value',
+                        description: 'model parameter value',
+                        hint: 'value to set for the parameter (number, string, boolean, or JSON)',
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        kind: 'literal',
+        value: 'emojifilter',
+        description: 'Emoji filter option',
+        next: [
+            {
+                kind: 'value',
+                name: 'mode',
+                description: 'filter mode',
+                hint: 'filter mode',
+                options: emojifilterOptions,
+            },
+        ],
+    },
+    ...directSettingLiterals.filter((literal) => literal.value !== 'emojifilter'),
+    // Stryker disable all -- fallback value handler is exercised through runtime flows and
+    // would require extensive integration scaffolding beyond the schema migration scope.
+    {
+        kind: 'value',
+        name: 'setting',
+        description: 'any ephemeral setting key',
+        options: Object.entries(ephemeralSettingHelp)
+            .filter(([key]) => !directSettingKeys.has(key))
+            .map(([value, description]) => ({
+            value,
+            description,
+        })),
+        next: [
+            {
+                kind: 'value',
+                name: 'setting-value',
+                description: 'setting value',
+                hint: async (_ctx, tokens) => {
+                    const setting = tokens.partialToken || tokens.tokens[0];
+                    switch (setting) {
+                        case 'context-limit':
+                            return 'positive integer (e.g., 100000)';
+                        case 'compression-threshold':
+                            return 'decimal between 0 and 1 (e.g., 0.7)';
+                        case 'emojifilter':
+                            return 'allowed, auto, warn, or error';
+                        case 'streaming':
+                            return 'enabled or disabled';
+                        case 'socket-timeout':
+                            return 'positive integer in milliseconds (e.g., 60000)';
+                        case 'socket-keepalive':
+                        case 'socket-nodelay':
+                        case 'shell-replacement':
+                            return 'true or false';
+                        case 'tool-output-truncate-mode':
+                            return 'warn, truncate, or sample';
+                        case 'maxTurnsPerPrompt':
+                            return 'positive integer or -1 (unlimited)';
+                        default:
+                            return 'value to set';
+                    }
+                },
+                completer: async (ctx, partial, tokens) => {
+                    const setting = tokens.tokens[0] || tokens.partialToken;
+                    if (setting === 'emojifilter') {
+                        return emojifilterOptions
+                            .filter((option) => option.value.startsWith(partial))
+                            .map((option) => ({
+                            value: option.value,
+                            description: option.description,
+                        }));
+                    }
+                    if (setting === 'streaming') {
+                        return streamingOptions
+                            .filter((option) => option.value.startsWith(partial))
+                            .map((option) => ({
+                            value: option.value,
+                            description: option.description,
+                        }));
+                    }
+                    if (setting === 'socket-keepalive' ||
+                        setting === 'socket-nodelay' ||
+                        setting === 'shell-replacement') {
+                        return booleanOptions
+                            .filter((option) => option.value.startsWith(partial))
+                            .map((option) => ({
+                            value: option.value,
+                            description: option.description,
+                        }));
+                    }
+                    if (setting === 'tool-output-truncate-mode') {
+                        return truncateModeOptions
+                            .filter((option) => option.value.startsWith(partial))
+                            .map((option) => ({
+                            value: option.value,
+                            description: option.description,
+                        }));
+                    }
+                    if (setting === 'custom-headers') {
+                        const headers = getRuntimeApi().getEphemeralSettings()['custom-headers'];
+                        if (headers) {
+                            return Object.keys(headers)
+                                .filter((name) => name.startsWith(partial))
+                                .map((name) => ({
+                                value: name,
+                                description: `header: ${name}`,
+                            }));
+                        }
+                    }
+                    return [];
+                },
+            },
+        ],
+    },
+    // Stryker restore all
+];
+// Stryker restore StringLiteral
+export const setCommand = {
+    name: 'set',
+    description: 'set model parameters or ephemeral settings',
     kind: CommandKind.BUILT_IN,
+    schema: setSchema,
     action: async (context, args) => {
-        const parts = args?.trim().split(/\s+/);
-        if (!parts || parts.length === 0 || !parts[0]) {
+        const runtime = getRuntimeApi();
+        // This handles direct ephemeral settings: /set <ephemeral-key> <value>
+        const trimmedArgs = args?.trim();
+        if (!trimmedArgs) {
             return {
                 type: 'message',
                 messageType: 'error',
-                content: 'Usage: /set unset <key> [subkey]\nExamples:\n  /set unset context-limit\n  /set unset custom-headers Authorization\n  /set unset modelparam max_tokens',
+                content: 'Usage: /set <ephemeral-key> <value>\nExample: /set context-limit 100000\n\nFor model parameters use: /set modelparam <key> <value>',
             };
         }
+        const parts = trimmedArgs.split(/\s+/);
         const key = parts[0];
-        const subkey = parts[1];
-        // Get the config
-        const config = context.services.config;
-        if (!config) {
+        if (key === 'modelparam') {
+            if (parts.length < 3) {
+                return {
+                    type: 'message',
+                    messageType: 'error',
+                    content: 'Usage: /set modelparam <key> <value>\nExample: /set modelparam temperature 0.7',
+                };
+            }
+            const paramName = parts[1];
+            const rawValue = parts.slice(2).join(' ');
+            const parsedParamValue = parseValue(rawValue);
+            try {
+                runtime.setActiveModelParam(paramName, parsedParamValue);
+            }
+            catch (error) {
+                return {
+                    type: 'message',
+                    messageType: 'error',
+                    content: `Failed to set model parameter: ${error instanceof Error ? error.message : String(error)}`,
+                };
+            }
+            const formattedValue = typeof parsedParamValue === 'string'
+                ? parsedParamValue
+                : typeof parsedParamValue === 'number' ||
+                    typeof parsedParamValue === 'boolean' ||
+                    parsedParamValue === null
+                    ? String(parsedParamValue)
+                    : JSON.stringify(parsedParamValue);
             return {
                 type: 'message',
-                messageType: 'error',
-                content: 'No configuration available',
+                messageType: 'info',
+                content: `Model parameter '${paramName}' set to ${formattedValue}`,
             };
         }
-        // Handle unset for model parameters
-        if (key === 'modelparam' && subkey) {
-            const providerManager = config.getProviderManager();
-            const activeProvider = providerManager?.getActiveProvider();
-            if (!activeProvider) {
+        if (key === 'unset') {
+            if (parts.length < 2) {
                 return {
                     type: 'message',
                     messageType: 'error',
-                    content: 'No active provider',
+                    content: 'Usage: /set unset <ephemeral-key|modelparam> [subkey]\nExample: /set unset base-url',
                 };
             }
-            if ('getModelParams' in activeProvider &&
-                typeof activeProvider.getModelParams === 'function') {
-                const modelParams = activeProvider.getModelParams();
-                if (!modelParams || !(subkey in modelParams)) {
+            const targetKey = parts[1];
+            const subKey = parts[2];
+            if (targetKey === 'modelparam') {
+                if (!subKey) {
                     return {
                         type: 'message',
                         messageType: 'error',
-                        content: `Model parameter '${subkey}' is not set`,
+                        content: 'Usage: /set unset modelparam <key>\nExample: /set unset modelparam temperature',
                     };
                 }
-                if ('setModelParams' in activeProvider &&
-                    typeof activeProvider.setModelParams === 'function') {
-                    activeProvider.setModelParams({ [subkey]: undefined });
+                try {
+                    runtime.clearActiveModelParam(subKey);
+                }
+                catch (error) {
                     return {
                         type: 'message',
-                        messageType: 'info',
-                        content: `Model parameter '${subkey}' has been removed`,
+                        messageType: 'error',
+                        content: `Failed to clear model parameter: ${error instanceof Error ? error.message : String(error)}`,
                     };
                 }
-            }
-            return {
-                type: 'message',
-                messageType: 'error',
-                content: 'Provider does not support model parameters',
-            };
-        }
-        // Handle nested unset for custom-headers
-        if (key === 'custom-headers' && subkey) {
-            const currentHeaders = config.getEphemeralSetting('custom-headers');
-            if (!currentHeaders || !(subkey in currentHeaders)) {
                 return {
                     type: 'message',
-                    messageType: 'error',
-                    content: `Custom header '${subkey}' is not set`,
+                    messageType: 'info',
+                    content: `Model parameter '${subKey}' cleared`,
                 };
             }
-            // Remove the specific header
-            const updatedHeaders = { ...currentHeaders };
-            delete updatedHeaders[subkey];
-            // If no headers left, remove the entire setting
-            if (Object.keys(updatedHeaders).length === 0) {
-                // Note: SettingsService doesn't currently support ephemeral settings,
-                // so we continue to use the config directly for these session-only settings
-                config.setEphemeralSetting('custom-headers', undefined);
+            const validEphemeralKeys = Object.keys(ephemeralSettingHelp);
+            if (!validEphemeralKeys.includes(targetKey)) {
                 return {
                     type: 'message',
-                    messageType: 'info',
-                    content: `Removed custom header '${subkey}' and cleared custom-headers setting`,
+                    messageType: 'error',
+                    content: `Invalid setting key: ${targetKey}. Valid keys are: ${validEphemeralKeys.join(', ')}`,
                 };
             }
-            else {
-                config.setEphemeralSetting('custom-headers', updatedHeaders);
+            if (targetKey === 'custom-headers' && subKey) {
+                const currentHeaders = runtime.getEphemeralSettings()['custom-headers'];
+                if (currentHeaders && subKey in currentHeaders) {
+                    const nextHeaders = { ...currentHeaders };
+                    delete nextHeaders[subKey];
+                    runtime.setEphemeralSetting(targetKey, Object.keys(nextHeaders).length > 0 ? nextHeaders : undefined);
+                    return {
+                        type: 'message',
+                        messageType: 'info',
+                        content: `Custom header '${subKey}' cleared`,
+                    };
+                }
                 return {
                     type: 'message',
                     messageType: 'info',
-                    content: `Removed custom header '${subkey}'`,
+                    content: `No custom header named '${subKey}' found`,
                 };
             }
-        }
-        // Handle regular unset (non-nested)
-        if (subkey) {
-            return {
-                type: 'message',
-                messageType: 'error',
-                content: `Setting '${key}' does not support nested unset. Use: /set unset ${key}`,
-            };
-        }
-        // No special handling for emojifilter - treat it like any other ephemeral setting
-        // Check if the setting exists
-        const currentValue = config.getEphemeralSetting(key);
-        if (currentValue === undefined) {
+            runtime.setEphemeralSetting(targetKey, undefined);
             return {
                 type: 'message',
-                messageType: 'error',
-                content: `Ephemeral setting '${key}' is not set`,
+                messageType: 'info',
+                content: `Ephemeral setting '${targetKey}' cleared`,
             };
         }
-        // Clear the ephemeral setting
-        // Note: SettingsService doesn't currently support ephemeral settings,
-        // so we continue to use the config directly for these session-only settings
-        config.setEphemeralSetting(key, undefined);
-        // Compression settings are now handled via ephemeral settings only
-        // No special handling needed - the unsetEphemeralSetting above handles it
-        return {
-            type: 'message',
-            messageType: 'info',
-            content: `Ephemeral setting '${key}' has been removed`,
-        };
-    },
-    completion: async (_context, partialArg) => {
-        // Get all current ephemeral settings
-        const config = _context.services.config;
-        if (!config)
-            return [];
-        const ephemeralSettings = config.getEphemeralSettings();
-        const ephemeralKeys = Object.keys(ephemeralSettings).filter((key) => ephemeralSettings[key] !== undefined);
-        // Add 'modelparam' and 'emojifilter' as completion options
-        const specialKeys = ['modelparam', 'emojifilter'];
-        const allKeys = [...ephemeralKeys, ...specialKeys];
-        if (partialArg) {
-            const parts = partialArg.split(/\s+/);
-            // If user typed "emojifilter " (with space), offer mode options
-            if (parts.length === 2 && parts[0] === 'emojifilter') {
-                const modes = ['allowed', 'auto', 'warn', 'error'];
-                if (parts[1]) {
-                    return modes.filter((mode) => mode.startsWith(parts[1]));
-                }
-                return modes;
-            }
-            // If user typed "modelparam " (with space), offer model param names
-            if (parts.length === 2 && parts[0] === 'modelparam') {
-                const providerManager = config.getProviderManager();
-                const activeProvider = providerManager?.getActiveProvider();
-                if (activeProvider &&
-                    'getModelParams' in activeProvider &&
-                    typeof activeProvider.getModelParams === 'function') {
-                    const modelParams = activeProvider.getModelParams();
-                    if (modelParams) {
-                        const paramNames = Object.keys(modelParams);
-                        if (parts[1]) {
-                            return paramNames.filter((name) => name.startsWith(parts[1]));
-                        }
-                        return paramNames;
-                    }
-                }
-                return [];
-            }
-            // If user typed "custom-headers " (with space), offer header names
-            if (parts.length === 2 && parts[0] === 'custom-headers') {
-                const headers = ephemeralSettings['custom-headers'];
-                if (headers) {
-                    const headerNames = Object.keys(headers);
-                    if (parts[1]) {
-                        return headerNames.filter((name) => name.startsWith(parts[1]));
-                    }
-                    return headerNames;
-                }
-                return [];
+        // If only key is provided, show help for that key
+        if (parts.length === 1) {
+            if (ephemeralSettingHelp[key]) {
+                return {
+                    type: 'message',
+                    messageType: 'info',
+                    content: `${key}: ${ephemeralSettingHelp[key]}`,
+                };
             }
-            // Otherwise, complete the setting key
-            return allKeys.filter((key) => key.startsWith(parts[0]));
-        }
-        return allKeys;
-    },
-};
-// Subcommand for /set modelparam
-const modelParamCommand = {
-    name: 'modelparam',
-    description: 'set model parameters like temperature, max_tokens, etc',
-    kind: CommandKind.BUILT_IN,
-    action: async (context, args) => {
-        const parts = args?.trim().split(/\s+/);
-        if (!parts || parts.length < 2) {
             return {
                 type: 'message',
                 messageType: 'error',
-                content: 'Usage: /set modelparam <key> <value>\nExample: /set modelparam temperature 0.7',
+                content: `Usage: /set ${key} <value>\n\nValid ephemeral keys:\n${Object.entries(ephemeralSettingHelp)
+                    .map(([k, v]) => `  ${k}: ${v}`)
+                    .join('\n')}`,
             };
         }
-        const key = parts[0];
-        const value = parts.slice(1).join(' ');
-        // Get provider manager from config
-        const config = context.services.config;
-        if (!config) {
+        const value = parts.slice(1).join(' '); // Join remaining parts as value
+        // List of valid ephemeral settings from the specification
+        const validEphemeralKeys = Object.keys(ephemeralSettingHelp);
+        // Check if it's a valid ephemeral key
+        if (!validEphemeralKeys.includes(key)) {
             return {
                 type: 'message',
                 messageType: 'error',
-                content: 'No configuration available',
+                content: `Invalid setting key: ${key}. Valid keys are: ${validEphemeralKeys.join(', ')}`,
             };
         }
-        const providerManager = config.getProviderManager();
-        if (!providerManager) {
-            return {
-                type: 'message',
-                messageType: 'error',
-                content: 'Provider manager not initialized',
-            };
+        // Parse the value
+        let parsedValue = parseValue(value);
+        // Validate specific settings
+        if (key === 'compression-threshold') {
+            const numValue = parsedValue;
+            if (typeof numValue !== 'number' || numValue <= 0 || numValue > 1) {
+                return {
+                    type: 'message',
+                    messageType: 'error',
+                    content: `compression-threshold must be a decimal between 0 and 1 (e.g., 0.7 for 70%)`,
+                };
+            }
         }
-        const activeProvider = providerManager.getActiveProvider();
-        if (!activeProvider) {
-            return {
-                type: 'message',
-                messageType: 'error',
-                content: 'No active provider',
-            };
+        if (key === 'context-limit') {
+            const numValue = parsedValue;
+            if (typeof numValue !== 'number' ||
+                numValue <= 0 ||
+                !Number.isInteger(numValue)) {
+                return {
+                    type: 'message',
+                    messageType: 'error',
+                    content: `context-limit must be a positive integer (e.g., 100000)`,
+                };
+            }
         }
-        // Check if provider supports setModelParams
-        if (!('setModelParams' in activeProvider) ||
-            typeof activeProvider.setModelParams !== 'function') {
-            return {
-                type: 'message',
-                messageType: 'error',
-                content: `Provider '${activeProvider.name}' does not support model parameters`,
-            };
+        // Validate socket configuration settings
+        if (key === 'socket-timeout') {
+            const numValue = parsedValue;
+            if (typeof numValue !== 'number' ||
+                numValue <= 0 ||
+                !Number.isInteger(numValue)) {
+                return {
+                    type: 'message',
+                    messageType: 'error',
+                    content: `socket-timeout must be a positive integer in milliseconds (e.g., 60000)`,
+                };
+            }
         }
-        const parsedValue = parseModelParamValue(value);
-        // Set the model parameter
-        try {
-            await activeProvider.setModelParams({ [key]: parsedValue });
-            return {
-                type: 'message',
-                messageType: 'info',
-                content: `Model parameter '${key}' set to ${JSON.stringify(parsedValue)} (use /profile save to persist)`,
-            };
+        if (key === 'socket-keepalive' || key === 'socket-nodelay') {
+            if (typeof parsedValue !== 'boolean') {
+                return {
+                    type: 'message',
+                    messageType: 'error',
+                    content: `${key} must be either 'true' or 'false'`,
+                };
+            }
         }
-        catch (error) {
-            return {
-                type: 'message',
-                messageType: 'error',
-                content: `Failed to set model parameter: ${error instanceof Error ? error.message : String(error)}`,
-            };
+        // Validate tool output settings
+        if (key === 'tool-output-max-items' ||
+            key === 'tool-output-max-tokens' ||
+            key === 'tool-output-item-size-limit' ||
+            key === 'max-prompt-tokens') {
+            const numValue = parsedValue;
+            if (typeof numValue !== 'number' ||
+                numValue <= 0 ||
+                !Number.isInteger(numValue)) {
+                return {
+                    type: 'message',
+                    messageType: 'error',
+                    content: `${key} must be a positive integer`,
+                };
+            }
         }
-    },
-    completion: async (_context, partialArg) => {
-        // Common model parameters across providers
-        const commonParams = [
-            'temperature',
-            'max_tokens',
-            'maxOutputTokens',
-            'top_p',
-            'top_k',
-            'presence_penalty',
-            'frequency_penalty',
-            'stop_sequences',
-            'seed',
-            'enable_thinking',
-        ];
-        // If user has typed part of a parameter name, filter suggestions
-        if (partialArg) {
-            const parts = partialArg.split(/\s+/);
-            if (parts.length === 1) {
-                // Still typing the parameter name
-                return commonParams.filter((param) => param.startsWith(parts[0]));
+        // Validate maxTurnsPerPrompt
+        if (key === 'maxTurnsPerPrompt') {
+            const numValue = parsedValue;
+            if (typeof numValue !== 'number' ||
+                !Number.isInteger(numValue) ||
+                (numValue !== -1 && numValue <= 0)) {
+                return {
+                    type: 'message',
+                    messageType: 'error',
+                    content: `${key} must be a positive integer or -1 for unlimited`,
+                };
             }
         }
-        return [];
-    },
-};
-export const setCommand = {
-    name: 'set',
-    description: 'set model parameters or ephemeral settings',
-    kind: CommandKind.BUILT_IN,
-    subCommands: [modelParamCommand, unsetCommand],
-    action: async (context, args) => {
-        // This handles direct ephemeral settings: /set <ephemeral-key> <value>
-        const trimmedArgs = args?.trim();
-        if (!trimmedArgs) {
-            return {
-                type: 'message',
-                messageType: 'error',
-                content: 'Usage: /set <ephemeral-key> <value>\nExample: /set context-limit 100000\n\nFor model parameters use: /set modelparam <key> <value>',
-            };
+        if (key === 'tool-output-truncate-mode') {
+            const validModes = ['warn', 'truncate', 'sample'];
+            if (!validModes.includes(parsedValue)) {
+                return {
+                    type: 'message',
+                    messageType: 'error',
+                    content: `${key} must be one of: ${validModes.join(', ')}`,
+                };
+            }
         }
-        const parts = trimmedArgs.split(/\s+/);
-        const key = parts[0];
-        // If only key is provided, show help for that key
-        if (parts.length === 1) {
-            if (ephemeralSettingHelp[key]) {
+        // Validate emojifilter mode
+        if (key === 'emojifilter') {
+            const validModes = [
+                'allowed',
+                'auto',
+                'warn',
+                'error',
+            ];
+            const normalizedValue = parsedValue.toLowerCase();
+            if (!validModes.includes(normalizedValue)) {
                 return {
                     type: 'message',
-                    messageType: 'info',
-                    content: `${key}: ${ephemeralSettingHelp[key]}`,
+                    messageType: 'error',
+                    content: `Invalid emoji filter mode '${parsedValue}'. Valid modes are: ${validModes.join(', ')}`,
                 };
             }
-            return {
-                type: 'message',
-                messageType: 'error',
-                content: `Usage: /set ${key} <value>\n\nValid ephemeral keys:\n${Object.entries(ephemeralSettingHelp)
-                    .map(([k, v]) => `  ${k}: ${v}`)
-                    .join('\n')}`,
-            };
+            // Override the parsed value with normalized lowercase version
+            parsedValue = normalizedValue;
         }
-        const value = parts.slice(1).join(' ');
-        const parseResult = parseEphemeralSettingValue(key, value);
-        if (!parseResult.success) {
-            return {
-                type: 'message',
-                messageType: 'error',
-                content: parseResult.message,
-            };
+        // Validate shell-replacement setting
+        if (key === 'shell-replacement') {
+            if (typeof parsedValue !== 'boolean') {
+                return {
+                    type: 'message',
+                    messageType: 'error',
+                    content: `shell-replacement must be either 'true' or 'false'`,
+                };
+            }
+        }
+        // Validate streaming mode
+        if (key === 'streaming') {
+            const validModes = ['enabled', 'disabled'];
+            const normalizedValue = parsedValue.toLowerCase();
+            if (!validModes.includes(normalizedValue)) {
+                return {
+                    type: 'message',
+                    messageType: 'error',
+                    content: `Invalid streaming mode '${parsedValue}'. Valid modes are: ${validModes.join(', ')}`,
+                };
+            }
+            // Override the parsed value with normalized lowercase version
+            parsedValue = normalizedValue;
         }
-        const parsedValue = parseResult.value;
         // Get the config to apply settings
         const config = context.services.config;
         if (!config) {
@@ -333,8 +692,6 @@ export const setCommand = {
                 content: 'No configuration available',
             };
         }
-        const settingsService = config.getSettingsService();
-        const useSettingsService = settingsService !== null;
         // Store compression settings as ephemeral settings
         // They will be read by geminiChat.ts when compression is needed
         if (key === 'context-limit' || key === 'compression-threshold') {
@@ -347,83 +704,42 @@ export const setCommand = {
         // They will be saved only when user explicitly saves a profile
         // Note: SettingsService doesn't currently support ephemeral settings,
         // so we continue to use the config directly for these session-only settings
-        if (useSettingsService) {
-            // When SettingsService is available, we still use config for ephemeral settings
-            // as they are session-only and not persisted to the settings file
-            config.setEphemeralSetting(key, parsedValue);
-        }
-        else {
-            // Fallback to direct config usage
-            config.setEphemeralSetting(key, parsedValue);
-        }
+        runtime.setEphemeralSetting(key, parsedValue);
         return {
             type: 'message',
             messageType: 'info',
             content: `Ephemeral setting '${key}' set to ${JSON.stringify(parsedValue)} (session only, use /profile save to persist)`,
         };
     },
-    completion: async (_context, partialArg) => {
-        // Provide completions for ephemeral settings
-        const ephemeralKeys = Object.keys(ephemeralSettingHelp);
-        if (partialArg) {
-            const parts = partialArg.split(/\s+/);
-            if (parts.length === 1) {
-                // Still typing the key
-                return ephemeralKeys.filter((key) => key.startsWith(parts[0]));
-            }
-            else if (parts.length === 2) {
-                // User has typed the key and a space, provide value completions for specific keys
-                const key = parts[0];
-                // Provide completions for tool-output-truncate-mode
-                if (key === 'tool-output-truncate-mode') {
-                    const modes = ['warn', 'truncate', 'sample'];
-                    if (parts[1]) {
-                        return modes.filter((mode) => mode.startsWith(parts[1]));
-                    }
-                    return modes;
-                }
-                // Provide completions for emojifilter
-                if (key === 'emojifilter') {
-                    const modes = ['allowed', 'auto', 'warn', 'error'];
-                    if (parts[1]) {
-                        return modes.filter((mode) => mode.startsWith(parts[1].toLowerCase()));
-                    }
-                    return modes;
-                }
-                // Provide completions for shell-replacement
-                if (key === 'shell-replacement') {
-                    const values = ['true', 'false'];
-                    if (parts[1]) {
-                        return values.filter((value) => value.startsWith(parts[1].toLowerCase()));
-                    }
-                    return values;
-                }
-                // Provide completions for streaming
-                if (key === 'streaming') {
-                    const modes = ['enabled', 'disabled'];
-                    if (parts[1]) {
-                        return modes.filter((mode) => mode.startsWith(parts[1].toLowerCase()));
-                    }
-                    return modes;
-                }
-                // Provide completions for socket boolean settings
-                if (key === 'socket-keepalive' || key === 'socket-nodelay') {
-                    const values = ['true', 'false'];
-                    if (parts[1]) {
-                        return values.filter((value) => value.startsWith(parts[1].toLowerCase()));
-                    }
-                    return values;
-                }
-                if (key === 'authOnly') {
-                    const values = ['true', 'false'];
-                    if (parts[1]) {
-                        return values.filter((value) => value.startsWith(parts[1].toLowerCase()));
-                    }
-                    return values;
-                }
-            }
-        }
-        return ephemeralKeys;
-    },
 };
+// Stryker disable all -- Parsing is covered by higher-level integration tests and mutating this
+// helper introduces hundreds of equivalent mutants unrelated to autocomplete behaviour.
+/**
+ * Parse a string value into the appropriate type.
+ * Handles numbers, booleans, and JSON objects/arrays.
+ */
+function parseValue(value) {
+    // Try to parse as number
+    if (/^-?\d+(\.\d+)?$/.test(value)) {
+        const num = Number(value);
+        if (!isNaN(num)) {
+            return num;
+        }
+    }
+    // Try to parse as boolean
+    if (value.toLowerCase() === 'true') {
+        return true;
+    }
+    if (value.toLowerCase() === 'false') {
+        return false;
+    }
+    // Try to parse as JSON
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        // If all parsing fails, return as string
+        return value;
+    }
+}
 //# sourceMappingURL=setCommand.js.map