@theia/ai-core 1.74.0-next.9 → 1.74.1

package/src/browser/frontend-language-model-service.ts

@@ -18,7 +18,7 @@ import { nls } from '@theia/core/lib/common/nls';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { Prioritizeable } from '@theia/core/lib/common/prioritizeable';
 import { WorkspaceTrustService } from '@theia/workspace/lib/browser/workspace-trust-service';
-import { LanguageModel, LanguageModelResponse, ReasoningSettings, UserRequest } from '../common';
+import { AiConfigurationService, LanguageModel, LanguageModelResponse, ReasoningSettings, UserRequest } from '../common';
 import { LanguageModelServiceImpl } from '../common/language-model-service';
 import {
     PREFERENCE_NAME_REQUEST_SETTINGS,
@@ -27,7 +27,6 @@ import {
     ReasoningPreferenceEntry,
     getRequestSettingSpecificity
 } from '../common/ai-core-preferences';
-import { TrustAwarePreferenceReader } from './trust-aware-preference-reader';
 
 @injectable()
 export class FrontendLanguageModelServiceImpl extends LanguageModelServiceImpl {
@@ -35,15 +34,15 @@ export class FrontendLanguageModelServiceImpl extends LanguageModelServiceImpl {
     @inject(WorkspaceTrustService)
     protected readonly workspaceTrustService: WorkspaceTrustService;
 
-    @inject(TrustAwarePreferenceReader)
-    protected readonly trustAwareReader: TrustAwarePreferenceReader;
+    @inject(AiConfigurationService)
+    protected readonly aiConfiguration: AiConfigurationService;
 
     override async sendRequest(
         languageModel: LanguageModel,
         languageModelRequest: UserRequest
     ): Promise<LanguageModelResponse> {
-        const requestSettings = this.trustAwareReader.get<RequestSetting[]>(PREFERENCE_NAME_REQUEST_SETTINGS, []) ?? [];
-        const reasoningEntries = this.trustAwareReader.get<ReasoningPreferenceEntry[]>(PREFERENCE_NAME_REASONING, []) ?? [];
+        const requestSettings = this.aiConfiguration.get<RequestSetting[]>(PREFERENCE_NAME_REQUEST_SETTINGS, []) ?? [];
+        const reasoningEntries = this.aiConfiguration.get<ReasoningPreferenceEntry[]>(PREFERENCE_NAME_REASONING, []) ?? [];
         const trusted = await this.workspaceTrustService.getWorkspaceTrust();
         if (!trusted) {
             throw new Error(nls.localize('theia/ai-core/aiDisabledInRestrictedMode', 'AI features are not available in untrusted workspaces.'));

package/src/browser/index.ts

@@ -23,6 +23,7 @@ export * from './ai-core-frontend-application-contribution';
 export * from './ai-core-frontend-module';
 export * from '../common/ai-core-preferences';
 export * from './ai-settings-service';
+export * from './ai-configuration-service-impl';
 export * from './ai-view-contribution';
 export * from './frontend-language-model-registry';
 export * from './frontend-language-model-alias-registry';

package/src/browser/prompt-variable-contribution.spec.ts

@@ -225,13 +225,99 @@ describe('PromptVariableContribution', () => {
             expect(result?.variable).to.deep.equal(PROMPT_VARIABLE);
         });
 
-        it('returns empty string for non-existent prompts', async () => {
+        describe('customized (file-based) commands, whose fragment id differs from the command name', () => {
+            const customized = {
+                id: 'my-file',
+                customizationId: 'customization-1',
+                priority: 1,
+                template: 'Deploy $ARGUMENTS now.',
+                isCommand: true,
+                commandName: 'deploy'
+            };
+
+            beforeEach(() => {
+                (promptService as unknown as Record<string, unknown>)['customizationService'] = {
+                    isPromptFragmentCustomized: (id: string) => id === customized.id,
+                    getActivePromptFragmentCustomization: (id: string) => (id === customized.id ? customized : undefined),
+                    getCustomizedPromptFragmentIds: () => [customized.id]
+                };
+            });
+
+            it('resolves the command with arguments', async () => {
+                const result = await contribution.resolve({ variable: PROMPT_VARIABLE, arg: 'deploy|prod' }, {});
+                expect(result?.value).to.equal('Deploy prod now.');
+            });
+
+            it('resolves the command without arguments', async () => {
+                const result = await contribution.resolve({ variable: PROMPT_VARIABLE, arg: 'deploy' }, {});
+                expect(result?.value).to.equal('Deploy $ARGUMENTS now.');
+            });
+
+            it('is accepted by isKnownCommand for both invocations', () => {
+                expect(promptService.isKnownCommand('deploy')).to.be.true;
+            });
+
+            it('still resolves the command by its fragment id', async () => {
+                const result = await contribution.resolve({ variable: PROMPT_VARIABLE, arg: 'my-file' }, {});
+                expect(result?.value).to.equal('Deploy $ARGUMENTS now.');
+            });
+        });
+
+        // Resolving to `undefined` instead of an empty string makes callers keep the original text
+        // (the literal `#prompt:...` / `{{prompt:...}}` placeholder) rather than silently dropping it.
+        it('returns undefined for a non-existent prompt with arguments', async () => {
             const result = await contribution.resolve(
                 { variable: PROMPT_VARIABLE, arg: 'non-existent|args' },
                 {}
             );
 
-            expect(result?.value).to.equal('');
+            expect(result).to.be.undefined;
+        });
+
+        it('returns undefined for a non-existent prompt without arguments', async () => {
+            const result = await contribution.resolve(
+                { variable: PROMPT_VARIABLE, arg: 'non-existent' },
+                {}
+            );
+
+            expect(result).to.be.undefined;
+        });
+
+        it('returns undefined for a path-like argument', async () => {
+            promptService.addBuiltInPromptFragment({
+                id: 'hello-cmd',
+                template: 'Hello, world!',
+                isCommand: true,
+                commandName: 'hello'
+            });
+
+            const result = await contribution.resolve(
+                { variable: PROMPT_VARIABLE, arg: 'home|/user/notes.txt and fix the bug' },
+                {}
+            );
+
+            expect(result).to.be.undefined;
+        });
+
+        it('returns undefined when no argument is given', async () => {
+            expect(await contribution.resolve({ variable: PROMPT_VARIABLE, arg: undefined }, {})).to.be.undefined;
+            expect(await contribution.resolve({ variable: PROMPT_VARIABLE, arg: '   ' }, {})).to.be.undefined;
+        });
+
+        it('resolves a command referenced by its fragment id without arguments', async () => {
+            promptService.addBuiltInPromptFragment({
+                id: 'hello-cmd',
+                template: 'Hello, world!',
+                isCommand: true,
+                commandName: 'hello'
+            });
+
+            const result = await contribution.resolve(
+                { variable: PROMPT_VARIABLE, arg: 'hello' },
+                {}
+            );
+
+            expect(result?.value).to.equal('Hello, world!');
         });
     });
 });

package/src/browser/prompt-variable-contribution.ts

@@ -76,11 +76,13 @@ export class PromptVariableContribution implements AIVariableContribution, AIVar
                 const promptIdOrCommandName = pipeIndex >= 0 ? arg.substring(0, pipeIndex) : arg;
                 const commandArgs = pipeIndex >= 0 ? arg.substring(pipeIndex + 1) : '';
 
-                // Determine the actual fragment ID
-                // If this is a command invocation (has args), try to find by command name first
-                let fragment = commandArgs
-                    ? this.promptService.getPromptFragmentByCommandName(promptIdOrCommandName)
-                    : undefined;
+                // Determine the actual fragment ID by looking up the command name first.
+                // This must not be conditional on arguments being present: a customized (file-based)
+                // command has a fragment id that differs from its command name, so `/deploy` without
+                // arguments would otherwise not resolve even though `/deploy prod` does. It also keeps
+                // this lookup aligned with `PromptService.isKnownCommand`, which the chat request
+                // parser uses to decide whether `/deploy` is a command at all.
+                let fragment = this.promptService.getPromptFragmentByCommandName(promptIdOrCommandName);
 
                 // Fall back to looking up by fragment ID if not found by command name
                 if (!fragment) {
@@ -90,11 +92,7 @@ export class PromptVariableContribution implements AIVariableContribution, AIVar
                 // If we still don't have a fragment, we can't resolve
                 if (!fragment) {
                     this.logger.debug(`Could not find prompt fragment or command '${promptIdOrCommandName}'`);
-                    return {
-                        variable: request.variable,
-                        value: '',
-                        allResolvedDependencies: []
-                    };
+                    return undefined;
                 }
 
                 const fragmentId = fragment.id;
@@ -124,12 +122,11 @@ export class PromptVariableContribution implements AIVariableContribution, AIVar
                 }
             }
         }
-        this.logger.debug(`Could not resolve prompt variable '${request.variable.name}' with arg '${request.arg}'. Returning empty string.`);
-        return {
-            variable: request.variable,
-            value: '',
-            allResolvedDependencies: []
-        };
+        // Returning `undefined` rather than an empty resolution keeps the original text in place:
+        // callers fall back to the literal `#prompt:...` / `{{prompt:...}}` placeholder instead of
+        // silently dropping it, which is also how every other unresolvable variable behaves.
+        this.logger.debug(`Could not resolve prompt variable '${request.variable.name}' with arg '${request.arg}'.`);
+        return undefined;
     }
 
     private substituteCommandArguments(template: string, commandName: string, commandArgs: string): string {

package/src/browser/trust-aware-preference-reader.spec.ts

@@ -165,6 +165,35 @@ describe('TrustAwarePreferenceReader', () => {
         });
     });
 
+    describe('suppressUntrusted', () => {
+        const inspection = {
+            preferenceName: PREFERENCE_NAME,
+            defaultValue: 'default',
+            globalValue: 'user',
+            workspaceValue: 'workspace',
+            workspaceFolderValue: 'folder',
+            value: 'folder'
+        };
+
+        it('clears the workspace and folder values when untrusted', async () => {
+            trust.trustDeferred.resolve(false);
+            await reader.ready;
+            const result = reader.suppressUntrusted({ ...inspection });
+            expect(result.workspaceValue).to.equal(undefined);
+            expect(result.workspaceFolderValue).to.equal(undefined);
+            expect(result.globalValue).to.equal('user');
+            expect(result.defaultValue).to.equal('default');
+        });
+
+        it('returns the inspection unchanged when trusted', async () => {
+            trust.trustDeferred.resolve(true);
+            await reader.ready;
+            const result = reader.suppressUntrusted({ ...inspection });
+            expect(result.workspaceValue).to.equal('workspace');
+            expect(result.workspaceFolderValue).to.equal('folder');
+        });
+    });
+
     describe('onDidChangeTrust', () => {
         beforeEach(async () => {
             trust.trustDeferred.resolve(false);

package/src/browser/trust-aware-preference-reader.ts

@@ -18,7 +18,7 @@ import { inject, injectable, postConstruct } from '@theia/core/shared/inversify'
 import { JSONValue } from '@theia/core/shared/@lumino/coreutils';
 import { Emitter, Event } from '@theia/core';
 import { Deferred } from '@theia/core/lib/common/promise-util';
-import { PreferenceService } from '@theia/core/lib/common/preferences';
+import { PreferenceInspection, PreferenceService } from '@theia/core/lib/common/preferences';
 import { WorkspaceTrustService } from '@theia/workspace/lib/browser/workspace-trust-service';
 
 /**
@@ -27,6 +27,9 @@ import { WorkspaceTrustService } from '@theia/workspace/lib/browser/workspace-tr
  *
  * Writes should continue to go through `PreferenceService` directly; trust only
  * affects reads.
+ *
+ * @internal This is an implementation detail of {@link AiConfigurationService}. AI configuration
+ * consumers should go through `AiConfigurationService` rather than injecting this reader directly.
  */
 @injectable()
 export class TrustAwarePreferenceReader {
@@ -102,7 +105,24 @@ export class TrustAwarePreferenceReader {
             return this.preferences.get<T>(preferenceName, fallback, resourceUri);
         }
         const inspection = this.preferences.inspect<JSONValue>(preferenceName, resourceUri);
-        const value = inspection?.globalValue ?? inspection?.defaultValue;
-        return (value as T | undefined) ?? fallback;
+        if (!inspection) {
+            return fallback;
+        }
+        const suppressed = this.suppressUntrusted(inspection);
+        return ((suppressed.globalValue ?? suppressed.defaultValue) as T | undefined) ?? fallback;
+    }
+
+    /**
+     * Narrows a raw {@link PreferenceInspection} according to workspace trust: when the workspace is
+     * untrusted the folder and workspace scope values are dropped so that only the user and default
+     * scopes contribute (failing closed until the trust state resolves). A trusted inspection is
+     * returned unchanged. This is the single definition of the trust-suppression rule, shared by
+     * {@link get} and by inspection-based consumers, so value reads and inspections cannot drift.
+     */
+    suppressUntrusted<T extends JSONValue>(inspection: PreferenceInspection<T>): PreferenceInspection<T> {
+        if (this.trusted) {
+            return inspection;
+        }
+        return { ...inspection, workspaceValue: undefined, workspaceFolderValue: undefined };
     }
 }

package/src/common/ai-configuration-service.ts

@@ -0,0 +1,128 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { Event } from '@theia/core';
+import { JSONValue } from '@theia/core/shared/@lumino/coreutils';
+import { PreferenceInspection, PreferenceScope } from '@theia/core/lib/common/preferences';
+
+export const AiConfigurationService = Symbol('AiConfigurationService');
+
+/**
+ * A {@link PreferenceInspection} augmented with a derived, workspace-trust-aware source scope.
+ */
+export interface AiConfigurationInspection<T extends JSONValue = JSONValue> extends PreferenceInspection<T> {
+    /**
+     * The narrowest scope (honoring workspace trust) in which a value is explicitly set, i.e. the
+     * scope that determines the effective {@link PreferenceInspection.value}. Walked in precedence
+     * order `Folder -> Workspace -> User`; `undefined` when only the default value applies. In an
+     * untrusted workspace the folder/workspace scopes are ignored, so `sourceScope` is either
+     * `User` or `undefined`.
+     */
+    sourceScope?: PreferenceScope;
+}
+
+/**
+ * Payload of {@link AiConfigurationService.onDidChange}.
+ */
+export interface AiConfigurationChange {
+    /**
+     * The preference key that changed. When the change is caused by a workspace-trust transition
+     * (which can change the effective value of any trust-gated key) this is `undefined` and
+     * {@link affects} returns `true` for every resource. Listeners tracking a specific key should
+     * re-query the value when `preferenceName` is `undefined` or equals their key.
+     */
+    readonly preferenceName?: string;
+    /**
+     * Tests whether the given resource is affected by the change.
+     * @param resourceUri the uri of the resource to test.
+     */
+    affects(resourceUri?: string): boolean;
+    /**
+     * Tests whether the given preference key is affected by this change, treating a workspace-trust
+     * transition (where {@link preferenceName} is `undefined`) as affecting every trust-gated key.
+     * Prefer this over comparing {@link preferenceName} directly so listeners do not silently miss
+     * trust transitions.
+     * @param preferenceName the preference key to test.
+     */
+    affectsPreference(preferenceName: string): boolean;
+}
+
+/**
+ * Framework API for reading and writing AI-related (`ai-features.*`) preferences.
+ *
+ * `AiConfigurationService` wraps the core `PreferenceService` and is the intended extension point
+ * for adopters and extensions that configure AI features: prefer it over talking to
+ * `PreferenceService` directly for `ai-features.*` keys. Routing all AI configuration through this
+ * seam keeps consumers insulated from future changes to how AI preferences are stored.
+ *
+ * Reads ({@link get}, {@link inspect}) are **workspace-trust-aware**: workspace and folder scope
+ * values are suppressed while the workspace is untrusted (failing closed until the trust state
+ * resolves), matching how AI features read preferences today. Writes ({@link set}, {@link update})
+ * are never gated by trust.
+ */
+export interface AiConfigurationService {
+    /**
+     * Resolves once the underlying preference service and the initial workspace-trust state are
+     * ready. Await this before the first read for a deterministic, trust-aware result.
+     */
+    readonly ready: Promise<void>;
+
+    /**
+     * Retrieves the effective, trust-aware value for the given preference.
+     *
+     * @param key the preference identifier.
+     * @param defaultValue the value to return when no value is stored.
+     * @param resourceUri the uri of the resource for which the preference is read.
+     */
+    get<T>(key: string, defaultValue?: T, resourceUri?: string): T | undefined;
+
+    /**
+     * Writes `value` to the given scope. Maps to `PreferenceService.set`.
+     *
+     * @param key the preference identifier.
+     * @param value the new value (must be JSON-serializable). `undefined` clears the value in the given scope.
+     * @param scope the scope to write to. For {@link PreferenceScope.Folder} a `resourceUri` is required.
+     * @param resourceUri the uri of the resource for which the preference is stored.
+     */
+    set(key: string, value: unknown, scope: PreferenceScope, resourceUri?: string): Promise<void>;
+
+    /**
+     * "Smart write": picks the scope so that the effective value becomes `value`. Maps to
+     * `PreferenceService.updateValue`.
+     *
+     * @param key the preference identifier.
+     * @param value the value to apply (must be JSON-serializable). `undefined` resets the preference to its default value.
+     * @param resourceUri the uri of the resource to which the change applies.
+     */
+    update(key: string, value: unknown, resourceUri?: string): Promise<void>;
+
+    /**
+     * Retrieves the per-scope values for the given preference, enriched with a derived,
+     * trust-aware {@link AiConfigurationInspection.sourceScope} and effective
+     * {@link PreferenceInspection.value}.
+     *
+     * @param key the preference identifier.
+     * @param resourceUri the uri of the resource for which the preference is inspected.
+     */
+    inspect<T extends JSONValue>(key: string, resourceUri?: string): AiConfigurationInspection<T> | undefined;
+
+    /**
+     * Fires when a `ai-features.*` preference changes or when the workspace-trust state transitions
+     * (which can change the effective value of trust-gated keys). The effective value is not carried
+     * on the event; listeners re-query it via {@link get}/{@link inspect}.
+     */
+    onDidChange: Event<AiConfigurationChange>;
+}

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

@@ -24,7 +24,7 @@ import {
     NOTIFICATION_TYPE_DESCRIPTIONS,
     NotificationType
 } from './notification-types';
-import { ReasoningSettings } from './language-model';
+import { ReasoningSettings, SERVER_SIDE_COMPACTION_TOKEN_THRESHOLD_MINIMUM } 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');
@@ -34,11 +34,31 @@ 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';
+export const PREFERENCE_NAME_SERVER_SIDE_COMPACTION = 'ai-features.chat.serverSideCompaction';
+export const PREFERENCE_NAME_SERVER_SIDE_COMPACTION_TOKEN_THRESHOLD = 'ai-features.chat.serverSideCompactionTokenThreshold';
 
 export const LANGUAGE_MODEL_ALIASES_PREFERENCE = 'ai-features.languageModelAliases';
 
 export const aiCorePreferenceSchema: PreferenceSchema = {
     properties: {
+        [PREFERENCE_NAME_SERVER_SIDE_COMPACTION]: {
+            title: AI_CORE_PREFERENCES_TITLE,
+            type: 'boolean',
+            description: nls.localize('theia/ai/core/serverSideCompaction/description',
+                'Enable provider-native server-side compaction by default for chat requests. When on, models that support it ' +
+                'may automatically summarize older turns once the conversation grows past their own threshold, letting long ' +
+                'sessions continue past the context limit. Each provider offers its own override, and individual chat sessions ' +
+                'can override this in their session settings. Models without support ignore it.'),
+            default: true,
+        },
+        [PREFERENCE_NAME_SERVER_SIDE_COMPACTION_TOKEN_THRESHOLD]: {
+            title: AI_CORE_PREFERENCES_TITLE,
+            type: 'integer',
+            minimum: SERVER_SIDE_COMPACTION_TOKEN_THRESHOLD_MINIMUM,
+            description: nls.localize('theia/ai/core/serverSideCompactionTokenThreshold/description',
+                'Default input-token threshold at which provider-native server-side compaction should run. Providers and individual chat sessions ' +
+                'can override this value. When unset, the provider chooses its default threshold. If set, the value must be at least 50,000 tokens.'),
+        },
         [PREFERENCE_NAME_PROMPT_TEMPLATES]: {
             title: AI_CORE_PREFERENCES_TITLE,
             description: nls.localize('theia/ai/core/promptTemplates/description',
@@ -239,6 +259,8 @@ export interface AICoreConfiguration {
     [PREFERENCE_NAME_MAX_RETRIES]: number | undefined;
     [PREFERENCE_NAME_DEFAULT_NOTIFICATION_TYPE]: NotificationType | undefined;
     [PREFERENCE_NAME_SKILL_DIRECTORIES]: string[] | undefined;
+    [PREFERENCE_NAME_SERVER_SIDE_COMPACTION]: boolean | undefined;
+    [PREFERENCE_NAME_SERVER_SIDE_COMPACTION_TOKEN_THRESHOLD]: number | undefined;
 }
 
 export interface RequestSetting {

package/src/common/index.ts

@@ -31,6 +31,7 @@ export * from './protocol';
 export * from './today-variable-contribution';
 export * from './variable-service';
 export * from './settings-service';
+export * from './ai-configuration-service';
 export * from './language-model-service';
 export * from './token-usage-service';
 export * from './ai-variable-resource';

package/src/common/language-model.spec.ts

@@ -15,7 +15,19 @@
 // *****************************************************************************
 
 import { expect } from 'chai';
-import { isModelMatching, isToolCallContent, LanguageModel, LanguageModelSelector } from './language-model';
+import {
+    DefaultLanguageModelRegistryImpl,
+    isCompactionResponsePart,
+    isLanguageModelStreamResponsePart,
+    isModelMatching,
+    isToolCallContent,
+    LanguageModel,
+    LanguageModelSelector,
+    resolveCompactionDefault,
+    resolveCompactionTokenThreshold,
+    resolveCompactionTokenThresholdDefault,
+    resolveServerSideCompaction
+} from './language-model';
 
 describe('isModelMatching', () => {
     it('returns false with one of two parameter mismatches', () => {
@@ -163,3 +175,88 @@ describe('isToolCallContent', () => {
     });
 
 });
+
+describe('DefaultLanguageModelRegistryImpl', () => {
+    function createRegistry(): DefaultLanguageModelRegistryImpl {
+        const registry = new DefaultLanguageModelRegistryImpl();
+        // No DI container in this unit test, so resolve the internal `initialized` gate manually.
+        (registry as unknown as { markInitialized: () => void }).markInitialized();
+        return registry;
+    }
+
+    function model(id: string): LanguageModel {
+        return { id, status: { status: 'ready' } } as LanguageModel;
+    }
+
+    it('getLanguageModels returns a fresh array so consumers can detect changes by reference', async () => {
+        const registry = createRegistry();
+        registry.addLanguageModels([model('a')]);
+
+        const first = await registry.getLanguageModels();
+        expect(first).to.have.length(1);
+
+        registry.addLanguageModels([model('b')]);
+        const second = await registry.getLanguageModels();
+
+        // A new snapshot must be a different array reference (React memoization relies on this).
+        expect(second).to.not.equal(first);
+        // The earlier snapshot must not be mutated in place by later registry changes.
+        expect(first.map(m => m.id)).to.deep.equal(['a']);
+        expect(second.map(m => m.id)).to.deep.equal(['a', 'b']);
+    });
+
+    it('reflects removals in a fresh snapshot without mutating an earlier one', async () => {
+        const registry = createRegistry();
+        registry.addLanguageModels([model('a'), model('b')]);
+        const before = await registry.getLanguageModels();
+
+        registry.removeLanguageModels(['a']);
+        const after = await registry.getLanguageModels();
+
+        expect(before.map(m => m.id)).to.deep.equal(['a', 'b']);
+        expect(after.map(m => m.id)).to.deep.equal(['b']);
+    });
+});
+
+describe('compaction contract', () => {
+    it('recognizes a compaction response part', () => {
+        const part = { compaction: { provider: 'anthropic', data: { foo: 1 } } };
+        expect(isCompactionResponsePart(part)).to.equal(true);
+        expect(isLanguageModelStreamResponsePart(part)).to.equal(true);
+    });
+    it('rejects a non-compaction part', () => {
+        expect(isCompactionResponsePart({ content: 'hi' })).to.equal(false);
+        // eslint-disable-next-line no-null/no-null
+        expect(isCompactionResponsePart(null)).to.equal(false);
+        expect(isCompactionResponsePart(undefined)).to.equal(false);
+        // eslint-disable-next-line no-null/no-null
+        expect(isCompactionResponsePart({ compaction: null })).to.equal(false);
+        expect(isCompactionResponsePart({ compaction: { provider: 42 } })).to.equal(false);
+    });
+    it('resolves a model default from the global preference and the per-provider override', () => {
+        expect(resolveCompactionDefault(true, 'default')).to.equal(true);
+        expect(resolveCompactionDefault(false, 'default')).to.equal(false);
+        expect(resolveCompactionDefault(false, 'enabled')).to.equal(true);
+        expect(resolveCompactionDefault(true, 'disabled')).to.equal(false);
+    });
+    it('resolves compaction token thresholds with session, provider, global precedence', () => {
+        expect(resolveCompactionTokenThresholdDefault(undefined, undefined)).to.equal(undefined);
+        expect(resolveCompactionTokenThresholdDefault(100_000, undefined)).to.equal(100_000);
+        expect(resolveCompactionTokenThresholdDefault(100_000, 200_000)).to.equal(200_000);
+        expect(resolveCompactionTokenThreshold(undefined, undefined)).to.equal(undefined);
+        expect(resolveCompactionTokenThreshold(200_000, undefined)).to.equal(200_000);
+        expect(resolveCompactionTokenThreshold(200_000, { tokenThreshold: 300_000 })).to.equal(300_000);
+    });
+    it('resolves server-side compaction with capability gate and session-wins precedence', () => {
+        // capability gate
+        expect(resolveServerSideCompaction(false, true, { enabled: true })).to.equal(false);
+        expect(resolveServerSideCompaction(undefined, true, undefined)).to.equal(false);
+        // no per-session setting -> model default
+        expect(resolveServerSideCompaction(true, true, undefined)).to.equal(true);
+        expect(resolveServerSideCompaction(true, false, undefined)).to.equal(false);
+        expect(resolveServerSideCompaction(true, true, {})).to.equal(true);
+        // explicit per-session setting wins over the model default (which already folds in the per-provider override)
+        expect(resolveServerSideCompaction(true, false, { enabled: true })).to.equal(true);
+        expect(resolveServerSideCompaction(true, true, { enabled: false })).to.equal(false);
+    });
+});