@neuralinnovations/dataisland-sdk 0.0.1-dev9 → 0.1.1

package/src/storages/chats/answer.ts

@@ -1,14 +1,20 @@
 import {
   AnswerStatus,
-  FetchTokensResponse,
-  SourceDto,
-  StepType
+  SourceDto
 } from "../../dto/chatResponse"
+import { EventDispatcher } from "../../events"
 
 export type AnswerId = string
 export type StepId = string
 
-export abstract class Answer {
+export enum AnswerEvent {
+  ADDED = "added",
+  CANCALLED = "cancelled",
+  FAILED = "failed",
+  UPDATED = "updated"
+}
+
+export abstract class Answer extends EventDispatcher<AnswerEvent, Answer> {
 
   /**
    * Answer id.
@@ -16,24 +22,29 @@ export abstract class Answer {
   abstract get id(): AnswerId
 
   /**
-   * Answer status.
+   * Answer data object
    */
-  abstract get status(): AnswerStatus
+  abstract get question(): string
 
   /**
-   * Answer sources.
+   * Answer tokens
    */
-  abstract sources(type: StepType): Promise<SourceDto[]>
+  abstract get tokens(): string
 
   /**
-   * Fetch answer.
+   * Answer status.
+   */
+  abstract get status(): AnswerStatus
+
+  /**
+   * Answer sources.
    */
-  abstract fetch(): Promise<void>
+  abstract get sources(): SourceDto[]
 
   /**
-   * Fetch answer.
+   * Answer time.
    */
-  abstract fetchTokens(type: StepType, tokenStartAt: number): Promise<FetchTokensResponse>
+  abstract get timestamp(): number
 
   /**
    * Cancel answer

package/src/storages/chats/chat.impl.ts

@@ -1,7 +1,7 @@
 import { Chat, ChatAnswerType } from "./chat"
 import { Disposable } from "../../disposable"
-import { Answer } from "./answer"
-import { ChatDto } from "../../dto/chatResponse"
+import { Answer, AnswerId } from "./answer"
+import {ChatDto, ChatResourceDto} from "../../dto/chatResponse"
 import { Context } from "../../context"
 import { AnswerImpl } from "./answer.impl"
 import { RpcService } from "../../services/rpcService"
@@ -10,7 +10,7 @@ import { Organization } from "../organizations/organization"
 
 export class ChatImpl extends Chat implements Disposable {
   private _isDisposed: boolean = false
-  private readonly _answers: Answer[] = []
+  private _answers: AnswerImpl[] = []
 
   private _content?: ChatDto
 
@@ -24,10 +24,11 @@ export class ChatImpl extends Chat implements Disposable {
   async initFrom(chat: ChatDto): Promise<ChatImpl> {
     this._content = chat
 
+    this._answers = []
     // init answers
     for (const ans of chat.answers) {
       // create answer implementation
-      const answer = await new AnswerImpl(this, this.context).initFromData(ans)
+      const answer = new AnswerImpl(this, this.context).initFromHistory(ans)
 
       // add answer to the collection
       this._answers.push(answer)
@@ -36,6 +37,27 @@ export class ChatImpl extends Chat implements Disposable {
     return this
   }
 
+  async update(): Promise<void> {
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Chats")
+      .searchParam("id", this.id)
+      .sendGet()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        `Get chat for id ${this.id} is failed`,
+        response
+      )
+    }
+
+    // parse chat from the server's response
+    const chat = (await response!.json() as { chat: ChatDto }).chat as ChatDto
+
+    await this.initFrom(chat)
+  }
+
   get id(): string {
     return <string>this._content?.id
   }
@@ -44,15 +66,43 @@ export class ChatImpl extends Chat implements Disposable {
     return <string>this._content?.name
   }
 
+  get resource(): ChatResourceDto {
+    return  <ChatResourceDto>this._content?.resources
+  }
+
+  get model(): string {
+    return <string>this._content?.model
+  }
+
+  get createAt(): number{
+    return <number>this._content?.createdAt
+  }
+
+  get modifiedAt(): number{
+    return <number>this._content?.modifiedAt
+  }
+  get clientContext(): string {
+    return <string>this._content?.clientContext
+  }
+
   get collection(): readonly Answer[] {
-    return this._answers
+    return <Answer[]>this._answers
   }
 
   get isDisposed(): boolean {
     return this._isDisposed
   }
 
-  async ask(message: string, answerType: ChatAnswerType): Promise<Answer> {
+  public getAnswer(id: AnswerId): Answer {
+    const answer = this._answers.find(answer => answer.id === id)
+    if (answer) {
+      return answer
+    }
+    throw new Error(`Answer with id ${id} is not found`)
+  }
+
+  async ask(message: string, answerType: ChatAnswerType): Promise<Answer | undefined> {
+
     // send request to the server
     const response = await this.context
       .resolve(RpcService)
@@ -65,14 +115,17 @@ export class ChatImpl extends Chat implements Disposable {
 
     // check response status
     if (ResponseUtils.isFail(response)) {
+      if (await ResponseUtils.isLimitReached()){
+        return undefined
+      }
       await ResponseUtils.throwError(`Failed to ask a question, organization: ${this.organization.id}`, response)
     }
 
     // parse answer id from the server's response
-    const id = (await response!.json()).id
+    const id = (await response!.json() as { id: string }).id
 
     // create answer implementation
-    const answer = await new AnswerImpl(this, this.context).initFromId(id)
+    const answer = await new AnswerImpl(this, this.context).initNew(id, message)
 
     // add answer to the collection
     this._answers.push(answer)
@@ -80,6 +133,8 @@ export class ChatImpl extends Chat implements Disposable {
     return answer
   }
 
+
+
   dispose(): void {
     this._isDisposed = true
   }

package/src/storages/chats/chat.ts

@@ -1,5 +1,6 @@
 import { Answer } from "./answer"
 import { Organization } from "../organizations/organization"
+import {ChatResourceDto} from "../../dto/chatResponse"
 
 export type ChatId = string
 
@@ -25,14 +26,51 @@ export abstract class Chat {
    */
   abstract get name(): string
 
+  /**
+   * Chat resource info : type ChatType, related entities Ids.
+   */
+  abstract get resource(): ChatResourceDto
+
+  /**
+   * Model.
+   */
+  abstract get model(): string
+
+  /**
+   * CreateAt.
+   */
+  abstract get createAt(): number
+
+  /**
+   * Modified at.
+   */
+  abstract get modifiedAt(): number
+
+  /**
+   * Added client context.
+   */
+  abstract get clientContext(): string
+
   /**
    * Answers list.
    */
   abstract get collection(): ReadonlyArray<Answer>
 
+  /**
+   * Get answer by id
+   * @param id answer id
+   */
+  abstract getAnswer(id: string): Answer
+
+  /**
+   * Update chat
+   */
+  abstract update(): Promise<void>
+
   /**
    * Ask new question in chat.
    */
-  abstract ask(message: string, answerType: ChatAnswerType): Promise<Answer>
+  abstract ask(message: string, answerType: ChatAnswerType): Promise<Answer | undefined>
+
 }
 

package/src/storages/chats/chats.impl.ts

@@ -7,6 +7,8 @@ import { OrganizationId } from "../organizations/organizations"
 import { Chat } from "./chat"
 import { ChatImpl } from "./chat.impl"
 import { Chats, ChatsEvent } from "./chats"
+import {LibraryId} from "../library/libraryId"
+import {LibrariesService} from "../../services/librariesService"
 
 export class ChatsImpl extends Chats {
   private readonly _chats: Chat[] = []
@@ -19,6 +21,16 @@ export class ChatsImpl extends Chats {
   }
 
   async initFrom(organizationId: OrganizationId): Promise<void> {
+    await this.loadOrganizationChats(organizationId)
+    const libraries = (this.context.resolve(LibrariesService) as LibrariesService).libraries.collection
+    for (const library of libraries){
+      await this.loadLibraryChats(library.id)
+    }
+
+    this._chats.sort((a, b) => b.modifiedAt - a.modifiedAt)
+  }
+
+  async loadOrganizationChats(organizationId: OrganizationId): Promise<void> {
     // init chats from the server's response
     const limit = 100
     const page = 0
@@ -55,7 +67,45 @@ export class ChatsImpl extends Chats {
         data: chat
       })
     }
+  }
+
+  async loadLibraryChats(libraryId: LibraryId): Promise<void>{
+    // init chats from the server's response
+    const limit = 100
+    const page = 0
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Chats/list/library")
+      .searchParam("libraryId", libraryId)
+      .searchParam("limit", limit.toString())
+      .searchParam("page", page.toString())
+      .sendGet()
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      await ResponseUtils.throwError(
+        `Chats list library id:${libraryId}, page:${page}, limit:${limit}, failed`,
+        response
+      )
+    }
 
+    // parse chats from the server's response
+    const chats = (await response!.json()) as ChatListResponse
+
+    // init chats
+    for (const cht of chats.chats) {
+      // create chat implementation
+      const chat = await new ChatImpl(this.context, this.organization).initFrom(cht)
+
+      // add chat to the collection
+      this._chats.push(chat)
+
+      // dispatch event
+      this.dispatch({
+        type: ChatsEvent.ADDED,
+        data: chat
+      })
+    }
   }
 
   get collection(): readonly Chat[] {
@@ -70,28 +120,41 @@ export class ChatsImpl extends Chats {
     return this._chats.find(chat => chat.id === id)
   }
 
-  async create(): Promise<Chat> {
+  async create(model: string, clientContext: string = ""): Promise<Chat | undefined> {
+    if (model === undefined || model === null) {
+      throw new Error("Create chat, model is undefined or null")
+    }
+
+    if (model.length === 0) {
+      throw new Error("Create chat, model is empty")
+    }
 
     // send create request to the server
     const response = await this.context
       .resolve(RpcService)
-      ?.requestBuilder("api/v1/Chats")
-      .sendPostJson({ organizationId: this.organization.id })
+      ?.requestBuilder("api/v1/Chats/workspaces")
+      .sendPostJson({ organizationId: this.organization.id, model: model, clientContext: clientContext })
 
     // check response status
     if (ResponseUtils.isFail(response)) {
+      if (await ResponseUtils.isLimitReached()){
+        return undefined
+      }
+
       await ResponseUtils.throwError(`Failed to create chat, organization: ${this.organization.id}`, response)
     }
 
     // parse workspace from the server's response
-    const content = (await response!.json()).chat as ChatDto
+    const content = (await response!.json() as {
+      chat: ChatDto
+    }).chat as ChatDto
 
     // create workspace implementation
     const chat = new ChatImpl(this.context, this.organization)
     await chat.initFrom(content)
 
     // add chat to the collection
-    this._chats.push(chat)
+    this._chats.splice(0, 0, chat)
 
     // dispatch event
     this.dispatch({
@@ -102,6 +165,198 @@ export class ChatsImpl extends Chats {
     return chat
   }
 
+  async createWithFile(fileId: string): Promise<Chat | undefined> {
+    if (fileId === undefined || fileId === null) {
+      throw new Error("Create chat with file, id is undefined or null")
+    }
+    if (fileId.length === 0 || fileId.trim().length === 0) {
+      throw new Error("Create chat with file, id is empty")
+    }
+
+    // send create request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Chats/file")
+      .sendPostJson({ 
+        organizationId: this.organization.id,
+        fileId: fileId,
+        model: "search"
+      })
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      if (await ResponseUtils.isLimitReached()){
+        return undefined
+      }
+
+      await ResponseUtils.throwError(`Failed to create chat, organization: ${this.organization.id}`, response)
+    }
+
+    // parse workspace from the server's response
+    const content = (await response!.json() as {
+      chat: ChatDto
+    }).chat as ChatDto
+
+    // create workspace implementation
+    const chat = new ChatImpl(this.context, this.organization)
+    await chat.initFrom(content)
+
+    // add chat to the collection
+    this._chats.splice(0, 0, chat)
+
+    // dispatch event
+    this.dispatch({
+      type: ChatsEvent.ADDED,
+      data: chat
+    })
+
+    return chat
+  }
+
+  async createWithWorkspace(workspaceIds: string[], clientContext: string = ""): Promise<Chat | undefined> {
+    if (workspaceIds === undefined || workspaceIds === null) {
+      throw new Error("Create chat with workspace, ids are undefined or null")
+    }
+    if (workspaceIds.length === 0) {
+      throw new Error("Create chat with workspace, ids are empty")
+    }
+
+    // send create request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/Chats/workspaces")
+      .sendPostJson({
+        organizationId: this.organization.id,
+        model: "search",
+        clientContext: clientContext,
+        workspaceIds: workspaceIds
+      })
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      if (await ResponseUtils.isLimitReached()){
+        return undefined
+      }
+
+      await ResponseUtils.throwError(`Failed to create chat in workspace, organization: ${this.organization.id}`, response)
+    }
+
+    // parse workspace from the server's response
+    const content = (await response!.json() as {
+      chat: ChatDto
+    }).chat as ChatDto
+
+    // create workspace implementation
+    const chat = new ChatImpl(this.context, this.organization)
+    await chat.initFrom(content)
+
+    // add chat to the collection
+    this._chats.splice(0, 0, chat)
+
+    // dispatch event
+    this.dispatch({
+      type: ChatsEvent.ADDED,
+      data: chat
+    })
+
+    return chat
+  }
+
+  async createWithLibraryFolder(libraryId: string, folderIds: string[] | null = null): Promise<Chat | undefined>{
+    if (libraryId === undefined || libraryId === null || libraryId.trim() === "")  {
+      throw new Error("Create chat with library folder, library id is undefined, null or empty")
+    }
+
+    // send create request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/chats/library/folders")
+      .sendPostJson({
+        libraryId: libraryId,
+        folderIds: folderIds,
+        model: "search",
+        clientContext: "",
+      })
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      if (await ResponseUtils.isLimitReached()){
+        return undefined
+      }
+
+      await ResponseUtils.throwError(`Failed to create chat in library with folder, library: ${libraryId}`, response)
+    }
+
+    // parse workspace from the server's response
+    const content = (await response!.json() as {
+      chat: ChatDto
+    }).chat as ChatDto
+
+    // create workspace implementation
+    const chat = new ChatImpl(this.context, this.organization)
+    await chat.initFrom(content)
+
+    // add chat to the collection
+    this._chats.splice(0, 0, chat)
+
+    // dispatch event
+    this.dispatch({
+      type: ChatsEvent.ADDED,
+      data: chat
+    })
+
+    return chat
+  }
+
+  async createWithLibraryFile(libraryId: string, fileId: string): Promise<Chat | undefined>{
+    if (libraryId === undefined || libraryId === null || libraryId.trim() === "")  {
+      throw new Error("Create chat with library file, library id is undefined, null or empty")
+    }
+
+    // send create request to the server
+    const response = await this.context
+      .resolve(RpcService)
+      ?.requestBuilder("api/v1/chats/library/file")
+      .sendPostJson({
+        libraryId: libraryId,
+        fileId: fileId,
+        model: "search",
+        clientContext: "",
+      })
+
+    // check response status
+    if (ResponseUtils.isFail(response)) {
+      if (await ResponseUtils.isLimitReached()){
+        return undefined
+      }
+
+      await ResponseUtils.throwError(`Failed to create chat in library with file, library: ${libraryId}`, response)
+    }
+
+    // parse workspace from the server's response
+    const content = (await response!.json() as {
+      chat: ChatDto
+    }).chat as ChatDto
+
+    // create workspace implementation
+    const chat = new ChatImpl(this.context, this.organization)
+    await chat.initFrom(content)
+
+    // add chat to the collection
+    this._chats.splice(0, 0, chat)
+
+    // dispatch event
+    this.dispatch({
+      type: ChatsEvent.ADDED,
+      data: chat
+    })
+
+    return chat
+  }
+
+
+
+
   async delete(id: string): Promise<void> {
     // get chat by id
     const chat = <ChatImpl>this.tryGet(id)

package/src/storages/chats/chats.ts

@@ -25,7 +25,34 @@ export abstract class Chats extends EventDispatcher<ChatsEvent, Chat> {
   /**
    * Create new chat.
    */
-  abstract create(): Promise<Chat>
+  abstract create(model: string, clientContext: string): Promise<Chat | undefined>
+
+  /**
+   * Create chat with specific file
+   * @param fileId 
+   */
+  abstract createWithFile(fileId: string): Promise<Chat | undefined>
+
+  /**
+   * Create chat with specific workspace
+   * @param workspaceIds
+   * @param clientContext
+   */
+  abstract createWithWorkspace(workspaceIds: string[], clientContext: string): Promise<Chat | undefined>
+
+  /**
+   * Create chat with library folders
+   * @param libraryId
+   * @param folderIds
+   */
+  abstract createWithLibraryFolder(libraryId: string, folderIds: string[]): Promise<Chat | undefined>
+
+  /**
+   * Create chat with library file
+   * @param libraryId
+   * @param fileId
+   */
+  abstract createWithLibraryFile(libraryId: string, fileId: string): Promise<Chat | undefined>
 
   /**
    * Get chat by id.