@jupyterlite/ai 0.2.0 → 0.4.0

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

@@ -1,11 +1,15 @@
 import { CompletionHandler, IInlineCompletionContext } from '@jupyterlab/completer';
-import { LLM } from '@langchain/core/language_models/llms';
+import { BaseLanguageModel } from '@langchain/core/language_models/base';
 import { ReadonlyPartialJSONObject } from '@lumino/coreutils';
 export interface IBaseCompleter {
     /**
      * The LLM completer.
      */
-    provider: LLM;
+    provider: BaseLanguageModel;
+    /**
+     * The completion prompt.
+     */
+    prompt: string;
     /**
      * The function to fetch a new completion.
      */

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

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

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

@@ -0,0 +1,67 @@
+import { ChromeAI } from '@langchain/community/experimental/llms/chrome_ai';
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { COMPLETION_SYSTEM_PROMPT } from '../provider';
+/**
+ * Regular expression to match the '```' string at the start of a string.
+ * So the completions returned by the LLM can still be kept after removing the code block formatting.
+ *
+ * For example, if the response contains the following content after typing `import pandas`:
+ *
+ * ```python
+ * as pd
+ * ```
+ *
+ * The formatting string after removing the code block delimiters will be:
+ *
+ * as pd
+ */
+const CODE_BLOCK_START_REGEX = /^```(?:[a-zA-Z]+)?\n?/;
+/**
+ * Regular expression to match the '```' string at the end of a string.
+ */
+const CODE_BLOCK_END_REGEX = /```$/;
+export class ChromeCompleter {
+    constructor(options) {
+        this._prompt = COMPLETION_SYSTEM_PROMPT;
+        this._chromeProvider = new ChromeAI({ ...options.settings });
+    }
+    /**
+     * Getter and setter for the initial prompt.
+     */
+    get prompt() {
+        return this._prompt;
+    }
+    set prompt(value) {
+        this._prompt = value;
+    }
+    get provider() {
+        return this._chromeProvider;
+    }
+    async fetch(request, context) {
+        const { text, offset: cursorOffset } = request;
+        const prompt = text.slice(0, cursorOffset);
+        const trimmedPrompt = prompt.trim();
+        const messages = [
+            new SystemMessage(this._prompt),
+            new HumanMessage(trimmedPrompt)
+        ];
+        try {
+            let response = await this._chromeProvider.invoke(messages);
+            // ChromeAI sometimes returns a string starting with '```',
+            // so process the response to remove the code block delimiters
+            if (CODE_BLOCK_START_REGEX.test(response)) {
+                response = response
+                    .replace(CODE_BLOCK_START_REGEX, '')
+                    .replace(CODE_BLOCK_END_REGEX, '');
+            }
+            const items = [{ insertText: response }];
+            return {
+                items
+            };
+        }
+        catch (error) {
+            console.error('Error fetching completion:', error);
+            return { items: [] };
+        }
+    }
+}

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

@@ -1,15 +1,16 @@
 import { CompletionHandler, IInlineCompletionContext } from '@jupyterlab/completer';
-import { LLM } from '@langchain/core/language_models/llms';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import { BaseCompleter, IBaseCompleter } from './base-completer';
 export declare class CodestralCompleter implements IBaseCompleter {
     constructor(options: BaseCompleter.IOptions);
-    get provider(): LLM;
-    set requestCompletion(value: () => void);
-    fetch(request: CompletionHandler.IRequest, context: IInlineCompletionContext): Promise<{
-        items: any;
-    }>;
-    private _requestCompletion?;
+    get provider(): BaseChatModel;
+    /**
+     * Getter and setter for the initial prompt.
+     */
+    get prompt(): string;
+    set prompt(value: string);
+    fetch(request: CompletionHandler.IRequest, context: IInlineCompletionContext): Promise<any>;
     private _throttler;
     private _mistralProvider;
-    private _currentData;
+    private _prompt;
 }

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

@@ -1,75 +1,58 @@
-import { MistralAI } from '@langchain/mistralai';
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { ChatMistralAI } from '@langchain/mistralai';
 import { Throttler } from '@lumino/polling';
+import { COMPLETION_SYSTEM_PROMPT } from '../provider';
 /**
  * The Mistral API has a rate limit of 1 request per second
  */
 const INTERVAL = 1000;
-/**
- * Timeout to avoid endless requests
- */
-const REQUEST_TIMEOUT = 3000;
 export class CodestralCompleter {
     constructor(options) {
-        this._currentData = null;
-        // this._requestCompletion = options.requestCompletion;
-        this._mistralProvider = new MistralAI({ ...options.settings });
-        this._throttler = new Throttler(async (data) => {
-            var _a;
-            const invokedData = data;
-            // Request completion.
-            const request = this._mistralProvider.completionWithRetry(data, {}, false);
-            const timeoutPromise = new Promise(resolve => {
-                return setTimeout(() => resolve(null), REQUEST_TIMEOUT);
-            });
-            // Fetch again if the request is too long or if the prompt has changed.
-            const response = await Promise.race([request, timeoutPromise]);
-            if (response === null ||
-                invokedData.prompt !== ((_a = this._currentData) === null || _a === void 0 ? void 0 : _a.prompt)) {
-                return {
-                    items: [],
-                    fetchAgain: true
-                };
-            }
+        this._prompt = COMPLETION_SYSTEM_PROMPT;
+        this._mistralProvider = new ChatMistralAI({ ...options.settings });
+        this._throttler = new Throttler(async (messages) => {
+            const response = await this._mistralProvider.invoke(messages);
             // Extract results of completion request.
-            const items = response.choices.map((choice) => {
-                return { insertText: choice.message.content };
-            });
-            return {
-                items
-            };
+            const items = [];
+            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
+                    });
+                });
+            }
+            return { items };
         }, { limit: INTERVAL });
     }
     get provider() {
         return this._mistralProvider;
     }
-    set requestCompletion(value) {
-        this._requestCompletion = value;
+    /**
+     * 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);
-        const suffix = text.slice(cursorOffset);
-        const data = {
-            prompt,
-            suffix,
-            model: this._mistralProvider.model,
-            // temperature: 0,
-            // top_p: 1,
-            // max_tokens: 1024,
-            // min_tokens: 0,
-            stream: false,
-            // random_seed: 1337,
-            stop: []
-        };
+        const messages = [
+            new SystemMessage(this._prompt),
+            new HumanMessage(prompt)
+        ];
         try {
-            this._currentData = data;
-            const completionResult = await this._throttler.invoke(data);
-            if (completionResult.fetchAgain) {
-                if (this._requestCompletion) {
-                    this._requestCompletion();
-                }
-            }
-            return { items: completionResult.items };
+            return await this._throttler.invoke(messages);
         }
         catch (error) {
             console.error('Error fetching completions', error);

package/lib/llm-models/index.d.ts

@@ -1,3 +1,4 @@
+import { IAIProvider } from '../tokens';
 export * from './base-completer';
-export * from './codestral-completer';
-export * from './utils';
+declare const AIProviders: IAIProvider[];
+export { AIProviders };

package/lib/llm-models/index.js

@@ -1,3 +1,43 @@
+import { ChatAnthropic } from '@langchain/anthropic';
+import { ChromeAI } from '@langchain/community/experimental/llms/chrome_ai';
+import { ChatMistralAI } from '@langchain/mistralai';
+import { ChatOpenAI } from '@langchain/openai';
+import { AnthropicCompleter } from './anthropic-completer';
+import { CodestralCompleter } from './codestral-completer';
+import { ChromeCompleter } from './chrome-completer';
+import { OpenAICompleter } from './openai-completer';
+import { instructions } from '../settings/instructions';
+import { ProviderSettings } from '../settings/schemas';
 export * from './base-completer';
-export * from './codestral-completer';
-export * from './utils';
+const AIProviders = [
+    {
+        name: 'Anthropic',
+        chatModel: ChatAnthropic,
+        completer: AnthropicCompleter,
+        settingsSchema: ProviderSettings.Anthropic,
+        errorMessage: (error) => error.error.error.message
+    },
+    {
+        name: 'ChromeAI',
+        // TODO: fix
+        // @ts-expect-error: missing properties
+        chatModel: ChromeAI,
+        completer: ChromeCompleter,
+        instructions: instructions.ChromeAI,
+        settingsSchema: ProviderSettings.ChromeAI
+    },
+    {
+        name: 'MistralAI',
+        chatModel: ChatMistralAI,
+        completer: CodestralCompleter,
+        instructions: instructions.MistralAI,
+        settingsSchema: ProviderSettings.MistralAI
+    },
+    {
+        name: 'OpenAI',
+        chatModel: ChatOpenAI,
+        completer: OpenAICompleter,
+        settingsSchema: ProviderSettings.OpenAI
+    }
+];
+export { AIProviders };

package/lib/llm-models/openai-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 OpenAICompleter 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 _openAIProvider;
+    private _prompt;
+}

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

@@ -0,0 +1,51 @@
+import { AIMessage, SystemMessage } from '@langchain/core/messages';
+import { ChatOpenAI } from '@langchain/openai';
+import { COMPLETION_SYSTEM_PROMPT } from '../provider';
+export class OpenAICompleter {
+    constructor(options) {
+        this._prompt = COMPLETION_SYSTEM_PROMPT;
+        this._openAIProvider = new ChatOpenAI({ ...options.settings });
+    }
+    get provider() {
+        return this._openAIProvider;
+    }
+    /**
+     * 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);
+        const messages = [new SystemMessage(this._prompt), new AIMessage(prompt)];
+        try {
+            const response = await this._openAIProvider.invoke(messages);
+            const items = [];
+            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(prompt.length)
+                    });
+                });
+            }
+            return { items };
+        }
+        catch (error) {
+            console.error('Error fetching completions', error);
+            return { items: [] };
+        }
+    }
+}

package/lib/provider.d.ts

@@ -4,18 +4,43 @@ import { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import { ISignal } from '@lumino/signaling';
 import { ReadonlyPartialJSONObject } from '@lumino/coreutils';
 import { IBaseCompleter } from './llm-models';
-import { IAIProvider } from './token';
-export declare class AIProvider implements IAIProvider {
-    constructor(options: AIProvider.IOptions);
-    get name(): string;
+import { IAIProvider, IAIProviderRegistry } from './tokens';
+import { JSONSchema7 } from 'json-schema';
+export declare const chatSystemPrompt: (options: AIProviderRegistry.IPromptOptions) => string;
+export declare const COMPLETION_SYSTEM_PROMPT = "\nYou are an application built to provide helpful code completion suggestions.\nYou should only produce code. Keep comments to minimum, use the\nprogramming language comment syntax. Produce clean code.\nThe code is written in JupyterLab, a data analysis and code development\nenvironment which can execute code extended with additional syntax for\ninteractive features, such as magics.\nOnly give raw strings back, do not format the response using backticks.\nThe output should be a single string, and should correspond to what a human users\nwould write.\nDo not include the prompt in the output, only the string that should be appended to the current input.\n";
+export declare class AIProviderRegistry implements IAIProviderRegistry {
+    /**
+     * Get the list of provider names.
+     */
+    get providers(): string[];
+    /**
+     * Add a new provider.
+     */
+    add(provider: IAIProvider): void;
+    /**
+     * Get the current provider name.
+     */
+    get currentName(): string;
     /**
      * Get the current completer of the completion provider.
      */
-    get completer(): IBaseCompleter | null;
+    get currentCompleter(): IBaseCompleter | null;
     /**
      * Get the current llm chat model.
      */
-    get chatModel(): BaseChatModel | null;
+    get currentChatModel(): BaseChatModel | null;
+    /**
+     * Get the settings schema of a given provider.
+     */
+    getSettingsSchema(provider: string): JSONSchema7;
+    /**
+     * Get the instructions of a given provider.
+     */
+    getInstructions(provider: string): string | undefined;
+    /**
+     * Format an error message from the current provider.
+     */
+    formatErrorMessage(error: any): string;
     /**
      * Get the current chat error;
      */
@@ -25,22 +50,27 @@ export declare class AIProvider implements IAIProvider {
      */
     get completerError(): string;
     /**
-     * Set the models (chat model and completer).
-     * Creates the models if the name has changed, otherwise only updates their config.
+     * Set the providers (chat model and completer).
+     * Creates the providers if the name has changed, otherwise only updates their config.
      *
-     * @param name - the name of the model to use.
+     * @param name - the name of the provider to use.
      * @param settings - the settings for the models.
      */
-    setModels(name: string, settings: ReadonlyPartialJSONObject): void;
-    get modelChange(): ISignal<IAIProvider, void>;
-    private _completionProvider;
-    private _llmChatModel;
+    setProvider(name: string, settings: ReadonlyPartialJSONObject): void;
+    /**
+     * A signal emitting when the provider or its settings has changed.
+     */
+    get providerChanged(): ISignal<IAIProviderRegistry, void>;
+    private _currentProvider;
+    private _completer;
+    private _chatModel;
     private _name;
-    private _modelChange;
+    private _providerChanged;
     private _chatError;
     private _completerError;
+    private _providers;
 }
-export declare namespace AIProvider {
+export declare namespace AIProviderRegistry {
     /**
      * The options for the LLM provider.
      */
@@ -54,6 +84,15 @@ export declare namespace AIProvider {
          */
         requestCompletion: () => void;
     }
+    /**
+     * The options for the Chat system prompt.
+     */
+    interface IPromptOptions {
+        /**
+         * The provider name.
+         */
+        provider_name: string;
+    }
     /**
      * This function indicates whether a key is writable in an object.
      * https://stackoverflow.com/questions/54724875/can-we-check-whether-property-is-readonly-in-typescript