@flutchai/flutch-sdk 0.1.3 → 0.1.5

package/dist/index.d.cts

@@ -0,0 +1,1499 @@
+import { JSONSchema7 } from 'json-schema';
+import * as _nestjs_common from '@nestjs/common';
+import { Logger, Type, CanActivate, ExecutionContext, DynamicModule } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { HumanMessage } from '@langchain/core/messages';
+import { BaseChannel, CompiledStateGraph, LangGraphRunnableConfig } from '@langchain/langgraph';
+import Redis from 'ioredis';
+import { Registry } from 'prom-client';
+import { Response, Request } from 'express';
+import { DiscoveryService, MetadataScanner, ModuleRef } from '@nestjs/core';
+import { StructuredTool } from '@langchain/core/tools';
+import { ChatAnthropic } from '@langchain/anthropic';
+import { ChatCohere } from '@langchain/cohere';
+import { ChatMistralAI } from '@langchain/mistralai';
+import { ChatOpenAI } from '@langchain/openai';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { BaseDocumentCompressor } from '@langchain/core/retrievers/document_compressors';
+import { Embeddings } from '@langchain/core/embeddings';
+import { Document } from '@langchain/core/documents';
+
+interface RequestContext {
+    userId: string;
+    companyId?: string;
+    method: "GET" | "POST";
+    payload?: any;
+    channel: string;
+    platform?: string;
+}
+interface DataEnvelope<T = any> {
+    schema: string;
+    data: T;
+    meta?: {
+        total?: number;
+        page?: number;
+        redirect?: string;
+        message?: string;
+    };
+}
+type EndpointHandler = (ctx: RequestContext) => Promise<DataEnvelope>;
+interface EndpointDescriptor {
+    name: string;
+    method: "GET" | "POST";
+    handler: EndpointHandler;
+    schema?: JSONSchema7;
+}
+declare class EndpointRegistry {
+    private readonly logger;
+    private readonly endpoints;
+    register(graphType: string, endpoint: EndpointDescriptor): void;
+    registerMultiple(graphType: string, endpoints: EndpointDescriptor[]): void;
+    get(graphType: string, endpointName: string): EndpointDescriptor | undefined;
+    list(graphType: string): string[];
+    listEndpoints(graphType: string): string[];
+    listGraphTypes(): string[];
+    call(graphType: string, endpointName: string, context: RequestContext): Promise<DataEnvelope>;
+    getStats(): {
+        totalGraphTypes: number;
+        totalEndpoints: number;
+        endpointsByGraph: Record<string, number>;
+    };
+    clear(): void;
+    clearGraph(graphType: string): void;
+}
+
+declare const ENDPOINT_METADATA_KEY = "graph:endpoints";
+interface EndpointMetadata {
+    name: string;
+    method: "GET" | "POST";
+    methodName: string;
+    schema?: JSONSchema7;
+}
+interface EndpointOptions {
+    method: "GET" | "POST";
+    schema?: JSONSchema7;
+}
+declare function Endpoint(name: string, options: EndpointOptions): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+declare function WithEndpoints(target: any): void;
+declare function getEndpointMetadata(constructor: any): EndpointMetadata[];
+declare function createEndpointDescriptors(instance: any, metadata: EndpointMetadata[]): EndpointDescriptor[];
+declare function findEndpointMethod(constructor: any, endpointName: string): string | undefined;
+interface UIEndpointClassMetadata {
+    graphType: string;
+}
+interface UIEndpointMethodMetadata {
+    endpointName: string;
+    method: "GET" | "POST";
+    methodName: string | symbol;
+}
+declare function WithUIEndpoints(graphType: string): <T extends {
+    new (...args: any[]): {};
+}>(constructor: T) => T;
+declare function UIEndpoint(endpointName: string, method?: "GET" | "POST"): (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => PropertyDescriptor;
+declare function getUIEndpointClassMetadata(constructor: any): UIEndpointClassMetadata | null;
+declare function getUIEndpointMethodsMetadata(constructor: any): UIEndpointMethodMetadata[];
+declare function hasUIEndpoints(constructor: any): boolean;
+declare function registerUIEndpointsFromClass(endpointRegistry: any, EndpointClass: any, instance?: any): void;
+
+declare class UIEndpointsDiscoveryService {
+    private readonly discoveryService;
+    private readonly metadataScanner;
+    private readonly endpointRegistry;
+    private readonly logger;
+    constructor(discoveryService: DiscoveryService, metadataScanner: MetadataScanner, endpointRegistry: EndpointRegistry);
+    discoverUIEndpoints(): Promise<void>;
+    private getUIEndpointMethodsCount;
+}
+
+declare class BuilderRegistryService {
+    private builders;
+    registerBuilder(builder: AbstractGraphBuilder<string>): void;
+    getBuilders(): AbstractGraphBuilder<string>[];
+}
+
+interface UIDispatchDto {
+    graphType: string;
+    endpoint: string;
+    method: "GET" | "POST";
+    data?: any;
+    context: {
+        userId: string;
+        companyId?: string;
+        channel?: string;
+        platform?: string;
+    };
+}
+declare class UIDispatchController {
+    private readonly endpointRegistry;
+    private readonly builderRegistry;
+    private readonly logger;
+    constructor(endpointRegistry: EndpointRegistry, builderRegistry: BuilderRegistryService);
+    dispatchUIEndpoint(dto: UIDispatchDto): Promise<DataEnvelope>;
+    getGraphManifest(graphType: string, userId: string): Promise<any>;
+    listEndpoints(graphType: string, userId: string): Promise<string[]>;
+    getGraphCatalog(userId: string, companyId?: string): Promise<any[]>;
+}
+
+interface CallbackEntry {
+    graphType: string;
+    handler: string;
+    userId: string;
+    threadId?: string;
+    agentId?: string;
+    params: Record<string, any>;
+    metadata?: {
+        idempotencyKey?: string;
+        scopes?: string[];
+        ttlSec?: number;
+        platform?: string;
+        companyId?: string;
+    };
+}
+interface CallbackRecord extends CallbackEntry {
+    token: string;
+    status: "pending" | "processing" | "completed" | "expired" | "failed";
+    createdAt: number;
+    executedAt?: number;
+    retries: number;
+    lastError?: string;
+}
+interface CallbackResult {
+    success: boolean;
+    message?: string;
+    attachments?: any[];
+    patch?: CallbackPatch;
+    error?: string;
+}
+interface CallbackPatch {
+    editMessage?: string;
+    text?: string;
+    keyboard?: any;
+    disableButtons?: boolean;
+    newButtons?: any[];
+}
+interface CallbackContext {
+    userId: string;
+    threadId?: string;
+    agentId?: string;
+    params: Record<string, any>;
+    platform?: string;
+    metadata?: any;
+}
+type CallbackHandler = (context: CallbackContext) => Promise<CallbackResult>;
+
+declare enum AttachmentType {
+    IMAGE = "image",
+    VOICE = "voice",
+    FILE = "file",
+    BUTTON = "button",
+    CITATION = "citation",
+    SUGGESTION = "suggestion",
+    WEBAPP = "webapp",
+    SOURCE = "source",
+    CARD = "card",
+    CHART = "chart"
+}
+interface IAttachment {
+    type: AttachmentType;
+    value: any;
+    metadata?: Record<string, any>;
+}
+type CitationValue = {
+    source: {
+        url: string;
+        title: string;
+        type: "webpage" | "pdf" | "article";
+        articleId?: string;
+        knowledgeBaseId?: string;
+    };
+};
+
+interface IReasoningStep {
+    index: number;
+    type: "text" | "tool_call" | "tool_result" | "thinking" | "tool_use";
+    text?: string;
+    metadata?: Record<string, any>;
+}
+interface IReasoningChain {
+    steps: IReasoningStep[];
+    isComplete: boolean;
+}
+
+type TracingLevel = "info" | "warn" | "error" | "debug";
+interface IToolCall {
+    name: string;
+    id?: string;
+    input?: any;
+}
+interface ITracingEvent {
+    node: string;
+    type: string;
+    timestamp: number;
+    level: TracingLevel;
+    message: string;
+    data?: any;
+    error?: string;
+}
+
+interface IStoredMessageContent {
+    text?: string;
+    attachments?: IAttachment[];
+    metadata?: Record<string, any>;
+    tracingEvents?: ITracingEvent[];
+    reasoningChains?: IReasoningChain[];
+    hasReasoningProcess?: boolean;
+    currentToolCall?: IToolCall | null;
+}
+
+type ChartType = "line" | "bar" | "pie" | "area";
+interface IChartDataPoint {
+    label: string;
+    value: number;
+    color?: string;
+}
+interface IChartDataset {
+    label: string;
+    data: IChartDataPoint[];
+    color?: string;
+}
+interface IChartValue {
+    type: ChartType;
+    title: string;
+    description?: string;
+    datasets: IChartDataset[];
+    options?: {
+        showLegend?: boolean;
+        showGrid?: boolean;
+        currency?: boolean;
+        percentage?: boolean;
+        [key: string]: any;
+    };
+}
+
+interface IUsageMetrics {
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+    [key: string]: any;
+}
+
+declare enum StreamChannel {
+    TEXT = "text",
+    PROCESSING = "processing",
+    TOOLS = "tools"
+}
+
+interface IGraphService {
+    healthCheck(): Promise<boolean>;
+    getSupportedGraphTypes(): Promise<string[]>;
+    generateAnswer(payload: IGraphRequestPayload): Promise<IGraphResponsePayload>;
+    streamAnswer(payload: IGraphRequestPayload, onPartial: (chunk: string) => void): Promise<IGraphResponsePayload>;
+    cancelGeneration(requestId: string): Promise<void>;
+    executeCallback(token: string, platform?: string, platformContext?: any): Promise<CallbackResult>;
+}
+interface IGraphRequestPayload {
+    requestId: string;
+    threadId: string;
+    userId: string;
+    agentId: string;
+    message: HumanMessage;
+    graphType: string;
+    graphSettings: any;
+    context?: Record<string, any>;
+    metadata?: Record<string, any>;
+}
+interface IGraphResponsePayload {
+    requestId: string;
+    text: string;
+    attachments?: IAttachment[];
+    reasoningChains?: IReasoningChain[];
+    metadata: {
+        usageMetrics: IUsageMetrics;
+        [key: string]: any;
+    };
+}
+declare const GraphServiceTokens: {
+    REGISTRY: string;
+    CLIENT: string;
+    SETTINGS_REPOSITORY: string;
+};
+interface IGraphSettingsRepository {
+    getSettings(settingsId: string): Promise<any>;
+    getSettingsByAgentAndType(agentId: string, graphType: string): Promise<any>;
+    saveSettings(agentId: string, graphType: string, settings: any): Promise<string>;
+}
+
+interface IGraphServiceRegistry {
+    getService(graphType: string): Promise<IGraphService | null>;
+    getAllServices(): Promise<Map<string, IGraphService>>;
+    registerService(graphType: string, service: IGraphService): void;
+    unregisterService(graphType: string): void;
+    refresh(): Promise<void>;
+}
+
+declare class GraphController {
+    protected readonly graphService: IGraphService;
+    private readonly builderRegistry;
+    protected readonly logger: Logger;
+    constructor(graphService: IGraphService, builderRegistry: BuilderRegistryService);
+    healthCheck(): Promise<{
+        status: string;
+        timestamp: string;
+    }>;
+    getSupportedGraphTypes(): Promise<string[]>;
+    generateAnswer(payload: IGraphRequestPayload): Promise<IGraphResponsePayload>;
+    streamAnswer(payload: IGraphRequestPayload, res: Response): Promise<void>;
+    cancelGeneration(requestId: string): Promise<{
+        message: string;
+    }>;
+    getRegisteredGraphs(): Promise<{
+        total: number;
+        graphs: Array<{
+            graphType: string;
+            builderName: string;
+        }>;
+    }>;
+    getRegistryStats(): Promise<{
+        totalBuilders: number;
+        graphTypes: string[];
+        builderTypes: Record<string, number>;
+    }>;
+}
+
+declare const GraphManifestSchema: {
+    $schema: string;
+    type: string;
+    title: string;
+    description: string;
+    properties: {
+        graphType: {
+            type: string;
+            description: string;
+            pattern: string;
+        };
+        title: {
+            type: string;
+            description: string;
+            minLength: number;
+            maxLength: number;
+        };
+        description: {
+            type: string;
+            description: string;
+            minLength: number;
+            maxLength: number;
+        };
+        detailedDescription: {
+            type: string;
+            description: string;
+            minLength: number;
+        };
+        category: {
+            type: string;
+            description: string;
+            enum: string[];
+        };
+        tags: {
+            type: string;
+            description: string;
+            items: {
+                type: string;
+                pattern: string;
+            };
+            uniqueItems: boolean;
+        };
+        hue: {
+            type: string;
+            description: string;
+            minimum: number;
+            maximum: number;
+        };
+        visibility: {
+            type: string;
+            description: string;
+            enum: string[];
+            default: string;
+        };
+        isEmbedded: {
+            type: string;
+            description: string;
+            default: boolean;
+        };
+        isActive: {
+            type: string;
+            description: string;
+            default: boolean;
+        };
+        schema: {
+            type: string;
+            description: string;
+            properties: {
+                type: {
+                    type: string;
+                    const: string;
+                };
+                properties: {
+                    type: string;
+                    additionalProperties: {
+                        type: string;
+                        properties: {
+                            type: {
+                                type: string;
+                            };
+                            title: {
+                                type: string;
+                            };
+                            description: {
+                                type: string;
+                            };
+                            default: {};
+                            minimum: {
+                                type: string;
+                            };
+                            maximum: {
+                                type: string;
+                            };
+                            minLength: {
+                                type: string;
+                            };
+                            maxLength: {
+                                type: string;
+                            };
+                            format: {
+                                type: string;
+                            };
+                            enum: {
+                                type: string;
+                            };
+                        };
+                        required: string[];
+                    };
+                };
+                required: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                };
+            };
+            required: string[];
+            additionalProperties: boolean;
+        };
+        defaultSettings: {
+            type: string;
+            description: string;
+        };
+    };
+    required: string[];
+    additionalProperties: boolean;
+};
+declare class GraphManifestValidator {
+    static validate(manifest: any): {
+        isValid: boolean;
+        errors: string[];
+    };
+    static validateOrThrow(manifest: any): void;
+}
+
+interface IGraphTraceEvent {
+    type: string;
+    name?: string;
+    channel?: string;
+    nodeName?: string;
+    timestamp: number;
+    metadata?: Record<string, unknown>;
+    data?: Record<string, unknown>;
+}
+
+interface VersionRoute {
+    version: string;
+    builderClass: Type<AbstractGraphBuilder<any>>;
+    isDefault?: boolean;
+}
+interface VersioningConfig {
+    baseGraphType: string;
+    versions: VersionRoute[];
+    defaultVersionStrategy?: "latest" | "explicit";
+}
+interface VersionResolution {
+    version: string;
+    builderClass: Type<AbstractGraphBuilder<any>>;
+    fullGraphType: string;
+}
+interface VersionResolutionOptions {
+    requestedVersion?: string;
+    strict?: boolean;
+}
+
+declare class VersionedGraphService {
+    private readonly logger;
+    private readonly versionConfigs;
+    constructor();
+    registerVersioning(config: VersioningConfig): void;
+    resolveVersion(graphType: string, options?: VersionResolutionOptions): Promise<VersionResolution>;
+    createVersionedBuilder(graphType: string, moduleRef?: ModuleRef, options?: VersionResolutionOptions): Promise<AbstractGraphBuilder<any>>;
+    getAvailableVersions(baseGraphType: string): string[];
+    isVersionSupported(graphType: string, options?: VersionResolutionOptions): boolean;
+    private findBestVersionRoute;
+    private isVersionCompatible;
+    getVersioningInfo(baseGraphType: string): VersioningConfig | null;
+}
+
+interface IGraphTracer {
+    log(data: any): void;
+    error(data: any): void;
+}
+interface IUsageRecorder {
+    recordModelExecution(record: any): void;
+}
+
+type MappedChannels<T> = {
+    [K in keyof T]: BaseChannel<T[K], T[K]>;
+};
+declare global {
+    namespace GraphTypes {
+        interface Registry {
+        }
+    }
+}
+type IGraphTypeRegistry = GraphTypes.Registry;
+interface IGenericGraphType {
+    Params: any;
+    State: any;
+    Config: any;
+    Input: any;
+    Definition: any;
+    ConfigDefinition: any;
+    InputDefinition: any;
+    StateValues: any;
+    ConfigValues: any;
+    InputValues: any;
+    OutputValues: any;
+}
+type CompiledGraphFor<T extends string> = T extends keyof IGraphTypeRegistry ? CompiledStateGraph<IGraphTypeRegistry[T]["State"], IGraphTypeRegistry[T]["State"], string, IGraphTypeRegistry[T]["Input"], IGraphTypeRegistry[T]["State"], IGraphTypeRegistry[T]["Config"]> : CompiledStateGraph<any, any, string, any, any, any>;
+interface IGraphBuilder<T extends string> {
+    buildGraph(config?: any): Promise<CompiledGraphFor<T>>;
+}
+interface IGraphCompiler {
+    getConfiguredGraph<T extends string>(type: T, thread?: any): Promise<CompiledGraphFor<T>>;
+}
+type BaseGraphState = {};
+interface IGraphMetadata {
+    userId: string;
+    applicationId: string;
+    workflowType: string;
+    version: string;
+}
+interface IGraphConfigurable<TGraphSettings = any> {
+    thread_id?: string;
+    metadata?: IGraphMetadata;
+    graphSettings: TGraphSettings;
+}
+type IGraphRunnableConfig<TGraphSettings = any> = LangGraphRunnableConfig<IGraphConfigurable<TGraphSettings>> & {
+    configurable: IGraphConfigurable<TGraphSettings>;
+};
+type StrictGraphRunnableConfig<TGraphSettings = any> = LangGraphRunnableConfig<TGraphSettings> & {
+    configurable: IGraphConfigurable<TGraphSettings>;
+};
+interface LLMConfig {
+    modelId: string;
+    temperature?: number;
+    maxTokens?: number;
+    prompt?: string;
+}
+interface IGraphTypeMetadata {
+    type: string;
+    metadata: {
+        title: string;
+        description: string;
+        detailedDescription: string;
+        icon?: string;
+        recommendations?: string[];
+        tags?: string[];
+        category?: string;
+    };
+    schema: {
+        properties: Record<string, any>;
+        required: string[];
+    };
+    defaultSettings: any;
+    formFields?: any[];
+}
+type IGraphMetadataRegistry = Record<string, IGraphTypeMetadata>;
+
+declare class CallbackStore {
+    private readonly redis;
+    private readonly isProduction;
+    constructor(redis: Redis);
+    private generateToken;
+    issue(entry: CallbackEntry): Promise<string>;
+    getAndLock(token: string): Promise<CallbackRecord | null>;
+    private getAndLockAtomic;
+    private getAndLockSimple;
+    finalize(token: string): Promise<void>;
+    fail(token: string, error: string): Promise<CallbackRecord | null>;
+    private failAtomic;
+    private failSimple;
+    retry(token: string): Promise<CallbackRecord | null>;
+    private retryAtomic;
+    private retrySimple;
+}
+
+declare class CallbackRegistry {
+    private handlers;
+    register(handler: string, callback: CallbackHandler, graphType?: string): void;
+    get(handler: string, graphType?: string): CallbackHandler | undefined;
+    listHandlers(): string[];
+}
+
+interface CallbackUser {
+    userId: string;
+    roles?: string[];
+    permissions?: string[];
+    companyId?: string;
+}
+interface ACLValidationResult {
+    allowed: boolean;
+    reason?: string;
+    requiredScopes?: string[];
+    userScopes?: string[];
+}
+declare class CallbackACL {
+    private readonly logger;
+    validate(user: CallbackUser | undefined, record: CallbackRecord): Promise<ACLValidationResult>;
+    private validateScopes;
+    private validateGraphTypeAccess;
+    private getAllowedGraphNamespaces;
+    private validateCompanyAccess;
+    private performAdditionalSecurityChecks;
+    canRetry(user: CallbackUser, record: CallbackRecord): Promise<boolean>;
+    getPermissionDetails(user: CallbackUser, record: CallbackRecord): Record<string, any>;
+}
+
+interface AuditEntry {
+    id: string;
+    correlationId: string;
+    timestamp: number;
+    action: CallbackAuditAction;
+    userId?: string;
+    callbackToken: string;
+    graphType: string;
+    handler: string;
+    success: boolean;
+    duration?: number;
+    error?: string;
+    metadata: Record<string, any>;
+    ip?: string;
+    userAgent?: string;
+}
+declare enum CallbackAuditAction {
+    TOKEN_ISSUED = "TOKEN_ISSUED",
+    TOKEN_VALIDATED = "TOKEN_VALIDATED",
+    TOKEN_LOCKED = "TOKEN_LOCKED",
+    EXECUTION_STARTED = "EXECUTION_STARTED",
+    EXECUTION_COMPLETED = "EXECUTION_COMPLETED",
+    EXECUTION_FAILED = "EXECUTION_FAILED",
+    TOKEN_EXPIRED = "TOKEN_EXPIRED",
+    ACCESS_DENIED = "ACCESS_DENIED",
+    RATE_LIMITED = "RATE_LIMITED",
+    RETRY_ATTEMPTED = "RETRY_ATTEMPTED"
+}
+declare class CallbackAuditor {
+    private readonly logger;
+    private readonly auditStore;
+    logTokenIssued(token: string, graphType: string, handler: string, userId: string, metadata?: Record<string, any>): Promise<string>;
+    logExecutionStart(record: CallbackRecord, user: CallbackUser | undefined, correlationId?: string): Promise<string>;
+    logExecutionSuccess(record: CallbackRecord, user: CallbackUser | undefined, result: CallbackResult, duration: number, correlationId: string): Promise<void>;
+    logExecutionFailure(record: CallbackRecord, user: CallbackUser | undefined, error: Error, duration: number, correlationId: string): Promise<void>;
+    logAccessDenied(token: string, userId?: string, reason?: string, metadata?: Record<string, any>): Promise<void>;
+    logRateLimited(identifier: string, retryAfter: number, metadata?: Record<string, any>): Promise<void>;
+    logRetryAttempt(record: CallbackRecord, user: CallbackUser | undefined, attemptNumber: number): Promise<string>;
+    getTokenAuditTrail(token: string): Promise<AuditEntry[]>;
+    getUserAuditTrail(userId: string, startTime?: number, endTime?: number): Promise<AuditEntry[]>;
+    getStatistics(startTime: number, endTime: number): Promise<Record<string, any>>;
+    private persist;
+    private generateCorrelationId;
+    exportAuditLogs(startTime: number, endTime: number, format?: "json" | "csv"): Promise<string>;
+}
+
+declare class CallbackMetrics {
+    private readonly registry;
+    private readonly callbacksTotal;
+    private readonly callbacksSuccess;
+    private readonly callbacksFailed;
+    private readonly callbacksRetried;
+    private readonly accessDenied;
+    private readonly rateLimited;
+    private readonly tokensIssued;
+    private readonly tokensExpired;
+    private readonly executionDuration;
+    private readonly aclValidationDuration;
+    private readonly tokenAge;
+    private readonly activeCallbacks;
+    private readonly pendingCallbacks;
+    private readonly queueSize;
+    constructor(registry?: Registry);
+    recordExecutionStart(graphType: string, handler?: string): void;
+    recordExecutionComplete(graphType: string, handler: string, duration: number, success: boolean, error?: string): void;
+    recordTokenIssued(graphType: string, handler: string): void;
+    recordTokenExpired(graphType: string): void;
+    recordTokenAge(graphType: string, ageMs: number): void;
+    recordAclValidation(allowed: boolean, durationMs: number): void;
+    recordAccessDenied(reason: string): void;
+    recordRateLimited(identifierType: "user" | "ip" | "token"): void;
+    recordRetry(graphType: string, handler: string): void;
+    updateQueueSize(size: number): void;
+    getMetrics(): Promise<string>;
+    getContentType(): string;
+    reset(): void;
+    private classifyError;
+    getSummary(): Promise<Record<string, any>>;
+}
+
+interface RateLimitConfig {
+    windowMs: number;
+    maxRequests: number;
+    keyPrefix?: string;
+    skipFailedRequests?: boolean;
+}
+interface RateLimitResult {
+    allowed: boolean;
+    limit: number;
+    remaining: number;
+    resetAt: number;
+    retryAfter?: number;
+}
+declare class CallbackRateLimiter {
+    private readonly redis;
+    private readonly logger;
+    private readonly defaultConfig;
+    constructor(redis: Redis);
+    checkLimit(identifier: string, config?: Partial<RateLimitConfig>): Promise<RateLimitResult>;
+    checkUserLimit(userId: string, config?: Partial<RateLimitConfig>): Promise<RateLimitResult>;
+    checkIpLimit(ip: string, config?: Partial<RateLimitConfig>): Promise<RateLimitResult>;
+    checkTokenLimit(identifier: string, config?: Partial<RateLimitConfig>): Promise<RateLimitResult>;
+    reset(identifier: string, keyPrefix?: string): Promise<void>;
+    getStatus(identifier: string, config?: Partial<RateLimitConfig>): Promise<RateLimitResult>;
+    createHeaders(result: RateLimitResult): Record<string, string>;
+}
+
+interface IdempotencyConfig {
+    ttlSeconds: number;
+    keyPrefix: string;
+    hashPayload: boolean;
+    includeUserId: boolean;
+}
+interface IdempotencyEntry {
+    key: string;
+    result: CallbackResult;
+    createdAt: number;
+    executedAt: number;
+    expiresAt: number;
+    requestHash: string;
+    attempts: number;
+}
+declare enum IdempotencyStatus {
+    NEW = "NEW",
+    IN_PROGRESS = "IN_PROGRESS",
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED"
+}
+declare class IdempotencyManager {
+    private readonly redis;
+    private readonly logger;
+    private readonly defaultConfig;
+    constructor(redis: Redis);
+    checkAndLock(idempotencyKey: string | undefined, requestData: {
+        userId?: string;
+        graphType: string;
+        handler: string;
+        params: Record<string, any>;
+    }, config?: Partial<IdempotencyConfig>): Promise<{
+        status: IdempotencyStatus;
+        result?: CallbackResult;
+        key: string;
+    }>;
+    storeResult(key: string, result: CallbackResult, config?: Partial<IdempotencyConfig>): Promise<void>;
+    markFailed(key: string, error: string, config?: Partial<IdempotencyConfig>): Promise<void>;
+    releaseLock(key: string, config?: Partial<IdempotencyConfig>): Promise<void>;
+    private generateKey;
+    private acquireLock;
+    private deterministicStringify;
+    private sortObject;
+    cleanup(): Promise<number>;
+    getStatistics(): Promise<{
+        totalEntries: number;
+        completedEntries: number;
+        inProgressEntries: number;
+        failedEntries: number;
+        cacheHitRate: number;
+    }>;
+}
+
+declare class TelegramPatchHandler implements CallbackPatchHandler {
+    private readonly logger;
+    apply(patch: CallbackPatch, context?: any): Promise<void>;
+}
+
+declare class WebPatchHandler implements CallbackPatchHandler {
+    private readonly logger;
+    apply(patch: CallbackPatch, context?: any): Promise<void>;
+}
+
+interface CallbackPatchHandler {
+    apply(patch: CallbackPatch, context?: any): Promise<void>;
+}
+declare class CallbackPatchService {
+    private readonly telegram;
+    private readonly web;
+    private readonly logger;
+    constructor(telegram: TelegramPatchHandler, web: WebPatchHandler);
+    apply(record: CallbackRecord, patch: CallbackPatch, context?: any): Promise<void>;
+}
+
+interface RouterConfig {
+    maxRetries?: number;
+    retryDelayMs?: number;
+    timeoutMs?: number;
+    enableCircuitBreaker?: boolean;
+    circuitBreakerThreshold?: number;
+    circuitBreakerResetMs?: number;
+}
+interface CircuitBreakerState {
+    failures: number;
+    lastFailure?: number;
+    state: "closed" | "open" | "half-open";
+}
+declare class SmartCallbackRouter {
+    private readonly registry;
+    private readonly store;
+    private readonly acl;
+    private readonly auditor;
+    private readonly metrics;
+    private readonly rateLimiter;
+    private readonly idempotencyManager;
+    private readonly patchService;
+    private readonly logger;
+    private readonly circuitBreakers;
+    private readonly defaultConfig;
+    constructor(registry: CallbackRegistry, store: CallbackStore, acl: CallbackACL, auditor: CallbackAuditor, metrics: CallbackMetrics, rateLimiter: CallbackRateLimiter, idempotencyManager: IdempotencyManager, patchService: CallbackPatchService);
+    route(record: CallbackRecord, user: CallbackUser | undefined, requestMetadata?: {
+        ip?: string;
+        userAgent?: string;
+        platform?: string;
+        platformContext?: any;
+    }, config?: RouterConfig): Promise<CallbackResult>;
+    private executeWithRetry;
+    private executeWithTimeout;
+    private checkRateLimits;
+    private checkCircuitBreaker;
+    private recordCircuitBreakerFailure;
+    private resetCircuitBreaker;
+    private isNonRetryableError;
+    private sleep;
+    getCircuitBreakerStatus(): Map<string, CircuitBreakerState>;
+}
+
+declare class UniversalCallbackService {
+    private readonly store;
+    private readonly router;
+    constructor(store: CallbackStore, router: SmartCallbackRouter);
+    handle(record: CallbackRecord, user?: any, metadata?: {
+        ip?: string;
+        userAgent?: string;
+        platform?: string;
+        platformContext?: any;
+    }): Promise<CallbackResult>;
+}
+
+declare function registerFinanceExampleCallback(registry: CallbackRegistry): void;
+
+interface CallbackMetadata {
+    handler: string;
+    method: string | symbol;
+    target: any;
+}
+interface ExtendedCallbackContext extends CallbackContext {
+    builder?: any;
+}
+
+type ExtendedCallbackHandler = (context: ExtendedCallbackContext) => Promise<CallbackResult>;
+declare function Callback(handler: string): (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => PropertyDescriptor;
+declare function WithCallbacks<T extends {
+    new (...args: any[]): {};
+}>(CallbacksClass: T): <U extends {
+    new (...args: any[]): {};
+}>(BuilderClass: U) => any;
+declare function getCallbackMetadata(target: any): CallbackMetadata[];
+declare function hasCallbacks(target: any): boolean;
+declare function findCallbackMethod(target: any, handler: string): string | symbol | null;
+
+interface CallbackRequest extends Request {
+    callbackRecord: CallbackRecord;
+    user?: CallbackUser;
+}
+declare class CallbackTokenGuard implements CanActivate {
+    private readonly store;
+    private readonly acl;
+    private readonly logger;
+    constructor(store: CallbackStore, acl: CallbackACL);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+    private extractUser;
+}
+
+declare class CallbackController {
+    private readonly callbackService;
+    constructor(callbackService: UniversalCallbackService);
+    handleCallback(req: CallbackRequest): Promise<CallbackResult>;
+}
+
+interface IGraphManifest {
+    companySlug: string;
+    name: string;
+    title: string;
+    description: string;
+    detailedDescription: string;
+    category?: string;
+    author?: string;
+    maintainer?: string;
+    repository?: string;
+    tags?: string[];
+    ui?: {
+        enabled: boolean;
+        title: string;
+        description?: string;
+        defaultScreen: string;
+        menu: string[];
+        screens: Record<string, any>;
+        theme?: Record<string, any>;
+        permissions?: Record<string, any>;
+    };
+    versioning: {
+        strategy: "semver";
+        defaultVersion: string;
+        supportedVersions: string[];
+    };
+    versions: Record<string, {
+        status: string;
+        releaseDate: string;
+        isActive: boolean;
+        visibility: "public" | "private";
+        configSchemaPath?: string;
+    }>;
+}
+declare abstract class AbstractGraphBuilder<V extends string = string> {
+    abstract readonly version: V;
+    protected logger: Logger;
+    protected callbackRegistry: CallbackRegistry;
+    protected endpointRegistry: EndpointRegistry;
+    get graphType(): string;
+    protected manifestPath: string;
+    protected manifest?: IGraphManifest;
+    constructor();
+    abstract buildGraph(config: any): Promise<any>;
+    protected createGraphContext(payload: IGraphRequestPayload): {
+        messageId?: string;
+        threadId: string;
+        userId: string;
+        agentId: string;
+        companyId?: string;
+    };
+    prepareConfig(payload: IGraphRequestPayload): Promise<any>;
+    protected loadManifest(): Promise<IGraphManifest | null>;
+    protected loadManifestSync(): IGraphManifest | null;
+    protected validateManifest(manifest: IGraphManifest): void;
+    getGraphMetadata(): Promise<IGraphManifest | null>;
+    getVersionConfig(): Promise<{
+        configSchema: any;
+        graphType: string;
+        version: V;
+        status: string;
+        releaseDate: string;
+        isActive: boolean;
+        visibility: "public" | "private";
+        configSchemaPath?: string;
+        companySlug: string;
+        name: string;
+        title: string;
+        description: string;
+        detailedDescription: string;
+        category: string;
+        tags: string[];
+        ui: {
+            enabled: boolean;
+            title: string;
+            description?: string;
+            defaultScreen: string;
+            menu: string[];
+            screens: Record<string, any>;
+            theme?: Record<string, any>;
+            permissions?: Record<string, any>;
+        };
+    }>;
+    getFullGraphType(baseGraphType: string): string;
+    validateVersion(): boolean;
+    protected registerCallbacks(): Promise<void>;
+    protected registerEndpoints(): Promise<void>;
+    protected registerEndpointsManually(endpoints: EndpointDescriptor[]): void;
+}
+interface IGraphEngine {
+    invokeGraph(graph: any, config: any, signal?: AbortSignal): Promise<any>;
+    streamGraph(graph: any, config: any, onPartial: (chunk: string) => void, signal?: AbortSignal): Promise<any>;
+}
+declare class UniversalGraphService implements IGraphService {
+    protected readonly configService: ConfigService;
+    private readonly builders;
+    private readonly engine;
+    private readonly endpointRegistry;
+    readonly logger: Logger;
+    constructor(configService: ConfigService, builders: AbstractGraphBuilder<string>[], engine: IGraphEngine, endpointRegistry: EndpointRegistry);
+    getSupportedGraphTypes(): Promise<string[]>;
+    generateAnswer(payload: IGraphRequestPayload): Promise<IGraphResponsePayload>;
+    streamAnswer(payload: any, onPartial: any): Promise<{
+        requestId: any;
+        text: any;
+        attachments: any;
+        metadata: any;
+        reasoningChains: any;
+    }>;
+    healthCheck(): Promise<boolean>;
+    cancelGeneration(requestId: string): Promise<void>;
+    private readonly activeGenerations;
+    private registerActiveGeneration;
+    private unregisterActiveGeneration;
+    executeCallback(token: string, platform?: string, platformContext?: any): Promise<CallbackResult>;
+    private executeCallbackFromDecorators;
+    private parseCallbackToken;
+    private parseCallbackParams;
+    callEndpoint(graphType: string, endpointName: string, context: RequestContext): Promise<DataEnvelope>;
+    listEndpoints(graphType: string): string[];
+    listGraphTypesWithEndpoints(): string[];
+    private getBuilderForType;
+}
+
+interface IDeletionInfo {
+    deletedAt: Date;
+    deletedBy: string;
+    reason?: string;
+}
+interface IBaseEntity {
+    id: string;
+    version: number;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletion?: IDeletionInfo;
+}
+
+declare function bootstrap(AppModule: any, options?: {
+    port?: number;
+    globalPrefix?: string;
+}): Promise<_nestjs_common.INestApplication<any>>;
+
+interface LLMCallRecord {
+    modelId: string;
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    timestamp: number;
+    nodeName?: string;
+}
+interface StreamAccumulator {
+    streamedText: string;
+    reasoningChains: IReasoningChain[];
+    generation: IStoredMessageContent | null;
+    llmCalls: LLMCallRecord[];
+    traceEvents: IGraphTraceEvent[];
+    traceStartedAt: number | null;
+    traceCompletedAt: number | null;
+}
+declare class EventProcessor {
+    private readonly logger;
+    createAccumulator(): StreamAccumulator;
+    private normalizeContentBlocks;
+    processEvent(acc: StreamAccumulator, event: any, onPartial?: (chunk: string) => void): void;
+    getResult(acc: StreamAccumulator): {
+        content: IStoredMessageContent;
+        metrics: {
+            modelCalls: Array<{
+                nodeName: string;
+                timestamp: number;
+                modelId: string;
+                promptTokens: number;
+                completionTokens: number;
+                totalTokens: number;
+                latencyMs: number;
+            }>;
+            apiCalls: any[];
+        } | null;
+        trace: {
+            events: IGraphTraceEvent[];
+            startedAt: number;
+            completedAt: number;
+            durationMs: number;
+            totalEvents: number;
+            totalModelCalls: number;
+        } | null;
+    };
+    private captureTraceEvent;
+    private normalizeTraceEvent;
+}
+
+declare class LangGraphEngine implements IGraphEngine {
+    private readonly eventProcessor;
+    private readonly configService;
+    private readonly logger;
+    constructor(eventProcessor: EventProcessor, configService: ConfigService);
+    invokeGraph(graph: any, config: any, signal?: AbortSignal): Promise<any>;
+    streamGraph(graph: any, config: any, onPartial: (chunk: string) => void, signal?: AbortSignal): Promise<any>;
+    private sendMetricsWebhook;
+    private sendTraceEventsBatch;
+    private processGraphResult;
+}
+
+declare enum GraphEngineType {
+    LANGGRAPH = "langgraph",
+    LANGFLOW = "langflow",
+    FLOWISE = "flowise"
+}
+declare class GraphEngineFactory {
+    private readonly langgraph;
+    constructor(langgraph: LangGraphEngine);
+    getEngine(engineType: GraphEngineType): IGraphEngine;
+}
+
+interface UniversalGraphModuleOptions {
+    engineType?: GraphEngineType;
+    versioning?: VersioningConfig[];
+}
+declare class UniversalGraphModule {
+    static forRoot(options: UniversalGraphModuleOptions): DynamicModule;
+}
+
+interface ApiCallTracerOptions {
+    maxStringLength?: number;
+    maxDepth?: number;
+}
+declare const DEFAULT_TRACER_OPTIONS: Required<ApiCallTracerOptions>;
+interface TraceApiCallResult<TResult> {
+    result: TResult;
+    startedAt: number;
+    completedAt: number;
+    durationMs: number;
+}
+declare function traceApiCall<TResult>(execute: () => Promise<TResult>, options?: ApiCallTracerOptions): Promise<TraceApiCallResult<TResult>>;
+declare function sanitizeTraceData(value: unknown, depth?: number, seen?: WeakSet<object>, options?: ApiCallTracerOptions): unknown;
+
+declare enum ModelProvider {
+    FLUTCH = "flutch",
+    FLUTCH_MISTRAL = "flutch-mistral",
+    FLUTCH_OPENAI = "flutch-openai",
+    FLUTCH_ANTHROPIC = "flutch-anthropic",
+    MISTRAL = "mistral",
+    OPENAI = "openai",
+    ANTHROPIC = "anthropic",
+    AWS = "aws",
+    COHERE = "cohere",
+    VOYAGEAI = "voyageai"
+}
+declare enum ModelType {
+    CHAT = "chat",
+    RERANK = "rerank",
+    EMBEDDING = "embedding",
+    IMAGE = "image",
+    SPEECH = "speech"
+}
+declare enum ChatFeature {
+    STREAMING = "streaming",
+    TOOLS = "tools",
+    VISION = "vision",
+    FUNCTION_CALLING = "function_calling",
+    JSON_MODE = "json_mode"
+}
+
+interface ModelConfig {
+    name: string;
+    modelProvider: ModelProvider;
+    temperature?: number;
+    maxTokens?: number;
+}
+interface ModelByIdConfig {
+    modelId: string;
+    temperature?: number;
+    maxTokens?: number;
+}
+type ModelConfigFetcher = (modelId: string) => Promise<ModelConfigWithToken>;
+interface ModelConfigWithToken {
+    modelId: string;
+    modelName: string;
+    provider: ModelProvider;
+    defaultTemperature: number;
+    defaultMaxTokens: number;
+    apiToken?: string;
+    requiresApiKey: boolean;
+}
+type LLModel = BaseChatModel;
+type ConcreteModels = ChatOpenAI | ChatAnthropic | ChatCohere | ChatMistralAI;
+type ModelCreator = (config: ModelConfig & {
+    customApiToken?: string;
+}) => LLModel;
+
+type Model = BaseChatModel | BaseDocumentCompressor | Embeddings;
+interface ModelByIdWithTypeConfig extends ModelByIdConfig {
+    modelType: ModelType;
+}
+interface ModelConfigWithTokenAndType extends ModelConfigWithToken {
+    modelType: ModelType;
+    maxDocuments?: number;
+    dimensions?: number;
+    supportedFormats?: string[];
+}
+interface IModelInitializer {
+    createChatModelById(modelId: string): Promise<BaseChatModel>;
+    createRerankModelById(modelId: string): Promise<BaseDocumentCompressor>;
+    createEmbeddingModelById(modelId: string): Promise<Embeddings>;
+    createModelById(modelId: string, expectedType?: ModelType): Promise<Model>;
+    initializeChatModel(config: ModelByIdConfig): Promise<BaseChatModel>;
+    initializeRerankModel(config: ModelByIdConfig): Promise<BaseDocumentCompressor>;
+    initializeEmbeddingModel(config: ModelByIdConfig): Promise<Embeddings>;
+    initializeModelByType(config: ModelByIdWithTypeConfig): Promise<Model>;
+    getModelConfigWithType(modelId: string): Promise<ModelConfigWithTokenAndType>;
+    isModelTypeSupported(modelType: ModelType): boolean;
+    getSupportedModelTypes(): ModelType[];
+}
+type ChatModelCreator = (config: ModelConfigWithTokenAndType) => BaseChatModel;
+type RerankModelCreator = (config: ModelConfigWithTokenAndType) => BaseDocumentCompressor;
+type EmbeddingModelCreator = (config: ModelConfigWithTokenAndType) => Embeddings;
+interface ModelCreators {
+    [ModelType.CHAT]: ChatModelCreator;
+    [ModelType.RERANK]: RerankModelCreator;
+    [ModelType.EMBEDDING]: EmbeddingModelCreator;
+    [ModelType.IMAGE]?: never;
+    [ModelType.SPEECH]?: never;
+}
+
+declare class ModelInitializer implements IModelInitializer {
+    private configFetcher?;
+    private logger;
+    private modelConfigCache;
+    private modelInstanceCache;
+    constructor(configFetcher?: ModelConfigFetcher, logger?: Logger);
+    private generateModelCacheKey;
+    private requiresMaxCompletionTokens;
+    private readonly chatModelCreators;
+    private readonly rerankModelCreators;
+    private readonly embeddingModelCreators;
+    initializeChatModel(config: ModelByIdConfig): Promise<BaseChatModel>;
+    initializeRerankModel(config: ModelByIdConfig): Promise<BaseDocumentCompressor>;
+    initializeEmbeddingModel(config: ModelByIdConfig): Promise<Embeddings>;
+    createChatModelById(modelId: string): Promise<BaseChatModel>;
+    createRerankModelById(modelId: string): Promise<BaseDocumentCompressor>;
+    createEmbeddingModelById(modelId: string): Promise<Embeddings>;
+    createModelById(modelId: string, expectedType?: ModelType): Promise<Model>;
+    initializeModelByType(config: ModelByIdWithTypeConfig): Promise<Model>;
+    getModelConfigWithType(modelId: string): Promise<ModelConfigWithTokenAndType>;
+    isModelTypeSupported(modelType: ModelType): boolean;
+    getSupportedModelTypes(): ModelType[];
+    clearCache(): void;
+    clearModelCache(modelId: string): void;
+    getCacheStats(): {
+        configCacheSize: number;
+        instanceCacheSize: number;
+        configCacheKeys: string[];
+        instanceCacheKeys: string[];
+    };
+    private fetchFromApi;
+}
+declare function prepareModelWithTools(model: BaseChatModel, tools: StructuredTool[], baseConfig?: any): {
+    modelWithTools: any;
+    finalConfig: any;
+    toolsMethod: "bindTools" | "manual" | "none";
+};
+
+interface VoyageAIRerankConfig {
+    apiKey?: string;
+    model?: string;
+    topN?: number;
+    truncation?: boolean;
+}
+declare class VoyageAIRerank extends BaseDocumentCompressor {
+    private apiKey;
+    private model;
+    private topN;
+    private truncation;
+    private baseUrl;
+    constructor(config: VoyageAIRerankConfig);
+    compressDocuments(documents: Document[], query: string, callbacks?: any): Promise<Document[]>;
+}
+
+interface IToolCatalog extends IBaseEntity {
+    toolName: string;
+    title: string;
+    description?: string;
+    category?: string;
+    isActive: boolean;
+    toolVersion?: string;
+    configSchema?: IToolConfigOption[];
+}
+interface IToolConfigOption {
+    key: string;
+    name: string;
+    description?: string;
+    type: "string" | "number" | "boolean" | "select" | "kbselect" | "modelSelector" | "text" | "textarea";
+    required?: boolean;
+    defaultValue?: any;
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+    params?: {
+        isMulti?: boolean;
+        minimum?: number;
+        maximum?: number;
+        placeholder?: string;
+        maxLength?: number;
+        modelType?: ModelType;
+        provider?: ModelProvider;
+        isActive?: boolean;
+    };
+}
+
+interface IAgentToolConfig {
+    toolName: string;
+    enabled: boolean;
+    config?: Record<string, any>;
+}
+interface IAgentToolConfiguration {
+    toolName: string;
+    enabled: boolean;
+    config?: Record<string, any>;
+    credentials?: Record<string, string>;
+    useGlobalCredentials?: boolean;
+}
+interface ISystemToolCredentials {
+    toolName: string;
+    credentials: Record<string, string>;
+    createdBy: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface IToolExecutionContext {
+    toolName: string;
+    config: Record<string, any>;
+    credentials: Record<string, string>;
+    agentId: string;
+    userId: string;
+}
+
+interface McpTool {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: Record<string, any>;
+        required?: string[];
+    };
+}
+interface ToolExecutionResult {
+    success: boolean;
+    result?: any;
+    error?: string;
+}
+interface McpRuntimeClient {
+    getTools(): Promise<McpTool[]>;
+    executeTool(name: string, args: any): Promise<ToolExecutionResult>;
+    isHealthy(): Promise<boolean>;
+}
+
+type LangChainStructuredTool = StructuredTool<any, any, any, string>;
+declare class McpConverter {
+    private readonly logger;
+    private readonly mcpRuntimeUrl;
+    constructor(mcpRuntimeUrl?: string);
+    private jsonSchemaToZod;
+    private mapPrimitiveSchema;
+    convertTool(mcpTool: McpTool): LangChainStructuredTool;
+    convertTools(mcpTools: McpTool[]): Promise<LangChainStructuredTool[]>;
+    fetchAndConvertTools(filter?: string): Promise<LangChainStructuredTool[]>;
+    healthCheck(): Promise<boolean>;
+}
+
+declare class McpToolFilter {
+    private readonly mcpRuntimeUrl;
+    private readonly logger;
+    private readonly mcpConverter;
+    constructor(mcpRuntimeUrl?: string);
+    getFilteredTools(enabledTools?: string[]): Promise<StructuredTool[]>;
+    getAllTools(): Promise<StructuredTool[]>;
+    isHealthy(): Promise<boolean>;
+    getAvailableToolNames(): Promise<string[]>;
+}
+
+declare enum RetrieverSearchType {
+    Search = "search",
+    MMR = "mmr",
+    Similarity = "similarity"
+}
+
+interface CustomDocument {
+    id: string;
+    content: string;
+    metadata: {
+        knowledgeBaseId: string;
+        source?: string;
+        title?: string;
+        url?: string;
+        [key: string]: any;
+    };
+}
+interface RetrieveQueryOptions {
+    k?: number;
+    threshold?: number;
+    metadata?: Record<string, any>;
+}
+interface KnowledgeBaseInfo {
+    id: string;
+    name: string;
+    documentsCount: number;
+    lastUpdated: string;
+}
+
+interface RetrieverConfig {
+    apiUrl?: string;
+    internalToken?: string;
+    timeout?: number;
+    retries?: number;
+}
+declare class RetrieverService {
+    private readonly logger;
+    private readonly apiUrl;
+    private readonly internalToken;
+    private readonly timeout;
+    private readonly retries;
+    constructor(config?: RetrieverConfig);
+    private makeRequest;
+    healthCheck(): Promise<boolean>;
+    search(query: string, searchType: RetrieverSearchType, knowledgeBaseIds: string[], options?: RetrieveQueryOptions): Promise<CustomDocument[]>;
+    getDocumentsByIds(ids: string[]): Promise<CustomDocument[]>;
+    knowledgeBaseExists(knowledgeBaseId: string): Promise<boolean>;
+    getKnowledgeBaseInfo(knowledgeBaseId: string): Promise<KnowledgeBaseInfo | null>;
+    textSearch(query: string, knowledgeBaseIds: string[], limit?: number): Promise<CustomDocument[]>;
+    getAvailableKnowledgeBases(): Promise<KnowledgeBaseInfo[]>;
+    check(): string;
+}
+
+declare class GraphTypeUtils {
+    static parse(fullType: string): {
+        companyId: string;
+        name: string;
+        version?: string;
+    };
+    static build(companyId: string, name: string, version?: string): string;
+    static normalize(graphType: string): string;
+    static getBaseType(graphType: string): string;
+    static getVersion(graphType: string): string | undefined;
+    static isValidVersion(version: string): boolean;
+    static isSystemGraph(graphType: string): boolean;
+    static compareVersions(a: string, b: string): number;
+}
+
+export { type ACLValidationResult, AbstractGraphBuilder, type ApiCallTracerOptions, AttachmentType, type AuditEntry, GraphController as BaseGraphServiceController, UniversalGraphModule as BaseGraphServiceModule, type BaseGraphState, BuilderRegistryService, Callback, CallbackACL, CallbackAuditAction, CallbackAuditor, type CallbackContext, CallbackController, type CallbackEntry, type CallbackHandler, type CallbackMetadata, CallbackMetrics, type CallbackPatch, type CallbackPatchHandler, CallbackPatchService, CallbackRateLimiter, type CallbackRecord, CallbackRegistry, type CallbackRequest, type CallbackResult, CallbackStore, CallbackTokenGuard, type CallbackUser, type ChartType, ChatFeature, type ChatModelCreator, type CitationValue, type CompiledGraphFor, type ConcreteModels, type CustomDocument, DEFAULT_TRACER_OPTIONS, type DataEnvelope, ENDPOINT_METADATA_KEY, type EmbeddingModelCreator, Endpoint, type EndpointDescriptor, type EndpointHandler, type EndpointMetadata, type EndpointOptions, EndpointRegistry, EventProcessor, type ExtendedCallbackContext, type ExtendedCallbackHandler, GraphController, GraphEngineFactory, GraphEngineType, GraphManifestSchema, GraphManifestValidator, GraphServiceTokens, GraphTypeUtils, type IAgentToolConfig, type IAgentToolConfiguration, type IAttachment, type IBaseEntity, type IChartDataPoint, type IChartDataset, type IChartValue, type IDeletionInfo, type IGenericGraphType, type IGraphBuilder, type IGraphCompiler, type IGraphConfigurable, type IGraphEngine, type IGraphManifest, type IGraphMetadata, type IGraphMetadataRegistry, type IGraphRequestPayload, type IGraphResponsePayload, type IGraphRunnableConfig, type IGraphService, type IGraphServiceRegistry, type IGraphSettingsRepository, type IGraphTraceEvent, type IGraphTracer, type IGraphTypeMetadata, type IGraphTypeRegistry, type IModelInitializer, type IReasoningChain, type IReasoningStep, type IStoredMessageContent, type ISystemToolCredentials, type IToolCall, type IToolCatalog, type IToolConfigOption, type IToolExecutionContext, type ITracingEvent, type IUsageMetrics, type IUsageRecorder, type IdempotencyConfig, type IdempotencyEntry, IdempotencyManager, IdempotencyStatus, type KnowledgeBaseInfo, type LLMCallRecord, type LLMConfig, type LLModel, LangGraphEngine, type MappedChannels, McpConverter, type McpRuntimeClient, type McpTool, McpToolFilter, type Model, type ModelByIdConfig, type ModelByIdWithTypeConfig, type ModelConfig, type ModelConfigFetcher, type ModelConfigWithToken, type ModelConfigWithTokenAndType, type ModelCreator, type ModelCreators, ModelInitializer, ModelProvider, ModelType, type RateLimitConfig, type RateLimitResult, type RequestContext, type RerankModelCreator, type RetrieveQueryOptions, type RetrieverConfig, RetrieverSearchType, RetrieverService, type RouterConfig, SmartCallbackRouter, type StreamAccumulator, StreamChannel, type StrictGraphRunnableConfig, TelegramPatchHandler, type ToolExecutionResult, type TraceApiCallResult, type TracingLevel, UIDispatchController, type UIDispatchDto, UIEndpoint, type UIEndpointClassMetadata, type UIEndpointMethodMetadata, UIEndpointsDiscoveryService, UniversalCallbackService, UniversalGraphModule, type UniversalGraphModuleOptions, UniversalGraphService, type VersionResolution, type VersionResolutionOptions, type VersionRoute, VersionedGraphService, type VersioningConfig, VoyageAIRerank, type VoyageAIRerankConfig, WebPatchHandler, WithCallbacks, WithEndpoints, WithUIEndpoints, bootstrap, createEndpointDescriptors, findCallbackMethod, findEndpointMethod, getCallbackMetadata, getEndpointMetadata, getUIEndpointClassMetadata, getUIEndpointMethodsMetadata, hasCallbacks, hasUIEndpoints, prepareModelWithTools, registerFinanceExampleCallback, registerUIEndpointsFromClass, sanitizeTraceData, traceApiCall };