@trustgraph/client 1.2.1 → 1.3.1

package/dist/index.js

@@ -1,1375 +0,0 @@
-'use strict';
-
-// Constant defining the delay before attempting to reconnect a WebSocket
-// (2 seconds)
-const SOCKET_RECONNECTION_TIMEOUT$2 = 2000;
-class ServiceCallMulti {
-    constructor(mid, msg, success, error, timeout, retries, socket, receiver) {
-        this.mid = mid;
-        this.msg = msg;
-        this.success = success;
-        this.error = error;
-        this.timeout = timeout;
-        this.retries = retries;
-        this.socket = socket;
-        this.complete = false;
-        this.receiver = receiver;
-    }
-    start() {
-        this.socket.inflight[this.mid] = this;
-        this.attempt();
-    }
-    onReceived(resp) {
-        if (this.complete == true)
-            console.log(this.mid, "should not happen, request is already complete");
-        const fin = this.receiver(resp);
-        if (fin) {
-            this.complete = true;
-            //        console.log("Received for", this.mid);
-            clearTimeout(this.timeoutId);
-            this.timeoutId = undefined;
-            delete this.socket.inflight[this.mid];
-            this.success(resp);
-        }
-    }
-    onTimeout() {
-        if (this.complete == true)
-            console.log(this.mid, "timeout should not happen, request is already complete");
-        console.log("Request", this.mid, "timed out");
-        clearTimeout(this.timeoutId);
-        this.attempt();
-    }
-    attempt() {
-        //        console.log("attempt:", this.mid);
-        if (this.complete == true)
-            console.log(this.mid, "attempt should not be called, request is already complete");
-        this.retries--;
-        if (this.retries < 0) {
-            console.log("Request", this.mid, "ran out of retries");
-            clearTimeout(this.timeoutId);
-            delete this.socket.inflight[this.mid];
-            this.error("Ran out of retries");
-            return; // Exit early - no more attempts
-        }
-        // Check if WebSocket connection is available and ready
-        if (this.socket.ws && this.socket.ws.readyState === WebSocket.OPEN) {
-            try {
-                this.socket.ws.send(JSON.stringify(this.msg));
-                this.timeoutId = setTimeout(this.onTimeout.bind(this), this.timeout);
-                return;
-            }
-            catch (e) {
-                console.log("Error:", e);
-                console.log("Message send failure, retry...");
-                // Calculate backoff delay with jitter
-                const backoffDelay = Math.min(SOCKET_RECONNECTION_TIMEOUT$2 * Math.pow(2, 3 - this.retries) +
-                    Math.random() * 1000, 30000);
-                this.timeoutId = setTimeout(this.attempt.bind(this), backoffDelay);
-                console.log("Reopen...");
-                // Attempt to reopen the WebSocket connection
-                this.socket.reopen();
-            }
-        }
-        else {
-            // No WebSocket connection available or not ready
-            // Check if socket is connecting
-            if (this.socket.ws &&
-                this.socket.ws.readyState === WebSocket.CONNECTING) {
-                // Wait a bit longer for connection to establish
-                setTimeout(this.attempt.bind(this), 500);
-            }
-            else {
-                // Socket is closed or closing, trigger reopen
-                console.log("Socket not ready, reopening...");
-                this.socket.reopen();
-                // Calculate backoff delay
-                const backoffDelay = Math.min(SOCKET_RECONNECTION_TIMEOUT$2 * Math.pow(2, 3 - this.retries) +
-                    Math.random() * 1000, 30000);
-                setTimeout(this.attempt.bind(this), backoffDelay);
-            }
-        }
-    }
-}
-
-// Constant defining the delay before attempting to reconnect a WebSocket
-// (2 seconds)
-const SOCKET_RECONNECTION_TIMEOUT$1 = 2000;
-/**
- * ServiceCall represents a single request/response cycle over a WebSocket
- * connection with built-in retry logic, timeout handling, and completion
- * tracking.
- *
- * This class manages the lifecycle of a service call including:
- * - Sending the initial request
- * - Handling timeouts and retries
- * - Managing completion state
- * - Cleaning up resources
- */
-class ServiceCall {
-    constructor(mid, // Message ID - unique identifier for this request
-    msg, // The actual message/request to send
-    success, // Callback function called on
-    // successful response
-    error, // Callback function called on error/failure
-    timeout, // Timeout duration in milliseconds
-    retries, // Number of retry attempts allowed
-    socket) {
-        this.mid = mid;
-        this.msg = msg;
-        this.success = success;
-        this.error = error;
-        this.timeout = timeout;
-        this.retries = retries;
-        this.socket = socket;
-        this.complete = false; // Track if this request has completed
-    }
-    /**
-     * Initiates the service call by registering it with the socket's inflight
-     * requests and making the first attempt to send the message
-     */
-    start() {
-        // Register this request as "in-flight" so responses can be matched to it
-        this.socket.inflight[this.mid] = this;
-        // Make the first attempt to send the message
-        this.attempt();
-    }
-    /**
-     * Called when a response is received for this request
-     * Handles cleanup and calls the success or error callback based on response
-     *
-     * @param resp - The response object received from the server
-     */
-    onReceived(resp) {
-        // Defensive check - this shouldn't happen but log if it does
-        if (this.complete == true)
-            console.log(this.mid, "should not happen, request is already complete");
-        // Mark as complete to prevent duplicate processing
-        this.complete = true;
-        // Clean up timeout timer
-        clearTimeout(this.timeoutId);
-        this.timeoutId = undefined;
-        // Remove from inflight requests tracker
-        delete this.socket.inflight[this.mid];
-        // Check if the response contains an error (error can be directly in resp or nested under response)
-        let errorToHandle = null;
-        // Check for direct error in response
-        if (resp && typeof resp === "object" && "error" in resp) {
-            errorToHandle = resp.error;
-        }
-        // Check for nested error under response property
-        else if (resp && typeof resp === "object" && "response" in resp) {
-            const response = resp.response;
-            if (response && typeof response === "object" && "error" in response) {
-                errorToHandle = response.error;
-            }
-        }
-        if (errorToHandle) {
-            // Response contains an error - call error callback
-            const errorObj = errorToHandle;
-            const errorMessage = (typeof errorObj.message === "string" ? errorObj.message : null) ||
-                (typeof errorObj.type === "string" ? errorObj.type : null) ||
-                "Unknown error";
-            console.log("ServiceCall: API error detected in response:", errorMessage, "Full error:", errorToHandle);
-            this.error(new Error(errorMessage));
-            return;
-        }
-        // Call success callback with the response
-        this.success(resp);
-    }
-    /**
-     * Called when the request times out
-     * Triggers another attempt if retries are available
-     */
-    onTimeout() {
-        // Defensive check - this shouldn't happen but log if it does
-        if (this.complete == true)
-            console.log(this.mid, "timeout should not happen, request is already complete");
-        console.log("Request", this.mid, "timed out");
-        // Clear the current timeout
-        clearTimeout(this.timeoutId);
-        // Try again (this will check retry count)
-        this.attempt();
-    }
-    /**
-     * Calculates exponential backoff delay with jitter
-     * @returns backoff delay in milliseconds
-     */
-    calculateBackoff() {
-        return Math.min(SOCKET_RECONNECTION_TIMEOUT$1 * Math.pow(2, 3 - this.retries) +
-            Math.random() * 1000, 30000);
-    }
-    /**
-     * Core retry logic - attempts to send the message over the WebSocket
-     * Handles retries and waits for BaseApi to handle reconnection
-     */
-    attempt() {
-        // Defensive check - this shouldn't be called on completed requests
-        if (this.complete == true)
-            console.log(this.mid, "attempt should not be called, request is already complete");
-        // Decrement retry counter
-        this.retries--;
-        // Check if we've exhausted all retries
-        if (this.retries < 0) {
-            console.log("Request", this.mid, "ran out of retries");
-            // Clean up and call error callback
-            clearTimeout(this.timeoutId);
-            delete this.socket.inflight[this.mid];
-            this.error("Ran out of retries");
-            return; // Exit early - no more attempts
-        }
-        // Check if WebSocket connection is available and ready
-        if (this.socket.ws && this.socket.ws.readyState === WebSocket.OPEN) {
-            try {
-                // Attempt to send the message as JSON
-                this.socket.ws.send(JSON.stringify(this.msg));
-                // Set up timeout for this attempt
-                this.timeoutId = setTimeout(this.onTimeout.bind(this), this.timeout);
-                return; // Success - message sent, waiting for response or timeout
-            }
-            catch (e) {
-                // Handle send failure - wait for BaseApi to handle reconnection
-                console.log("Error:", e);
-                console.log("Message send failure, waiting for socket reconnection...");
-                // Schedule retry with backoff - let BaseApi handle the reconnection
-                this.timeoutId = setTimeout(this.attempt.bind(this), this.calculateBackoff());
-            }
-        }
-        else {
-            // No WebSocket connection available or not ready
-            // Let BaseApi handle reconnection, just wait and retry
-            console.log("Request", this.mid, "waiting for socket reconnection...");
-            // Use consistent backoff for all waiting scenarios
-            setTimeout(this.attempt.bind(this), this.calculateBackoff());
-        }
-    }
-}
-
-// Configuration constants
-const SOCKET_RECONNECTION_TIMEOUT = 2000; // 2 seconds between reconnection
-// attempts
-const SOCKET_URL = "/api/socket"; // WebSocket endpoint path
-/**
- * Generates a random message ID using cryptographically secure random values
- * @param length - Number of random characters to generate
- * @returns Random string of specified length
- */
-function makeid(length) {
-    const array = new Uint32Array(length);
-    crypto.getRandomValues(array);
-    const characters = "abcdefghijklmnopqrstuvwxyz1234567890";
-    return array.reduce((acc, current) => acc + characters[current % characters.length], "");
-}
-class BaseApi {
-    constructor(user, token) {
-        this.inflight = {}; // Track active requests by
-        // message ID
-        this.reconnectAttempts = 0; // Track reconnection attempts
-        this.maxReconnectAttempts = 10; // Maximum reconnection attempts
-        this.reconnectionState = "idle"; // Connection state
-        // Connection state tracking for UI
-        this.connectionStateListeners = [];
-        this.tag = makeid(16); // Generate unique client tag
-        this.id = 1; // Start message ID counter
-        this.token = token; // Store authentication token
-        this.user = user; // Store user identifier
-        console.log("SOCKET: opening socket...", token ? "with auth" : "without auth", "user:", user);
-        this.openSocket(); // Establish WebSocket connection
-        console.log("SOCKET: socket opened");
-    }
-    /**
-     * Subscribe to connection state changes for UI updates
-     */
-    onConnectionStateChange(listener) {
-        this.connectionStateListeners.push(listener);
-        // Immediately send current state
-        listener(this.getConnectionState());
-        // Return unsubscribe function
-        return () => {
-            const index = this.connectionStateListeners.indexOf(listener);
-            if (index > -1) {
-                this.connectionStateListeners.splice(index, 1);
-            }
-        };
-    }
-    /**
-     * Get current connection state
-     */
-    getConnectionState() {
-        const hasApiKey = !!this.token;
-        // Determine status based on WebSocket state and reconnection state
-        let status;
-        if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
-            if (this.reconnectionState === "failed") {
-                status = "failed";
-            }
-            else if (this.reconnectionState === "reconnecting") {
-                status = "reconnecting";
-            }
-            else {
-                status = "connecting";
-            }
-        }
-        else if (this.ws.readyState === WebSocket.CONNECTING) {
-            status = "connecting";
-        }
-        else if (this.ws.readyState === WebSocket.OPEN) {
-            status = hasApiKey ? "authenticated" : "unauthenticated";
-        }
-        else {
-            status = "connecting";
-        }
-        const state = {
-            status,
-            hasApiKey,
-            lastError: this.lastError,
-        };
-        // Add reconnection details if applicable
-        if (status === "reconnecting") {
-            state.reconnectAttempt = this.reconnectAttempts;
-            state.maxAttempts = this.maxReconnectAttempts;
-        }
-        return state;
-    }
-    /**
-     * Notify all listeners of connection state changes
-     */
-    notifyStateChange() {
-        const state = this.getConnectionState();
-        this.connectionStateListeners.forEach((listener) => {
-            try {
-                listener(state);
-            }
-            catch (error) {
-                console.error("Error in connection state listener:", error);
-            }
-        });
-    }
-    /**
-     * Establishes WebSocket connection and sets up event handlers
-     */
-    openSocket() {
-        // Don't create multiple connections
-        if (this.ws &&
-            (this.ws.readyState === WebSocket.CONNECTING ||
-                this.ws.readyState === WebSocket.OPEN)) {
-            return;
-        }
-        // Clean up old socket if exists
-        if (this.ws) {
-            this.ws.removeEventListener("message", this.onMessage);
-            this.ws.removeEventListener("close", this.onClose);
-            this.ws.removeEventListener("open", this.onOpen);
-            this.ws.removeEventListener("error", this.onError);
-            this.ws = undefined;
-        }
-        try {
-            // Build WebSocket URL with optional token parameter
-            const wsUrl = this.token
-                ? `${SOCKET_URL}?token=${this.token}`
-                : SOCKET_URL;
-            console.log("SOCKET: connecting to", wsUrl.replace(/token=[^&]*/, "token=***"));
-            this.ws = new WebSocket(wsUrl);
-        }
-        catch (e) {
-            console.error("[socket creation error]", e);
-            this.scheduleReconnect();
-            return;
-        }
-        // Bind event handlers to maintain proper 'this' context
-        this.onMessage = this.onMessage.bind(this);
-        this.onClose = this.onClose.bind(this);
-        this.onOpen = this.onOpen.bind(this);
-        this.onError = this.onError.bind(this);
-        // Attach event listeners
-        this.ws.addEventListener("message", this.onMessage);
-        this.ws.addEventListener("close", this.onClose);
-        this.ws.addEventListener("open", this.onOpen);
-        this.ws.addEventListener("error", this.onError);
-    }
-    // Handle incoming messages from server
-    onMessage(message) {
-        if (!message.data)
-            return;
-        try {
-            const obj = JSON.parse(message.data);
-            // Skip messages without ID (can't route them)
-            if (!obj.id)
-                return;
-            // Route response to the corresponding inflight request
-            if (this.inflight[obj.id]) {
-                this.inflight[obj.id].onReceived(obj.response);
-            }
-        }
-        catch (e) {
-            console.error("[socket message parse error]", e);
-        }
-    }
-    // Handle connection closure - automatically attempt reconnection
-    onClose(event) {
-        console.log("[socket close]", event.code, event.reason);
-        this.lastError = `Connection closed: ${event.reason || "Unknown reason"}`;
-        this.ws = undefined;
-        this.notifyStateChange();
-        this.scheduleReconnect();
-    }
-    // Handle successful connection
-    onOpen() {
-        console.log("[socket open]");
-        this.reconnectAttempts = 0; // Reset reconnection attempts on success
-        this.reconnectionState = "idle"; // Reset connection state
-        this.lastError = undefined; // Clear any previous errors
-        // Clear any pending reconnect timer
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = undefined;
-        }
-        // Notify UI of successful connection
-        this.notifyStateChange();
-    }
-    // Handle socket errors
-    onError(event) {
-        console.error("[socket error]", event);
-        this.lastError = "Connection error occurred";
-        this.notifyStateChange();
-    }
-    /**
-     * Schedules a reconnection attempt with exponential backoff
-     */
-    scheduleReconnect() {
-        // Prevent concurrent reconnection attempts
-        if (this.reconnectionState === "reconnecting") {
-            console.log("[socket] Reconnection already in progress, skipping");
-            return;
-        }
-        // Don't schedule if already scheduled
-        if (this.reconnectTimer)
-            return;
-        this.reconnectionState = "reconnecting";
-        this.reconnectAttempts++;
-        this.notifyStateChange(); // Notify UI of reconnection attempt
-        if (this.reconnectAttempts > this.maxReconnectAttempts) {
-            console.error("[socket] Max reconnection attempts reached");
-            this.reconnectionState = "failed";
-            this.lastError = "Max reconnection attempts exceeded";
-            this.notifyStateChange();
-            // Notify all pending requests of the failure
-            for (const mid in this.inflight) {
-                this.inflight[mid].error(new Error("WebSocket connection failed"));
-            }
-            return;
-        }
-        // Calculate exponential backoff with jitter
-        const backoffDelay = Math.min(SOCKET_RECONNECTION_TIMEOUT * Math.pow(2, this.reconnectAttempts - 1) +
-            Math.random() * 1000, 30000);
-        console.log(`[socket] Reconnecting in ${backoffDelay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
-        this.reconnectTimer = setTimeout(() => {
-            this.reconnectTimer = undefined;
-            this.reopen();
-        }, backoffDelay);
-    }
-    /**
-     * Reopens the WebSocket connection (used after connection failures)
-     */
-    reopen() {
-        console.log("[socket reopen]");
-        // Check if we're already connected or connecting
-        if (this.ws &&
-            (this.ws.readyState === WebSocket.OPEN ||
-                this.ws.readyState === WebSocket.CONNECTING)) {
-            return;
-        }
-        this.openSocket();
-    }
-    /**
-     * Closes the WebSocket connection and cleans up
-     */
-    close() {
-        // Clear reconnection timer
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = undefined;
-        }
-        // Clean up WebSocket
-        if (this.ws) {
-            // Remove event listeners to prevent memory leaks
-            this.ws.removeEventListener("message", this.onMessage);
-            this.ws.removeEventListener("close", this.onClose);
-            this.ws.removeEventListener("open", this.onOpen);
-            this.ws.removeEventListener("error", this.onError);
-            this.ws.close();
-            this.ws = undefined;
-        }
-        // Clear any remaining inflight requests
-        for (const mid in this.inflight) {
-            this.inflight[mid].error(new Error("Socket closed"));
-        }
-        this.inflight = {};
-    }
-    /**
-     * Generates the next unique message ID for requests
-     * Format: {clientTag}-{incrementingNumber}
-     */
-    getNextId() {
-        const mid = this.tag + "-" + this.id.toString();
-        this.id++;
-        return mid;
-    }
-    /**
-     * Core method for making service requests over WebSocket
-     * @param service - Name of the service to call
-     * @param request - Request payload
-     * @param timeout - Request timeout in milliseconds (default: 10000)
-     * @param retries - Number of retry attempts (default: 3)
-     * @param flow - Optional flow identifier
-     * @returns Promise resolving to the service response
-     */
-    makeRequest(service, request, timeout, retries, flow) {
-        const mid = this.getNextId();
-        // Set default values
-        if (timeout == undefined)
-            timeout = 10000;
-        if (retries == undefined)
-            retries = 3;
-        // Construct the request message
-        const msg = {
-            id: mid,
-            service: service,
-            request: request,
-        };
-        // Add flow identifier if provided
-        if (flow)
-            msg.flow = flow;
-        // Return a Promise that will be resolved/rejected by the ServiceCall
-        return new Promise((resolve, reject) => {
-            const call = new ServiceCall(mid, msg, resolve, reject, timeout, retries, this);
-            call.start();
-            // Commented out debug logging: console.log("-->", msg);
-        }).then((obj) => {
-            // Commented out success logging: console.log("Success for", mid);
-            return obj;
-        });
-    }
-    /**
-     * Makes a request that can receive multiple responses (streaming)
-     * Used for operations that return data in chunks
-     */
-    makeRequestMulti(service, request, receiver, // Callback to handle each response chunk
-    timeout, retries, flow) {
-        const mid = this.getNextId();
-        // Set defaults
-        if (timeout == undefined)
-            timeout = 10000;
-        if (retries == undefined)
-            retries = 3;
-        // Construct request message
-        const msg = {
-            id: mid,
-            service: service,
-            request: request,
-        };
-        if (flow)
-            msg.flow = flow;
-        return new Promise((resolve, reject) => {
-            const call = new ServiceCallMulti(mid, msg, resolve, reject, timeout, retries, this, // eslint-disable-line @typescript-eslint/no-explicit-any
-            receiver);
-            call.start();
-        }).then((obj) => {
-            return obj;
-        });
-    }
-    /**
-     * Convenience method for making flow-specific requests
-     * Defaults to "default" flow if none specified
-     */
-    makeFlowRequest(service, request, timeout, retries, flow) {
-        if (!flow)
-            flow = "default";
-        return this.makeRequest(service, request, timeout, retries, flow);
-    }
-    // Factory methods for creating specialized API instances
-    librarian() {
-        return new LibrarianApi(this);
-    }
-    flows() {
-        return new FlowsApi(this);
-    }
-    flow(id) {
-        return new FlowApi(this, id);
-    }
-    knowledge() {
-        return new KnowledgeApi(this);
-    }
-    config() {
-        return new ConfigApi(this);
-    }
-    collectionManagement() {
-        return new CollectionManagementApi(this);
-    }
-}
-/**
- * LibrarianApi - Manages document storage and retrieval
- * Handles document lifecycle including upload, processing, and removal
- */
-class LibrarianApi {
-    constructor(api) {
-        this.api = api;
-    }
-    /**
-     * Retrieves list of all documents in the system
-     */
-    getDocuments() {
-        return this.api
-            .makeRequest("librarian", {
-            operation: "list-documents",
-            user: "trustgraph",
-        }, 60000)
-            .then((r) => r["document-metadatas"]);
-    }
-    /**
-     * Retrieves list of documents currently being processed
-     */
-    getProcessing() {
-        return this.api
-            .makeRequest("librarian", {
-            operation: "list-processing",
-            user: "trustgraph",
-        }, 60000)
-            .then((r) => r["processing-metadata"]);
-    }
-    /**
-     * Uploads a document to the library with full metadata
-     * @param document - Base64-encoded document content
-     * @param id - Optional document identifier
-     * @param metadata - Optional metadata as triples
-     * @param mimeType - Document MIME type
-     * @param title - Document title
-     * @param comments - Additional comments
-     * @param tags - Document tags for categorization
-     * @param user - User identifier
-     */
-    loadDocument(document, // base64-encoded doc
-    mimeType, title, comments, tags, user, id, metadata) {
-        return this.api.makeRequest("librarian", {
-            operation: "add-document",
-            "document-metadata": {
-                id: id,
-                time: Math.floor(Date.now() / 1000), // Unix timestamp
-                kind: mimeType,
-                title: title,
-                comments: comments,
-                metadata: metadata,
-                user: user ? user : "trustgraph",
-                tags: tags,
-            },
-            content: document,
-        }, 30000);
-    }
-    /**
-     * Removes a document from the library
-     */
-    removeDocument(id, collection) {
-        return this.api.makeRequest("librarian", {
-            operation: "remove-document",
-            "document-id": id,
-            user: this.api.user,
-            collection: collection || "default",
-        }, 30000);
-    }
-    /**
-     * Adds a document to the processing queue
-     * @param id - Processing job identifier
-     * @param doc_id - Document to process
-     * @param flow - Processing flow to use
-     * @param user - User identifier
-     * @param collection - Collection to add processed data to
-     * @param tags - Tags for the processing job
-     */
-    addProcessing(id, doc_id, flow, user, collection, tags) {
-        return this.api.makeRequest("librarian", {
-            operation: "add-processing",
-            "processing-metadata": {
-                id: id,
-                "document-id": doc_id,
-                time: Math.floor(Date.now() / 1000),
-                flow: flow,
-                user: user ? user : "trustgraph",
-                collection: collection ? collection : "default",
-                tags: tags ? tags : [],
-            },
-        }, 30000);
-    }
-}
-/**
- * FlowsApi - Manages processing flows and configuration
- * Flows define how documents and data are processed through the system
- */
-class FlowsApi {
-    constructor(api) {
-        this.api = api;
-    }
-    /**
-     * Retrieves list of available flows
-     */
-    getFlows() {
-        return this.api
-            .makeRequest("flow", {
-            operation: "list-flows",
-        }, 60000)
-            .then((r) => r["flow-ids"] || []);
-    }
-    /**
-     * Retrieves definition of a specific flow
-     */
-    getFlow(id) {
-        return this.api
-            .makeRequest("flow", {
-            operation: "get-flow",
-            "flow-id": id,
-        }, 60000)
-            .then((r) => JSON.parse(r.flow || "{}")); // Parse JSON flow definition
-    }
-    // Configuration management methods
-    /**
-     * Retrieves all configuration settings
-     */
-    getConfigAll() {
-        return this.api.makeRequest("config", {
-            operation: "config",
-        }, 60000);
-    }
-    /**
-     * Retrieves specific configuration values by key
-     */
-    getConfig(keys) {
-        return this.api.makeRequest("config", {
-            operation: "get",
-            keys: keys,
-        }, 60000);
-    }
-    /**
-     * Updates configuration values
-     */
-    putConfig(values) {
-        return this.api.makeRequest("config", {
-            operation: "put",
-            values: values,
-        }, 60000);
-    }
-    /**
-     * Deletes configuration entries
-     */
-    deleteConfig(keys) {
-        return this.api.makeRequest("config", {
-            operation: "delete",
-            keys: keys,
-        }, 30000);
-    }
-    // Prompt management - specialized config operations for AI prompts
-    /**
-     * Retrieves list of available prompt templates
-     */
-    getPrompts() {
-        return this.getConfigAll().then((r) => {
-            const config = r;
-            return JSON.parse(config.config.prompt["template-index"]);
-        });
-    }
-    /**
-     * Retrieves a specific prompt template
-     */
-    getPrompt(id) {
-        return this.getConfigAll().then((r) => {
-            const config = r;
-            return JSON.parse(config.config.prompt[`template.${id}`]);
-        });
-    }
-    /**
-     * Retrieves the system prompt configuration
-     */
-    getSystemPrompt() {
-        return this.getConfigAll().then((r) => {
-            const config = r;
-            return JSON.parse(config.config.prompt.system);
-        });
-    }
-    // Flow class management - templates for creating flows
-    /**
-     * Retrieves list of available flow classes (templates)
-     */
-    getFlowClasses() {
-        return this.api
-            .makeRequest("flow", {
-            operation: "list-classes",
-        }, 60000)
-            .then((r) => r["class-names"]);
-    }
-    /**
-     * Retrieves definition of a specific flow class
-     */
-    getFlowClass(name) {
-        return this.api
-            .makeRequest("flow", {
-            operation: "get-class",
-            "class-name": name,
-        }, 60000)
-            .then((r) => JSON.parse(r["class-definition"] || "{}"));
-    }
-    /**
-     * Deletes a flow class
-     */
-    deleteFlowClass(name) {
-        return this.api.makeRequest("flow", {
-            operation: "delete-class",
-            "class-name": name,
-        }, 30000);
-    }
-    // Flow lifecycle management
-    /**
-     * Starts a new flow instance
-     */
-    startFlow(id, class_name, description, parameters) {
-        const request = {
-            operation: "start-flow",
-            "flow-id": id,
-            "class-name": class_name,
-            description: description,
-        };
-        // Only include parameters if provided and not empty
-        if (parameters && Object.keys(parameters).length > 0) {
-            request.parameters = parameters;
-        }
-        return this.api
-            .makeRequest("flow", request, 30000)
-            .then((response) => {
-            if (response.error) {
-                let errorMessage = "Flow start failed";
-                if (typeof response.error === "object" &&
-                    response.error &&
-                    "message" in response.error) {
-                    errorMessage =
-                        response.error.message || errorMessage;
-                }
-                else if (typeof response.error === "string") {
-                    errorMessage = response.error;
-                }
-                throw new Error(errorMessage);
-            }
-            return response;
-        });
-    }
-    /**
-     * Stops a running flow instance
-     */
-    stopFlow(id) {
-        return this.api.makeRequest("flow", {
-            operation: "stop-flow",
-            "flow-id": id,
-        }, 30000);
-    }
-}
-/**
- * FlowApi - Interface for interacting with a specific flow instance
- * Provides flow-specific versions of core AI/ML operations
- */
-class FlowApi {
-    constructor(api, flowId) {
-        this.api = api;
-        this.flowId = flowId; // All requests will be routed through this flow
-    }
-    /**
-     * Performs text completion using AI models within this flow
-     */
-    textCompletion(system, text) {
-        return this.api
-            .makeRequest("text-completion", {
-            system: system, // System prompt/instructions
-            prompt: text, // User prompt
-        }, 30000, undefined, // Use default retries
-        this.flowId)
-            .then((r) => r.response);
-    }
-    /**
-     * Performs Graph RAG (Retrieval Augmented Generation) query
-     */
-    graphRag(text, options, collection) {
-        return this.api
-            .makeRequest("graph-rag", {
-            query: text,
-            user: this.api.user,
-            collection: collection || "default",
-            "entity-limit": options?.entityLimit,
-            "triple-limit": options?.tripleLimit,
-            "max-subgraph-size": options?.maxSubgraphSize,
-            "max-path-length": options?.pathLength,
-        }, 60000, // Longer timeout for complex graph operations
-        undefined, this.flowId)
-            .then((r) => r.response);
-    }
-    /**
-     * Performs Document RAG (Retrieval Augmented Generation) query
-     */
-    documentRag(text, docLimit, collection) {
-        return this.api
-            .makeRequest("document-rag", {
-            query: text,
-            user: this.api.user,
-            collection: collection || "default",
-            "doc-limit": docLimit || 20,
-        }, 60000, // Longer timeout for document operations
-        undefined, this.flowId)
-            .then((r) => r.response);
-    }
-    /**
-     * Interacts with an AI agent that provides streaming responses
-     */
-    agent(question, think, // Called when agent is thinking
-    observe, // Called when agent observes something
-    answer, // Called when agent provides answer
-    error) {
-        // Create a receiver function to handle streaming responses
-        const receiver = (response) => {
-            console.log("Agent response received:", response);
-            const resp = response;
-            // Check for backend errors
-            if (resp.error) {
-                const errorObj = resp.error;
-                const errorMessage = (typeof errorObj.message === "string" ? errorObj.message : null) ||
-                    "Unknown agent error";
-                error(`Agent error: ${errorMessage}`);
-                return true; // End streaming on error
-            }
-            // Handle different response types
-            if (typeof resp.thought === "string")
-                think(resp.thought);
-            if (typeof resp.observation === "string")
-                observe(resp.observation);
-            if (typeof resp.answer === "string") {
-                answer(resp.answer);
-                return true; // End streaming when final answer is received
-            }
-            return false; // Continue streaming
-        };
-        // Use the existing makeRequestMulti infrastructure
-        return this.api
-            .makeRequestMulti("agent", {
-            question: question,
-            user: this.api.user,
-        }, receiver, 120000, // 120 second timeout
-        2, // 2 retries
-        this.flowId)
-            .catch((err) => {
-            // Handle any errors from makeRequestMulti
-            const errorMessage = err instanceof Error
-                ? err.message
-                : err?.toString() || "Unknown error";
-            error(`Agent request failed: ${errorMessage}`);
-        });
-    }
-    /**
-     * Generates embeddings for text within this flow
-     */
-    embeddings(text) {
-        return this.api
-            .makeRequest("embeddings", {
-            text: text,
-        }, 30000, undefined, this.flowId)
-            .then((r) => r.vectors);
-    }
-    /**
-     * Queries the knowledge graph using embedding vectors
-     */
-    graphEmbeddingsQuery(vecs, limit, collection) {
-        return this.api
-            .makeRequest("graph-embeddings", {
-            vectors: vecs,
-            limit: limit ? limit : 20, // Default to 20 results
-            user: this.api.user,
-            collection: collection || "default",
-        }, 30000, undefined, this.flowId)
-            .then((r) => r.entities);
-    }
-    /**
-     * Queries knowledge graph triples (subject-predicate-object relationships)
-     * All parameters are optional - omitted parameters act as wildcards
-     */
-    triplesQuery(s, p, o, limit, collection) {
-        return this.api
-            .makeRequest("triples", {
-            s: s, // Subject
-            p: p, // Predicate
-            o: o, // Object
-            limit: limit ? limit : 20,
-            user: this.api.user,
-            collection: collection || "default",
-        }, 30000, undefined, this.flowId)
-            .then((r) => r.response);
-    }
-    /**
-     * Loads a document into this flow for processing
-     */
-    loadDocument(document, // base64-encoded document
-    id, metadata) {
-        return this.api.makeRequest("document-load", {
-            id: id,
-            metadata: metadata,
-            data: document,
-        }, 30000, undefined, this.flowId);
-    }
-    /**
-     * Loads plain text into this flow for processing
-     */
-    loadText(text, // Text content
-    id, metadata, charset) {
-        return this.api.makeRequest("text-load", {
-            id: id,
-            metadata: metadata,
-            text: text,
-            charset: charset,
-        }, 30000, undefined, this.flowId);
-    }
-    /**
-     * Executes a GraphQL query against structured data objects
-     */
-    objectsQuery(query, collection, variables, operationName) {
-        return this.api
-            .makeRequest("objects", {
-            query: query,
-            user: this.api.user,
-            collection: collection || "default",
-            variables: variables,
-            operation_name: operationName,
-        }, 30000, undefined, this.flowId)
-            .then((r) => {
-            // Return the GraphQL response structure directly
-            const result = {};
-            if (r.data !== undefined)
-                result.data = r.data;
-            if (r.errors)
-                result.errors = r.errors;
-            if (r.extensions)
-                result.extensions = r.extensions;
-            return result;
-        });
-    }
-    /**
-     * Converts a natural language question to a GraphQL query
-     */
-    nlpQuery(question, maxResults) {
-        return this.api
-            .makeRequest("nlp-query", {
-            question: question,
-            max_results: maxResults || 100,
-        }, 30000, undefined, this.flowId)
-            .then((r) => r);
-    }
-    /**
-     * Executes a natural language question against structured data
-     * Combines NLP query conversion and GraphQL execution
-     */
-    structuredQuery(question, collection) {
-        return this.api
-            .makeRequest("structured-query", {
-            question: question,
-            user: this.api.user,
-            collection: collection || "default",
-        }, 30000, undefined, this.flowId)
-            .then((r) => {
-            // Return the response structure directly
-            const result = {};
-            if (r.data !== undefined)
-                result.data = r.data;
-            if (r.errors)
-                result.errors = r.errors;
-            return result;
-        });
-    }
-}
-/**
- * ConfigApi - Dedicated configuration management interface
- * Handles system configuration, prompts, and token cost tracking
- */
-class ConfigApi {
-    constructor(api) {
-        this.api = api;
-    }
-    /**
-     * Retrieves complete configuration
-     */
-    getConfigAll() {
-        return this.api.makeRequest("config", {
-            operation: "config",
-        }, 60000);
-    }
-    /**
-     * Retrieves specific configuration entries
-     */
-    getConfig(keys) {
-        return this.api.makeRequest("config", {
-            operation: "get",
-            keys: keys,
-        }, 60000);
-    }
-    /**
-     * Updates configuration values
-     */
-    putConfig(values) {
-        return this.api.makeRequest("config", {
-            operation: "put",
-            values: values,
-        }, 60000);
-    }
-    /**
-     * Deletes configuration entries
-     */
-    deleteConfig(keys) {
-        return this.api.makeRequest("config", {
-            operation: "delete",
-            keys: keys,
-        }, 30000);
-    }
-    // Specialized prompt management methods
-    /**
-     * Retrieves available prompt templates
-     */
-    getPrompts() {
-        return this.getConfigAll().then((r) => {
-            const config = r;
-            return JSON.parse(config.config.prompt["template-index"]);
-        });
-    }
-    /**
-     * Retrieves a specific prompt template
-     */
-    getPrompt(id) {
-        return this.getConfigAll().then((r) => {
-            const config = r;
-            return JSON.parse(config.config.prompt[`template.${id}`]);
-        });
-    }
-    /**
-     * Retrieves system prompt configuration
-     */
-    getSystemPrompt() {
-        return this.getConfigAll().then((r) => {
-            const config = r;
-            return JSON.parse(config.config.prompt.system);
-        });
-    }
-    /**
-     * Lists available configuration types
-     */
-    list(type) {
-        return this.api
-            .makeRequest("config", {
-            operation: "list",
-            type: type,
-        }, 60000)
-            .then((r) => r);
-    }
-    /**
-     * Retrieves all key/values for a specific type
-     */
-    getValues(type) {
-        return this.api
-            .makeRequest("config", {
-            operation: "getvalues",
-            type: type,
-        }, 60000)
-            .then((r) => r.values);
-    }
-    /**
-     * Retrieves token cost information for different AI models
-     * Useful for cost tracking and optimization
-     */
-    getTokenCosts() {
-        return this.api
-            .makeRequest("config", {
-            operation: "getvalues",
-            type: "token-costs",
-        }, 60000)
-            .then((r) => {
-            // Parse JSON values and restructure data
-            const response = r;
-            return (response.values || []).map((x) => {
-                const item = x;
-                return { key: item.key, value: JSON.parse(item.value) };
-            });
-        })
-            .then((r) => 
-        // Transform to more usable format
-        r.map((x) => {
-            const item = x;
-            const value = item.value;
-            return {
-                model: item.key,
-                input_price: value.input_price, // Cost per input token
-                output_price: value.output_price, // Cost per output token
-            };
-        }));
-    }
-}
-/**
- * KnowledgeApi - Manages knowledge graph cores and data
- * Knowledge cores appear to be collections of processed knowledge graph data
- */
-class KnowledgeApi {
-    constructor(api) {
-        this.api = api;
-    }
-    /**
-     * Retrieves list of available knowledge graph cores
-     */
-    getKnowledgeCores() {
-        return this.api
-            .makeRequest("knowledge", {
-            operation: "list-kg-cores",
-            user: "trustgraph",
-        }, 60000)
-            .then((r) => r.ids);
-    }
-    /**
-     * Deletes a knowledge graph core
-     */
-    deleteKgCore(id, collection) {
-        return this.api.makeRequest("knowledge", {
-            operation: "delete-kg-core",
-            id: id,
-            user: this.api.user,
-            collection: collection || "default",
-        }, 30000);
-    }
-    /**
-     * Deletes a knowledge graph core
-     */
-    loadKgCore(id, flow, collection) {
-        return this.api.makeRequest("knowledge", {
-            operation: "load-kg-core",
-            id: id,
-            flow: flow,
-            user: this.api.user,
-            collection: collection || "default",
-        }, 30000);
-    }
-    /**
-     * Retrieves a knowledge graph core with streaming data
-     * Uses multi-request pattern for large datasets
-     * @param receiver - Callback function to handle streaming data chunks
-     */
-    getKgCore(id, collection, receiver) {
-        // Wrapper to handle end-of-stream detection
-        const recv = (msg) => {
-            const response = msg;
-            if (response.eos) {
-                // End of stream - notify receiver and signal completion
-                receiver(msg, true);
-                return true;
-            }
-            else {
-                // Regular message - continue streaming
-                receiver(msg, false);
-                return false;
-            }
-        };
-        return this.api.makeRequestMulti("knowledge", {
-            operation: "get-kg-core",
-            id: id,
-            user: this.api.user,
-            collection: collection || "default",
-        }, recv, // Stream handler
-        30000);
-    }
-}
-/**
- * CollectionManagementApi - Manages collections for organizing documents
- * Provides operations for listing, creating, updating, and deleting collections
- */
-class CollectionManagementApi {
-    constructor(api) {
-        this.api = api;
-    }
-    /**
-     * Lists all collections for a user with optional tag filtering
-     * @param user - User identifier
-     * @param tagFilter - Optional array of tags to filter collections
-     * @returns Promise resolving to array of collection metadata
-     */
-    listCollections(user, tagFilter) {
-        const request = {
-            operation: "list-collections",
-            user,
-        };
-        if (tagFilter && tagFilter.length > 0) {
-            request.tag_filter = tagFilter;
-        }
-        return this.api
-            .makeRequest("collection-management", request, 30000)
-            .then((r) => r.collections || []);
-    }
-    /**
-     * Creates or updates a collection
-     * @param user - User identifier
-     * @param collection - Collection ID (unique identifier)
-     * @param name - Display name for the collection
-     * @param description - Description of the collection
-     * @param tags - Array of tags for categorization
-     * @returns Promise resolving to updated collection metadata
-     */
-    updateCollection(user, collection, name, description, tags) {
-        const request = {
-            operation: "update-collection",
-            user,
-            collection,
-        };
-        if (name !== undefined) {
-            request.name = name;
-        }
-        if (description !== undefined) {
-            request.description = description;
-        }
-        if (tags !== undefined) {
-            request.tags = tags;
-        }
-        return this.api
-            .makeRequest("collection-management", request, 30000)
-            .then((r) => {
-            if (r.collections &&
-                Array.isArray(r.collections) &&
-                r.collections.length > 0) {
-                return r.collections[0];
-            }
-            throw new Error("Failed to update collection");
-        });
-    }
-    /**
-     * Deletes a collection and all its data
-     * @param user - User identifier
-     * @param collection - Collection ID to delete
-     * @returns Promise resolving when deletion is complete
-     */
-    deleteCollection(user, collection) {
-        return this.api.makeRequest("collection-management", {
-            operation: "delete-collection",
-            user,
-            collection,
-        }, 30000);
-    }
-}
-/**
- * Factory function to create a new TrustGraph WebSocket connection
- * This is the main entry point for using the TrustGraph API
- * @param user - User identifier for API requests
- * @param token - Optional authentication token for secure connections
- */
-const createTrustGraphSocket = (user, token) => {
-    return new BaseApi(user, token);
-};
-
-exports.BaseApi = BaseApi;
-exports.CollectionManagementApi = CollectionManagementApi;
-exports.ConfigApi = ConfigApi;
-exports.FlowApi = FlowApi;
-exports.FlowsApi = FlowsApi;
-exports.KnowledgeApi = KnowledgeApi;
-exports.LibrarianApi = LibrarianApi;
-exports.createTrustGraphSocket = createTrustGraphSocket;
-//# sourceMappingURL=index.js.map