@flutchai/flutch-sdk 0.1.0

package/dist/callbacks/web-patch.handler.d.ts

@@ -0,0 +1,6 @@
+import { CallbackPatch } from "../interfaces/callback.interface";
+import { CallbackPatchHandler } from "./callback-patch.service";
+export declare class WebPatchHandler implements CallbackPatchHandler {
+    private readonly logger;
+    apply(patch: CallbackPatch, context?: any): Promise<void>;
+}

package/dist/callbacks/web-patch.handler.js

@@ -0,0 +1,24 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var WebPatchHandler_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebPatchHandler = void 0;
+const common_1 = require("@nestjs/common");
+let WebPatchHandler = WebPatchHandler_1 = class WebPatchHandler {
+    constructor() {
+        this.logger = new common_1.Logger(WebPatchHandler_1.name);
+    }
+    async apply(patch, context) {
+        this.logger.debug(`Applying Web patch ${JSON.stringify(patch)} with context ${JSON.stringify(context)}`);
+    }
+};
+exports.WebPatchHandler = WebPatchHandler;
+exports.WebPatchHandler = WebPatchHandler = WebPatchHandler_1 = __decorate([
+    (0, common_1.Injectable)()
+], WebPatchHandler);
+//# sourceMappingURL=web-patch.handler.js.map

package/dist/callbacks/web-patch.handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-patch.handler.js","sourceRoot":"","sources":["../../src/callbacks/web-patch.handler.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,2CAAoD;AAK7C,IAAM,eAAe,uBAArB,MAAM,eAAe;IAArB;QACY,WAAM,GAAG,IAAI,eAAM,CAAC,iBAAe,CAAC,IAAI,CAAC,CAAC;IAS7D,CAAC;IAPC,KAAK,CAAC,KAAK,CAAC,KAAoB,EAAE,OAAa;QAC7C,IAAI,CAAC,MAAM,CAAC,KAAK,CACf,sBAAsB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,iBAAiB,IAAI,CAAC,SAAS,CACxE,OAAO,CACR,EAAE,CACJ,CAAC;IACJ,CAAC;CACF,CAAA;AAVY,0CAAe;0BAAf,eAAe;IAD3B,IAAA,mBAAU,GAAE;GACA,eAAe,CAU3B"}

package/dist/core/abstract-graph.builder.d.ts

@@ -0,0 +1,128 @@
+import { Logger } from "@nestjs/common";
+import { ConfigService } from "@nestjs/config";
+import { CallbackResult, IGraphRequestPayload, IGraphResponsePayload, IGraphService } from "../interfaces";
+import { CallbackRegistry } from "../callbacks/callback-registry";
+import { EndpointRegistry } from "../endpoint-registry/endpoint.registry";
+export 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;
+    }>;
+}
+export 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: import("../endpoint-registry/endpoint.registry").EndpointDescriptor[]): void;
+}
+export interface IGraphEngine {
+    invokeGraph(graph: any, config: any, signal?: AbortSignal): Promise<any>;
+    streamGraph(graph: any, config: any, onPartial: (chunk: string) => void, signal?: AbortSignal): Promise<any>;
+}
+export 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: import("../endpoint-registry/endpoint.registry").RequestContext): Promise<import("../endpoint-registry/endpoint.registry").DataEnvelope>;
+    listEndpoints(graphType: string): string[];
+    listGraphTypesWithEndpoints(): string[];
+    private getBuilderForType;
+}

package/dist/core/abstract-graph.builder.js

@@ -0,0 +1,488 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var UniversalGraphService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniversalGraphService = exports.AbstractGraphBuilder = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const path = __importStar(require("path"));
+const callback_registry_1 = require("../callbacks/callback-registry");
+const endpoint_registry_1 = require("../endpoint-registry/endpoint.registry");
+class AbstractGraphBuilder {
+    get graphType() {
+        var _a, _b, _c, _d;
+        if (((_a = this.manifest) === null || _a === void 0 ? void 0 : _a.companySlug) && ((_b = this.manifest) === null || _b === void 0 ? void 0 : _b.name)) {
+            return `${this.manifest.companySlug}.${this.manifest.name}::${this.version}`;
+        }
+        console.log(`DEBUG graphType: manifest=${!!this.manifest}, companySlug=${(_c = this.manifest) === null || _c === void 0 ? void 0 : _c.companySlug}, name=${(_d = this.manifest) === null || _d === void 0 ? void 0 : _d.name}, version=${this.version}`);
+        return `unknown::${this.version}`;
+    }
+    constructor() {
+        this.logger = new common_1.Logger(AbstractGraphBuilder.name);
+        this.manifestPath = path.join(process.cwd(), "graph.manifest.json");
+        try {
+            this.loadManifestSync();
+            if (this.manifest) {
+                this.logger.debug(`Loaded manifest for ${this.manifest.companySlug}.${this.manifest.name} (${this.constructor.name})`);
+            }
+        }
+        catch (error) {
+            this.logger.warn(`Failed to load manifest in constructor: ${error.message}`);
+        }
+        setImmediate(() => {
+            this.logger.debug(`Starting callback and endpoint registration for ${this.constructor.name}`);
+            this.registerCallbacks().catch(error => {
+                this.logger.error(`Failed to register callbacks in constructor: ${error.message}`);
+            });
+            this.registerEndpoints().catch(error => {
+                this.logger.error(`Failed to register endpoints in constructor: ${error.message}`);
+            });
+        });
+    }
+    createGraphContext(payload) {
+        return {
+            messageId: payload.messageId,
+            threadId: payload.threadId,
+            userId: payload.userId,
+            agentId: payload.agentId,
+            companyId: payload.companyId,
+        };
+    }
+    async prepareConfig(payload) {
+        const context = this.createGraphContext(payload);
+        return {
+            configurable: {
+                thread_id: payload.threadId,
+                context,
+                metadata: {
+                    userId: payload.userId,
+                    agentId: payload.agentId,
+                    requestId: payload.requestId,
+                    graphType: this.graphType,
+                    version: this.version,
+                },
+            },
+        };
+    }
+    async loadManifest() {
+        if (!this.manifestPath) {
+            return null;
+        }
+        try {
+            const fs = await Promise.resolve().then(() => __importStar(require("fs/promises")));
+            const path = await Promise.resolve().then(() => __importStar(require("path")));
+            const manifestFullPath = path.resolve(this.manifestPath);
+            const manifestContent = await fs.readFile(manifestFullPath, "utf-8");
+            const manifest = JSON.parse(manifestContent);
+            this.manifest = manifest;
+            return manifest;
+        }
+        catch (error) {
+            console.error(`Failed to load manifest from ${this.manifestPath}: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    loadManifestSync() {
+        if (!this.manifestPath) {
+            return null;
+        }
+        try {
+            const fs = require("fs");
+            const path = require("path");
+            const manifestFullPath = path.resolve(this.manifestPath);
+            const manifestContent = fs.readFileSync(manifestFullPath, "utf-8");
+            const manifest = JSON.parse(manifestContent);
+            this.manifest = manifest;
+            return manifest;
+        }
+        catch (error) {
+            console.error(`Failed to load manifest from ${this.manifestPath}: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    validateManifest(manifest) {
+    }
+    async getGraphMetadata() {
+        if (this.manifest) {
+            return this.manifest;
+        }
+        return await this.loadManifest();
+    }
+    async getVersionConfig() {
+        const manifest = await this.loadManifest();
+        if (!manifest) {
+            throw new Error(`Manifest not found at ${this.manifestPath}`);
+        }
+        const versionConfig = manifest.versions[this.version];
+        if (!versionConfig) {
+            throw new Error(`Version ${this.version} not found in manifest`);
+        }
+        let configSchema = null;
+        if (versionConfig.configSchemaPath) {
+            try {
+                const fs = await Promise.resolve().then(() => __importStar(require("fs/promises")));
+                const schemaPath = path.resolve(process.cwd(), versionConfig.configSchemaPath);
+                const schemaContent = await fs.readFile(schemaPath, "utf-8");
+                const schemaData = JSON.parse(schemaContent);
+                configSchema = schemaData.schema;
+            }
+            catch (error) {
+                this.logger.warn(`Failed to load config schema: ${error.message}`);
+            }
+        }
+        return Object.assign(Object.assign({ companySlug: manifest.companySlug, name: manifest.name, title: manifest.title, description: manifest.description, detailedDescription: manifest.detailedDescription, category: manifest.category, tags: manifest.tags, ui: manifest.ui }, versionConfig), { configSchema, graphType: this.graphType, version: this.version });
+    }
+    getFullGraphType(baseGraphType) {
+        if (!baseGraphType) {
+            throw new Error("baseGraphType is required for versioned graphs");
+        }
+        return `${baseGraphType}::${this.version}`;
+    }
+    validateVersion() {
+        const versionRegex = /^\d+\.\d+\.\d+$/;
+        if (!versionRegex.test(this.version)) {
+            throw new Error(`Invalid version format: ${this.version}. Expected format: X.Y.Z`);
+        }
+        return true;
+    }
+    async registerCallbacks() {
+        this.logger.log(`CallbackRegistry instance: ${!!this.callbackRegistry}`);
+        if (!this.callbackRegistry) {
+            this.logger.error("CallbackRegistry not injected! This should not happen.");
+            return;
+        }
+        try {
+            const { getCallbackMetadata } = await Promise.resolve().then(() => __importStar(require("../decorators/callback.decorators")));
+            const callbackMetadata = getCallbackMetadata(this.constructor);
+            this.logger.log(`Found ${(callbackMetadata === null || callbackMetadata === void 0 ? void 0 : callbackMetadata.length) || 0} callbacks for ${this.constructor.name}`);
+            this.logger.log(`Callback metadata:`, JSON.stringify(callbackMetadata, null, 2));
+            if (!callbackMetadata || callbackMetadata.length === 0) {
+                this.logger.warn(`No callbacks found for ${this.constructor.name}. Check @WithCallbacks decorator.`);
+                return;
+            }
+            const fullGraphType = this.graphType;
+            for (const { handler, method } of callbackMetadata) {
+                const callbackMethod = this[method];
+                if (typeof callbackMethod === "function") {
+                    const boundCallback = async (context) => {
+                        return callbackMethod.call(this, context);
+                    };
+                    this.callbackRegistry.register(handler, boundCallback, fullGraphType);
+                    this.logger.log(`Registered callback "${handler}" for graph type "${fullGraphType}"`);
+                }
+            }
+            this.logger.log(`Registered ${callbackMetadata.length} callbacks for ${this.constructor.name}`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to register callbacks: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async registerEndpoints() {
+        this.logger.log(`EndpointRegistry instance: ${!!this.endpointRegistry}`);
+        if (!this.endpointRegistry) {
+            this.logger.error("EndpointRegistry not injected! This should not happen.");
+            return;
+        }
+        try {
+            const { getEndpointMetadata, createEndpointDescriptors } = await Promise.resolve().then(() => __importStar(require("../endpoint-registry/endpoint.decorators")));
+            const endpointMetadata = getEndpointMetadata(this.constructor);
+            if (!endpointMetadata || endpointMetadata.length === 0) {
+                return;
+            }
+            this.logger.log(`Found ${endpointMetadata.length} endpoints for ${this.constructor.name}`);
+            this.logger.debug(`Endpoint metadata:`, JSON.stringify(endpointMetadata, null, 2));
+            const fullGraphType = this.graphType;
+            const endpointDescriptors = createEndpointDescriptors(this, endpointMetadata);
+            for (const descriptor of endpointDescriptors) {
+                this.endpointRegistry.register(fullGraphType, descriptor);
+                this.logger.log(`Registered endpoint "${descriptor.name}" for graph type "${fullGraphType}"`);
+            }
+            this.logger.log(`Registered ${endpointDescriptors.length} endpoints for ${this.constructor.name}`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to register endpoints: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    registerEndpointsManually(endpoints) {
+        if (!this.endpointRegistry) {
+            this.logger.error("EndpointRegistry not available");
+            return;
+        }
+        const fullGraphType = this.graphType;
+        for (const endpoint of endpoints) {
+            this.endpointRegistry.register(fullGraphType, endpoint);
+            this.logger.log(`Manually registered endpoint "${endpoint.name}" for graph type "${fullGraphType}"`);
+        }
+    }
+}
+exports.AbstractGraphBuilder = AbstractGraphBuilder;
+__decorate([
+    (0, common_1.Inject)(callback_registry_1.CallbackRegistry),
+    __metadata("design:type", callback_registry_1.CallbackRegistry)
+], AbstractGraphBuilder.prototype, "callbackRegistry", void 0);
+__decorate([
+    (0, common_1.Inject)(endpoint_registry_1.EndpointRegistry),
+    __metadata("design:type", endpoint_registry_1.EndpointRegistry)
+], AbstractGraphBuilder.prototype, "endpointRegistry", void 0);
+let UniversalGraphService = UniversalGraphService_1 = class UniversalGraphService {
+    constructor(configService, builders, engine, endpointRegistry) {
+        this.configService = configService;
+        this.builders = builders;
+        this.engine = engine;
+        this.endpointRegistry = endpointRegistry;
+        this.logger = new common_1.Logger(UniversalGraphService_1.name);
+        this.activeGenerations = new Map();
+        this.logger.log("UniversalGraphService initialized");
+    }
+    async getSupportedGraphTypes() {
+        return this.builders.map(builder => {
+            return builder.graphType;
+        });
+    }
+    async generateAnswer(payload) {
+        const builder = this.getBuilderForType(payload.graphType);
+        const graph = await builder.buildGraph(payload);
+        const config = await builder.prepareConfig(payload);
+        const abortController = new AbortController();
+        this.registerActiveGeneration(payload.requestId, () => {
+            abortController.abort();
+        });
+        try {
+            const result = await this.engine.invokeGraph(graph, config, abortController.signal);
+            return {
+                requestId: payload.requestId,
+                text: result.text || "",
+                attachments: result.attachments || [],
+                metadata: result.metadata || {},
+                reasoningChains: result.reasoningChains || [],
+            };
+        }
+        finally {
+            this.unregisterActiveGeneration(payload.requestId);
+        }
+    }
+    async streamAnswer(payload, onPartial) {
+        var _a, _b, _c;
+        this.logger.debug(`>>> Entering streamAnswer with requestId: ${payload.requestId}`);
+        const abortController = new AbortController();
+        try {
+            const builder = this.getBuilderForType(payload.graphType);
+            this.logger.debug(`Got builder for graph type: ${payload.graphType}`);
+            const graph = await builder.buildGraph(payload);
+            this.logger.debug(`Graph built for requestId: ${payload.requestId}`);
+            this.logger.debug(`Preparing config for requestId: ${payload.requestId}`);
+            const config = await builder.prepareConfig(payload);
+            this.logger.debug(`Config prepared`);
+            this.registerActiveGeneration(payload.requestId, () => {
+                abortController.abort();
+            });
+            this.logger.debug(`Active generation registered: ${payload.requestId}`);
+            this.logger.debug(`Calling engine.streamGraph for requestId: ${payload.requestId}`);
+            const result = await this.engine.streamGraph(graph, config, onPartial, abortController.signal);
+            this.logger.debug(`[STREAM-RESULT] Engine returned:`, {
+                hasText: !!result.text,
+                textLength: ((_a = result.text) === null || _a === void 0 ? void 0 : _a.length) || 0,
+                attachmentsCount: ((_b = result.attachments) === null || _b === void 0 ? void 0 : _b.length) || 0,
+                reasoningChainsCount: ((_c = result.reasoningChains) === null || _c === void 0 ? void 0 : _c.length) || 0,
+                resultKeys: Object.keys(result || {}),
+            });
+            return {
+                requestId: payload.requestId,
+                text: result.text || "",
+                attachments: result.attachments || [],
+                metadata: result.metadata || {},
+                reasoningChains: result.reasoningChains || [],
+            };
+        }
+        catch (error) {
+            this.logger.error(`Ошибка в streamAnswer: ${error.message}`);
+            this.logger.error(`Стектрейс: ${error.stack}`);
+            throw error;
+        }
+        finally {
+            abortController.abort();
+            this.unregisterActiveGeneration(payload.requestId);
+        }
+    }
+    async healthCheck() {
+        try {
+            if (this.builders.length === 0) {
+                this.logger.warn("No builders registered");
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Health check failed: ${error.message}`);
+            return false;
+        }
+    }
+    async cancelGeneration(requestId) {
+        const generation = this.activeGenerations.get(requestId);
+        if (generation) {
+            generation.cancel();
+            this.activeGenerations.delete(requestId);
+            this.logger.log(`Cancelled generation for request: ${requestId}`);
+        }
+        else {
+            this.logger.warn(`No active generation found for request: ${requestId}`);
+        }
+    }
+    registerActiveGeneration(requestId, cancel) {
+        this.activeGenerations.set(requestId, { cancel });
+        setTimeout(() => {
+            if (this.activeGenerations.has(requestId)) {
+                this.activeGenerations.delete(requestId);
+                this.logger.debug(`Auto-cleaned generation for request: ${requestId}`);
+            }
+        }, 10 * 60 * 1000);
+    }
+    unregisterActiveGeneration(requestId) {
+        this.activeGenerations.delete(requestId);
+    }
+    async executeCallback(token, platform, platformContext) {
+        this.logger.debug(`Executing callback with token: ${token}`);
+        try {
+            const result = await this.executeCallbackFromDecorators(token, platform, platformContext);
+            if (result) {
+                return result;
+            }
+            return {
+                success: false,
+                error: "Callback handler not found",
+            };
+        }
+        catch (error) {
+            this.logger.error(`Error executing callback: ${error instanceof Error ? error.message : String(error)}`);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : "Unknown error",
+            };
+        }
+    }
+    async executeCallbackFromDecorators(token, platform, platformContext) {
+        const { getCallbackMetadata, findCallbackMethod } = await Promise.resolve().then(() => __importStar(require("../decorators/callback.decorators")));
+        const { graphType, handler } = this.parseCallbackToken(token);
+        const builder = this.builders.find(b => b.graphType === graphType);
+        if (!builder) {
+            this.logger.warn(`No builder found for graph type: ${graphType}`);
+            return null;
+        }
+        const methodName = findCallbackMethod(builder.constructor, handler);
+        if (!methodName || typeof builder[methodName] !== "function") {
+            this.logger.warn(`No callback method found for handler: ${handler} in ${graphType}`);
+            return null;
+        }
+        const context = {
+            userId: (platformContext === null || platformContext === void 0 ? void 0 : platformContext.userId) || "unknown",
+            threadId: platformContext === null || platformContext === void 0 ? void 0 : platformContext.threadId,
+            agentId: platformContext === null || platformContext === void 0 ? void 0 : platformContext.agentId,
+            params: this.parseCallbackParams(token),
+            platform,
+            metadata: {
+                token,
+                platformContext,
+                graphType,
+                handler,
+            },
+        };
+        this.logger.debug(`Executing callback ${handler} on builder ${graphType}`);
+        const result = await builder[methodName](context);
+        return result;
+    }
+    parseCallbackToken(token) {
+        const parts = token.split("_");
+        if (parts.length < 4 || parts[0] !== "cb") {
+            throw new Error(`Invalid callback token format: ${token}`);
+        }
+        const graphName = parts[1];
+        const handler = parts[2];
+        const graphType = `${graphName}::1.0.0`;
+        return { graphType, handler };
+    }
+    parseCallbackParams(token) {
+        const parts = token.split("_");
+        if (parts.length < 4) {
+            return {};
+        }
+        try {
+            const encodedParams = parts.slice(3).join("_");
+            const decodedParams = Buffer.from(encodedParams, "base64url").toString("utf8");
+            return JSON.parse(decodedParams);
+        }
+        catch (error) {
+            this.logger.warn(`Failed to parse callback params from token: ${token}`, error);
+            return {};
+        }
+    }
+    async callEndpoint(graphType, endpointName, context) {
+        this.logger.debug(`Calling endpoint "${endpointName}" for graph "${graphType}"`);
+        return await this.endpointRegistry.call(graphType, endpointName, context);
+    }
+    listEndpoints(graphType) {
+        return this.endpointRegistry.list(graphType);
+    }
+    listGraphTypesWithEndpoints() {
+        return this.endpointRegistry.listGraphTypes();
+    }
+    getBuilderForType(graphType) {
+        const builder = this.builders.find(b => b.graphType === graphType);
+        if (!builder) {
+            throw new Error(`No builder found for graph type: ${graphType}`);
+        }
+        return builder;
+    }
+};
+exports.UniversalGraphService = UniversalGraphService;
+exports.UniversalGraphService = UniversalGraphService = UniversalGraphService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Inject)("GRAPH_BUILDERS")),
+    __param(2, (0, common_1.Inject)("GRAPH_ENGINE")),
+    __param(3, (0, common_1.Inject)(endpoint_registry_1.EndpointRegistry)),
+    __metadata("design:paramtypes", [config_1.ConfigService, Array, Object, endpoint_registry_1.EndpointRegistry])
+], UniversalGraphService);
+//# sourceMappingURL=abstract-graph.builder.js.map