@jupyterlite/ai 0.2.0

package/lib/provider.d.ts

@@ -0,0 +1,74 @@
+import { ICompletionProviderManager } from '@jupyterlab/completer';
+import { BaseLanguageModel } from '@langchain/core/language_models/base';
+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;
+    /**
+     * Get the current completer of the completion provider.
+     */
+    get completer(): IBaseCompleter | null;
+    /**
+     * Get the current llm chat model.
+     */
+    get chatModel(): BaseChatModel | null;
+    /**
+     * Get the current chat error;
+     */
+    get chatError(): string;
+    /**
+     * get the current completer error.
+     */
+    get completerError(): string;
+    /**
+     * Set the models (chat model and completer).
+     * Creates the models if the name has changed, otherwise only updates their config.
+     *
+     * @param name - the name of the model to use.
+     * @param settings - the settings for the models.
+     */
+    setModels(name: string, settings: ReadonlyPartialJSONObject): void;
+    get modelChange(): ISignal<IAIProvider, void>;
+    private _completionProvider;
+    private _llmChatModel;
+    private _name;
+    private _modelChange;
+    private _chatError;
+    private _completerError;
+}
+export declare namespace AIProvider {
+    /**
+     * The options for the LLM provider.
+     */
+    interface IOptions {
+        /**
+         * The completion provider manager in which register the LLM completer.
+         */
+        completionProviderManager: ICompletionProviderManager;
+        /**
+         * The application commands registry.
+         */
+        requestCompletion: () => void;
+    }
+    /**
+     * 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
+     *
+     * @param obj - An object extending the BaseLanguageModel interface.
+     * @param key - A string as a key of the object.
+     * @returns a boolean whether the key is writable or not.
+     */
+    function isWritable<T extends BaseLanguageModel>(obj: T, key: keyof T): boolean;
+    /**
+     * Update the config of a language model.
+     * It only updates the writable attributes of the model.
+     *
+     * @param model - the model to update.
+     * @param settings - the configuration s a JSON object.
+     */
+    function updateConfig<T extends BaseLanguageModel>(model: T, settings: ReadonlyPartialJSONObject): void;
+}

package/lib/provider.js

@@ -0,0 +1,117 @@
+import { Signal } from '@lumino/signaling';
+import { CompletionProvider } from './completion-provider';
+import { getChatModel } from './llm-models';
+export class AIProvider {
+    constructor(options) {
+        this._llmChatModel = null;
+        this._name = 'None';
+        this._modelChange = new Signal(this);
+        this._chatError = '';
+        this._completerError = '';
+        this._completionProvider = new CompletionProvider({
+            name: 'None',
+            settings: {},
+            requestCompletion: options.requestCompletion
+        });
+        options.completionProviderManager.registerInlineProvider(this._completionProvider);
+    }
+    get name() {
+        return this._name;
+    }
+    /**
+     * Get the current completer of the completion provider.
+     */
+    get completer() {
+        if (this._name === null) {
+            return null;
+        }
+        return this._completionProvider.completer;
+    }
+    /**
+     * Get the current llm chat model.
+     */
+    get chatModel() {
+        if (this._name === null) {
+            return null;
+        }
+        return this._llmChatModel;
+    }
+    /**
+     * Get the current chat error;
+     */
+    get chatError() {
+        return this._chatError;
+    }
+    /**
+     * get the current completer error.
+     */
+    get completerError() {
+        return this._completerError;
+    }
+    /**
+     * Set the models (chat model and completer).
+     * Creates the models if the name has changed, otherwise only updates their config.
+     *
+     * @param name - the name of the model to use.
+     * @param settings - the settings for the models.
+     */
+    setModels(name, settings) {
+        try {
+            this._completionProvider.setCompleter(name, settings);
+            this._completerError = '';
+        }
+        catch (e) {
+            this._completerError = e.message;
+        }
+        try {
+            this._llmChatModel = getChatModel(name, settings);
+            this._chatError = '';
+        }
+        catch (e) {
+            this._chatError = e.message;
+            this._llmChatModel = null;
+        }
+        this._name = name;
+        this._modelChange.emit();
+    }
+    get modelChange() {
+        return this._modelChange;
+    }
+}
+(function (AIProvider) {
+    /**
+     * 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
+     *
+     * @param obj - An object extending the BaseLanguageModel interface.
+     * @param key - A string as a key of the object.
+     * @returns a boolean whether the key is writable or not.
+     */
+    function isWritable(obj, key) {
+        const desc = Object.getOwnPropertyDescriptor(obj, key) ||
+            Object.getOwnPropertyDescriptor(Object.getPrototypeOf(obj), key) ||
+            {};
+        return Boolean(desc.writable);
+    }
+    AIProvider.isWritable = isWritable;
+    /**
+     * Update the config of a language model.
+     * It only updates the writable attributes of the model.
+     *
+     * @param model - the model to update.
+     * @param settings - the configuration s a JSON object.
+     */
+    function updateConfig(model, settings) {
+        Object.entries(settings).forEach(([key, value], index) => {
+            if (key in model) {
+                const modelKey = key;
+                if (isWritable(model, modelKey)) {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore
+                    model[modelKey] = value;
+                }
+            }
+        });
+    }
+    AIProvider.updateConfig = updateConfig;
+})(AIProvider || (AIProvider = {}));

package/lib/token.d.ts

@@ -0,0 +1,13 @@
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { Token } from '@lumino/coreutils';
+import { ISignal } from '@lumino/signaling';
+import { IBaseCompleter } from './llm-models';
+export interface IAIProvider {
+    name: string;
+    completer: IBaseCompleter | null;
+    chatModel: BaseChatModel | null;
+    modelChange: ISignal<IAIProvider, void>;
+    chatError: string;
+    completerError: string;
+}
+export declare const IAIProvider: Token<IAIProvider>;

package/lib/token.js

@@ -0,0 +1,2 @@
+import { Token } from '@lumino/coreutils';
+export const IAIProvider = new Token('@jupyterlite/ai:AIProvider', 'Provider for chat and completion LLM provider');

package/package.json

@@ -0,0 +1,197 @@
+{
+    "name": "@jupyterlite/ai",
+    "version": "0.2.0",
+    "description": "AI code completions and chat for JupyterLite",
+    "keywords": [
+        "jupyter",
+        "jupyterlab",
+        "jupyterlab-extension"
+    ],
+    "homepage": "https://github.com/jupyterlite/ai",
+    "bugs": {
+        "url": "https://github.com/jupyterlite/ai/issues"
+    },
+    "license": "BSD-3-Clause",
+    "author": "JupyterLite Contributors",
+    "files": [
+        "lib/**/*.{d.ts,eot,gif,html,jpg,js,js.map,json,png,svg,woff2,ttf}",
+        "style/**/*.{css,js,eot,gif,html,jpg,json,png,svg,woff2,ttf}",
+        "src/**/*.{ts,tsx}",
+        "schema/*.json"
+    ],
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "style": "style/index.css",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/jupyterlite/ai.git"
+    },
+    "scripts": {
+        "build": "jlpm build:lib && jlpm build:labextension:dev",
+        "build:prod": "jlpm clean && jlpm build:lib:prod && jlpm build:labextension",
+        "build:labextension": "jupyter labextension build .",
+        "build:labextension:dev": "jupyter labextension build --development True .",
+        "build:lib": "tsc --sourceMap",
+        "build:lib:prod": "tsc",
+        "clean": "jlpm clean:lib",
+        "clean:lib": "rimraf lib tsconfig.tsbuildinfo",
+        "clean:lintcache": "rimraf .eslintcache .stylelintcache",
+        "clean:labextension": "rimraf jupyterlite_ai/labextension jupyterlite_ai/_version.py",
+        "clean:all": "jlpm clean:lib && jlpm clean:labextension && jlpm clean:lintcache",
+        "eslint": "jlpm eslint:check --fix",
+        "eslint:check": "eslint . --cache --ext .ts,.tsx",
+        "install:extension": "jlpm build",
+        "lint": "jlpm stylelint && jlpm prettier && jlpm eslint",
+        "lint:check": "jlpm stylelint:check && jlpm prettier:check && jlpm eslint:check",
+        "prettier": "jlpm prettier:base --write --list-different",
+        "prettier:base": "prettier \"**/*{.ts,.tsx,.js,.jsx,.css,.json,.md}\"",
+        "prettier:check": "jlpm prettier:base --check",
+        "stylelint": "jlpm stylelint:check --fix",
+        "stylelint:check": "stylelint --cache \"style/**/*.css\"",
+        "watch": "run-p watch:src watch:labextension",
+        "watch:src": "tsc -w --sourceMap",
+        "watch:labextension": "jupyter labextension watch ."
+    },
+    "dependencies": {
+        "@jupyter/chat": "^0.5.0",
+        "@jupyterlab/application": "^4.2.0",
+        "@jupyterlab/apputils": "^4.3.0",
+        "@jupyterlab/completer": "^4.2.0",
+        "@jupyterlab/notebook": "^4.2.0",
+        "@jupyterlab/rendermime": "^4.2.0",
+        "@jupyterlab/settingregistry": "^4.2.0",
+        "@langchain/core": "^0.3.13",
+        "@langchain/mistralai": "^0.1.1",
+        "@lumino/coreutils": "^2.1.2",
+        "@lumino/polling": "^2.1.2",
+        "@lumino/signaling": "^2.1.2"
+    },
+    "devDependencies": {
+        "@jupyterlab/builder": "^4.0.0",
+        "@types/json-schema": "^7.0.11",
+        "@types/react": "^18.0.26",
+        "@types/react-addons-linked-state-mixin": "^0.14.22",
+        "@typescript-eslint/eslint-plugin": "^6.1.0",
+        "@typescript-eslint/parser": "^6.1.0",
+        "css-loader": "^6.7.1",
+        "eslint": "^8.36.0",
+        "eslint-config-prettier": "^8.8.0",
+        "eslint-plugin-prettier": "^5.0.0",
+        "npm-run-all": "^4.1.5",
+        "prettier": "^3.0.0",
+        "rimraf": "^5.0.1",
+        "source-map-loader": "^1.0.2",
+        "style-loader": "^3.3.1",
+        "stylelint": "^15.10.1",
+        "stylelint-config-recommended": "^13.0.0",
+        "stylelint-config-standard": "^34.0.0",
+        "stylelint-csstree-validator": "^3.0.0",
+        "stylelint-prettier": "^4.0.0",
+        "typescript": "~5.0.2",
+        "yjs": "^13.5.0"
+    },
+    "sideEffects": [
+        "style/*.css",
+        "style/index.js"
+    ],
+    "styleModule": "style/index.js",
+    "publishConfig": {
+        "access": "public"
+    },
+    "jupyterlab": {
+        "extension": true,
+        "outputDir": "jupyterlite_ai/labextension",
+        "schemaDir": "schema"
+    },
+    "eslintIgnore": [
+        "node_modules",
+        "dist",
+        "coverage",
+        "**/*.d.ts"
+    ],
+    "eslintConfig": {
+        "extends": [
+            "eslint:recommended",
+            "plugin:@typescript-eslint/eslint-recommended",
+            "plugin:@typescript-eslint/recommended",
+            "plugin:prettier/recommended"
+        ],
+        "parser": "@typescript-eslint/parser",
+        "parserOptions": {
+            "project": "tsconfig.json",
+            "sourceType": "module"
+        },
+        "plugins": [
+            "@typescript-eslint"
+        ],
+        "rules": {
+            "@typescript-eslint/naming-convention": [
+                "error",
+                {
+                    "selector": "interface",
+                    "format": [
+                        "PascalCase"
+                    ],
+                    "custom": {
+                        "regex": "^I[A-Z]",
+                        "match": true
+                    }
+                }
+            ],
+            "@typescript-eslint/no-unused-vars": [
+                "warn",
+                {
+                    "args": "none"
+                }
+            ],
+            "@typescript-eslint/no-explicit-any": "off",
+            "@typescript-eslint/no-namespace": "off",
+            "@typescript-eslint/no-use-before-define": "off",
+            "@typescript-eslint/quotes": [
+                "error",
+                "single",
+                {
+                    "avoidEscape": true,
+                    "allowTemplateLiterals": false
+                }
+            ],
+            "curly": [
+                "error",
+                "all"
+            ],
+            "eqeqeq": "error",
+            "prefer-arrow-callback": "error"
+        }
+    },
+    "prettier": {
+        "singleQuote": true,
+        "trailingComma": "none",
+        "arrowParens": "avoid",
+        "endOfLine": "auto",
+        "overrides": [
+            {
+                "files": "package.json",
+                "options": {
+                    "tabWidth": 4
+                }
+            }
+        ]
+    },
+    "stylelint": {
+        "extends": [
+            "stylelint-config-recommended",
+            "stylelint-config-standard",
+            "stylelint-prettier/recommended"
+        ],
+        "plugins": [
+            "stylelint-csstree-validator"
+        ],
+        "rules": {
+            "csstree/validator": true,
+            "property-no-vendor-prefix": null,
+            "selector-class-pattern": "^([a-z][A-z\\d]*)(-[A-z\\d]+)*$",
+            "selector-no-vendor-prefix": null,
+            "value-no-vendor-prefix": null
+        }
+    }
+}

package/schema/ai-provider.json

@@ -0,0 +1,21 @@
+{
+  "title": "AI provider",
+  "description": "Provider settings",
+  "type": "object",
+  "properties": {
+    "provider": {
+      "type": "string",
+      "title": "The AI provider",
+      "description": "The AI provider to use for chat and completion",
+      "default": "None",
+      "enum": ["None", "MistralAI"]
+    },
+    "apiKey": {
+      "type": "string",
+      "title": "The Codestral API key",
+      "description": "The API key to use for Codestral",
+      "default": ""
+    }
+  },
+  "additionalProperties": false
+}

package/schema/chat.json

@@ -0,0 +1,20 @@
+{
+  "title": "Chat configuration",
+  "description": "Configuration for the chat panel",
+  "type": "object",
+  "properties": {
+    "sendWithShiftEnter": {
+      "description": "Whether to send a message via Shift-Enter instead of Enter.",
+      "type": "boolean",
+      "default": false,
+      "readOnly": false
+    },
+    "enableCodeToolbar": {
+      "description": "Whether to enable or not the code toolbar.",
+      "type": "boolean",
+      "default": true,
+      "readOnly": false
+    }
+  },
+  "additionalProperties": false
+}

package/src/chat-handler.ts

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+
+import {
+  ChatModel,
+  IChatHistory,
+  IChatMessage,
+  INewMessage
+} from '@jupyter/chat';
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import {
+  AIMessage,
+  HumanMessage,
+  mergeMessageRuns
+} from '@langchain/core/messages';
+import { UUID } from '@lumino/coreutils';
+import { getErrorMessage } from './llm-models';
+import { IAIProvider } from './token';
+
+export type ConnectionMessage = {
+  type: 'connection';
+  client_id: string;
+};
+
+export class ChatHandler extends ChatModel {
+  constructor(options: ChatHandler.IOptions) {
+    super(options);
+    this._aiProvider = options.aiProvider;
+    this._aiProvider.modelChange.connect(() => {
+      this._errorMessage = this._aiProvider.chatError;
+    });
+  }
+
+  get provider(): BaseChatModel | null {
+    return this._aiProvider.chatModel;
+  }
+
+  async sendMessage(message: INewMessage): Promise<boolean> {
+    message.id = UUID.uuid4();
+    const msg: IChatMessage = {
+      id: message.id,
+      body: message.body,
+      sender: { username: 'User' },
+      time: Date.now(),
+      type: 'msg'
+    };
+    this.messageAdded(msg);
+
+    if (this._aiProvider.chatModel === null) {
+      const errorMsg: IChatMessage = {
+        id: UUID.uuid4(),
+        body: `**${this._errorMessage ? this._errorMessage : this._defaultErrorMessage}**`,
+        sender: { username: 'ERROR' },
+        time: Date.now(),
+        type: 'msg'
+      };
+      this.messageAdded(errorMsg);
+      return false;
+    }
+
+    this._history.messages.push(msg);
+
+    const messages = mergeMessageRuns(
+      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: IChatMessage = {
+          id: UUID.uuid4(),
+          body: content.toString(),
+          sender: { username: 'AI' },
+          time: Date.now(),
+          type: 'msg'
+        };
+        this.messageAdded(botMsg);
+        this._history.messages.push(botMsg);
+        return true;
+      })
+      .catch(reason => {
+        const error = getErrorMessage(this._aiProvider.name, reason);
+        const errorMsg: IChatMessage = {
+          id: UUID.uuid4(),
+          body: `**${error}**`,
+          sender: { username: 'ERROR' },
+          time: Date.now(),
+          type: 'msg'
+        };
+        this.messageAdded(errorMsg);
+        return false;
+      })
+      .finally(() => {
+        this.updateWriters([]);
+      });
+  }
+
+  async getHistory(): Promise<IChatHistory> {
+    return this._history;
+  }
+
+  dispose(): void {
+    super.dispose();
+  }
+
+  messageAdded(message: IChatMessage): void {
+    super.messageAdded(message);
+  }
+
+  private _aiProvider: IAIProvider;
+  private _errorMessage: string = '';
+  private _history: IChatHistory = { messages: [] };
+  private _defaultErrorMessage = 'AI provider not configured';
+}
+
+export namespace ChatHandler {
+  export interface IOptions extends ChatModel.IOptions {
+    aiProvider: IAIProvider;
+  }
+}

package/src/completion-provider.ts

@@ -0,0 +1,81 @@
+import {
+  CompletionHandler,
+  IInlineCompletionContext,
+  IInlineCompletionProvider
+} from '@jupyterlab/completer';
+import { LLM } from '@langchain/core/language_models/llms';
+
+import { getCompleter, IBaseCompleter, BaseCompleter } from './llm-models';
+import { ReadonlyPartialJSONObject } from '@lumino/coreutils';
+
+/**
+ * The generic completion provider to register to the completion provider manager.
+ */
+export class CompletionProvider implements IInlineCompletionProvider {
+  readonly identifier = '@jupyterlite/ai';
+
+  constructor(options: CompletionProvider.IOptions) {
+    const { name, settings } = options;
+    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: string, settings: ReadonlyPartialJSONObject) {
+    try {
+      this._completer = getCompleter(name, settings);
+      if (this._completer) {
+        this._completer.requestCompletion = this._requestCompletion;
+      }
+      this._name = this._completer === null ? 'None' : name;
+    } catch (e: any) {
+      this._completer = null;
+      this._name = 'None';
+      throw e;
+    }
+  }
+
+  /**
+   * Get the current completer name.
+   */
+  get name(): string {
+    return this._name;
+  }
+
+  /**
+   * Get the current completer.
+   */
+  get completer(): IBaseCompleter | null {
+    return this._completer;
+  }
+
+  /**
+   * Get the LLM completer.
+   */
+  get llmCompleter(): LLM | null {
+    return this._completer?.provider || null;
+  }
+
+  async fetch(
+    request: CompletionHandler.IRequest,
+    context: IInlineCompletionContext
+  ) {
+    return this._completer?.fetch(request, context);
+  }
+
+  private _name: string = 'None';
+  private _requestCompletion: () => void;
+  private _completer: IBaseCompleter | null = null;
+}
+
+export namespace CompletionProvider {
+  export interface IOptions extends BaseCompleter.IOptions {
+    name: string;
+    requestCompletion: () => void;
+  }
+}