feat: web remote conversation

core/src/browser/extensions/engines/AIEngine.ts

@@ -54,6 +54,7 @@ export type ToolChoice = 'none' | 'auto' | 'required' | ToolCallSpec
 export interface chatCompletionRequest {
   model: string // Model ID, though for local it might be implicit via sessionInfo
   messages: chatCompletionRequestMessage[]
+  thread_id?: string // Thread/conversation ID for context tracking
   return_progress?: boolean
   tools?: Tool[]
   tool_choice?: ToolChoice

extensions-web/src/conversational-web/api.ts

@@ -0,0 +1,160 @@
+/**
+ * Conversation API wrapper using JanAuthProvider
+ */
+
+import { getSharedAuthService, JanAuthService } from '../shared/auth'
+import { CONVERSATION_API_ROUTES } from './const'
+import {
+  Conversation,
+  ConversationResponse,
+  ListConversationsParams,
+  ListConversationsResponse,
+  PaginationParams,
+  PaginatedResponse,
+  ConversationItem,
+  ListConversationItemsParams,
+  ListConversationItemsResponse
+} from './types'
+
+declare const JAN_API_BASE: string
+
+export class RemoteApi {
+  private authService: JanAuthService
+
+  constructor() {
+    this.authService = getSharedAuthService()
+  }
+
+  async createConversation(
+    data: Conversation
+  ): Promise<ConversationResponse> {
+    const url = `${JAN_API_BASE}${CONVERSATION_API_ROUTES.CONVERSATIONS}`
+
+    return this.authService.makeAuthenticatedRequest<ConversationResponse>(
+      url,
+      {
+        method: 'POST',
+        body: JSON.stringify(data),
+      }
+    )
+  }
+
+  async updateConversation(
+    conversationId: string,
+    data: Conversation
+  ): Promise<ConversationResponse> {
+    const url = `${JAN_API_BASE}${CONVERSATION_API_ROUTES.CONVERSATION_BY_ID(conversationId)}`
+
+    return this.authService.makeAuthenticatedRequest<ConversationResponse>(
+      url,
+      {
+        method: 'PATCH',
+        body: JSON.stringify(data),
+      }
+    )
+  }
+
+  async listConversations(
+    params?: ListConversationsParams
+  ): Promise<ListConversationsResponse> {
+    const queryParams = new URLSearchParams()
+
+    if (params?.limit !== undefined) {
+      queryParams.append('limit', params.limit.toString())
+    }
+    if (params?.after) {
+      queryParams.append('after', params.after)
+    }
+    if (params?.order) {
+      queryParams.append('order', params.order)
+    }
+
+    const queryString = queryParams.toString()
+    const url = `${JAN_API_BASE}${CONVERSATION_API_ROUTES.CONVERSATIONS}${queryString ? `?${queryString}` : ''}`
+
+    return this.authService.makeAuthenticatedRequest<ListConversationsResponse>(
+      url,
+      {
+        method: 'GET',
+      }
+    )
+  }
+
+  /**
+   * Generic method to fetch all pages of paginated data
+   */
+  async fetchAllPaginated<T>(
+    fetchFn: (params: PaginationParams) => Promise<PaginatedResponse<T>>,
+    initialParams?: Partial<PaginationParams>
+  ): Promise<T[]> {
+    const allItems: T[] = []
+    let after: string | undefined = undefined
+    let hasMore = true
+    const limit = initialParams?.limit || 100
+
+    while (hasMore) {
+      const response = await fetchFn({
+        limit,
+        after,
+        ...initialParams,
+      })
+
+      allItems.push(...response.data)
+      hasMore = response.has_more
+      after = response.last_id
+    }
+
+    return allItems
+  }
+
+  async getAllConversations(): Promise<ConversationResponse[]> {
+    return this.fetchAllPaginated<ConversationResponse>(
+      (params) => this.listConversations(params)
+    )
+  }
+
+  async deleteConversation(conversationId: string): Promise<void> {
+    const url = `${JAN_API_BASE}${CONVERSATION_API_ROUTES.CONVERSATION_BY_ID(conversationId)}`
+
+    await this.authService.makeAuthenticatedRequest(
+      url,
+      {
+        method: 'DELETE',
+      }
+    )
+  }
+
+  async listConversationItems(
+    conversationId: string,
+    params?: Omit<ListConversationItemsParams, 'conversation_id'>
+  ): Promise<ListConversationItemsResponse> {
+    const queryParams = new URLSearchParams()
+
+    if (params?.limit !== undefined) {
+      queryParams.append('limit', params.limit.toString())
+    }
+    if (params?.after) {
+      queryParams.append('after', params.after)
+    }
+    if (params?.order) {
+      queryParams.append('order', params.order)
+    }
+
+    const queryString = queryParams.toString()
+    const url = `${JAN_API_BASE}${CONVERSATION_API_ROUTES.CONVERSATION_ITEMS(conversationId)}${queryString ? `?${queryString}` : ''}`
+
+    return this.authService.makeAuthenticatedRequest<ListConversationItemsResponse>(
+      url,
+      {
+        method: 'GET',
+      }
+    )
+  }
+
+  async getAllConversationItems(conversationId: string): Promise<ConversationItem[]> {
+    return this.fetchAllPaginated<ConversationItem>(
+      (params) => this.listConversationItems(conversationId, params),
+      { limit: 100, order: 'asc' }
+    )
+  }
+}

extensions-web/src/conversational-web/const.ts

@@ -0,0 +1,17 @@
+/**
+ * API Constants for Conversational Web
+ */
+
+
+export const CONVERSATION_API_ROUTES = {
+  CONVERSATIONS: '/conversations',
+  CONVERSATION_BY_ID: (id: string) => `/conversations/${id}`,
+  CONVERSATION_ITEMS: (id: string) => `/conversations/${id}/items`,
+} as const
+
+export const DEFAULT_ASSISTANT = {
+  id: 'jan',
+  name: 'Jan',
+  avatar: '👋',
+  created_at: 1747029866.542,
+}

extensions-web/src/conversational-web/extension.ts

@@ -0,0 +1,154 @@
+/**
+ * Web Conversational Extension
+ * Implements thread and message management using IndexedDB
+ */
+
+import {
+  Thread,
+  ThreadMessage,
+  ConversationalExtension,
+  ThreadAssistantInfo,
+} from '@janhq/core'
+import { RemoteApi } from './api'
+import { getDefaultAssistant, ObjectParser, combineConversationItemsToMessages } from './utils'
+
+export default class ConversationalExtensionWeb extends ConversationalExtension {
+  private remoteApi: RemoteApi | undefined
+
+  async onLoad() {
+    console.log('Loading Web Conversational Extension')
+    this.remoteApi = new RemoteApi()
+  }
+
+  onUnload() {}
+
+  // Thread Management
+  async listThreads(): Promise<Thread[]> {
+    try {
+      if (!this.remoteApi) {
+        throw new Error('RemoteApi not initialized')
+      }
+      const conversations = await this.remoteApi.getAllConversations()
+      console.log('!!!Listed threads:', conversations.map(ObjectParser.conversationToThread))
+      return conversations.map(ObjectParser.conversationToThread)
+    } catch (error) {
+      console.error('Failed to list threads:', error)
+      return []
+    }
+  }
+
+  async createThread(thread: Thread): Promise<Thread> {
+    try {
+      if (!this.remoteApi) {
+        throw new Error('RemoteApi not initialized')
+      }
+      const response = await this.remoteApi.createConversation(
+        ObjectParser.threadToConversation(thread)
+      )
+      // Create a new thread object with the server's ID
+      const createdThread = {
+        ...thread,
+        id: response.id,
+        assistants: thread.assistants.map(getDefaultAssistant)
+      }
+      console.log('!!!Created thread:', createdThread)
+      return createdThread
+    } catch (error) {
+      console.error('Failed to create thread:', error)
+      throw error
+    }
+  }
+
+  async modifyThread(thread: Thread): Promise<void> {
+    try {
+      if (!this.remoteApi) {
+        throw new Error('RemoteApi not initialized')
+      }
+      await this.remoteApi.updateConversation(
+        thread.id,
+        ObjectParser.threadToConversation(thread)
+      )
+      console.log('!!!Modified thread:', thread)
+    } catch (error) {
+      console.error('Failed to modify thread:', error)
+      throw error
+    }
+  }
+
+  async deleteThread(threadId: string): Promise<void> {
+    try {
+      if (!this.remoteApi) {
+        throw new Error('RemoteApi not initialized')
+      }
+      await this.remoteApi.deleteConversation(threadId)
+      console.log('!!!Deleted thread:', threadId)
+    } catch (error) {
+      console.error('Failed to delete thread:', error)
+      throw error
+    }
+  }
+
+  // Message Management
+  async createMessage(message: ThreadMessage): Promise<ThreadMessage> {
+    console.log('!!!Created message:', message)
+    return message
+  }
+
+  async listMessages(threadId: string): Promise<ThreadMessage[]> {
+    try {
+      if (!this.remoteApi) {
+        throw new Error('RemoteApi not initialized')
+      }
+      console.log('!!!Listing messages for thread:', threadId)
+
+      // Fetch all conversation items from the API
+      const items = await this.remoteApi.getAllConversationItems(threadId)
+
+      // Convert and combine conversation items to thread messages
+      const messages = combineConversationItemsToMessages(items, threadId)
+
+      console.log('!!!Fetched messages:', messages)
+      return messages
+    } catch (error) {
+      console.error('Failed to list messages:', error)
+      return []
+    }
+  }
+
+  async modifyMessage(message: ThreadMessage): Promise<ThreadMessage> {
+    console.log('!!!Modified message:', message)
+    return message
+  }
+
+  async deleteMessage(threadId: string, messageId: string): Promise<void> {
+    console.log('!!!Deleted message:', threadId, messageId)
+  }
+
+  async getThreadAssistant(threadId: string): Promise<ThreadAssistantInfo> {
+    console.log('!!!Getting assistant for thread:', threadId)
+    return { id: 'jan', name: 'Jan', model: { id: 'jan-v1-4b' } }
+  }
+
+  async createThreadAssistant(
+    threadId: string,
+    assistant: ThreadAssistantInfo
+  ): Promise<ThreadAssistantInfo> {
+    console.log('!!!Creating assistant for thread:', threadId, assistant)
+    return assistant
+  }
+
+  async modifyThreadAssistant(
+    threadId: string,
+    assistant: ThreadAssistantInfo
+  ): Promise<ThreadAssistantInfo> {
+    console.log('!!!Modifying assistant for thread:', threadId, assistant)
+    return assistant
+  }
+
+  async getThreadAssistantInfo(
+    threadId: string
+  ): Promise<ThreadAssistantInfo | undefined> {
+    console.log('!!!Getting assistant info for thread:', threadId)
+    return { id: 'jan', name: 'Jan', model: { id: 'jan-v1-4b' } }
+  }
+}