@theia/ai-core 1.46.0-next.241

package/src/browser/ai-configuration/language-model-renderer.tsx

@@ -0,0 +1,113 @@
+// *****************************************************************************
+// Copyright (C) 2024 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 * as React from '@theia/core/shared/react';
+import { Agent, LanguageModelRequirement } from '../../common';
+import { LanguageModel, LanguageModelRegistry } from '../../common/language-model';
+import { AISettingsService } from '../../common/settings-service';
+import { Mutable } from '@theia/core';
+
+export interface LanguageModelSettingsProps {
+    agent: Agent;
+    languageModels?: LanguageModel[];
+    aiSettingsService: AISettingsService;
+    languageModelRegistry: LanguageModelRegistry;
+}
+
+export const LanguageModelRenderer: React.FC<LanguageModelSettingsProps> = (
+    { agent, languageModels, aiSettingsService, languageModelRegistry }) => {
+
+    const findLanguageModelRequirement = async (purpose: string): Promise<LanguageModelRequirement | undefined> => {
+        const requirementSetting = await aiSettingsService.getAgentSettings(agent.id);
+        return requirementSetting?.languageModelRequirements?.find(e => e.purpose === purpose);
+    };
+
+    const [lmRequirementMap, setLmRequirementMap] = React.useState<Record<string, LanguageModelRequirement>>({});
+
+    React.useEffect(() => {
+        const computeLmRequirementMap = async () => {
+            const map = await agent.languageModelRequirements.reduce(async (accPromise, curr) => {
+                const acc = await accPromise;
+                // take the agents requirements and override them with the user settings if present
+                const lmRequirement = await findLanguageModelRequirement(curr.purpose) ?? curr;
+                // if no llm is selected through the identifier, see what would be the default
+                if (!lmRequirement.identifier) {
+                    const llm = await languageModelRegistry.selectLanguageModel({ agent: agent.id, ...lmRequirement });
+                    (lmRequirement as Mutable<LanguageModelRequirement>).identifier = llm?.id;
+                }
+                acc[curr.purpose] = lmRequirement;
+                return acc;
+            }, Promise.resolve({} as Record<string, LanguageModelRequirement>));
+            setLmRequirementMap(map);
+        };
+        computeLmRequirementMap();
+    }, []);
+
+    const renderLanguageModelMetadata = (requirement: LanguageModelRequirement, index: number) => {
+        const languageModel = languageModels?.find(model => model.id === requirement.identifier);
+        if (!languageModel) {
+            return <div></div>;
+        }
+
+        return <>
+            <div>{requirement.purpose}</div>
+            <div key={index}>
+                {languageModel.id && <p><strong>Identifier: </strong> {languageModel.id}</p>}
+                {languageModel.name && <p><strong>Name: </strong> {languageModel.name}</p>}
+                {languageModel.vendor && <p><strong>Vendor: </strong> {languageModel.vendor}</p>}
+                {languageModel.version && <p><strong>Version: </strong> {languageModel.version}</p>}
+                {languageModel.family && <p><strong>Family: </strong> {languageModel.family}</p>}
+                {languageModel.maxInputTokens && <p><strong>Min Input Tokens: </strong> {languageModel.maxInputTokens}</p>}
+                {languageModel.maxOutputTokens && <p><strong>Max Output Tokens: </strong> {languageModel.maxOutputTokens}</p>}
+            </div>
+        </>;
+
+    };
+
+    const onSelectedModelChange = (purpose: string, event: React.ChangeEvent<HTMLSelectElement>): void => {
+        const newLmRequirementMap = { ...lmRequirementMap, [purpose]: { purpose, identifier: event.target.value } };
+        aiSettingsService.updateAgentSettings(agent.id, { languageModelRequirements: Object.values(newLmRequirementMap) });
+        setLmRequirementMap(newLmRequirementMap);
+    };
+
+    return <div className='language-model-container'>
+        {Object.values(lmRequirementMap).map((requirements, index) => (
+            <React.Fragment key={index}>
+                <div><strong>Purpose:</strong></div>
+                <div>
+                    {/* language model metadata */}
+                    {renderLanguageModelMetadata(requirements, index)}
+                    {/* language model selector */}
+                    <>
+                        <label className="theia-header no-select" htmlFor={`model-select-${agent.id}`}>Language Model:</label>
+                        <select
+                            className="theia-select"
+                            id={`model-select-${agent.id}`}
+                            value={requirements.identifier}
+                            onChange={event => onSelectedModelChange(requirements.purpose, event)}
+                        >
+                            <option value=""></option>
+                            {languageModels?.sort((a, b) => (a.name ?? a.id).localeCompare(b.name ?? b.id)).map(model => (
+                                <option key={model.id} value={model.id}>{model.name ?? model.id}</option>
+                            ))}
+                        </select>
+                    </>
+                    <hr />
+                </div>
+            </React.Fragment>
+        ))}
+
+    </div>;
+};

package/src/browser/ai-configuration/template-settings-renderer.tsx

@@ -0,0 +1,128 @@
+// *****************************************************************************
+// Copyright (C) 2024 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 * as React from '@theia/core/shared/react';
+import { PromptCustomizationService, PromptService } from '../../common/prompt-service';
+import { AISettingsService, PromptTemplate } from '../../common';
+
+const DEFAULT_VARIANT = 'default';
+
+export interface TemplateRendererProps {
+    agentId: string;
+    template: PromptTemplate;
+    promptCustomizationService: PromptCustomizationService;
+    promptService: PromptService;
+    aiSettingsService: AISettingsService;
+}
+
+export const TemplateRenderer: React.FC<TemplateRendererProps> = ({
+    agentId,
+    template,
+    promptCustomizationService,
+    promptService,
+    aiSettingsService,
+}) => {
+    const variantIds = [DEFAULT_VARIANT, ...promptService.getVariantIds(template.id)];
+    const [selectedVariant, setSelectedVariant] = React.useState<string>(DEFAULT_VARIANT);
+
+    React.useEffect(() => {
+        (async () => {
+            const agentSettings = await aiSettingsService.getAgentSettings(agentId);
+            const currentVariant =
+                agentSettings?.selectedVariants?.[template.id] || DEFAULT_VARIANT;
+            setSelectedVariant(currentVariant);
+        })();
+    }, [template.id, aiSettingsService, agentId]);
+
+    const isInvalidVariant = !variantIds.includes(selectedVariant);
+
+    const handleVariantChange = async (event: React.ChangeEvent<HTMLSelectElement>) => {
+        const newVariant = event.target.value;
+        setSelectedVariant(newVariant);
+
+        const agentSettings = await aiSettingsService.getAgentSettings(agentId);
+        const selectedVariants = agentSettings?.selectedVariants || {};
+
+        const updatedVariants = { ...selectedVariants };
+        if (newVariant === DEFAULT_VARIANT) {
+            delete updatedVariants[template.id];
+        } else {
+            updatedVariants[template.id] = newVariant;
+        }
+
+        await aiSettingsService.updateAgentSettings(agentId, {
+            selectedVariants: updatedVariants,
+        });
+    };
+
+    const openTemplate = () => {
+        const templateId = selectedVariant === DEFAULT_VARIANT ? template.id : selectedVariant;
+        const selectedTemplate = promptService.getRawPrompt(templateId);
+        promptCustomizationService.editTemplate(templateId, selectedTemplate?.template || '');
+    };
+
+    const resetTemplate = () => {
+        const templateId = selectedVariant === DEFAULT_VARIANT ? template.id : selectedVariant;
+        promptCustomizationService.resetTemplate(templateId);
+    };
+
+    return (
+        <div className="template-renderer">
+            <div className="settings-section-title template-header">
+                <strong>{template.id}</strong>
+            </div>
+            <div className="template-controls">
+                {(variantIds.length > 1 || isInvalidVariant) && (
+                    <>
+                        <label htmlFor={`variant-selector-${template.id}`} className="template-select-label">
+                            Select Variant:
+                        </label>
+                        <select
+                            id={`variant-selector-${template.id}`}
+                            className={`theia-select template-variant-selector ${isInvalidVariant ? 'error' : ''}`}
+                            value={isInvalidVariant ? 'invalid' : selectedVariant}
+                            onChange={handleVariantChange}
+                        >
+                            {isInvalidVariant && (
+                                <option value="invalid" disabled>
+                                    The selected variant is no longer available
+                                </option>
+                            )}
+                            {variantIds.map(variantId => (
+                                <option key={variantId} value={variantId}>
+                                    {variantId}
+                                </option>
+                            ))}
+                        </select>
+                    </>
+                )}
+                <button
+                    className="theia-button main"
+                    onClick={openTemplate}
+                    disabled={isInvalidVariant}
+                >
+                    Edit
+                </button>
+                <button
+                    className="theia-button secondary"
+                    onClick={resetTemplate}
+                    disabled={isInvalidVariant}
+                >
+                    Reset
+                </button>
+            </div>
+        </div>
+    );
+};

package/src/browser/ai-configuration/variable-configuration-widget.tsx

@@ -0,0 +1,110 @@
+// *****************************************************************************
+// Copyright (C) 2024 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 { codicon, ReactWidget } from '@theia/core/lib/browser';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import * as React from '@theia/core/shared/react';
+import { Agent, AIVariable, AIVariableService } from '../../common';
+import { AIAgentConfigurationWidget } from './agent-configuration-widget';
+import { AIConfigurationSelectionService } from './ai-configuration-service';
+import { AgentService } from '../../common/agent-service';
+
+@injectable()
+export class AIVariableConfigurationWidget extends ReactWidget {
+
+    static readonly ID = 'ai-variable-configuration-container-widget';
+    static readonly LABEL = 'Variables';
+
+    @inject(AIVariableService)
+    protected readonly variableService: AIVariableService;
+
+    @inject(AgentService)
+    protected readonly agentService: AgentService;
+
+    @inject(AIConfigurationSelectionService)
+    protected readonly aiConfigurationSelectionService: AIConfigurationSelectionService;
+
+    @postConstruct()
+    protected init(): void {
+        this.id = AIVariableConfigurationWidget.ID;
+        this.title.label = AIVariableConfigurationWidget.LABEL;
+        this.title.closable = false;
+        this.update();
+        this.toDispose.push(this.variableService.onDidChangeVariables(() => this.update()));
+    }
+
+    protected render(): React.ReactNode {
+        return <div className='configuration-variables-list'>
+            <ul>
+                {this.variableService.getVariables().map(variable =>
+                    <li key={variable.id} className='variable-item' >
+                        <div className='settings-section-title settings-section-category-title' style={{ paddingLeft: 0, paddingBottom: 10 }}>{variable.name}</div>
+                        <small>{variable.id}</small>
+                        <small>{variable.description}</small>
+                        {this.renderReferencedVariables(variable)}
+                        {this.renderArgs(variable)}
+                    </li>
+                )}
+            </ul>
+        </div>;
+    }
+
+    protected renderReferencedVariables(variable: AIVariable): React.ReactNode | undefined {
+        const agents = this.getAgentsForVariable(variable);
+        if (agents.length === 0) {
+            return;
+        }
+
+        return <div>
+            <h3>Agents</h3>
+            <ul className='variable-references'>
+                {agents.map(agent => <li key={agent.id} className='theia-TreeNode theia-CompositeTreeNode theia-ExpandableTreeNode theia-mod-selected'>
+                    <div onClick={() => { this.showAgentConfiguration(agent); }} className='variable-reference'>
+                        <span>{agent.name}</span>
+                        <i className={codicon('chevron-right')}></i>
+                    </div></li>)}
+            </ul>
+        </div>;
+    }
+
+    protected renderArgs(variable: AIVariable): React.ReactNode | undefined {
+        if (variable.args === undefined || variable.args.length === 0) {
+            return;
+        }
+
+        return <div className='variable-args-container'>
+            <h3>Variable Arguments</h3>
+            <div className='variable-args'>
+                {variable.args.map(arg =>
+                    <React.Fragment key={arg.name}>
+                        <span>{arg.name}</span>
+                        <small>{arg.description}</small>
+                    </React.Fragment>
+                )}
+            </div>
+        </div>;
+    }
+
+    protected showAgentConfiguration(agent: Agent): void {
+        this.aiConfigurationSelectionService.setActiveAgent(agent);
+        this.aiConfigurationSelectionService.selectConfigurationTab(AIAgentConfigurationWidget.ID);
+    }
+
+    protected getAgentsForVariable(variable: AIVariable): Agent[] {
+        return this.agentService.getAgents().filter(a => a.variables?.includes(variable.id));
+    }
+}
+

package/src/browser/ai-core-frontend-application-contribution.ts

@@ -0,0 +1,39 @@
+// *****************************************************************************
+// Copyright (C) 2024 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 { FrontendApplicationContribution } from '@theia/core/lib/browser';
+import { inject, injectable, named } from '@theia/core/shared/inversify';
+import { Agent } from '../common';
+import { AgentService } from '../common/agent-service';
+import { ContributionProvider } from '@theia/core/lib/common/contribution-provider';
+
+@injectable()
+export class AICoreFrontendApplicationContribution implements FrontendApplicationContribution {
+    @inject(AgentService)
+    private readonly agentService: AgentService;
+
+    @inject(ContributionProvider) @named(Agent)
+    protected readonly agentsProvider: ContributionProvider<Agent>;
+
+    onStart(): void {
+        this.agentsProvider.getContributions().forEach(agent => {
+            this.agentService.registerAgent(agent);
+        });
+    }
+
+    onStop(): void {
+    }
+}

package/src/browser/ai-core-frontend-module.ts

@@ -0,0 +1,161 @@
+// *****************************************************************************
+// Copyright (C) 2024 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 { bindContributionProvider, CommandContribution, CommandHandler } from '@theia/core';
+import {
+    RemoteConnectionProvider,
+    ServiceConnectionProvider,
+} from '@theia/core/lib/browser/messaging/service-connection-provider';
+import { ContainerModule } from '@theia/core/shared/inversify';
+import {
+    AIVariableContribution,
+    AIVariableService,
+    ToolInvocationRegistry,
+    ToolInvocationRegistryImpl,
+    LanguageModelDelegateClient,
+    languageModelDelegatePath,
+    LanguageModelFrontendDelegate,
+    LanguageModelProvider,
+    LanguageModelRegistry,
+    LanguageModelRegistryClient,
+    languageModelRegistryDelegatePath,
+    LanguageModelRegistryFrontendDelegate,
+    PromptCustomizationService,
+    PromptService,
+    PromptServiceImpl,
+    ToolProvider
+} from '../common';
+import {
+    FrontendLanguageModelRegistryImpl,
+    LanguageModelDelegateClientImpl,
+} from './frontend-language-model-registry';
+
+import { bindViewContribution, FrontendApplicationContribution, WidgetFactory } from '@theia/core/lib/browser';
+import { TabBarToolbarContribution } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
+import { LanguageGrammarDefinitionContribution } from '@theia/monaco/lib/browser/textmate';
+import { AIAgentConfigurationWidget } from './ai-configuration/agent-configuration-widget';
+import { AIConfigurationSelectionService } from './ai-configuration/ai-configuration-service';
+import { AIAgentConfigurationViewContribution } from './ai-configuration/ai-configuration-view-contribution';
+import { AIConfigurationContainerWidget } from './ai-configuration/ai-configuration-widget';
+import { AIVariableConfigurationWidget } from './ai-configuration/variable-configuration-widget';
+import { AICoreFrontendApplicationContribution } from './ai-core-frontend-application-contribution';
+import { bindAICorePreferences } from './ai-core-preferences';
+import { AISettingsServiceImpl } from './ai-settings-service';
+import { FrontendPromptCustomizationServiceImpl } from './frontend-prompt-customization-service';
+import { FrontendVariableService } from './frontend-variable-service';
+import { PromptTemplateContribution } from './prompttemplate-contribution';
+import { TomorrowVariableContribution } from '../common/tomorrow-variable-contribution';
+import { TheiaVariableContribution } from './theia-variable-contribution';
+import { TodayVariableContribution } from '../common/today-variable-contribution';
+import { AgentsVariableContribution } from '../common/agents-variable-contribution';
+import { AIActivationService } from './ai-activation-service';
+import { AgentService, AgentServiceImpl } from '../common/agent-service';
+import { AICommandHandlerFactory } from './ai-command-handler-factory';
+import { AISettingsService } from '../common/settings-service';
+
+export default new ContainerModule(bind => {
+    bindContributionProvider(bind, LanguageModelProvider);
+
+    bind(FrontendLanguageModelRegistryImpl).toSelf().inSingletonScope();
+    bind(LanguageModelRegistry).toService(FrontendLanguageModelRegistryImpl);
+
+    bind(LanguageModelDelegateClientImpl).toSelf().inSingletonScope();
+    bind(LanguageModelDelegateClient).toService(LanguageModelDelegateClientImpl);
+    bind(LanguageModelRegistryClient).toService(LanguageModelDelegateClient);
+
+    bind(LanguageModelRegistryFrontendDelegate).toDynamicValue(
+        ctx => {
+            const connection = ctx.container.get<ServiceConnectionProvider>(RemoteConnectionProvider);
+            const client = ctx.container.get<LanguageModelRegistryClient>(LanguageModelRegistryClient);
+            return connection.createProxy<LanguageModelRegistryFrontendDelegate>(languageModelRegistryDelegatePath, client);
+        }
+    );
+
+    bind(LanguageModelFrontendDelegate)
+        .toDynamicValue(ctx => {
+            const connection = ctx.container.get<ServiceConnectionProvider>(RemoteConnectionProvider);
+            const client = ctx.container.get<LanguageModelDelegateClient>(LanguageModelDelegateClient);
+            return connection.createProxy<LanguageModelFrontendDelegate>(languageModelDelegatePath, client);
+        })
+        .inSingletonScope();
+
+    bindAICorePreferences(bind);
+
+    bind(FrontendPromptCustomizationServiceImpl).toSelf().inSingletonScope();
+    bind(PromptCustomizationService).toService(FrontendPromptCustomizationServiceImpl);
+    bind(PromptServiceImpl).toSelf().inSingletonScope();
+    bind(PromptService).toService(PromptServiceImpl);
+
+    bind(PromptTemplateContribution).toSelf().inSingletonScope();
+    bind(LanguageGrammarDefinitionContribution).toService(PromptTemplateContribution);
+    bind(CommandContribution).toService(PromptTemplateContribution);
+    bind(TabBarToolbarContribution).toService(PromptTemplateContribution);
+
+    bind(AIConfigurationSelectionService).toSelf().inSingletonScope();
+    bind(AIConfigurationContainerWidget).toSelf();
+    bind(WidgetFactory)
+        .toDynamicValue(ctx => ({
+            id: AIConfigurationContainerWidget.ID,
+            createWidget: () => ctx.container.get(AIConfigurationContainerWidget)
+        }))
+        .inSingletonScope();
+
+    bindViewContribution(bind, AIAgentConfigurationViewContribution);
+    bind(AISettingsService).to(AISettingsServiceImpl).inRequestScope();
+    bindContributionProvider(bind, AIVariableContribution);
+    bind(FrontendVariableService).toSelf().inSingletonScope();
+    bind(AIVariableService).toService(FrontendVariableService);
+    bind(FrontendApplicationContribution).toService(FrontendVariableService);
+    bind(AIVariableContribution).to(TheiaVariableContribution).inSingletonScope();
+    bind(AIVariableContribution).to(TodayVariableContribution).inSingletonScope();
+    bind(AIVariableContribution).to(TomorrowVariableContribution).inSingletonScope();
+    bind(AIVariableContribution).to(AgentsVariableContribution).inSingletonScope();
+
+    bind(FrontendApplicationContribution).to(AICoreFrontendApplicationContribution).inSingletonScope();
+
+    bind(AIVariableConfigurationWidget).toSelf();
+    bind(WidgetFactory)
+        .toDynamicValue(ctx => ({
+            id: AIVariableConfigurationWidget.ID,
+            createWidget: () => ctx.container.get(AIVariableConfigurationWidget)
+        }))
+        .inSingletonScope();
+
+    bind(AIAgentConfigurationWidget).toSelf();
+    bind(WidgetFactory)
+        .toDynamicValue(ctx => ({
+            id: AIAgentConfigurationWidget.ID,
+            createWidget: () => ctx.container.get(AIAgentConfigurationWidget)
+        }))
+        .inSingletonScope();
+
+    bind(ToolInvocationRegistry).to(ToolInvocationRegistryImpl).inSingletonScope();
+    bindContributionProvider(bind, ToolProvider);
+
+    bind(AIActivationService).toSelf().inSingletonScope();
+    bind(FrontendApplicationContribution).toService(AIActivationService);
+    bind(AgentServiceImpl).toSelf().inSingletonScope();
+    bind(AgentService).toService(AgentServiceImpl);
+
+    bind(AICommandHandlerFactory).toFactory<CommandHandler>(context => (handler: CommandHandler) => {
+        const activationService = context.container.get(AIActivationService);
+        return {
+            execute: (...args: unknown[]) => handler.execute(...args),
+            isEnabled: (...args: unknown[]) => activationService.isActive && (handler.isEnabled?.(...args) ?? true),
+            isVisible: (...args: unknown[]) => activationService.isActive && (handler.isVisible?.(...args) ?? true),
+            isToggled: (...args: unknown[]) => handler.isToggled?.(...args) ?? false
+        };
+    });
+});

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

@@ -0,0 +1,115 @@
+// *****************************************************************************
+// Copyright (C) 2024 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 { PreferenceContribution, PreferenceProxy, PreferenceSchema } from '@theia/core/lib/browser';
+import { PreferenceProxyFactory } from '@theia/core/lib/browser/preferences/injectable-preference-proxy';
+import { interfaces } from '@theia/core/shared/inversify';
+
+export const AI_CORE_PREFERENCES_TITLE = '✨ AI Features [Experimental]';
+export const PREFERENCE_NAME_ENABLE_EXPERIMENTAL = 'ai-features.AiEnable.enableAI';
+export const PREFERENCE_NAME_PROMPT_TEMPLATES = 'ai-features.promptTemplates.promptTemplatesFolder';
+export const PREFERENCE_NAME_REQUEST_SETTINGS = 'ai-features.modelSettings.requestSettings';
+
+export const aiCorePreferenceSchema: PreferenceSchema = {
+    type: 'object',
+    properties: {
+        [PREFERENCE_NAME_ENABLE_EXPERIMENTAL]: {
+            title: AI_CORE_PREFERENCES_TITLE,
+            markdownDescription: '❗ This setting allows you to access and experiment with the latest AI capabilities.\
+            \n\
+            Please note that these features are in an experimental phase, which means they may be unstable and\
+            undergo significant changes. It is important to be aware that these experimental features may generate\
+            continuous requests to the language models (LLMs) you provide access to. This might incur costs that you\
+            need to monitor closely. By enabling this option, you acknowledge these risks.\
+            \n\
+            **Please note! The settings below in this section will only take effect\n\
+            once the main feature setting is enabled. After enabling the feature, you need to configure at least one\
+            LLM provider below. Also see [the documentation](https://theia-ide.org/docs/user_ai/)**.',
+            type: 'boolean',
+            default: false,
+        },
+        [PREFERENCE_NAME_PROMPT_TEMPLATES]: {
+            title: AI_CORE_PREFERENCES_TITLE,
+            description: 'Folder for storing customized prompt templates. If not customized the user config directory is used. Please consider to use a folder, which is\
+            under version control to manage your variants of prompt templates.',
+            type: 'string',
+            default: '',
+            typeDetails: {
+                isFilepath: true,
+                selectionProps: {
+                    openLabel: 'Select Folder',
+                    canSelectFiles: false,
+                    canSelectFolders: true,
+                    canSelectMany: false
+                }
+            },
+        },
+        [PREFERENCE_NAME_REQUEST_SETTINGS]: {
+            title: 'Custom Request Settings',
+            markdownDescription: 'Allows specifying custom request settings for multiple models.\n\
+            Each object represents the configuration for a specific model. The `modelId` field specifies the model ID, `requestSettings` defines model-specific settings.\n\
+            The `providerId` field is optional and allows you to apply the settings to a specific provider. If not set, the settings will be applied to all providers.\n\
+            Example providerIds: huggingface, openai, ollama, llamafile.\n\
+            Refer to [our documentation](https://theia-ide.org/docs/user_ai/#custom-request-settings) for more information.',
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    modelId: {
+                        type: 'string',
+                        description: 'The model id'
+                    },
+                    requestSettings: {
+                        type: 'object',
+                        additionalProperties: true,
+                        description: 'Settings for the specific model ID.',
+                    },
+                    providerId: {
+                        type: 'string',
+                        description: 'The (optional) provider id to apply the settings to. If not set, the settings will be applied to all providers.',
+                    },
+                },
+            },
+            default: [],
+        }
+    }
+};
+export interface AICoreConfiguration {
+    [PREFERENCE_NAME_ENABLE_EXPERIMENTAL]: boolean | undefined;
+    [PREFERENCE_NAME_PROMPT_TEMPLATES]: string | undefined;
+    [PREFERENCE_NAME_REQUEST_SETTINGS]: Array<{
+        modelId: string;
+        requestSettings?: { [key: string]: unknown };
+        providerId?: string;
+    }> | undefined;
+}
+
+export interface RequestSetting {
+    modelId: string;
+    requestSettings?: { [key: string]: unknown };
+    providerId?: string;
+}
+
+export const AICorePreferences = Symbol('AICorePreferences');
+export type AICorePreferences = PreferenceProxy<AICoreConfiguration>;
+
+export function bindAICorePreferences(bind: interfaces.Bind): void {
+    bind(AICorePreferences).toDynamicValue(ctx => {
+        const factory = ctx.container.get<PreferenceProxyFactory>(PreferenceProxyFactory);
+        return factory(aiCorePreferenceSchema);
+    }).inSingletonScope();
+    bind(PreferenceContribution).toConstantValue({ schema: aiCorePreferenceSchema });
+}