10xgraph-client 0.0.0-stage → 0.6.0

package/src/endpoints/threadMessages.ts

@@ -0,0 +1,97 @@
+import { ResponseMetadata } from './metadata.js';
+import { Message } from '../message.js';
+import { createErrorFromResponse } from '../errors.js';
+import { buildHeaders, getRequestCredentials, RequestContext } from '../request.js';
+
+export interface ThreadMessagesContext extends RequestContext {}
+
+export interface ThreadMessagesRequest {
+  threadId: string | number;
+  search?: string;
+  offset?: number;
+  limit?: number;
+}
+
+export interface ThreadMessagesData {
+  messages: Message[];
+}
+
+// Backward compatibility alias
+export type CheckpointMessagesData = ThreadMessagesData;
+
+export interface ThreadMessagesResponse {
+  data: ThreadMessagesData;
+  metadata: ResponseMetadata;
+}
+
+// Backward compatibility alias
+export type CheckpointMessagesResponse = ThreadMessagesResponse;
+
+export async function threadMessages(
+  context: ThreadMessagesContext,
+  request: ThreadMessagesRequest
+): Promise<ThreadMessagesResponse> {
+  try {
+    if (context.debug) {
+      console.debug('TenxGraphClient: Fetching thread messages for thread', request.threadId);
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), context.timeout);
+
+    // Build query parameters
+    const params = new URLSearchParams();
+    if (request.search !== undefined) {
+      params.append('search', request.search);
+    }
+    if (request.offset !== undefined) {
+      params.append('offset', request.offset.toString());
+    }
+    if (request.limit !== undefined) {
+      params.append('limit', request.limit.toString());
+    }
+
+    const queryString = params.toString();
+    const url = `${context.baseUrl}/v1/threads/${request.threadId}/messages${queryString ? '?' + queryString : ''}`;
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: buildHeaders(context as RequestContext, {
+        'Content-Type': 'application/json',
+      }),
+      ...getRequestCredentials(context as RequestContext),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      console.warn(
+        `TenxGraphClient: Checkpoint messages fetch failed with HTTP ${response.status}`
+      );
+      const error = await createErrorFromResponse(
+        response,
+        'Thread messages fetch failed',
+        '/v1/threads/{thread_id}/messages',
+        'GET'
+      );
+      throw error;
+    }
+
+    const data: ThreadMessagesResponse = await response.json();
+
+    if (context.debug) {
+      console.info('TenxGraphClient: Thread messages fetched successfully', data);
+    }
+
+    return data;
+  } catch (error) {
+    if (context.debug) {
+      console.debug('TenxGraphClient: Checkpoint messages fetch failed:', error);
+    }
+    throw error;
+  }
+}
+
+// Backward compatibility alias
+export const checkpointMessages = threadMessages;

package/src/endpoints/threadState.ts

@@ -0,0 +1,74 @@
+import { ResponseMetadata } from './metadata.js';
+import { AgentState } from '../agent.js';
+import { createErrorFromResponse } from '../errors.js';
+import { buildHeaders, getRequestCredentials, RequestContext } from '../request.js';
+
+export interface ThreadStateContext extends RequestContext {}
+
+export interface ThreadStateData {
+  state: AgentState;
+}
+
+export interface ThreadStateResponse {
+  data: ThreadStateData;
+  metadata: ResponseMetadata;
+}
+
+export async function threadState(
+  context: ThreadStateContext,
+  threadId: string | number
+): Promise<ThreadStateResponse> {
+  try {
+    if (context.debug) {
+      console.debug(`TenxGraphClient: Fetching thread state for thread ${threadId}`);
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), context.timeout);
+
+    const response = await fetch(`${context.baseUrl}/v1/threads/${threadId}/state`, {
+      method: 'GET',
+      headers: buildHeaders(context as RequestContext, {
+        'Content-Type': 'application/json',
+        accept: 'application/json',
+      }),
+      ...getRequestCredentials(context as RequestContext),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      console.warn(`TenxGraphClient: Thread state fetch failed with HTTP ${response.status}`);
+      const error = await createErrorFromResponse(
+        response,
+        'Thread state fetch failed',
+        '/v1/threads/{thread_id}/state',
+        'GET'
+      );
+      throw error;
+    }
+
+    const data: ThreadStateResponse = await response.json();
+
+    if (context.debug) {
+      console.info(
+        `TenxGraphClient: Thread state fetched successfully for thread ${threadId}`,
+        data
+      );
+    }
+
+    return data;
+  } catch (error) {
+    if ((error as Error).name === 'AbortError') {
+      console.warn(`TenxGraphClient: Thread state fetch timeout after ${context.timeout}ms`);
+      throw new Error(`Request timeout after ${context.timeout}ms`);
+    }
+
+    if (context.debug) {
+      console.debug(`TenxGraphClient: Thread state fetch failed:`, error);
+    }
+
+    throw error;
+  }
+}

package/src/endpoints/threads.ts

@@ -0,0 +1,112 @@
+import { ResponseMetadata } from './metadata.js';
+import { createErrorFromResponse } from '../errors.js';
+import { buildHeaders, getRequestCredentials, RequestContext } from '../request.js';
+
+export interface ThreadsContext extends RequestContext {}
+
+export interface ThreadsRequest {
+  search?: string;
+  offset?: number;
+  limit?: number;
+}
+
+export interface ThreadItem {
+  thread_id: string;
+  thread_name: string | null;
+  user_id: string | null;
+  metadata: Record<string, any> | null;
+  updated_at: string | null;
+  run_id: string | null;
+}
+
+export interface ThreadsData {
+  threads: ThreadItem[];
+}
+
+export interface ThreadsResponse {
+  data: ThreadsData;
+  metadata: ResponseMetadata;
+}
+
+/**
+ * Fetch list of threads with optional search and pagination
+ * GET /v1/threads
+ */
+export async function threads(
+  context: ThreadsContext,
+  request?: ThreadsRequest
+): Promise<ThreadsResponse> {
+  try {
+    if (context.debug) {
+      console.debug('TenxGraphClient: Fetching threads list');
+      if (request?.search) {
+        console.debug(`  Search: ${request.search}`);
+      }
+      if (request?.offset !== undefined) {
+        console.debug(`  Offset: ${request.offset}`);
+      }
+      if (request?.limit !== undefined) {
+        console.debug(`  Limit: ${request.limit}`);
+      }
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), context.timeout);
+
+    // Build query parameters
+    const params = new URLSearchParams();
+    if (request?.search) {
+      params.append('search', request.search);
+    }
+    if (request?.offset !== undefined) {
+      params.append('offset', request.offset.toString());
+    }
+    if (request?.limit !== undefined) {
+      params.append('limit', request.limit.toString());
+    }
+
+    const queryString = params.toString();
+    const url = `${context.baseUrl}/v1/threads${queryString ? `?${queryString}` : ''}`;
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: buildHeaders(context as RequestContext, {
+        'Content-Type': 'application/json',
+        accept: 'application/json',
+      }),
+      ...getRequestCredentials(context as RequestContext),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      console.warn(`TenxGraphClient: Threads list fetch failed with HTTP ${response.status}`);
+      const error = await createErrorFromResponse(
+        response,
+        'Threads list fetch failed',
+        '/v1/threads',
+        'GET'
+      );
+      throw error;
+    }
+
+    const data: ThreadsResponse = await response.json();
+
+    if (context.debug) {
+      console.info('TenxGraphClient: Threads list fetched successfully', data);
+      console.debug(`  Found ${data.data.threads.length} threads`);
+    }
+
+    return data;
+  } catch (error) {
+    if ((error as Error).name === 'AbortError') {
+      console.warn(`TenxGraphClient: Threads list fetch timeout after ${context.timeout}ms`);
+      throw new Error(`Request timeout after ${context.timeout}ms`);
+    }
+    if (context.debug) {
+      console.debug('TenxGraphClient: Threads list fetch failed:', error);
+    }
+    throw error;
+  }
+}

package/src/endpoints/updateMemory.ts

@@ -0,0 +1,90 @@
+import { ResponseMetadata } from './metadata.js';
+import { createErrorFromResponse } from '../errors.js';
+import { buildHeaders, getRequestCredentials, RequestContext } from '../request.js';
+
+export interface UpdateMemoryContext extends RequestContext {}
+
+export interface UpdateMemoryRequest {
+  memoryId: string;
+  config?: Record<string, any>;
+  options?: Record<string, any>;
+  content: string;
+  metadata?: Record<string, any>;
+}
+
+export interface UpdateMemoryData {
+  success: boolean;
+  data: Record<string, any>;
+}
+
+export interface UpdateMemoryResponse {
+  data: UpdateMemoryData;
+  metadata: ResponseMetadata;
+}
+
+export async function updateMemory(
+  context: UpdateMemoryContext,
+  request: UpdateMemoryRequest
+): Promise<UpdateMemoryResponse> {
+  try {
+    if (context.debug) {
+      console.debug('TenxGraphClient: Updating memory with ID:', request.memoryId);
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), context.timeout);
+
+    const url = `${context.baseUrl}/v1/store/memories/${request.memoryId}`;
+
+    // Prepare request body
+    const body = {
+      config: request.config || {},
+      options: request.options || {},
+      content: request.content,
+      metadata: request.metadata || {},
+    };
+
+    if (context.debug) {
+      console.debug('TenxGraphClient: Request payload:', JSON.stringify(body, null, 2));
+    }
+
+    const response = await fetch(url, {
+      method: 'PUT',
+      headers: buildHeaders(context as RequestContext, {
+        'Content-Type': 'application/json',
+      }),
+      ...getRequestCredentials(context as RequestContext),
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      console.warn(`TenxGraphClient: Update memory failed with HTTP ${response.status}`);
+      const error = await createErrorFromResponse(
+        response,
+        'Update memory request failed',
+        '/v1/memory/{memory_id}',
+        'PUT'
+      );
+      throw error;
+    }
+
+    const data: UpdateMemoryResponse = await response.json();
+
+    if (context.debug) {
+      console.info('TenxGraphClient: Memory updated successfully', {
+        memory_id: request.memoryId,
+        success: data.data.success,
+      });
+    }
+
+    return data;
+  } catch (error) {
+    if (context.debug) {
+      console.debug('TenxGraphClient: Update memory failed:', error);
+    }
+    throw error;
+  }
+}

package/src/endpoints/updateThreadState.ts

@@ -0,0 +1,82 @@
+import { ResponseMetadata } from './metadata.js';
+import { AgentState } from '../agent.js';
+import { createErrorFromResponse } from '../errors.js';
+import { buildHeaders, getRequestCredentials, RequestContext } from '../request.js';
+
+export interface UpdateThreadStateContext extends RequestContext {}
+
+export interface UpdateThreadStateRequest {
+  config: Record<string, any>;
+  state: AgentState;
+}
+
+export interface UpdateThreadStateData {
+  state: AgentState;
+}
+
+export interface UpdateThreadStateResponse {
+  data: UpdateThreadStateData;
+  metadata: ResponseMetadata;
+}
+
+export async function updateThreadState(
+  context: UpdateThreadStateContext,
+  threadId: string | number,
+  request: UpdateThreadStateRequest
+): Promise<UpdateThreadStateResponse> {
+  try {
+    if (context.debug) {
+      console.debug(`TenxGraphClient: Updating thread state for thread ${threadId}`);
+      console.debug(`TenxGraphClient: Request payload:`, JSON.stringify(request, null, 2));
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), context.timeout);
+
+    const response = await fetch(`${context.baseUrl}/v1/threads/${threadId}/state`, {
+      method: 'PUT',
+      headers: buildHeaders(context as RequestContext, {
+        'Content-Type': 'application/json',
+        accept: 'application/json',
+      }),
+      ...getRequestCredentials(context as RequestContext),
+      body: JSON.stringify(request),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      console.warn(`TenxGraphClient: Thread state update failed with HTTP ${response.status}`);
+      const error = await createErrorFromResponse(
+        response,
+        'Thread state update failed',
+        '/v1/threads/{thread_id}/state',
+        'PUT'
+      );
+      throw error;
+    }
+
+    const data: UpdateThreadStateResponse = await response.json();
+
+    if (context.debug) {
+      console.info(
+        `TenxGraphClient: Thread state updated successfully for thread ${threadId}`,
+        data
+      );
+    }
+
+    return data;
+  } catch (error) {
+    if ((error as Error).name === 'AbortError') {
+      console.warn(`TenxGraphClient: Thread state update timeout after ${context.timeout}ms`);
+      throw new Error(`Request timeout after ${context.timeout}ms`);
+    }
+
+    if (context.debug) {
+      console.debug(`TenxGraphClient: Thread state update failed:`, error);
+    }
+
+    throw error;
+  }
+}