10xgraph-client 0.6.0 → 1.0.0-rc.2

package/dist/cjs/client.d.ts

@@ -0,0 +1,533 @@
+import { ToolHandler, ToolRegistration } from './tools.js';
+import { Message } from './message.js';
+import { PingResponse } from './endpoints/ping.js';
+import { GraphResponse } from './endpoints/graph.js';
+import { GraphToolsResponse } from './endpoints/graphTools.js';
+import { ObservabilityResponse } from './endpoints/observability.js';
+import { StateSchemaResponse } from './endpoints/stateSchema.js';
+import { ThreadStateResponse } from './endpoints/threadState.js';
+import { UpdateThreadStateResponse } from './endpoints/updateThreadState.js';
+import { ClearThreadStateResponse } from './endpoints/clearThreadState.js';
+import { ThreadMessagesRequest, ThreadMessagesResponse } from './endpoints/threadMessages.js';
+import { AddThreadMessagesResponse } from './endpoints/addThreadMessages.js';
+import { ThreadMessageResponse } from './endpoints/threadMessage.js';
+import { ThreadDetailsResponse } from './endpoints/threadDetails.js';
+import { DeleteThreadMessageResponse } from './endpoints/deleteThreadMessage.js';
+import { UpdateThreadMessageFeedbackResponse } from './endpoints/updateThreadMessageFeedback.js';
+import { DeleteThreadResponse } from './endpoints/deleteThread.js';
+import { ThreadsRequest, ThreadsResponse } from './endpoints/threads.js';
+import { InvokeResult, InvokeCallback } from './endpoints/invoke.js';
+import { StreamChunk } from './endpoints/stream.js';
+import { RealtimeSession, RealtimeInit, RealtimeOptions } from './endpoints/realtime.js';
+import type { WebSocketImpl } from './ws.js';
+import { StoreMemoryRequest, StoreMemoryResponse } from './endpoints/storeMemory.js';
+import { SearchMemoryRequest, SearchMemoryResponse } from './endpoints/searchMemory.js';
+import { GetMemoryResponse } from './endpoints/getMemory.js';
+import { UpdateMemoryResponse } from './endpoints/updateMemory.js';
+import { DeleteMemoryResponse } from './endpoints/deleteMemory.js';
+import { ListMemoriesResponse } from './endpoints/listMemories.js';
+import { ForgetMemoriesResponse } from './endpoints/forgetMemories.js';
+import { StopGraphResponse } from './endpoints/stopGraph.js';
+import { FixGraphResponse } from './endpoints/fixGraph.js';
+import { ListFilesRequest, ListFilesResponse, FileUploadResponse, FileAccessUrlResponse, FileInfoResponse, MultimodalConfigResponse } from './endpoints/files.js';
+import { DeleteFileResponse } from './endpoints/deleteFile.js';
+import { TenxGraphAuth, RequestOptions } from './request.js';
+export interface TenxGraphConfig {
+    baseUrl: string;
+    /**
+     * Bearer token, or a function returning one. A function is called before every request,
+     * so a short-lived JWT can be refreshed without rebuilding the client.
+     */
+    authToken?: string | null | (() => string | null | undefined);
+    auth?: TenxGraphAuth | null;
+    headers?: HeadersInit;
+    credentials?: RequestCredentials;
+    timeout?: number;
+    debug?: boolean;
+    webSocketImpl?: WebSocketImpl;
+}
+export declare class TenxGraphClient {
+    private baseUrl;
+    private authToken?;
+    private auth?;
+    private headers?;
+    private credentials?;
+    private timeout;
+    private debug;
+    private webSocketImpl?;
+    private toolExecutor;
+    constructor(config: TenxGraphConfig);
+    /**
+     * Replace the bearer token used for later requests (for example after a refresh).
+     * Does not touch an open stream or socket.
+     */
+    setAuthToken(token: string | null | (() => string | null | undefined)): void;
+    /** Drop the bearer token and any `auth` credentials. Later requests are sent without them. */
+    clearAuth(): void;
+    private createContext;
+    /**
+     * Register a tool for remote execution
+     */
+    registerTool(registration: ToolRegistration): void;
+    /**
+     * Register only the client-side implementation of a remote tool.
+     * The trusted schema must be declared in the server's 10xgraph.json.
+     */
+    registerToolHandler(name: string, handler: ToolHandler): void;
+    /**
+     * Ping the server to check connectivity
+     */
+    ping(options?: RequestOptions): Promise<PingResponse>;
+    /**
+     * Fetch the agent graph
+     */
+    graph(options?: RequestOptions): Promise<GraphResponse>;
+    /**
+     * Fetch the tools exposed by the graph's tool nodes, grouped by node.
+     * Each tool is tagged with its source (local / mcp / remote).
+     */
+    graphTools(options?: RequestOptions): Promise<GraphToolsResponse>;
+    /**
+     * Fetch the reconstructed observability trace (spans, events, cost) for a
+     * thread. Returns the latest run by default, or a specific run when given.
+     */
+    observability(threadId: string, runId?: string, options?: RequestOptions): Promise<ObservabilityResponse>;
+    /**
+     * Stop a running graph execution for a specific thread
+     * @param threadId - The ID of the thread to stop execution for
+     * @param config - Optional configuration for the stop operation
+     * @returns StopGraphResponse with the stop operation result
+     */
+    stopGraph(threadId: string, config?: Record<string, any>, options?: RequestOptions): Promise<StopGraphResponse>;
+    /**
+     * Repair a thread whose run stopped after the model asked for tools but before
+     * the results were saved. The server removes assistant messages with unanswered
+     * tool calls (matched by tool call id) and tool results whose call no longer
+     * exists. Unanswered calls of the latest assistant message are kept while the
+     * thread is paused (interrupt, client tool call or human approval). When nothing
+     * needs fixing, removed_count is 0 and the state is not written.
+     *
+     * @param threadId - The ID of the thread to fix state for
+     * @param config - Optional configuration for the fix operation
+     * @returns FixGraphResponse with the fix operation result including removed_count
+     */
+    fixGraph(threadId: string, config?: Record<string, any>, options?: RequestOptions): Promise<FixGraphResponse>;
+    /**
+       *
+  
+      /**
+       * Fetch the state schema of the agent
+       */
+    graphStateSchema(options?: RequestOptions): Promise<StateSchemaResponse>;
+    /**
+     * ***************** ALL THREAD APIS *****************
+     */
+    /**
+     * Fetch the state of a specific thread
+     * @param threadId - The ID of the thread to fetch state for
+     * @returns ThreadStateResponse containing the thread's current state
+     */
+    threadState(threadId: string | number, options?: RequestOptions): Promise<ThreadStateResponse>;
+    /**
+     * Update the state of a specific thread (checkpoint)
+     * @param threadId - The ID of the thread to update
+     * @param config - Configuration map for the thread
+     * @param state - New AgentState for the thread
+     * @returns UpdateThreadStateResponse with the updated state
+     */
+    updateThreadState(threadId: string | number, config: Record<string, any>, state: any, // AgentState
+    options?: RequestOptions): Promise<UpdateThreadStateResponse>;
+    /**
+     * Clear the state of a specific thread (delete checkpoint)
+     * @param threadId - The ID of the thread to clear state for
+     * @returns ClearThreadStateResponse with the clear operation result
+     */
+    clearThreadState(threadId: string | number, options?: RequestOptions): Promise<ClearThreadStateResponse>;
+    /**
+     * Fetch details for a specific thread
+     * @param threadId - The ID of the thread to fetch
+     * @returns ThreadDetailsResponse containing thread details
+     */
+    threadDetails(threadId: string | number, options?: RequestOptions): Promise<ThreadDetailsResponse>;
+    /**
+     * Fetch list of threads with optional search and pagination
+     * @param search - Optional search term to filter threads
+     * @param offset - Optional offset for pagination (default 0)
+     * @param limit - Optional limit for pagination (default no limit)
+     * @returns ThreadsResponse containing the list of threads and metadata
+     */
+    threads(): Promise<ThreadsResponse>;
+    threads(request: ThreadsRequest, options?: RequestOptions): Promise<ThreadsResponse>;
+    /**
+     * Fetch messages from a specific thread with optional search and pagination
+     * @param threadId - The ID of the thread to fetch messages from
+     * @param search - Optional search term to filter messages
+     * @param offset - Optional offset for pagination (default 0)
+     * @param limit - Optional limit for pagination (default no limit)
+     * @returns ThreadMessagesResponse containing the messages and metadata
+     */
+    threadMessages(threadId: string | number, request: Omit<ThreadMessagesRequest, 'threadId'>, options?: RequestOptions): Promise<ThreadMessagesResponse>;
+    /**
+     * Add messages to a specific thread checkpoint
+     *
+     * @deprecated Requires the `checkpointer:import` scope (admin only) in 10xgraph-api releases after 0.9.0.
+     * Use `updateThreadMessageFeedback` to attach feedback to a message.
+     *
+     * @param threadId - The ID of the thread to add messages to
+     * @param messages - Array of messages to add to the checkpoint
+     * @param config - Configuration map for the checkpoint
+     * @param metadata - Optional metadata for the checkpoint
+     * @returns AddCheckpointMessagesResponse containing the operation result
+     */
+    addThreadMessages(threadId: string | number, messages: Message[], config?: Record<string, any>, metadata?: Record<string, any>, options?: RequestOptions): Promise<AddThreadMessagesResponse>;
+    /**
+     * Fetch a specific message from a thread by message ID
+     * @param threadId - The ID of the thread
+     * @param messageId - The ID of the message to fetch
+     * @returns ThreadMessageResponse containing the message and metadata
+     */
+    singleMessage(threadId: string | number, messageId: string, options?: RequestOptions): Promise<ThreadMessageResponse>;
+    /**
+     * Delete a specific message from a thread
+     * @param threadId - The ID of the thread
+     * @param messageId - The ID of the message to delete
+     * @param config - Optional configuration map to send with the request body
+     * @returns DeleteThreadMessageResponse containing the deletion result
+     */
+    deleteMessage(threadId: string | number, messageId: string, config?: Record<string, any>, options?: RequestOptions): Promise<DeleteThreadMessageResponse>;
+    /**
+     * Replace the feedback attached to a message (`message.metadata.feedback`).
+     * Nothing else on the message changes.
+     * @param threadId - The ID of the thread
+     * @param messageId - The ID of the message to attach feedback to
+     * @param feedback - Any JSON object, at most 8192 serialized bytes and nesting depth 10
+     * @returns UpdateThreadMessageFeedbackResponse containing the updated message
+     */
+    updateThreadMessageFeedback(threadId: string | number, messageId: string, feedback: Record<string, unknown>, options?: RequestOptions): Promise<UpdateThreadMessageFeedbackResponse>;
+    /**
+     * Delete a specific thread
+     * @param threadId - The ID of the thread to delete
+     * @param config - Optional configuration map to send with the request body
+     * @returns DeleteThreadResponse containing the deletion result
+     */
+    deleteThread(threadId: string | number, config?: Record<string, any>, options?: RequestOptions): Promise<DeleteThreadResponse>;
+    /**
+     * Invoke the agent graph with automatic tool execution loop
+     * @param messages - Array of messages to send
+     * @param options - Invoke options
+     * @returns InvokeResult with all messages and intermediate steps
+     */
+    invoke(messages: Message[], options?: {
+        initial_state?: Record<string, any>;
+        config?: Record<string, any>;
+        recursion_limit?: number;
+        on_busy?: 'wait' | 'cancel';
+        resume?: unknown;
+        interrupt_id?: string;
+        response_granularity?: 'full' | 'partial' | 'low';
+        /** Abort to cancel the request (and the open stream or socket). */
+        signal?: AbortSignal;
+        onPartialResult?: InvokeCallback;
+    }): Promise<InvokeResult>;
+    /**
+     * Stream invoke to the agent graph
+     * Returns an async iterable that yields stream chunks as they arrive
+     *
+     * @param messages - Array of messages to send
+     * @param options - Stream options
+     * @returns AsyncGenerator of StreamChunk objects
+     *
+     * @example
+     * ```ts
+     * const stream = client.streamInvoke([userMessage], {
+     *   initial_state: {},
+     *   response_granularity: 'low'
+     * });
+     *
+     * for await (const chunk of stream) {
+     *   if (chunk.event === 'message') {
+     *     console.log('Message:', chunk.message?.content);
+     *   } else if (chunk.event === 'updates') {
+     *     console.log('State updated:', chunk.state);
+     *   }
+     * }
+     * ```
+     */
+    stream(messages: Message[], options?: {
+        initial_state?: Record<string, any>;
+        config?: Record<string, any>;
+        recursion_limit?: number;
+        on_busy?: 'wait' | 'cancel';
+        resume?: unknown;
+        interrupt_id?: string;
+        response_granularity?: 'full' | 'partial' | 'low';
+        /** Abort to cancel the request (and the open stream or socket). */
+        signal?: AbortSignal;
+    }): AsyncGenerator<StreamChunk, void, unknown>;
+    /**
+     * Stream invoke via a persistent WebSocket connection.
+     *
+     * Identical API to ``stream()`` — same message types, same chunk format,
+     * same tool-execution loop — but uses a single WebSocket instead of one
+     * HTTP request per tool-call iteration.  Switch from ``stream()`` to
+     * ``wsStream()`` by changing one method name; everything else stays the
+     * same.
+     *
+     * The WebSocket stays open for the full lifecycle of the call (fresh run +
+     * any resume runs triggered by remote tool calls).  The server sends a
+     * ``{ event:"updates", data:{ status:"done" } }`` chunk after each run so
+     * the client knows when to send the next resume request.
+     *
+     * Auth: the bearer token is sent via the ``10xgraph-bearer`` WebSocket
+     * subprotocol (browser-safe; never placed in the URL), with the Authorization
+     * header also set on Node runtimes.
+     *
+     * @param messages - Array of messages to send
+     * @param options - Same options as ``stream()``
+     * @returns AsyncGenerator of StreamChunk objects
+     *
+     * @example
+     * ```ts
+     * const stream = client.wsStream([userMessage], {
+     *   config: { thread_id: 'my-thread' },
+     *   response_granularity: 'low',
+     * });
+     *
+     * for await (const chunk of stream) {
+     *   if (chunk.event === 'message') {
+     *     console.log('Message:', chunk.message?.content);
+     *   }
+     * }
+     * ```
+     */
+    wsStream(messages: Message[], options?: {
+        initial_state?: Record<string, any>;
+        config?: Record<string, any>;
+        recursion_limit?: number;
+        on_busy?: 'wait' | 'cancel';
+        resume?: unknown;
+        interrupt_id?: string;
+        response_granularity?: 'full' | 'partial' | 'low';
+        /** Abort to cancel the request (and the open stream or socket). */
+        signal?: AbortSignal;
+    }): AsyncGenerator<StreamChunk, void, unknown>;
+    /**
+     * Open a realtime (audio-to-audio) session over ``/v1/graph/live``.
+     *
+     * Transport-only: send PCM16 input via ``session.sendAudio(...)`` and receive
+     * PCM16 output via ``session.on('audio', ...)``. Mic capture and audio playback
+     * are the caller's responsibility. The session auto-reconnects (with backoff)
+     * on an unexpected drop and resumes the same ``thread_id``.
+     *
+     * @example
+     * ```ts
+     * const session = client.realtime({ model: 'gemini-3.8-live' });
+     * session.on('audio', (pcm) => speaker.write(pcm));
+     * session.on('output_transcript', (e) => console.log(e.text));
+     * await session.ready;
+     * session.sendAudio(micChunk);
+     * ```
+     */
+    realtime(init: RealtimeInit, options?: RealtimeOptions): RealtimeSession;
+    /**
+     * Store a memory in the agent's memory system
+     *
+     * @param request - Memory storage request parameters
+     * @returns Promise<StoreMemoryResponse> containing the memory_id
+     *
+     * @example
+     * ```ts
+     * const result = await client.storeMemory({
+     *   content: "User prefers dark mode",
+     *   memory_type: MemoryType.SEMANTIC,
+     *   category: "preferences",
+     *   metadata: { source: "user_settings" }
+     * });
+     * console.log('Memory stored with ID:', result.data.memory_id);
+     * ```
+     */
+    storeMemory(request: StoreMemoryRequest, options?: RequestOptions): Promise<StoreMemoryResponse>;
+    /**
+     * Search for memories in the agent's memory system
+     *
+     * @param request - Memory search request parameters
+     * @returns Promise<SearchMemoryResponse> containing matching memories
+     *
+     * @example
+     * ```ts
+     * const results = await client.searchMemory({
+     *   query: "dark mode preferences",
+     *   memory_type: MemoryType.SEMANTIC,
+     *   limit: 5,
+     *   retrieval_strategy: RetrievalStrategy.SIMILARITY
+     * });
+     * results.data.results.forEach(result => {
+     *   console.log('Memory:', result.content, 'Score:', result.score);
+     * });
+     * ```
+     */
+    searchMemory(request: SearchMemoryRequest, options?: RequestOptions): Promise<SearchMemoryResponse>;
+    /**
+     * Get a specific memory by ID
+     *
+     * @param memoryId - The ID of the memory to retrieve
+     * @param options - Optional config and options
+     * @returns Promise<GetMemoryResponse> containing the memory details
+     *
+     * @example
+     * ```ts
+     * const memory = await client.getMemory('mem-12345', {
+     *   config: { include_vector: true }
+     * });
+     * console.log('Memory:', memory.data.memory.content);
+     * console.log('Score:', memory.data.memory.score);
+     * ```
+     */
+    getMemory(memoryId: string, options?: {
+        config?: Record<string, any>;
+        options?: Record<string, any>;
+        signal?: AbortSignal;
+    }): Promise<GetMemoryResponse>;
+    /**
+     * Update an existing memory by ID
+     *
+     * @param memoryId - The ID of the memory to update
+     * @param content - The updated content for the memory
+     * @param options - Optional config, options, and metadata
+     * @returns Promise<UpdateMemoryResponse> containing success status and updated data
+     *
+     * @example
+     * ```ts
+     * const result = await client.updateMemory('mem-12345', 'Updated content', {
+     *   metadata: { tags: ['important', 'updated'] }
+     * });
+     * console.log('Update success:', result.data.success);
+     * ```
+     */
+    updateMemory(memoryId: string, content: string, options?: {
+        config?: Record<string, any>;
+        options?: Record<string, any>;
+        metadata?: Record<string, any>;
+        signal?: AbortSignal;
+    }): Promise<UpdateMemoryResponse>;
+    /**
+     * Delete a memory by ID
+     *
+     * @param memoryId - The ID of the memory to delete
+     * @param options - Optional config and options
+     * @returns Promise<DeleteMemoryResponse> containing success status and deletion confirmation
+     *
+     * @example
+     * ```ts
+     * const result = await client.deleteMemory('mem-12345', {
+     *   config: { soft_delete: true }
+     * });
+     * console.log('Delete success:', result.data.success);
+     * console.log('Deleted:', result.data.data);
+     * ```
+     */
+    deleteMemory(memoryId: string, options?: {
+        config?: Record<string, any>;
+        options?: Record<string, any>;
+        signal?: AbortSignal;
+    }): Promise<DeleteMemoryResponse>;
+    /**
+     * List all memories with optional pagination
+     *
+     * @param options - Optional config, options, and limit
+     * @returns Promise<ListMemoriesResponse> containing array of memories
+     *
+     * @example
+     * ```ts
+     * const result = await client.listMemories({
+     *   limit: 50,
+     *   config: { include_vectors: false }
+     * });
+     * console.log('Found memories:', result.data.memories.length);
+     * result.data.memories.forEach(memory => {
+     *   console.log('Memory:', memory.content, 'Type:', memory.memory_type);
+     * });
+     * ```
+     */
+    listMemories(options?: {
+        config?: Record<string, any>;
+        options?: Record<string, any>;
+        limit?: number;
+        offset?: number;
+        signal?: AbortSignal;
+    }): Promise<ListMemoriesResponse>;
+    /**
+     * Forget (delete) memories based on filters and criteria
+     *
+     * @param options - Optional config, options, memory type, category, and filters
+     * @returns Promise<ForgetMemoriesResponse> containing success status
+     *
+     * @example
+     * ```ts
+     * // Forget all episodic memories in a category
+     * const result = await client.forgetMemories({
+     *   memory_type: MemoryType.EPISODIC,
+     *   category: 'temporary',
+     *   filters: { tag: 'delete-me' }
+     * });
+     * console.log('Forget success:', result.data.success);
+     * ```
+     */
+    forgetMemories(options?: {
+        config?: Record<string, any>;
+        options?: Record<string, any>;
+        memory_type?: any;
+        category?: string;
+        filters?: Record<string, any>;
+        signal?: AbortSignal;
+    }): Promise<ForgetMemoriesResponse>;
+    /**
+     * Upload a file (image, audio, document) to the server.
+     * Returns file metadata including file_id for use in multimodal messages.
+     *
+     * @param file - A File, Blob, or { data: Blob; filename: string } object
+     * @returns FileUploadResponse with file_id and metadata
+     *
+     * @example
+     * ```ts
+     * const result = await client.uploadFile(file);
+     * const msg = Message.withImage('Describe this', result.data.url);
+     * ```
+     */
+    uploadFile(file: File | Blob | {
+        data: Blob;
+        filename: string;
+    }, options?: RequestOptions): Promise<FileUploadResponse>;
+    /**
+     * Download a file by its file_id. Returns raw Blob.
+     */
+    getFile(fileId: string, options?: RequestOptions): Promise<Blob>;
+    /**
+     * List the caller's uploaded files (GET /v1/files).
+     * Throws a TenxGraphError with status 501 when the media store cannot enumerate files.
+     */
+    listFiles(params?: ListFilesRequest, options?: RequestOptions): Promise<ListFilesResponse>;
+    /**
+     * Get metadata about a stored file.
+     */
+    getFileInfo(fileId: string, options?: RequestOptions): Promise<FileInfoResponse>;
+    /**
+     * Get the best access URL for a stored file.
+     * For cloud-backed media this will typically be a signed URL.
+     * For local or memory-backed media this may fall back to the API file route.
+     */
+    getFileAccessUrl(fileId: string, options?: RequestOptions): Promise<FileAccessUrlResponse>;
+    /**
+     * Delete a stored file. Only the file's owner can delete it.
+     * Requires the `files:delete` permission; the server returns 404 when the file
+     * does not exist or belongs to someone else.
+     *
+     * @param fileId - The file_id returned by `uploadFile`
+     * @returns DeleteFileResponse with `data.file_id` and `data.deleted`
+     */
+    deleteFile(fileId: string, options?: RequestOptions): Promise<DeleteFileResponse>;
+    /**
+     * Get the current multimodal configuration from the server.
+     */
+    getMultimodalConfig(options?: RequestOptions): Promise<MultimodalConfigResponse>;
+}

package/dist/cjs/compat.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 declare const AgentFlowClient: typeof TenxGraphClient;
+/** @deprecated Use `TenxGraphClient`. Removed in 2.0. */
+export type AgentFlowClient = TenxGraphClient;
+/** @deprecated Use `TenxGraphError`. Removed in 2.0. */
+export declare const AgentFlowError: typeof 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/dist/cjs/endpoints/addThreadMessages.d.ts

@@ -0,0 +1,25 @@
+import { ResponseMetadata } from './metadata.js';
+import { Message } from '../message.js';
+import { 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;
+}
+/**
+ * @deprecated Requires the `checkpointer:import` scope (admin only) in 10xgraph-api releases after 0.9.0.
+ * Use `updateThreadMessageFeedback` to attach feedback to a message.
+ */
+export declare function addThreadMessages(context: AddThreadMessagesContext, request: AddThreadMessagesRequest): Promise<AddThreadMessagesResponse>;

package/dist/cjs/endpoints/clearThreadState.d.ts

@@ -0,0 +1,14 @@
+import { ResponseMetadata } from './metadata.js';
+import { 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 declare function clearThreadState(context: ClearThreadStateContext, threadId: string | number): Promise<ClearThreadStateResponse>;

package/dist/cjs/endpoints/deleteFile.d.ts

@@ -0,0 +1,13 @@
+import { ResponseMetadata } from './metadata.js';
+import { RequestContext } from '../request.js';
+export interface DeleteFileContext extends RequestContext {
+}
+export interface DeleteFileData {
+    file_id: string;
+    deleted: boolean;
+}
+export interface DeleteFileResponse {
+    data: DeleteFileData;
+    metadata: ResponseMetadata;
+}
+export declare function deleteFile(context: DeleteFileContext, fileId: string): Promise<DeleteFileResponse>;

package/dist/cjs/endpoints/deleteMemory.d.ts

@@ -0,0 +1,18 @@
+import { ResponseMetadata } from './metadata.js';
+import { 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 declare function deleteMemory(context: DeleteMemoryContext, request: DeleteMemoryRequest): Promise<DeleteMemoryResponse>;

package/dist/cjs/endpoints/deleteThread.d.ts

@@ -0,0 +1,18 @@
+import { ResponseMetadata } from './metadata.js';
+import { 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 declare function deleteThread(context: DeleteThreadContext, request: DeleteThreadRequest): Promise<DeleteThreadResponse>;

package/dist/cjs/endpoints/deleteThreadMessage.d.ts

@@ -0,0 +1,19 @@
+import { ResponseMetadata } from './metadata.js';
+import { 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 declare function deleteThreadMessage(context: DeleteThreadMessageContext, request: DeleteThreadMessageRequest): Promise<DeleteThreadMessageResponse>;