@robosystems/client 0.2.48 → 0.3.0

package/sdk-extensions/AgentClient.js

@@ -1,218 +0,0 @@
-'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 background task 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 background task 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.test.ts

@@ -1,403 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { AgentClient, QueuedAgentError } from './AgentClient'
-
-// Mock EventSource for SSE tests
-class MockEventSource {
-  url: string
-  withCredentials: boolean
-  readyState: number = 0
-  onopen: ((event: any) => void) | null = null
-  onerror: ((event: any) => void) | null = null
-  onmessage: ((event: any) => void) | null = null
-  private eventListeners: Map<string, Set<(event: any) => void>> = new Map()
-
-  static CONNECTING = 0
-  static OPEN = 1
-  static CLOSED = 2
-
-  constructor(url: string, options?: { withCredentials?: boolean }) {
-    this.url = url
-    this.withCredentials = options?.withCredentials ?? false
-
-    setTimeout(() => {
-      this.readyState = MockEventSource.OPEN
-      if (this.onopen) {
-        this.onopen({ type: 'open' })
-      }
-    }, 0)
-  }
-
-  addEventListener(event: string, listener: (event: any) => void) {
-    if (!this.eventListeners.has(event)) {
-      this.eventListeners.set(event, new Set())
-    }
-    this.eventListeners.get(event)!.add(listener)
-  }
-
-  removeEventListener(event: string, listener: (event: any) => void) {
-    const listeners = this.eventListeners.get(event)
-    if (listeners) {
-      listeners.delete(listener)
-    }
-  }
-
-  dispatchEvent(event: any) {
-    const listeners = this.eventListeners.get(event.type)
-    if (listeners) {
-      listeners.forEach((listener) => listener(event))
-    }
-    return true
-  }
-
-  close() {
-    this.readyState = MockEventSource.CLOSED
-  }
-
-  simulateMessage(eventType: string, data: any) {
-    const event = {
-      type: eventType,
-      data: JSON.stringify(data),
-      lastEventId: '',
-    }
-
-    const listeners = this.eventListeners.get(eventType)
-    if (listeners) {
-      listeners.forEach((listener) => listener(event))
-    }
-  }
-}
-
-// Helper to create proper mock Response objects
-function createMockResponse(data: any, options: { ok?: boolean; status?: number } = {}) {
-  return {
-    ok: options.ok ?? true,
-    status: options.status ?? 200,
-    statusText: options.status === 200 ? 'OK' : 'Error',
-    headers: new Headers({ 'content-type': 'application/json' }),
-    json: async () => data,
-    text: async () => JSON.stringify(data),
-    blob: async () => new Blob([JSON.stringify(data)]),
-    arrayBuffer: async () => new TextEncoder().encode(JSON.stringify(data)).buffer,
-  }
-}
-
-describe('AgentClient', () => {
-  let client: AgentClient
-  let mockFetch: any
-
-  beforeEach(() => {
-    client = new AgentClient({
-      baseUrl: 'http://localhost:8000',
-      token: 'test-token',
-      headers: { 'X-API-Key': 'test-key' },
-    })
-
-    mockFetch = vi.fn()
-    global.fetch = mockFetch
-    globalThis.fetch = mockFetch
-    global.EventSource = MockEventSource as any
-    vi.clearAllMocks()
-  })
-
-  // ── executeQuery ──────────────────────────────────────────────────────
-
-  describe('executeQuery', () => {
-    it('should handle immediate sync response', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          content: 'Revenue increased 15% year-over-year.',
-          agent_used: 'financial',
-          mode_used: 'standard',
-          metadata: { sources: ['10-K'] },
-          tokens_used: { prompt_tokens: 500, completion_tokens: 100, total_tokens: 600 },
-          confidence_score: 0.92,
-          execution_time: 1.5,
-        })
-      )
-
-      const result = await client.executeQuery('graph_1', {
-        message: 'What was revenue growth?',
-      })
-
-      expect(result.content).toBe('Revenue increased 15% year-over-year.')
-      expect(result.agent_used).toBe('financial')
-      expect(result.mode_used).toBe('standard')
-      expect(result.metadata).toEqual({ sources: ['10-K'] })
-      expect(result.tokens_used).toEqual({
-        prompt_tokens: 500,
-        completion_tokens: 100,
-        total_tokens: 600,
-      })
-      expect(result.confidence_score).toBe(0.92)
-      expect(result.execution_time).toBe(1.5)
-      expect(result.timestamp).toBeDefined()
-    })
-
-    it('should accept full request options', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          content: 'Answer',
-          agent_used: 'rag',
-          mode_used: 'quick',
-        })
-      )
-
-      const result = await client.executeQuery('graph_1', {
-        message: 'test query',
-        history: [{ role: 'user', content: 'prior question' }],
-        context: { fiscal_year: 2024 },
-        mode: 'extended',
-        enableRag: true,
-        forceExtendedAnalysis: true,
-      })
-
-      expect(result.content).toBe('Answer')
-      expect(mockFetch).toHaveBeenCalledTimes(1)
-    })
-
-    it('should throw QueuedAgentError when maxWait is 0', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          status: 'queued',
-          operation_id: 'op_123',
-          message: 'Agent execution queued',
-        })
-      )
-
-      try {
-        await client.executeQuery('graph_1', { message: 'complex query' }, { maxWait: 0 })
-        expect.fail('Should have thrown')
-      } catch (error) {
-        expect(error).toBeInstanceOf(QueuedAgentError)
-        const queuedError = error as QueuedAgentError
-        expect(queuedError.queueInfo.operation_id).toBe('op_123')
-        expect(queuedError.message).toBe('Agent execution was queued')
-      }
-    })
-
-    it('should throw on unexpected response format', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          unexpected: 'data',
-        })
-      )
-
-      await expect(client.executeQuery('graph_1', { message: 'test' })).rejects.toThrow(
-        'Unexpected response format from agent endpoint'
-      )
-    })
-
-    it('should wait for SSE completion when queued', async () => {
-      // Return a queued response
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          operation_id: 'op_456',
-          message: 'Queued',
-        })
-      )
-
-      const resultPromise = client.executeQuery('graph_1', { message: 'test' })
-
-      // Wait for SSE client to connect
-      await new Promise((r) => setTimeout(r, 10))
-
-      // Find the SSEClient's EventSource and simulate agent_completed
-      // The SSEClient creates a new EventSource internally
-      // We need to find the last created MockEventSource
-      // Since we mocked EventSource globally, the last constructed instance will get the events
-
-      // Simulate the agent_completed event through the mock EventSource
-      // The SSEClient connects and registers listeners
-      await new Promise((r) => setTimeout(r, 50))
-
-      // Since we can't easily access the internal EventSource in this test pattern,
-      // and the SSE test infrastructure is complex, let's verify the error path instead
-      // The promise will reject since no SSE events come
-    })
-  })
-
-  // ── executeAgent ──────────────────────────────────────────────────────
-
-  describe('executeAgent', () => {
-    it('should handle immediate sync response for specific agent', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          content: 'Financial analysis complete.',
-          agent_used: 'financial',
-          mode_used: 'extended',
-          confidence_score: 0.95,
-          execution_time: 3.2,
-        })
-      )
-
-      const result = await client.executeAgent('graph_1', 'financial', {
-        message: 'Analyze Q3 earnings',
-      })
-
-      expect(result.content).toBe('Financial analysis complete.')
-      expect(result.agent_used).toBe('financial')
-      expect(result.mode_used).toBe('extended')
-      expect(result.confidence_score).toBe(0.95)
-    })
-
-    it('should throw QueuedAgentError when maxWait is 0', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          operation_id: 'op_789',
-          message: 'Queued for financial agent',
-        })
-      )
-
-      await expect(
-        client.executeAgent('graph_1', 'financial', { message: 'test' }, { maxWait: 0 })
-      ).rejects.toThrow(QueuedAgentError)
-    })
-
-    it('should throw on unexpected response format', async () => {
-      mockFetch.mockResolvedValueOnce(createMockResponse({ weird: true }))
-
-      await expect(client.executeAgent('graph_1', 'research', { message: 'test' })).rejects.toThrow(
-        'Unexpected response format from agent endpoint'
-      )
-    })
-
-    it('should execute specific agent type', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          content: 'RAG result',
-          agent_used: 'rag',
-          mode_used: 'quick',
-        })
-      )
-
-      const result = await client.executeAgent('graph_1', 'rag', { message: 'search docs' })
-
-      expect(result.content).toBe('RAG result')
-      expect(result.agent_used).toBe('rag')
-      expect(mockFetch).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  // ── Convenience methods ───────────────────────────────────────────────
-
-  describe('query', () => {
-    it('should execute auto-select query', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          content: 'Auto-selected answer',
-          agent_used: 'rag',
-          mode_used: 'quick',
-        })
-      )
-
-      const result = await client.query('graph_1', 'What is revenue?', { year: 2024 })
-
-      expect(result.content).toBe('Auto-selected answer')
-      expect(result.agent_used).toBe('rag')
-      expect(mockFetch).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  describe('analyzeFinancials', () => {
-    it('should execute financial agent', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          content: 'Financial analysis',
-          agent_used: 'financial',
-          mode_used: 'extended',
-        })
-      )
-
-      const result = await client.analyzeFinancials('graph_1', 'Analyze margins')
-
-      expect(result.content).toBe('Financial analysis')
-      expect(result.agent_used).toBe('financial')
-    })
-  })
-
-  describe('research', () => {
-    it('should execute research agent', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          content: 'Research findings',
-          agent_used: 'research',
-          mode_used: 'extended',
-        })
-      )
-
-      const result = await client.research('graph_1', 'Industry trends')
-
-      expect(result.content).toBe('Research findings')
-      expect(result.agent_used).toBe('research')
-    })
-  })
-
-  describe('rag', () => {
-    it('should execute RAG agent', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          content: 'Retrieved document excerpt',
-          agent_used: 'rag',
-          mode_used: 'quick',
-        })
-      )
-
-      const result = await client.rag('graph_1', 'Find disclosure about goodwill')
-
-      expect(result.content).toBe('Retrieved document excerpt')
-      expect(result.agent_used).toBe('rag')
-    })
-  })
-
-  // ── close ─────────────────────────────────────────────────────────────
-
-  describe('close', () => {
-    it('should close without error when no SSE client exists', () => {
-      expect(() => client.close()).not.toThrow()
-    })
-
-    it('should be safe to call close multiple times', () => {
-      client.close()
-      expect(() => client.close()).not.toThrow()
-    })
-  })
-
-  // ── QueuedAgentError ──────────────────────────────────────────────────
-
-  describe('QueuedAgentError', () => {
-    it('should create error with queue info', () => {
-      const queueInfo = {
-        status: 'queued' as const,
-        operation_id: 'op_test',
-        message: 'Queued for processing',
-        sse_endpoint: '/v1/operations/op_test/stream',
-      }
-
-      const error = new QueuedAgentError(queueInfo)
-
-      expect(error.message).toBe('Agent execution was queued')
-      expect(error.name).toBe('QueuedAgentError')
-      expect(error.queueInfo).toEqual(queueInfo)
-      expect(error).toBeInstanceOf(Error)
-    })
-  })
-
-  // ── Constructor ───────────────────────────────────────────────────────
-
-  describe('constructor', () => {
-    it('should create with minimal config', () => {
-      const c = new AgentClient({ baseUrl: 'http://localhost:8000' })
-      expect(c).toBeInstanceOf(AgentClient)
-    })
-
-    it('should accept all config options', () => {
-      const c = new AgentClient({
-        baseUrl: 'http://localhost:8000',
-        credentials: 'include',
-        headers: { Authorization: 'Bearer token' },
-        token: 'jwt-token',
-      })
-      expect(c).toBeInstanceOf(AgentClient)
-    })
-  })
-})