@agentuity/server 1.0.1 → 1.0.2

package/src/api/stream/get.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { APIClient, APIResponseSchema } from '../api';
+import { StreamResponseError } from './util';
+
+const StreamDetailSchema = z.object({
+	id: z.string().describe('the stream id'),
+	namespace: z.string().describe('the stream namespace'),
+	metadata: z.record(z.string(), z.string()).describe('stream metadata'),
+	url: z.string().describe('public URL to access the stream'),
+	sizeBytes: z.number().describe('size in bytes'),
+	createdAt: z.string().nullable().describe('ISO 8601 creation timestamp'),
+	updatedAt: z.string().nullable().describe('ISO 8601 last update timestamp'),
+	startedAt: z.string().nullable().describe('ISO 8601 stream start timestamp'),
+	endedAt: z.string().nullable().describe('ISO 8601 stream end timestamp'),
+	expiresAt: z.string().nullable().describe('ISO 8601 expiration timestamp or null'),
+	orgId: z.string().describe('the organization id'),
+	projectId: z.string().nullable().describe('the project id'),
+	completed: z.boolean().describe('whether the stream upload is completed'),
+	headers: z.record(z.string(), z.string()).describe('stream headers'),
+	chunks: z.number().describe('number of chunks'),
+});
+
+const StreamDetailResponseSchema = APIResponseSchema(StreamDetailSchema);
+
+export type StreamDetailResponse = z.infer<typeof StreamDetailResponseSchema>;
+export type StreamDetail = z.infer<typeof StreamDetailSchema>;
+
+/**
+ * Get a specific stream by ID.
+ *
+ * @param client - The API client
+ * @param id - The stream ID
+ * @returns A promise that resolves to the stream details
+ *
+ * @example
+ * const stream = await streamGet(client, 'stream_abc123');
+ * console.log(`Namespace: ${stream.namespace}, Size: ${stream.sizeBytes} bytes`);
+ */
+export async function streamGet(client: APIClient, id: string): Promise<StreamDetail> {
+	const resp = await client.request<StreamDetailResponse>(
+		'GET',
+		`/cli/stream/${encodeURIComponent(id)}`,
+		StreamDetailResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new StreamResponseError({ message: resp.message });
+}

package/src/api/stream/index.ts

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

package/src/api/stream/list.ts

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+import { APIClient, APIResponseSchema } from '../api';
+import { StreamResponseError } from './util';
+
+const StreamInfoSchema = z.object({
+	id: z.string().describe('the stream id'),
+	namespace: z.string().describe('the stream namespace'),
+	metadata: z.record(z.string(), z.string()).describe('stream metadata'),
+	url: z.string().describe('public URL to access the stream'),
+	sizeBytes: z.number().describe('size in bytes'),
+	expiresAt: z.string().nullable().describe('ISO 8601 expiration timestamp or null'),
+	orgId: z.string().describe('the organization id'),
+	projectId: z.string().nullable().describe('the project id'),
+	projectName: z.string().nullable().describe('the project name'),
+});
+
+const StreamListDataSchema = z.object({
+	streams: z.array(StreamInfoSchema).describe('list of streams'),
+	total: z.number().describe('total count of matching streams'),
+});
+
+const StreamListResponseSchema = APIResponseSchema(StreamListDataSchema);
+
+export type StreamListResponse = z.infer<typeof StreamListResponseSchema>;
+export type StreamListData = z.infer<typeof StreamListDataSchema>;
+export type StreamInfo = z.infer<typeof StreamInfoSchema>;
+
+export interface StreamListOptions {
+	/**
+	 * Filter by specific project ID
+	 */
+	projectId?: string;
+	/**
+	 * Filter by specific organization ID
+	 */
+	orgId?: string;
+	/**
+	 * Filter by stream namespace
+	 */
+	namespace?: string;
+	/**
+	 * Maximum number of streams to return (default: 100, max: 1000)
+	 */
+	limit?: number;
+	/**
+	 * Number of streams to skip for pagination
+	 */
+	offset?: number;
+	/**
+	 * Filter by metadata key-value pairs
+	 */
+	metadata?: Record<string, string>;
+}
+
+/**
+ * List streams with optional filtering.
+ *
+ * If no projectId or orgId is provided, returns streams from all orgs the user is a member of.
+ *
+ * @param client - The API client
+ * @param options - Filtering and pagination options
+ * @returns A promise that resolves to the list of streams with metadata
+ *
+ * @example
+ * // List all streams across all orgs
+ * const result = await streamList(client);
+ * console.log(`Found ${result.total} streams`);
+ *
+ * @example
+ * // List streams for a specific project
+ * const result = await streamList(client, { projectId: 'proj_123' });
+ *
+ * @example
+ * // List streams with namespace filter
+ * const result = await streamList(client, { namespace: 'agent-logs' });
+ *
+ * @example
+ * // List streams with metadata filter
+ * const result = await streamList(client, {
+ *   metadata: { type: 'export', env: 'production' }
+ * });
+ */
+export async function streamList(
+	client: APIClient,
+	options: StreamListOptions = {}
+): Promise<StreamListData> {
+	const { projectId, orgId, namespace, limit, offset, metadata } = options;
+	const params = new URLSearchParams();
+
+	if (projectId) params.set('projectId', projectId);
+	if (orgId) params.set('orgId', orgId);
+	if (namespace) params.set('namespace', namespace);
+	if (limit !== undefined) params.set('limit', limit.toString());
+	if (offset !== undefined) params.set('offset', offset.toString());
+	if (metadata && Object.keys(metadata).length > 0) {
+		params.set('metadata', JSON.stringify(metadata));
+	}
+
+	const queryString = params.toString();
+	const resp = await client.request<StreamListResponse>(
+		'GET',
+		`/cli/stream${queryString ? `?${queryString}` : ''}`,
+		StreamListResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new StreamResponseError({ message: resp.message });
+}

package/src/api/stream/util.ts

@@ -0,0 +1,3 @@
+import { StructuredError } from '@agentuity/core';
+
+export const StreamResponseError = StructuredError('StreamResponseError');

package/src/api/thread/delete.ts

@@ -2,14 +2,14 @@ import { z } from 'zod';
 import { APIClient, APIResponseSchemaNoData } from '../api';
 import { ThreadResponseError } from './util';
 
-const _ThreadDeleteRequestSchema = z.object({
+export const _ThreadDeleteRequestSchema = z.object({
 	id: z.string().describe('the thread id'),
 });
 
-const ThreadDeleteResponseSchema = APIResponseSchemaNoData();
+export const ThreadDeleteResponseSchema = APIResponseSchemaNoData();
 
-type ThreadDeleteRequest = z.infer<typeof _ThreadDeleteRequestSchema>;
-type ThreadDeleteResponse = z.infer<typeof ThreadDeleteResponseSchema>;
+export type ThreadDeleteRequest = z.infer<typeof _ThreadDeleteRequestSchema>;
+export type ThreadDeleteResponse = z.infer<typeof ThreadDeleteResponseSchema>;
 
 /**
  * Delete a thread by id

package/src/api/thread/get.ts

@@ -1,18 +1,16 @@
 import { z } from 'zod';
 import { APIClient, APIResponseSchema } from '../api';
-import { ThreadSchema } from './list';
+import { ThreadSchema, type Thread } from './list';
 import { ThreadResponseError } from './util';
 
-const _ThreadGetRequestSchema = z.object({
+export const _ThreadGetRequestSchema = z.object({
 	id: z.string().describe('the thread id'),
 });
 
-const ThreadGetResponseSchema = APIResponseSchema(ThreadSchema);
+export const ThreadGetResponseSchema = APIResponseSchema(ThreadSchema);
 
-type ThreadGetRequest = z.infer<typeof _ThreadGetRequestSchema>;
-type ThreadGetResponse = z.infer<typeof ThreadGetResponseSchema>;
-
-export type Thread = z.infer<typeof ThreadSchema>;
+export type ThreadGetRequest = z.infer<typeof _ThreadGetRequestSchema>;
+export type ThreadGetResponse = z.infer<typeof ThreadGetResponseSchema>;
 
 /**
  * Get a single thread by id

package/src/api/thread/index.ts

@@ -1,4 +1,4 @@
-export { threadGet, type Thread } from './get';
-export { threadList, type ThreadList, type ThreadListOptions, ThreadSchema } from './list';
-export { threadDelete } from './delete';
-export { ThreadResponseError } from './util';
+export * from './get';
+export * from './list';
+export * from './delete';
+export * from './util';

package/src/api/thread/list.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { APIClient, APIResponseSchema } from '../api';
 import { ThreadResponseError } from './util';
 
-const ThreadSchema = z.object({
+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'),
@@ -19,14 +19,12 @@ const ThreadSchema = z.object({
 		.describe('unencrypted key-value metadata'),
 });
 
-export { ThreadSchema };
+export const ThreadListResponseData = z.array(ThreadSchema);
 
-const ThreadListResponse = z.array(ThreadSchema);
-
-const ThreadListResponseSchema = APIResponseSchema(ThreadListResponse);
+export const ThreadListResponseSchema = APIResponseSchema(ThreadListResponseData);
 
 export type ThreadListResponse = z.infer<typeof ThreadListResponseSchema>;
-export type ThreadList = z.infer<typeof ThreadListResponse>;
+export type ThreadList = z.infer<typeof ThreadListResponseData>;
 export type Thread = z.infer<typeof ThreadSchema>;
 
 export interface ThreadListOptions {

package/src/api/user/whoami.ts

@@ -2,17 +2,17 @@ import { z } from 'zod';
 import { APIResponseSchema, APIClient } from '../api';
 import { UserResponseError } from './util';
 
-const OrganizationSchema = z.object({
+export const OrganizationSchema = z.object({
 	id: z.string().describe('the unique id for the organization'),
 	name: z.string().describe('the name of the organization'),
 });
 
-const WhoamiResponse = z.object({
+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'),
 });
-const WhoamiResponseSchema = APIResponseSchema(WhoamiResponse);
+export const WhoamiResponseSchema = APIResponseSchema(WhoamiResponse);
 
 export type WhoamiResponse = z.infer<typeof WhoamiResponseSchema>;
 export type User = z.infer<typeof WhoamiResponse>;