📦 NEW: Threads support

Author: msaaddev

examples/nodejs/examples/threads/threads.append.ts

@@ -0,0 +1,23 @@
+import 'dotenv/config';
+import {Langbase} from 'langbase';
+
+const langbase = new Langbase({
+	apiKey: process.env.LANGBASE_API_KEY!,
+});
+
+async function main() {
+	const response = await langbase.threads.append({
+		threadId: 'REPLACE_WITH_THREAD_ID',
+		messages: [
+			{
+				role: 'assistant',
+				content: 'Nice to meet you',
+				metadata: {size: 'small'},
+			},
+		],
+	});
+
+	console.log(response);
+}
+
+main();

examples/nodejs/examples/threads/threads.create.ts

@@ -0,0 +1,17 @@
+import 'dotenv/config';
+import {Langbase} from 'langbase';
+
+const langbase = new Langbase({
+	apiKey: process.env.LANGBASE_API_KEY!,
+});
+
+async function main() {
+	const response = await langbase.threads.create({
+		messages: [{role: 'user', content: 'hello', metadata: {size: 'small'}}],
+		metadata: {company: 'langbase'},
+	});
+
+	console.log(response);
+}
+
+main();

examples/nodejs/examples/threads/threads.delete.ts

@@ -0,0 +1,16 @@
+import 'dotenv/config';
+import {Langbase} from 'langbase';
+
+const langbase = new Langbase({
+	apiKey: process.env.LANGBASE_API_KEY!,
+});
+
+async function main() {
+	const response = await langbase.threads.delete({
+		threadId: 'REPLACE_WITH_THREAD_ID',
+	});
+
+	console.log(response);
+}
+
+main();

examples/nodejs/examples/threads/threads.get.ts

@@ -0,0 +1,16 @@
+import 'dotenv/config';
+import {Langbase} from 'langbase';
+
+const langbase = new Langbase({
+	apiKey: process.env.LANGBASE_API_KEY!,
+});
+
+async function main() {
+	const response = await langbase.threads.get({
+		threadId: 'REPLACE_WITH_THREAD_ID',
+	});
+
+	console.log(response);
+}
+
+main();

examples/nodejs/examples/threads/threads.messages.list.ts

@@ -0,0 +1,16 @@
+import 'dotenv/config';
+import {Langbase} from 'langbase';
+
+const langbase = new Langbase({
+	apiKey: process.env.LANGBASE_API_KEY!,
+});
+
+async function main() {
+	const response = await langbase.threads.messages.list({
+		threadId: 'REPLACE_WITH_THREAD_ID',
+	});
+
+	console.log(response);
+}
+
+main();

examples/nodejs/examples/threads/threads.update.ts

@@ -0,0 +1,20 @@
+import 'dotenv/config';
+import {Langbase} from 'langbase';
+
+const langbase = new Langbase({
+	apiKey: process.env.LANGBASE_API_KEY!,
+});
+
+async function main() {
+	const response = await langbase.threads.update({
+		threadId: 'REPLACE_WITH_THREAD_ID',
+		metadata: {
+			company: 'langbase',
+			about: 'Langbase is the most powerful serverless platform for building AI agents with memory.',
+		},
+	});
+
+	console.log(response);
+}
+
+main();

examples/nodejs/package.json

@@ -35,9 +35,12 @@
     "embed": "npx tsx ./examples/embed/index.ts",
     "chunk": "npx tsx ./examples/chunk/index.ts",
     "parse": "npx tsx ./examples/parse/index.ts",
-    "thread.messages.add": "npx tsx ./examples/threads/thread.messages.add.ts",
-    "thread.messages.list": "npx tsx ./examples/threads/thread.messages.list.ts",
-    "thread.delete": "npx tsx ./examples/threads/thread.delete.ts"
+    "threads.create": "npx tsx ./examples/threads/threads.create.ts",
+    "threads.update": "npx tsx ./examples/threads/threads.update.ts",
+    "threads.delete": "npx tsx ./examples/threads/threads.delete.ts",
+    "threads.append": "npx tsx ./examples/threads/threads.append.ts",
+    "threads.messages.list": "npx tsx ./examples/threads/threads.messages.list.ts",
+    "threads.get": "npx tsx ./examples/threads/threads.get.ts"
   },
   "keywords": [],
   "author": "Ahmad Awais <[email protected]> (https://twitter.com/MrAhmadAwais)",

packages/langbase/src/langbase/langbase.ts

@@ -91,6 +91,11 @@ export interface Message {
 	tool_calls?: ToolCall[];
 }
 
+export interface ThreadMessage extends Message {
+	attachments?: any[];
+	metadata?: Record<string, string>;
+}
+
 export interface Variable {
 	name: string;
 	value: string;
@@ -342,19 +347,47 @@ export type ParseResponse = {
 	content: string;
 };
 
-export interface AddMessageOptions {
+export interface ThreadsCreate {
+	threadId?: string;
+	metadata?: Record<string, string>;
+	messages?: ThreadMessage[];
+}
+
+export interface ThreadsUpdate {
 	threadId: string;
-	messages: Message[];
+	metadata: Record<string, string>;
 }
 
-export interface ListMessagesOptions {
+export interface ThreadsGet {
 	threadId: string;
 }
 
 export interface DeleteThreadOptions {
 	threadId: string;
 }
 
+export interface ThreadsBaseResponse {
+	id: string;
+	object: 'thread';
+	created_at: number;
+	metadata: Record<string, string>;
+}
+
+export interface ThreadMessagesCreate {
+	threadId: string;
+	messages: ThreadMessage[];
+}
+
+export interface ThreadMessagesList {
+	threadId: string;
+}
+
+export interface ThreadMessagesBaseResponse extends ThreadMessage {
+	id: string;
+	created_at: number;
+	thread_id: string;
+}
+
 export class Langbase {
 	private request: Request;
 	private apiKey: string;
@@ -435,13 +468,20 @@ export class Langbase {
 		};
 	};
 
-	// public thread: {
-	// 	messages: {
-	// 		add: (options: AddMessageOptions) => Promise<Message[]>;
-	// 		list: (options: ListMessagesOptions) => Promise<Message[]>;
-	// 	};
-	// 	delete: (options: DeleteThreadOptions) => Promise<boolean>;
-	// };
+	public threads: {
+		create: (options: ThreadsCreate) => Promise<ThreadsBaseResponse>;
+		update: (options: ThreadsUpdate) => Promise<ThreadsBaseResponse>;
+		get: (options: ThreadsGet) => Promise<ThreadsBaseResponse>;
+		delete: (options: DeleteThreadOptions) => Promise<{success: boolean}>;
+		append: (
+			options: ThreadMessagesCreate,
+		) => Promise<ThreadMessagesBaseResponse[]>;
+		messages: {
+			list: (
+				options: ThreadMessagesList,
+			) => Promise<ThreadMessagesBaseResponse[]>;
+		};
+	};
 
 	/**
 	 * @deprecated This method is deprecated and will be removed in a future version.
@@ -534,13 +574,16 @@ export class Langbase {
 		this.embed = this.generateEmbeddings.bind(this);
 		this.chunk = this.chunkDocument.bind(this);
 		this.parse = this.parseDocument.bind(this);
-		// this.thread = {
-		// 	messages: {
-		// 		add: this.addMessages.bind(this),
-		// 		list: this.listMessages.bind(this),
-		// 	},
-		// 	delete: this.deleteThread.bind(this),
-		// };
+		this.threads = {
+			create: this.createThread.bind(this),
+			update: this.updateThread.bind(this),
+			get: this.getThread.bind(this),
+			delete: this.deleteThread.bind(this),
+			append: this.appendThreadMessages.bind(this),
+			messages: {
+				list: this.listThreadMessages.bind(this),
+			},
+		};
 	}
 
 	private async runPipe(
@@ -894,47 +937,71 @@ export class Langbase {
 	}
 
 	/**
-	 * Adds multiple messages to a specified thread.
-	 *
-	 * @param options - The options for adding messages
-	 * @param options.threadId - The ID of the thread to add messages to
-	 * @param options.messages - The array of messages to be added
-	 * @returns A Promise that resolves to an array of Message objects
-	 * @throws May throw an error if the request fails
+	 * Creates a new thread with specified options.
+	 * @param {ThreadsCreate} options - The options object containing thread creation parameters.
+	 * @returns {Promise<ThreadsBaseResponse>} A promise that resolves to the created thread response.
+	 * @private
 	 */
-	private async addMessages(options: AddMessageOptions): Promise<Message[]> {
+	private async createThread(
+		options: ThreadsCreate,
+	): Promise<ThreadsBaseResponse> {
 		return this.request.post({
-			endpoint: `/v1/threads/${options.threadId}/messages`,
-			body: options.messages,
+			endpoint: '/v1/threads',
+			body: options,
 		});
 	}
 
 	/**
-	 * Retrieves all messages from a specified thread.
+	 * Updates an existing thread with the provided options.
 	 *
-	 * @param options - The options for listing messages
-	 * @param options.threadId - The unique identifier of the thread to list messages from
-	 * @returns Promise that resolves to an array of Message objects
-	 * @throws {Error} If the request fails or the thread ID is invalid
+	 * @param options - The options to update the thread with
+	 * @param options.threadId - The ID of the thread to update
+	 * @returns A promise that resolves to the updated thread response
+	 * @throws {Error} If the request fails
 	 */
-	private async listMessages(
-		options: ListMessagesOptions,
-	): Promise<Message[]> {
-		return this.request.get({
-			endpoint: `/v1/threads/${options.threadId}/messages`,
+	private async updateThread(
+		options: ThreadsUpdate,
+	): Promise<ThreadsBaseResponse> {
+		return this.request.post({
+			endpoint: `/v1/threads/${options.threadId}`,
+			body: options,
 		});
 	}
 
 	/**
-	 * Deletes a thread using the provided thread ID.
-	 * @param options - The options for deleting a thread
-	 * @param options.threadId - The unique identifier of the thread to delete
-	 * @returns A promise that resolves to true if the thread was successfully deleted
-	 * @throws Will throw an error if the deletion fails or if the thread ID is invalid
+	 * Retrieves a thread by its ID.
+	 * @param {ThreadsGet} options - The options object containing the thread ID.
+	 * @param {string} options.threadId - The unique identifier of the thread to retrieve.
+	 * @returns {Promise<ThreadsBaseResponse>} A promise that resolves to the thread data.
 	 */
-	private async deleteThread(options: DeleteThreadOptions): Promise<boolean> {
+	private async getThread(options: ThreadsGet): Promise<ThreadsBaseResponse> {
+		return this.request.get({
+			endpoint: `/v1/threads/${options.threadId}`,
+		});
+	}
+
+	private async deleteThread(
+		options: DeleteThreadOptions,
+	): Promise<{success: boolean}> {
 		return this.request.delete({
 			endpoint: `/v1/threads/${options.threadId}`,
 		});
 	}
+
+	private async appendThreadMessages(
+		options: ThreadMessagesCreate,
+	): Promise<ThreadMessagesBaseResponse[]> {
+		return this.request.post({
+			endpoint: `/v1/threads/${options.threadId}/messages`,
+			body: options.messages,
+		});
+	}
+
+	private async listThreadMessages(
+		options: ThreadMessagesList,
+	): Promise<ThreadMessagesBaseResponse[]> {
+		return this.request.get({
+			endpoint: `/v1/threads/${options.threadId}/messages`,
+		});
+	}
 }