Theia AI Change Sets: Managing Complex AI Change Suggestions

In modern development environments, AI assistants have become indispensable for enhancing developer productivity. However, a persistent challenge has been presenting complex AI-suggested changes to users alongside their chat conversation. Traditional approaches often intermingle change suggestions of the AI with explanatory text, making it difficult for developers to maintain a clear overview of modifications spanning multiple resources, such as files.

Theia AI’s innovative Change Sets feature elegantly addresses this challenge by providing a dedicated area in a chat session that centralizes all change suggestions. Change Sets separate suggested changes from the ongoing conversation, creating a distinct area where users can systematically review modifications across files and other types of resources. This concept has been successfully adopted for code files in well-known proprietary AI-native IDEs, such as Github Copilot or Cursor’s Composer mode. Now, with Theia AI’s support for Change Sets, this innovative capability becomes available for tool builders developing their own specialized IDEs and in the AI-powered Theia IDE. Theia AI’s changeset support goes even beyond code and files, it is flexible enough to be applied for any change representation e.g. in domain-specific tools or modeling environments, too.

If you don’t know Theia AI, visit the Theia AI introduction and learn more about developing AI assistants in domain-specific tools. To try it out first hand, you can download the AI-powered Theia IDE built with Theia AI today.

Introducing Theia AI’s Change Sets

With the new Change Sets feature, Theia AI introduces a central, dedicated space above the chat input where all AI-suggested changes are collected within a chat session and presented for review—separate from the ongoing conversation, yet a prominent place of chat session.

Let’s have a look at a concrete domain-specific example tool for configuring and developing robots. In this video, a user requests to add a lidar component to their robot, describing the behavior they want the robot to implement using this new sensor. The AI responds with a comprehensive change set containing three distinct modifications: implementation code for the requested behavior, updates to the documentation reflecting the new capability, and a change to the robot’s component configuration model to include the required hardware. We can see the user reviewing the documentation changes in a diff editor to verify the content before applying all the suggested changes at once.

This approach to deal with AI-suggested changes provides numerous benefits for users:

1. AI staging area: All changes proposed by the AI are collected in one place, separate from the chat conversation. Think of it as the staging area of your AI.

2. Efficient review and apply process: Users can systematically review and apply the changes in the context of a logical unit, such as a file or changed element, without having to scroll through the conversation history—and apply changes selectively or all of them at once.

3. Iterating on changes in context: Users can ask for adjustments to specific changes without losing track of the overall set of changes. Also the AI can keep all changes in context at once, ensuring to adapt all relevant changes cohesively.

4. Ready for domain-specific elements: Changes to different resource types (files, diagrams, configurations) are presented in a consistent interface.

👉 Do you want to see Change Sets in Action, see How Theia Coder applies them in the AI-powered Theia IDE!

Implementing Change Sets in Your Custom Tools

Adopting Change Sets in Theia AI involves a straightforward process that tool builders can follow to enhance their custom environments with well-managed, AI-suggested changes. Here’s how to integrate this powerful feature:

1. Create a Custom Agent

The first step is to create a custom chat agent in Theia AI, which will handle user requests and coordinate with the LLM to generate appropriate responses and change suggestions. Theia AI provides a comprehensive framework for creating these agents (see Theia AI documentation).

Agents mediate between the user, the LLM, and the tool. They get the user conversation as input and control the entire LLM communication, the context augmentation, the prompt flow and how the LLM response(s) are translated back to the user in the form of a reply, as well as in the form of change suggestions.

2. Turning LLM Responses into Change Sets

Once your agent is established, you need to decide how it enables the LLM to interact with the Change Sets. There are two primary approaches:

1. Using structured prompts: Design prompts that instruct the LLM to format its change suggestions in a specific, parseable way. Your agent would then parse the LLM’s responses to extract file paths, change types, and content modifications, translating them into Change Set elements.

2. Providing tool functions: Expose specialized functions to the LLM that enable it to directly create and modify Change Set elements. The Theia Coder agent of the AI-powered Theia IDE for software developers demonstrates this approach with functions like WriteChangeToFile (see full source code). This method gives the LLM more direct control over Change Set creation and management.

Whether to you use structured prompts or tool functions depends on your specific requirements and your strategy for separation of control. With structured prompts, your agent is in control of the entire process of creating change elements, which may improve reliability. On the other hand, this may require a more complex agent. With tool functions, you give more power to the LLM, which may increase flexibility of reacting to different types of user requests, but this requires a very capable LLM and may cause more unexpected behavior if not prompted properly.

3. Create and Populate Change Sets

After determining how your LLM will communicate changes, implement the logic to create and populate Change Sets in your agent’s invoke method or in the tool handlers you provide to the LLM. The framework provides a clean API for this purpose, the following example shows how to add a “file creation” element to a change set:

// Create a change set with a descriptive name
const changeSet = new ChangeSetImpl('Refactoring Change Set');

// Add file changes to the change set (add, modify, or delete)
changeSet.addElement(
    this.fileChangeFactory({
        uri: fileToAdd,
        type: 'add',
        state: 'pending',
        targetState: 'New content for the file',
        changeSet,
        chatSessionId: request.session.id
    })
);

// Attach the change set to the session
request.session.setChangeSet(changeSet);
request.response.complete();

This pattern allows your agent to collect all proposed changes from the LLM into a single, organized Change Set that users can review comprehensively before applying any modifications.

For more information on how to manage change sets, please refer to the detailed Theia AI documentation and examples.

Beyond Text Files: Custom Change Set Elements

What truly sets Theia AI apart is its ability to represent change suggestions beyond traditional text files. As a framework designed for specialized IDEs and domain-specific tools, Theia AI enables you to define custom Change Set elements for virtually any resource type, including:

• Your specific data formats that users edit in form-based editors
• Models underneath a graphical diagram
• Domain-specific languages and modeling languages

The screenshot above illustrates how Theia AI’s change sets can represent modifications across different resource types. In this example, a user has requested to integrate a new sensor into a robot configuration project. The AI response includes not only traditional text-based changes (implementation code and documentation updates) but also a domain-specific change to the robot’s configuration model. This third change element – Add LiDAR X123 – demonstrates Theia AI’s flexibility: it represents a modification to a specialized, non-text format that requires custom visualization and handling.

With the flexible ChangeSetElement interfaces that agents can add to change sets, tool builders have full control over how these custom Change Set elements appear in the user interface by providing a dedicated name, icon, and optional additional information. They also can provide custom implementations for how such elements behave on click, how to represent the changes if the user opens the change details, or how to apply or revert those changes in the workspace.

export interface ChangeSetElement {
    readonly uri: URI;

    onDidChange?: Event<void>
    readonly name?: string;
    readonly icon?: string;
    readonly additionalInfo?: string;

    readonly state?: 'pending' | 'applied' | 'stale';
    readonly type?: 'add' | 'modify' | 'delete';
    readonly data?: { [key: string]: unknown };

    open?(): Promise<void>;
    openChange?(): Promise<void>;
    apply?(): Promise<void>;
    revert?(): Promise<void>;
    dispose?(): void;
}

/// ... adding a custom change set type:
changeSet.addElements(
    {
        uri: new URI('component://sensors/0/lidarx123'),
        name: 'Add LiDAR X123',
        additionalInfo: 'Component Model',
        icon: 'codicon codicon-chip',
        apply: async () => {
            // ... your custom logic to add a component to your model
        },
        openChange: async () => {
            // ... your custom code to open your custom editor highlighting the change
        };
        // ...
    }
);

This flexibility makes Theia AI an ideal foundation for implementing AI assistants in specialized tools where changes might affect multiple heterogeneous types of resources.

Conclusion

Change Sets in Theia AI represent a significant step forward in how AI agents propose modifications to resources in development environments. By providing a dedicated, organized place for suggested changes, they streamline the collaboration between AI and users, making it easier to review, refine, and apply changes with confidence.

For tool builders, the extensible nature of Theia AI’s Change Sets opens new possibilities for integrating AI assistance into specialized environments, with support for domain-specific resource types beyond traditional text files.

Learn More

To explore more about Theia AI and its capabilities:

• Theia AI introduction
• Theia AI vision
• Theia AI documentation
• Theia Tool Platform

Interested in implementing Theia AI in your tools? EclipseSource provides consulting and implementation services backed by our extensive experience in tool development. We also specialize in tailored AI assistance for web- and cloud-based tools and professional support for Eclipse Theia and VS Code.

👉 Get in touch with us to discuss your specific use case!