@trustgraph/client 0.2.0

package/dist/index.js

@@ -0,0 +1,1375 @@
+'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