(feat) implement Conversation and Message classes with serialization and message management

Author: paoloanzn

packages/core-sdk/src/Conversation.ts

@@ -0,0 +1,75 @@
+import { randomUUID, type UUID } from "node:crypto";
+import type { Message } from "@/message.js"
+
+function dumpConversationToBytes(c: Conversation): Uint8Array {
+    const payload = {
+        uuid: c.uuid,
+        messages: c.messages.map((message) => {
+            const base = {
+                uuid: message.uuid,
+                timestamp: message.timestamp.toISOString(),
+                role: message.role,
+                encodedContent: Array.from(message.encodedContent.bytes),
+            };
+
+            if (message.role === "assistant" && message.toolCalls) {
+                return { ...base, toolCalls: message.toolCalls };
+            }
+
+            if (message.role === "tool") {
+                return { ...base, toolCallId: message.toolCallId };
+            }
+
+            return base;
+        }),
+    };
+
+    return new TextEncoder().encode(JSON.stringify(payload));
+}
+
+export type SearchMessageResult<Message, E = Error> =
+    | { ok: true, value: Message }
+    | { ok: false, error: E };
+
+export class Conversation {
+    readonly #uuid: UUID;
+    #messages: Message[];
+
+    private constructor(messages: Message[]) {
+        this.#uuid = randomUUID();
+        this.#messages = messages;
+    }
+
+    static fromMessages(messages?: Message[]) {
+        const m = (messages && messages?.length != 0) ? messages : [] as Message[];
+        return new Conversation(m);
+    }
+
+    get uuid(): UUID {
+        return this.#uuid;
+    }
+
+    get messages(): Message[] {
+        return this.#messages;
+    }
+
+    searchMessage(uuid: UUID): SearchMessageResult<Message, "message_not_found"> {
+        if (this.#messages.length <= 0) {
+            return { ok: false, error: "message_not_found" };
+        }
+
+        for (let i = 0; i < this.#messages.length; i++) {
+            const message = this.#messages[i];
+            if (message?.uuid === uuid) return { ok: true, value: message };
+        }
+
+        return { ok: false, error: "message_not_found" };
+    }
+
+    addMessage(message: Message): void {
+        this.#messages = [...this.#messages, message] as Message[];
+    }
+
+    dumpToBytes(): Uint8Array { return dumpConversationToBytes(this); }
+
+}

packages/core-sdk/src/Message.ts

@@ -0,0 +1,46 @@
+import type { UUID } from "node:crypto";
+
+export class EncodedContent {
+    readonly #bytes: Uint8Array;
+
+    private constructor(bytes: Uint8Array) {
+        this.#bytes = bytes;
+    }
+
+    static fromString(text: string): EncodedContent {
+        return new EncodedContent(new TextEncoder().encode(text));
+    }
+
+    get size(): number {
+        return this.#bytes.length;
+    }
+
+    get bytes(): Uint8Array {
+        return this.#bytes;
+    }
+
+    decode(): string {
+        return new TextDecoder("utf-8").decode(this.#bytes);
+    }
+}
+
+type ToolCallId = string & { readonly __brand: "ToolCallId" };
+export const toolCallId = (s: string): ToolCallId => s as ToolCallId;
+
+export type ToolCall = {
+    readonly toolCallId: ToolCallId,
+    readonly name: string,
+    readonly arguments: { [key: string]: unknown }
+}
+
+export interface MessageBase {
+    readonly uuid: UUID;
+    readonly timestamp: Date;
+    readonly encodedContent: EncodedContent;
+}
+
+export type Message = 
+    | (MessageBase & {readonly role: "user"})
+    | (MessageBase & {readonly role: "assistant", readonly toolCalls?: ToolCall[]})
+    | (MessageBase & {readonly role: "system"})
+    | (MessageBase & {readonly role: "tool", readonly toolCallId: ToolCallId})

packages/core-sdk/src/Provider.ts

@@ -0,0 +1,16 @@
+import { Agent as HttpsAgent } from "node:https";
+import { URL } from "node:url";
+
+export interface Provider {
+    readonly identifier: string;
+}
+
+export type HttpsProviderConfig = {
+    baseUrl: URL
+};
+
+export interface HttpsProvider extends Provider {
+    readonly config: HttpsProviderConfig;
+    readonly baseUrl: URL;
+    readonly httpsAgent: HttpsAgent;
+}