@adecore/agents 0.31.3 → 0.31.4

package/dist/chat/acp-backend.js

@@ -2,7 +2,7 @@ import { readFileSync } from 'node:fs';
 import { attachmentImageMime } from '@adecore/agent-contracts';
 import { errorText } from '../error-text.js';
 import { MODE_ORDER } from '../modes.js';
-import { ACP_AUTH_REQUIRED, ACP_PROTOCOL_VERSION, AcpProtocol, acpStopWords, autoAllows, parseInitialize, parseSessionInfo, promptUsageOf, resolveAcpMode, runtimeModeOf, sessionIdOf } from './acp-protocol.js';
+import { ACP_AUTH_REQUIRED, ACP_PROTOCOL_VERSION, AcpProtocol, acpStopWords, autoAllows, parseInitialize, parseSessionInfo, promptUsageOf, resolveAcpMode, runtimeModeOf, sessionIdOf, thoughtLevelOf } from './acp-protocol.js';
 import { attachmentNote } from './input.js';
 import { JsonRpcError, JsonRpcTransport } from './json-rpc-transport.js';
 export const DEFAULT_ACP_CLIENT = { name: 'agents', title: 'Agents', version: '0.1.0' };
@@ -86,9 +86,9 @@ export class AcpBackend {
         this.capabilities = capabilities;
         const info = await this.openSession(transport, capabilities);
         const modeId = await this.applyMode(transport, info);
-        const model = await this.applyModel(transport, info);
+        const { model, thoughtLevel } = await this.applyModel(transport, info);
         this.model = model;
-        await this.applyThoughtLevel(transport, info);
+        await this.applyThoughtLevel(transport, thoughtLevel);
         this.spec.onSession?.(info);
         this.emit({
             type: 'session',
@@ -191,25 +191,29 @@ export class AcpBackend {
         }
         return resolved.modeId;
     }
-    /* Switches to the selected model where the agent offers it; answers the model the session runs. */
+    /*
+     * Switches to the selected model where the agent offers it; answers the model the session runs and the
+     * reasoning effort it offers there, which may change with the model.
+     */
     async applyModel(transport, info) {
         const models = info.models;
+        const thoughtLevel = info.thoughtLevel;
         const wanted = this.spec.model ? this.spec.model(this.launch.selection) : this.launch.selection.model;
         if (models === null || wanted === null || wanted === models.current) {
-            return models?.current ?? wanted;
+            return { model: models?.current ?? wanted, thoughtLevel };
         }
         if (!models.models.some((model) => model.id === wanted)) {
             this.emit({ type: 'note', level: 'warning', text: `${this.spec.name} does not offer ${this.launch.modelName}. It runs ${models.current}.` });
-            return models.current;
+            return { model: models.current, thoughtLevel };
         }
         try {
             if (models.configId === null) {
                 await transport.request('session/set_model', { sessionId: this.sessionId, modelId: wanted });
+                return { model: wanted, thoughtLevel };
             }
-            else {
-                await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: models.configId, value: wanted });
-            }
-            return wanted;
+            const result = await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: models.configId, value: wanted });
+            const after = thoughtLevelOf(result);
+            return { model: wanted, thoughtLevel: after === undefined ? thoughtLevel : after };
         }
         catch (error) {
             if (!(error instanceof JsonRpcError)) {
@@ -220,20 +224,26 @@ export class AcpBackend {
                 level: 'warning',
                 text: `${this.spec.name} did not switch to ${this.launch.modelName} (${errorText(error)}). It runs ${models.current}.`
             });
-            return models.current;
+            return { model: models.current, thoughtLevel };
         }
     }
-    async applyThoughtLevel(transport, info) {
-        const level = info.thoughtLevel;
+    /* Sets the selected effort where the session offers it; a model without one runs as it is. */
+    async applyThoughtLevel(transport, level) {
         const effort = this.launch.selection.options.effort;
-        if (level === null || typeof effort !== 'string' || effort === level.current || !level.values.includes(effort)) {
+        const choice = level?.choices.find((entry) => entry.id === effort);
+        if (level === null || choice === undefined || effort === level.current) {
             return;
         }
-        await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: level.configId, value: effort }).catch((error) => {
+        try {
+            await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: level.configId, value: choice.id });
+        }
+        catch (error) {
             if (!(error instanceof JsonRpcError)) {
                 throw error;
             }
-        });
+            const current = level.choices.find((entry) => entry.id === level.current)?.name ?? level.current;
+            this.emit({ type: 'note', level: 'warning', text: `${this.spec.name} kept its reasoning at ${current} instead of ${choice.name}.` });
+        }
     }
     promptBlocks(input) {
         const sendsImages = this.capabilities?.images === true;

package/dist/chat/acp-protocol.d.ts

@@ -52,17 +52,24 @@ export interface AcpModeState {
     modes: AcpMode[];
     configId: string | null;
 }
+export interface AcpChoice {
+    id: string;
+    name: string;
+    description: string | null;
+}
+export interface AcpThoughtLevel {
+    configId: string;
+    current: string;
+    choices: AcpChoice[];
+}
 export interface AcpSessionInfo {
     sessionId: string;
     agent: AcpAgentInfo | null;
     models: AcpModelState | null;
     modes: AcpModeState | null;
-    thoughtLevel: {
-        configId: string;
-        current: string;
-        values: string[];
-    } | null;
+    thoughtLevel: AcpThoughtLevel | null;
 }
+export declare function thoughtLevelOf(result: unknown): AcpThoughtLevel | null | undefined;
 export declare function parseSessionInfo(result: unknown, sessionId: string, agent: AcpAgentInfo | null): AcpSessionInfo;
 export declare function sessionIdOf(result: unknown): string | null;
 export type AcpModeMap = Partial<Record<RuntimeMode, readonly string[]>>;

package/dist/chat/acp-protocol.js

@@ -75,7 +75,7 @@ const ModeStateSchema = z.looseObject({
     availableModes: z.array(z.unknown())
 });
 const ModeSchema = z.looseObject({ id: z.string(), name: z.string() });
-const SelectValueSchema = z.looseObject({ value: z.string(), name: z.string() });
+const SelectValueSchema = z.looseObject({ value: z.string(), name: z.string(), description: z.string().nullish() });
 const ConfigOptionSchema = z.looseObject({
     id: z.string(),
     name: z.string(),
@@ -144,6 +144,18 @@ function selectValues(option) {
 function selectOption(options, category) {
     return options.find((option) => option.type === 'select' && option.category === category && typeof option.currentValue === 'string') ?? null;
 }
+function thoughtOption(options) {
+    return (selectOption(options, 'thought_level') ??
+        options.find((option) => option.type === 'select' && option.id === 'reasoning_effort' && typeof option.currentValue === 'string') ??
+        null);
+}
+/* The reasoning effort in a response that carries the session's config options; undefined when it carries none. */
+export function thoughtLevelOf(result) {
+    if (!isRecord(result) || !Array.isArray(result.configOptions)) {
+        return undefined;
+    }
+    return sessionState(validItems(ConfigOptionSchema, result.configOptions), null, null).thoughtLevel;
+}
 export function parseSessionInfo(result, sessionId, agent) {
     const record = isRecord(result) ? result : {};
     const options = validItems(ConfigOptionSchema, Array.isArray(record.configOptions) ? record.configOptions : []);
@@ -152,7 +164,7 @@ export function parseSessionInfo(result, sessionId, agent) {
 function sessionState(options, modes, models) {
     const modelOption = selectOption(options, 'model');
     const modeOption = selectOption(options, 'mode');
-    const thoughtOption = selectOption(options, 'thought_level');
+    const thought = thoughtOption(options);
     const modeState = ModeStateSchema.safeParse(modes);
     const modelState = ModelStateSchema.safeParse(models);
     return {
@@ -186,8 +198,12 @@ function sessionState(options, modes, models) {
                     configId: null
                 }
                 : null,
-        thoughtLevel: thoughtOption
-            ? { configId: thoughtOption.id, current: thoughtOption.currentValue, values: selectValues(thoughtOption).map((value) => value.value) }
+        thoughtLevel: thought
+            ? {
+                configId: thought.id,
+                current: thought.currentValue,
+                choices: selectValues(thought).map((value) => ({ id: value.value, name: value.name, description: value.description ?? null }))
+            }
             : null
     };
 }

package/dist/chat/index.d.ts

@@ -1,5 +1,5 @@
 export { type AcpAgentSpec, type AcpClientInfo, type AcpUsageReport, createAcpBackend } from './acp-backend.ts';
-export type { AcpAgentInfo, AcpModel, AcpModelState, AcpMode, AcpModeState, AcpPermissionRequest, AcpSessionInfo, AcpModeMap, AcpTurnUsage } from './acp-protocol.ts';
+export type { AcpAgentInfo, AcpModel, AcpModelState, AcpMode, AcpModeState, AcpPermissionRequest, AcpSessionInfo, AcpModeMap, AcpChoice, AcpThoughtLevel, AcpTurnUsage } from './acp-protocol.ts';
 export { AttachmentStore } from './attachment-store.ts';
 export type { BackendLaunch, TurnInput, ApprovalDecision, BackendEvent, BackendHost, ChatBackend } from './backend.ts';
 export { runningInBackground, type BackgroundWork } from './background-work.ts';

package/dist/providers/acp-provider.js

@@ -29,11 +29,31 @@ const OWN_USAGE_FILES = new Set(['grok']);
 function adoptableModels(info) {
     return (info.models?.models ?? []).filter((model) => model.id !== '' && !model.id.startsWith('-')).map((model) => ({ slug: model.id, name: model.name }));
 }
+/* The reasoning effort a session offers, as the `effort` option the composer draws for every provider. */
+function effortOption(info) {
+    const level = info.thoughtLevel;
+    if (level === null || !level.choices.some((choice) => choice.id === level.current)) {
+        return [];
+    }
+    return [
+        {
+            id: 'effort',
+            label: 'Reasoning',
+            type: 'select',
+            defaultChoice: level.current,
+            choices: level.choices.map((choice) => ({
+                id: choice.id,
+                label: choice.name,
+                ...(choice.description === null ? {} : { description: choice.description })
+            }))
+        }
+    ];
+}
 export function createAcpProvider(spec) {
     const capabilities = { ...ACP_CAPABILITIES, ...spec.capabilities };
     const onSession = (info) => {
         if (spec.adoptModels !== false && info.models !== null) {
-            spec.catalog.adopt(adoptableModels(info), info.models.current);
+            spec.catalog.adopt(adoptableModels(info), info.models.current, effortOption(info));
         }
         spec.onSession?.(info);
     };

package/dist/providers/catalog.d.ts

@@ -1,4 +1,4 @@
-import type { ModelCatalogData, ModelInfo, ModelSelection } from '@adecore/agent-contracts';
+import type { ModelCatalogData, ModelInfo, ModelOptionDescriptor, ModelSelection } from '@adecore/agent-contracts';
 export type ModelCatalogInput = Omit<ModelCatalogData, 'updatedAt'> & {
     updatedAt?: string;
 };
@@ -11,7 +11,7 @@ export declare class ModelCatalog {
     adopt(models: ReadonlyArray<{
         slug: string;
         name: string;
-    }>, defaultModel: string): boolean;
+    }>, defaultModel: string, options?: readonly ModelOptionDescriptor[]): boolean;
     list(): ModelInfo[];
     nameOf(slug: string): string;
     resolveModel(name: string): string | null;

package/dist/providers/catalog.js

@@ -30,13 +30,16 @@ export class ModelCatalog {
     /*
      * Takes the models an agent reported for itself in place of the list, the agent's current model as the
      * default and its order kept; answers whether the models changed. Every model gets the profile the
-     * default has now, as an agent names its models but not what each can be asked for.
+     * default has now, as an agent names its models but not what each can be asked for, with `options`
+     * in place of the profile's options of the same id.
      */
-    adopt(models, defaultModel) {
+    adopt(models, defaultModel, options = []) {
         if (models.length === 0 || !models.some((model) => model.slug === defaultModel)) {
             return false;
         }
-        const profile = this.profileOf(this.data.defaultModel) ?? { options: [], contextWindowTokens: {} };
+        const base = this.profileOf(this.data.defaultModel) ?? { options: [], contextWindowTokens: {} };
+        const replaced = new Set(options.map((option) => option.id));
+        const profile = { ...base, options: [...base.options.filter((option) => !replaced.has(option.id)), ...options] };
         const data = {
             ...(this.data.updatedAt === undefined ? {} : { updatedAt: this.data.updatedAt }),
             defaultModel,

package/dist/testing/fake-acp.d.ts

@@ -7,6 +7,7 @@ export interface FakeAcpOptions {
     legacyModels?: boolean;
     closeSession?: boolean;
     turnUsage?: Record<string, number>;
+    reasoningEffort?: 'accept' | 'reject';
 }
 export declare function fakeAcpWith(options: FakeAcpOptions): FakeCli;
 export declare const fakeAcp: FakeCli;

package/dist/testing/fake-acp.js

@@ -7,6 +7,7 @@ export function fakeAcpWith(options) {
         let sessionId = '';
         let mode = modes[0] ?? '';
         let model = 'fake-small';
+        let effort = 'low';
         let serverRequestId = 0;
         let callCounter = 0;
         let prompt = null;
@@ -41,11 +42,24 @@ export function fakeAcpWith(options) {
                 { value: 'fake-small', name: 'Fake small' },
                 { value: 'fake-large', name: 'Fake large' }
             ];
+            const effortChoices = [
+                { value: 'low', name: 'Low', description: 'Answers quickly' },
+                { value: 'high', name: 'High' },
+                ...(model === 'fake-large' ? [{ value: 'xhigh', name: 'Extra high' }] : [])
+            ];
+            const effortOption = options.reasoningEffort === undefined
+                ? []
+                : [{ id: 'reasoning_effort', name: 'Reasoning effort', type: 'select', currentValue: effort, options: effortChoices }];
             return {
                 ...(modes.length === 0 ? {} : { modes: { currentModeId: mode, availableModes: modes.map((id) => ({ id, name: id })) } }),
                 ...(options.legacyModels
                     ? { models: { currentModelId: model, availableModels: modelChoices.map((choice) => ({ modelId: choice.value, name: choice.name })) } }
-                    : { configOptions: [{ id: 'model', name: 'Model', type: 'select', category: 'model', currentValue: model, options: modelChoices }] })
+                    : {
+                        configOptions: [
+                            { id: 'model', name: 'Model', type: 'select', category: 'model', currentValue: model, options: modelChoices },
+                            ...effortOption
+                        ]
+                    })
             };
         };
         const askPermission = (toolCall, onAnswer) => {
@@ -241,6 +255,13 @@ export function fakeAcpWith(options) {
                     if (params.configId === 'model') {
                         model = String(params.value);
                     }
+                    if (params.configId === 'reasoning_effort') {
+                        if (options.reasoningEffort === 'reject') {
+                            refuse(id, -32602, 'Reasoning effort is locked');
+                            return;
+                        }
+                        effort = String(params.value);
+                    }
                     respond(id, { configOptions: sessionState().configOptions ?? [] });
                     return;
                 case 'session/prompt':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adecore/agents",
-  "version": "0.31.3",
+  "version": "0.31.4",
   "description": "Node-compatible agent chat hosts, providers, accounts, usage and durable task coordination.",
   "type": "module",
   "exports": {
@@ -81,8 +81,8 @@
     "test": "bun --conditions=source test"
   },
   "dependencies": {
-    "@adecore/agent-contracts": "0.31.3",
-    "@adecore/intelligent-ui": "0.31.3",
+    "@adecore/agent-contracts": "0.31.4",
+    "@adecore/intelligent-ui": "0.31.4",
     "zod": "^4.6.5"
   },
   "devDependencies": {

package/src/chat/acp-backend.ts

@@ -14,10 +14,12 @@ import {
     resolveAcpMode,
     runtimeModeOf,
     sessionIdOf,
+    thoughtLevelOf,
     type AcpAgentCapabilities,
     type AcpModeMap,
     type AcpPermissionRequest,
     type AcpSessionInfo,
+    type AcpThoughtLevel,
     type AcpTurnUsage
 } from './acp-protocol.ts';
 import type { ApprovalDecision, BackendEvent, BackendHost, BackendLaunch, ChatBackend, TurnInput } from './backend.ts';
@@ -154,9 +156,9 @@ export class AcpBackend implements ChatBackend {
         this.capabilities = capabilities;
         const info = await this.openSession(transport, capabilities);
         const modeId = await this.applyMode(transport, info);
-        const model = await this.applyModel(transport, info);
+        const { model, thoughtLevel } = await this.applyModel(transport, info);
         this.model = model;
-        await this.applyThoughtLevel(transport, info);
+        await this.applyThoughtLevel(transport, thoughtLevel);
         this.spec.onSession?.(info);
         this.emit({
             type: 'session',
@@ -263,24 +265,29 @@ export class AcpBackend implements ChatBackend {
         return resolved.modeId;
     }
 
-    /* Switches to the selected model where the agent offers it; answers the model the session runs. */
-    private async applyModel(transport: JsonRpcTransport, info: AcpSessionInfo): Promise<string | null> {
+    /*
+     * Switches to the selected model where the agent offers it; answers the model the session runs and the
+     * reasoning effort it offers there, which may change with the model.
+     */
+    private async applyModel(transport: JsonRpcTransport, info: AcpSessionInfo): Promise<{ model: string | null; thoughtLevel: AcpThoughtLevel | null }> {
         const models = info.models;
+        const thoughtLevel = info.thoughtLevel;
         const wanted = this.spec.model ? this.spec.model(this.launch.selection) : this.launch.selection.model;
         if (models === null || wanted === null || wanted === models.current) {
-            return models?.current ?? wanted;
+            return { model: models?.current ?? wanted, thoughtLevel };
         }
         if (!models.models.some((model) => model.id === wanted)) {
             this.emit({ type: 'note', level: 'warning', text: `${this.spec.name} does not offer ${this.launch.modelName}. It runs ${models.current}.` });
-            return models.current;
+            return { model: models.current, thoughtLevel };
         }
         try {
             if (models.configId === null) {
                 await transport.request('session/set_model', { sessionId: this.sessionId, modelId: wanted });
-            } else {
-                await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: models.configId, value: wanted });
+                return { model: wanted, thoughtLevel };
             }
-            return wanted;
+            const result = await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: models.configId, value: wanted });
+            const after = thoughtLevelOf(result);
+            return { model: wanted, thoughtLevel: after === undefined ? thoughtLevel : after };
         } catch (error) {
             if (!(error instanceof JsonRpcError)) {
                 throw error;
@@ -290,21 +297,26 @@ export class AcpBackend implements ChatBackend {
                 level: 'warning',
                 text: `${this.spec.name} did not switch to ${this.launch.modelName} (${errorText(error)}). It runs ${models.current}.`
             });
-            return models.current;
+            return { model: models.current, thoughtLevel };
         }
     }
 
-    private async applyThoughtLevel(transport: JsonRpcTransport, info: AcpSessionInfo): Promise<void> {
-        const level = info.thoughtLevel;
+    /* Sets the selected effort where the session offers it; a model without one runs as it is. */
+    private async applyThoughtLevel(transport: JsonRpcTransport, level: AcpThoughtLevel | null): Promise<void> {
         const effort = this.launch.selection.options.effort;
-        if (level === null || typeof effort !== 'string' || effort === level.current || !level.values.includes(effort)) {
+        const choice = level?.choices.find((entry) => entry.id === effort);
+        if (level === null || choice === undefined || effort === level.current) {
             return;
         }
-        await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: level.configId, value: effort }).catch((error: unknown) => {
+        try {
+            await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: level.configId, value: choice.id });
+        } catch (error) {
             if (!(error instanceof JsonRpcError)) {
                 throw error;
             }
-        });
+            const current = level.choices.find((entry) => entry.id === level.current)?.name ?? level.current;
+            this.emit({ type: 'note', level: 'warning', text: `${this.spec.name} kept its reasoning at ${current} instead of ${choice.name}.` });
+        }
     }
 
     private promptBlocks(input: TurnInput): unknown[] {

package/src/chat/acp-protocol.ts

@@ -107,7 +107,7 @@ const ModeStateSchema = z.looseObject({
 
 const ModeSchema = z.looseObject({ id: z.string(), name: z.string() });
 
-const SelectValueSchema = z.looseObject({ value: z.string(), name: z.string() });
+const SelectValueSchema = z.looseObject({ value: z.string(), name: z.string(), description: z.string().nullish() });
 
 const ConfigOptionSchema = z.looseObject({
     id: z.string(),
@@ -221,14 +221,27 @@ export interface AcpModeState {
     configId: string | null;
 }
 
+export interface AcpChoice {
+    id: string;
+    name: string;
+    description: string | null;
+}
+
+/* The reasoning effort a session offers: the config option that sets it, the value it runs at and the values it takes. */
+export interface AcpThoughtLevel {
+    configId: string;
+    current: string;
+    choices: AcpChoice[];
+}
+
 /* What `session/new`, `session/load` or `session/resume` said about the session, for a host that fills its catalog from it. */
 export interface AcpSessionInfo {
     sessionId: string;
     agent: AcpAgentInfo | null;
     models: AcpModelState | null;
     modes: AcpModeState | null;
-    // The reasoning effort a session offers, as a config option with the `thought_level` category.
-    thoughtLevel: { configId: string; current: string; values: string[] } | null;
+    // A config option of the `thought_level` category, or one with the id `reasoning_effort` where an agent sets no category.
+    thoughtLevel: AcpThoughtLevel | null;
 }
 
 type ConfigOption = z.infer<typeof ConfigOptionSchema>;
@@ -243,6 +256,22 @@ function selectOption(options: ConfigOption[], category: string): ConfigOption |
     return options.find((option) => option.type === 'select' && option.category === category && typeof option.currentValue === 'string') ?? null;
 }
 
+function thoughtOption(options: ConfigOption[]): ConfigOption | null {
+    return (
+        selectOption(options, 'thought_level') ??
+        options.find((option) => option.type === 'select' && option.id === 'reasoning_effort' && typeof option.currentValue === 'string') ??
+        null
+    );
+}
+
+/* The reasoning effort in a response that carries the session's config options; undefined when it carries none. */
+export function thoughtLevelOf(result: unknown): AcpThoughtLevel | null | undefined {
+    if (!isRecord(result) || !Array.isArray(result.configOptions)) {
+        return undefined;
+    }
+    return sessionState(validItems(ConfigOptionSchema, result.configOptions), null, null).thoughtLevel;
+}
+
 export function parseSessionInfo(result: unknown, sessionId: string, agent: AcpAgentInfo | null): AcpSessionInfo {
     const record = isRecord(result) ? result : {};
     const options = validItems(ConfigOptionSchema, Array.isArray(record.configOptions) ? record.configOptions : []);
@@ -252,7 +281,7 @@ export function parseSessionInfo(result: unknown, sessionId: string, agent: AcpA
 function sessionState(options: ConfigOption[], modes: unknown, models: unknown): Omit<AcpSessionInfo, 'sessionId' | 'agent'> {
     const modelOption = selectOption(options, 'model');
     const modeOption = selectOption(options, 'mode');
-    const thoughtOption = selectOption(options, 'thought_level');
+    const thought = thoughtOption(options);
     const modeState = ModeStateSchema.safeParse(modes);
     const modelState = ModelStateSchema.safeParse(models);
     return {
@@ -286,8 +315,12 @@ function sessionState(options: ConfigOption[], modes: unknown, models: unknown):
                     configId: null
                 }
               : null,
-        thoughtLevel: thoughtOption
-            ? { configId: thoughtOption.id, current: thoughtOption.currentValue as string, values: selectValues(thoughtOption).map((value) => value.value) }
+        thoughtLevel: thought
+            ? {
+                  configId: thought.id,
+                  current: thought.currentValue as string,
+                  choices: selectValues(thought).map((value) => ({ id: value.value, name: value.name, description: value.description ?? null }))
+              }
             : null
     };
 }

package/src/chat/index.ts

@@ -9,6 +9,8 @@ export type {
     AcpPermissionRequest,
     AcpSessionInfo,
     AcpModeMap,
+    AcpChoice,
+    AcpThoughtLevel,
     AcpTurnUsage
 } from './acp-protocol.ts';
 export { AttachmentStore } from './attachment-store.ts';

package/src/providers/acp-provider.ts

@@ -1,4 +1,4 @@
-import type { AgentKind, ProviderCapabilities, ProviderInstall } from '@adecore/agent-contracts';
+import type { AgentKind, ModelOptionDescriptor, ProviderCapabilities, ProviderInstall } from '@adecore/agent-contracts';
 import { createAcpBackend, type AcpAgentSpec, type AcpUsageReport } from '../chat/acp-backend.ts';
 import type { AcpSessionInfo } from '../chat/acp-protocol.ts';
 import { askAcpAccount } from './accounts/acp-account.ts';
@@ -66,11 +66,32 @@ function adoptableModels(info: AcpSessionInfo): Array<{ slug: string; name: stri
     return (info.models?.models ?? []).filter((model) => model.id !== '' && !model.id.startsWith('-')).map((model) => ({ slug: model.id, name: model.name }));
 }
 
+/* The reasoning effort a session offers, as the `effort` option the composer draws for every provider. */
+function effortOption(info: AcpSessionInfo): ModelOptionDescriptor[] {
+    const level = info.thoughtLevel;
+    if (level === null || !level.choices.some((choice) => choice.id === level.current)) {
+        return [];
+    }
+    return [
+        {
+            id: 'effort',
+            label: 'Reasoning',
+            type: 'select',
+            defaultChoice: level.current,
+            choices: level.choices.map((choice) => ({
+                id: choice.id,
+                label: choice.name,
+                ...(choice.description === null ? {} : { description: choice.description })
+            }))
+        }
+    ];
+}
+
 export function createAcpProvider(spec: AcpProviderSpec): ChatProvider {
     const capabilities = { ...ACP_CAPABILITIES, ...spec.capabilities };
     const onSession = (info: AcpSessionInfo): void => {
         if (spec.adoptModels !== false && info.models !== null) {
-            spec.catalog.adopt(adoptableModels(info), info.models.current);
+            spec.catalog.adopt(adoptableModels(info), info.models.current, effortOption(info));
         }
         spec.onSession?.(info);
     };

package/src/providers/catalog.ts

@@ -1,4 +1,4 @@
-import type { ModelCatalogData, ModelCatalogProfile, ModelInfo, ModelSelection } from '@adecore/agent-contracts';
+import type { ModelCatalogData, ModelCatalogProfile, ModelInfo, ModelOptionDescriptor, ModelSelection } from '@adecore/agent-contracts';
 import manifest from './claude-models.json' with { type: 'json' };
 
 // What a host builds a catalog from; one that is never replaced needs no date.
@@ -41,13 +41,16 @@ export class ModelCatalog {
     /*
      * Takes the models an agent reported for itself in place of the list, the agent's current model as the
      * default and its order kept; answers whether the models changed. Every model gets the profile the
-     * default has now, as an agent names its models but not what each can be asked for.
+     * default has now, as an agent names its models but not what each can be asked for, with `options`
+     * in place of the profile's options of the same id.
      */
-    adopt(models: ReadonlyArray<{ slug: string; name: string }>, defaultModel: string): boolean {
+    adopt(models: ReadonlyArray<{ slug: string; name: string }>, defaultModel: string, options: readonly ModelOptionDescriptor[] = []): boolean {
         if (models.length === 0 || !models.some((model) => model.slug === defaultModel)) {
             return false;
         }
-        const profile = this.profileOf(this.data.defaultModel) ?? { options: [], contextWindowTokens: {} };
+        const base = this.profileOf(this.data.defaultModel) ?? { options: [], contextWindowTokens: {} };
+        const replaced = new Set(options.map((option) => option.id));
+        const profile = { ...base, options: [...base.options.filter((option) => !replaced.has(option.id)), ...options] };
         const data: ModelCatalogInput = {
             ...(this.data.updatedAt === undefined ? {} : { updatedAt: this.data.updatedAt }),
             defaultModel,

package/src/testing/fake-acp.ts

@@ -24,6 +24,9 @@ export interface FakeAcpOptions {
     closeSession?: boolean;
     // The `usage` every `session/prompt` response carries; absent reports none.
     turnUsage?: Record<string, number>;
+    // Offers a reasoning effort as the config option `reasoning_effort`, without a category: Low and High, and
+    // Extra high on `fake-large`. `reject` refuses every change to it.
+    reasoningEffort?: 'accept' | 'reject';
 }
 
 export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
@@ -33,6 +36,7 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
         let sessionId = '';
         let mode = modes[0] ?? '';
         let model = 'fake-small';
+        let effort = 'low';
         let serverRequestId = 0;
         let callCounter = 0;
         let prompt: { rpcId: number | string; cancelled: boolean } | null = null;
@@ -74,11 +78,25 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
                 { value: 'fake-small', name: 'Fake small' },
                 { value: 'fake-large', name: 'Fake large' }
             ];
+            const effortChoices = [
+                { value: 'low', name: 'Low', description: 'Answers quickly' },
+                { value: 'high', name: 'High' },
+                ...(model === 'fake-large' ? [{ value: 'xhigh', name: 'Extra high' }] : [])
+            ];
+            const effortOption =
+                options.reasoningEffort === undefined
+                    ? []
+                    : [{ id: 'reasoning_effort', name: 'Reasoning effort', type: 'select', currentValue: effort, options: effortChoices }];
             return {
                 ...(modes.length === 0 ? {} : { modes: { currentModeId: mode, availableModes: modes.map((id) => ({ id, name: id })) } }),
                 ...(options.legacyModels
                     ? { models: { currentModelId: model, availableModels: modelChoices.map((choice) => ({ modelId: choice.value, name: choice.name })) } }
-                    : { configOptions: [{ id: 'model', name: 'Model', type: 'select', category: 'model', currentValue: model, options: modelChoices }] })
+                    : {
+                          configOptions: [
+                              { id: 'model', name: 'Model', type: 'select', category: 'model', currentValue: model, options: modelChoices },
+                              ...effortOption
+                          ]
+                      })
             };
         };
 
@@ -277,6 +295,13 @@ export function fakeAcpWith(options: FakeAcpOptions): FakeCli {
                     if (params.configId === 'model') {
                         model = String(params.value);
                     }
+                    if (params.configId === 'reasoning_effort') {
+                        if (options.reasoningEffort === 'reject') {
+                            refuse(id, -32602, 'Reasoning effort is locked');
+                            return;
+                        }
+                        effort = String(params.value);
+                    }
                     respond(id, { configOptions: sessionState().configOptions ?? [] });
                     return;
                 case 'session/prompt':