@mistralai/mistralai 0.0.8 → 0.1.3

package/.eslintrc.yml

@@ -2,11 +2,12 @@ env:
   browser: true
   es2021: true
 extends: google
-ignorePatterns: 
+ignorePatterns:
   - examples/chat-react/
 parserOptions:
   ecmaVersion: latest
   sourceType: module
-rules: 
+rules:
   indent: ["error", 2]
   space-before-function-paren: ["error", "never"]
+  quotes: ["error", "single"]

package/.github/workflows/build_publish.yaml

@@ -3,7 +3,7 @@ name: Build and Publish
 on:
   push:
     branches: ["main"]
-    
+
     # We only deploy on tags and main branch
     tags:
       # Only run on tags that match the following regex
@@ -14,10 +14,13 @@ on:
   pull_request:
 
 jobs:
-  
-  lint:
+  lint_and_test:
     runs-on: ubuntu-latest
 
+    strategy:
+      matrix:
+        node-version: [18, 20]
+
     steps:
       # Checkout the repository
       - name: Checkout
@@ -27,20 +30,25 @@ jobs:
       - name: set node version
         uses: actions/setup-node@v4
         with:
-          node-version: 18
+          node-version: ${{ matrix.node-version }}
 
       # Install Build stuff
       - name: Install Dependencies
         run: |
           npm install
 
-        # Ruff
+        # Eslint
       - name: ESlint check
         run: |
-          ./node_modules/.bin/eslint .
+          npm run lint
+
+        # Run tests
+      - name: Run tests
+        run: |
+          npm run test
 
   publish:
-    needs: lint
+    needs: lint_and_test
     runs-on: ubuntu-latest
     if: startsWith(github.ref, 'refs/tags')
 
@@ -60,6 +68,67 @@ jobs:
         run: |
           echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" >> .npmrc
           npm version ${{ github.ref_name }}
-          npm publish 
+          sed -i 's/VERSION = '\''0.0.1'\''/VERSION = '\''${{ github.ref_name }}'\''/g' src/client.js
+          npm publish
+
+  create_pr_on_public:
+    if: startsWith(github.ref, 'refs/tags')
+    runs-on: ubuntu-latest
+    needs: lint_and_test
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          token: ${{ secrets.PUBLIC_CLIENT_WRITE_TOKEN }}
+
+      - name: Pull public updates
+        env: # We cannot use the github bot token to push to the public repo, we have to use one with more permissions
+          GITHUB_TOKEN: ${{ secrets.PUBLIC_CLIENT_WRITE_TOKEN }}
+        run: |
+
+          set -x
+          git config --global user.name "GitHub Actions"
+          git config --global user.email "mayo@mistral.ai"
+
+          git remote add public https://github.com/mistralai/client-js.git
+          git remote update
+
+          # Create a diff of the changes, ignoring the ci workflow
+          git merge public/main --no-commit --no-ff --no-edit --allow-unrelated-histories --strategy-option ours
+
+          # If there are changes, commit them
+          if ! git diff --quiet; then
+            git commit -m "Update from public repo"
+            git push origin ${{github.ref}}
+          else
+            echo "No changes to apply"
+          fi
+
+      - name: Push to public repo
+        env:
+          GITHUB_TOKEN: ${{ secrets.PUBLIC_CLIENT_WRITE_TOKEN }}
+        run: |
+          git checkout public/main
+          git checkout -b update/${{github.ref_name}}
+
+          # write version number to version file
+          echo ${{github.ref_name}} > version.txt
+
+          git add .
+          git commit -m "Bump version file"
+
+          # create a diff of this ref and the public repo
+          git diff update/${{github.ref_name}} ${{github.ref_name}} --binary -- . ':!.github' > changes.diff
+
+          # apply the diff to the current branch
+          git apply changes.diff
+
+          # commit the changes
+          git add .
+          git commit -m "Update version to ${{github.ref_name}}"
+
+          # push the changes
+          git push public update/${{github.ref_name}}
 
-      
+          # Create a PR from this branch to the public repo
+          gh pr create --title "Update client to ${{github.ref_name}}" --body "This PR was automatically created by a GitHub Action" --base main --head update/${{github.ref_name}} --repo mistralai/client-js

package/README.md

@@ -11,16 +11,19 @@ You can install the library in your project using:
 `npm install @mistralai/mistralai`
 
 ## Usage
+
 ### Set up
+
 ```typescript
 import MistralClient from '@mistralai/mistralai';
 
-const apiKey = "Your API key";
+const apiKey = process.env.MISTRAL_API_KEY || 'your_api_key';
 
 const client = new MistralClient(apiKey);
 ```
 
 ### List models
+
 ```typescript
 const listModelsResponse = await client.listModels();
 const listModels = listModelsResponse.data;
@@ -30,6 +33,7 @@ listModels.forEach((model) => {
 ```
 
 ### Chat with streaming
+
 ```typescript
 const chatStreamResponse = await client.chatStream({
   model: 'mistral-tiny',
@@ -44,7 +48,9 @@ for await (const chunk of chatStreamResponse) {
   }
 }
 ```
+
 ### Chat without streaming
+
 ```typescript
 const chatResponse = await client.chat({
   model: 'mistral-tiny',
@@ -53,7 +59,9 @@ const chatResponse = await client.chat({
 
 console.log('Chat:', chatResponse.choices[0].message.content);
 ```
-###Embeddings
+
+### Embeddings
+
 ```typescript
 const input = [];
 for (let i = 0; i < 1; i++) {
@@ -67,6 +75,7 @@ const embeddingsBatchResponse = await client.embeddings({
 
 console.log('Embeddings Batch:', embeddingsBatchResponse.data);
 ```
+
 ## Run examples
 
 You can run the examples in the examples directory by installing them locally:
@@ -76,23 +85,39 @@ cd examples
 npm install .
 ```
 
-### API Key Setup
+### API key setup
 
 Running the examples requires a Mistral AI API key.
 
-1. Get your own Mistral API Key: <https://docs.mistral.ai/#api-access>
-2. Set your Mistral API Key as an environment variable. You only need to do this once.
+Get your own Mistral API Key: <https://docs.mistral.ai/#api-access>
+
+### Run the examples
+
+```bash
+MISTRAL_API_KEY='your_api_key' node chat_with_streaming.js
+```
+
+### Persisting the API key in environment
+
+Set your Mistral API Key as an environment variable. You only need to do this once.
 
 ```bash
 # set Mistral API Key (using zsh for example)
-$ echo 'export MISTRAL_API_KEY=[your_key_here]' >> ~/.zshenv
+$ echo 'export MISTRAL_API_KEY=[your_api_key]' >> ~/.zshenv
 
 # reload the environment (or just quit and open a new terminal)
 $ source ~/.zshenv
 ```
 
-You can then run the examples using node:
+You can then run the examples without appending the API key:
 
 ```bash
-MISTRAL_API_KEY=XXXX node chat_with_streaming.js
+node chat_with_streaming.js
+```
+After the env variable setup the client will find the `MISTRAL_API_KEY` by itself
+
+```typescript
+import MistralClient from '@mistralai/mistralai';
+
+const client = new MistralClient();
 ```

package/examples/chat-react/package-lock.json

@@ -26,6 +26,7 @@
       "devDependencies": {
         "eslint": "^8.55.0",
         "eslint-config-google": "^0.14.0",
+        "jest": "^29.7.0",
         "prettier": "2.8.8"
       }
     },
@@ -16023,16 +16024,16 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.3.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.3.tgz",
-      "integrity": "sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==",
+      "version": "4.9.5",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz",
+      "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==",
       "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
       },
       "engines": {
-        "node": ">=14.17"
+        "node": ">=4.2.0"
       }
     },
     "node_modules/unbox-primitive": {
@@ -19300,6 +19301,7 @@
       "requires": {
         "eslint": "^8.55.0",
         "eslint-config-google": "^0.14.0",
+        "jest": "^29.7.0",
         "node-fetch": "^2.6.7",
         "prettier": "2.8.8"
       }
@@ -28464,9 +28466,9 @@
       }
     },
     "typescript": {
-      "version": "5.3.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.3.tgz",
-      "integrity": "sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==",
+      "version": "4.9.5",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz",
+      "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==",
       "peer": true
     },
     "unbox-primitive": {

package/examples/chat-react/package.json

@@ -13,11 +13,6 @@
   "scripts": {
     "start": "react-scripts start"
   },
-  // "eslintConfig": {
-  //   "extends": [
-  //     "react-app"
-  //   ]
-  // },
   "browserslist": {
     "production": [
       ">0.2%",

package/examples/function_calling.js

@@ -0,0 +1,122 @@
+import MistralClient from '@mistralai/mistralai';
+
+const apiKey = process.env.MISTRAL_API_KEY;
+
+// Assuming we have the following data
+const data = {
+  transactionId: ['T1001', 'T1002', 'T1003', 'T1004', 'T1005'],
+  customerId: ['C001', 'C002', 'C003', 'C002', 'C001'],
+  paymentAmount: [125.50, 89.99, 120.00, 54.30, 210.20],
+  paymentDate: [
+    '2021-10-05', '2021-10-06', '2021-10-07', '2021-10-05', '2021-10-08',
+  ],
+  paymentStatus: ['Paid', 'Unpaid', 'Paid', 'Paid', 'Pending'],
+};
+
+/**
+ * This function retrieves the payment status of a transaction id.
+ * @param {object} data - The data object.
+ * @param {string} transactionId - The transaction id.
+ * @return {string} - The payment status.
+ */
+function retrievePaymentStatus({data, transactionId}) {
+  const transactionIndex = data.transactionId.indexOf(transactionId);
+  if (transactionIndex != -1) {
+    return JSON.stringify({status: data.payment_status[transactionIndex]});
+  } else {
+    return JSON.stringify({status: 'error - transaction id not found.'});
+  }
+}
+
+/**
+ * This function retrieves the payment date of a transaction id.
+ * @param {object} data - The data object.
+ * @param {string} transactionId - The transaction id.
+ * @return {string} - The payment date.
+ *
+ */
+function retrievePaymentDate({data, transactionId}) {
+  const transactionIndex = data.transactionId.indexOf(transactionId);
+  if (transactionIndex != -1) {
+    return JSON.stringify({status: data.payment_date[transactionIndex]});
+  } else {
+    return JSON.stringify({status: 'error - transaction id not found.'});
+  }
+}
+
+const namesToFunctions = {
+  retrievePaymentStatus: (transactionId) =>
+    retrievePaymentStatus({data, ...transactionId}),
+  retrievePaymentDate: (transactionId) =>
+    retrievePaymentDate({data, ...transactionId}),
+};
+
+const tools = [
+  {
+    type: 'function',
+    function: {
+      name: 'retrievePaymentStatus',
+      description: 'Get payment status of a transaction id',
+      parameters: {
+        type: 'object',
+        required: ['transactionId'],
+        properties: {transactionId:
+          {type: 'string', description: 'The transaction id.'},
+        },
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'retrievePaymentDate',
+      description: 'Get payment date of a transaction id',
+      parameters: {
+        type: 'object',
+        required: ['transactionId'],
+        properties: {transactionId:
+          {type: 'string', description: 'The transaction id.'},
+        },
+      },
+    },
+  },
+];
+
+
+const model = 'mistral-large';
+
+const client = new MistralClient(apiKey, 'https://api-2.aurocloud.net');
+
+const messages = [
+  {role: 'user', content: 'What\'s the status of my transaction?'},
+];
+
+let response = await client.chat({
+  model: model, messages: messages, tools: tools,
+});
+
+
+console.log(response.choices[0].message.content);
+
+messages.push(
+  {role: 'assistant', content: response.choices[0].message.content},
+);
+messages.push({role: 'user', content: 'My transaction ID is T1001.'});
+
+response = await client.chat({model: model, messages: messages, tools: tools});
+
+const toolCall = response.choices[0].message.toolCalls[0];
+const functionName = toolCall.function.name;
+const functionParams = JSON.parse(toolCall.function.arguments);
+
+console.log(`calling functionName: ${functionName}`);
+console.log(`functionParams: ${toolCall.function.arguments}`);
+
+const functionResult = namesToFunctions[functionName](functionParams);
+
+messages.push(response.choices[0].message);
+messages.push({role: 'tool', name: functionName, content: functionResult});
+
+response = await client.chat({model: model, messages: messages, tools: tools});
+
+console.log(response.choices[0].message.content);

package/examples/json_format.js

@@ -0,0 +1,13 @@
+import MistralClient from '@mistralai/mistralai';
+
+const apiKey = process.env.MISTRAL_API_KEY;
+
+const client = new MistralClient(apiKey);
+
+const chatResponse = await client.chat({
+  model: 'mistral-large',
+  messages: [{role: 'user', content: 'What is the best French cheese?'}],
+  responseFormat: {type: 'json_object'},
+});
+
+console.log('Chat:', chatResponse.choices[0].message.content);

package/examples/package-lock.json

@@ -21,6 +21,7 @@
             "devDependencies": {
                 "eslint": "^8.55.0",
                 "eslint-config-google": "^0.14.0",
+                "jest": "^29.7.0",
                 "prettier": "2.8.8"
             }
         },

package/package.json

@@ -1,22 +1,32 @@
 {
   "name": "@mistralai/mistralai",
-  "version": "0.0.8",
+  "version": "0.1.3",
   "description": "",
   "author": "bam4d@mistral.ai",
   "license": "ISC",
   "type": "module",
   "main": "src/client.js",
+  "scripts": {
+    "lint": "./node_modules/.bin/eslint .",
+    "test": "node --experimental-vm-modules node_modules/.bin/jest"
+  },
+  "jest": {
+    "testPathIgnorePatterns": [
+      "examples"
+    ]
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/mistralai/client-js"
   },
-  "types": "src/mistralai.d.ts",
+  "types": "src/client.d.ts",
   "dependencies": {
     "node-fetch": "^2.6.7"
   },
   "devDependencies": {
     "eslint": "^8.55.0",
     "eslint-config-google": "^0.14.0",
-    "prettier": "2.8.8"
+    "prettier": "2.8.8",
+    "jest": "^29.7.0"
   }
 }

package/src/client.d.ts

@@ -29,6 +29,42 @@ declare module '@mistralai/mistralai' {
         data: Model[];
     }
 
+    export interface Function {
+        name: string;
+        description: string;
+        parameters: object;
+    }
+
+    export enum ToolType {
+        function = 'function',
+    }
+
+    export interface FunctionCall {
+        name: string;
+        arguments: string;
+    }
+
+    export interface ToolCalls {
+        id: 'null';
+        type: ToolType = ToolType.function;
+        function: FunctionCall;
+    }
+
+    export enum ResponseFormats {
+        text = 'text',
+        json_object = 'json_object',
+    }
+
+    export enum ToolChoice {
+        auto = 'auto',
+        any = 'any',
+        none = 'none',
+    }
+
+    export interface ResponseFormat {
+        type: ResponseFormats = ResponseFormats.text;
+    }
+
     export interface TokenUsage {
         prompt_tokens: number;
         completion_tokens: number;
@@ -49,6 +85,7 @@ declare module '@mistralai/mistralai' {
         delta: {
             role?: string;
             content?: string;
+            tool_calls?: ToolCalls[];
         };
         finish_reason: string;
     }
@@ -95,35 +132,56 @@ declare module '@mistralai/mistralai' {
 
         private _makeChatCompletionRequest(
             model: string,
-            messages: Array<{ role: string; content: string }>,
+            messages: Array<{ role: string; name?: string, content: string | string[], tool_calls?: ToolCalls[]; }>,
+            tools?: Array<{ type: string; function:Function; }>, 
             temperature?: number,
             maxTokens?: number,
             topP?: number,
             randomSeed?: number,
             stream?: boolean,
-            safeMode?: boolean
+            /**
+             * @deprecated use safePrompt instead
+             */
+            safeMode?: boolean,
+            safePrompt?: boolean,
+            toolChoice?: ToolChoice,
+            responseFormat?: ResponseFormat
         ): object;
 
         listModels(): Promise<ListModelsResponse>;
 
         chat(options: {
             model: string;
-            messages: Array<{ role: string; content: string }>;
+            messages: Array<{ role: string; name?: string, content: string | string[], tool_calls?: ToolCalls[]; }>;
+            tools?: Array<{ type: string; function:Function; }>; 
             temperature?: number;
             maxTokens?: number;
             topP?: number;
             randomSeed?: number;
+            /**
+             * @deprecated use safePrompt instead
+             */
             safeMode?: boolean;
+            safePrompt?: boolean;
+            toolChoice?: ToolChoice;
+            responseFormat?: ResponseFormat; 
         }): Promise<ChatCompletionResponse>;
 
         chatStream(options: {
             model: string;
-            messages: Array<{ role: string; content: string }>;
+            messages: Array<{ role: string; name?: string, content: string | string[], tool_calls?: ToolCalls[]; }>;
+            tools?: Array<{ type: string; function:Function; }>;
             temperature?: number;
             maxTokens?: number;
             topP?: number;
             randomSeed?: number;
+            /**
+             * @deprecated use safePrompt instead
+             */
             safeMode?: boolean;
+            safePrompt?: boolean;
+            toolChoice?: ToolChoice;
+            responseFormat?: ResponseFormat;
         }): AsyncGenerator<ChatCompletionResponseChunk, void, unknown>;
 
         embeddings(options: {

package/src/client.js

@@ -1,16 +1,26 @@
-let fetch;
 let isNode = false;
-if (typeof globalThis.fetch === 'undefined') {
-  fetch = (await import('node-fetch')).default;
-  isNode = true;
-} else {
-  fetch = globalThis.fetch;
-}
-
 
+const VERSION = '0.0.3';
 const RETRY_STATUS_CODES = [429, 500, 502, 503, 504];
 const ENDPOINT = 'https://api.mistral.ai';
 
+/**
+ * Initialize fetch
+ * @return {Promise<void>}
+ */
+async function initializeFetch() {
+  if (typeof window === 'undefined' ||
+    typeof globalThis.fetch === 'undefined') {
+    const nodeFetch = await import('node-fetch');
+    fetch = nodeFetch.default;
+    isNode = true;
+  } else {
+    fetch = globalThis.fetch;
+  }
+}
+
+initializeFetch();
+
 /**
  * MistralAPIError
  * @return {MistralAPIError}
@@ -51,6 +61,10 @@ class MistralClient {
 
     this.maxRetries = maxRetries;
     this.timeout = timeout;
+
+    if (this.endpoint.indexOf('inference.azure.com')) {
+      this.modelDefault = 'mistral';
+    }
   }
 
   /**
@@ -65,6 +79,8 @@ class MistralClient {
     const options = {
       method: method,
       headers: {
+        'User-Agent': `mistral-client-js/${VERSION}`,
+        'Accept': request?.stream ? 'text/event-stream' : 'application/json',
         'Content-Type': 'application/json',
         'Authorization': `Bearer ${this.apiKey}`,
       },
@@ -85,14 +101,13 @@ class MistralClient {
               // Chrome does not support async iterators yet, so polyfill it
               const asyncIterator = async function* () {
                 try {
-                  const decoder = new TextDecoder();
                   while (true) {
                     // Read from the stream
                     const {done, value} = await reader.read();
                     // Exit if we're done
                     if (done) return;
                     // Else yield the chunk
-                    yield decoder.decode(value, {stream: true});
+                    yield value;
                   }
                 } finally {
                   reader.releaseLock();
@@ -104,14 +119,19 @@ class MistralClient {
           }
           return await response.json();
         } else if (RETRY_STATUS_CODES.includes(response.status)) {
-          console.debug(`Retrying request, attempt: ${attempts + 1}`);
+          console.debug(
+            `Retrying request on response status: ${response.status}`,
+            `Response: ${await response.text()}`,
+            `Attempt: ${attempts + 1}`,
+          );
           // eslint-disable-next-line max-len
           await new Promise((resolve) =>
             setTimeout(resolve, Math.pow(2, (attempts + 1)) * 500),
           );
         } else {
           throw new MistralAPIError(
-            `HTTP error! status: ${response.status}`,
+            `HTTP error! status: ${response.status} ` +
+            `Response: \n${await response.text()}`,
           );
         }
       } catch (error) {
@@ -133,33 +153,50 @@ class MistralClient {
    * Creates a chat completion request
    * @param {*} model
    * @param {*} messages
+   * @param {*} tools
    * @param {*} temperature
    * @param {*} maxTokens
    * @param {*} topP
    * @param {*} randomSeed
    * @param {*} stream
-   * @param {*} safeMode
+   * @param {*} safeMode deprecated use safePrompt instead
+   * @param {*} safePrompt
+   * @param {*} toolChoice
+   * @param {*} responseFormat
    * @return {Promise<Object>}
    */
   _makeChatCompletionRequest = function(
     model,
     messages,
+    tools,
     temperature,
     maxTokens,
     topP,
     randomSeed,
     stream,
     safeMode,
+    safePrompt,
+    toolChoice,
+    responseFormat,
   ) {
+    // if modelDefault and model are undefined, throw an error
+    if (!model && !this.modelDefault) {
+      throw new MistralAPIError(
+        'You must provide a model name',
+      );
+    }
     return {
-      model: model,
+      model: model ?? this.modelDefault,
       messages: messages,
+      tools: tools ?? undefined,
       temperature: temperature ?? undefined,
       max_tokens: maxTokens ?? undefined,
       top_p: topP ?? undefined,
       random_seed: randomSeed ?? undefined,
       stream: stream ?? undefined,
-      safe_prompt: safeMode ?? undefined,
+      safe_prompt: (safeMode || safePrompt) ?? undefined,
+      tool_choice: toolChoice ?? undefined,
+      response_format: responseFormat ?? undefined,
     };
   };
 
@@ -177,31 +214,43 @@ class MistralClient {
    * @param {*} model the name of the model to chat with, e.g. mistral-tiny
    * @param {*} messages an array of messages to chat with, e.g.
    * [{role: 'user', content: 'What is the best French cheese?'}]
+   * @param {*} tools  a list of tools to use.
    * @param {*} temperature the temperature to use for sampling, e.g. 0.5
    * @param {*} maxTokens the maximum number of tokens to generate, e.g. 100
    * @param {*} topP the cumulative probability of tokens to generate, e.g. 0.9
    * @param {*} randomSeed the random seed to use for sampling, e.g. 42
-   * @param {*} safeMode whether to use safe mode, e.g. true
+   * @param {*} safeMode deprecated use safePrompt instead
+   * @param {*} safePrompt whether to use safe mode, e.g. true
+   * @param {*} toolChoice the tool to use, e.g. 'auto'
+   * @param {*} responseFormat the format of the response, e.g. 'json_format'
    * @return {Promise<Object>}
    */
   chat = async function({
     model,
     messages,
+    tools,
     temperature,
     maxTokens,
     topP,
     randomSeed,
     safeMode,
+    safePrompt,
+    toolChoice,
+    responseFormat,
   }) {
     const request = this._makeChatCompletionRequest(
       model,
       messages,
+      tools,
       temperature,
       maxTokens,
       topP,
       randomSeed,
       false,
       safeMode,
+      safePrompt,
+      toolChoice,
+      responseFormat,
     );
     const response = await this._request(
       'post',
@@ -216,31 +265,43 @@ class MistralClient {
    * @param {*} model the name of the model to chat with, e.g. mistral-tiny
    * @param {*} messages an array of messages to chat with, e.g.
    * [{role: 'user', content: 'What is the best French cheese?'}]
+   * @param {*} tools  a list of tools to use.
    * @param {*} temperature the temperature to use for sampling, e.g. 0.5
    * @param {*} maxTokens the maximum number of tokens to generate, e.g. 100
    * @param {*} topP the cumulative probability of tokens to generate, e.g. 0.9
    * @param {*} randomSeed the random seed to use for sampling, e.g. 42
-   * @param {*} safeMode whether to use safe mode, e.g. true
+   * @param {*} safeMode deprecated use safePrompt instead
+   * @param {*} safePrompt whether to use safe mode, e.g. true
+   * @param {*} toolChoice the tool to use, e.g. 'auto'
+   * @param {*} responseFormat the format of the response, e.g. 'json_format'
    * @return {Promise<Object>}
    */
   chatStream = async function* ({
     model,
     messages,
+    tools,
     temperature,
     maxTokens,
     topP,
     randomSeed,
     safeMode,
+    safePrompt,
+    toolChoice,
+    responseFormat,
   }) {
     const request = this._makeChatCompletionRequest(
       model,
       messages,
+      tools,
       temperature,
       maxTokens,
       topP,
       randomSeed,
       true,
       safeMode,
+      safePrompt,
+      toolChoice,
+      responseFormat,
     );
     const response = await this._request(
       'post',
@@ -249,9 +310,9 @@ class MistralClient {
     );
 
     let buffer = '';
-
+    const decoder = new TextDecoder();
     for await (const chunk of response) {
-      buffer += chunk;
+      buffer += decoder.decode(chunk, {stream: true});
       let firstNewline;
       while ((firstNewline = buffer.indexOf('\n')) !== -1) {
         const chunkLine = buffer.substring(0, firstNewline);

package/tests/client.test.js

@@ -0,0 +1,179 @@
+import MistralClient from '../src/client';
+import {
+  mockListModels,
+  mockFetch,
+  mockChatResponseStreamingPayload,
+  mockEmbeddingRequest,
+  mockEmbeddingResponsePayload,
+  mockChatResponsePayload,
+  mockFetchStream,
+} from './utils';
+
+// Test the list models endpoint
+describe('Mistral Client', () => {
+  let client;
+  beforeEach(() => {
+    client = new MistralClient();
+  });
+
+  describe('chat()', () => {
+    it('should return a chat response object', async() => {
+      // Mock the fetch function
+      const mockResponse = mockChatResponsePayload();
+      globalThis.fetch = mockFetch(200, mockResponse);
+
+      const response = await client.chat({
+        model: 'mistral-small',
+        messages: [
+          {
+            role: 'user',
+            content: 'What is the best French cheese?',
+          },
+        ],
+      });
+      expect(response).toEqual(mockResponse);
+    });
+
+    it('should return a chat response object if safeMode is set', async() => {
+      // Mock the fetch function
+      const mockResponse = mockChatResponsePayload();
+      globalThis.fetch = mockFetch(200, mockResponse);
+
+      const response = await client.chat({
+        model: 'mistral-small',
+        messages: [
+          {
+            role: 'user',
+            content: 'What is the best French cheese?',
+          },
+        ],
+        safeMode: true,
+      });
+      expect(response).toEqual(mockResponse);
+    });
+
+    it('should return a chat response object if safePrompt is set', async() => {
+      // Mock the fetch function
+      const mockResponse = mockChatResponsePayload();
+      globalThis.fetch = mockFetch(200, mockResponse);
+
+      const response = await client.chat({
+        model: 'mistral-small',
+        messages: [
+          {
+            role: 'user',
+            content: 'What is the best French cheese?',
+          },
+        ],
+        safePrompt: true,
+      });
+      expect(response).toEqual(mockResponse);
+    });
+  });
+
+  describe('chatStream()', () => {
+    it('should return parsed, streamed response', async() => {
+      // Mock the fetch function
+      const mockResponse = mockChatResponseStreamingPayload();
+      globalThis.fetch = mockFetchStream(200, mockResponse);
+
+      const response = await client.chatStream({
+        model: 'mistral-small',
+        messages: [
+          {
+            role: 'user',
+            content: 'What is the best French cheese?',
+          },
+        ],
+      });
+
+      const parsedResponse = [];
+      for await (const r of response) {
+        parsedResponse.push(r);
+      }
+
+      expect(parsedResponse.length).toEqual(11);
+    });
+
+    it('should return parsed, streamed response with safeMode', async() => {
+      // Mock the fetch function
+      const mockResponse = mockChatResponseStreamingPayload();
+      globalThis.fetch = mockFetchStream(200, mockResponse);
+
+      const response = await client.chatStream({
+        model: 'mistral-small',
+        messages: [
+          {
+            role: 'user',
+            content: 'What is the best French cheese?',
+          },
+        ],
+        safeMode: true,
+      });
+
+      const parsedResponse = [];
+      for await (const r of response) {
+        parsedResponse.push(r);
+      }
+
+      expect(parsedResponse.length).toEqual(11);
+    });
+
+    it('should return parsed, streamed response with safePrompt', async() => {
+      // Mock the fetch function
+      const mockResponse = mockChatResponseStreamingPayload();
+      globalThis.fetch = mockFetchStream(200, mockResponse);
+
+      const response = await client.chatStream({
+        model: 'mistral-small',
+        messages: [
+          {
+            role: 'user',
+            content: 'What is the best French cheese?',
+          },
+        ],
+        safePrompt: true,
+      });
+
+      const parsedResponse = [];
+      for await (const r of response) {
+        parsedResponse.push(r);
+      }
+
+      expect(parsedResponse.length).toEqual(11);
+    });
+  });
+
+  describe('embeddings()', () => {
+    it('should return embeddings', async() => {
+      // Mock the fetch function
+      const mockResponse = mockEmbeddingResponsePayload();
+      globalThis.fetch = mockFetch(200, mockResponse);
+
+      const response = await client.embeddings(mockEmbeddingRequest);
+      expect(response).toEqual(mockResponse);
+    });
+  });
+
+  describe('embeddings() batched', () => {
+    it('should return batched embeddings', async() => {
+      // Mock the fetch function
+      const mockResponse = mockEmbeddingResponsePayload(10);
+      globalThis.fetch = mockFetch(200, mockResponse);
+
+      const response = await client.embeddings(mockEmbeddingRequest);
+      expect(response).toEqual(mockResponse);
+    });
+  });
+
+  describe('listModels()', () => {
+    it('should return a list of models', async() => {
+      // Mock the fetch function
+      const mockResponse = mockListModels();
+      globalThis.fetch = mockFetch(200, mockResponse);
+
+      const response = await client.listModels();
+      expect(response).toEqual(mockResponse);
+    });
+  });
+});

package/tests/utils.js

@@ -0,0 +1,257 @@
+import jest from 'jest-mock';
+
+/**
+ * Mock the fetch function
+ * @param {*} status
+ * @param {*} payload
+ * @return {Object}
+ */
+export function mockFetch(status, payload) {
+  return jest.fn(() =>
+    Promise.resolve({
+      json: () => Promise.resolve(payload),
+      text: () => Promise.resolve(JSON.stringify(payload)),
+      status,
+      ok: status >= 200 && status < 300,
+    }),
+  );
+}
+
+/**
+ * Mock fetch stream
+ * @param {*} status
+ * @param {*} payload
+ * @return {Object}
+ */
+export function mockFetchStream(status, payload) {
+  const asyncIterator = async function* () {
+    while (true) {
+      // Read from the stream
+      const value = payload.shift();
+      // Exit if we're done
+      if (!value) return;
+      // Else yield the chunk
+      yield value;
+    }
+  };
+
+  return jest.fn(() =>
+    Promise.resolve({
+      // body is a ReadableStream of the objects in payload list
+      body: asyncIterator(),
+      status,
+      ok: status >= 200 && status < 300,
+    }),
+  );
+}
+
+/**
+ * Mock models list
+ * @return {Object}
+ */
+export function mockListModels() {
+  return {
+    object: 'list',
+    data: [
+      {
+        id: 'mistral-medium',
+        object: 'model',
+        created: 1703186988,
+        owned_by: 'mistralai',
+        root: null,
+        parent: null,
+        permission: [
+          {
+            id: 'modelperm-15bebaf316264adb84b891bf06a84933',
+            object: 'model_permission',
+            created: 1703186988,
+            allow_create_engine: false,
+            allow_sampling: true,
+            allow_logprobs: false,
+            allow_search_indices: false,
+            allow_view: true,
+            allow_fine_tuning: false,
+            organization: '*',
+            group: null,
+            is_blocking: false,
+          },
+        ],
+      },
+      {
+        id: 'mistral-small',
+        object: 'model',
+        created: 1703186988,
+        owned_by: 'mistralai',
+        root: null,
+        parent: null,
+        permission: [
+          {
+            id: 'modelperm-d0dced5c703242fa862f4ca3f241c00e',
+            object: 'model_permission',
+            created: 1703186988,
+            allow_create_engine: false,
+            allow_sampling: true,
+            allow_logprobs: false,
+            allow_search_indices: false,
+            allow_view: true,
+            allow_fine_tuning: false,
+            organization: '*',
+            group: null,
+            is_blocking: false,
+          },
+        ],
+      },
+      {
+        id: 'mistral-tiny',
+        object: 'model',
+        created: 1703186988,
+        owned_by: 'mistralai',
+        root: null,
+        parent: null,
+        permission: [
+          {
+            id: 'modelperm-0e64e727c3a94f17b29f8895d4be2910',
+            object: 'model_permission',
+            created: 1703186988,
+            allow_create_engine: false,
+            allow_sampling: true,
+            allow_logprobs: false,
+            allow_search_indices: false,
+            allow_view: true,
+            allow_fine_tuning: false,
+            organization: '*',
+            group: null,
+            is_blocking: false,
+          },
+        ],
+      },
+      {
+        id: 'mistral-embed',
+        object: 'model',
+        created: 1703186988,
+        owned_by: 'mistralai',
+        root: null,
+        parent: null,
+        permission: [
+          {
+            id: 'modelperm-ebdff9046f524e628059447b5932e3ad',
+            object: 'model_permission',
+            created: 1703186988,
+            allow_create_engine: false,
+            allow_sampling: true,
+            allow_logprobs: false,
+            allow_search_indices: false,
+            allow_view: true,
+            allow_fine_tuning: false,
+            organization: '*',
+            group: null,
+            is_blocking: false,
+          },
+        ],
+      },
+    ],
+  };
+}
+
+/**
+ * Mock chat completion object
+ * @return {Object}
+ */
+export function mockChatResponsePayload() {
+  return {
+    id: 'chat-98c8c60e3fbf4fc49658eddaf447357c',
+    object: 'chat.completion',
+    created: 1703165682,
+    choices: [
+      {
+        finish_reason: 'stop',
+        message: {
+          role: 'assistant',
+          content: 'What is the best French cheese?',
+        },
+        index: 0,
+      },
+    ],
+    model: 'mistral-small',
+    usage: {prompt_tokens: 90, total_tokens: 90, completion_tokens: 0},
+  };
+}
+
+/**
+ * Mock chat completion stream
+ * @return {Object}
+ */
+export function mockChatResponseStreamingPayload() {
+  const encoder = new TextEncoder();
+  const firstMessage =
+    [encoder.encode('data: ' +
+    JSON.stringify({
+      id: 'cmpl-8cd9019d21ba490aa6b9740f5d0a883e',
+      model: 'mistral-small',
+      choices: [
+        {
+          index: 0,
+          delta: {role: 'assistant'},
+          finish_reason: null,
+        },
+      ],
+    }) +
+    '\n\n')];
+  const lastMessage = [encoder.encode('data: [DONE]\n\n')];
+
+  const dataMessages = [];
+  for (let i = 0; i < 10; i++) {
+    dataMessages.push(encoder.encode(
+      'data: ' +
+        JSON.stringify({
+          id: 'cmpl-8cd9019d21ba490aa6b9740f5d0a883e',
+          object: 'chat.completion.chunk',
+          created: 1703168544,
+          model: 'mistral-small',
+          choices: [
+            {
+              index: i,
+              delta: {content: `stream response ${i}`},
+              finish_reason: null,
+            },
+          ],
+        }) +
+        '\n\n'),
+    );
+  }
+
+  return firstMessage.concat(dataMessages).concat(lastMessage);
+}
+
+/**
+ * Mock embeddings response
+ * @param {number} batchSize
+ * @return {Object}
+ */
+export function mockEmbeddingResponsePayload(batchSize = 1) {
+  return {
+    id: 'embd-98c8c60e3fbf4fc49658eddaf447357c',
+    object: 'list',
+    data:
+      [
+        {
+          object: 'embedding',
+          embedding: [-0.018585205078125, 0.027099609375, 0.02587890625],
+          index: 0,
+        },
+      ] * batchSize,
+    model: 'mistral-embed',
+    usage: {prompt_tokens: 90, total_tokens: 90, completion_tokens: 0},
+  };
+}
+
+/**
+ * Mock embeddings request payload
+ * @return {Object}
+ */
+export function mockEmbeddingRequest() {
+  return {
+    model: 'mistral-embed',
+    input: 'embed',
+  };
+}