@robosystems/client 0.1.19 → 0.1.21

package/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 = {
     /**
@@ -1254,6 +1501,18 @@ export type DetailedTransactionsResponse = {
     };
 };
 
+/**
+ * EmailVerificationRequest
+ * Email verification request model.
+ */
+export type EmailVerificationRequest = {
+    /**
+     * Token
+     * Email verification token from email link
+     */
+    token: string;
+};
+
 /**
  * EnhancedCreditTransactionResponse
  * Enhanced credit transaction response with more details.
@@ -1357,6 +1616,18 @@ export type ExchangeTokenRequest = {
     } | null;
 };
 
+/**
+ * ForgotPasswordRequest
+ * Forgot password request model.
+ */
+export type ForgotPasswordRequest = {
+    /**
+     * Email
+     * Email address to send reset link
+     */
+    email: string;
+};
+
 /**
  * GraphInfo
  * Graph information for user.
@@ -1978,11 +2249,11 @@ export type RepositoryCreditsResponse = {
      * Message
      * Access message
      */
-    message?: string;
+    message?: string | null;
     /**
      * Credit summary if access available
      */
-    credits?: CreditSummary;
+    credits?: CreditSummary | null;
 };
 
 /**
@@ -1997,6 +2268,40 @@ export type RepositoryPlan = 'starter' | 'advanced' | 'unlimited';
  */
 export type RepositoryType = 'sec' | 'industry' | 'economic';
 
+/**
+ * ResetPasswordRequest
+ * Reset password request model.
+ */
+export type ResetPasswordRequest = {
+    /**
+     * Token
+     * Password reset token from email link
+     */
+    token: string;
+    /**
+     * New Password
+     * New password (must meet security requirements)
+     */
+    new_password: string;
+};
+
+/**
+ * ResetPasswordValidateResponse
+ * Password reset token validation response model.
+ */
+export type ResetPasswordValidateResponse = {
+    /**
+     * Valid
+     * Whether the token is valid
+     */
+    valid: boolean;
+    /**
+     * Email
+     * Masked email address if token is valid
+     */
+    email?: string | null;
+};
+
 /**
  * ResponseMode
  * Response modes for execution.
@@ -2321,6 +2626,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.
@@ -3171,6 +3507,12 @@ export type LoginUserResponse = LoginUserResponses[keyof LoginUserResponses];
 
 export type LogoutUserData = {
     body?: never;
+    headers?: {
+        /**
+         * Authorization
+         */
+        authorization?: string | null;
+    };
     path?: never;
     query?: never;
     url: '/v1/auth/logout';
@@ -3235,14 +3577,20 @@ export type GetCurrentAuthUserResponses = {
 
 export type GetCurrentAuthUserResponse = GetCurrentAuthUserResponses[keyof GetCurrentAuthUserResponses];
 
-export type RefreshSessionData = {
+export type RefreshAuthSessionData = {
     body?: never;
+    headers?: {
+        /**
+         * Authorization
+         */
+        authorization?: string | null;
+    };
     path?: never;
     query?: never;
     url: '/v1/auth/refresh';
 };
 
-export type RefreshSessionErrors = {
+export type RefreshAuthSessionErrors = {
     /**
      * Not authenticated
      */
@@ -3253,177 +3601,350 @@ export type RefreshSessionErrors = {
     422: HttpValidationError;
 };
 
-export type RefreshSessionError = RefreshSessionErrors[keyof RefreshSessionErrors];
+export type RefreshAuthSessionError = RefreshAuthSessionErrors[keyof RefreshAuthSessionErrors];
 
-export type RefreshSessionResponses = {
+export type RefreshAuthSessionResponses = {
     /**
      * Successful Response
      */
     200: AuthResponse;
 };
 
-export type RefreshSessionResponse = RefreshSessionResponses[keyof RefreshSessionResponses];
+export type RefreshAuthSessionResponse = RefreshAuthSessionResponses[keyof RefreshAuthSessionResponses];
 
-export type GenerateSsoTokenData = {
+export type ResendVerificationEmailData = {
     body?: never;
+    headers?: {
+        /**
+         * Authorization
+         */
+        authorization?: string | null;
+    };
     path?: never;
     query?: never;
-    url: '/v1/auth/sso-token';
+    url: '/v1/auth/email/resend';
 };
 
-export type GenerateSsoTokenErrors = {
+export type ResendVerificationEmailErrors = {
     /**
-     * Not authenticated
+     * Email already verified
      */
-    401: ErrorResponse;
+    400: ErrorResponse;
     /**
      * Validation Error
      */
     422: HttpValidationError;
+    /**
+     * Rate limit exceeded
+     */
+    429: ErrorResponse;
+    /**
+     * Email service unavailable
+     */
+    503: ErrorResponse;
 };
 
-export type GenerateSsoTokenError = GenerateSsoTokenErrors[keyof GenerateSsoTokenErrors];
+export type ResendVerificationEmailError = ResendVerificationEmailErrors[keyof ResendVerificationEmailErrors];
 
-export type GenerateSsoTokenResponses = {
+export type ResendVerificationEmailResponses = {
     /**
+     * Response Resendverificationemail
      * Successful Response
      */
-    200: SsoTokenResponse;
+    200: {
+        [key: string]: unknown;
+    };
 };
 
-export type GenerateSsoTokenResponse = GenerateSsoTokenResponses[keyof GenerateSsoTokenResponses];
+export type ResendVerificationEmailResponse = ResendVerificationEmailResponses[keyof ResendVerificationEmailResponses];
 
-export type SsoLoginData = {
-    body: SsoLoginRequest;
+export type VerifyEmailData = {
+    body: EmailVerificationRequest;
     path?: never;
     query?: never;
-    url: '/v1/auth/sso-login';
+    url: '/v1/auth/email/verify';
 };
 
-export type SsoLoginErrors = {
+export type VerifyEmailErrors = {
     /**
-     * Invalid SSO token
+     * Invalid or expired token
      */
-    401: ErrorResponse;
+    400: ErrorResponse;
     /**
      * Validation Error
      */
     422: HttpValidationError;
 };
 
-export type SsoLoginError = SsoLoginErrors[keyof SsoLoginErrors];
+export type VerifyEmailError = VerifyEmailErrors[keyof VerifyEmailErrors];
 
-export type SsoLoginResponses = {
+export type VerifyEmailResponses = {
     /**
      * Successful Response
      */
     200: AuthResponse;
 };
 
-export type SsoLoginResponse = SsoLoginResponses[keyof SsoLoginResponses];
+export type VerifyEmailResponse = VerifyEmailResponses[keyof VerifyEmailResponses];
 
-export type SsoTokenExchangeData = {
-    body: SsoExchangeRequest;
+export type GetPasswordPolicyData = {
+    body?: never;
     path?: never;
     query?: never;
-    url: '/v1/auth/sso-exchange';
+    url: '/v1/auth/password/policy';
 };
 
-export type SsoTokenExchangeErrors = {
-    /**
-     * Invalid request data
-     */
-    400: ErrorResponse;
+export type GetPasswordPolicyResponses = {
     /**
-     * Invalid SSO token
+     * Password policy requirements
      */
-    401: ErrorResponse;
-    /**
+    200: PasswordPolicyResponse;
+};
+
+export type GetPasswordPolicyResponse = GetPasswordPolicyResponses[keyof GetPasswordPolicyResponses];
+
+export type CheckPasswordStrengthData = {
+    body: PasswordCheckRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/auth/password/check';
+};
+
+export type CheckPasswordStrengthErrors = {
+    /**
      * Validation Error
      */
     422: HttpValidationError;
 };
 
-export type SsoTokenExchangeError = SsoTokenExchangeErrors[keyof SsoTokenExchangeErrors];
+export type CheckPasswordStrengthError = CheckPasswordStrengthErrors[keyof CheckPasswordStrengthErrors];
 
-export type SsoTokenExchangeResponses = {
+export type CheckPasswordStrengthResponses = {
+    /**
+     * Password strength analysis
+     */
+    200: PasswordCheckResponse;
+};
+
+export type CheckPasswordStrengthResponse = CheckPasswordStrengthResponses[keyof CheckPasswordStrengthResponses];
+
+export type ForgotPasswordData = {
+    body: ForgotPasswordRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/auth/password/forgot';
+};
+
+export type ForgotPasswordErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+    /**
+     * Rate limit exceeded
+     */
+    429: ErrorResponse;
+};
+
+export type ForgotPasswordError = ForgotPasswordErrors[keyof ForgotPasswordErrors];
+
+export type ForgotPasswordResponses = {
     /**
+     * Response Forgotpassword
      * Successful Response
      */
-    200: SsoExchangeResponse;
+    200: {
+        [key: string]: unknown;
+    };
 };
 
-export type SsoTokenExchangeResponse = SsoTokenExchangeResponses[keyof SsoTokenExchangeResponses];
+export type ForgotPasswordResponse = ForgotPasswordResponses[keyof ForgotPasswordResponses];
 
-export type CompleteSsoAuthData = {
-    body: SsoCompleteRequest;
+export type ValidateResetTokenData = {
+    body?: never;
+    path?: never;
+    query: {
+        /**
+         * Token
+         * Password reset token
+         */
+        token: string;
+    };
+    url: '/v1/auth/password/reset/validate';
+};
+
+export type ValidateResetTokenErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export type ValidateResetTokenError = ValidateResetTokenErrors[keyof ValidateResetTokenErrors];
+
+export type ValidateResetTokenResponses = {
+    /**
+     * Successful Response
+     */
+    200: ResetPasswordValidateResponse;
+};
+
+export type ValidateResetTokenResponse = ValidateResetTokenResponses[keyof ValidateResetTokenResponses];
+
+export type ResetPasswordData = {
+    body: ResetPasswordRequest;
     path?: never;
     query?: never;
-    url: '/v1/auth/sso-complete';
+    url: '/v1/auth/password/reset';
 };
 
-export type CompleteSsoAuthErrors = {
+export type ResetPasswordErrors = {
     /**
-     * Invalid session
+     * Invalid token or password
      */
-    401: ErrorResponse;
+    400: ErrorResponse;
     /**
      * Validation Error
      */
     422: HttpValidationError;
 };
 
-export type CompleteSsoAuthError = CompleteSsoAuthErrors[keyof CompleteSsoAuthErrors];
+export type ResetPasswordError = ResetPasswordErrors[keyof ResetPasswordErrors];
 
-export type CompleteSsoAuthResponses = {
+export type ResetPasswordResponses = {
     /**
      * Successful Response
      */
     200: AuthResponse;
 };
 
-export type CompleteSsoAuthResponse = CompleteSsoAuthResponses[keyof CompleteSsoAuthResponses];
+export type ResetPasswordResponse = ResetPasswordResponses[keyof ResetPasswordResponses];
 
-export type GetPasswordPolicyData = {
+export type GenerateSsoTokenData = {
     body?: never;
+    headers?: {
+        /**
+         * Authorization
+         */
+        authorization?: string | null;
+    };
     path?: never;
     query?: never;
-    url: '/v1/auth/password/policy';
+    url: '/v1/auth/sso-token';
 };
 
-export type GetPasswordPolicyResponses = {
+export type GenerateSsoTokenErrors = {
     /**
-     * Password policy requirements
+     * Not authenticated
      */
-    200: PasswordPolicyResponse;
+    401: ErrorResponse;
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
 };
 
-export type GetPasswordPolicyResponse = GetPasswordPolicyResponses[keyof GetPasswordPolicyResponses];
+export type GenerateSsoTokenError = GenerateSsoTokenErrors[keyof GenerateSsoTokenErrors];
 
-export type CheckPasswordStrengthData = {
-    body: PasswordCheckRequest;
+export type GenerateSsoTokenResponses = {
+    /**
+     * Successful Response
+     */
+    200: SsoTokenResponse;
+};
+
+export type GenerateSsoTokenResponse = GenerateSsoTokenResponses[keyof GenerateSsoTokenResponses];
+
+export type SsoLoginData = {
+    body: SsoLoginRequest;
     path?: never;
     query?: never;
-    url: '/v1/auth/password/check';
+    url: '/v1/auth/sso-login';
 };
 
-export type CheckPasswordStrengthErrors = {
+export type SsoLoginErrors = {
+    /**
+     * Invalid SSO token
+     */
+    401: ErrorResponse;
     /**
      * Validation Error
      */
     422: HttpValidationError;
 };
 
-export type CheckPasswordStrengthError = CheckPasswordStrengthErrors[keyof CheckPasswordStrengthErrors];
+export type SsoLoginError = SsoLoginErrors[keyof SsoLoginErrors];
 
-export type CheckPasswordStrengthResponses = {
+export type SsoLoginResponses = {
     /**
-     * Password strength analysis
+     * Successful Response
      */
-    200: PasswordCheckResponse;
+    200: AuthResponse;
 };
 
-export type CheckPasswordStrengthResponse = CheckPasswordStrengthResponses[keyof CheckPasswordStrengthResponses];
+export type SsoLoginResponse = SsoLoginResponses[keyof SsoLoginResponses];
+
+export type SsoTokenExchangeData = {
+    body: SsoExchangeRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/auth/sso-exchange';
+};
+
+export type SsoTokenExchangeErrors = {
+    /**
+     * Invalid request data
+     */
+    400: ErrorResponse;
+    /**
+     * Invalid SSO token
+     */
+    401: ErrorResponse;
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export type SsoTokenExchangeError = SsoTokenExchangeErrors[keyof SsoTokenExchangeErrors];
+
+export type SsoTokenExchangeResponses = {
+    /**
+     * Successful Response
+     */
+    200: SsoExchangeResponse;
+};
+
+export type SsoTokenExchangeResponse = SsoTokenExchangeResponses[keyof SsoTokenExchangeResponses];
+
+export type CompleteSsoAuthData = {
+    body: SsoCompleteRequest;
+    path?: never;
+    query?: never;
+    url: '/v1/auth/sso-complete';
+};
+
+export type CompleteSsoAuthErrors = {
+    /**
+     * Invalid session
+     */
+    401: ErrorResponse;
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export type CompleteSsoAuthError = CompleteSsoAuthErrors[keyof CompleteSsoAuthErrors];
+
+export type CompleteSsoAuthResponses = {
+    /**
+     * Successful Response
+     */
+    200: AuthResponse;
+};
+
+export type CompleteSsoAuthResponse = CompleteSsoAuthResponses[keyof CompleteSsoAuthResponses];
 
 export type GetCaptchaConfigData = {
     body?: never;
@@ -4301,7 +4822,7 @@ export type GetRepositoryCreditsResponses = {
 
 export type GetRepositoryCreditsResponse = GetRepositoryCreditsResponses[keyof GetRepositoryCreditsResponses];
 
-export type ListConnectionsData = {
+export type GetConnectionOptionsData = {
     body?: never;
     headers?: {
         /**
@@ -4316,22 +4837,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 +4851,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 +4881,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;
-};
-
-export type CreateConnectionResponse = CreateConnectionResponses[keyof CreateConnectionResponses];
+    200: {
+        [key: string]: unknown;
+    };
+};
 
-export type DeleteConnectionData = {
-    body?: never;
+export type SyncConnectionResponse = SyncConnectionResponses[keyof SyncConnectionResponses];
+
+export type CreateLinkTokenData = {
+    body: LinkTokenRequest;
     headers?: {
         /**
          * Authorization
@@ -4425,21 +4938,63 @@ export type DeleteConnectionData = {
          * Graph database identifier
          */
         graph_id: string;
+    };
+    query?: never;
+    url: '/v1/{graph_id}/connections/link/token';
+};
+
+export type CreateLinkTokenErrors = {
+    /**
+     * Invalid provider or request
+     */
+    400: ErrorResponse;
+    /**
+     * Entity not found
+     */
+    404: ErrorResponse;
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+    /**
+     * Failed to create link token
+     */
+    500: ErrorResponse;
+};
+
+export type CreateLinkTokenError = CreateLinkTokenErrors[keyof CreateLinkTokenErrors];
+
+export type CreateLinkTokenResponses = {
+    /**
+     * Link token created successfully
+     */
+    200: unknown;
+};
+
+export type ExchangeLinkTokenData = {
+    body: ExchangeTokenRequest;
+    headers?: {
         /**
-         * Connection Id
-         * Connection identifier
+         * 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/link/exchange';
 };
 
-export type DeleteConnectionErrors = {
+export type ExchangeLinkTokenErrors = {
     /**
-     * Access denied - admin role required
+     * Invalid token or provider
      */
-    403: ErrorResponse;
+    400: ErrorResponse;
     /**
      * Connection not found
      */
@@ -4449,24 +5004,22 @@ export type DeleteConnectionErrors = {
      */
     422: HttpValidationError;
     /**
-     * Failed to delete connection
+     * Token exchange failed
      */
     500: ErrorResponse;
 };
 
-export type DeleteConnectionError = DeleteConnectionErrors[keyof DeleteConnectionErrors];
+export type ExchangeLinkTokenError = ExchangeLinkTokenErrors[keyof ExchangeLinkTokenErrors];
 
-export type DeleteConnectionResponses = {
+export type ExchangeLinkTokenResponses = {
     /**
-     * Connection deleted successfully
+     * Token exchanged successfully
      */
-    200: SuccessResponse;
+    200: unknown;
 };
 
-export type DeleteConnectionResponse = DeleteConnectionResponses[keyof DeleteConnectionResponses];
-
-export type GetConnectionData = {
-    body?: never;
+export type InitOAuthData = {
+    body: OAuthInitRequest;
     headers?: {
         /**
          * Authorization
@@ -4479,19 +5032,60 @@ export type GetConnectionData = {
          * Graph database identifier
          */
         graph_id: string;
+    };
+    query?: never;
+    url: '/v1/{graph_id}/connections/oauth/init';
+};
+
+export type InitOAuthErrors = {
+    /**
+     * 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?: {
         /**
-         * Connection Id
-         * Unique connection identifier
+         * Authorization
          */
-        connection_id: string;
+        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/{connection_id}';
+    url: '/v1/{graph_id}/connections/oauth/callback/{provider}';
 };
 
-export type GetConnectionErrors = {
+export type OauthCallbackErrors = {
     /**
-     * Access denied to connection
+     * OAuth error or invalid state
+     */
+    400: ErrorResponse;
+    /**
+     * State does not match user
      */
     403: ErrorResponse;
     /**
@@ -4503,23 +5097,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 +5126,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 +5151,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 +5182,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 +5235,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 +5259,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 +5289,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 +5313,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 +5340,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 +5391,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 +5456,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 ListAgentsResponse = ListAgentsResponses[keyof ListAgentsResponses];
+
+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 QueryFinancialAgentError = QueryFinancialAgentErrors[keyof QueryFinancialAgentErrors];
+export type GetAgentMetadataErrors = {
+    /**
+     * Agent type not found
+     */
+    404: unknown;
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+
+export type GetAgentMetadataError = GetAgentMetadataErrors[keyof GetAgentMetadataErrors];
 
-export type QueryFinancialAgentResponses = {
+export type GetAgentMetadataResponses = {
     /**
-     * Successful financial analysis
+     * Agent metadata retrieved successfully
      */
-    200: AgentResponse;
+    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 +6808,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 +7174,7 @@ export type CreateSubgraphResponses = {
 export type CreateSubgraphResponse = CreateSubgraphResponses[keyof CreateSubgraphResponses];
 
 export type DeleteSubgraphData = {
-    body?: DeleteSubgraphRequest;
+    body: DeleteSubgraphRequest;
     headers?: {
         /**
          * Authorization