@robosystems/client 0.2.48 → 0.3.0

package/sdk-extensions/AgentClient.ts

@@ -1,321 +0,0 @@
-'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 background task 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 background task 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/LedgerClient.d.ts

@@ -1,242 +0,0 @@
-import type { AccountListResponse, AccountRollupsResponse, AccountTreeResponse, ClosingBookStructuresResponse, LedgerSummaryResponse, LedgerTransactionDetailResponse, LedgerTransactionListResponse, MappingDetailResponse, TrialBalanceResponse } from '../sdk/types.gen';
-export interface LedgerEntity {
-    id: string;
-    name: string;
-    legalName: string | null;
-    entityType: string | null;
-    industry: string | null;
-    status: string | null;
-}
-export interface MappingInfo {
-    id: string;
-    name: string;
-    description: string | null;
-    structureType: string;
-    taxonomyId: string;
-    isActive: boolean;
-}
-export interface MappingCoverage {
-    totalCoaElements: number;
-    mappedCount: number;
-    unmappedCount: number;
-    coveragePercent: number;
-    highConfidence: number;
-    mediumConfidence: number;
-    lowConfidence: number;
-}
-export interface Structure {
-    id: string;
-    name: string;
-    structureType: string;
-}
-export interface Schedule {
-    structureId: string;
-    name: string;
-    taxonomyName: string;
-    entryTemplate: Record<string, unknown> | null;
-    scheduleMetadata: Record<string, unknown> | null;
-    totalPeriods: number;
-    periodsWithEntries: number;
-}
-export interface ScheduleCreated {
-    structureId: string;
-    name: string;
-    taxonomyId: string;
-    totalPeriods: number;
-    totalFacts: number;
-}
-export interface ScheduleFact {
-    elementId: string;
-    elementName: string;
-    value: number;
-    periodStart: string;
-    periodEnd: string;
-}
-export interface PeriodCloseItem {
-    structureId: string;
-    structureName: string;
-    amount: number;
-    status: string;
-    entryId: string | null;
-}
-export interface PeriodCloseStatus {
-    fiscalPeriodStart: string;
-    fiscalPeriodEnd: string;
-    periodStatus: string;
-    schedules: PeriodCloseItem[];
-    totalDraft: number;
-    totalPosted: number;
-}
-export interface ClosingEntry {
-    entryId: string;
-    status: string;
-    postingDate: string;
-    memo: string;
-    debitElementId: string;
-    creditElementId: string;
-    amount: number;
-}
-export interface CreateScheduleOptions {
-    name: string;
-    elementIds: string[];
-    periodStart: string;
-    periodEnd: string;
-    monthlyAmount: number;
-    entryTemplate: {
-        debitElementId: string;
-        creditElementId: string;
-        entryType?: string;
-        memoTemplate?: string;
-    };
-    taxonomyId?: string;
-    scheduleMetadata?: {
-        method?: string;
-        originalAmount?: number;
-        residualValue?: number;
-        usefulLifeMonths?: number;
-        assetElementId?: string;
-    };
-}
-export declare class LedgerClient {
-    private config;
-    constructor(config: {
-        baseUrl: string;
-        credentials?: 'include' | 'same-origin' | 'omit';
-        headers?: Record<string, string>;
-        token?: string;
-    });
-    /**
-     * Get the entity (company/organization) for this graph.
-     */
-    getEntity(graphId: string): Promise<LedgerEntity | null>;
-    /**
-     * List accounts (flat).
-     */
-    listAccounts(graphId: string): Promise<AccountListResponse>;
-    /**
-     * Get the account tree (hierarchical).
-     */
-    getAccountTree(graphId: string): Promise<AccountTreeResponse>;
-    /**
-     * List transactions with optional date filters.
-     */
-    listTransactions(graphId: string, options?: {
-        startDate?: string;
-        endDate?: string;
-        limit?: number;
-        offset?: number;
-    }): Promise<LedgerTransactionListResponse>;
-    /**
-     * Get transaction detail with entries and line items.
-     */
-    getTransaction(graphId: string, transactionId: string): Promise<LedgerTransactionDetailResponse>;
-    /**
-     * Get trial balance (CoA-level debits/credits).
-     */
-    getTrialBalance(graphId: string, options?: {
-        startDate?: string;
-        endDate?: string;
-    }): Promise<TrialBalanceResponse>;
-    /**
-     * Get mapped trial balance (CoA rolled up to GAAP concepts).
-     */
-    getMappedTrialBalance(graphId: string, options?: {
-        mappingId?: string;
-        startDate?: string;
-        endDate?: string;
-    }): Promise<unknown>;
-    /**
-     * Get ledger summary (account count, transaction count, date range).
-     */
-    getSummary(graphId: string): Promise<LedgerSummaryResponse>;
-    /**
-     * Get the reporting taxonomy (US GAAP seed).
-     */
-    getReportingTaxonomy(graphId: string): Promise<unknown>;
-    /**
-     * List reporting structures (IS, BS, CF) for a taxonomy.
-     */
-    listStructures(graphId: string, taxonomyId?: string): Promise<Structure[]>;
-    /**
-     * List elements (CoA accounts, GAAP concepts, etc.).
-     */
-    listElements(graphId: string, options?: {
-        taxonomyId?: string;
-        source?: string;
-        classification?: string;
-        isAbstract?: boolean;
-        limit?: number;
-        offset?: number;
-    }): Promise<unknown>;
-    /**
-     * Create a new CoA→GAAP mapping structure.
-     * Returns the created mapping info.
-     */
-    createMappingStructure(graphId: string, options?: {
-        name?: string;
-        description?: string;
-        taxonomyId?: string;
-    }): Promise<MappingInfo>;
-    /**
-     * List available CoA→GAAP mapping structures.
-     */
-    listMappings(graphId: string): Promise<MappingInfo[]>;
-    /**
-     * Get mapping detail — all associations with element names.
-     */
-    getMappingDetail(graphId: string, mappingId: string): Promise<MappingDetailResponse>;
-    /**
-     * Get mapping coverage — how many CoA elements are mapped.
-     */
-    getMappingCoverage(graphId: string, mappingId: string): Promise<MappingCoverage>;
-    /**
-     * Create a manual mapping association (CoA element → GAAP element).
-     */
-    createMapping(graphId: string, mappingId: string, fromElementId: string, toElementId: string, confidence?: number): Promise<void>;
-    /**
-     * Delete a mapping association.
-     */
-    deleteMapping(graphId: string, mappingId: string, associationId: string): Promise<void>;
-    /**
-     * Trigger AI auto-mapping (MappingAgent).
-     * Returns immediately — the agent runs in the background.
-     */
-    autoMap(graphId: string, mappingId: string): Promise<{
-        operationId?: string;
-    }>;
-    /**
-     * Create a schedule with pre-generated monthly facts.
-     */
-    createSchedule(graphId: string, options: CreateScheduleOptions): Promise<ScheduleCreated>;
-    /**
-     * List all schedules for a graph.
-     */
-    listSchedules(graphId: string): Promise<Schedule[]>;
-    /**
-     * Get facts for a schedule, optionally filtered by period.
-     */
-    getScheduleFacts(graphId: string, structureId: string, periodStart?: string, periodEnd?: string): Promise<ScheduleFact[]>;
-    /**
-     * Get close status for all schedules in a fiscal period.
-     */
-    getPeriodCloseStatus(graphId: string, periodStart: string, periodEnd: string): Promise<PeriodCloseStatus>;
-    /**
-     * Create a draft closing entry from a schedule's facts for a period.
-     */
-    createClosingEntry(graphId: string, structureId: string, postingDate: string, periodStart: string, periodEnd: string, memo?: string): Promise<ClosingEntry>;
-    /**
-     * Get all closing book structure categories for the sidebar.
-     * Returns statements, account rollups, schedules, trial balance,
-     * and period close grouped into categories.
-     */
-    getClosingBookStructures(graphId: string): Promise<ClosingBookStructuresResponse>;
-    /**
-     * Get account rollups — CoA accounts grouped by reporting element with balances.
-     * Shows how company-specific accounts roll up to standardized reporting lines.
-     */
-    getAccountRollups(graphId: string, options?: {
-        mappingId?: string;
-        startDate?: string;
-        endDate?: string;
-    }): Promise<AccountRollupsResponse>;
-}