10xgraph-client 0.0.0-stage → 0.6.0

package/src/compat.ts

@@ -0,0 +1,35 @@
+/**
+ * Deprecated names from `@10xscale/agentflow-client`, kept so code written against the old
+ * package keeps compiling after switching the import to `10xgraph-client`.
+ * Each alias is the same class or type as its new name, so `instanceof` checks still work.
+ * All of them will be removed in 2.0.
+ */
+import { TenxGraphClient, TenxGraphConfig } from './client.js';
+import { TenxGraphError } from './errors.js';
+import {
+  TenxGraphAuth,
+  TenxGraphBasicAuth,
+  TenxGraphBearerAuth,
+  TenxGraphHeaderAuth,
+} from './request.js';
+
+/** @deprecated Use `TenxGraphClient`. Removed in 2.0. */
+export const AgentFlowClient = TenxGraphClient;
+/** @deprecated Use `TenxGraphClient`. Removed in 2.0. */
+export type AgentFlowClient = TenxGraphClient;
+
+/** @deprecated Use `TenxGraphError`. Removed in 2.0. */
+export const AgentFlowError = TenxGraphError;
+/** @deprecated Use `TenxGraphError`. Removed in 2.0. */
+export type AgentFlowError = TenxGraphError;
+
+/** @deprecated Use `TenxGraphConfig`. Removed in 2.0. */
+export type AgentFlowConfig = TenxGraphConfig;
+/** @deprecated Use `TenxGraphAuth`. Removed in 2.0. */
+export type AgentFlowAuth = TenxGraphAuth;
+/** @deprecated Use `TenxGraphBearerAuth`. Removed in 2.0. */
+export type AgentFlowBearerAuth = TenxGraphBearerAuth;
+/** @deprecated Use `TenxGraphBasicAuth`. Removed in 2.0. */
+export type AgentFlowBasicAuth = TenxGraphBasicAuth;
+/** @deprecated Use `TenxGraphHeaderAuth`. Removed in 2.0. */
+export type AgentFlowHeaderAuth = TenxGraphHeaderAuth;

package/src/endpoints/addThreadMessages.ts

@@ -0,0 +1,83 @@
+import { ResponseMetadata } from './metadata.js';
+import { Message } from '../message.js';
+import { createErrorFromResponse } from '../errors.js';
+import { buildHeaders, getRequestCredentials, RequestContext } from '../request.js';
+
+export interface AddThreadMessagesContext extends RequestContext {}
+
+export interface AddThreadMessagesRequest {
+  threadId: string | number;
+  config: Record<string, any>;
+  messages: Message[];
+  metadata?: Record<string, any>;
+}
+
+export interface AddThreadMessagesData {
+  success: boolean;
+  message: string;
+  data: Record<string, any>;
+}
+
+export interface AddThreadMessagesResponse {
+  data: AddThreadMessagesData;
+  metadata: ResponseMetadata;
+}
+
+export async function addThreadMessages(
+  context: AddThreadMessagesContext,
+  request: AddThreadMessagesRequest
+): Promise<AddThreadMessagesResponse> {
+  try {
+    if (context.debug) {
+      console.debug('TenxGraphClient: Adding thread messages to thread', request.threadId);
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), context.timeout);
+
+    const url = `${context.baseUrl}/v1/threads/${request.threadId}/messages`;
+
+    // Prepare request body
+    const body = {
+      config: request.config,
+      messages: request.messages,
+      metadata: request.metadata || {},
+    };
+
+    const response = await fetch(url, {
+      method: 'POST',
+      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: Add checkpoint messages failed with HTTP ${response.status}`);
+      const error = await createErrorFromResponse(
+        response,
+        'Add thread messages failed',
+        '/v1/threads/{thread_id}/messages',
+        'POST'
+      );
+      throw error;
+    }
+
+    const data: AddThreadMessagesResponse = await response.json();
+
+    if (context.debug) {
+      console.info('TenxGraphClient: Thread messages added successfully', data);
+    }
+
+    return data;
+  } catch (error) {
+    if (context.debug) {
+      console.debug('TenxGraphClient: Add checkpoint messages failed:', error);
+    }
+    throw error;
+  }
+}

package/src/endpoints/clearThreadState.ts

@@ -0,0 +1,75 @@
+import { ResponseMetadata } from './metadata.js';
+import { createErrorFromResponse } from '../errors.js';
+import { buildHeaders, getRequestCredentials, RequestContext } from '../request.js';
+
+export interface ClearThreadStateContext extends RequestContext {}
+
+export interface ClearThreadStateData {
+  success: boolean;
+  message: string;
+  data: boolean;
+}
+
+export interface ClearThreadStateResponse {
+  data: ClearThreadStateData;
+  metadata: ResponseMetadata;
+}
+
+export async function clearThreadState(
+  context: ClearThreadStateContext,
+  threadId: string | number
+): Promise<ClearThreadStateResponse> {
+  try {
+    if (context.debug) {
+      console.debug(`TenxGraphClient: Clearing 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: 'DELETE',
+      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 clear failed with HTTP ${response.status}`);
+      const error = await createErrorFromResponse(
+        response,
+        'Thread state clear failed',
+        '/v1/threads/{thread_id}/state',
+        'DELETE'
+      );
+      throw error;
+    }
+
+    const data: ClearThreadStateResponse = await response.json();
+
+    if (context.debug) {
+      console.info(
+        `TenxGraphClient: Thread state cleared successfully for thread ${threadId}`,
+        data
+      );
+    }
+
+    return data;
+  } catch (error) {
+    if ((error as Error).name === 'AbortError') {
+      console.warn(`TenxGraphClient: Thread state clear timeout after ${context.timeout}ms`);
+      throw new Error(`Request timeout after ${context.timeout}ms`);
+    }
+
+    if (context.debug) {
+      console.debug(`TenxGraphClient: Thread state clear failed:`, error);
+    }
+
+    throw error;
+  }
+}

package/src/endpoints/deleteMemory.ts

@@ -0,0 +1,91 @@
+import { ResponseMetadata } from './metadata.js';
+import { createErrorFromResponse } from '../errors.js';
+import { buildHeaders, getRequestCredentials, RequestContext } from '../request.js';
+
+export interface DeleteMemoryContext extends RequestContext {}
+
+export interface DeleteMemoryRequest {
+  memoryId: string;
+  config?: Record<string, any>;
+  options?: Record<string, any>;
+}
+
+export interface DeleteMemoryData {
+  success: boolean;
+  data: string;
+}
+
+export interface DeleteMemoryResponse {
+  data: DeleteMemoryData;
+  metadata: ResponseMetadata;
+}
+
+export async function deleteMemory(
+  context: DeleteMemoryContext,
+  request: DeleteMemoryRequest
+): Promise<DeleteMemoryResponse> {
+  try {
+    if (context.debug) {
+      console.debug('TenxGraphClient: Deleting 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 || {},
+    };
+
+    if (context.debug) {
+      console.debug('TenxGraphClient: Delete request payload:', JSON.stringify(body, null, 2));
+    }
+
+    const response = await fetch(url, {
+      method: 'DELETE',
+      headers: buildHeaders(context as RequestContext, {
+        'Content-Type': 'application/json',
+        accept: 'application/json',
+      }),
+      ...getRequestCredentials(context as RequestContext),
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      console.warn(`TenxGraphClient: Delete memory failed with HTTP ${response.status}`);
+      const error = await createErrorFromResponse(
+        response,
+        'Delete memory request failed',
+        '/v1/memory/{memory_id}',
+        'DELETE'
+      );
+      throw error;
+    }
+
+    const data: DeleteMemoryResponse = await response.json();
+
+    if (context.debug) {
+      console.info('TenxGraphClient: Memory deleted successfully', {
+        memory_id: request.memoryId,
+        success: data.data.success,
+      });
+    }
+
+    return data;
+  } catch (error) {
+    if ((error as Error).name === 'AbortError') {
+      console.warn(`TenxGraphClient: Delete memory timeout after ${context.timeout}ms`);
+      throw new Error(`Request timeout after ${context.timeout}ms`);
+    }
+    if (context.debug) {
+      console.debug('TenxGraphClient: Delete memory failed:', error);
+    }
+    throw error;
+  }
+}

package/src/endpoints/deleteThread.ts

@@ -0,0 +1,78 @@
+import { ResponseMetadata } from './metadata.js';
+import { createErrorFromResponse } from '../errors.js';
+import { buildHeaders, getRequestCredentials, RequestContext } from '../request.js';
+
+export interface DeleteThreadContext extends RequestContext {}
+
+export interface DeleteThreadRequest {
+  threadId: string | number;
+  config?: Record<string, any>;
+}
+
+export interface DeleteThreadData {
+  success: boolean;
+  message: string;
+  data: boolean;
+}
+
+export interface DeleteThreadResponse {
+  data: DeleteThreadData;
+  metadata: ResponseMetadata;
+}
+
+export async function deleteThread(
+  context: DeleteThreadContext,
+  request: DeleteThreadRequest
+): Promise<DeleteThreadResponse> {
+  try {
+    if (context.debug) {
+      console.debug('TenxGraphClient: Deleting thread', `thread: ${request.threadId}`);
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), context.timeout);
+
+    const url = `${context.baseUrl}/v1/threads/${request.threadId}`;
+
+    const response = await fetch(url, {
+      method: 'DELETE',
+      headers: buildHeaders(context as RequestContext, {
+        'Content-Type': 'application/json',
+        accept: 'application/json',
+      }),
+      ...getRequestCredentials(context as RequestContext),
+      body: JSON.stringify({ config: request.config || {} }),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      console.warn(`TenxGraphClient: Delete thread failed with HTTP ${response.status}`);
+      const error = await createErrorFromResponse(
+        response,
+        'Delete thread failed',
+        '/v1/threads/{thread_id}',
+        'DELETE'
+      );
+      throw error;
+    }
+
+    const data: DeleteThreadResponse = await response.json();
+
+    if (context.debug) {
+      console.info('TenxGraphClient: Thread deleted successfully', data);
+    }
+
+    return data;
+  } catch (error) {
+    if ((error as Error).name === 'AbortError') {
+      console.warn(`TenxGraphClient: Delete thread timeout after ${context.timeout}ms`);
+      throw new Error(`Request timeout after ${context.timeout}ms`);
+    }
+    if (context.debug) {
+      console.debug('TenxGraphClient: Delete thread failed:', error);
+    }
+    throw error;
+  }
+}

package/src/endpoints/deleteThreadMessage.ts

@@ -0,0 +1,83 @@
+import { ResponseMetadata } from './metadata.js';
+import { createErrorFromResponse } from '../errors.js';
+import { buildHeaders, getRequestCredentials, RequestContext } from '../request.js';
+
+export interface DeleteThreadMessageContext extends RequestContext {}
+
+export interface DeleteThreadMessageRequest {
+  threadId: string | number;
+  messageId: string;
+  config?: Record<string, any>;
+}
+
+export interface DeleteThreadMessageData {
+  success: boolean;
+  message: string;
+  data: Record<string, any>;
+}
+
+export interface DeleteThreadMessageResponse {
+  data: DeleteThreadMessageData;
+  metadata: ResponseMetadata;
+}
+
+export async function deleteThreadMessage(
+  context: DeleteThreadMessageContext,
+  request: DeleteThreadMessageRequest
+): Promise<DeleteThreadMessageResponse> {
+  try {
+    if (context.debug) {
+      console.debug(
+        'TenxGraphClient: Deleting thread message',
+        `thread: ${request.threadId}`,
+        `message: ${request.messageId}`
+      );
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), context.timeout);
+
+    const url = `${context.baseUrl}/v1/threads/${request.threadId}/messages/${request.messageId}`;
+
+    const response = await fetch(url, {
+      method: 'DELETE',
+      headers: buildHeaders(context as RequestContext, {
+        'Content-Type': 'application/json',
+        accept: 'application/json',
+      }),
+      ...getRequestCredentials(context as RequestContext),
+      body: JSON.stringify({ config: request.config || {} }),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      console.warn(`TenxGraphClient: Delete thread message failed with HTTP ${response.status}`);
+      const error = await createErrorFromResponse(
+        response,
+        'Delete thread message failed',
+        '/v1/threads/{thread_id}/messages/{message_id}',
+        'DELETE'
+      );
+      throw error;
+    }
+
+    const data: DeleteThreadMessageResponse = await response.json();
+
+    if (context.debug) {
+      console.info('TenxGraphClient: Thread message deleted successfully', data);
+    }
+
+    return data;
+  } catch (error) {
+    if ((error as Error).name === 'AbortError') {
+      console.warn(`TenxGraphClient: Delete thread message timeout after ${context.timeout}ms`);
+      throw new Error(`Request timeout after ${context.timeout}ms`);
+    }
+    if (context.debug) {
+      console.debug('TenxGraphClient: Delete thread message failed:', error);
+    }
+    throw error;
+  }
+}