@robosystems/client 0.2.11 → 0.2.12

package/sdk/types.gen.ts

@@ -914,7 +914,7 @@ export type CheckoutStatusResponse = {
     subscription_id: string;
     /**
      * Resource Id
-     * Resource ID (graph_id or repository name) once provisioned
+     * Resource ID (graph_id for both graphs and repositories) once provisioned. For repositories, this is the repository slug (e.g., 'sec')
      */
     resource_id?: string | null;
     /**
@@ -1154,7 +1154,7 @@ export type CreateCheckoutRequest = {
     resource_type: string;
     /**
      * Resource Config
-     * Configuration for the resource to be provisioned
+     * Configuration for the resource to be provisioned. For repositories: {'repository_name': 'graph_id'} where graph_id is the repository slug (e.g., 'sec')
      */
     resource_config: {
         [key: string]: unknown;
@@ -6255,6 +6255,46 @@ export type SyncConnectionResponses = {
 
 export type SyncConnectionResponse = SyncConnectionResponses[keyof SyncConnectionResponses];
 
+export type ListAgentsData = {
+    body?: never;
+    path: {
+        /**
+         * Graph Id
+         */
+        graph_id: string;
+    };
+    query?: {
+        /**
+         * Capability
+         * Filter by capability (e.g., 'financial_analysis', 'rag_search')
+         */
+        capability?: string | null;
+    };
+    url: '/v1/graphs/{graph_id}/agent';
+};
+
+export type ListAgentsErrors = {
+    /**
+     * Unauthorized - Invalid or missing authentication
+     */
+    401: unknown;
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export type ListAgentsError = ListAgentsErrors[keyof ListAgentsErrors];
+
+export type ListAgentsResponses = {
+    /**
+     * List of agents retrieved successfully
+     */
+    200: AgentListResponse;
+};
+
+export type ListAgentsResponse = ListAgentsResponses[keyof ListAgentsResponses];
+
 export type AutoSelectAgentData = {
     body: AgentRequest;
     path: {
@@ -6263,7 +6303,13 @@ export type AutoSelectAgentData = {
          */
         graph_id: string;
     };
-    query?: never;
+    query?: {
+        /**
+         * Mode
+         * Override execution mode: sync, async, stream, or auto
+         */
+        mode?: ResponseMode | null;
+    };
     url: '/v1/graphs/{graph_id}/agent';
 };
 
@@ -6297,10 +6343,53 @@ export type AutoSelectAgentResponses = {
      * Query successfully processed by selected agent
      */
     200: AgentResponse;
+    /**
+     * Query queued for async processing with operation tracking
+     */
+    202: unknown;
 };
 
 export type AutoSelectAgentResponse = AutoSelectAgentResponses[keyof AutoSelectAgentResponses];
 
+export type GetAgentMetadataData = {
+    body?: never;
+    path: {
+        /**
+         * Graph Id
+         */
+        graph_id: string;
+        /**
+         * Agent Type
+         * Agent type identifier (e.g., 'financial', 'research', 'rag')
+         */
+        agent_type: string;
+    };
+    query?: never;
+    url: '/v1/graphs/{graph_id}/agent/{agent_type}';
+};
+
+export type GetAgentMetadataErrors = {
+    /**
+     * Agent type not found
+     */
+    404: unknown;
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export type GetAgentMetadataError = GetAgentMetadataErrors[keyof GetAgentMetadataErrors];
+
+export type GetAgentMetadataResponses = {
+    /**
+     * Agent metadata retrieved successfully
+     */
+    200: AgentMetadataResponse;
+};
+
+export type GetAgentMetadataResponse = GetAgentMetadataResponses[keyof GetAgentMetadataResponses];
+
 export type ExecuteSpecificAgentData = {
     body: AgentRequest;
     path: {
@@ -6313,7 +6402,13 @@ export type ExecuteSpecificAgentData = {
          */
         graph_id: string;
     };
-    query?: never;
+    query?: {
+        /**
+         * Mode
+         * Override execution mode: sync, async, stream, or auto
+         */
+        mode?: ResponseMode | null;
+    };
     url: '/v1/graphs/{graph_id}/agent/{agent_type}';
 };
 
@@ -6351,6 +6446,10 @@ export type ExecuteSpecificAgentResponses = {
      * Query successfully processed by specified agent
      */
     200: AgentResponse;
+    /**
+     * Query queued for async processing with operation tracking
+     */
+    202: unknown;
 };
 
 export type ExecuteSpecificAgentResponse = ExecuteSpecificAgentResponses[keyof ExecuteSpecificAgentResponses];
@@ -6397,85 +6496,6 @@ export type BatchProcessQueriesResponses = {
 
 export type BatchProcessQueriesResponse = BatchProcessQueriesResponses[keyof BatchProcessQueriesResponses];
 
-export type ListAgentsData = {
-    body?: never;
-    path: {
-        /**
-         * Graph Id
-         */
-        graph_id: string;
-    };
-    query?: {
-        /**
-         * Capability
-         * Filter by capability (e.g., 'financial_analysis', 'rag_search')
-         */
-        capability?: string | null;
-    };
-    url: '/v1/graphs/{graph_id}/agent/list';
-};
-
-export type ListAgentsErrors = {
-    /**
-     * Unauthorized - Invalid or missing authentication
-     */
-    401: unknown;
-    /**
-     * Validation Error
-     */
-    422: HttpValidationError;
-};
-
-export type ListAgentsError = ListAgentsErrors[keyof ListAgentsErrors];
-
-export type ListAgentsResponses = {
-    /**
-     * List of agents retrieved successfully
-     */
-    200: AgentListResponse;
-};
-
-export type ListAgentsResponse = ListAgentsResponses[keyof ListAgentsResponses];
-
-export type GetAgentMetadataData = {
-    body?: never;
-    path: {
-        /**
-         * Graph Id
-         */
-        graph_id: string;
-        /**
-         * Agent Type
-         * Agent type identifier (e.g., 'financial', 'research', 'rag')
-         */
-        agent_type: string;
-    };
-    query?: never;
-    url: '/v1/graphs/{graph_id}/agent/{agent_type}/metadata';
-};
-
-export type GetAgentMetadataErrors = {
-    /**
-     * Agent type not found
-     */
-    404: unknown;
-    /**
-     * Validation Error
-     */
-    422: HttpValidationError;
-};
-
-export type GetAgentMetadataError = GetAgentMetadataErrors[keyof GetAgentMetadataErrors];
-
-export type GetAgentMetadataResponses = {
-    /**
-     * Agent metadata retrieved successfully
-     */
-    200: AgentMetadataResponse;
-};
-
-export type GetAgentMetadataResponse = GetAgentMetadataResponses[keyof GetAgentMetadataResponses];
-
 export type RecommendAgentData = {
     body: AgentRecommendationRequest;
     path: {
@@ -7214,6 +7234,7 @@ export type ListCreditTransactionsData = {
     path: {
         /**
          * Graph Id
+         * Graph database identifier
          */
         graph_id: string;
     };

package/sdk-extensions/AgentClient.d.ts

@@ -0,0 +1,82 @@
+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 declare class AgentClient {
+    private sseClient?;
+    private config;
+    constructor(config: {
+        baseUrl: string;
+        credentials?: 'include' | 'same-origin' | 'omit';
+        headers?: Record<string, string>;
+        token?: string;
+    });
+    /**
+     * Execute agent query with automatic agent selection
+     */
+    executeQuery(graphId: string, request: AgentQueryRequest, options?: AgentOptions): Promise<AgentResult>;
+    /**
+     * Execute specific agent type
+     */
+    executeAgent(graphId: string, agentType: string, request: AgentQueryRequest, options?: AgentOptions): Promise<AgentResult>;
+    private waitForAgentCompletion;
+    /**
+     * Convenience method for simple agent queries with auto-selection
+     */
+    query(graphId: string, message: string, context?: Record<string, any>): Promise<AgentResult>;
+    /**
+     * Execute financial agent for financial analysis
+     */
+    analyzeFinancials(graphId: string, message: string, options?: AgentOptions): Promise<AgentResult>;
+    /**
+     * Execute research agent for deep research
+     */
+    research(graphId: string, message: string, options?: AgentOptions): Promise<AgentResult>;
+    /**
+     * Execute RAG agent for fast retrieval
+     */
+    rag(graphId: string, message: string, options?: AgentOptions): Promise<AgentResult>;
+    /**
+     * Cancel any active SSE connections
+     */
+    close(): void;
+}
+/**
+ * Error thrown when agent execution is queued and maxWait is 0
+ */
+export declare class QueuedAgentError extends Error {
+    queueInfo: QueuedAgentResponse;
+    constructor(queueInfo: QueuedAgentResponse);
+}

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;