@hotmeshio/hotmesh 0.5.8 → 0.6.1

package/build/index.d.ts

@@ -16,7 +16,9 @@ import * as Enums from './modules/enums';
 import * as KeyStore from './modules/key';
 import { ConnectorService as Connector } from './services/connector/factory';
 import { PostgresConnection as ConnectorPostgres } from './services/connector/providers/postgres';
+import { RedisConnection as ConnectorIORedis } from './services/connector/providers/ioredis';
+import { RedisConnection as ConnectorRedis } from './services/connector/providers/redis';
 import { NatsConnection as ConnectorNATS } from './services/connector/providers/nats';
 export { Connector, //factory
-ConnectorNATS, ConnectorPostgres, HotMesh, HotMeshConfig, MeshCall, MemFlow, Client, Connection, proxyActivities, Search, Entity, Worker, workflow, WorkflowHandle, Enums, Errors, Utils, KeyStore, };
+ConnectorIORedis, ConnectorNATS, ConnectorPostgres, ConnectorRedis, HotMesh, HotMeshConfig, MeshCall, MemFlow, Client, Connection, proxyActivities, Search, Entity, Worker, workflow, WorkflowHandle, Enums, Errors, Utils, KeyStore, };
 export * as Types from './types';

package/build/index.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Types = exports.KeyStore = exports.Utils = exports.Errors = exports.Enums = exports.WorkflowHandle = exports.workflow = exports.Worker = exports.Entity = exports.Search = exports.proxyActivities = exports.Connection = exports.Client = exports.MemFlow = exports.MeshCall = exports.HotMesh = exports.ConnectorPostgres = exports.ConnectorNATS = exports.Connector = void 0;
+exports.Types = exports.KeyStore = exports.Utils = exports.Errors = exports.Enums = exports.WorkflowHandle = exports.workflow = exports.Worker = exports.Entity = exports.Search = exports.proxyActivities = exports.Connection = exports.Client = exports.MemFlow = exports.MeshCall = exports.HotMesh = exports.ConnectorRedis = exports.ConnectorPostgres = exports.ConnectorNATS = exports.ConnectorIORedis = exports.Connector = void 0;
 const hotmesh_1 = require("./services/hotmesh");
 Object.defineProperty(exports, "HotMesh", { enumerable: true, get: function () { return hotmesh_1.HotMesh; } });
 const meshcall_1 = require("./services/meshcall");
@@ -58,6 +58,10 @@ const factory_1 = require("./services/connector/factory");
 Object.defineProperty(exports, "Connector", { enumerable: true, get: function () { return factory_1.ConnectorService; } });
 const postgres_1 = require("./services/connector/providers/postgres");
 Object.defineProperty(exports, "ConnectorPostgres", { enumerable: true, get: function () { return postgres_1.PostgresConnection; } });
+const ioredis_1 = require("./services/connector/providers/ioredis");
+Object.defineProperty(exports, "ConnectorIORedis", { enumerable: true, get: function () { return ioredis_1.RedisConnection; } });
+const redis_1 = require("./services/connector/providers/redis");
+Object.defineProperty(exports, "ConnectorRedis", { enumerable: true, get: function () { return redis_1.RedisConnection; } });
 const nats_1 = require("./services/connector/providers/nats");
 Object.defineProperty(exports, "ConnectorNATS", { enumerable: true, get: function () { return nats_1.NatsConnection; } });
 exports.Types = __importStar(require("./types"));

package/build/modules/enums.d.ts

@@ -11,6 +11,10 @@ export declare const HMSH_TELEMETRY: "debug" | "info";
  * Default cleanup time for signal in the db when its associated job is completed.
  */
 export declare const HMSH_SIGNAL_EXPIRE = 3600;
+/**
+ * Determines if the system is running in cluster mode (for Redis cluster support).
+ */
+export declare const HMSH_IS_CLUSTER: boolean;
 export declare const HMSH_CODE_SUCCESS = 200;
 export declare const HMSH_CODE_PENDING = 202;
 export declare const HMSH_CODE_NOTFOUND = 404;
@@ -107,3 +111,16 @@ export declare const HMSH_GUID_SIZE: number;
  * Default task queue name used when no task queue is specified
  */
 export declare const DEFAULT_TASK_QUEUE = "default";
+/**
+ * PostgreSQL NOTIFY payload limit. If a job message exceeds this size,
+ * a reference message is sent instead and the subscriber fetches via getState.
+ * PostgreSQL hard limit is 8000 bytes; default 7500 provides safety margin.
+ */
+export declare const HMSH_NOTIFY_PAYLOAD_LIMIT: number;
+/**
+ * Serializer compression threshold. When a stringified object exceeds this size
+ * in bytes, it will be gzipped and base64 encoded (with /b prefix) to reduce
+ * Redis hash storage size. Default 100 bytes - small enough to catch most
+ * workflow state but compression only applies if it actually reduces size.
+ */
+export declare const HMSH_SERIALIZER_COMPRESSION_THRESHOLD: number;

package/build/modules/enums.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_TASK_QUEUE = exports.HMSH_GUID_SIZE = exports.HMSH_SCOUT_INTERVAL_SECONDS = exports.HMSH_FIDELITY_SECONDS = exports.HMSH_EXPIRE_DURATION = exports.HMSH_XPENDING_COUNT = exports.HMSH_XCLAIM_COUNT = exports.HMSH_XCLAIM_DELAY_MS = exports.HMSH_BLOCK_TIME_MS = exports.HMSH_MEMFLOW_EXP_BACKOFF = exports.HMSH_MEMFLOW_MAX_INTERVAL = exports.HMSH_MEMFLOW_MAX_ATTEMPTS = exports.HMSH_GRADUATED_INTERVAL_MS = exports.HMSH_MAX_TIMEOUT_MS = exports.HMSH_MAX_RETRIES = exports.MAX_DELAY = exports.MAX_STREAM_RETRIES = exports.INITIAL_STREAM_BACKOFF = exports.MAX_STREAM_BACKOFF = exports.HMSH_EXPIRE_JOB_SECONDS = exports.HMSH_OTT_WAIT_TIME = exports.HMSH_DEPLOYMENT_PAUSE = exports.HMSH_DEPLOYMENT_DELAY = exports.HMSH_ACTIVATION_MAX_RETRY = exports.HMSH_QUORUM_DELAY_MS = exports.HMSH_QUORUM_ROLLCALL_CYCLES = exports.HMSH_STATUS_UNKNOWN = exports.HMSH_CODE_MEMFLOW_RETRYABLE = exports.HMSH_CODE_MEMFLOW_FATAL = exports.HMSH_CODE_MEMFLOW_MAXED = exports.HMSH_CODE_MEMFLOW_TIMEOUT = exports.HMSH_CODE_MEMFLOW_WAIT = exports.HMSH_CODE_MEMFLOW_PROXY = exports.HMSH_CODE_MEMFLOW_CHILD = exports.HMSH_CODE_MEMFLOW_ALL = exports.HMSH_CODE_MEMFLOW_SLEEP = exports.HMSH_CODE_UNACKED = exports.HMSH_CODE_TIMEOUT = exports.HMSH_CODE_UNKNOWN = exports.HMSH_CODE_INTERRUPT = exports.HMSH_CODE_NOTFOUND = exports.HMSH_CODE_PENDING = exports.HMSH_CODE_SUCCESS = exports.HMSH_SIGNAL_EXPIRE = exports.HMSH_TELEMETRY = exports.HMSH_LOGLEVEL = void 0;
+exports.HMSH_SERIALIZER_COMPRESSION_THRESHOLD = exports.HMSH_NOTIFY_PAYLOAD_LIMIT = exports.DEFAULT_TASK_QUEUE = exports.HMSH_GUID_SIZE = exports.HMSH_SCOUT_INTERVAL_SECONDS = exports.HMSH_FIDELITY_SECONDS = exports.HMSH_EXPIRE_DURATION = exports.HMSH_XPENDING_COUNT = exports.HMSH_XCLAIM_COUNT = exports.HMSH_XCLAIM_DELAY_MS = exports.HMSH_BLOCK_TIME_MS = exports.HMSH_MEMFLOW_EXP_BACKOFF = exports.HMSH_MEMFLOW_MAX_INTERVAL = exports.HMSH_MEMFLOW_MAX_ATTEMPTS = exports.HMSH_GRADUATED_INTERVAL_MS = exports.HMSH_MAX_TIMEOUT_MS = exports.HMSH_MAX_RETRIES = exports.MAX_DELAY = exports.MAX_STREAM_RETRIES = exports.INITIAL_STREAM_BACKOFF = exports.MAX_STREAM_BACKOFF = exports.HMSH_EXPIRE_JOB_SECONDS = exports.HMSH_OTT_WAIT_TIME = exports.HMSH_DEPLOYMENT_PAUSE = exports.HMSH_DEPLOYMENT_DELAY = exports.HMSH_ACTIVATION_MAX_RETRY = exports.HMSH_QUORUM_DELAY_MS = exports.HMSH_QUORUM_ROLLCALL_CYCLES = exports.HMSH_STATUS_UNKNOWN = exports.HMSH_CODE_MEMFLOW_RETRYABLE = exports.HMSH_CODE_MEMFLOW_FATAL = exports.HMSH_CODE_MEMFLOW_MAXED = exports.HMSH_CODE_MEMFLOW_TIMEOUT = exports.HMSH_CODE_MEMFLOW_WAIT = exports.HMSH_CODE_MEMFLOW_PROXY = exports.HMSH_CODE_MEMFLOW_CHILD = exports.HMSH_CODE_MEMFLOW_ALL = exports.HMSH_CODE_MEMFLOW_SLEEP = exports.HMSH_CODE_UNACKED = exports.HMSH_CODE_TIMEOUT = exports.HMSH_CODE_UNKNOWN = exports.HMSH_CODE_INTERRUPT = exports.HMSH_CODE_NOTFOUND = exports.HMSH_CODE_PENDING = exports.HMSH_CODE_SUCCESS = exports.HMSH_IS_CLUSTER = exports.HMSH_SIGNAL_EXPIRE = exports.HMSH_TELEMETRY = exports.HMSH_LOGLEVEL = void 0;
 /**
  * Determines the log level for the application. The default is 'info'.
  */
@@ -13,6 +13,10 @@ exports.HMSH_TELEMETRY = process.env.HMSH_TELEMETRY || 'info';
  * Default cleanup time for signal in the db when its associated job is completed.
  */
 exports.HMSH_SIGNAL_EXPIRE = 3600; //seconds
+/**
+ * Determines if the system is running in cluster mode (for Redis cluster support).
+ */
+exports.HMSH_IS_CLUSTER = process.env.HMSH_IS_CLUSTER === 'true';
 // HOTMESH STATUS CODES
 exports.HMSH_CODE_SUCCESS = 200;
 exports.HMSH_CODE_PENDING = 202;
@@ -131,3 +135,16 @@ exports.HMSH_GUID_SIZE = Math.min(parseInt(process.env.HMSH_GUID_SIZE, 10) || 22
  * Default task queue name used when no task queue is specified
  */
 exports.DEFAULT_TASK_QUEUE = 'default';
+/**
+ * PostgreSQL NOTIFY payload limit. If a job message exceeds this size,
+ * a reference message is sent instead and the subscriber fetches via getState.
+ * PostgreSQL hard limit is 8000 bytes; default 7500 provides safety margin.
+ */
+exports.HMSH_NOTIFY_PAYLOAD_LIMIT = parseInt(process.env.HMSH_NOTIFY_PAYLOAD_LIMIT, 10) || 7500;
+/**
+ * Serializer compression threshold. When a stringified object exceeds this size
+ * in bytes, it will be gzipped and base64 encoded (with /b prefix) to reduce
+ * Redis hash storage size. Default 100 bytes - small enough to catch most
+ * workflow state but compression only applies if it actually reduces size.
+ */
+exports.HMSH_SERIALIZER_COMPRESSION_THRESHOLD = parseInt(process.env.HMSH_SERIALIZER_COMPRESSION_THRESHOLD, 10) || 100000000;

package/build/modules/utils.js

@@ -79,11 +79,38 @@ function identifyProvider(provider) {
     else if (provider.toString().toLowerCase().includes('nats')) {
         return 'nats';
     }
+    else if ('defineCommand' in prototype ||
+        Object.keys(prototype).includes('multi')) {
+        return 'ioredis';
+    }
+    else if (Object.keys(prototype).includes('Multi')) {
+        return 'redis';
+    }
+    if (provider.constructor) {
+        if (provider.constructor.name === 'Redis' ||
+            provider.constructor.name === 'EventEmitter') {
+            if ('hset' in provider) {
+                return 'ioredis';
+            }
+        }
+        else if (provider.constructor.name === 'ProviderClient' ||
+            provider.constructor.name === 'Commander') {
+            if ('HSET' in provider) {
+                return 'redis';
+            }
+        }
+    }
     let type = null;
     if (Object.keys(provider).includes('connection') ||
         !isNaN(provider.totalCount) && !isNaN(provider.idleCount)) {
         type = 'postgres';
     }
+    else if (Object.keys(provider).includes('Pipeline')) {
+        type = 'ioredis';
+    }
+    else if (Object.keys(provider).includes('createClient')) {
+        type = 'redis';
+    }
     else if (prototype.constructor.toString().includes('NatsConnectionImpl')) {
         type = 'nats';
     }

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.5.8",
+    "version": "0.6.1",
     "description": "Permanent-Memory Workflows & AI Agents",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -23,9 +23,11 @@
         "test:await": "NODE_ENV=test jest ./tests/functional/awaiter/postgres.test.ts --detectOpenHandles --forceExit --verbose",
         "test:compile": "NODE_ENV=test jest ./tests/functional/compile/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:connect": "NODE_ENV=test jest ./tests/unit/services/connector/* --detectOpenHandles --forceExit --verbose",
+        "test:connect:ioredis": "NODE_ENV=test jest ./tests/unit/services/connector/providers/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
         "test:connect:postgres": "NODE_ENV=test jest ./tests/unit/services/connector/providers/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:connect:redis": "NODE_ENV=test jest ./tests/unit/services/connector/providers/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
         "test:connect:nats": "NODE_ENV=test jest ./tests/unit/services/connector/providers/nats.test.ts --detectOpenHandles --forceExit --verbose",
-        "test:memflow": "NODE_ENV=test jest ./tests/memflow/*/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:memflow": "NODE_ENV=test jest ./tests/memflow/*/*.test.ts --detectOpenHandles --forceExit --verbose",
         "test:memflow:basic": "HMSH_LOGLEVEL=info NODE_ENV=test jest ./tests/memflow/basic/postgres.test.ts --detectOpenHandles --forceExit --verbose",
         "test:memflow:collision": "NODE_ENV=test jest ./tests/memflow/collision/*.test.ts --detectOpenHandles --forceExit --verbose",
         "test:memflow:fatal": "NODE_ENV=test jest ./tests/memflow/fatal/*.test.ts --detectOpenHandles --forceExit --verbose",
@@ -62,9 +64,15 @@
         "test:signal": "NODE_ENV=test jest ./tests/functional/signal/*.test.ts --detectOpenHandles --forceExit --verbose",
         "test:status": "NODE_ENV=test jest ./tests/functional/status/index.test.ts --detectOpenHandles --forceExit --verbose",
         "test:providers": "NODE_ENV=test jest ./tests/functional/*/providers/*/*.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:store:ioredis": "NODE_ENV=test jest ./tests/functional/store/providers/redis/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:store:redis": "NODE_ENV=test jest ./tests/functional/store/providers/redis/redis.test.ts --detectOpenHandles --forceExit --verbose",
         "test:store:postgres": "NODE_ENV=test jest ./tests/functional/store/providers/postgres/postgres.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:stream:ioredis": "NODE_ENV=test jest ./tests/functional/stream/providers/redis/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:stream:redis": "NODE_ENV=test jest ./tests/functional/stream/providers/redis/redis.test.ts --detectOpenHandles --forceExit --verbose",
         "test:stream:postgres": "NODE_ENV=test jest ./tests/functional/stream/providers/postgres/postgres.test.ts --detectOpenHandles --forceExit --verbose",
         "test:stream:nats": "NODE_ENV=test jest ./tests/functional/stream/providers/nats/nats.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:sub:ioredis": "NODE_ENV=test jest ./tests/functional/sub/providers/redis/ioredis.test.ts --detectOpenHandles --forceExit --verbose",
+        "test:sub:redis": "NODE_ENV=test jest ./tests/functional/sub/providers/redis/redis.test.ts --detectOpenHandles --forceExit --verbose",
         "test:sub:postgres": "NODE_ENV=test jest ./tests/functional/sub/providers/postgres/postgres.test.ts --detectOpenHandles --forceExit --verbose",
         "test:sub:nats": "NODE_ENV=test jest ./tests/functional/sub/providers/nats/nats.test.ts --detectOpenHandles --forceExit --verbose",
         "test:trigger": "NODE_ENV=test jest ./tests/unit/services/activities/trigger.test.ts --detectOpenHandles --forceExit --verbose",
@@ -106,11 +114,13 @@
         "eslint-config-prettier": "^9.1.0",
         "eslint-plugin-import": "^2.29.1",
         "eslint-plugin-prettier": "^5.1.3",
+        "ioredis": "^5.3.2",
         "javascript-obfuscator": "^0.6.2",
         "jest": "^29.5.0",
         "nats": "^2.28.0",
         "openai": "^5.9.0",
         "pg": "^8.10.0",
+        "redis": "^4.6.13",
         "rimraf": "^4.4.1",
         "terser": "^5.37.0",
         "ts-jest": "^29.0.5",
@@ -120,7 +130,9 @@
         "typescript": "^5.0.4"
     },
     "peerDependencies": {
+        "ioredis": "^4.0.0 || ^5.0.0",
         "nats": "^2.0.0",
-        "pg": "^8.0.0"
+        "pg": "^8.0.0",
+        "redis": "^4.0.0"
     }
 }

package/build/services/connector/factory.d.ts

@@ -3,7 +3,7 @@ import { ProviderConfig, ProviderNativeClient } from '../../types/provider';
 export declare class ConnectorService {
     static disconnectAll(): Promise<void>;
     /**
-     * Connect to a provider (postgres, nats) and return the native
+     * Connect to a provider (redis, nats, postgres) and return the native
      * client. Connections are handled by the engine and worker routers at
      * initialization, but the factory method provided here is useful
      * for testing provider configurations.

package/build/services/connector/factory.js

@@ -2,15 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectorService = void 0;
 const utils_1 = require("../../modules/utils");
+const ioredis_1 = require("./providers/ioredis");
 const nats_1 = require("./providers/nats");
 const postgres_1 = require("./providers/postgres");
+const redis_1 = require("./providers/redis");
 class ConnectorService {
     static async disconnectAll() {
+        await redis_1.RedisConnection.disconnectAll();
+        await ioredis_1.RedisConnection.disconnectAll();
         await postgres_1.PostgresConnection.disconnectAll();
         await nats_1.NatsConnection.disconnectAll();
     }
     /**
-     * Connect to a provider (postgres, nats) and return the native
+     * Connect to a provider (redis, nats, postgres) and return the native
      * client. Connections are handled by the engine and worker routers at
      * initialization, but the factory method provided here is useful
      * for testing provider configurations.
@@ -69,10 +73,20 @@ class ConnectorService {
         const providerClass = ProviderConfig.class;
         const options = ProviderConfig.options;
         const providerName = ProviderConfig.provider || (0, utils_1.identifyProvider)(providerClass); //e.g. 'postgres.poolclient'
+        if (!providerName) {
+            throw new Error(`Unable to identify provider type. Please explicitly set the 'provider' field in your connection config. ` +
+                `Received class: ${providerClass?.constructor?.name || 'unknown'}`);
+        }
         const providerType = providerName.split('.')[0]; //e.g. 'postgres'
         let clientInstance;
         const id = (0, utils_1.guid)();
         switch (providerType) {
+            case 'redis':
+                clientInstance = await redis_1.RedisConnection.connect(id, providerClass, options, { provider: providerName });
+                break;
+            case 'ioredis':
+                clientInstance = await ioredis_1.RedisConnection.connect(id, providerClass, options, { provider: providerName });
+                break;
             case 'nats':
                 clientInstance = await nats_1.NatsConnection.connect(id, providerClass, options, { provider: providerName });
                 break;

package/build/services/connector/providers/ioredis.d.ts

@@ -0,0 +1,9 @@
+import { AbstractConnection } from '..';
+import { IORedisClientOptions as RedisClientOptions, IORedisClassType as RedisClassType, IORedisClientType as RedisClientType } from '../../../types/redis';
+declare class RedisConnection extends AbstractConnection<RedisClassType, RedisClientOptions> {
+    defaultOptions: RedisClientOptions;
+    createConnection(Redis: RedisClassType, options: RedisClientOptions): Promise<RedisClientType>;
+    getClient(): RedisClientType;
+    closeConnection(connection: RedisClientType): Promise<void>;
+}
+export { RedisConnection };

package/build/services/connector/providers/ioredis.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisConnection = void 0;
+const __1 = require("..");
+class RedisConnection extends __1.AbstractConnection {
+    constructor() {
+        super(...arguments);
+        this.defaultOptions = {
+            host: 'localhost',
+            port: 6379,
+        };
+    }
+    async createConnection(Redis, options) {
+        return new Redis(options);
+    }
+    getClient() {
+        if (!this.connection) {
+            throw new Error('Redis client is not connected');
+        }
+        return this.connection;
+    }
+    async closeConnection(connection) {
+        await connection.quit();
+    }
+}
+exports.RedisConnection = RedisConnection;

package/build/services/connector/providers/redis.d.ts

@@ -0,0 +1,9 @@
+import { AbstractConnection } from '..';
+import { RedisRedisClassType as RedisClassType, RedisRedisClientType as RedisClientType, RedisRedisClientOptions as RedisClientOptions } from '../../../types/redis';
+declare class RedisConnection extends AbstractConnection<RedisClassType, RedisClientOptions> {
+    defaultOptions: RedisClientOptions;
+    createConnection(Redis: Partial<RedisClassType>, options: RedisClientOptions): Promise<Partial<RedisClientType>>;
+    getClient(): RedisClientType;
+    closeConnection(connection: any): Promise<void>;
+}
+export { RedisConnection, RedisClientType };

package/build/services/connector/providers/redis.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisConnection = void 0;
+const __1 = require("..");
+class RedisConnection extends __1.AbstractConnection {
+    constructor() {
+        super(...arguments);
+        this.defaultOptions = {
+            socket: {
+                host: 'localhost',
+                port: 6379,
+                tls: false,
+            },
+        };
+    }
+    async createConnection(Redis, options) {
+        return new Promise((resolve, reject) => {
+            const client = Redis.createClient(options);
+            client.on('error', (error) => {
+                reject(error);
+            });
+            client.on('ready', () => {
+                resolve(client);
+            });
+            client.connect();
+        });
+    }
+    getClient() {
+        if (!this.connection) {
+            throw new Error('Redis client is not connected');
+        }
+        return this.connection;
+    }
+    async closeConnection(connection) {
+        await connection.quit();
+    }
+}
+exports.RedisConnection = RedisConnection;

package/build/services/engine/index.js

@@ -547,7 +547,12 @@ class EngineService {
      */
     async sub(topic, callback) {
         const subscriptionCallback = async (topic, message) => {
-            callback(message.topic, message.job);
+            let jobOutput = message.job;
+            // If _ref is true, payload was too large - fetch full job data via getState
+            if (message._ref && message.job?.metadata) {
+                jobOutput = await this.getState(message.job.metadata.tpc, message.job.metadata.jid);
+            }
+            callback(message.topic, jobOutput);
         };
         return await this.subscribe.subscribe(key_1.KeyType.QUORUM, subscriptionCallback, this.appId, topic);
     }
@@ -562,7 +567,12 @@ class EngineService {
      */
     async psub(wild, callback) {
         const subscriptionCallback = async (topic, message) => {
-            callback(message.topic, message.job);
+            let jobOutput = message.job;
+            // If _ref is true, payload was too large - fetch full job data via getState
+            if (message._ref && message.job?.metadata) {
+                jobOutput = await this.getState(message.job.metadata.tpc, message.job.metadata.jid);
+            }
+            callback(message.topic, jobOutput);
         };
         return await this.subscribe.psubscribe(key_1.KeyType.QUORUM, subscriptionCallback, this.appId, wild);
     }

package/build/services/quorum/index.js

@@ -88,7 +88,24 @@ class QuorumService {
                 self.engine.processWebHooks();
             }
             else if (message.type === 'job') {
-                self.engine.routeToSubscribers(message.topic, message.job);
+                let jobOutput = message.job;
+                // If _ref is true, payload was too large - fetch full job data via getState
+                if (message._ref && message.job?.metadata) {
+                    try {
+                        jobOutput = await self.engine.getState(message.job.metadata.tpc, message.job.metadata.jid);
+                        self.logger.debug('quorum-job-ref-resolved', {
+                            jid: message.job.metadata.jid,
+                        });
+                    }
+                    catch (err) {
+                        self.logger.error('quorum-job-ref-error', {
+                            jid: message.job.metadata.jid,
+                            error: err,
+                        });
+                        return; // Can't route without job data
+                    }
+                }
+                self.engine.routeToSubscribers(message.topic, jobOutput);
             }
             else if (message.type === 'cron') {
                 self.engine.processTimeHooks();

package/build/services/search/factory.js

@@ -3,12 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SearchServiceFactory = void 0;
 const utils_1 = require("../../modules/utils");
 const postgres_1 = require("./providers/postgres/postgres");
+const ioredis_1 = require("./providers/redis/ioredis");
+const redis_1 = require("./providers/redis/redis");
 class SearchServiceFactory {
     static async init(providerClient, storeProviderClient, namespace, appId, logger) {
         let service;
         if ((0, utils_1.identifyProvider)(providerClient) === 'postgres') {
             service = new postgres_1.PostgresSearchService(providerClient, storeProviderClient);
         }
+        else if ((0, utils_1.identifyProvider)(providerClient) === 'redis') {
+            service = new redis_1.RedisSearchService(providerClient, storeProviderClient);
+        }
+        else {
+            service = new ioredis_1.IORedisSearchService(providerClient, storeProviderClient);
+        }
         await service.init(namespace, appId, logger);
         return service;
     }

package/build/services/search/providers/redis/ioredis.d.ts

@@ -0,0 +1,23 @@
+import { SearchService } from '../../index';
+import { ILogger } from '../../../logger';
+import { IORedisClientType } from '../../../../types/redis';
+declare class IORedisSearchService extends SearchService<IORedisClientType> {
+    constructor(searchClient: IORedisClientType, storeClient?: IORedisClientType);
+    init(namespace: string, appId: string, logger: ILogger): Promise<void>;
+    createSearchIndex(indexName: string, prefixes: string[], schema: string[]): Promise<void>;
+    listSearchIndexes(): Promise<string[]>;
+    updateContext(key: string, fields: Record<string, string>): Promise<any>;
+    setFields(key: string, fields: Record<string, string>): Promise<number>;
+    getField(key: string, field: string): Promise<string>;
+    getFields(key: string, fields: string[]): Promise<string[]>;
+    getAllFields(key: string): Promise<Record<string, string>>;
+    deleteFields(key: string, fields: string[]): Promise<number>;
+    incrementFieldByFloat(key: string, field: string, increment: number): Promise<number>;
+    sendQuery(...query: [string, ...string[]]): Promise<any>;
+    sendIndexedQuery(index: string, query: string[]): Promise<string[]>;
+    findEntities(): Promise<any[]>;
+    findEntityById(): Promise<any>;
+    findEntitiesByCondition(): Promise<any[]>;
+    createEntityIndex(): Promise<void>;
+}
+export { IORedisSearchService };

package/build/services/search/providers/redis/ioredis.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IORedisSearchService = void 0;
+const index_1 = require("../../index");
+class IORedisSearchService extends index_1.SearchService {
+    constructor(searchClient, storeClient) {
+        super(searchClient, storeClient);
+    }
+    async init(namespace, appId, logger) {
+        this.namespace = namespace;
+        this.appId = appId;
+        this.logger = logger;
+    }
+    async createSearchIndex(indexName, prefixes, schema) {
+        try {
+            await this.searchClient.call('FT.CREATE', indexName, 'ON', 'HASH', 'PREFIX', prefixes.length.toString(), ...prefixes, 'SCHEMA', ...schema);
+        }
+        catch (error) {
+            this.logger.info('Error creating search index', { error });
+            throw error;
+        }
+    }
+    async listSearchIndexes() {
+        try {
+            const indexes = await this.searchClient.call('FT._LIST');
+            return indexes;
+        }
+        catch (error) {
+            this.logger.info('Error listing search indexes', { error });
+            throw error;
+        }
+    }
+    async updateContext(key, fields) {
+        // Find replay ID if present (field with hyphen, not the @udata field)
+        const replayId = Object.keys(fields).find((k) => k.includes('-') && !k.startsWith('@'));
+        // Route based on @udata operation
+        if ('@udata:set' in fields) {
+            const udata = JSON.parse(fields['@udata:set']);
+            const fieldsToSet = Array.isArray(udata)
+                ? Object.fromEntries(Array.from({ length: udata.length / 2 }, (_, i) => [
+                    udata[i * 2],
+                    udata[i * 2 + 1],
+                ]))
+                : udata;
+            const result = await this.setFields(key, fieldsToSet);
+            if (replayId)
+                await this.searchClient.hset(key, { [replayId]: String(result) });
+            return result;
+        }
+        if ('@udata:get' in fields) {
+            const result = await this.getField(key, fields['@udata:get']);
+            if (replayId)
+                await this.searchClient.hset(key, { [replayId]: result });
+            return result;
+        }
+        if ('@udata:mget' in fields) {
+            const result = await this.getFields(key, JSON.parse(fields['@udata:mget']));
+            if (replayId)
+                await this.searchClient.hset(key, { [replayId]: result.join('|||') });
+            return result;
+        }
+        if ('@udata:delete' in fields) {
+            const result = await this.deleteFields(key, JSON.parse(fields['@udata:delete']));
+            if (replayId)
+                await this.searchClient.hset(key, { [replayId]: String(result) });
+            return result;
+        }
+        if ('@udata:increment' in fields) {
+            const { field, value } = JSON.parse(fields['@udata:increment']);
+            const result = await this.incrementFieldByFloat(key, field, value);
+            if (replayId)
+                await this.searchClient.hset(key, { [replayId]: String(result) });
+            return result;
+        }
+        if ('@udata:multiply' in fields) {
+            const { field, value } = JSON.parse(fields['@udata:multiply']);
+            const result = await this.incrementFieldByFloat(key, field, Math.log(value));
+            if (replayId)
+                await this.searchClient.hset(key, { [replayId]: String(result) });
+            return result;
+        }
+        if ('@udata:all' in fields) {
+            const all = await this.getAllFields(key);
+            const result = Object.fromEntries(Object.entries(all).filter(([k]) => k.startsWith('_')));
+            if (replayId)
+                await this.searchClient.hset(key, { [replayId]: JSON.stringify(result) });
+            return result;
+        }
+        // Default: call setFields
+        return await this.setFields(key, fields);
+    }
+    async setFields(key, fields) {
+        try {
+            const result = await this.searchClient.hset(key, fields);
+            return Number(result);
+        }
+        catch (error) {
+            this.logger.error(`Error setting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async getField(key, field) {
+        try {
+            return await this.searchClient.hget(key, field);
+        }
+        catch (error) {
+            this.logger.error(`Error getting field ${field} for key: ${key}`, {
+                error,
+            });
+            throw error;
+        }
+    }
+    async getFields(key, fields) {
+        try {
+            return await this.searchClient.hmget(key, [...fields]);
+        }
+        catch (error) {
+            this.logger.error(`Error getting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async getAllFields(key) {
+        try {
+            return await this.searchClient.hgetall(key);
+        }
+        catch (error) {
+            this.logger.error(`Error getting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async deleteFields(key, fields) {
+        try {
+            const result = await this.searchClient.hdel(key, ...fields);
+            return Number(result);
+        }
+        catch (error) {
+            this.logger.error(`Error deleting fields for key: ${key}`, { error });
+            throw error;
+        }
+    }
+    async incrementFieldByFloat(key, field, increment) {
+        try {
+            const result = await this.searchClient.hincrbyfloat(key, field, increment);
+            return Number(result);
+        }
+        catch (error) {
+            this.logger.error(`Error incrementing field ${field} for key: ${key}`, {
+                error,
+            });
+            throw error;
+        }
+    }
+    async sendQuery(...query) {
+        try {
+            return await this.searchClient.call(...query);
+        }
+        catch (error) {
+            this.logger.error('Error executing query', { error });
+            throw error;
+        }
+    }
+    async sendIndexedQuery(index, query) {
+        try {
+            if (query[0]?.startsWith('FT.')) {
+                const [cmd, ...rest] = query;
+                return (await this.searchClient.call(cmd, ...rest));
+            }
+            return (await this.searchClient.call('FT.SEARCH', index, ...query));
+        }
+        catch (error) {
+            this.logger.error('Error executing query', { error });
+            throw error;
+        }
+    }
+    // Entity methods - not implemented for Redis (postgres-specific JSONB operations)
+    async findEntities() {
+        throw new Error('Entity findEntities not supported in Redis - use PostgreSQL');
+    }
+    async findEntityById() {
+        throw new Error('Entity findEntityById not supported in Redis - use PostgreSQL');
+    }
+    async findEntitiesByCondition() {
+        throw new Error('Entity findEntitiesByCondition not supported in Redis - use PostgreSQL');
+    }
+    async createEntityIndex() {
+        throw new Error('Entity createEntityIndex not supported in Redis - use PostgreSQL');
+    }
+}
+exports.IORedisSearchService = IORedisSearchService;