Support providing chat history

ai-providers/azure.ts

@@ -1,7 +1,7 @@
 import { ReadableStream, ReadableByteStreamController, UnderlyingByteSource } from 'stream/web'
-import { AiProvider, NoContentError, StreamChunkCallback } from './provider.js'
+import { AiProvider, ChatHistory, NoContentError, StreamChunkCallback } from './provider.js'
 import { AiStreamEvent, encodeEvent } from './event.js'
-import { AzureKeyCredential, ChatCompletions, EventStream, OpenAIClient } from '@azure/openai'
+import { AzureKeyCredential, ChatCompletions, ChatRequestMessageUnion, EventStream, OpenAIClient } from '@azure/openai'
 
 type AzureStreamResponse = EventStream<ChatCompletions>
 
@@ -95,8 +95,9 @@ export class AzureProvider implements AiProvider {
     )
   }
 
-  async ask (prompt: string): Promise<string> {
+  async ask (prompt: string, chatHistory?: ChatHistory): Promise<string> {
     const { choices } = await this.client.getChatCompletions(this.deploymentName, [
+      ...this.chatHistoryToMessages(chatHistory),
       { role: 'user', content: prompt }
     ])
 
@@ -112,11 +113,26 @@ export class AzureProvider implements AiProvider {
     return message.content
   }
 
-  async askStream (prompt: string, chunkCallback?: StreamChunkCallback | undefined): Promise<ReadableStream> {
+  async askStream (prompt: string, chunkCallback?: StreamChunkCallback, chatHistory?: ChatHistory): Promise<ReadableStream> {
     const response = await this.client.streamChatCompletions(this.deploymentName, [
+      ...this.chatHistoryToMessages(chatHistory),
       { role: 'user', content: prompt }
     ])
 
     return new ReadableStream(new AzureByteSource(response, chunkCallback))
   }
+
+  private chatHistoryToMessages(chatHistory?: ChatHistory): ChatRequestMessageUnion[] {
+    if (chatHistory === undefined) {
+      return []
+    }
+
+    const messages: ChatRequestMessageUnion[] = []
+    for (const previousInteraction of chatHistory) {
+      messages.push({ role: 'user', content: previousInteraction.prompt })
+      messages.push({ role: 'assistant', content: previousInteraction.response })
+    }
+
+    return messages
+  }
 }

ai-providers/llama2.ts

@@ -1,12 +1,13 @@
 import { ReadableByteStreamController, ReadableStream, UnderlyingByteSource } from 'stream/web'
 import { FastifyLoggerInstance } from 'fastify'
 import {
+  ConversationInteraction,
   LLamaChatPromptOptions,
   LlamaChatSession,
   LlamaContext,
   LlamaModel
 } from 'node-llama-cpp'
-import { AiProvider, StreamChunkCallback } from './provider.js'
+import { AiProvider, ChatHistory, StreamChunkCallback } from './provider.js'
 import { AiStreamEvent, encodeEvent } from './event.js'
 
 interface ChunkQueueNode {
@@ -174,15 +175,21 @@ export class Llama2Provider implements AiProvider {
     this.logger = logger
   }
 
-  async ask (prompt: string): Promise<string> {
-    const session = new LlamaChatSession({ context: this.context })
+  async ask (prompt: string, chatHistory?: ChatHistory): Promise<string> {
+    const session = new LlamaChatSession({
+      context: this.context,
+      conversationHistory: chatHistory
+    })
     const response = await session.prompt(prompt)
 
     return response
   }
 
-  async askStream (prompt: string, chunkCallback?: StreamChunkCallback): Promise<ReadableStream> {
-    const session = new LlamaChatSession({ context: this.context })
+  async askStream (prompt: string, chunkCallback?: StreamChunkCallback, chatHistory?: ChatHistory): Promise<ReadableStream> {
+    const session = new LlamaChatSession({
+      context: this.context,
+      conversationHistory: chatHistory
+    })
 
     return new ReadableStream(new Llama2ByteSource(session, prompt, this.logger, chunkCallback))
   }

ai-providers/mistral.ts

@@ -1,6 +1,6 @@
 import { ReadableStream, UnderlyingByteSource, ReadableByteStreamController } from 'node:stream/web'
 import MistralClient, { ChatCompletionResponseChunk } from '@platformatic/mistral-client'
-import { AiProvider, NoContentError, StreamChunkCallback } from './provider.js'
+import { AiProvider, ChatHistory, NoContentError, StreamChunkCallback } from './provider.js'
 import { AiStreamEvent, encodeEvent } from './event.js'
 
 type MistralStreamResponse = AsyncGenerator<ChatCompletionResponseChunk, void, unknown>
@@ -66,10 +66,11 @@ export class MistralProvider implements AiProvider {
     this.client = new MistralClient(apiKey)
   }
 
-  async ask (prompt: string): Promise<string> {
+  async ask (prompt: string, chatHistory?: ChatHistory): Promise<string> {
     const response = await this.client.chat({
       model: this.model,
       messages: [
+        ...this.chatHistoryToMessages(chatHistory),
         { role: 'user', content: prompt }
       ]
     })
@@ -81,13 +82,28 @@ export class MistralProvider implements AiProvider {
     return response.choices[0].message.content
   }
 
-  async askStream (prompt: string, chunkCallback?: StreamChunkCallback): Promise<ReadableStream> {
+  async askStream (prompt: string, chunkCallback?: StreamChunkCallback, chatHistory?: ChatHistory): Promise<ReadableStream> {
     const response = this.client.chatStream({
       model: this.model,
       messages: [
+        ...this.chatHistoryToMessages(chatHistory),
         { role: 'user', content: prompt }
       ]
     })
     return new ReadableStream(new MistralByteSource(response, chunkCallback))
   }
+
+  private chatHistoryToMessages(chatHistory?: ChatHistory): { role: string, content: string }[] {
+    if (chatHistory === undefined) {
+      return []
+    }
+
+    const messages: { role: string, content: string }[] = []
+    for (const previousInteraction of chatHistory) {
+      messages.push({ role: 'user', content: previousInteraction.prompt })
+      messages.push({ role: 'assistant', content: previousInteraction.response })
+    }
+
+    return messages
+  }
 }

ai-providers/ollama.ts

@@ -1,6 +1,6 @@
 import { ReadableStream, UnderlyingByteSource, ReadableByteStreamController } from 'stream/web'
-import { Ollama, ChatResponse } from 'ollama'
-import { AiProvider, StreamChunkCallback } from './provider.js'
+import { Ollama, ChatResponse, Message } from 'ollama'
+import { AiProvider, ChatHistory, StreamChunkCallback } from './provider.js'
 import { AiStreamEvent, encodeEvent } from './event.js'
 
 type OllamaStreamResponse = AsyncGenerator<ChatResponse>
@@ -51,26 +51,42 @@ export class OllamaProvider implements AiProvider {
     this.client = new Ollama({ host })
   }
 
-  async ask (prompt: string): Promise<string> {
+  async ask (prompt: string, chatHistory?: ChatHistory): Promise<string> {
     const response = await this.client.chat({
       model: this.model,
       messages: [
+        ...this.chatHistoryToMessages(chatHistory),
         { role: 'user', content: prompt }
       ]
     })
 
     return response.message.content
   }
 
-  async askStream (prompt: string, chunkCallback?: StreamChunkCallback | undefined): Promise<ReadableStream> {
+  async askStream (prompt: string, chunkCallback?: StreamChunkCallback, chatHistory?: ChatHistory): Promise<ReadableStream> {
     const response = await this.client.chat({
       model: this.model,
       messages: [
+        ...this.chatHistoryToMessages(chatHistory),
         { role: 'user', content: prompt }
       ],
       stream: true
     })
 
     return new ReadableStream(new OllamaByteSource(response, chunkCallback))
   }
+
+  private chatHistoryToMessages(chatHistory?: ChatHistory): Message[] {
+    if (chatHistory === undefined) {
+      return []
+    }
+
+    const messages: Message[] = []
+    for (const previousInteraction of chatHistory) {
+      messages.push({ role: 'user', content: previousInteraction.prompt })
+      messages.push({ role: 'assistant', content: previousInteraction.response })
+    }
+
+    return messages
+  }
 }

ai-providers/open-ai.ts

@@ -1,9 +1,9 @@
 import { ReadableStream, UnderlyingByteSource, ReadableByteStreamController } from 'node:stream/web'
 import OpenAI from 'openai'
-import { AiProvider, NoContentError, StreamChunkCallback } from './provider.js'
+import { AiProvider, ChatHistory, NoContentError, StreamChunkCallback } from './provider.js'
 import { ReadableStream as ReadableStreamPolyfill } from 'web-streams-polyfill'
 import { fetch } from 'undici'
-import { ChatCompletionChunk } from 'openai/resources/index'
+import { ChatCompletionChunk, ChatCompletionMessageParam } from 'openai/resources/index'
 import { AiStreamEvent, encodeEvent } from './event.js'
 import createError from '@fastify/error'
 
@@ -96,10 +96,11 @@ export class OpenAiProvider implements AiProvider {
     this.client = new OpenAI({ apiKey, fetch })
   }
 
-  async ask (prompt: string): Promise<string> {
+  async ask (prompt: string, chatHistory?: ChatHistory): Promise<string> {
     const response = await this.client.chat.completions.create({
       model: this.model,
       messages: [
+        ...this.chatHistoryToMessages(chatHistory),
         { role: 'user', content: prompt }
       ],
       stream: false
@@ -117,14 +118,29 @@ export class OpenAiProvider implements AiProvider {
     return content
   }
 
-  async askStream (prompt: string, chunkCallback?: StreamChunkCallback): Promise<ReadableStream> {
+  async askStream (prompt: string, chunkCallback?: StreamChunkCallback, chatHistory?: ChatHistory): Promise<ReadableStream> {
     const response = await this.client.chat.completions.create({
       model: this.model,
       messages: [
+        ...this.chatHistoryToMessages(chatHistory),
         { role: 'user', content: prompt }
       ],
       stream: true
     })
     return new ReadableStream(new OpenAiByteSource(response.toReadableStream() as ReadableStreamPolyfill, chunkCallback))
   }
+
+  private chatHistoryToMessages(chatHistory?: ChatHistory): ChatCompletionMessageParam[] {
+    if (chatHistory === undefined) {
+      return []
+    }
+
+    const messages: ChatCompletionMessageParam[] = []
+    for (const previousInteraction of chatHistory) {
+      messages.push({ role: 'user', content: previousInteraction.prompt })
+      messages.push({ role: 'assistant', content: previousInteraction.response })
+    }
+
+    return messages
+  }
 }

ai-providers/provider.ts

@@ -1,11 +1,13 @@
 import { ReadableStream } from 'node:stream/web'
 import createError from '@fastify/error'
 
+export type ChatHistory = { prompt: string, response: string }[]
+
 export type StreamChunkCallback = (response: string) => Promise<string>
 
 export interface AiProvider {
-  ask: (prompt: string) => Promise<string>
-  askStream: (prompt: string, chunkCallback?: StreamChunkCallback) => Promise<ReadableStream>
+  ask: (prompt: string, chatHistory?: ChatHistory) => Promise<string>
+  askStream: (prompt: string, chunkCallback?: StreamChunkCallback, chatHistory?: ChatHistory) => Promise<ReadableStream>
 }
 
 export const NoContentError = createError<[string]>('NO_CONTENT', '%s didn\'t return any content')

index.d.ts

@@ -3,19 +3,24 @@ import { PlatformaticApp } from '@platformatic/service'
 import { errorResponseBuilderContext } from '@fastify/rate-limit'
 import { AiWarpConfig } from './config.js'
 
+type ChatHistory = {
+  prompt: string,
+  response: string
+}[]
+
 declare module 'fastify' {
   interface FastifyInstance {
     platformatic: PlatformaticApp<AiWarpConfig>
     ai: {
       /**
        * Send a prompt to the AI provider and receive the full response.
        */
-      warp: (request: FastifyRequest, prompt: string) => Promise<string>
+      warp: (request: FastifyRequest, prompt: string, chatHistory?: ChatHistory) => Promise<string>
 
       /**
        * Send a prompt to the AI provider and receive a streamed response.
        */
-      warpStream: (request: FastifyRequest, prompt: string) => Promise<ReadableStream>
+      warpStream: (request: FastifyRequest, prompt: string, chatHistory?: ChatHistory) => Promise<ReadableStream>
 
       /**
        * A function to be called before warp() returns it's result. It can

plugins/api.ts

@@ -16,7 +16,11 @@ const plugin: FastifyPluginAsyncTypebox = async (fastify) => {
     method: 'POST',
     schema: {
       body: Type.Object({
-        prompt: Type.String()
+        prompt: Type.String(),
+        chatHistory: Type.Optional(Type.Array(Type.Object({
+          prompt: Type.String(),
+          response: Type.String()
+        })))
       }),
       response: {
         200: Type.Object({

plugins/warp.ts

@@ -37,21 +37,21 @@ export default fastifyPlugin(async (fastify) => {
   const provider = await build(config.aiProvider, fastify.log)
 
   fastify.decorate('ai', {
-    warp: async (request, prompt) => {
+    warp: async (request, prompt, chatHistory) => {
       let decoratedPrompt = prompt
       if (config.promptDecorators !== undefined) {
         const { prefix, suffix } = config.promptDecorators
         decoratedPrompt = (prefix ?? '') + decoratedPrompt + (suffix ?? '')
       }
 
-      let response = await provider.ask(decoratedPrompt)
+      let response = await provider.ask(decoratedPrompt, chatHistory)
       if (fastify.ai.preResponseCallback !== undefined) {
         response = await fastify.ai.preResponseCallback(request, response) ?? response
       }
 
       return response
     },
-    warpStream: async (request, prompt) => {
+    warpStream: async (request, prompt, chatHistory) => {
       let decoratedPrompt = prompt
       if (config.promptDecorators !== undefined) {
         const { prefix, suffix } = config.promptDecorators
@@ -68,7 +68,7 @@ export default fastifyPlugin(async (fastify) => {
         }
       }
 
-      const response = await provider.askStream(decoratedPrompt, chunkCallback)
+      const response = await provider.askStream(decoratedPrompt, chunkCallback, chatHistory)
       return response
     },
     rateLimiting: {}

static/scripts/chat.js

@@ -66,8 +66,10 @@ async function promptAiWarp (message) {
       headers: {
         'content-type': 'application/json'
       },
-      // TODO chat history
-      body: JSON.stringify({ prompt: message.prompt })
+      body: JSON.stringify({
+        prompt: message.prompt,
+        chatHistory: messages
+      })
     })
     if (res.status !== 200) {
       const { message, code } = await res.json()