@jupyterlite/ai 0.2.0 → 0.4.0

package/README.md

@@ -3,9 +3,9 @@
 [![Github Actions Status](https://github.com/jupyterlite/ai/workflows/Build/badge.svg)](https://github.com/jupyterlite/ai/actions/workflows/build.yml)
 [![lite-badge](https://jupyterlite.rtfd.io/en/latest/_static/badge.svg)](https://jupyterlite.github.io/ai/lab/index.html)
 
-AI code completions and chat for JupyterLab, Notebook 7 and JupyterLite, powered by MistralAI ✨
+AI code completions and chat for JupyterLab, Notebook 7 and JupyterLite ✨
 
-[a screencast showing the Codestral extension in JupyterLite](https://github.com/jupyterlite/ai/assets/591645/855c4e3e-3a63-4868-8052-5c9909922c21)
+[a screencast showing the Jupyterlite AI extension in JupyterLite](https://github.com/jupyterlite/ai/assets/591645/855c4e3e-3a63-4868-8052-5c9909922c21)
 
 ## Requirements
 
@@ -14,12 +14,7 @@ AI code completions and chat for JupyterLab, Notebook 7 and JupyterLite, powered
 > To enable more AI providers in JupyterLab and Jupyter Notebook, we recommend using the [Jupyter AI](https://github.com/jupyterlab/jupyter-ai) extension directly.
 > At the moment Jupyter AI is not compatible with JupyterLite, but might be to some extent in the future.
 
-- JupyterLab >= 4.1.0 or Notebook >= 7.1.0
-
-> [!WARNING]
-> This extension is still very much experimental. It is not an official MistralAI extension.
-> It is exploring the integration of the MistralAI API with JupyterLab, which can also be used in [JupyterLite](https://jupyterlite.readthedocs.io/).
-> For a more complete AI extension for JupyterLab, see [Jupyter AI](https://github.com/jupyterlab/jupyter-ai).
+- JupyterLab >= 4.4.0a0 or Notebook >= 7.4.0a0
 
 ## ✨ Try it in your browser ✨
 
@@ -37,13 +32,29 @@ To install the extension, execute:
 pip install jupyterlite-ai
 ```
 
+To install requirements (jupyterlab, jupyterlite and notebook), there is an optional dependencies argument:
+
+```bash
+pip install jupyterlite-ai[jupyter]
+```
+
 # Usage
 
+AI providers typically require using an API key to access their models.
+
+The process is different for each provider, so you may refer to their documentation to learn how to generate new API keys, if they are not covered in the sections below.
+
+## Using MistralAI
+
+> [!WARNING]
+> This extension is still very much experimental. It is not an official MistralAI extension.
+
 1. Go to https://console.mistral.ai/api-keys/ and create an API key.
 
 ![Screenshot showing how to create an API key](./img/1-api-key.png)
 
-2. Open the JupyterLab settings and go to the Codestral section to enter the API key
+2. Open the JupyterLab settings and go to the **Ai providers** section to select the `MistralAI`
+   provider and the API key (required).
 
 ![Screenshot showing how to add the API key to the settings](./img/2-jupyterlab-settings.png)
 
@@ -51,6 +62,34 @@ pip install jupyterlite-ai
 
 ![Screenshot showing how to use the chat](./img/3-usage.png)
 
+## Using ChromeAI
+
+> [!WARNING]
+> Support for ChromeAI is still experimental and only available in Google Chrome.
+
+You can test ChromeAI is enabled in your browser by going to the following URL: https://chromeai.org/
+
+Enable the proper flags in Google Chrome.
+
+- chrome://flags/#prompt-api-for-gemini-nano
+  - Select: `Enabled`
+- chrome://flags/#optimization-guide-on-device-model
+  - Select: `Enabled BypassPrefRequirement`
+- chrome://components
+  - Click `Check for Update` on Optimization Guide On Device Model to download the model
+- [Optional] chrome://flags/#text-safety-classifier
+
+![a screenshot showing how to enable the ChromeAI flag in Google Chrome](https://github.com/user-attachments/assets/d48f46cc-52ee-4ce5-9eaf-c763cdbee04c)
+
+Then restart Chrome for these changes to take effect.
+
+> [!WARNING]
+> On first use, Chrome will download the on-device model, which can be as large as 22GB (according to their docs and at the time of writing).
+> During the download, ChromeAI may not be available via the extension.
+
+> [!NOTE]
+> For more information about Chrome Built-in AI: https://developer.chrome.com/docs/ai/get-started
+
 ## Uninstall
 
 To remove the extension, execute:

package/lib/chat-handler.d.ts

@@ -1,6 +1,6 @@
 import { ChatModel, IChatHistory, IChatMessage, INewMessage } from '@jupyter/chat';
 import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import { IAIProvider } from './token';
+import { IAIProviderRegistry } from './tokens';
 export type ConnectionMessage = {
     type: 'connection';
     client_id: string;
@@ -8,17 +8,29 @@ export type ConnectionMessage = {
 export declare class ChatHandler extends ChatModel {
     constructor(options: ChatHandler.IOptions);
     get provider(): BaseChatModel | null;
+    /**
+     * Getter and setter for the persona name.
+     */
+    get personaName(): string;
+    set personaName(value: string);
+    /**
+     * Getter and setter for the initial prompt.
+     */
+    get prompt(): string;
+    set prompt(value: string);
     sendMessage(message: INewMessage): Promise<boolean>;
     getHistory(): Promise<IChatHistory>;
     dispose(): void;
     messageAdded(message: IChatMessage): void;
-    private _aiProvider;
+    private _providerRegistry;
+    private _personaName;
+    private _prompt;
     private _errorMessage;
     private _history;
     private _defaultErrorMessage;
 }
 export declare namespace ChatHandler {
     interface IOptions extends ChatModel.IOptions {
-        aiProvider: IAIProvider;
+        providerRegistry: IAIProviderRegistry;
     }
 }

package/lib/chat-handler.js

@@ -3,34 +3,81 @@
  * Distributed under the terms of the Modified BSD License.
  */
 import { ChatModel } from '@jupyter/chat';
-import { AIMessage, HumanMessage, mergeMessageRuns } from '@langchain/core/messages';
+import { AIMessage, HumanMessage, mergeMessageRuns, SystemMessage } from '@langchain/core/messages';
 import { UUID } from '@lumino/coreutils';
-import { getErrorMessage } from './llm-models';
+import { chatSystemPrompt } from './provider';
+import { jupyternautLiteIcon } from './icons';
+/**
+ * The base64 encoded SVG string of the jupyternaut lite icon.
+ * Encode so it can be passed as avatar_url to jupyter-chat.
+ */
+const AI_AVATAR_BASE64 = btoa(jupyternautLiteIcon.svgstr);
+const AI_AVATAR = `data:image/svg+xml;base64,${AI_AVATAR_BASE64}`;
 export class ChatHandler extends ChatModel {
     constructor(options) {
         super(options);
+        this._personaName = 'AI';
         this._errorMessage = '';
         this._history = { messages: [] };
         this._defaultErrorMessage = 'AI provider not configured';
-        this._aiProvider = options.aiProvider;
-        this._aiProvider.modelChange.connect(() => {
-            this._errorMessage = this._aiProvider.chatError;
+        this._providerRegistry = options.providerRegistry;
+        this._prompt = chatSystemPrompt({
+            provider_name: this._providerRegistry.currentName
+        });
+        this._providerRegistry.providerChanged.connect(() => {
+            this._errorMessage = this._providerRegistry.chatError;
+            this._prompt = chatSystemPrompt({
+                provider_name: this._providerRegistry.currentName
+            });
         });
     }
     get provider() {
-        return this._aiProvider.chatModel;
+        return this._providerRegistry.currentChatModel;
+    }
+    /**
+     * Getter and setter for the persona name.
+     */
+    get personaName() {
+        return this._personaName;
+    }
+    set personaName(value) {
+        this.messages.forEach(message => {
+            if (message.sender.username === this._personaName) {
+                const updated = { ...message };
+                updated.sender.username = value;
+                this.messageAdded(updated);
+            }
+        });
+        this._personaName = value;
+    }
+    /**
+     * Getter and setter for the initial prompt.
+     */
+    get prompt() {
+        return this._prompt;
+    }
+    set prompt(value) {
+        this._prompt = value;
     }
     async sendMessage(message) {
+        var _a;
+        const body = message.body;
+        if (body.startsWith('/clear')) {
+            // TODO: do we need a clear method?
+            this.messagesDeleted(0, this.messages.length);
+            this._history.messages = [];
+            return false;
+        }
         message.id = UUID.uuid4();
         const msg = {
             id: message.id,
-            body: message.body,
+            body,
             sender: { username: 'User' },
             time: Date.now(),
             type: 'msg'
         };
         this.messageAdded(msg);
-        if (this._aiProvider.chatModel === null) {
+        if (this._providerRegistry.currentChatModel === null) {
             const errorMsg = {
                 id: UUID.uuid4(),
                 body: `**${this._errorMessage ? this._errorMessage : this._defaultErrorMessage}**`,
@@ -42,30 +89,35 @@ export class ChatHandler extends ChatModel {
             return false;
         }
         this._history.messages.push(msg);
-        const messages = mergeMessageRuns(this._history.messages.map(msg => {
+        const messages = mergeMessageRuns([new SystemMessage(this._prompt)]);
+        messages.push(...this._history.messages.map(msg => {
             if (msg.sender.username === 'User') {
                 return new HumanMessage(msg.body);
             }
             return new AIMessage(msg.body);
         }));
-        this.updateWriters([{ username: 'AI' }]);
-        return this._aiProvider.chatModel
-            .invoke(messages)
-            .then(response => {
-            const content = response.content;
-            const botMsg = {
-                id: UUID.uuid4(),
-                body: content.toString(),
-                sender: { username: 'AI' },
-                time: Date.now(),
-                type: 'msg'
-            };
-            this.messageAdded(botMsg);
+        const sender = { username: this._personaName, avatar_url: AI_AVATAR };
+        this.updateWriters([sender]);
+        // create an empty message to be filled by the AI provider
+        const botMsg = {
+            id: UUID.uuid4(),
+            body: '',
+            sender,
+            time: Date.now(),
+            type: 'msg'
+        };
+        let content = '';
+        try {
+            for await (const chunk of await this._providerRegistry.currentChatModel.stream(messages)) {
+                content += (_a = chunk.content) !== null && _a !== void 0 ? _a : chunk;
+                botMsg.body = content;
+                this.messageAdded(botMsg);
+            }
             this._history.messages.push(botMsg);
             return true;
-        })
-            .catch(reason => {
-            const error = getErrorMessage(this._aiProvider.name, reason);
+        }
+        catch (reason) {
+            const error = this._providerRegistry.formatErrorMessage(reason);
             const errorMsg = {
                 id: UUID.uuid4(),
                 body: `**${error}**`,
@@ -75,10 +127,10 @@ export class ChatHandler extends ChatModel {
             };
             this.messageAdded(errorMsg);
             return false;
-        })
-            .finally(() => {
+        }
+        finally {
             this.updateWriters([]);
-        });
+        }
     }
     async getHistory() {
         return this._history;

package/lib/completion-provider.d.ts

@@ -1,20 +1,12 @@
 import { CompletionHandler, IInlineCompletionContext, IInlineCompletionProvider } from '@jupyterlab/completer';
-import { LLM } from '@langchain/core/language_models/llms';
-import { IBaseCompleter, BaseCompleter } from './llm-models';
-import { ReadonlyPartialJSONObject } from '@lumino/coreutils';
+import { IBaseCompleter } from './llm-models';
+import { IAIProviderRegistry } from './tokens';
 /**
  * The generic completion provider to register to the completion provider manager.
  */
 export declare class CompletionProvider implements IInlineCompletionProvider {
     readonly identifier = "@jupyterlite/ai";
     constructor(options: CompletionProvider.IOptions);
-    /**
-     * Set the completer.
-     *
-     * @param name - the name of the completer.
-     * @param settings - The settings associated to the completer.
-     */
-    setCompleter(name: string, settings: ReadonlyPartialJSONObject): void;
     /**
      * Get the current completer name.
      */
@@ -23,18 +15,13 @@ export declare class CompletionProvider implements IInlineCompletionProvider {
      * Get the current completer.
      */
     get completer(): IBaseCompleter | null;
-    /**
-     * Get the LLM completer.
-     */
-    get llmCompleter(): LLM | null;
     fetch(request: CompletionHandler.IRequest, context: IInlineCompletionContext): Promise<any>;
-    private _name;
+    private _providerRegistry;
     private _requestCompletion;
-    private _completer;
 }
 export declare namespace CompletionProvider {
-    interface IOptions extends BaseCompleter.IOptions {
-        name: string;
+    interface IOptions {
+        providerRegistry: IAIProviderRegistry;
         requestCompletion: () => void;
     }
 }

package/lib/completion-provider.js

@@ -1,57 +1,31 @@
-import { getCompleter } from './llm-models';
 /**
  * The generic completion provider to register to the completion provider manager.
  */
 export class CompletionProvider {
     constructor(options) {
         this.identifier = '@jupyterlite/ai';
-        this._name = 'None';
-        this._completer = null;
-        const { name, settings } = options;
+        this._providerRegistry = options.providerRegistry;
         this._requestCompletion = options.requestCompletion;
-        this.setCompleter(name, settings);
-    }
-    /**
-     * Set the completer.
-     *
-     * @param name - the name of the completer.
-     * @param settings - The settings associated to the completer.
-     */
-    setCompleter(name, settings) {
-        try {
-            this._completer = getCompleter(name, settings);
-            if (this._completer) {
-                this._completer.requestCompletion = this._requestCompletion;
+        this._providerRegistry.providerChanged.connect(() => {
+            if (this.completer) {
+                this.completer.requestCompletion = this._requestCompletion;
             }
-            this._name = this._completer === null ? 'None' : name;
-        }
-        catch (e) {
-            this._completer = null;
-            this._name = 'None';
-            throw e;
-        }
+        });
     }
     /**
      * Get the current completer name.
      */
     get name() {
-        return this._name;
+        return this._providerRegistry.currentName;
     }
     /**
      * Get the current completer.
      */
     get completer() {
-        return this._completer;
-    }
-    /**
-     * Get the LLM completer.
-     */
-    get llmCompleter() {
-        var _a;
-        return ((_a = this._completer) === null || _a === void 0 ? void 0 : _a.provider) || null;
+        return this._providerRegistry.currentCompleter;
     }
     async fetch(request, context) {
         var _a;
-        return (_a = this._completer) === null || _a === void 0 ? void 0 : _a.fetch(request, context);
+        return (_a = this.completer) === null || _a === void 0 ? void 0 : _a.fetch(request, context);
     }
 }

package/lib/icons.d.ts

@@ -0,0 +1,2 @@
+import { LabIcon } from '@jupyterlab/ui-components';
+export declare const jupyternautLiteIcon: LabIcon;

package/lib/icons.js

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { LabIcon } from '@jupyterlab/ui-components';
+/**
+ * This icon is based on the jupyternaut icon from Jupyter AI:
+ * https://github.com/jupyterlab/jupyter-ai/blob/main/packages/jupyter-ai/style/icons/jupyternaut.svg
+ * With a small tweak for the colors to match the JupyterLite icon.
+ */
+import jupyternautLiteSvg from '../style/icons/jupyternaut-lite.svg';
+export const jupyternautLiteIcon = new LabIcon({
+    name: '@jupyterlite/ai:jupyternaut-lite',
+    svgstr: jupyternautLiteSvg
+});

package/lib/index.d.ts

@@ -1,4 +1,5 @@
+import { IAutocompletionRegistry } from '@jupyter/chat';
 import { JupyterFrontEndPlugin } from '@jupyterlab/application';
-import { IAIProvider } from './token';
-declare const _default: (JupyterFrontEndPlugin<void> | JupyterFrontEndPlugin<IAIProvider>)[];
+import { IAIProviderRegistry } from './tokens';
+declare const _default: (JupyterFrontEndPlugin<void> | JupyterFrontEndPlugin<IAutocompletionRegistry> | JupyterFrontEndPlugin<IAIProviderRegistry>)[];
 export default _default;

package/lib/index.js

@@ -1,19 +1,49 @@
-import { ActiveCellManager, buildChatSidebar, buildErrorWidget } from '@jupyter/chat';
+import { ActiveCellManager, AutocompletionRegistry, buildChatSidebar, buildErrorWidget, IAutocompletionRegistry } from '@jupyter/chat';
 import { IThemeManager } from '@jupyterlab/apputils';
 import { ICompletionProviderManager } from '@jupyterlab/completer';
 import { INotebookTracker } from '@jupyterlab/notebook';
 import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
+import { IFormRendererRegistry } from '@jupyterlab/ui-components';
 import { ChatHandler } from './chat-handler';
-import { AIProvider } from './provider';
-import { IAIProvider } from './token';
+import { CompletionProvider } from './completion-provider';
+import { AIProviders } from './llm-models';
+import { AIProviderRegistry } from './provider';
+import { aiSettingsRenderer } from './settings/panel';
+import { renderSlashCommandOption } from './slash-commands';
+import { IAIProviderRegistry } from './tokens';
+const autocompletionRegistryPlugin = {
+    id: '@jupyterlite/ai:autocompletion-registry',
+    description: 'Autocompletion registry',
+    autoStart: true,
+    provides: IAutocompletionRegistry,
+    activate: () => {
+        const autocompletionRegistry = new AutocompletionRegistry();
+        const options = ['/clear'];
+        const autocompletionCommands = {
+            opener: '/',
+            commands: options.map(option => {
+                return {
+                    id: option.slice(1),
+                    label: option,
+                    description: 'Clear the chat window'
+                };
+            }),
+            props: {
+                renderOption: renderSlashCommandOption
+            }
+        };
+        autocompletionRegistry.add('jupyterlite-ai', autocompletionCommands);
+        return autocompletionRegistry;
+    }
+};
 const chatPlugin = {
     id: '@jupyterlite/ai:chat',
     description: 'LLM chat extension',
     autoStart: true,
+    requires: [IAIProviderRegistry, IRenderMimeRegistry, IAutocompletionRegistry],
     optional: [INotebookTracker, ISettingRegistry, IThemeManager],
-    requires: [IAIProvider, IRenderMimeRegistry],
-    activate: async (app, aiProvider, rmRegistry, notebookTracker, settingsRegistry, themeManager) => {
+    activate: async (app, providerRegistry, rmRegistry, autocompletionRegistry, notebookTracker, settingsRegistry, themeManager) => {
         let activeCellManager = null;
         if (notebookTracker) {
             activeCellManager = new ActiveCellManager({
@@ -22,16 +52,20 @@ const chatPlugin = {
             });
         }
         const chatHandler = new ChatHandler({
-            aiProvider: aiProvider,
-            activeCellManager: activeCellManager
+            providerRegistry,
+            activeCellManager
         });
         let sendWithShiftEnter = false;
         let enableCodeToolbar = true;
+        let personaName = 'AI';
         function loadSetting(setting) {
             sendWithShiftEnter = setting.get('sendWithShiftEnter')
                 .composite;
             enableCodeToolbar = setting.get('enableCodeToolbar').composite;
+            personaName = setting.get('personaName').composite;
+            // set the properties
             chatHandler.config = { sendWithShiftEnter, enableCodeToolbar };
+            chatHandler.personaName = personaName;
         }
         Promise.all([app.restored, settingsRegistry === null || settingsRegistry === void 0 ? void 0 : settingsRegistry.load(chatPlugin.id)])
             .then(([, settings]) => {
@@ -50,9 +84,10 @@ const chatPlugin = {
             chatWidget = buildChatSidebar({
                 model: chatHandler,
                 themeManager,
-                rmRegistry
+                rmRegistry,
+                autocompletionRegistry
             });
-            chatWidget.title.caption = 'Codestral Chat';
+            chatWidget.title.caption = 'Jupyterlite AI Chat';
         }
         catch (e) {
             chatWidget = buildErrorWidget(themeManager);
@@ -61,30 +96,52 @@ const chatPlugin = {
         console.log('Chat extension initialized');
     }
 };
-const aiProviderPlugin = {
-    id: '@jupyterlite/ai:ai-provider',
+const completerPlugin = {
+    id: '@jupyterlite/ai:completer',
     autoStart: true,
-    requires: [ICompletionProviderManager, ISettingRegistry],
-    provides: IAIProvider,
-    activate: (app, manager, settingRegistry) => {
-        const aiProvider = new AIProvider({
-            completionProviderManager: manager,
+    requires: [IAIProviderRegistry, ICompletionProviderManager],
+    activate: (app, providerRegistry, manager) => {
+        const completer = new CompletionProvider({
+            providerRegistry,
             requestCompletion: () => app.commands.execute('inline-completer:invoke')
         });
+        manager.registerInlineProvider(completer);
+    }
+};
+const providerRegistryPlugin = {
+    id: '@jupyterlite/ai:provider-registry',
+    autoStart: true,
+    requires: [IFormRendererRegistry, ISettingRegistry],
+    optional: [IRenderMimeRegistry],
+    provides: IAIProviderRegistry,
+    activate: (app, editorRegistry, settingRegistry, rmRegistry) => {
+        const providerRegistry = new AIProviderRegistry();
+        editorRegistry.addRenderer('@jupyterlite/ai:provider-registry.AIprovider', aiSettingsRenderer({ providerRegistry, rmRegistry }));
         settingRegistry
-            .load(aiProviderPlugin.id)
+            .load(providerRegistryPlugin.id)
             .then(settings => {
             const updateProvider = () => {
-                const provider = settings.get('provider').composite;
-                aiProvider.setModels(provider, settings.composite);
+                var _a;
+                // Update the settings to the AI providers.
+                const providerSettings = ((_a = settings.get('AIprovider').composite) !== null && _a !== void 0 ? _a : {
+                    provider: 'None'
+                });
+                providerRegistry.setProvider(providerSettings.provider, providerSettings);
             };
             settings.changed.connect(() => updateProvider());
             updateProvider();
         })
             .catch(reason => {
-            console.error(`Failed to load settings for ${aiProviderPlugin.id}`, reason);
+            console.error(`Failed to load settings for ${providerRegistryPlugin.id}`, reason);
         });
-        return aiProvider;
+        // Initialize the registry with the default providers
+        AIProviders.forEach(provider => providerRegistry.add(provider));
+        return providerRegistry;
     }
 };
-export default [chatPlugin, aiProviderPlugin];
+export default [
+    providerRegistryPlugin,
+    autocompletionRegistryPlugin,
+    chatPlugin,
+    completerPlugin
+];

package/lib/llm-models/anthropic-completer.d.ts

@@ -0,0 +1,19 @@
+import { CompletionHandler, IInlineCompletionContext } from '@jupyterlab/completer';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { BaseCompleter, IBaseCompleter } from './base-completer';
+export declare class AnthropicCompleter implements IBaseCompleter {
+    constructor(options: BaseCompleter.IOptions);
+    get provider(): BaseChatModel;
+    /**
+     * Getter and setter for the initial prompt.
+     */
+    get prompt(): string;
+    set prompt(value: string);
+    fetch(request: CompletionHandler.IRequest, context: IInlineCompletionContext): Promise<{
+        items: {
+            insertText: string;
+        }[];
+    }>;
+    private _anthropicProvider;
+    private _prompt;
+}

package/lib/llm-models/anthropic-completer.js

@@ -0,0 +1,57 @@
+import { ChatAnthropic } from '@langchain/anthropic';
+import { AIMessage, SystemMessage } from '@langchain/core/messages';
+import { COMPLETION_SYSTEM_PROMPT } from '../provider';
+export class AnthropicCompleter {
+    constructor(options) {
+        this._prompt = COMPLETION_SYSTEM_PROMPT;
+        this._anthropicProvider = new ChatAnthropic({ ...options.settings });
+    }
+    get provider() {
+        return this._anthropicProvider;
+    }
+    /**
+     * Getter and setter for the initial prompt.
+     */
+    get prompt() {
+        return this._prompt;
+    }
+    set prompt(value) {
+        this._prompt = value;
+    }
+    async fetch(request, context) {
+        const { text, offset: cursorOffset } = request;
+        const prompt = text.slice(0, cursorOffset);
+        // Anthropic does not allow whitespace at the end of the AIMessage
+        const trimmedPrompt = prompt.trim();
+        const messages = [
+            new SystemMessage(this._prompt),
+            new AIMessage(trimmedPrompt)
+        ];
+        try {
+            const response = await this._anthropicProvider.invoke(messages);
+            const items = [];
+            // Anthropic can return string or complex content, a list of string/images/other.
+            if (typeof response.content === 'string') {
+                items.push({
+                    insertText: response.content
+                });
+            }
+            else {
+                response.content.forEach(content => {
+                    if (content.type !== 'text') {
+                        return;
+                    }
+                    items.push({
+                        insertText: content.text,
+                        filterText: prompt.substring(trimmedPrompt.length)
+                    });
+                });
+            }
+            return { items };
+        }
+        catch (error) {
+            console.error('Error fetching completions', error);
+            return { items: [] };
+        }
+    }
+}