10xgraph-client 0.6.0 → 1.0.0-rc.2

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

@@ -0,0 +1,56 @@
+import { ResponseMetadata } from './metadata.js';
+import { RequestContext } from '../request.js';
+import { MemoryType } from './storeMemory.js';
+export interface SearchMemoryContext extends RequestContext {
+}
+/**
+ * Memory retrieval strategies
+ */
+export declare enum RetrievalStrategy {
+    SIMILARITY = "similarity",// Vector similarity search
+    TEMPORAL = "temporal",// Time-based retrieval
+    RELEVANCE = "relevance",// Relevance scoring
+    HYBRID = "hybrid",// Combined approaches
+    GRAPH_TRAVERSAL = "graph_traversal"
+}
+/**
+ * Supported distance metrics for vector similarity
+ */
+export declare enum DistanceMetric {
+    COSINE = "cosine",
+    EUCLIDEAN = "euclidean",
+    DOT_PRODUCT = "dot_product",
+    MANHATTAN = "manhattan"
+}
+export interface SearchMemoryRequest {
+    config?: Record<string, any>;
+    options?: Record<string, any>;
+    query: string;
+    memory_type?: MemoryType;
+    category?: string;
+    limit?: number;
+    score_threshold?: number;
+    filters?: Record<string, any>;
+    retrieval_strategy?: RetrievalStrategy;
+    distance_metric?: DistanceMetric;
+    max_tokens?: number;
+}
+export interface MemoryResult {
+    id: string;
+    content: string;
+    score: number;
+    memory_type: string;
+    metadata: Record<string, any>;
+    vector: number[];
+    user_id: string;
+    thread_id: string;
+    timestamp: string;
+}
+export interface SearchMemoryData {
+    results: MemoryResult[];
+}
+export interface SearchMemoryResponse {
+    data: SearchMemoryData;
+    metadata: ResponseMetadata;
+}
+export declare function searchMemory(context: SearchMemoryContext, request: SearchMemoryRequest): Promise<SearchMemoryResponse>;

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

@@ -0,0 +1,49 @@
+import { ResponseMetadata } from './metadata.js';
+import { RequestContext } from '../request.js';
+export interface StateSchemaContext extends RequestContext {
+}
+/**
+ * JSON Schema definition for a field in AgentState
+ * Contains type information, description, validation rules, and default values
+ */
+export interface FieldSchema {
+    type?: string | string[];
+    description?: string;
+    default?: any;
+    items?: any;
+    properties?: Record<string, FieldSchema>;
+    required?: string[];
+    enum?: any[];
+    $ref?: string;
+    $defs?: Record<string, any>;
+    anyOf?: any[];
+    allOf?: any[];
+    oneOf?: any[];
+    [key: string]: any;
+}
+/**
+ * Complete JSON Schema for AgentState
+ * Describes all available fields, their types, constraints, and meanings
+ */
+export interface AgentStateSchema {
+    title?: string;
+    description?: string;
+    type?: string;
+    properties: Record<string, FieldSchema>;
+    required?: string[];
+    $defs?: Record<string, any>;
+    [key: string]: any;
+}
+/**
+ * Response containing the complete AgentState schema
+ * Users can use this to:
+ * - Understand field types and structure
+ * - Build dynamic forms or validation
+ * - Know what fields are available and required
+ * - See field descriptions and constraints
+ */
+export interface StateSchemaResponse {
+    data: AgentStateSchema;
+    metadata: ResponseMetadata;
+}
+export declare function stateSchema(context: StateSchemaContext): Promise<StateSchemaResponse>;

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

@@ -0,0 +1,35 @@
+import { ResponseMetadata } from './metadata.js';
+import { RequestContext } from '../request.js';
+export interface StopGraphContext extends RequestContext {
+}
+export interface StopGraphRequest {
+    thread_id: string;
+    config?: Record<string, any>;
+}
+export interface StopGraphResponse {
+    data: {
+        /** False when the thread has no checkpointer or no saved state. */
+        ok: boolean;
+        /** True when a run was active and a stop was requested. */
+        running?: boolean;
+        /** Why nothing was stopped, e.g. 'no-checkpointer' or 'no-state'. */
+        reason?: string;
+        /** @deprecated The server never sends this field. Use `ok`. */
+        success?: boolean;
+        /** @deprecated The server never sends this field. */
+        message?: string;
+        /** @deprecated The server never sends this field. */
+        thread_id?: string;
+        /** @deprecated The server never sends this field. */
+        stopped_at?: string;
+    };
+    metadata: ResponseMetadata;
+}
+/**
+ * Stop a running graph execution for a specific thread
+ *
+ * @param context - Request context with baseUrl, auth, timeout
+ * @param request - Stop request with thread_id and optional config
+ * @returns Promise<StopGraphResponse> with stop operation result
+ */
+export declare function stopGraph(context: StopGraphContext, request: StopGraphRequest): Promise<StopGraphResponse>;

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

@@ -0,0 +1,32 @@
+import { ResponseMetadata } from './metadata.js';
+import { RequestContext } from '../request.js';
+export interface StoreMemoryContext extends RequestContext {
+}
+/**
+ * Types of memories that can be stored
+ */
+export declare enum MemoryType {
+    EPISODIC = "episodic",// Conversation memories
+    SEMANTIC = "semantic",// Facts and knowledge
+    PROCEDURAL = "procedural",// How-to knowledge
+    ENTITY = "entity",// Entity-based memories
+    RELATIONSHIP = "relationship",// Entity relationships
+    CUSTOM = "custom",// Custom memory types
+    DECLARATIVE = "declarative"
+}
+export interface StoreMemoryRequest {
+    config?: Record<string, any>;
+    options?: Record<string, any>;
+    content: string;
+    memory_type: MemoryType;
+    category: string;
+    metadata?: Record<string, any>;
+}
+export interface StoreMemoryData {
+    memory_id: string;
+}
+export interface StoreMemoryResponse {
+    data: StoreMemoryData;
+    metadata: ResponseMetadata;
+}
+export declare function storeMemory(context: StoreMemoryContext, request: StoreMemoryRequest): Promise<StoreMemoryResponse>;

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

@@ -0,0 +1,67 @@
+import { Message } from '../message.js';
+import { AgentState } from '../agent.js';
+import { ToolExecutor } from '../tools.js';
+import { RequestContext } from '../request.js';
+export interface StreamContext extends RequestContext {
+    toolExecutor?: ToolExecutor;
+    /** Caller-supplied signal; aborting it cancels the request, including the open stream. */
+    signal?: AbortSignal;
+}
+export interface StreamRequest {
+    messages: any[];
+    initial_state?: Record<string, any>;
+    config?: Record<string, any>;
+    recursion_limit?: number;
+    /** What to do when another run is active on the same thread (server default: 'wait'). */
+    on_busy?: 'wait' | 'cancel';
+    /** Value that answers an open interrupt. Send together with `interrupt_id`. */
+    resume?: unknown;
+    /** Id of the interrupt being answered by `resume`. */
+    interrupt_id?: string;
+    response_granularity?: 'full' | 'partial' | 'low';
+}
+export declare enum StreamEventType {
+    MESSAGE = "message",
+    UPDATES = "updates",
+    STATE = "state",
+    ERROR = "error"
+}
+export interface StreamMetadata {
+    is_new_thread: boolean;
+    thread_id: string;
+    [key: string]: any;
+}
+export interface StreamChunk {
+    event: StreamEventType | string;
+    message?: Message | null;
+    state?: AgentState | null;
+    data?: any;
+    thread_id?: string;
+    run_id?: string;
+    metadata?: StreamMetadata | Record<string, any>;
+    timestamp?: number;
+}
+/**
+ * Stream invoke to the graph with automatic tool execution loop
+ * Returns an async iterable that yields stream chunks as they arrive
+ *
+ * This implements the same tool execution loop as invoke(), but uses
+ * HTTP streaming instead of REST API calls.
+ *
+ * @example
+ * ```ts
+ * const stream = streamInvoke(context, request);
+ * for await (const chunk of stream) {
+ *   if (chunk.event === 'message') {
+ *     console.log('Message:', chunk.message);
+ *   } else if (chunk.event === 'updates') {
+ *     console.log('State:', chunk.state);
+ *   }
+ * }
+ * ```
+ */
+export declare function streamInvoke(context: StreamContext, request: StreamRequest): AsyncGenerator<StreamChunk, void, unknown>;
+/**
+ * Serialize a Message object for API transmission
+ */
+export declare function serializeMessage(message: Message): any;

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

@@ -0,0 +1,18 @@
+import { ResponseMetadata } from './metadata.js';
+import { RequestContext } from '../request.js';
+export interface ThreadDetailsContext extends RequestContext {
+}
+export interface ThreadDetailsData {
+    thread_data: {
+        thread: Record<string, any>;
+    };
+}
+export interface ThreadDetailsResponse {
+    data: ThreadDetailsData;
+    metadata: ResponseMetadata;
+}
+/**
+ * Fetch details for a specific thread.
+ * GET /v1/threads/{threadId}
+ */
+export declare function threadDetails(context: ThreadDetailsContext, threadId: string | number): Promise<ThreadDetailsResponse>;

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

@@ -0,0 +1,16 @@
+import { ResponseMetadata } from './metadata.js';
+import { Message } from '../message.js';
+import { RequestContext } from '../request.js';
+export interface ThreadMessageContext extends RequestContext {
+}
+export interface ThreadMessageRequest {
+    threadId: string | number;
+    messageId: string;
+}
+export interface ThreadMessageData extends Message {
+}
+export interface ThreadMessageResponse {
+    data: ThreadMessageData;
+    metadata: ResponseMetadata;
+}
+export declare function threadMessage(context: ThreadMessageContext, request: ThreadMessageRequest): Promise<ThreadMessageResponse>;

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

@@ -0,0 +1,28 @@
+import { ResponseMetadata } from './metadata.js';
+import { Message } from '../message.js';
+import { 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[];
+    /** True when more messages exist after this page. Absent on servers older than 1.0.0. */
+    has_more?: boolean;
+    /** Offset the server applied. */
+    offset?: number;
+    /** Limit the server applied (after its default and maximum clamp). */
+    limit?: number;
+}
+export type CheckpointMessagesData = ThreadMessagesData;
+export interface ThreadMessagesResponse {
+    data: ThreadMessagesData;
+    metadata: ResponseMetadata;
+}
+export type CheckpointMessagesResponse = ThreadMessagesResponse;
+export declare function threadMessages(context: ThreadMessagesContext, request: ThreadMessagesRequest): Promise<ThreadMessagesResponse>;
+export declare const checkpointMessages: typeof threadMessages;

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

@@ -0,0 +1,13 @@
+import { ResponseMetadata } from './metadata.js';
+import { AgentState } from '../agent.js';
+import { RequestContext } from '../request.js';
+export interface ThreadStateContext extends RequestContext {
+}
+export interface ThreadStateData {
+    state: AgentState;
+}
+export interface ThreadStateResponse {
+    data: ThreadStateData;
+    metadata: ResponseMetadata;
+}
+export declare function threadState(context: ThreadStateContext, threadId: string | number): Promise<ThreadStateResponse>;

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

@@ -0,0 +1,35 @@
+import { ResponseMetadata } from './metadata.js';
+import { 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[];
+    /** True when more threads exist after this page. Absent on servers older than 1.0.0. */
+    has_more?: boolean;
+    /** Offset the server applied. */
+    offset?: number;
+    /** Limit the server applied (after its default and maximum clamp). */
+    limit?: number;
+}
+export interface ThreadsResponse {
+    data: ThreadsData;
+    metadata: ResponseMetadata;
+}
+/**
+ * Fetch list of threads with optional search and pagination
+ * GET /v1/threads
+ */
+export declare function threads(context: ThreadsContext, request?: ThreadsRequest): Promise<ThreadsResponse>;

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

@@ -0,0 +1,20 @@
+import { ResponseMetadata } from './metadata.js';
+import { 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 declare function updateMemory(context: UpdateMemoryContext, request: UpdateMemoryRequest): Promise<UpdateMemoryResponse>;

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

@@ -0,0 +1,19 @@
+import { ResponseMetadata } from './metadata.js';
+import { ThreadMessageData } from './threadMessage.js';
+import { RequestContext } from '../request.js';
+export interface UpdateThreadMessageFeedbackContext extends RequestContext {
+}
+export interface UpdateThreadMessageFeedbackRequest {
+    threadId: string | number;
+    messageId: string;
+    /**
+     * Any JSON object. Replaces `message.metadata.feedback`. The server rejects
+     * feedback larger than 8192 serialized bytes or nested deeper than 10 levels (HTTP 422).
+     */
+    feedback: Record<string, unknown>;
+}
+export interface UpdateThreadMessageFeedbackResponse {
+    data: ThreadMessageData;
+    metadata: ResponseMetadata;
+}
+export declare function updateThreadMessageFeedback(context: UpdateThreadMessageFeedbackContext, request: UpdateThreadMessageFeedbackRequest): Promise<UpdateThreadMessageFeedbackResponse>;

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

@@ -0,0 +1,22 @@
+import { ResponseMetadata } from './metadata.js';
+import { AgentState } from '../agent.js';
+import { RequestContext } from '../request.js';
+export interface UpdateThreadStateContext extends RequestContext {
+}
+/**
+ * State fields the server accepts on update. `context_summary` and `execution_meta` are
+ * rejected by the server, so they are not part of this type.
+ */
+export type UpdatableThreadState = Partial<Omit<AgentState, 'context_summary' | 'execution_meta'>> & Record<string, any>;
+export interface UpdateThreadStateRequest {
+    config: Record<string, any>;
+    state: UpdatableThreadState;
+}
+export interface UpdateThreadStateData {
+    state: AgentState;
+}
+export interface UpdateThreadStateResponse {
+    data: UpdateThreadStateData;
+    metadata: ResponseMetadata;
+}
+export declare function updateThreadState(context: UpdateThreadStateContext, threadId: string | number, request: UpdateThreadStateRequest): Promise<UpdateThreadStateResponse>;

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

@@ -0,0 +1,34 @@
+import { ToolExecutor } from '../tools.js';
+import { RequestContext } from '../request.js';
+import { StreamChunk, StreamRequest } from './stream.js';
+export interface WsStreamContext extends RequestContext {
+    toolExecutor?: ToolExecutor;
+    /** Caller-supplied signal; aborting it closes the socket and ends the stream. */
+    signal?: AbortSignal;
+}
+/**
+ * Stream invoke via a persistent WebSocket connection.
+ *
+ * The protocol is:
+ *
+ *   1. Connect to ``/v1/graph/ws`` (auth via the ``10xgraph-bearer`` subprotocol or Authorization header).
+ *   2. Send ``{ invoke_type:"fresh", messages:[…], config:{…}, … }``.
+ *   3. Receive ``StreamChunk`` JSON messages; yield each to the caller.
+ *   4. Server sends ``{ event:"updates", data:{ status:"done" } }`` after each run.
+ *   5. If the run contained remote tool calls, execute them and send:
+ *      ``{ invoke_type:"resume", tool_result:[…], config:{ thread_id } }``.
+ *   6. Repeat from step 3 until no more tool calls.
+ *   7. Close the WebSocket.
+ *
+ * This replaces the HTTP loop in ``streamInvoke`` — the round-trip cost of
+ * re-opening a new HTTP connection for each tool call is eliminated.
+ *
+ * @example
+ * ```ts
+ * const stream = wsStreamInvoke(context, request);
+ * for await (const chunk of stream) {
+ *   if (chunk.event === 'message') console.log(chunk.message);
+ * }
+ * ```
+ */
+export declare function wsStreamInvoke(context: WsStreamContext, request: StreamRequest): AsyncGenerator<StreamChunk, void, unknown>;

package/dist/cjs/errors.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Error handling for 10xGraph API
+ * Provides structured error types for all HTTP status codes
+ */
+export interface ErrorDetail {
+    loc?: string[];
+    msg?: string;
+    type?: string;
+}
+export interface ApiErrorResponse {
+    metadata: {
+        message: string;
+        request_id: string;
+        timestamp: string;
+    };
+    error: {
+        code: string;
+        message: string;
+        details: ErrorDetail[];
+        /** Present on 429 replies. */
+        retry_after_seconds?: number;
+    };
+}
+/**
+ * Base error class for all 10xGraph API errors
+ */
+export declare class TenxGraphError extends Error {
+    readonly statusCode: number;
+    readonly errorCode: string;
+    readonly requestId: string;
+    readonly timestamp: string;
+    readonly details: ErrorDetail[];
+    readonly context?: Record<string, any>;
+    endpoint?: string;
+    method?: string;
+    readonly recoverySuggestion?: string;
+    /** Underlying error (fetch rejection, socket error) when there is one. */
+    cause?: unknown;
+    /** Response headers of the failed HTTP reply, lowercased names. Absent for transport errors. */
+    responseHeaders?: Record<string, string>;
+    /** Parsed JSON body (or raw text) of the failed HTTP reply, before any normalisation. */
+    responseBody?: unknown;
+    constructor(message: string, statusCode: number, errorCode: string, requestId: string, timestamp: string, details?: ErrorDetail[], context?: Record<string, any>, endpoint?: string, method?: string, recoverySuggestion?: string);
+    /**
+     * Get a user-friendly error message with recovery suggestion
+     */
+    getUserMessage(): string;
+    /**
+     * Get full error details for debugging
+     */
+    toJSON(): Record<string, any>;
+}
+/**
+ * 400 Bad Request Error
+ * Thrown when the request is malformed or contains invalid data
+ */
+export declare class BadRequestError extends TenxGraphError {
+    constructor(message: string, requestId: string, timestamp: string, details?: ErrorDetail[]);
+}
+/**
+ * 401 Unauthorized Error
+ * Thrown when authentication credentials are missing or invalid
+ */
+export declare class AuthenticationError extends TenxGraphError {
+    constructor(message: string, requestId: string, timestamp: string, details?: ErrorDetail[]);
+}
+/**
+ * 403 Forbidden Error
+ * Thrown when the user doesn't have permission to access the resource
+ */
+export declare class PermissionError extends TenxGraphError {
+    constructor(message: string, requestId: string, timestamp: string, details?: ErrorDetail[]);
+}
+/**
+ * 404 Not Found Error
+ * Thrown when the requested resource doesn't exist
+ */
+export declare class NotFoundError extends TenxGraphError {
+    constructor(message: string, requestId: string, timestamp: string, details?: ErrorDetail[]);
+}
+/**
+ * 409 Conflict Error
+ * Thrown when the thread is busy with another run, or when a resume's
+ * `interrupt_id` does not match the open interrupt. Never retried automatically.
+ */
+export declare class ConflictError extends TenxGraphError {
+    constructor(message: string, requestId: string, timestamp: string, details?: ErrorDetail[]);
+}
+/**
+ * 422 Validation Error
+ * Thrown when the request data fails validation
+ */
+export declare class ValidationError extends TenxGraphError {
+    constructor(message: string, requestId: string, timestamp: string, details?: ErrorDetail[]);
+}
+/**
+ * 500 Server Error
+ * Thrown when the server encounters an internal error
+ */
+export declare class ServerError extends TenxGraphError {
+    constructor(message: string, requestId: string, timestamp: string, errorCode?: string, details?: ErrorDetail[], statusCode?: number);
+}
+/**
+ * Graph Error
+ * Thrown when there's an error in graph execution
+ */
+export declare class GraphError extends TenxGraphError {
+    constructor(message: string, requestId: string, timestamp: string, details?: ErrorDetail[], context?: Record<string, any>);
+}
+/**
+ * Node Error
+ * Thrown when there's an error executing a specific node
+ */
+export declare class NodeError extends TenxGraphError {
+    readonly nodeName?: string;
+    constructor(message: string, requestId: string, timestamp: string, details?: ErrorDetail[], context?: Record<string, any>, nodeName?: string);
+}
+/**
+ * Graph Recursion Error
+ * Thrown when graph execution exceeds the recursion limit
+ */
+export declare class GraphRecursionError extends TenxGraphError {
+    readonly recursionLimit?: number;
+    constructor(message: string, requestId: string, timestamp: string, details?: ErrorDetail[], context?: Record<string, any>, recursionLimit?: number);
+}
+/**
+ * Storage Error
+ * Thrown when there's an error accessing storage
+ */
+export declare class StorageError extends TenxGraphError {
+    constructor(message: string, requestId: string, timestamp: string, details?: ErrorDetail[], context?: Record<string, any>);
+}
+/**
+ * Transient Storage Error
+ * Thrown when there's a temporary storage issue (503 Service Unavailable)
+ */
+export declare class TransientStorageError extends TenxGraphError {
+    constructor(message: string, requestId: string, timestamp: string, details?: ErrorDetail[], context?: Record<string, any>);
+}
+/**
+ * Metrics Error
+ * Thrown when there's an error collecting or reporting metrics
+ */
+export declare class MetricsError extends TenxGraphError {
+    constructor(message: string, requestId: string, timestamp: string, details?: ErrorDetail[], context?: Record<string, any>);
+}
+/**
+ * Schema Version Error
+ * Thrown when there's a version mismatch in data schemas
+ */
+export declare class SchemaVersionError extends TenxGraphError {
+    readonly expectedVersion?: string;
+    readonly actualVersion?: string;
+    constructor(message: string, requestId: string, timestamp: string, details?: ErrorDetail[], context?: Record<string, any>, expectedVersion?: string, actualVersion?: string);
+}
+/**
+ * Serialization Error
+ * Thrown when there's an error serializing or deserializing data
+ */
+export declare class SerializationError extends TenxGraphError {
+    constructor(message: string, requestId: string, timestamp: string, details?: ErrorDetail[], context?: Record<string, any>);
+}
+/**
+ * 429 Too Many Requests
+ * Carries the server's retry hint in seconds (Retry-After header, else the body's
+ * `retry_after_seconds`), or undefined when the server sent none.
+ */
+export declare class RateLimitError extends TenxGraphError {
+    readonly retryAfterSeconds?: number;
+    constructor(message: string, requestId: string, timestamp: string, details?: ErrorDetail[], retryAfterSeconds?: number);
+}
+/**
+ * Request Timeout Error
+ * Thrown client-side when a request exceeds the configured `timeout`. statusCode is 0.
+ */
+export declare class RequestTimeoutError extends TenxGraphError {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number, endpoint?: string, method?: string, cause?: unknown);
+}
+/**
+ * Network Error
+ * Thrown when the request never got an HTTP reply (DNS failure, connection refused, offline,
+ * CORS block). `cause` holds the underlying fetch error. statusCode is 0.
+ */
+export declare class NetworkError extends TenxGraphError {
+    constructor(message: string, endpoint?: string, method?: string, cause?: unknown);
+}
+/**
+ * WebSocket Error
+ * Thrown for WebSocket failures: connection errors, unexpected close, handshake rejection.
+ * `closeCode` is the close frame code when the failure was a close.
+ */
+export declare class WebSocketError extends TenxGraphError {
+    readonly closeCode?: number;
+    constructor(message: string, closeCode?: number, endpoint?: string, cause?: unknown);
+}
+/**
+ * Stream Error
+ * Thrown when an HTTP or WebSocket run stream fails after it started: an error chunk from the
+ * server, a malformed chunk, or a stream that ended before completion.
+ */
+export declare class StreamError extends TenxGraphError {
+    constructor(message: string, errorCode?: string, requestId?: string, endpoint?: string, method?: string, cause?: unknown);
+}
+/**
+ * Parse error response from API
+ */
+export declare function parseErrorResponse(response: Response): Promise<ApiErrorResponse | null>;
+/**
+ * Create appropriate error instance based on HTTP status code and error code
+ */
+export declare function createErrorFromResponse(response: Response, fallbackMessage?: string, endpoint?: string, method?: string): Promise<TenxGraphError>;