@robosystems/client 0.1.19 → 0.1.20

package/sdk/types.gen.ts

@@ -123,6 +123,27 @@ export type AddOnCreditInfo = {
     rollover_amount?: number;
 };
 
+/**
+ * AgentListResponse
+ * Response for listing available agents.
+ */
+export type AgentListResponse = {
+    /**
+     * Agents
+     * Dictionary of available agents with metadata
+     */
+    agents: {
+        [key: string]: {
+            [key: string]: unknown;
+        };
+    };
+    /**
+     * Total
+     * Total number of agents
+     */
+    total: number;
+};
+
 /**
  * AgentMessage
  * Message in conversation history.
@@ -138,16 +159,142 @@ export type AgentMessage = {
      * Message content
      */
     content: string;
+    /**
+     * Timestamp
+     * Message timestamp
+     */
+    timestamp?: string | null;
+};
+
+/**
+ * AgentMetadataResponse
+ * Response for agent metadata.
+ */
+export type AgentMetadataResponse = {
+    /**
+     * Name
+     * Agent name
+     */
+    name: string;
+    /**
+     * Description
+     * Agent description
+     */
+    description: string;
+    /**
+     * Version
+     * Agent version
+     */
+    version: string;
+    /**
+     * Capabilities
+     * Agent capabilities
+     */
+    capabilities: Array<string>;
+    /**
+     * Supported Modes
+     * Supported execution modes
+     */
+    supported_modes: Array<string>;
+    /**
+     * Requires Credits
+     * Whether agent requires credits
+     */
+    requires_credits: boolean;
+    /**
+     * Author
+     * Agent author
+     */
+    author?: string | null;
+    /**
+     * Tags
+     * Agent tags
+     */
+    tags?: Array<string>;
+};
+
+/**
+ * AgentMode
+ * Agent execution modes.
+ */
+export type AgentMode = 'quick' | 'standard' | 'extended' | 'streaming';
+
+/**
+ * AgentRecommendation
+ * Single agent recommendation.
+ */
+export type AgentRecommendation = {
+    /**
+     * Agent Type
+     * Agent type identifier
+     */
+    agent_type: string;
+    /**
+     * Agent Name
+     * Agent display name
+     */
+    agent_name: string;
+    /**
+     * Confidence
+     * Confidence score (0-1)
+     */
+    confidence: number;
+    /**
+     * Capabilities
+     * Agent capabilities
+     */
+    capabilities: Array<string>;
+    /**
+     * Reason
+     * Reason for recommendation
+     */
+    reason?: string | null;
+};
+
+/**
+ * AgentRecommendationRequest
+ * Request for agent recommendations.
+ */
+export type AgentRecommendationRequest = {
+    /**
+     * Query
+     * Query to analyze
+     */
+    query: string;
+    /**
+     * Context
+     * Additional context
+     */
+    context?: {
+        [key: string]: unknown;
+    } | null;
+};
+
+/**
+ * AgentRecommendationResponse
+ * Response for agent recommendations.
+ */
+export type AgentRecommendationResponse = {
+    /**
+     * Recommendations
+     * List of agent recommendations sorted by confidence
+     */
+    recommendations: Array<AgentRecommendation>;
+    /**
+     * Query
+     * The analyzed query
+     */
+    query: string;
 };
 
 /**
  * AgentRequest
- * Request model for financial agent interactions.
+ * Request model for agent interactions.
  */
 export type AgentRequest = {
     /**
      * Message
-     * Financial analysis query
+     * The query or message to process
      */
     message: string;
     /**
@@ -157,45 +304,106 @@ export type AgentRequest = {
     history?: Array<AgentMessage>;
     /**
      * Context
-     * Additional context for analysis (e.g., include_schema, limit_results)
+     * Additional context for analysis (e.g., enable_rag, include_schema)
      */
     context?: {
         [key: string]: unknown;
     } | null;
+    /**
+     * Execution mode
+     */
+    mode?: AgentMode | null;
+    /**
+     * Agent Type
+     * Specific agent type to use (optional)
+     */
+    agent_type?: string | null;
+    /**
+     * Criteria for agent selection
+     */
+    selection_criteria?: SelectionCriteria | null;
     /**
      * Force Extended Analysis
-     * Force extended analysis mode with comprehensive research (like Claude Desktop's deep research)
+     * Force extended analysis mode with comprehensive research
      */
     force_extended_analysis?: boolean;
+    /**
+     * Enable Rag
+     * Enable RAG context enrichment
+     */
+    enable_rag?: boolean;
+    /**
+     * Stream
+     * Enable streaming response
+     */
+    stream?: boolean;
 };
 
 /**
  * AgentResponse
- * Response model for financial agent interactions.
+ * Response model for agent interactions.
  */
 export type AgentResponse = {
     /**
-     * Response
-     * Financial analysis response
+     * Content
+     * The agent's response content
+     */
+    content: string;
+    /**
+     * Agent Used
+     * The agent type that handled the request
      */
-    response: string;
+    agent_used: string;
+    /**
+     * The execution mode used
+     */
+    mode_used: AgentMode;
     /**
      * Metadata
-     * Analysis metadata (e.g., analysis_type, graph_id)
+     * Response metadata including routing info
      */
     metadata?: {
         [key: string]: unknown;
     } | null;
+    /**
+     * Tokens Used
+     * Token usage statistics
+     */
+    tokens_used?: {
+        [key: string]: number;
+    } | null;
+    /**
+     * Confidence Score
+     * Confidence score of the response
+     */
+    confidence_score?: number | null;
     /**
      * Operation Id
-     * SSE operation ID for monitoring extended analysis via /v1/operations/{operation_id}/stream
+     * Operation ID for SSE monitoring
      */
     operation_id?: string | null;
     /**
      * Is Partial
-     * Whether this is a partial response with more analysis coming
+     * Whether this is a partial response
      */
     is_partial?: boolean;
+    /**
+     * Error Details
+     * Error details if any
+     */
+    error_details?: {
+        [key: string]: unknown;
+    } | null;
+    /**
+     * Execution Time
+     * Execution time in seconds
+     */
+    execution_time?: number | null;
+    /**
+     * Timestamp
+     * Response timestamp
+     */
+    timestamp?: string;
 };
 
 /**
@@ -217,9 +425,9 @@ export type AuthResponse = {
     message: string;
     /**
      * Token
-     * JWT authentication token
+     * JWT authentication token (optional for cookie-based auth)
      */
-    token: string;
+    token?: string | null;
 };
 
 /**
@@ -456,6 +664,45 @@ export type BackupStatsResponse = {
     };
 };
 
+/**
+ * BatchAgentRequest
+ * Request for batch processing multiple queries.
+ */
+export type BatchAgentRequest = {
+    /**
+     * Queries
+     * List of queries to process
+     */
+    queries: Array<AgentRequest>;
+    /**
+     * Parallel
+     * Process queries in parallel
+     */
+    parallel?: boolean;
+};
+
+/**
+ * BatchAgentResponse
+ * Response for batch processing.
+ */
+export type BatchAgentResponse = {
+    /**
+     * Results
+     * List of agent responses
+     */
+    results: Array<AgentResponse>;
+    /**
+     * Total Execution Time
+     * Total execution time
+     */
+    total_execution_time: number;
+    /**
+     * Parallel Processed
+     * Whether queries were processed in parallel
+     */
+    parallel_processed: boolean;
+};
+
 /**
  * CancellationResponse
  * Response for subscription cancellation.
@@ -834,12 +1081,12 @@ export type CreditSummary = {
      * Last Allocation Date
      * Last allocation date (ISO format)
      */
-    last_allocation_date?: string;
+    last_allocation_date?: string | null;
     /**
      * Next Allocation Date
      * Next allocation date (ISO format)
      */
-    next_allocation_date?: string;
+    next_allocation_date?: string | null;
     /**
      * Is Active
      * Whether credit pool is active
@@ -908,7 +1155,7 @@ export type CreditsSummaryResponse = {
      */
     credits_by_addon?: Array<{
         [key: string]: unknown;
-    }>;
+    }> | null;
     /**
      * Addon Count
      * Number of active add-ons
@@ -918,7 +1165,7 @@ export type CreditsSummaryResponse = {
 
 /**
  * CustomSchemaDefinition
- * Custom schema definition for user-defined graphs.
+ * Custom schema definition for custom graphs.
  */
 export type CustomSchemaDefinition = {
     /**
@@ -1978,11 +2225,11 @@ export type RepositoryCreditsResponse = {
      * Message
      * Access message
      */
-    message?: string;
+    message?: string | null;
     /**
      * Credit summary if access available
      */
-    credits?: CreditSummary;
+    credits?: CreditSummary | null;
 };
 
 /**
@@ -2321,6 +2568,37 @@ export type SchemaValidationResponse = {
     } | null;
 };
 
+/**
+ * SelectionCriteria
+ * Criteria for agent selection.
+ */
+export type SelectionCriteria = {
+    /**
+     * Min Confidence
+     * Minimum confidence score
+     */
+    min_confidence?: number;
+    /**
+     * Required Capabilities
+     * Required agent capabilities
+     */
+    required_capabilities?: Array<string>;
+    /**
+     * Preferred execution mode
+     */
+    preferred_mode?: AgentMode | null;
+    /**
+     * Max Response Time
+     * Maximum response time in seconds
+     */
+    max_response_time?: number;
+    /**
+     * Excluded Agents
+     * Agents to exclude from selection
+     */
+    excluded_agents?: Array<string>;
+};
+
 /**
  * StorageLimitResponse
  * Storage limit information response.
@@ -4301,7 +4579,7 @@ export type GetRepositoryCreditsResponses = {
 
 export type GetRepositoryCreditsResponse = GetRepositoryCreditsResponses[keyof GetRepositoryCreditsResponses];
 
-export type ListConnectionsData = {
+export type GetConnectionOptionsData = {
     body?: never;
     headers?: {
         /**
@@ -4316,22 +4594,11 @@ export type ListConnectionsData = {
          */
         graph_id: string;
     };
-    query?: {
-        /**
-         * Entity Id
-         * Filter by entity ID
-         */
-        entity_id?: string | null;
-        /**
-         * Provider
-         * Filter by provider type
-         */
-        provider?: ('sec' | 'quickbooks' | 'plaid') | null;
-    };
-    url: '/v1/{graph_id}/connections';
+    query?: never;
+    url: '/v1/{graph_id}/connections/options';
 };
 
-export type ListConnectionsErrors = {
+export type GetConnectionOptionsErrors = {
     /**
      * Access denied to graph
      */
@@ -4341,25 +4608,24 @@ export type ListConnectionsErrors = {
      */
     422: HttpValidationError;
     /**
-     * Failed to list connections
+     * Failed to retrieve options
      */
     500: ErrorResponse;
 };
 
-export type ListConnectionsError = ListConnectionsErrors[keyof ListConnectionsErrors];
+export type GetConnectionOptionsError = GetConnectionOptionsErrors[keyof GetConnectionOptionsErrors];
 
-export type ListConnectionsResponses = {
+export type GetConnectionOptionsResponses = {
     /**
-     * Response Listconnections
-     * Connections retrieved successfully
+     * Connection options retrieved successfully
      */
-    200: Array<ConnectionResponse>;
+    200: ConnectionOptionsResponse;
 };
 
-export type ListConnectionsResponse = ListConnectionsResponses[keyof ListConnectionsResponses];
+export type GetConnectionOptionsResponse = GetConnectionOptionsResponses[keyof GetConnectionOptionsResponses];
 
-export type CreateConnectionData = {
-    body: CreateConnectionRequest;
+export type SyncConnectionData = {
+    body: SyncConnectionRequest;
     headers?: {
         /**
          * Authorization
@@ -4372,47 +4638,51 @@ export type CreateConnectionData = {
          * Graph database identifier
          */
         graph_id: string;
+        /**
+         * Connection Id
+         * Connection identifier
+         */
+        connection_id: string;
     };
     query?: never;
-    url: '/v1/{graph_id}/connections';
+    url: '/v1/{graph_id}/connections/{connection_id}/sync';
 };
 
-export type CreateConnectionErrors = {
-    /**
-     * Invalid connection configuration
-     */
-    400: ErrorResponse;
+export type SyncConnectionErrors = {
     /**
      * Access denied - admin role required
      */
     403: ErrorResponse;
     /**
-     * Connection already exists
+     * Connection not found
      */
-    409: ErrorResponse;
+    404: ErrorResponse;
     /**
      * Validation Error
      */
     422: HttpValidationError;
     /**
-     * Failed to create connection
+     * Failed to start sync
      */
     500: ErrorResponse;
 };
 
-export type CreateConnectionError = CreateConnectionErrors[keyof CreateConnectionErrors];
+export type SyncConnectionError = SyncConnectionErrors[keyof SyncConnectionErrors];
 
-export type CreateConnectionResponses = {
+export type SyncConnectionResponses = {
     /**
-     * Connection created successfully
+     * Response Syncconnection
+     * Sync started successfully
      */
-    201: ConnectionResponse;
+    200: {
+        [key: string]: unknown;
+    };
 };
 
-export type CreateConnectionResponse = CreateConnectionResponses[keyof CreateConnectionResponses];
+export type SyncConnectionResponse = SyncConnectionResponses[keyof SyncConnectionResponses];
 
-export type DeleteConnectionData = {
-    body?: never;
+export type CreateLinkTokenData = {
+    body: LinkTokenRequest;
     headers?: {
         /**
          * Authorization
@@ -4425,23 +4695,18 @@ export type DeleteConnectionData = {
          * Graph database identifier
          */
         graph_id: string;
-        /**
-         * Connection Id
-         * Connection identifier
-         */
-        connection_id: string;
     };
     query?: never;
-    url: '/v1/{graph_id}/connections/{connection_id}';
+    url: '/v1/{graph_id}/connections/link/token';
 };
 
-export type DeleteConnectionErrors = {
+export type CreateLinkTokenErrors = {
     /**
-     * Access denied - admin role required
+     * Invalid provider or request
      */
-    403: ErrorResponse;
+    400: ErrorResponse;
     /**
-     * Connection not found
+     * Entity not found
      */
     404: ErrorResponse;
     /**
@@ -4449,24 +4714,22 @@ export type DeleteConnectionErrors = {
      */
     422: HttpValidationError;
     /**
-     * Failed to delete connection
+     * Failed to create link token
      */
     500: ErrorResponse;
 };
 
-export type DeleteConnectionError = DeleteConnectionErrors[keyof DeleteConnectionErrors];
+export type CreateLinkTokenError = CreateLinkTokenErrors[keyof CreateLinkTokenErrors];
 
-export type DeleteConnectionResponses = {
+export type CreateLinkTokenResponses = {
     /**
-     * Connection deleted successfully
+     * Link token created successfully
      */
-    200: SuccessResponse;
+    200: unknown;
 };
 
-export type DeleteConnectionResponse = DeleteConnectionResponses[keyof DeleteConnectionResponses];
-
-export type GetConnectionData = {
-    body?: never;
+export type ExchangeLinkTokenData = {
+    body: ExchangeTokenRequest;
     headers?: {
         /**
          * Authorization
@@ -4479,19 +4742,107 @@ export type GetConnectionData = {
          * Graph database identifier
          */
         graph_id: string;
-        /**
-         * Connection Id
-         * Unique connection identifier
+    };
+    query?: never;
+    url: '/v1/{graph_id}/connections/link/exchange';
+};
+
+export type ExchangeLinkTokenErrors = {
+    /**
+     * Invalid token or provider
+     */
+    400: ErrorResponse;
+    /**
+     * Connection not found
+     */
+    404: ErrorResponse;
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+    /**
+     * Token exchange failed
+     */
+    500: ErrorResponse;
+};
+
+export type ExchangeLinkTokenError = ExchangeLinkTokenErrors[keyof ExchangeLinkTokenErrors];
+
+export type ExchangeLinkTokenResponses = {
+    /**
+     * Token exchanged successfully
+     */
+    200: unknown;
+};
+
+export type InitOAuthData = {
+    body: OAuthInitRequest;
+    headers?: {
+        /**
+         * Authorization
          */
-        connection_id: string;
+        authorization?: string | null;
+    };
+    path: {
+        /**
+         * Graph Id
+         * Graph database identifier
+         */
+        graph_id: string;
     };
     query?: never;
-    url: '/v1/{graph_id}/connections/{connection_id}';
+    url: '/v1/{graph_id}/connections/oauth/init';
 };
 
-export type GetConnectionErrors = {
+export type InitOAuthErrors = {
     /**
-     * Access denied to connection
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export type InitOAuthError = InitOAuthErrors[keyof InitOAuthErrors];
+
+export type InitOAuthResponses = {
+    /**
+     * Successful Response
+     */
+    200: OAuthInitResponse;
+};
+
+export type InitOAuthResponse = InitOAuthResponses[keyof InitOAuthResponses];
+
+export type OauthCallbackData = {
+    body: OAuthCallbackRequest;
+    headers?: {
+        /**
+         * Authorization
+         */
+        authorization?: string | null;
+    };
+    path: {
+        /**
+         * Provider
+         * OAuth provider name
+         */
+        provider: string;
+        /**
+         * Graph Id
+         * Graph database identifier
+         */
+        graph_id: string;
+    };
+    query?: never;
+    url: '/v1/{graph_id}/connections/oauth/callback/{provider}';
+};
+
+export type OauthCallbackErrors = {
+    /**
+     * OAuth error or invalid state
+     */
+    400: ErrorResponse;
+    /**
+     * State does not match user
      */
     403: ErrorResponse;
     /**
@@ -4503,23 +4854,21 @@ export type GetConnectionErrors = {
      */
     422: HttpValidationError;
     /**
-     * Failed to retrieve connection
+     * OAuth callback processing failed
      */
     500: ErrorResponse;
 };
 
-export type GetConnectionError = GetConnectionErrors[keyof GetConnectionErrors];
+export type OauthCallbackError = OauthCallbackErrors[keyof OauthCallbackErrors];
 
-export type GetConnectionResponses = {
+export type OauthCallbackResponses = {
     /**
-     * Connection details retrieved successfully
+     * OAuth flow completed successfully
      */
-    200: ConnectionResponse;
+    200: unknown;
 };
 
-export type GetConnectionResponse = GetConnectionResponses[keyof GetConnectionResponses];
-
-export type GetConnectionOptionsData = {
+export type ListConnectionsData = {
     body?: never;
     headers?: {
         /**
@@ -4534,11 +4883,22 @@ export type GetConnectionOptionsData = {
          */
         graph_id: string;
     };
-    query?: never;
-    url: '/v1/{graph_id}/connections/options';
+    query?: {
+        /**
+         * Entity Id
+         * Filter by entity ID
+         */
+        entity_id?: string | null;
+        /**
+         * Provider
+         * Filter by provider type
+         */
+        provider?: ('sec' | 'quickbooks' | 'plaid') | null;
+    };
+    url: '/v1/{graph_id}/connections';
 };
 
-export type GetConnectionOptionsErrors = {
+export type ListConnectionsErrors = {
     /**
      * Access denied to graph
      */
@@ -4548,24 +4908,25 @@ export type GetConnectionOptionsErrors = {
      */
     422: HttpValidationError;
     /**
-     * Failed to retrieve options
+     * Failed to list connections
      */
     500: ErrorResponse;
 };
 
-export type GetConnectionOptionsError = GetConnectionOptionsErrors[keyof GetConnectionOptionsErrors];
+export type ListConnectionsError = ListConnectionsErrors[keyof ListConnectionsErrors];
 
-export type GetConnectionOptionsResponses = {
+export type ListConnectionsResponses = {
     /**
-     * Connection options retrieved successfully
+     * Response Listconnections
+     * Connections retrieved successfully
      */
-    200: ConnectionOptionsResponse;
+    200: Array<ConnectionResponse>;
 };
 
-export type GetConnectionOptionsResponse = GetConnectionOptionsResponses[keyof GetConnectionOptionsResponses];
+export type ListConnectionsResponse = ListConnectionsResponses[keyof ListConnectionsResponses];
 
-export type SyncConnectionData = {
-    body?: SyncConnectionRequest;
+export type CreateConnectionData = {
+    body: CreateConnectionRequest;
     headers?: {
         /**
          * Authorization
@@ -4578,51 +4939,47 @@ export type SyncConnectionData = {
          * Graph database identifier
          */
         graph_id: string;
-        /**
-         * Connection Id
-         * Connection identifier
-         */
-        connection_id: string;
     };
     query?: never;
-    url: '/v1/{graph_id}/connections/{connection_id}/sync';
+    url: '/v1/{graph_id}/connections';
 };
 
-export type SyncConnectionErrors = {
+export type CreateConnectionErrors = {
+    /**
+     * Invalid connection configuration
+     */
+    400: ErrorResponse;
     /**
      * Access denied - admin role required
      */
     403: ErrorResponse;
     /**
-     * Connection not found
+     * Connection already exists
      */
-    404: ErrorResponse;
+    409: ErrorResponse;
     /**
      * Validation Error
      */
     422: HttpValidationError;
     /**
-     * Failed to start sync
+     * Failed to create connection
      */
     500: ErrorResponse;
 };
 
-export type SyncConnectionError = SyncConnectionErrors[keyof SyncConnectionErrors];
+export type CreateConnectionError = CreateConnectionErrors[keyof CreateConnectionErrors];
 
-export type SyncConnectionResponses = {
+export type CreateConnectionResponses = {
     /**
-     * Response Syncconnection
-     * Sync started successfully
+     * Connection created successfully
      */
-    200: {
-        [key: string]: unknown;
-    };
+    201: ConnectionResponse;
 };
 
-export type SyncConnectionResponse = SyncConnectionResponses[keyof SyncConnectionResponses];
+export type CreateConnectionResponse = CreateConnectionResponses[keyof CreateConnectionResponses];
 
-export type CreateLinkTokenData = {
-    body: LinkTokenRequest;
+export type DeleteConnectionData = {
+    body?: never;
     headers?: {
         /**
          * Authorization
@@ -4635,18 +4992,23 @@ export type CreateLinkTokenData = {
          * Graph database identifier
          */
         graph_id: string;
+        /**
+         * Connection Id
+         * Connection identifier
+         */
+        connection_id: string;
     };
     query?: never;
-    url: '/v1/{graph_id}/connections/link/token';
+    url: '/v1/{graph_id}/connections/{connection_id}';
 };
 
-export type CreateLinkTokenErrors = {
+export type DeleteConnectionErrors = {
     /**
-     * Invalid provider or request
+     * Access denied - admin role required
      */
-    400: ErrorResponse;
+    403: ErrorResponse;
     /**
-     * Entity not found
+     * Connection not found
      */
     404: ErrorResponse;
     /**
@@ -4654,22 +5016,24 @@ export type CreateLinkTokenErrors = {
      */
     422: HttpValidationError;
     /**
-     * Failed to create link token
+     * Failed to delete connection
      */
     500: ErrorResponse;
 };
 
-export type CreateLinkTokenError = CreateLinkTokenErrors[keyof CreateLinkTokenErrors];
+export type DeleteConnectionError = DeleteConnectionErrors[keyof DeleteConnectionErrors];
 
-export type CreateLinkTokenResponses = {
+export type DeleteConnectionResponses = {
     /**
-     * Link token created successfully
+     * Connection deleted successfully
      */
-    200: unknown;
+    200: SuccessResponse;
 };
 
-export type ExchangeLinkTokenData = {
-    body: ExchangeTokenRequest;
+export type DeleteConnectionResponse = DeleteConnectionResponses[keyof DeleteConnectionResponses];
+
+export type GetConnectionData = {
+    body?: never;
     headers?: {
         /**
          * Authorization
@@ -4682,16 +5046,21 @@ export type ExchangeLinkTokenData = {
          * Graph database identifier
          */
         graph_id: string;
+        /**
+         * Connection Id
+         * Unique connection identifier
+         */
+        connection_id: string;
     };
     query?: never;
-    url: '/v1/{graph_id}/connections/link/exchange';
+    url: '/v1/{graph_id}/connections/{connection_id}';
 };
 
-export type ExchangeLinkTokenErrors = {
+export type GetConnectionErrors = {
     /**
-     * Invalid token or provider
+     * Access denied to connection
      */
-    400: ErrorResponse;
+    403: ErrorResponse;
     /**
      * Connection not found
      */
@@ -4701,22 +5070,24 @@ export type ExchangeLinkTokenErrors = {
      */
     422: HttpValidationError;
     /**
-     * Token exchange failed
+     * Failed to retrieve connection
      */
     500: ErrorResponse;
 };
 
-export type ExchangeLinkTokenError = ExchangeLinkTokenErrors[keyof ExchangeLinkTokenErrors];
+export type GetConnectionError = GetConnectionErrors[keyof GetConnectionErrors];
 
-export type ExchangeLinkTokenResponses = {
+export type GetConnectionResponses = {
     /**
-     * Token exchanged successfully
+     * Connection details retrieved successfully
      */
-    200: unknown;
+    200: ConnectionResponse;
 };
 
-export type InitOAuthData = {
-    body: OAuthInitRequest;
+export type GetConnectionResponse = GetConnectionResponses[keyof GetConnectionResponses];
+
+export type AutoSelectAgentData = {
+    body: AgentRequest;
     headers?: {
         /**
          * Authorization
@@ -4726,34 +5097,49 @@ export type InitOAuthData = {
     path: {
         /**
          * Graph Id
-         * Graph database identifier
          */
         graph_id: string;
     };
     query?: never;
-    url: '/v1/{graph_id}/connections/oauth/init';
+    url: '/v1/{graph_id}/agent';
 };
 
-export type InitOAuthErrors = {
+export type AutoSelectAgentErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: unknown;
+    /**
+     * Insufficient credits for selected agent
+     */
+    402: unknown;
     /**
      * Validation Error
      */
     422: HttpValidationError;
+    /**
+     * Rate limit exceeded
+     */
+    429: unknown;
+    /**
+     * Internal server error
+     */
+    500: ErrorResponse;
 };
 
-export type InitOAuthError = InitOAuthErrors[keyof InitOAuthErrors];
+export type AutoSelectAgentError = AutoSelectAgentErrors[keyof AutoSelectAgentErrors];
 
-export type InitOAuthResponses = {
+export type AutoSelectAgentResponses = {
     /**
-     * Successful Response
+     * Query successfully processed by selected agent
      */
-    200: OAuthInitResponse;
+    200: AgentResponse;
 };
 
-export type InitOAuthResponse = InitOAuthResponses[keyof InitOAuthResponses];
+export type AutoSelectAgentResponse = AutoSelectAgentResponses[keyof AutoSelectAgentResponses];
 
-export type OauthCallbackData = {
-    body: OAuthCallbackRequest;
+export type ExecuteSpecificAgentData = {
+    body: AgentRequest;
     headers?: {
         /**
          * Authorization
@@ -4762,54 +5148,58 @@ export type OauthCallbackData = {
     };
     path: {
         /**
-         * Provider
-         * OAuth provider name
+         * Agent Type
          */
-        provider: string;
+        agent_type: string;
         /**
          * Graph Id
-         * Graph database identifier
          */
         graph_id: string;
     };
     query?: never;
-    url: '/v1/{graph_id}/connections/oauth/callback/{provider}';
+    url: '/v1/{graph_id}/agent/{agent_type}';
 };
 
-export type OauthCallbackErrors = {
+export type ExecuteSpecificAgentErrors = {
     /**
-     * OAuth error or invalid state
+     * Invalid agent type or request parameters
      */
-    400: ErrorResponse;
+    400: unknown;
     /**
-     * State does not match user
+     * Insufficient credits for specified agent
      */
-    403: ErrorResponse;
+    402: unknown;
     /**
-     * Connection not found
+     * Agent type not found
      */
-    404: ErrorResponse;
+    404: unknown;
     /**
      * Validation Error
      */
     422: HttpValidationError;
     /**
-     * OAuth callback processing failed
+     * Rate limit exceeded
+     */
+    429: unknown;
+    /**
+     * Internal server error
      */
     500: ErrorResponse;
 };
 
-export type OauthCallbackError = OauthCallbackErrors[keyof OauthCallbackErrors];
+export type ExecuteSpecificAgentError = ExecuteSpecificAgentErrors[keyof ExecuteSpecificAgentErrors];
 
-export type OauthCallbackResponses = {
+export type ExecuteSpecificAgentResponses = {
     /**
-     * OAuth flow completed successfully
+     * Query successfully processed by specified agent
      */
-    200: unknown;
+    200: AgentResponse;
 };
 
-export type QueryFinancialAgentData = {
-    body: AgentRequest;
+export type ExecuteSpecificAgentResponse = ExecuteSpecificAgentResponses[keyof ExecuteSpecificAgentResponses];
+
+export type BatchProcessQueriesData = {
+    body: BatchAgentRequest;
     headers?: {
         /**
          * Authorization
@@ -4823,42 +5213,172 @@ export type QueryFinancialAgentData = {
         graph_id: string;
     };
     query?: never;
-    url: '/v1/{graph_id}/agent';
+    url: '/v1/{graph_id}/agent/batch';
 };
 
-export type QueryFinancialAgentErrors = {
+export type BatchProcessQueriesErrors = {
     /**
-     * Invalid request parameters
+     * Invalid batch request or too many queries
      */
-    400: ErrorResponse;
+    400: unknown;
     /**
-     * Insufficient credits for AI analysis
+     * Insufficient credits for batch processing
      */
-    402: ErrorResponse;
+    402: unknown;
     /**
-     * Access denied to graph
+     * Validation Error
      */
-    403: ErrorResponse;
+    422: HttpValidationError;
+    /**
+     * Internal server error during batch processing
+     */
+    500: unknown;
+};
+
+export type BatchProcessQueriesError = BatchProcessQueriesErrors[keyof BatchProcessQueriesErrors];
+
+export type BatchProcessQueriesResponses = {
+    /**
+     * Batch processing completed successfully
+     */
+    200: BatchAgentResponse;
+};
+
+export type BatchProcessQueriesResponse = BatchProcessQueriesResponses[keyof BatchProcessQueriesResponses];
+
+export type ListAgentsData = {
+    body?: never;
+    headers?: {
+        /**
+         * Authorization
+         */
+        authorization?: string | null;
+    };
+    path: {
+        /**
+         * Graph Id
+         * Graph database identifier
+         */
+        graph_id: string;
+    };
+    query?: {
+        /**
+         * Capability
+         * Filter by capability (e.g., 'financial_analysis', 'rag_search')
+         */
+        capability?: string | null;
+    };
+    url: '/v1/{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 = {
     /**
-     * Internal server error during analysis
+     * List of agents retrieved successfully
      */
-    500: ErrorResponse;
+    200: AgentListResponse;
 };
 
-export type QueryFinancialAgentError = QueryFinancialAgentErrors[keyof QueryFinancialAgentErrors];
+export type ListAgentsResponse = ListAgentsResponses[keyof ListAgentsResponses];
 
-export type QueryFinancialAgentResponses = {
+export type GetAgentMetadataData = {
+    body?: never;
+    headers?: {
+        /**
+         * Authorization
+         */
+        authorization?: string | null;
+    };
+    path: {
+        /**
+         * Graph Id
+         * Graph database identifier
+         */
+        graph_id: string;
+        /**
+         * Agent Type
+         * Agent type identifier (e.g., 'financial', 'research', 'rag')
+         */
+        agent_type: string;
+    };
+    query?: never;
+    url: '/v1/{graph_id}/agent/{agent_type}/metadata';
+};
+
+export type GetAgentMetadataErrors = {
     /**
-     * Successful financial analysis
+     * Agent type not found
      */
-    200: AgentResponse;
+    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;
+    headers?: {
+        /**
+         * Authorization
+         */
+        authorization?: string | null;
+    };
+    path: {
+        /**
+         * Graph Id
+         * Graph database identifier
+         */
+        graph_id: string;
+    };
+    query?: never;
+    url: '/v1/{graph_id}/agent/recommend';
+};
+
+export type RecommendAgentErrors = {
+    /**
+     * Invalid recommendation request
+     */
+    400: unknown;
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export type RecommendAgentError = RecommendAgentErrors[keyof RecommendAgentErrors];
+
+export type RecommendAgentResponses = {
+    /**
+     * Recommendations generated successfully
+     */
+    200: AgentRecommendationResponse;
 };
 
-export type QueryFinancialAgentResponse = QueryFinancialAgentResponses[keyof QueryFinancialAgentResponses];
+export type RecommendAgentResponse = RecommendAgentResponses[keyof RecommendAgentResponses];
 
 export type ListMcpToolsData = {
     body?: never;
@@ -6045,7 +6565,7 @@ export type CheckCreditBalanceData = {
          * Base Cost
          * Custom base cost (uses default if not provided)
          */
-        base_cost?: number | null;
+        base_cost?: number | string | null;
     };
     url: '/v1/{graph_id}/credits/balance/check';
 };
@@ -6411,7 +6931,7 @@ export type CreateSubgraphResponses = {
 export type CreateSubgraphResponse = CreateSubgraphResponses[keyof CreateSubgraphResponses];
 
 export type DeleteSubgraphData = {
-    body?: DeleteSubgraphRequest;
+    body: DeleteSubgraphRequest;
     headers?: {
         /**
          * Authorization