@robosystems/client 0.2.11 → 0.2.13

package/sdk-extensions/AgentClient.js

@@ -0,0 +1,218 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueuedAgentError = exports.AgentClient = void 0;
+/**
+ * Enhanced Agent Client with SSE support
+ * Provides intelligent agent execution with automatic strategy selection
+ */
+const sdk_gen_1 = require("../sdk/sdk.gen");
+const SSEClient_1 = require("./SSEClient");
+class AgentClient {
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Execute agent query with automatic agent selection
+     */
+    async executeQuery(graphId, request, options = {}) {
+        const data = {
+            url: '/v1/graphs/{graph_id}/agent',
+            path: { graph_id: graphId },
+            body: {
+                message: request.message,
+                history: request.history,
+                context: request.context,
+                mode: request.mode,
+                enable_rag: request.enableRag,
+                force_extended_analysis: request.forceExtendedAnalysis,
+            },
+        };
+        const response = await (0, sdk_gen_1.autoSelectAgent)(data);
+        const responseData = response.data;
+        // Check if this is an immediate response (sync execution)
+        if (responseData?.content !== undefined && responseData?.agent_used) {
+            return {
+                content: responseData.content,
+                agent_used: responseData.agent_used,
+                mode_used: responseData.mode_used,
+                metadata: responseData.metadata,
+                tokens_used: responseData.tokens_used,
+                confidence_score: responseData.confidence_score,
+                execution_time: responseData.execution_time,
+                timestamp: new Date().toISOString(),
+            };
+        }
+        // Check if this is a queued response (async Celery execution)
+        if (responseData?.operation_id) {
+            const queuedResponse = responseData;
+            // If user doesn't want to wait, throw with queue info
+            if (options.maxWait === 0) {
+                throw new QueuedAgentError(queuedResponse);
+            }
+            // Use SSE to monitor the operation
+            return this.waitForAgentCompletion(queuedResponse.operation_id, options);
+        }
+        // Unexpected response format
+        throw new Error('Unexpected response format from agent endpoint');
+    }
+    /**
+     * Execute specific agent type
+     */
+    async executeAgent(graphId, agentType, request, options = {}) {
+        const data = {
+            url: '/v1/graphs/{graph_id}/agent/{agent_type}',
+            path: { graph_id: graphId, agent_type: agentType },
+            body: {
+                message: request.message,
+                history: request.history,
+                context: request.context,
+                mode: request.mode,
+                enable_rag: request.enableRag,
+                force_extended_analysis: request.forceExtendedAnalysis,
+            },
+        };
+        const response = await (0, sdk_gen_1.executeSpecificAgent)(data);
+        const responseData = response.data;
+        // Check if this is an immediate response (sync execution)
+        if (responseData?.content !== undefined && responseData?.agent_used) {
+            return {
+                content: responseData.content,
+                agent_used: responseData.agent_used,
+                mode_used: responseData.mode_used,
+                metadata: responseData.metadata,
+                tokens_used: responseData.tokens_used,
+                confidence_score: responseData.confidence_score,
+                execution_time: responseData.execution_time,
+                timestamp: new Date().toISOString(),
+            };
+        }
+        // Check if this is a queued response (async Celery execution)
+        if (responseData?.operation_id) {
+            const queuedResponse = responseData;
+            // If user doesn't want to wait, throw with queue info
+            if (options.maxWait === 0) {
+                throw new QueuedAgentError(queuedResponse);
+            }
+            // Use SSE to monitor the operation
+            return this.waitForAgentCompletion(queuedResponse.operation_id, options);
+        }
+        // Unexpected response format
+        throw new Error('Unexpected response format from agent endpoint');
+    }
+    async waitForAgentCompletion(operationId, options) {
+        return new Promise((resolve, reject) => {
+            const sseClient = new SSEClient_1.SSEClient(this.config);
+            sseClient
+                .connect(operationId)
+                .then(() => {
+                let result = null;
+                // Listen for progress events
+                sseClient.on(SSEClient_1.EventType.OPERATION_PROGRESS, (data) => {
+                    options.onProgress?.(data.message, data.progress_percentage);
+                });
+                // Listen for agent-specific events
+                sseClient.on('agent_started', (data) => {
+                    options.onProgress?.(`Agent ${data.agent_type} started`, 0);
+                });
+                sseClient.on('agent_initialized', (data) => {
+                    options.onProgress?.(`${data.agent_name} initialized`, 10);
+                });
+                sseClient.on('progress', (data) => {
+                    options.onProgress?.(data.message, data.percentage);
+                });
+                sseClient.on('agent_completed', (data) => {
+                    result = {
+                        content: data.content,
+                        agent_used: data.agent_used,
+                        mode_used: data.mode_used,
+                        metadata: data.metadata,
+                        tokens_used: data.tokens_used,
+                        confidence_score: data.confidence_score,
+                        execution_time: data.execution_time,
+                        timestamp: data.timestamp || new Date().toISOString(),
+                    };
+                    sseClient.close();
+                    resolve(result);
+                });
+                // Fallback to generic completion event
+                sseClient.on(SSEClient_1.EventType.OPERATION_COMPLETED, (data) => {
+                    if (!result) {
+                        const agentResult = data.result || data;
+                        result = {
+                            content: agentResult.content || '',
+                            agent_used: agentResult.agent_used || 'unknown',
+                            mode_used: agentResult.mode_used || 'standard',
+                            metadata: agentResult.metadata,
+                            tokens_used: agentResult.tokens_used,
+                            confidence_score: agentResult.confidence_score,
+                            execution_time: agentResult.execution_time,
+                            timestamp: agentResult.timestamp || new Date().toISOString(),
+                        };
+                        sseClient.close();
+                        resolve(result);
+                    }
+                });
+                sseClient.on(SSEClient_1.EventType.OPERATION_ERROR, (error) => {
+                    sseClient.close();
+                    reject(new Error(error.message || error.error));
+                });
+                sseClient.on(SSEClient_1.EventType.OPERATION_CANCELLED, () => {
+                    sseClient.close();
+                    reject(new Error('Agent execution cancelled'));
+                });
+                // Handle generic error event
+                sseClient.on('error', (error) => {
+                    sseClient.close();
+                    reject(new Error(error.error || error.message || 'Agent execution failed'));
+                });
+            })
+                .catch(reject);
+        });
+    }
+    /**
+     * Convenience method for simple agent queries with auto-selection
+     */
+    async query(graphId, message, context) {
+        return this.executeQuery(graphId, { message, context }, { mode: 'auto' });
+    }
+    /**
+     * Execute financial agent for financial analysis
+     */
+    async analyzeFinancials(graphId, message, options = {}) {
+        return this.executeAgent(graphId, 'financial', { message }, options);
+    }
+    /**
+     * Execute research agent for deep research
+     */
+    async research(graphId, message, options = {}) {
+        return this.executeAgent(graphId, 'research', { message }, options);
+    }
+    /**
+     * Execute RAG agent for fast retrieval
+     */
+    async rag(graphId, message, options = {}) {
+        return this.executeAgent(graphId, 'rag', { message }, options);
+    }
+    /**
+     * Cancel any active SSE connections
+     */
+    close() {
+        if (this.sseClient) {
+            this.sseClient.close();
+            this.sseClient = undefined;
+        }
+    }
+}
+exports.AgentClient = AgentClient;
+/**
+ * Error thrown when agent execution is queued and maxWait is 0
+ */
+class QueuedAgentError extends Error {
+    constructor(queueInfo) {
+        super('Agent execution was queued');
+        this.queueInfo = queueInfo;
+        this.name = 'QueuedAgentError';
+    }
+}
+exports.QueuedAgentError = QueuedAgentError;

package/sdk-extensions/AgentClient.ts

@@ -0,0 +1,321 @@
+'use client'
+
+/**
+ * Enhanced Agent Client with SSE support
+ * Provides intelligent agent execution with automatic strategy selection
+ */
+
+import { autoSelectAgent, executeSpecificAgent } from '../sdk/sdk.gen'
+import type { AutoSelectAgentData, ExecuteSpecificAgentData } from '../sdk/types.gen'
+import { EventType, SSEClient } from './SSEClient'
+
+export interface AgentQueryRequest {
+  message: string
+  history?: Array<{ role: string; content: string }>
+  context?: Record<string, any>
+  mode?: 'quick' | 'standard' | 'extended' | 'streaming'
+  enableRag?: boolean
+  forceExtendedAnalysis?: boolean
+}
+
+export interface AgentOptions {
+  mode?: 'auto' | 'sync' | 'async'
+  maxWait?: number
+  onProgress?: (message: string, percentage?: number) => void
+}
+
+export interface AgentResult {
+  content: string
+  agent_used: string
+  mode_used: 'quick' | 'standard' | 'extended' | 'streaming'
+  metadata?: Record<string, any>
+  tokens_used?: {
+    prompt_tokens: number
+    completion_tokens: number
+    total_tokens: number
+  }
+  confidence_score?: number
+  execution_time?: number
+  timestamp?: string
+}
+
+export interface QueuedAgentResponse {
+  status: 'queued'
+  operation_id: string
+  message: string
+  sse_endpoint?: string
+}
+
+export class AgentClient {
+  private sseClient?: SSEClient
+  private config: {
+    baseUrl: string
+    credentials?: 'include' | 'same-origin' | 'omit'
+    headers?: Record<string, string>
+    token?: string
+  }
+
+  constructor(config: {
+    baseUrl: string
+    credentials?: 'include' | 'same-origin' | 'omit'
+    headers?: Record<string, string>
+    token?: string
+  }) {
+    this.config = config
+  }
+
+  /**
+   * Execute agent query with automatic agent selection
+   */
+  async executeQuery(
+    graphId: string,
+    request: AgentQueryRequest,
+    options: AgentOptions = {}
+  ): Promise<AgentResult> {
+    const data: AutoSelectAgentData = {
+      url: '/v1/graphs/{graph_id}/agent' as const,
+      path: { graph_id: graphId },
+      body: {
+        message: request.message,
+        history: request.history,
+        context: request.context,
+        mode: request.mode,
+        enable_rag: request.enableRag,
+        force_extended_analysis: request.forceExtendedAnalysis,
+      },
+    }
+
+    const response = await autoSelectAgent(data)
+    const responseData = response.data as any
+
+    // Check if this is an immediate response (sync execution)
+    if (responseData?.content !== undefined && responseData?.agent_used) {
+      return {
+        content: responseData.content,
+        agent_used: responseData.agent_used,
+        mode_used: responseData.mode_used,
+        metadata: responseData.metadata,
+        tokens_used: responseData.tokens_used,
+        confidence_score: responseData.confidence_score,
+        execution_time: responseData.execution_time,
+        timestamp: new Date().toISOString(),
+      }
+    }
+
+    // Check if this is a queued response (async Celery execution)
+    if (responseData?.operation_id) {
+      const queuedResponse = responseData as QueuedAgentResponse
+
+      // If user doesn't want to wait, throw with queue info
+      if (options.maxWait === 0) {
+        throw new QueuedAgentError(queuedResponse)
+      }
+
+      // Use SSE to monitor the operation
+      return this.waitForAgentCompletion(queuedResponse.operation_id, options)
+    }
+
+    // Unexpected response format
+    throw new Error('Unexpected response format from agent endpoint')
+  }
+
+  /**
+   * Execute specific agent type
+   */
+  async executeAgent(
+    graphId: string,
+    agentType: string,
+    request: AgentQueryRequest,
+    options: AgentOptions = {}
+  ): Promise<AgentResult> {
+    const data: ExecuteSpecificAgentData = {
+      url: '/v1/graphs/{graph_id}/agent/{agent_type}' as const,
+      path: { graph_id: graphId, agent_type: agentType },
+      body: {
+        message: request.message,
+        history: request.history,
+        context: request.context,
+        mode: request.mode,
+        enable_rag: request.enableRag,
+        force_extended_analysis: request.forceExtendedAnalysis,
+      },
+    }
+
+    const response = await executeSpecificAgent(data)
+    const responseData = response.data as any
+
+    // Check if this is an immediate response (sync execution)
+    if (responseData?.content !== undefined && responseData?.agent_used) {
+      return {
+        content: responseData.content,
+        agent_used: responseData.agent_used,
+        mode_used: responseData.mode_used,
+        metadata: responseData.metadata,
+        tokens_used: responseData.tokens_used,
+        confidence_score: responseData.confidence_score,
+        execution_time: responseData.execution_time,
+        timestamp: new Date().toISOString(),
+      }
+    }
+
+    // Check if this is a queued response (async Celery execution)
+    if (responseData?.operation_id) {
+      const queuedResponse = responseData as QueuedAgentResponse
+
+      // If user doesn't want to wait, throw with queue info
+      if (options.maxWait === 0) {
+        throw new QueuedAgentError(queuedResponse)
+      }
+
+      // Use SSE to monitor the operation
+      return this.waitForAgentCompletion(queuedResponse.operation_id, options)
+    }
+
+    // Unexpected response format
+    throw new Error('Unexpected response format from agent endpoint')
+  }
+
+  private async waitForAgentCompletion(
+    operationId: string,
+    options: AgentOptions
+  ): Promise<AgentResult> {
+    return new Promise((resolve, reject) => {
+      const sseClient = new SSEClient(this.config)
+
+      sseClient
+        .connect(operationId)
+        .then(() => {
+          let result: AgentResult | null = null
+
+          // Listen for progress events
+          sseClient.on(EventType.OPERATION_PROGRESS, (data) => {
+            options.onProgress?.(data.message, data.progress_percentage)
+          })
+
+          // Listen for agent-specific events
+          sseClient.on('agent_started' as EventType, (data) => {
+            options.onProgress?.(`Agent ${data.agent_type} started`, 0)
+          })
+
+          sseClient.on('agent_initialized' as EventType, (data) => {
+            options.onProgress?.(`${data.agent_name} initialized`, 10)
+          })
+
+          sseClient.on('progress' as EventType, (data) => {
+            options.onProgress?.(data.message, data.percentage)
+          })
+
+          sseClient.on('agent_completed' as EventType, (data) => {
+            result = {
+              content: data.content,
+              agent_used: data.agent_used,
+              mode_used: data.mode_used,
+              metadata: data.metadata,
+              tokens_used: data.tokens_used,
+              confidence_score: data.confidence_score,
+              execution_time: data.execution_time,
+              timestamp: data.timestamp || new Date().toISOString(),
+            }
+            sseClient.close()
+            resolve(result)
+          })
+
+          // Fallback to generic completion event
+          sseClient.on(EventType.OPERATION_COMPLETED, (data) => {
+            if (!result) {
+              const agentResult = data.result || data
+              result = {
+                content: agentResult.content || '',
+                agent_used: agentResult.agent_used || 'unknown',
+                mode_used: agentResult.mode_used || 'standard',
+                metadata: agentResult.metadata,
+                tokens_used: agentResult.tokens_used,
+                confidence_score: agentResult.confidence_score,
+                execution_time: agentResult.execution_time,
+                timestamp: agentResult.timestamp || new Date().toISOString(),
+              }
+              sseClient.close()
+              resolve(result)
+            }
+          })
+
+          sseClient.on(EventType.OPERATION_ERROR, (error) => {
+            sseClient.close()
+            reject(new Error(error.message || error.error))
+          })
+
+          sseClient.on(EventType.OPERATION_CANCELLED, () => {
+            sseClient.close()
+            reject(new Error('Agent execution cancelled'))
+          })
+
+          // Handle generic error event
+          sseClient.on('error' as EventType, (error) => {
+            sseClient.close()
+            reject(new Error(error.error || error.message || 'Agent execution failed'))
+          })
+        })
+        .catch(reject)
+    })
+  }
+
+  /**
+   * Convenience method for simple agent queries with auto-selection
+   */
+  async query(
+    graphId: string,
+    message: string,
+    context?: Record<string, any>
+  ): Promise<AgentResult> {
+    return this.executeQuery(graphId, { message, context }, { mode: 'auto' })
+  }
+
+  /**
+   * Execute financial agent for financial analysis
+   */
+  async analyzeFinancials(
+    graphId: string,
+    message: string,
+    options: AgentOptions = {}
+  ): Promise<AgentResult> {
+    return this.executeAgent(graphId, 'financial', { message }, options)
+  }
+
+  /**
+   * Execute research agent for deep research
+   */
+  async research(
+    graphId: string,
+    message: string,
+    options: AgentOptions = {}
+  ): Promise<AgentResult> {
+    return this.executeAgent(graphId, 'research', { message }, options)
+  }
+
+  /**
+   * Execute RAG agent for fast retrieval
+   */
+  async rag(graphId: string, message: string, options: AgentOptions = {}): Promise<AgentResult> {
+    return this.executeAgent(graphId, 'rag', { message }, options)
+  }
+
+  /**
+   * Cancel any active SSE connections
+   */
+  close(): void {
+    if (this.sseClient) {
+      this.sseClient.close()
+      this.sseClient = undefined
+    }
+  }
+}
+
+/**
+ * Error thrown when agent execution is queued and maxWait is 0
+ */
+export class QueuedAgentError extends Error {
+  constructor(public queueInfo: QueuedAgentResponse) {
+    super('Agent execution was queued')
+    this.name = 'QueuedAgentError'
+  }
+}

package/sdk-extensions/QueryClient.js

@@ -24,17 +24,30 @@ class QueryClient {
                 mode: options.mode,
                 test_mode: options.testMode,
             },
+            // For streaming mode, don't parse response - get raw Response object
+            ...(options.mode === 'stream' ? { parseAs: 'stream' } : {}),
         };
-        // Execute the query
         const response = await (0, sdk_gen_1.executeCypherQuery)(data);
-        // Check if this is an NDJSON streaming response
-        // The SDK returns the response object which includes the raw Response
-        if (response.response) {
+        // Check if this is a raw stream response (when parseAs: 'stream')
+        if (options.mode === 'stream' && response.response) {
             const contentType = response.response.headers.get('content-type') || '';
-            const streamFormat = response.response.headers.get('x-stream-format');
-            if (contentType.includes('application/x-ndjson') || streamFormat === 'ndjson') {
+            if (contentType.includes('application/x-ndjson')) {
                 return this.parseNDJSONResponse(response.response, graphId);
             }
+            else if (contentType.includes('application/json')) {
+                // Fallback: parse JSON manually
+                const data = await response.response.json();
+                if (data.data !== undefined && data.columns) {
+                    return {
+                        data: data.data,
+                        columns: data.columns,
+                        row_count: data.row_count || data.data.length,
+                        execution_time_ms: data.execution_time_ms || 0,
+                        graph_id: graphId,
+                        timestamp: data.timestamp || new Date().toISOString(),
+                    };
+                }
+            }
         }
         const responseData = response.data;
         // Check if this is an immediate response
@@ -58,12 +71,7 @@ class QueryClient {
                 throw new QueuedQueryError(queuedResponse);
             }
             // Use SSE to monitor the operation
-            if (options.mode === 'stream') {
-                return this.streamQueryResults(queuedResponse.operation_id, options);
-            }
-            else {
-                return this.waitForQueryCompletion(queuedResponse.operation_id, options);
-            }
+            return this.waitForQueryCompletion(queuedResponse.operation_id, options);
         }
         // Unexpected response format
         throw new Error('Unexpected response format from query endpoint');
@@ -73,35 +81,75 @@ class QueryClient {
         let columns = null;
         let totalRows = 0;
         let executionTimeMs = 0;
-        // Parse NDJSON line by line
-        const text = await response.text();
-        const lines = text.trim().split('\n');
-        for (const line of lines) {
-            if (!line.trim())
-                continue;
-            try {
-                const chunk = JSON.parse(line);
-                // Extract columns from first chunk
-                if (columns === null && chunk.columns) {
-                    columns = chunk.columns;
-                }
-                // Aggregate data rows (NDJSON uses "rows", regular JSON uses "data")
-                if (chunk.rows) {
-                    allData.push(...chunk.rows);
-                    totalRows += chunk.rows.length;
+        // Use streaming reader to avoid "body already read" error
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error('Response body is not readable');
+        }
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const chunk = JSON.parse(line);
+                        // Extract columns from first chunk
+                        if (columns === null && chunk.columns) {
+                            columns = chunk.columns;
+                        }
+                        // Aggregate data rows (NDJSON uses "rows", regular JSON uses "data")
+                        if (chunk.rows) {
+                            allData.push(...chunk.rows);
+                            totalRows += chunk.rows.length;
+                        }
+                        else if (chunk.data) {
+                            allData.push(...chunk.data);
+                            totalRows += chunk.data.length;
+                        }
+                        // Track execution time (use max from all chunks)
+                        if (chunk.execution_time_ms) {
+                            executionTimeMs = Math.max(executionTimeMs, chunk.execution_time_ms);
+                        }
+                    }
+                    catch (error) {
+                        console.error('Failed to parse NDJSON line:', error);
+                    }
                 }
-                else if (chunk.data) {
-                    allData.push(...chunk.data);
-                    totalRows += chunk.data.length;
+            }
+            // Parse any remaining buffer
+            if (buffer.trim()) {
+                try {
+                    const chunk = JSON.parse(buffer);
+                    if (columns === null && chunk.columns) {
+                        columns = chunk.columns;
+                    }
+                    if (chunk.rows) {
+                        allData.push(...chunk.rows);
+                        totalRows += chunk.rows.length;
+                    }
+                    else if (chunk.data) {
+                        allData.push(...chunk.data);
+                        totalRows += chunk.data.length;
+                    }
+                    if (chunk.execution_time_ms) {
+                        executionTimeMs = Math.max(executionTimeMs, chunk.execution_time_ms);
+                    }
                 }
-                // Track execution time (use max from all chunks)
-                if (chunk.execution_time_ms) {
-                    executionTimeMs = Math.max(executionTimeMs, chunk.execution_time_ms);
+                catch (error) {
+                    console.error('Failed to parse final NDJSON line:', error);
                 }
             }
-            catch (error) {
-                throw new Error(`Failed to parse NDJSON line: ${error}`);
-            }
+        }
+        catch (error) {
+            throw new Error(`NDJSON stream reading error: ${error}`);
         }
         // Return aggregated result
         return {