@agentuity/core 1.0.32 → 1.0.34

package/src/services/thread/delete.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { APIClient, APIResponseSchemaNoData } from '../api.ts';
+import { ThreadResponseError } from './util.ts';
+
+export const _ThreadDeleteRequestSchema = z.object({
+	id: z.string().describe('the thread id'),
+});
+
+export const ThreadDeleteResponseSchema = APIResponseSchemaNoData();
+
+export type ThreadDeleteRequest = z.infer<typeof _ThreadDeleteRequestSchema>;
+export type ThreadDeleteResponse = z.infer<typeof ThreadDeleteResponseSchema>;
+
+/**
+ * Delete a thread by id
+ *
+ * @param client
+ * @param request
+ * @returns
+ */
+export async function threadDelete(client: APIClient, request: ThreadDeleteRequest): Promise<void> {
+	const resp = await client.request<ThreadDeleteResponse>(
+		'DELETE',
+		`/thread/${request.id}`,
+		ThreadDeleteResponseSchema
+	);
+
+	if (!resp.success) {
+		throw new ThreadResponseError({ message: resp.message });
+	}
+}

package/src/services/thread/get.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { APIClient, APIResponseSchema } from '../api.ts';
+import { ThreadSchema, type Thread } from './list.ts';
+import { ThreadResponseError } from './util.ts';
+
+export const _ThreadGetRequestSchema = z.object({
+	id: z.string().describe('the thread id'),
+});
+
+export const ThreadGetResponseSchema = APIResponseSchema(ThreadSchema);
+
+export type ThreadGetRequest = z.infer<typeof _ThreadGetRequestSchema>;
+export type ThreadGetResponse = z.infer<typeof ThreadGetResponseSchema>;
+
+/**
+ * Get a single thread by id
+ *
+ * @param client
+ * @param request
+ * @returns
+ */
+export async function threadGet(client: APIClient, request: ThreadGetRequest): Promise<Thread> {
+	const resp = await client.request<ThreadGetResponse>(
+		'GET',
+		`/thread/${encodeURIComponent(request.id)}`,
+		ThreadGetResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new ThreadResponseError({ message: resp.message });
+}

package/src/services/thread/index.ts

@@ -0,0 +1,4 @@
+export * from './get.ts';
+export * from './list.ts';
+export * from './delete.ts';
+export * from './util.ts';

package/src/services/thread/list.ts

@@ -0,0 +1,81 @@
+import { SortDirectionSchema } from '../pagination.ts';
+import { z } from 'zod';
+import { APIClient, APIResponseSchema } from '../api.ts';
+import { ThreadResponseError } from './util.ts';
+
+export const ThreadSchema = z.object({
+	id: z.string().describe('the thread id'),
+	created_at: z.string().describe('the creation timestamp'),
+	updated_at: z.string().describe('the last update timestamp'),
+	deleted: z.boolean().describe('whether the thread is deleted'),
+	deleted_at: z.string().nullable().describe('the deletion timestamp'),
+	deleted_by: z.string().nullable().describe('who deleted the thread'),
+	org_id: z.string().describe('the organization id'),
+	project_id: z.string().describe('the project id'),
+	user_data: z.string().nullable().optional().describe('the user data as JSON'),
+	metadata: z
+		.record(z.string(), z.unknown())
+		.nullable()
+		.optional()
+		.describe('unencrypted key-value metadata'),
+});
+
+export const ThreadListResponseData = z.array(ThreadSchema);
+
+export const ThreadListResponseSchema = APIResponseSchema(ThreadListResponseData);
+
+export type ThreadListResponse = z.infer<typeof ThreadListResponseSchema>;
+export type ThreadList = z.infer<typeof ThreadListResponseData>;
+export type Thread = z.infer<typeof ThreadSchema>;
+
+export type ThreadSortField = 'created' | 'updated';
+
+export const ThreadListOptionsSchema = z.object({
+	count: z.number().optional().describe('Deprecated alias for limit'),
+	limit: z.number().optional().describe('Maximum number of threads to return'),
+	offset: z.number().optional().describe('Pagination offset'),
+	sort: z.enum(['created', 'updated']).optional().describe('Field to sort threads by'),
+	direction: SortDirectionSchema.optional().describe('Sort direction for thread listing'),
+	orgId: z.string().optional().describe('Optional organization id filter'),
+	projectId: z.string().optional().describe('Optional project id filter'),
+	metadata: z
+		.record(z.string(), z.unknown())
+		.optional()
+		.describe('Optional metadata match filter serialized as JSON'),
+});
+
+export type ThreadListOptions = z.infer<typeof ThreadListOptionsSchema>;
+
+/**
+ * List threads
+ *
+ * @param client
+ * @param options filtering and pagination options
+ * @returns
+ */
+export async function threadList(
+	client: APIClient,
+	options: ThreadListOptions = {}
+): Promise<ThreadList> {
+	const { limit, count, offset, sort, direction, orgId, projectId, metadata } = options;
+	const resolvedLimit = limit ?? count ?? 10;
+	const params = new URLSearchParams({ limit: resolvedLimit.toString() });
+	if (orgId) params.set('orgId', orgId);
+	if (projectId) params.set('projectId', projectId);
+	if (offset !== undefined) params.set('offset', offset.toString());
+	if (sort) params.set('sort', sort);
+	if (direction) params.set('direction', direction);
+	if (metadata) params.set('metadata', JSON.stringify(metadata));
+
+	const resp = await client.request<ThreadListResponse>(
+		'GET',
+		`/thread?${params.toString()}`,
+		ThreadListResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new ThreadResponseError({ message: resp.message });
+}

package/src/services/thread/util.ts

@@ -0,0 +1,3 @@
+import { StructuredError } from '../../error.ts';
+
+export const ThreadResponseError = StructuredError('ThreadResponseError');

package/src/services/user/index.ts

@@ -0,0 +1 @@
+export * from './whoami.ts';

package/src/services/user/util.ts

@@ -0,0 +1,3 @@
+import { StructuredError } from '../../error.ts';
+
+export const UserResponseError = StructuredError('UserResponseError');

package/src/services/user/whoami.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { APIResponseSchema, APIClient } from '../api.ts';
+import { UserResponseError } from './util.ts';
+
+export const OrganizationSchema = z.object({
+	id: z.string().describe('the unique id for the organization'),
+	name: z.string().describe('the name of the organization'),
+});
+
+export const WhoamiResponse = z.object({
+	firstName: z.string().describe('the first name of the user'),
+	lastName: z.string().describe('the last name of the user'),
+	organizations: z.array(OrganizationSchema).describe('the organizations the user is a member of'),
+});
+export const WhoamiResponseSchema = APIResponseSchema(WhoamiResponse);
+
+export type WhoamiResponse = z.infer<typeof WhoamiResponseSchema>;
+export type User = z.infer<typeof WhoamiResponse>;
+
+/**
+ * Get the current authenticated user information
+ *
+ * @param client
+ * @returns
+ */
+export async function whoami(client: APIClient): Promise<User> {
+	const resp = await client.get<WhoamiResponse>('/cli/auth/user', WhoamiResponseSchema);
+	if (resp.success) {
+		return resp.data;
+	}
+	throw new UserResponseError({ message: resp.message });
+}

package/src/services/vector/index.ts

@@ -0,0 +1 @@
+export * from './service.ts';