@ductape/sdk 0.0.4-v59 → 0.0.4-v60

package/dist/index.js

@@ -32,6 +32,17 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -52,7 +63,6 @@ const productsApi_service_1 = require("./api/services/productsApi.service");
 const imports_service_1 = __importDefault(require("./imports/imports.service"));
 const processor_service_1 = __importDefault(require("./processor/services/processor.service"));
 const logs_service_1 = __importDefault(require("./logs/logs.service"));
-const utils_1 = require("./utils");
 const mime = __importStar(require("mime-types"));
 const processor_utils_1 = require("./processor/utils/processor.utils");
 const database_1 = require("./database");
@@ -409,7 +419,7 @@ class Ductape {
         }
         return await Promise.resolve().then(() => __importStar(require('ioredis')));
     }
-    constructor({ workspace_id, private_key, user_id, env_type, redis_url }) {
+    constructor({ accessKey, env_type, redis_url }) {
         this.productBuilders = new Map();
         this.appBuilders = new Map();
         // Cached service instances (lazily initialized after auth)
@@ -422,6 +432,7 @@ class Ductape {
         this._cacheService = null;
         this._jobsService = null;
         this._secretsService = null;
+        this._privateKey = null;
         this._quotaService = null;
         this._fallbackService = null;
         this._healthcheckService = null;
@@ -1027,9 +1038,17 @@ class Ductape {
              * @param {IProductStorage} data - The storage data.
              * @returns {Promise<void>} Resolves when the storage is created. Throws on error.
              */
-            create: async (product, data) => {
+            create: async (data) => {
+                // Ensure secrets service is initialized for secret storage
+                await this.createNewSecretsService();
+                const { product } = data, storageData = __rest(data, ["product"]);
                 const builder = await this.getProductBuilder(product);
-                return builder.createStorage(data);
+                return builder.createStorage(storageData);
+            },
+            /**
+             * Creates a storage for a product (alternative method).
+              const builder = await this.getProductBuilder(product);
+              return builder.createStorage(data);
             },
             /**
              * Fetches all storages for a product.
@@ -1058,6 +1077,8 @@ class Ductape {
              * @returns {Promise<void>} Resolves when the storage is updated. Throws on error.
              */
             update: async (product, tag, data) => {
+                // Ensure secrets service is initialized for secret storage
+                await this.createNewSecretsService();
                 const builder = await this.getProductBuilder(product);
                 return builder.updateStorage(tag, data);
             },
@@ -1278,16 +1299,17 @@ class Ductape {
         /**
          * Events-related operations for managing product events (message brokers).
          */
-        this.events = {
+        this.messaging = {
             /**
              * Creates a message broker for a product.
              * @param {string} product - The product tag.
              * @param {Partial<IProductMessageBroker>} data - The message broker data.
              * @returns {Promise<void>} Resolves when the message broker is created. Throws on error.
              */
-            create: async (product, data) => {
+            create: async (data) => {
+                const { product } = data, brokerData = __rest(data, ["product"]);
                 const builder = await this.getProductBuilder(product);
-                return builder.createMessageBroker(data);
+                return builder.createMessageBroker(brokerData);
             },
             /**
              * Fetches all message brokers for a product.
@@ -1384,23 +1406,23 @@ class Ductape {
              *   message: { orderId: '123', status: 'pending' }
              * });
              */
-            publish: async (data) => {
+            produce: async (data) => {
                 const brokersService = await this.createNewBrokersService();
                 return brokersService.publish(data);
             },
             /**
-             * Subscribes to a message broker topic.
+             * consume to a message broker topic.
              * @param data - The subscribe input.
              * @returns The result of the subscribe operation.
              * @example
-             * await ductape.events.subscribe({
+             * await ductape.events.consume({
              *   product: 'my-product',
              *   env: 'production',
              *   event: 'broker-tag:topic-tag',
              *   callback: async (message) => console.log(message)
              * });
              */
-            subscribe: async (data) => {
+            consume: async (data) => {
                 const brokersService = await this.createNewBrokersService();
                 return brokersService.subscribe(data);
             },
@@ -2115,17 +2137,18 @@ class Ductape {
              * @param {string} [productTag] - The product tag.
              * @returns {Promise<void>} Resolves when the graph is created.
              */
-            create: async (graphConfig, productTag) => {
+            create: async (graphConfig) => {
                 const graphService = await this.createNewGraphService();
-                return graphService.create(graphConfig, productTag);
+                const { product: productTag } = graphConfig, config = __rest(graphConfig, ["product"]);
+                return graphService.create(config, productTag);
             },
             /**
              * Fetches a graph configuration by tag.
-             * @param {string} graphTag - The graph tag.
              * @param {string} [productTag] - The product tag.
+             * @param {string} graphTag - The graph tag.
              * @returns {Promise<any>} The fetched graph configuration.
              */
-            fetch: async (graphTag, productTag) => {
+            fetch: async (productTag, graphTag) => {
                 const graphService = await this.createNewGraphService();
                 return graphService.fetch(graphTag, productTag);
             },
@@ -2140,12 +2163,12 @@ class Ductape {
             },
             /**
              * Updates a graph configuration by tag.
+             * @param {string} [productTag] - The product tag.
              * @param {string} graphTag - The graph tag.
              * @param {any} updates - The updates to apply.
-             * @param {string} [productTag] - The product tag.
              * @returns {Promise<void>} Resolves when the graph is updated.
              */
-            update: async (graphTag, updates, productTag) => {
+            update: async (productTag, graphTag, updates) => {
                 const graphService = await this.createNewGraphService();
                 return graphService.update(graphTag, updates, productTag);
             },
@@ -2703,11 +2726,356 @@ class Ductape {
          */
         this.vector = {
             /**
-             * Get the underlying VectorDatabaseService instance
+             * Get the underlying VectorDatabaseService instance for advanced operations.
+             * @returns {Promise<VectorDatabaseService>} The vector database service instance.
              */
             getService: async () => {
                 return this.createNewVectorService();
             },
+            // ==================== CRUD OPERATIONS ====================
+            /**
+             * Creates a vector database configuration for a product.
+             * @param {ICreateVectorDbOptions} options - The vector configuration options.
+             * @returns {Promise<void>} Resolves when the vector config is created.
+             */
+            create: async (options) => {
+                const vectorService = await this.createNewVectorService();
+                return vectorService.create(options);
+            },
+            /**
+             * Fetches a vector database configuration by tag.
+             * @param {IFetchVectorOptions} options - The fetch options.
+             * @returns {Promise<IProductVector | null>} The fetched vector configuration.
+             */
+            fetch: async (options) => {
+                const vectorService = await this.createNewVectorService();
+                return vectorService.fetch(options);
+            },
+            /**
+             * Fetches all vector database configurations for a product.
+             * @param {object} options - The fetch options containing product tag.
+             * @returns {Promise<IProductVector[]>} The list of vector configurations.
+             */
+            list: async (options) => {
+                const vectorService = await this.createNewVectorService();
+                return vectorService.fetchAll(options);
+            },
+            /**
+             * Updates a vector database configuration.
+             * @param {IUpdateVectorDbOptions} options - The update options.
+             * @returns {Promise<void>} Resolves when the vector config is updated.
+             */
+            update: async (options) => {
+                const vectorService = await this.createNewVectorService();
+                return vectorService.update(options);
+            },
+            /**
+             * Deletes a vector database configuration.
+             * @param {IDeleteVectorConfigOptions} options - The delete options.
+             * @returns {Promise<void>} Resolves when the vector config is deleted.
+             */
+            delete: async (options) => {
+                const vectorService = await this.createNewVectorService();
+                return vectorService.delete(options);
+            },
+            // ==================== CONNECTION MANAGEMENT ====================
+            /**
+             * Connects to a vector database.
+             * @param {object} options - Connection options with product, env, and vector.
+             * @returns {Promise<VectorService>} The connected vector service.
+             */
+            connect: async (options) => {
+                const vectorService = await this.createNewVectorService();
+                return vectorService.connect(options);
+            },
+            /**
+             * Disconnects from a specific vector database.
+             * @param {object} options - Disconnect options with product, env, and vector.
+             * @returns {Promise<void>} Resolves when disconnected.
+             */
+            disconnect: async (options) => {
+                const vectorService = await this.createNewVectorService();
+                return vectorService.disconnect(options);
+            },
+            /**
+             * Disconnects all cached vector database connections.
+             * @returns {Promise<void>} Resolves when all connections are closed.
+             */
+            disconnectAll: async () => {
+                const vectorService = await this.createNewVectorService();
+                return vectorService.disconnectAll();
+            },
+            // ==================== VECTOR OPERATIONS ====================
+            /**
+             * Query vectors by similarity.
+             * @param {IProductVectorQueryOptions} options - The query options.
+             * @returns {Promise<IQueryVectorsResult>} The query results.
+             */
+            query: async (options) => {
+                const vectorService = await this.createNewVectorService();
+                return vectorService.query(options);
+            },
+            /**
+             * Upsert vectors (insert or update).
+             * @param {IProductVectorUpsertOptions} options - The upsert options.
+             * @returns {Promise<IUpsertVectorsResult>} The upsert result.
+             */
+            upsert: async (options) => {
+                const vectorService = await this.createNewVectorService();
+                return vectorService.upsert(options);
+            },
+            /**
+             * Fetch vectors by IDs.
+             * @param {IProductVectorFetchOptions} options - The fetch options.
+             * @returns {Promise<IFetchVectorsResult>} The fetched vectors.
+             */
+            fetchVectors: async (options) => {
+                const vectorService = await this.createNewVectorService();
+                return vectorService.fetchVectors(options);
+            },
+            /**
+             * Delete vectors by IDs.
+             * @param {IProductVectorDeleteOptions} options - The delete options.
+             * @returns {Promise<IDeleteVectorsResult>} The delete result.
+             */
+            deleteVectors: async (options) => {
+                const vectorService = await this.createNewVectorService();
+                return vectorService.deleteVectors(options);
+            },
+            /**
+             * Find similar vectors to a given vector.
+             * @param {object} options - Find similar options with product, env, tag, vector, and topK.
+             * @returns {Promise<IQueryVectorsResult>} The similar vectors.
+             */
+            findSimilar: async (options) => {
+                const { product, env, vector, values, topK = 10 } = options, rest = __rest(options, ["product", "env", "vector", "values", "topK"]);
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.findSimilar(values, topK, rest);
+            },
+            /**
+             * Upsert a single vector.
+             * @param {object} options - Single vector upsert options.
+             * @returns {Promise<IUpsertVectorsResult>} The upsert result.
+             */
+            upsertOne: async (options) => {
+                const { product, env, tag, id, values, metadata, namespace } = options;
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector: tag });
+                return service.upsertOne(id, values, metadata, namespace);
+            },
+            /**
+             * Fetch a single vector by ID.
+             * @param {object} options - Single vector fetch options.
+             * @returns {Promise<IVector | null>} The fetched vector or null.
+             */
+            fetchOne: async (options) => {
+                const { product, env, vector, id, namespace } = options;
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.fetchOne(id, namespace);
+            },
+            /**
+             * Update a single vector.
+             * @param {object} options - Update options.
+             * @returns {Promise<IUpdateVectorResult>} The update result.
+             */
+            updateVector: async (options) => {
+                const { product, env, vector } = options, updateOptions = __rest(options, ["product", "env", "vector"]);
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.update(updateOptions);
+            },
+            /**
+             * Update vector metadata.
+             * @param {object} options - Update metadata options.
+             * @returns {Promise<IUpdateVectorResult>} The update result.
+             */
+            updateMetadata: async (options) => {
+                const { product, env, vector, id, metadata, merge, namespace } = options;
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.updateMetadata(id, metadata, { merge, namespace });
+            },
+            /**
+             * Delete vectors by IDs (convenience method).
+             * @param {object} options - Delete by IDs options.
+             * @returns {Promise<IDeleteVectorsResult>} The delete result.
+             */
+            deleteByIds: async (options) => {
+                const { product, env, vector, ids, namespace } = options;
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.deleteByIds(ids, namespace);
+            },
+            /**
+             * Delete all vectors in a namespace.
+             * @param {object} options - Delete all options.
+             * @returns {Promise<IDeleteVectorsResult>} The delete result.
+             */
+            deleteAll: async (options) => {
+                const { product, env, vector, namespace } = options;
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.deleteAll(namespace);
+            },
+            /**
+             * List vector IDs.
+             * @param {object} options - List options.
+             * @returns {Promise<IListVectorsResult>} The list result.
+             */
+            listVectors: async (options) => {
+                const { product, env, vector } = options, listOptions = __rest(options, ["product", "env", "vector"]);
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.list(listOptions);
+            },
+            /**
+             * List all vector IDs (paginated).
+             * @param {object} options - List all options.
+             * @returns {Promise<string[]>} All vector IDs.
+             */
+            listAllVectors: async (options) => {
+                const { product, env, vector, namespace, prefix } = options;
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.listAll({ namespace, prefix });
+            },
+            // ==================== NAMESPACE OPERATIONS ====================
+            /**
+             * List available namespaces.
+             * @param {object} options - Namespace list options.
+             * @returns {Promise<IListNamespacesResult>} The namespaces.
+             */
+            listNamespaces: async (options) => {
+                const { product, env, vector } = options;
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.listNamespaces();
+            },
+            /**
+             * Delete a namespace.
+             * @param {object} options - Namespace delete options.
+             * @returns {Promise<void>} Resolves when deleted.
+             */
+            deleteNamespace: async (options) => {
+                const { product, env, vector, namespace } = options;
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.deleteNamespace(namespace);
+            },
+            // ==================== INDEX OPERATIONS ====================
+            /**
+             * Describe the current index.
+             * @param {object} options - Index describe options.
+             * @returns {Promise<IVectorIndexInfo>} The index info.
+             */
+            describeIndex: async (options) => {
+                const { product, env, vector } = options;
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.describeIndex();
+            },
+            /**
+             * Get index statistics.
+             * @param {object} options - Stats options.
+             * @returns {Promise<IVectorIndexStats>} The index stats.
+             */
+            getStats: async (options) => {
+                const { product, env, vector } = options;
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.getStats();
+            },
+            /**
+             * Create a new index.
+             * @param {object} options - Create index options.
+             * @returns {Promise<ICreateIndexResult>} The create result.
+             */
+            createIndex: async (options) => {
+                const { product, env, vector } = options, createOptions = __rest(options, ["product", "env", "vector"]);
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.createIndex(createOptions);
+            },
+            /**
+             * Delete an index.
+             * @param {object} options - Delete index options.
+             * @returns {Promise<IDeleteIndexResult>} The delete result.
+             */
+            deleteIndex: async (options) => {
+                const { product, env, vector, name } = options;
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.deleteIndex({ name });
+            },
+            /**
+             * List all indexes.
+             * @param {object} options - List indexes options.
+             * @returns {Promise<IVectorIndexInfo[]>} The list of indexes.
+             */
+            listIndexes: async (options) => {
+                const { product, env, vector } = options;
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.listIndexes();
+            },
+            // ==================== UTILITY METHODS ====================
+            /**
+             * Count vectors in the index.
+             * @param {object} options - Count options.
+             * @returns {Promise<number>} The vector count.
+             */
+            count: async (options) => {
+                const { product, env, vector, namespace } = options;
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.count(namespace);
+            },
+            /**
+             * Check if a vector exists.
+             * @param {object} options - Exists check options.
+             * @returns {Promise<boolean>} True if exists.
+             */
+            exists: async (options) => {
+                const { product, env, vector, id, namespace } = options;
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.exists(id, namespace);
+            },
+            /**
+             * Test connection to a vector database.
+             * @param {object} options - Test connection options.
+             * @returns {Promise<boolean>} True if connection is healthy.
+             */
+            testConnection: async (options) => {
+                const { product, env, vector } = options;
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.testConnection();
+            },
+            /**
+             * Check if a feature is supported.
+             * @param {object} options - Feature check options.
+             * @returns {Promise<boolean>} True if supported.
+             */
+            supportsFeature: async (options) => {
+                const { product, env, vector, feature } = options;
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.supportsFeature(feature);
+            },
+            /**
+             * Get all supported features.
+             * @param {object} options - Get features options.
+             * @returns {Promise<VectorFeature[]>} The supported features.
+             */
+            getSupportedFeatures: async (options) => {
+                const { product, env, vector } = options;
+                const vectorService = await this.createNewVectorService();
+                const service = await vectorService.connect({ product, env, vector });
+                return service.getSupportedFeatures();
+            },
         };
         /**
          * Job-related operations for managing product jobs.
@@ -2988,7 +3356,7 @@ class Ductape {
              * const secrets = await ductape.secrets.fetchAll();
              * secrets.forEach(s => console.log(s.key, s.description));
              */
-            fetchAll: async () => {
+            list: async () => {
                 const service = await this.createNewSecretsService();
                 return service.fetchAll();
             },
@@ -3105,9 +3473,10 @@ class Ductape {
              * @param {IProductCache} data - The cache data.
              * @returns {Promise<void>} Resolves when the cache is created. Throws on error.
              */
-            create: async (product, data) => {
+            create: async (data) => {
+                const { product } = data, config = __rest(data, ["product"]);
                 const builder = await this.getProductBuilder(product);
-                return builder.createCache(data);
+                return builder.createCache(config);
             },
             /**
              * Fetches all caches for a product.
@@ -3856,6 +4225,7 @@ class Ductape {
              * @returns {Promise<any>} The fetched log data.
              */
             fetch: async (params) => {
+                var _a, _b;
                 if (!this.loggerService) {
                     throw new Error('Logger service not initialized. Call logs.init() first');
                 }
@@ -3863,15 +4233,16 @@ class Ductape {
                     return await this.loggerService.fetch(params);
                 }
                 catch (e) {
-                    const error = e.response ? e.response.data.errors : e.toString();
-                    throw error;
+                    const error = ((_b = (_a = e.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.errors) || e.message || 'Unknown error';
+                    throw new Error(error);
                 }
             },
             publish: async () => { },
         };
-        this.workspace_id = workspace_id;
-        this.private_key = private_key;
-        this.user_id = user_id;
+        if (typeof window !== 'undefined') {
+            throw new Error('Ductape SDK can only be initialized in a server environment.');
+        }
+        this.accessKey = accessKey;
         this.environment = env_type || index_types_1.EnvType.PRODUCTION;
         this.userApi = new userApi_service_1.UserApiService(this.environment);
         this.appApi = new appApi_service_1.AppApiService(this.environment);
@@ -3880,7 +4251,7 @@ class Ductape {
         this.redis_url = redis_url;
         // Services are lazily initialized via factory methods (createNewDatabaseService, etc.)
         // This ensures initUserAuth() is called before service creation
-        return (0, utils_1.createDeepProxy)(this, this.environment);
+        //return createDeepProxy(this, this.environment);
     }
     async loadBullMQ() {
         if (typeof window !== 'undefined') {
@@ -4069,6 +4440,8 @@ class Ductape {
     async getProductBuilder(product) {
         if (!this.token)
             await this.initUserAuth();
+        // Ensure secrets service is initialized for operations that may need it
+        await this.createNewSecretsService();
         let builder = this.productBuilders.get(product);
         if (!builder) {
             builder = await this.createNewProductBuilder();
@@ -4099,6 +4472,7 @@ class Ductape {
         return this.createNewAppBuilder();
     }
     async initUserAuth(subCheck = true) {
+        var _a, _b;
         // Skip if already authenticated with valid credentials
         if (this.token && this.public_key) {
             return;
@@ -4115,11 +4489,27 @@ class Ductape {
             }
         }
         try {
-            await this.validateWorkspace(subCheck);
+            //await this.validateWorkspace(subCheck);
+            // Fetch private key using the dedicated endpoint for secrets encryption
+            // This is more secure as it doesn't expose the full workspace data
+            if (!this._privateKey) {
+                try {
+                    this._privateKey = await this.workspaceApi.fetchPrivateKey({
+                        token: this.token,
+                        public_key: this.public_key,
+                        user_id: this.user_id,
+                        workspace_id: this.workspace_id,
+                    }, this.accessKey);
+                }
+                catch (e) {
+                    // Don't throw - private key is only needed for secrets encryption
+                }
+            }
         }
         catch (e) {
-            const error = e.response ? e.response.data.errors : e.toString();
-            throw error;
+            const error = ((_b = (_a = e.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.errors) || e.message || 'Unknown error';
+            console.log("Errr", e);
+            throw new Error(error);
         }
     }
     createNewLogger(product_id, app_id) {
@@ -4142,6 +4532,7 @@ class Ductape {
             user_id: this.user_id,
             token: this.token,
             env_type: this.environment,
+            access_key: this.accessKey,
         });
     }
     async createNewProcessor() {
@@ -4155,6 +4546,8 @@ class Ductape {
             env_type: this.environment,
             redis_client: this.redisClient,
             queues: { health: this.healthCheckQueue, jobs: this.jobsQueue },
+            access_key: this.accessKey,
+            private_key: this._privateKey,
         });
     }
     async createNewImporter() {
@@ -4166,6 +4559,7 @@ class Ductape {
             user_id: this.user_id,
             token: this.token,
             env_type: this.environment,
+            access_key: this.accessKey,
         });
     }
     async createNewAppBuilder() {
@@ -4177,6 +4571,7 @@ class Ductape {
             user_id: this.user_id,
             token: this.token,
             env_type: this.environment,
+            access_key: this.accessKey,
         });
     }
     /**
@@ -4185,7 +4580,11 @@ class Ductape {
      */
     async createNewDatabaseService() {
         const subCheck = false;
-        await this.initUserAuth(subCheck);
+        if (!this.token || !this.public_key) {
+            await this.initUserAuth(subCheck);
+        }
+        // Ensure secrets service is initialized for automatic secret storage
+        await this.createNewSecretsService();
         // Return cached instance if available, otherwise create new
         if (!this._databaseService) {
             this._databaseService = new database_1.DatabaseService({
@@ -4194,6 +4593,8 @@ class Ductape {
                 user_id: this.user_id,
                 token: this.token,
                 env_type: this.environment,
+                private_key: this._privateKey,
+                access_key: this.accessKey,
             });
         }
         return this._databaseService;
@@ -4205,6 +4606,8 @@ class Ductape {
     async createNewGraphService() {
         const subCheck = false;
         await this.initUserAuth(subCheck);
+        // Ensure secrets service is initialized for secret storage/resolution
+        await this.createNewSecretsService();
         if (!this._graphService) {
             this._graphService = new graph_1.GraphService({
                 workspace_id: this.workspace_id,
@@ -4212,6 +4615,8 @@ class Ductape {
                 user_id: this.user_id,
                 token: this.token,
                 env_type: this.environment,
+                private_key: this._privateKey,
+                access_key: this.accessKey,
             });
         }
         return this._graphService;
@@ -4230,6 +4635,8 @@ class Ductape {
                 user_id: this.user_id,
                 token: this.token,
                 env_type: this.environment,
+                private_key: this._privateKey,
+                access_key: this.accessKey,
             });
         }
         return this._workflowService;
@@ -4248,6 +4655,9 @@ class Ductape {
                 user_id: this.user_id,
                 token: this.token,
                 env_type: this.environment,
+                redis_client: this.redisClient,
+                private_key: this._privateKey,
+                access_key: this.accessKey,
             });
         }
         return this._agentsService;
@@ -4275,6 +4685,8 @@ class Ductape {
     async createNewVectorService() {
         const subCheck = false;
         await this.initUserAuth(subCheck);
+        // Ensure secrets service is initialized for secret storage/resolution
+        await this.createNewSecretsService();
         if (!this._vectorService) {
             this._vectorService = new vector_1.VectorDatabaseService({
                 workspace_id: this.workspace_id,
@@ -4282,6 +4694,8 @@ class Ductape {
                 user_id: this.user_id,
                 token: this.token,
                 env_type: this.environment,
+                private_key: this._privateKey,
+                access_key: this.accessKey,
             });
         }
         return this._vectorService;
@@ -4328,7 +4742,25 @@ class Ductape {
     }
     async createNewSecretsService() {
         const subCheck = false;
-        await this.initUserAuth(subCheck);
+        if (!this.token || !this.public_key) {
+            await this.initUserAuth(subCheck);
+        }
+        // Private key is now fetched during initUserAuth() using the dedicated /private-key endpoint
+        // If for some reason it's not cached, fetch it now
+        if (!this._privateKey) {
+            console.warn('[Secrets] Private key not cached, fetching now...');
+            try {
+                this._privateKey = await this.workspaceApi.fetchPrivateKey({
+                    token: this.token,
+                    public_key: this.public_key,
+                    user_id: this.user_id,
+                    workspace_id: this.workspace_id,
+                }, this.accessKey);
+            }
+            catch (e) {
+                console.error('[Secrets] Failed to fetch private key:', e);
+            }
+        }
         if (!this._secretsService) {
             this._secretsService = new secrets_1.SecretsService({
                 environment: this.environment,
@@ -4337,7 +4769,10 @@ class Ductape {
                     public_key: this.public_key,
                     user_id: this.user_id,
                     workspace_id: this.workspace_id,
+                    access_key: this.accessKey,
+                    private_key: this._privateKey,
                 }),
+                getPrivateKey: () => this._privateKey,
             });
             // Set the global instance for use by other services (e.g., database, storage)
             (0, secrets_1.setSecretsService)(this._secretsService);
@@ -4372,6 +4807,7 @@ class Ductape {
             user_id: this.user_id,
             token: this.token,
             env_type: this.environment,
+            private_key: this._privateKey,
         });
     }
     /**
@@ -4405,6 +4841,7 @@ class Ductape {
                 env_type: this.environment,
                 redis_client: this.redisClient,
                 queues: { health: this.healthCheckQueue, jobs: this.jobsQueue },
+                private_key: this._privateKey,
             });
         }
         return this._quotaService;
@@ -4425,6 +4862,7 @@ class Ductape {
                 env_type: this.environment,
                 redis_client: this.redisClient,
                 queues: { health: this.healthCheckQueue, jobs: this.jobsQueue },
+                private_key: this._privateKey,
             });
         }
         return this._fallbackService;
@@ -4445,16 +4883,18 @@ class Ductape {
                 env_type: this.environment,
                 redis_client: this.redisClient,
                 queues: { health: this.healthCheckQueue, jobs: this.jobsQueue },
+                private_key: this._privateKey,
+                access_key: this.accessKey,
             });
         }
         return this._healthcheckService;
     }
     async fetchSession() {
         try {
-            if (!this.public_key && this.private_key)
+            if (!this.public_key && this.accessKey)
                 await this.refreshUserAccessToken();
-            if (!this.public_key && !this.private_key)
-                throw new Error('No user private/public keys');
+            if (!this.public_key && !this.accessKey)
+                throw new Error('No accessKey provided');
             this.session = await this.appApi.fetchAppBuilderSession({
                 public_key: this.public_key,
                 user_id: this.user_id,
@@ -4469,6 +4909,7 @@ class Ductape {
         }
     }
     async validateWorkspace(subCheck = true) {
+        var _a, _b;
         try {
             const workspace = await this.workspaceApi.fetchWorkspaceById({
                 token: this.token,
@@ -4480,11 +4921,29 @@ class Ductape {
                 throw new Error(`Workspace does not exist`);
         }
         catch (e) {
-            const error = e.response ? e.response.data.errors : e.toString();
-            throw error;
+            // Safely extract error message
+            let error;
+            if ((_b = (_a = e.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.errors) {
+                if (typeof e.response.data.errors === 'string') {
+                    error = e.response.data.errors;
+                }
+                else {
+                    try {
+                        error = JSON.stringify(e.response.data.errors);
+                    }
+                    catch (_c) {
+                        error = 'Error parsing response';
+                    }
+                }
+            }
+            else {
+                error = e.message || 'Unknown error';
+            }
+            throw new Error(error);
         }
     }
     async createNewAppBuilderSession() {
+        var _a, _b;
         try {
             this.session = await this.appApi.createAppBuilderSession({
                 token: this.token,
@@ -4494,26 +4953,28 @@ class Ductape {
             });
         }
         catch (e) {
-            const error = e.response ? e.response.data.errors : e.toString();
-            throw error;
+            const error = ((_b = (_a = e.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.errors) || e.message || 'Unknown error';
+            throw new Error(error);
         }
     }
     async refreshUserAccessToken() {
+        var _a, _b;
         try {
             const validUser = await this.userApi.fetchUserByPrivateKey({
-                private_key: this.private_key,
-                workspace_id: this.workspace_id,
-                user_id: this.user_id,
+                accessKey: this.accessKey,
             });
             this.token = validUser.auth_token;
             this.public_key = validUser.public_key;
+            this.user_id = validUser.user_id;
+            this.workspace_id = validUser.workspace_id;
         }
         catch (e) {
-            const error = e.response ? e.response.data.errors : e.toString();
-            throw error;
+            const error = ((_b = (_a = e.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.errors) || e.message || 'Unknown error';
+            throw new Error(error);
         }
     }
     async fetchWorkspaceApps(status) {
+        var _a, _b;
         try {
             if (!this.public_key || !this.token)
                 throw new Error('User session not initiated');
@@ -4526,11 +4987,12 @@ class Ductape {
             return this.apps;
         }
         catch (e) {
-            const error = e.response ? e.response.data.errors : e.toString();
-            throw error;
+            const error = ((_b = (_a = e.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.errors) || e.message || 'Unknown error';
+            throw new Error(error);
         }
     }
     async fetchWorkspaceProjects(status) {
+        var _a, _b;
         try {
             if (!this.public_key || !this.token)
                 throw new Error('User session not initiated');
@@ -4543,8 +5005,8 @@ class Ductape {
             return this.products;
         }
         catch (e) {
-            const error = e.response ? e.response.data.errors : e.toString();
-            throw error;
+            const error = ((_b = (_a = e.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.errors) || e.message || 'Unknown error';
+            throw new Error(error);
         }
     }
     /**