@theia/ai-core 1.71.0-next.8 → 1.71.0

package/src/common/ai-core-preferences.ts

@@ -24,12 +24,13 @@ import {
     NOTIFICATION_TYPE_DESCRIPTIONS,
     NotificationType
 } from './notification-types';
+import { ReasoningSettings } from './language-model';
 import { PreferenceSchema } from '@theia/core/lib/common/preferences/preference-schema';
 
 export const AI_CORE_PREFERENCES_TITLE = nls.localize('theia/ai-core/preferences/title', 'AI Features');
 export const PREFERENCE_NAME_PROMPT_TEMPLATES = 'ai-features.promptTemplates.promptTemplatesFolder';
 export const PREFERENCE_NAME_REQUEST_SETTINGS = 'ai-features.modelSettings.requestSettings';
-export const PREFERENCE_NAME_THINKING_MODE = 'ai-features.thinkingMode.defaults';
+export const PREFERENCE_NAME_REASONING = 'ai-features.reasoning.defaults';
 export const PREFERENCE_NAME_MAX_RETRIES = 'ai-features.modelSettings.maxRetries';
 export const PREFERENCE_NAME_DEFAULT_NOTIFICATION_TYPE = 'ai-features.notifications.default';
 export const PREFERENCE_NAME_SKILL_DIRECTORIES = 'ai-features.skills.skillDirectories';
@@ -149,19 +150,30 @@ export const aiCorePreferenceSchema: PreferenceSchema = {
             },
             default: []
         },
-        [PREFERENCE_NAME_THINKING_MODE]: {
-            title: nls.localize('theia/ai/core/thinkingMode/title', 'Thinking Mode Settings'),
-            markdownDescription: nls.localize('theia/ai/core/thinkingMode/mdDescription',
-                'Allows specifying thinking mode settings for models that support extended thinking capabilities.\n\
-            Each setting consists of:\n\
-            - `scope`: Defines when the setting applies:\n\
-              - `modelId` (optional): The model ID to match\n\
-              - `providerId` (optional): The provider ID to match\n\
-              - `agentId` (optional): The agent ID to match\n\
-            - `thinkingMode`: Thinking mode configuration:\n\
-              - `enabled` (boolean): Whether thinking mode is enabled\n\
-              - `budgetTokens` (number, optional): Maximum tokens for thinking (if supported by the model)\n\
-            Settings are matched based on specificity (agent: 100, model: 10, provider: 1 points).'),
+        [PREFERENCE_NAME_REASONING]: {
+            title: nls.localize('theia/ai/core/reasoning/title', 'Reasoning Defaults'),
+            markdownDescription: nls.localize('theia/ai/core/reasoning/mdDescription',
+                'Default value for the chat input\'s reasoning selector, applied to models that support reasoning.\n\n'
+                + 'This is a UI-level setting: the chosen level is translated to the provider\'s native API parameters'
+                + ' at request time (e.g. Anthropic `thinking` / `output_config.effort`, OpenAI `reasoning.effort`,'
+                + ' Gemini `thinkingConfig`) and takes precedence over any raw values supplied via'
+                + ' `#ai-features.modelSettings.requestSettings#` for the same fields.\n\n'
+                + 'Each entry consists of:\n'
+                + '- `scope`: Defines when the setting applies (`modelId`, `providerId`, `agentId`).\n'
+                + '- `reasoning.level`: One of `off`, `minimal`, `low`, `medium`, `high`, `auto`.\n\n'
+                + 'Precedence at runtime (highest first): session override via the selector → this preference →'
+                + ' the model\'s declared default. Whichever the selector displays is what gets sent. To override'
+                + ' a provider\'s reasoning field manually via `#ai-features.modelSettings.requestSettings#`, set'
+                + ' `reasoning.level` to `off` here so the level-based translation is disabled.\n\n'
+                + 'Entries are matched based on scope specificity (agent: 100, model: 10, provider: 1 points).\n\n'
+                + 'Example:\n'
+                + '```json\n'
+                + '[\n'
+                + '  { "scope": { "providerId": "anthropic" }, "reasoning": { "level": "medium" } },\n'
+                + '  { "scope": { "modelId": "openai/gpt-5" }, "reasoning": { "level": "high" } },\n'
+                + '  { "scope": { "agentId": "Coder" }, "reasoning": { "level": "off" } }\n'
+                + ']\n'
+                + '```'),
             type: 'array',
             items: {
                 type: 'object',
@@ -169,37 +181,22 @@ export const aiCorePreferenceSchema: PreferenceSchema = {
                     scope: {
                         type: 'object',
                         properties: {
-                            modelId: {
-                                type: 'string',
-                                description: nls.localize('theia/ai/core/thinkingMode/scope/modelId/description', 'The (optional) model id')
-                            },
-                            providerId: {
-                                type: 'string',
-                                description: nls.localize('theia/ai/core/thinkingMode/scope/providerId/description', 'The (optional) provider id to apply the settings to.')
-                            },
-                            agentId: {
-                                type: 'string',
-                                description: nls.localize('theia/ai/core/thinkingMode/scope/agentId/description', 'The (optional) agent id to apply the settings to.')
-                            }
+                            modelId: { type: 'string' },
+                            providerId: { type: 'string' },
+                            agentId: { type: 'string' }
                         }
                     },
-                    thinkingMode: {
+                    reasoning: {
                         type: 'object',
                         additionalProperties: false,
-                        description: nls.localize('theia/ai/core/thinkingMode/thinkingMode/description', 'Thinking mode configuration.'),
                         properties: {
-                            enabled: {
-                                type: 'boolean',
-                                default: false,
-                                description: nls.localize('theia/ai/core/thinkingMode/thinkingMode/enabled/description', 'Whether thinking mode is enabled.')
-                            },
-                            budgetTokens: {
-                                type: 'number',
-                                description: nls.localize('theia/ai/core/thinkingMode/thinkingMode/budgetTokens/description',
-                                    'Maximum tokens to use for thinking. Only applicable if the model supports thinking budget.')
+                            level: {
+                                type: 'string',
+                                enum: ['off', 'minimal', 'low', 'medium', 'high', 'auto'],
+                                default: 'auto'
                             }
                         },
-                        required: ['enabled']
+                        required: ['level']
                     }
                 },
                 additionalProperties: false
@@ -236,7 +233,7 @@ export const aiCorePreferenceSchema: PreferenceSchema = {
 export interface AICoreConfiguration {
     [PREFERENCE_NAME_PROMPT_TEMPLATES]: string | undefined;
     [PREFERENCE_NAME_REQUEST_SETTINGS]: Array<RequestSetting> | undefined;
-    [PREFERENCE_NAME_THINKING_MODE]: Array<ThinkingModeSetting> | undefined;
+    [PREFERENCE_NAME_REASONING]: Array<ReasoningPreferenceEntry> | undefined;
     [PREFERENCE_NAME_MAX_RETRIES]: number | undefined;
     [PREFERENCE_NAME_DEFAULT_NOTIFICATION_TYPE]: NotificationType | undefined;
     [PREFERENCE_NAME_SKILL_DIRECTORIES]: string[] | undefined;
@@ -254,9 +251,9 @@ export interface Scope {
     agentId?: string;
 }
 
-export interface ThinkingModeSetting {
+export interface ReasoningPreferenceEntry {
     scope?: Scope;
-    thinkingMode?: { enabled: boolean; budgetTokens?: number };
+    reasoning?: ReasoningSettings;
 }
 
 export const AICorePreferences = Symbol('AICorePreferences');

package/src/common/language-model.ts

@@ -19,9 +19,27 @@ import { inject, injectable, named, postConstruct } from '@theia/core/shared/inv
 
 export type MessageActor = 'user' | 'ai' | 'system';
 
-export interface ThinkingModeSettings {
-    enabled: boolean;
-    budgetTokens?: number;
+/** Provider-agnostic reasoning level; each provider maps this to its native API. */
+export type ReasoningLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'auto';
+
+export interface ReasoningSettings {
+    level: ReasoningLevel;
+}
+
+/**
+ * Shape of a model's reasoning parameter in its native API.
+ * - `'effort'`: discrete effort enum.
+ * - `'budget'`: numeric token budget.
+ */
+export type ReasoningApi = 'effort' | 'budget';
+
+/**
+ * Declares a model's reasoning capabilities. When unset, the chat UI hides the
+ * reasoning selector and providers ignore the `reasoning` field on requests.
+ */
+export interface ReasoningSupport {
+    readonly supportedLevels: ReadonlyArray<ReasoningLevel>;
+    readonly defaultLevel?: ReasoningLevel;
 }
 
 export type LanguageModelMessage = TextMessage | ThinkingMessage | ToolUseMessage | ToolResultMessage | ImageMessage;
@@ -272,7 +290,8 @@ export interface LanguageModelRequest {
     response_format?: { type: 'text' } | { type: 'json_object' } | ResponseFormatJsonSchema;
     settings?: { [key: string]: unknown };
     clientSettings?: { keepToolCalls: boolean; keepThinking: boolean };
-    thinkingMode?: ThinkingModeSettings;
+    /** Provider-agnostic reasoning configuration; providers translate it to their native API. */
+    reasoning?: ReasoningSettings;
 }
 export interface ResponseFormatJsonSchema {
     type: 'json_schema';
@@ -323,6 +342,7 @@ export interface UserRequest extends LanguageModelRequest {
 
 export interface LanguageModelTextResponse {
     text: string;
+    usage?: UsageResponsePart;
 }
 export const isLanguageModelTextResponse = (obj: unknown): obj is LanguageModelTextResponse =>
     !!(obj && typeof obj === 'object' && 'text' in obj && typeof (obj as { text: unknown }).text === 'string');
@@ -335,6 +355,8 @@ export const isLanguageModelStreamResponsePart = (part: unknown): part is Langua
 export interface UsageResponsePart {
     input_tokens: number;
     output_tokens: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
 }
 export const isUsageResponsePart = (part: unknown): part is UsageResponsePart =>
     !!(part && typeof part === 'object' &&
@@ -414,6 +436,7 @@ export const isLanguageModelStreamResponse = (obj: unknown): obj is LanguageMode
 export interface LanguageModelParsedResponse {
     parsed: unknown;
     content: string;
+    usage?: UsageResponsePart;
 }
 export const isLanguageModelParsedResponse = (obj: unknown): obj is LanguageModelParsedResponse =>
     !!(obj && typeof obj === 'object' && 'parsed' in obj && 'content' in obj);
@@ -437,6 +460,7 @@ export interface LanguageModelMetaData {
     readonly maxInputTokens?: number;
     readonly maxOutputTokens?: number;
     readonly status: LanguageModelStatus;
+    readonly reasoningSupport?: ReasoningSupport;
 }
 
 export namespace LanguageModelMetaData {

package/src/common/settings-service.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import { Event } from '@theia/core';
-import { LanguageModelRequirement } from './language-model';
+import { LanguageModelRequirement, ReasoningSettings } from './language-model';
 import { NotificationType } from './notification-types';
 import { GenericCapabilitySelections } from './capability-utils';
 
@@ -58,4 +58,10 @@ export interface AgentSettings {
      * Stores selected IDs for each capability type.
      */
     genericCapabilitySelections?: GenericCapabilitySelections;
+    /**
+     * Persisted reasoning selection for this agent. When set, the chat input's reasoning selector
+     * is initialized to this value at session start instead of falling back to the preference
+     * default or the model's declared default.
+     */
+    reasoning?: ReasoningSettings;
 }

package/src/node/backend-language-model-registry.ts

@@ -62,6 +62,7 @@ export class BackendLanguageModelRegistryImpl extends DefaultLanguageModelRegist
             family: model.family,
             maxInputTokens: model.maxInputTokens,
             maxOutputTokens: model.maxOutputTokens,
+            reasoningSupport: model.reasoningSupport,
         };
     }
 }