@adecore/agents 0.31.3 → 0.31.5

package/dist/providers/acp-agent-state.js

@@ -0,0 +1,170 @@
+import { ModelOptionDescriptorSchema } from '@adecore/agent-contracts';
+import { z } from 'zod';
+const AdoptedSchema = z.object({
+    defaultModel: z.string().min(1),
+    models: z.array(z.object({ slug: z.string().min(1), name: z.string(), contextWindow: z.number().int().positive().optional() })).min(1),
+    options: z.array(ModelOptionDescriptorSchema)
+});
+/* An agent's model id may reach a command line, so one that reads as a flag is left out. */
+function adoptableModels(info) {
+    return (info.models?.models ?? [])
+        .filter((model) => model.id !== '' && !model.id.startsWith('-'))
+        .map((model) => ({ slug: model.id, name: model.name, ...(model.contextWindow === null ? {} : { contextWindow: model.contextWindow }) }));
+}
+/* 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 })
+            }))
+        }
+    ];
+}
+/* Parses one stored part on its own, so a part a later version wrote differently costs only that part. */
+function storedPart(schema, value) {
+    const parsed = schema.safeParse(value);
+    return parsed.success ? parsed.data : null;
+}
+/*
+ * What an agent reported about itself, outside any one session: the models it offers and what follows from it for the
+ * provider's capabilities. Kept in the host's store when it has one, and every change is told to the listeners, so a host
+ * can hand its clients the new list.
+ */
+export class AcpAgentState {
+    // Changed in place, so a host that spread the provider into a value of its own reads the same object.
+    capabilities;
+    options;
+    listeners = new Set();
+    adopted = null;
+    // Whether the agent reported its context window in a `usage_update`, once in any session.
+    reportsContext = false;
+    // The slash commands the last session listed; null until one did.
+    commands = null;
+    constructor(options) {
+        this.options = options;
+        this.capabilities = { ...options.base, ...options.overrides };
+        this.restore();
+    }
+    onChange(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    session(info) {
+        if (!this.options.adoptModels || info.models === null) {
+            return;
+        }
+        const adopted = { defaultModel: info.models.current, models: adoptableModels(info), options: effortOption(info) };
+        const changed = this.adopt(adopted);
+        this.settle(changed);
+    }
+    commandsListed(commands) {
+        const names = [...new Set(commands)].sort();
+        if (this.commands !== null && JSON.stringify(names) === JSON.stringify(this.commands)) {
+            return;
+        }
+        this.commands = names;
+        const changed = this.refresh();
+        // The commands are saved even when the capabilities stay, so a restart knows them too.
+        this.save();
+        if (changed) {
+            this.notify();
+        }
+    }
+    contextReported() {
+        if (this.reportsContext) {
+            return;
+        }
+        this.reportsContext = true;
+        this.settle(this.refresh());
+    }
+    restore() {
+        let stored;
+        try {
+            stored = this.options.store?.load();
+        }
+        catch {
+            return;
+        }
+        if (typeof stored !== 'object' || stored === null) {
+            return;
+        }
+        const record = stored;
+        const adopted = storedPart(AdoptedSchema, record.models);
+        if (adopted !== null && this.options.adoptModels) {
+            this.adopt(adopted);
+        }
+        this.reportsContext = record.reportsContext === true;
+        this.commands = storedPart(z.array(z.string()), record.commands);
+        this.refresh();
+    }
+    /* What the agent showed it can do, under what the host set itself. */
+    learned() {
+        const commands = this.commands ?? [];
+        return {
+            ...(this.reportsContext ? { reportsContextWindow: true } : {}),
+            ...(commands.includes('compact') ? { compaction: 'prompt' } : {}),
+            ...(commands.includes('goal') ? { goals: 'command' } : {})
+        };
+    }
+    /* Lays what the agent showed over the capabilities, in place; answers whether they changed. */
+    refresh() {
+        const next = { ...this.options.base, ...this.learned(), ...this.options.overrides };
+        if (JSON.stringify(next) === JSON.stringify(this.capabilities)) {
+            return false;
+        }
+        const capabilities = this.capabilities;
+        for (const key of Object.keys(capabilities)) {
+            delete capabilities[key];
+        }
+        Object.assign(capabilities, next);
+        return true;
+    }
+    /* Answers whether the catalog changed; a list without its default is refused there and leaves the one adopted before. */
+    adopt(adopted) {
+        if (!adopted.models.some((model) => model.slug === adopted.defaultModel)) {
+            return false;
+        }
+        this.adopted = adopted;
+        return this.options.catalog.adopt(adopted.models, adopted.defaultModel, adopted.options);
+    }
+    /* Saves and tells the listeners once something changed. */
+    settle(changed) {
+        if (changed) {
+            this.save();
+            this.notify();
+        }
+    }
+    save() {
+        try {
+            this.options.store?.save(this.stored());
+        }
+        catch {
+            // A store that cannot write costs the next start what it would have kept, never this session.
+        }
+    }
+    notify() {
+        for (const listener of [...this.listeners]) {
+            listener();
+        }
+    }
+    stored() {
+        return {
+            ...(this.adopted === null ? {} : { models: this.adopted }),
+            ...(this.reportsContext ? { reportsContext: true } : {}),
+            ...(this.commands === null ? {} : { commands: this.commands })
+        };
+    }
+}

package/dist/providers/acp-provider.d.ts

@@ -1,5 +1,6 @@
 import type { AgentKind, ProviderCapabilities, ProviderInstall } from '@adecore/agent-contracts';
 import { type AcpAgentSpec } from '../chat/acp-backend.ts';
+import { type AcpCatalogStore } from './acp-agent-state.ts';
 import type { ModelCatalog } from './catalog.ts';
 import { type CliDetection } from './detect.ts';
 import type { ChatProvider, ProviderHome } from './provider.ts';
@@ -22,5 +23,6 @@ export interface AcpProviderSpec extends AcpAgentSpec {
     accountProbe?: boolean;
     adoptModels?: boolean;
     usageLog?: string;
+    catalogStore?: AcpCatalogStore;
 }
 export declare function createAcpProvider(spec: AcpProviderSpec): ChatProvider;

package/dist/providers/acp-provider.js

@@ -1,10 +1,11 @@
 import { createAcpBackend } from '../chat/acp-backend.js';
 import { askAcpAccount } from './accounts/acp-account.js';
+import { AcpAgentState } from './acp-agent-state.js';
 import { writeAcpUsage } from './acp-usage-log.js';
 import { detectCli } from './detect.js';
 /*
- * What every ACP agent can do through this backend. A file change comes as the text before and after;
- * a message names its mentions and attachments by path, as text the agent opens with its own tools.
+ * What every ACP agent can do through this backend, before what it shows of itself. A file change comes as the text
+ * before and after; a message names its mentions and attachments by path, and carries the files themselves where the agent takes them.
  */
 export const ACP_CAPABILITIES = {
     chat: true,
@@ -25,18 +26,22 @@ export const ACP_CAPABILITIES = {
 };
 /* Agents whose own usage files the scanner reads; a log of their turns would count every one twice. */
 const OWN_USAGE_FILES = new Set(['grok']);
-/* An agent's model id may reach a command line, so one that reads as a flag is left out. */
-function adoptableModels(info) {
-    return (info.models?.models ?? []).filter((model) => model.id !== '' && !model.id.startsWith('-')).map((model) => ({ slug: model.id, name: model.name }));
-}
 export function createAcpProvider(spec) {
-    const capabilities = { ...ACP_CAPABILITIES, ...spec.capabilities };
+    const state = new AcpAgentState({
+        catalog: spec.catalog,
+        adoptModels: spec.adoptModels !== false,
+        store: spec.catalogStore ?? null,
+        base: ACP_CAPABILITIES,
+        overrides: spec.capabilities ?? {}
+    });
     const onSession = (info) => {
-        if (spec.adoptModels !== false && info.models !== null) {
-            spec.catalog.adopt(adoptableModels(info), info.models.current);
-        }
+        state.session(info);
         spec.onSession?.(info);
     };
+    const onCommands = (commands) => {
+        state.commandsListed(commands);
+        spec.onCommands?.(commands);
+    };
     const usageLog = spec.usageLog === undefined || OWN_USAGE_FILES.has(spec.kind) ? null : spec.usageLog;
     const onUsage = usageLog === null
         ? spec.onUsage
@@ -48,7 +53,8 @@ export function createAcpProvider(spec) {
         kind: spec.kind,
         name: spec.name,
         catalog: spec.catalog,
-        capabilities,
+        capabilities: state.capabilities,
+        onChange: (listener) => state.onChange(listener),
         command: [spec.command, ...(spec.args ?? [])],
         resumeCommand: spec.resumeCommand ?? '',
         ...(spec.ignoresProjectConfig === undefined ? {} : { ignoresProjectConfig: spec.ignoresProjectConfig }),
@@ -70,9 +76,19 @@ export function createAcpProvider(spec) {
                     command,
                     env: { ...env, ...spec.env },
                     ...(spec.client ? { client: spec.client } : {}),
-                    onSession
+                    onSession,
+                    onCommands
                 })
             }),
-        createBackend: createAcpBackend({ ...spec, onSession, ...(onUsage === undefined ? {} : { onUsage }) })
+        createBackend: createAcpBackend({
+            ...spec,
+            onSession,
+            onCommands,
+            onContextReport: () => {
+                state.contextReported();
+                spec.onContextReport?.();
+            },
+            ...(onUsage === undefined ? {} : { onUsage })
+        })
     };
 }

package/dist/providers/catalog.d.ts

@@ -1,17 +1,19 @@
-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;
 };
 export declare class ModelCatalog {
     private readonly shippedAt;
     private data;
+    private hostWindows;
     constructor(data?: ModelCatalogInput);
     get defaultModel(): string;
     replace(data: ModelCatalogData): boolean;
     adopt(models: ReadonlyArray<{
         slug: string;
         name: string;
-    }>, defaultModel: string): boolean;
+        contextWindow?: number;
+    }>, defaultModel: string, options?: readonly ModelOptionDescriptor[]): boolean;
     list(): ModelInfo[];
     nameOf(slug: string): string;
     resolveModel(name: string): string | null;

package/dist/providers/catalog.js

@@ -11,6 +11,8 @@ function timeOf(data) {
 export class ModelCatalog {
     shippedAt;
     data;
+    // The sizes the host's own default had before an agent's models replaced it, for an adopted model that names none.
+    hostWindows;
     constructor(data = manifest) {
         this.shippedAt = timeOf(data);
         this.data = data;
@@ -25,23 +27,34 @@ export class ModelCatalog {
         }
         const changed = JSON.stringify(data) !== JSON.stringify(this.data);
         this.data = data;
+        this.hostWindows = undefined;
         return changed;
     }
     /*
      * 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, and the context window in tokens a model names as its only size.
      */
-    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));
+        this.hostWindows ??= base.contextWindowTokens;
+        const profile = { ...base, contextWindowTokens: this.hostWindows, options: [...base.options.filter((option) => !replaced.has(option.id)), ...options] };
+        const profileName = (window) => (window === undefined ? ADOPTED_PROFILE : `${ADOPTED_PROFILE}-${window}`);
+        const profiles = {};
+        for (const model of models) {
+            profiles[profileName(model.contextWindow)] =
+                model.contextWindow === undefined ? profile : { ...profile, contextWindowTokens: { '*': model.contextWindow } };
+        }
         const data = {
             ...(this.data.updatedAt === undefined ? {} : { updatedAt: this.data.updatedAt }),
             defaultModel,
-            profiles: { [ADOPTED_PROFILE]: profile },
-            models: models.map((model) => ({ slug: model.slug, name: model.name, profile: ADOPTED_PROFILE }))
+            profiles,
+            models: models.map((model) => ({ slug: model.slug, name: model.name, profile: profileName(model.contextWindow) }))
         };
         const changed = JSON.stringify(data) !== JSON.stringify(this.data);
         this.data = data;

package/dist/providers/index.d.ts

@@ -1,3 +1,4 @@
+export { type AcpCatalogStore } from './acp-agent-state.ts';
 export { ACP_CAPABILITIES, type AcpProviderSpec, createAcpProvider } from './acp-provider.ts';
 export { type AcpAccountProbe, askAcpAccount, type ProbeTimer } from './accounts/acp-account.ts';
 export { AccountError, type AccountLaunches, storedAccount, launchEnv } from './accounts/launch.ts';

package/dist/providers/index.js

@@ -1,4 +1,5 @@
 // Public API: exports.test.ts snapshots this list, so a name added or dropped here is an API change.
+export {} from './acp-agent-state.js';
 export { ACP_CAPABILITIES, createAcpProvider } from './acp-provider.js';
 export { askAcpAccount } from './accounts/acp-account.js';
 export { AccountError, storedAccount, launchEnv } from './accounts/launch.js';

package/dist/providers/provider.d.ts

@@ -25,5 +25,6 @@ export interface ChatProvider {
     detect(command: string, env: Record<string, string | undefined>): Promise<CliDetection>;
     enabled?(): boolean;
     askAccount?(command: readonly string[], env: Record<string, string | undefined>): Promise<AccountReading>;
+    onChange?(listener: () => void): () => void;
     createBackend(launch: BackendLaunch, host: BackendHost): ChatBackend;
 }

package/dist/providers/registry.d.ts

@@ -23,6 +23,7 @@ export declare class ProviderRegistry {
     oneShotProvider(preferred?: AgentKind): Promise<ChatProvider | null>;
     catalogFor(kind: AgentKind): ModelCatalog;
     enabled(kind: AgentKind): boolean;
+    onChange(listener: (kind: AgentKind) => void): () => void;
     invalidate(kind: AgentKind): void;
     protected fallback(kind: AgentKind): ChatProvider;
     private detection;

package/dist/providers/registry.js

@@ -97,6 +97,15 @@ export class ProviderRegistry {
     enabled(kind) {
         return this.get(kind).enabled?.() !== false;
     }
+    /* Calls the listener with the kind of every provider whose models or capabilities changed, so a host can list them again; answers how to stop. */
+    onChange(listener) {
+        const stops = this.providers.flatMap((provider) => (provider.onChange ? [provider.onChange(() => listener(provider.kind))] : []));
+        return () => {
+            for (const stop of stops) {
+                stop();
+            }
+        };
+    }
     invalidate(kind) {
         this.cache.delete(kind);
     }

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

@@ -7,6 +7,10 @@ export interface FakeAcpOptions {
     legacyModels?: boolean;
     closeSession?: boolean;
     turnUsage?: Record<string, number>;
+    reasoningEffort?: 'accept' | 'reject';
+    contextWindows?: boolean;
+    commands?: readonly string[];
+    embeddedContext?: boolean;
 }
 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;
@@ -37,15 +38,29 @@ export function fakeAcpWith(options) {
             prompt = null;
         };
         const sessionState = () => {
+            const meta = (totalContextTokens) => (options.contextWindows ? { _meta: { totalContextTokens } } : {});
             const modelChoices = [
-                { value: 'fake-small', name: 'Fake small' },
-                { value: 'fake-large', name: 'Fake large' }
+                { value: 'fake-small', name: 'Fake small', ...meta(128000) },
+                { value: 'fake-large', name: 'Fake large', ...meta(1000000) }
             ];
+            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 }] })
+                    ? { models: { currentModelId: model, availableModels: modelChoices.map(({ value, ...choice }) => ({ modelId: value, ...choice })) } }
+                    : {
+                        configOptions: [
+                            { id: 'model', name: 'Model', type: 'select', category: 'model', currentValue: model, options: modelChoices },
+                            ...effortOption
+                        ]
+                    })
             };
         };
         const askPermission = (toolCall, onAnswer) => {
@@ -179,7 +194,7 @@ export function fakeAcpWith(options) {
                         protocolVersion: 1,
                         agentCapabilities: {
                             loadSession: options.loadSession ?? true,
-                            promptCapabilities: { image: true, audio: false, embeddedContext: false },
+                            promptCapabilities: { image: true, audio: false, embeddedContext: options.embeddedContext === true },
                             sessionCapabilities: { ...(options.resumeSession ? { resume: {} } : {}), ...(options.closeSession ? { close: {} } : {}) }
                         },
                         authMethods: options.authMethod === undefined ? [] : [{ id: options.authMethod, name: 'Sign in' }],
@@ -197,6 +212,12 @@ export function fakeAcpWith(options) {
                     }
                     sessionId = `fake-session-${Math.random().toString(36).slice(2, 8)}`;
                     sessionHistory.set(sessionId, []);
+                    if (options.commands !== undefined) {
+                        update({
+                            sessionUpdate: 'available_commands_update',
+                            availableCommands: options.commands.map((name) => ({ name, description: name }))
+                        });
+                    }
                     respond(id, { sessionId, ...sessionState() });
                     return;
                 case 'session/load':
@@ -241,6 +262,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.5",
   "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.5",
+    "@adecore/intelligent-ui": "0.31.5",
     "zod": "^4.6.5"
   },
   "devDependencies": {