@olane/o-node 0.7.12-alpha.10 → 0.7.12-alpha.12

package/dist/src/interfaces/o-node.config.d.ts

@@ -39,6 +39,12 @@ export interface oNodeConfig extends oCoreConfig {
         baseDelayMs?: number;
         maxDelayMs?: number;
         timeoutMs?: number;
+        circuitBreaker?: {
+            enabled?: boolean;
+            failureThreshold?: number;
+            openTimeoutMs?: number;
+            halfOpenMaxAttempts?: number;
+        };
     };
 }
 //# sourceMappingURL=o-node.config.d.ts.map

package/dist/src/interfaces/o-node.config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-node.config.d.ts","sourceRoot":"","sources":["../../../src/interfaces/o-node.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC9C,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAC5B,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAE5B;;;OAGG;IACH,mBAAmB,CAAC,EAAE;QACpB,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB,CAAC;IAEF;;;OAGG;IACH,YAAY,CAAC,EAAE;QACb,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,yBAAyB,CAAC,EAAE,MAAM,CAAC;QACnC,yBAAyB,CAAC,EAAE,MAAM,CAAC;KACpC,CAAC;IAEF;;;OAGG;IACH,WAAW,CAAC,EAAE;QACZ,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH"}
+{"version":3,"file":"o-node.config.d.ts","sourceRoot":"","sources":["../../../src/interfaces/o-node.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC9C,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAC5B,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IAE5B;;;OAGG;IACH,mBAAmB,CAAC,EAAE;QACpB,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB,CAAC;IAEF;;;OAGG;IACH,YAAY,CAAC,EAAE;QACb,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,yBAAyB,CAAC,EAAE,MAAM,CAAC;QACnC,yBAAyB,CAAC,EAAE,MAAM,CAAC;KACpC,CAAC;IAEF;;;OAGG;IACH,WAAW,CAAC,EAAE;QACZ,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,cAAc,CAAC,EAAE;YACf,OAAO,CAAC,EAAE,OAAO,CAAC;YAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;YAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;YACvB,mBAAmB,CAAC,EAAE,MAAM,CAAC;SAC9B,CAAC;KACH,CAAC;CACH"}

package/dist/src/o-node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-node.d.ts","sourceRoot":"","sources":["../../src/o-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,MAAM,EACN,YAAY,EACb,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAIL,QAAQ,EACR,QAAQ,EAER,oBAAoB,EACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AAGnF,OAAO,EAAmB,SAAS,EAAE,MAAM,eAAe,CAAC;AAI3D,OAAO,EAAE,2BAA2B,EAAE,MAAM,8CAA8C,CAAC;AAC3F,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAEzE,qBAAa,KAAM,SAAQ,SAAS;IAC3B,MAAM,EAAG,MAAM,CAAC;IAChB,OAAO,EAAG,MAAM,CAAC;IACjB,OAAO,EAAG,YAAY,CAAC;IACvB,MAAM,EAAE,WAAW,CAAC;IACpB,iBAAiB,EAAG,sBAAsB,CAAC;IAC3C,gBAAgB,EAAG,qBAAqB,CAAC;IACzC,0BAA0B,CAAC,EAAE,2BAA2B,CAAC;IACzD,mBAAmB,CAAC,EAAE,oBAAoB,CAAC;IAC3C,oBAAoB,EAAG,oBAAoB,CAAC;IACnD,SAAS,CAAC,WAAW,EAAE,OAAO,CAAS;gBAE3B,MAAM,EAAE,WAAW;IAK/B,IAAI,MAAM,IAAI,YAAY,GAAG,IAAI,CAEhC;IAED,IAAI,aAAa,IAAI,YAAY,CAKhC;IAED,IAAI,YAAY,IAAI,MAAM,GAAG,IAAI,CAOhC;IAED,mBAAmB,IAAI,GAAG,EAAE;IAItB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IASvC,SAAS,CAAC,yBAAyB,IAAI,oBAAoB;IAQ3D,IAAI,aAAa,IAAI,YAAY,CAEhC;IAED,IAAI,gBAAgB,IAAI,cAAc,EAAE,CAEvC;IAED,IAAI,UAAU,IAAI,cAAc,EAAE,CAIjC;IAEK,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAsD3B,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IA2B/B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAwC/B,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM;IAItC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAetB,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAG1D;;;OAGG;IACG,SAAS,IAAI,OAAO,CAAC,YAAY,CAAC;cA0FxB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAMvC,OAAO,CACX,cAAc,EAAE,YAAY,EAC5B,aAAa,EAAE,YAAY,GAC1B,OAAO,CAAC,eAAe,CAAC;IA0BrB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA+FjC;;OAEG;IACG,GAAG,CACP,OAAO,EAAE,QAAQ,EACjB,IAAI,CAAC,EAAE;QACL,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE;YAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;SAAE,CAAC;QAChC,EAAE,CAAC,EAAE,MAAM,CAAC;KACb,GACA,OAAO,CAAC,GAAG,CAAC;IAST,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAYhC"}
+{"version":3,"file":"o-node.d.ts","sourceRoot":"","sources":["../../src/o-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,MAAM,EACN,YAAY,EACb,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAIL,QAAQ,EACR,QAAQ,EAER,oBAAoB,EACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AAGnF,OAAO,EAAmB,SAAS,EAAE,MAAM,eAAe,CAAC;AAI3D,OAAO,EAAE,2BAA2B,EAAE,MAAM,8CAA8C,CAAC;AAC3F,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAEzE,qBAAa,KAAM,SAAQ,SAAS;IAC3B,MAAM,EAAG,MAAM,CAAC;IAChB,OAAO,EAAG,MAAM,CAAC;IACjB,OAAO,EAAG,YAAY,CAAC;IACvB,MAAM,EAAE,WAAW,CAAC;IACpB,iBAAiB,EAAG,sBAAsB,CAAC;IAC3C,gBAAgB,EAAG,qBAAqB,CAAC;IACzC,0BAA0B,CAAC,EAAE,2BAA2B,CAAC;IACzD,mBAAmB,CAAC,EAAE,oBAAoB,CAAC;IAC3C,oBAAoB,EAAG,oBAAoB,CAAC;IACnD,SAAS,CAAC,WAAW,EAAE,OAAO,CAAS;gBAE3B,MAAM,EAAE,WAAW;IAK/B,IAAI,MAAM,IAAI,YAAY,GAAG,IAAI,CAEhC;IAED,IAAI,aAAa,IAAI,YAAY,CAKhC;IAED,IAAI,YAAY,IAAI,MAAM,GAAG,IAAI,CAOhC;IAED,mBAAmB,IAAI,GAAG,EAAE;IAItB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IASvC,SAAS,CAAC,yBAAyB,IAAI,oBAAoB;IAQ3D,IAAI,aAAa,IAAI,YAAY,CAEhC;IAED,IAAI,gBAAgB,IAAI,cAAc,EAAE,CAEvC;IAED,IAAI,UAAU,IAAI,cAAc,EAAE,CAIjC;IAEK,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAsD3B,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IA2B/B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAwC/B,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM;IAItC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAetB,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAG1D;;;OAGG;IACG,SAAS,IAAI,OAAO,CAAC,YAAY,CAAC;cA0FxB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAMvC,OAAO,CACX,cAAc,EAAE,YAAY,EAC5B,aAAa,EAAE,YAAY,GAC1B,OAAO,CAAC,eAAe,CAAC;IA0BrB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAyGjC;;OAEG;IACG,GAAG,CACP,OAAO,EAAE,QAAQ,EACjB,IAAI,CAAC,EAAE;QACL,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE;YAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;SAAE,CAAC;QAChC,EAAE,CAAC,EAAE,MAAM,CAAC;KACb,GACA,OAAO,CAAC,GAAG,CAAC;IAST,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAYhC"}

package/dist/src/o-node.js

@@ -300,16 +300,23 @@ export class oNode extends oToolBase {
         this.connectionManager = new oNodeConnectionManager({
             p2pNode: this.p2pNode,
         });
-        // Initialize leader request wrapper
+        // Initialize leader request wrapper with circuit breaker
         this.leaderRequestWrapper = new LeaderRequestWrapper({
             enabled: this.config.leaderRetry?.enabled ?? true,
             maxAttempts: this.config.leaderRetry?.maxAttempts ?? 20,
             baseDelayMs: this.config.leaderRetry?.baseDelayMs ?? 2000,
             maxDelayMs: this.config.leaderRetry?.maxDelayMs ?? 30000,
-            timeoutMs: this.config.leaderRetry?.timeoutMs ?? 10000,
+            timeoutMs: this.config.leaderRetry?.timeoutMs ?? 120000,
+            circuitBreaker: {
+                enabled: this.config.leaderRetry?.circuitBreaker?.enabled ?? true,
+                failureThreshold: this.config.leaderRetry?.circuitBreaker?.failureThreshold ?? 3,
+                openTimeoutMs: this.config.leaderRetry?.circuitBreaker?.openTimeoutMs ?? 30000,
+                halfOpenMaxAttempts: this.config.leaderRetry?.circuitBreaker?.halfOpenMaxAttempts ?? 1,
+            },
         });
         this.logger.info(`Leader retry config: enabled=${this.leaderRequestWrapper.getConfig().enabled}, ` +
-            `maxAttempts=${this.leaderRequestWrapper.getConfig().maxAttempts}`);
+            `maxAttempts=${this.leaderRequestWrapper.getConfig().maxAttempts}, ` +
+            `circuitBreaker.enabled=${this.leaderRequestWrapper.getConfig().circuitBreaker?.enabled}`);
         // initialize address resolution
         this.router.addResolver(new oMethodResolver(this.address));
         this.router.addResolver(new oNodeResolver(this.address));

package/dist/src/router/o-node.routing-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-node.routing-policy.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.routing-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAG1C;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,cAAc;IACpD;;;;;;;;;OASG;IACH,iBAAiB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;IAkB1D;;;;;;;;OAQG;IACH,0BAA0B,CACxB,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,KAAK,GACV,aAAa,GAAG,IAAI;CAuBxB"}
+{"version":3,"file":"o-node.routing-policy.d.ts","sourceRoot":"","sources":["../../../src/router/o-node.routing-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAG1C;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,cAAc;IACpD;;;;;;;;;OASG;IACH,iBAAiB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;IAkB1D;;;;;;;;OAQG;IACH,0BAA0B,CACxB,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,KAAK,GACV,aAAa,GAAG,IAAI;CAsBxB"}

package/dist/src/router/o-node.routing-policy.js

@@ -40,7 +40,7 @@ export class oNodeRoutingPolicy extends oRoutingPolicy {
         const isInternal = this.isInternalAddress(address, node);
         if (!isInternal) {
             // external address, so we need to route
-            this.logger.debug('Address is external, routing...', nodeAddress.toString(), nodeAddress.libp2pTransports.map((t) => t.toString()));
+            this.logger.debug('Address is external, routing...', nodeAddress.toString());
             // route to leader of external OS
             return {
                 nextHopAddress: new oNodeAddress(oAddress.leader().toString(), nodeAddress.libp2pTransports),

package/dist/src/router/resolvers/o-node.search-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-node.search-resolver.d.ts","sourceRoot":"","sources":["../../../../src/router/resolvers/o-node.search-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,KAAK,EAEL,UAAU,EACV,cAAc,EAEd,aAAa,EAEd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,qBAAa,eAAgB,SAAQ,gBAAgB;IACvC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ;gBAAjB,OAAO,EAAE,QAAQ;IAIhD,IAAI,gBAAgB,IAAI,UAAU,EAAE,CAEnC;IAED;;;;OAIG;IACH,SAAS,CAAC,kBAAkB,IAAI,QAAQ;IAIxC;;;;OAIG;IACH,SAAS,CAAC,eAAe,IAAI,MAAM;IAInC;;;;;OAKG;IACH,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,GAAG;IAOnD;;;;;;OAMG;IACH,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,GAAG,GAAG,EAAE;IASjE;;;;;OAKG;IACH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI;IAIlD;;;;;OAKG;IACH,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,GAAG,GAAG,cAAc,EAAE;IAOtD;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,wBAAwB,CAChC,OAAO,EAAE,QAAQ,EACjB,gBAAgB,EAAE,cAAc,EAAE,EAClC,IAAI,EAAE,KAAK,GACV,cAAc,EAAE;IAgBnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,SAAS,CAAC,gBAAgB,CACxB,IAAI,EAAE,KAAK,EACX,qBAAqB,EAAE,QAAQ,EAC/B,YAAY,EAAE,GAAG,GAChB,QAAQ;IAsBL,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CAoE/D"}
+{"version":3,"file":"o-node.search-resolver.d.ts","sourceRoot":"","sources":["../../../../src/router/resolvers/o-node.search-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,KAAK,EAEL,UAAU,EACV,cAAc,EAEd,aAAa,EAEd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,qBAAa,eAAgB,SAAQ,gBAAgB;IACvC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ;gBAAjB,OAAO,EAAE,QAAQ;IAIhD,IAAI,gBAAgB,IAAI,UAAU,EAAE,CAEnC;IAED;;;;OAIG;IACH,SAAS,CAAC,kBAAkB,IAAI,QAAQ;IAIxC;;;;OAIG;IACH,SAAS,CAAC,eAAe,IAAI,MAAM;IAInC;;;;;OAKG;IACH,SAAS,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,GAAG;IAOnD;;;;;;OAMG;IACH,SAAS,CAAC,mBAAmB,CAAC,OAAO,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,GAAG,GAAG,EAAE;IASjE;;;;;OAKG;IACH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI;IAIlD;;;;;OAKG;IACH,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,GAAG,GAAG,cAAc,EAAE;IAOtD;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,wBAAwB,CAChC,OAAO,EAAE,QAAQ,EACjB,gBAAgB,EAAE,cAAc,EAAE,EAClC,IAAI,EAAE,KAAK,GACV,cAAc,EAAE;IAgBnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,SAAS,CAAC,gBAAgB,CACxB,IAAI,EAAE,KAAK,EACX,qBAAqB,EAAE,QAAQ,EAC/B,YAAY,EAAE,GAAG,GAChB,QAAQ;IAeL,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CA8F/D"}

package/dist/src/router/resolvers/o-node.search-resolver.js

@@ -201,7 +201,6 @@ export class oSearchResolver extends oAddressResolver {
     determineNextHop(node, resolvedTargetAddress, searchResult) {
         // Determine next hop using standard hierarchy logic
         const nextHopAddress = oAddress.next(node.address, resolvedTargetAddress);
-        this.logger.debug('determineNextHop with params', 'node.address: ' + node.address.toString(), 'resolvedTargetAddress: ' + resolvedTargetAddress.toString(), 'searchResult.address: ' + searchResult.address, 'next hop: ' + nextHopAddress.toString());
         // Map transports from search result
         const targetTransports = this.mapTransports(searchResult);
         // Set transports on the next hop based on routing logic
@@ -218,13 +217,33 @@ export class oSearchResolver extends oAddressResolver {
                 requestOverride: resolveRequest,
             };
         }
-        // Perform registry search
+        // Perform registry search with error handling
         const searchParams = this.buildSearchParams(address);
         const registryAddress = this.getRegistryAddress();
-        const searchResponse = await node.use(registryAddress, {
-            method: this.getSearchMethod(),
-            params: searchParams,
-        });
+        let searchResponse;
+        try {
+            searchResponse = await node.use(registryAddress, {
+                method: this.getSearchMethod(),
+                params: searchParams,
+            });
+        }
+        catch (error) {
+            // Log the error but don't throw - allow fallback resolvers to handle it
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Check if this is a circuit breaker error (fast-fail scenario)
+            if (errorMessage.includes('Circuit breaker is OPEN')) {
+                this.logger.warn(`Registry search blocked by circuit breaker for ${address.toString()}: ${errorMessage}`);
+            }
+            else {
+                this.logger.error(`Registry search failed for ${address.toString()}: ${errorMessage}`);
+            }
+            // Return original address without transports, letting next resolver in chain handle it
+            return {
+                nextHopAddress: address,
+                targetAddress: targetAddress,
+                requestOverride: resolveRequest,
+            };
+        }
         // Filter and select result
         const filteredResults = this.filterSearchResults(searchResponse.result.data, node);
         const selectedResult = this.selectResult(filteredResults);
@@ -240,7 +259,6 @@ export class oSearchResolver extends oAddressResolver {
         const extraParams = address
             .toString() // o://embeddings-text replace o://embeddings-text = ''
             .replace(address.toRootAddress().toString(), '');
-        this.logger.debug('Extra params:', extraParams);
         // Check if selectedResult.address already contains the complete path
         // This happens when registry finds via staticAddress - the returned address
         // is the canonical hierarchical location, so we shouldn't append extraParams

package/dist/src/utils/circuit-breaker.d.ts

@@ -0,0 +1,107 @@
+import { oObject } from '@olane/o-core';
+export declare enum CircuitState {
+    CLOSED = "CLOSED",// Normal operation, requests pass through
+    OPEN = "OPEN",// Circuit broken, requests fast-fail
+    HALF_OPEN = "HALF_OPEN"
+}
+export interface CircuitBreakerConfig {
+    failureThreshold: number;
+    openTimeoutMs: number;
+    halfOpenMaxAttempts: number;
+    enabled: boolean;
+}
+export interface CircuitStats {
+    state: CircuitState;
+    consecutiveFailures: number;
+    totalFailures: number;
+    totalSuccesses: number;
+    lastFailureTime?: number;
+    lastSuccessTime?: number;
+    openedAt?: number;
+}
+/**
+ * Circuit Breaker Pattern Implementation
+ *
+ * Prevents cascading failures by "breaking the circuit" when a service
+ * experiences persistent failures. This allows the system to fail fast
+ * rather than wasting resources on retries that are likely to fail.
+ *
+ * States:
+ * - CLOSED: Normal operation, all requests pass through
+ * - OPEN: Circuit broken due to failures, requests fail immediately
+ * - HALF_OPEN: Testing recovery, limited requests allowed
+ *
+ * Flow:
+ * 1. CLOSED -> OPEN: After N consecutive failures
+ * 2. OPEN -> HALF_OPEN: After timeout period
+ * 3. HALF_OPEN -> CLOSED: After successful request
+ * 4. HALF_OPEN -> OPEN: After failure in recovery
+ *
+ * @example
+ * ```typescript
+ * const breaker = new CircuitBreaker('registry', {
+ *   failureThreshold: 3,
+ *   openTimeoutMs: 30000,
+ *   halfOpenMaxAttempts: 1,
+ *   enabled: true,
+ * });
+ *
+ * // Before making request
+ * if (!breaker.shouldAllowRequest()) {
+ *   throw new Error('Circuit breaker is open');
+ * }
+ *
+ * try {
+ *   const result = await makeRequest();
+ *   breaker.recordSuccess();
+ *   return result;
+ * } catch (error) {
+ *   breaker.recordFailure();
+ *   throw error;
+ * }
+ * ```
+ */
+export declare class CircuitBreaker extends oObject {
+    private readonly serviceName;
+    private readonly config;
+    private state;
+    private consecutiveFailures;
+    private totalFailures;
+    private totalSuccesses;
+    private lastFailureTime?;
+    private lastSuccessTime?;
+    private openedAt?;
+    private halfOpenAttempts;
+    constructor(serviceName: string, config: CircuitBreakerConfig);
+    /**
+     * Check if a request should be allowed through the circuit breaker
+     * @returns true if request should proceed, false if should fast-fail
+     */
+    shouldAllowRequest(): boolean;
+    /**
+     * Record a successful request
+     */
+    recordSuccess(): void;
+    /**
+     * Record a failed request
+     */
+    recordFailure(): void;
+    /**
+     * Get current statistics
+     */
+    getStats(): CircuitStats;
+    /**
+     * Get current circuit state
+     */
+    getState(): CircuitState;
+    /**
+     * Force reset the circuit breaker to CLOSED state
+     * Use with caution - mainly for testing or manual recovery
+     */
+    reset(): void;
+    /**
+     * Transition to a new state
+     */
+    private transitionTo;
+}
+//# sourceMappingURL=circuit-breaker.d.ts.map

package/dist/src/utils/circuit-breaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuit-breaker.d.ts","sourceRoot":"","sources":["../../../src/utils/circuit-breaker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,oBAAY,YAAY;IACtB,MAAM,WAAW,CAAE,0CAA0C;IAC7D,IAAI,SAAS,CAAE,qCAAqC;IACpD,SAAS,cAAc;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,YAAY,CAAC;IACpB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qBAAa,cAAe,SAAQ,OAAO;IAWvC,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAXzB,OAAO,CAAC,KAAK,CAAqC;IAClD,OAAO,CAAC,mBAAmB,CAAa;IACxC,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,eAAe,CAAC,CAAS;IACjC,OAAO,CAAC,eAAe,CAAC,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,CAAS;IAC1B,OAAO,CAAC,gBAAgB,CAAa;gBAGlB,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,oBAAoB;IAW/C;;;OAGG;IACH,kBAAkB,IAAI,OAAO;IA2C7B;;OAEG;IACH,aAAa,IAAI,IAAI;IAkBrB;;OAEG;IACH,aAAa,IAAI,IAAI;IA+BrB;;OAEG;IACH,QAAQ,IAAI,YAAY;IAYxB;;OAEG;IACH,QAAQ,IAAI,YAAY;IAIxB;;;OAGG;IACH,KAAK,IAAI,IAAI;IAQb;;OAEG;IACH,OAAO,CAAC,YAAY;CAOrB"}

package/dist/src/utils/circuit-breaker.js

@@ -0,0 +1,175 @@
+import { oObject } from '@olane/o-core';
+export var CircuitState;
+(function (CircuitState) {
+    CircuitState["CLOSED"] = "CLOSED";
+    CircuitState["OPEN"] = "OPEN";
+    CircuitState["HALF_OPEN"] = "HALF_OPEN";
+})(CircuitState || (CircuitState = {}));
+/**
+ * Circuit Breaker Pattern Implementation
+ *
+ * Prevents cascading failures by "breaking the circuit" when a service
+ * experiences persistent failures. This allows the system to fail fast
+ * rather than wasting resources on retries that are likely to fail.
+ *
+ * States:
+ * - CLOSED: Normal operation, all requests pass through
+ * - OPEN: Circuit broken due to failures, requests fail immediately
+ * - HALF_OPEN: Testing recovery, limited requests allowed
+ *
+ * Flow:
+ * 1. CLOSED -> OPEN: After N consecutive failures
+ * 2. OPEN -> HALF_OPEN: After timeout period
+ * 3. HALF_OPEN -> CLOSED: After successful request
+ * 4. HALF_OPEN -> OPEN: After failure in recovery
+ *
+ * @example
+ * ```typescript
+ * const breaker = new CircuitBreaker('registry', {
+ *   failureThreshold: 3,
+ *   openTimeoutMs: 30000,
+ *   halfOpenMaxAttempts: 1,
+ *   enabled: true,
+ * });
+ *
+ * // Before making request
+ * if (!breaker.shouldAllowRequest()) {
+ *   throw new Error('Circuit breaker is open');
+ * }
+ *
+ * try {
+ *   const result = await makeRequest();
+ *   breaker.recordSuccess();
+ *   return result;
+ * } catch (error) {
+ *   breaker.recordFailure();
+ *   throw error;
+ * }
+ * ```
+ */
+export class CircuitBreaker extends oObject {
+    constructor(serviceName, config) {
+        super();
+        this.serviceName = serviceName;
+        this.config = config;
+        this.state = CircuitState.CLOSED;
+        this.consecutiveFailures = 0;
+        this.totalFailures = 0;
+        this.totalSuccesses = 0;
+        this.halfOpenAttempts = 0;
+        this.logger.debug(`Circuit breaker initialized for ${serviceName}:`, `threshold=${config.failureThreshold},`, `timeout=${config.openTimeoutMs}ms,`, `enabled=${config.enabled}`);
+    }
+    /**
+     * Check if a request should be allowed through the circuit breaker
+     * @returns true if request should proceed, false if should fast-fail
+     */
+    shouldAllowRequest() {
+        if (!this.config.enabled) {
+            return true;
+        }
+        const now = Date.now();
+        switch (this.state) {
+            case CircuitState.CLOSED:
+                return true;
+            case CircuitState.OPEN:
+                // Check if timeout period has elapsed
+                if (this.openedAt &&
+                    now - this.openedAt >= this.config.openTimeoutMs) {
+                    this.logger.info(`Circuit breaker for ${this.serviceName} entering HALF_OPEN state`);
+                    this.transitionTo(CircuitState.HALF_OPEN);
+                    this.halfOpenAttempts = 0;
+                    return true;
+                }
+                // Circuit still open, fast-fail
+                this.logger.debug(`Circuit breaker for ${this.serviceName} is OPEN, rejecting request`);
+                return false;
+            case CircuitState.HALF_OPEN:
+                // Allow limited attempts in HALF_OPEN state
+                if (this.halfOpenAttempts < this.config.halfOpenMaxAttempts) {
+                    this.halfOpenAttempts++;
+                    return true;
+                }
+                this.logger.debug(`Circuit breaker for ${this.serviceName} HALF_OPEN max attempts reached`);
+                return false;
+        }
+    }
+    /**
+     * Record a successful request
+     */
+    recordSuccess() {
+        if (!this.config.enabled) {
+            return;
+        }
+        this.totalSuccesses++;
+        this.lastSuccessTime = Date.now();
+        this.consecutiveFailures = 0;
+        if (this.state === CircuitState.HALF_OPEN) {
+            this.logger.info(`Circuit breaker for ${this.serviceName} recovered, closing circuit`);
+            this.transitionTo(CircuitState.CLOSED);
+            this.halfOpenAttempts = 0;
+        }
+    }
+    /**
+     * Record a failed request
+     */
+    recordFailure() {
+        if (!this.config.enabled) {
+            return;
+        }
+        this.totalFailures++;
+        this.consecutiveFailures++;
+        this.lastFailureTime = Date.now();
+        if (this.state === CircuitState.HALF_OPEN) {
+            this.logger.warn(`Circuit breaker for ${this.serviceName} failed in HALF_OPEN, reopening circuit`);
+            this.transitionTo(CircuitState.OPEN);
+            this.openedAt = Date.now();
+            this.halfOpenAttempts = 0;
+            return;
+        }
+        if (this.state === CircuitState.CLOSED &&
+            this.consecutiveFailures >= this.config.failureThreshold) {
+            this.logger.error(`Circuit breaker for ${this.serviceName} opening after ${this.consecutiveFailures} consecutive failures`);
+            this.transitionTo(CircuitState.OPEN);
+            this.openedAt = Date.now();
+        }
+    }
+    /**
+     * Get current statistics
+     */
+    getStats() {
+        return {
+            state: this.state,
+            consecutiveFailures: this.consecutiveFailures,
+            totalFailures: this.totalFailures,
+            totalSuccesses: this.totalSuccesses,
+            lastFailureTime: this.lastFailureTime,
+            lastSuccessTime: this.lastSuccessTime,
+            openedAt: this.openedAt,
+        };
+    }
+    /**
+     * Get current circuit state
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Force reset the circuit breaker to CLOSED state
+     * Use with caution - mainly for testing or manual recovery
+     */
+    reset() {
+        this.logger.info(`Circuit breaker for ${this.serviceName} manually reset`);
+        this.transitionTo(CircuitState.CLOSED);
+        this.consecutiveFailures = 0;
+        this.halfOpenAttempts = 0;
+        this.openedAt = undefined;
+    }
+    /**
+     * Transition to a new state
+     */
+    transitionTo(newState) {
+        const oldState = this.state;
+        this.state = newState;
+        this.logger.debug(`Circuit breaker for ${this.serviceName}: ${oldState} -> ${newState}`);
+    }
+}

package/dist/src/utils/circuit-breaker.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=circuit-breaker.test.d.ts.map

package/dist/src/utils/circuit-breaker.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuit-breaker.test.d.ts","sourceRoot":"","sources":["../../../src/utils/circuit-breaker.test.ts"],"names":[],"mappings":""}

package/dist/src/utils/circuit-breaker.test.js

@@ -0,0 +1,262 @@
+import { expect } from 'chai';
+import { CircuitBreaker, CircuitState } from './circuit-breaker.js';
+describe('CircuitBreaker', () => {
+    let breaker;
+    beforeEach(() => {
+        breaker = new CircuitBreaker('test-service', {
+            enabled: true,
+            failureThreshold: 3,
+            openTimeoutMs: 1000,
+            halfOpenMaxAttempts: 1,
+        });
+    });
+    describe('State Transitions', () => {
+        it('should start in CLOSED state', () => {
+            expect(breaker.getState()).to.equal(CircuitState.CLOSED);
+            expect(breaker.shouldAllowRequest()).to.equal(true);
+        });
+        it('should transition to OPEN after threshold failures', () => {
+            expect(breaker.getState()).to.equal(CircuitState.CLOSED);
+            // Record failures up to threshold
+            breaker.recordFailure();
+            breaker.recordFailure();
+            expect(breaker.getState()).to.equal(CircuitState.CLOSED);
+            // Third failure should open circuit
+            breaker.recordFailure();
+            expect(breaker.getState()).to.equal(CircuitState.OPEN);
+            expect(breaker.shouldAllowRequest()).to.equal(false);
+        });
+        it('should transition to HALF_OPEN after timeout', async () => {
+            // Open the circuit
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            expect(breaker.getState()).to.equal(CircuitState.OPEN);
+            // Wait for timeout
+            await new Promise((resolve) => setTimeout(resolve, 1100));
+            // Next request should transition to HALF_OPEN
+            expect(breaker.shouldAllowRequest()).to.equal(true);
+            expect(breaker.getState()).to.equal(CircuitState.HALF_OPEN);
+        });
+        it('should transition from HALF_OPEN to CLOSED on success', async () => {
+            // Open the circuit
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            // Wait and transition to HALF_OPEN
+            await new Promise((resolve) => setTimeout(resolve, 1100));
+            breaker.shouldAllowRequest();
+            // Success should close circuit
+            breaker.recordSuccess();
+            expect(breaker.getState()).to.equal(CircuitState.CLOSED);
+        });
+        it('should transition from HALF_OPEN to OPEN on failure', async () => {
+            // Open the circuit
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            // Wait and transition to HALF_OPEN
+            await new Promise((resolve) => setTimeout(resolve, 1100));
+            breaker.shouldAllowRequest();
+            expect(breaker.getState()).to.equal(CircuitState.HALF_OPEN);
+            // Failure should reopen circuit
+            breaker.recordFailure();
+            expect(breaker.getState()).to.equal(CircuitState.OPEN);
+        });
+    });
+    describe('Request Gating', () => {
+        it('should allow all requests in CLOSED state', () => {
+            expect(breaker.shouldAllowRequest()).to.equal(true);
+            expect(breaker.shouldAllowRequest()).to.equal(true);
+        });
+        it('should block all requests in OPEN state', () => {
+            // Open the circuit
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            expect(breaker.shouldAllowRequest()).to.equal(false);
+        });
+        it('should limit requests in HALF_OPEN state', async () => {
+            // Open the circuit
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            // Wait and transition to HALF_OPEN
+            await new Promise((resolve) => setTimeout(resolve, 1100));
+            // First request allowed
+            expect(breaker.shouldAllowRequest()).to.equal(true);
+            expect(breaker.getState()).to.equal(CircuitState.HALF_OPEN);
+            // Subsequent requests blocked until result recorded
+            expect(breaker.shouldAllowRequest()).to.equal(false);
+        });
+    });
+    describe('Failure Tracking', () => {
+        it('should track consecutive failures', () => {
+            breaker.recordFailure();
+            expect(breaker.getStats().consecutiveFailures).to.equal(1);
+            breaker.recordFailure();
+            expect(breaker.getStats().consecutiveFailures).to.equal(2);
+            breaker.recordFailure();
+            expect(breaker.getStats().consecutiveFailures).to.equal(3);
+        });
+        it('should reset consecutive failures on success', () => {
+            breaker.recordFailure();
+            breaker.recordFailure();
+            expect(breaker.getStats().consecutiveFailures).to.equal(2);
+            breaker.recordSuccess();
+            expect(breaker.getStats().consecutiveFailures).to.equal(0);
+            expect(breaker.getState()).to.equal(CircuitState.CLOSED);
+        });
+        it('should track total failures and successes', () => {
+            breaker.recordFailure();
+            breaker.recordSuccess();
+            breaker.recordFailure();
+            breaker.recordSuccess();
+            const stats = breaker.getStats();
+            expect(stats.totalFailures).to.equal(2);
+            expect(stats.totalSuccesses).to.equal(2);
+        });
+        it('should track timestamps', () => {
+            const beforeFailure = Date.now();
+            breaker.recordFailure();
+            const afterFailure = Date.now();
+            const stats = breaker.getStats();
+            expect(stats.lastFailureTime).greaterThanOrEqual(beforeFailure);
+            expect(stats.lastFailureTime).lessThanOrEqual(afterFailure);
+            const beforeSuccess = Date.now();
+            breaker.recordSuccess();
+            const afterSuccess = Date.now();
+            const stats2 = breaker.getStats();
+            expect(stats2.lastSuccessTime).greaterThanOrEqual(beforeSuccess);
+            expect(stats2.lastSuccessTime).lessThanOrEqual(afterSuccess);
+        });
+    });
+    describe('Configuration', () => {
+        it('should respect custom failure threshold', () => {
+            const customBreaker = new CircuitBreaker('test', {
+                enabled: true,
+                failureThreshold: 5,
+                openTimeoutMs: 1000,
+                halfOpenMaxAttempts: 1,
+            });
+            // Should not open before threshold
+            customBreaker.recordFailure();
+            customBreaker.recordFailure();
+            customBreaker.recordFailure();
+            customBreaker.recordFailure();
+            expect(customBreaker.getState()).to.equal(CircuitState.CLOSED);
+            // Should open at threshold
+            customBreaker.recordFailure();
+            expect(customBreaker.getState()).to.equal(CircuitState.OPEN);
+        });
+        it('should respect custom half-open attempts', async () => {
+            const customBreaker = new CircuitBreaker('test', {
+                enabled: true,
+                failureThreshold: 2,
+                openTimeoutMs: 100,
+                halfOpenMaxAttempts: 3,
+            });
+            // Open circuit
+            customBreaker.recordFailure();
+            customBreaker.recordFailure();
+            // Wait for timeout
+            await new Promise((resolve) => setTimeout(resolve, 150));
+            // Should allow 3 attempts in HALF_OPEN
+            expect(customBreaker.shouldAllowRequest()).to.equal(true);
+            expect(customBreaker.shouldAllowRequest()).to.equal(true);
+            expect(customBreaker.shouldAllowRequest()).to.equal(true);
+            expect(customBreaker.shouldAllowRequest()).to.equal(false);
+        });
+        it('should bypass all logic when disabled', () => {
+            const disabledBreaker = new CircuitBreaker('test', {
+                enabled: false,
+                failureThreshold: 1,
+                openTimeoutMs: 1000,
+                halfOpenMaxAttempts: 1,
+            });
+            // Record many failures
+            disabledBreaker.recordFailure();
+            disabledBreaker.recordFailure();
+            disabledBreaker.recordFailure();
+            // Should still allow requests
+            expect(disabledBreaker.shouldAllowRequest()).to.equal(true);
+            expect(disabledBreaker.getState()).to.equal(CircuitState.CLOSED);
+        });
+    });
+    describe('Manual Control', () => {
+        it('should reset to CLOSED state', () => {
+            // Open circuit
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            expect(breaker.getState()).to.equal(CircuitState.OPEN);
+            // Reset
+            breaker.reset();
+            expect(breaker.getState()).to.equal(CircuitState.CLOSED);
+            expect(breaker.getStats().consecutiveFailures).to.equal(0);
+            expect(breaker.shouldAllowRequest()).to.equal(true);
+        });
+    });
+    describe('Statistics', () => {
+        it('should provide comprehensive stats', () => {
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordSuccess();
+            const stats = breaker.getStats();
+            expect(stats).to.have.property('state');
+            expect(stats).to.have.property('consecutiveFailures');
+            expect(stats).to.have.property('totalFailures');
+            expect(stats).to.have.property('totalSuccesses');
+            expect(stats).to.have.property('lastFailureTime');
+            expect(stats).to.have.property('lastSuccessTime');
+            expect(stats).to.have.property('openedAt');
+            expect(stats.state).to.equal(CircuitState.CLOSED);
+            expect(stats.consecutiveFailures).to.equal(0);
+            expect(stats.totalFailures).to.equal(2);
+            expect(stats.totalSuccesses).to.equal(1);
+        });
+        it('should track openedAt timestamp', () => {
+            const before = Date.now();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            const after = Date.now();
+            const stats = breaker.getStats();
+            expect(stats.openedAt).greaterThanOrEqual(before);
+            expect(stats.openedAt).lessThanOrEqual(after);
+        });
+    });
+    describe('Edge Cases', () => {
+        it('should handle rapid state transitions', async () => {
+            // Open
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            expect(breaker.getState()).to.equal(CircuitState.OPEN);
+            // Wait for HALF_OPEN
+            await new Promise((resolve) => setTimeout(resolve, 1100));
+            breaker.shouldAllowRequest();
+            expect(breaker.getState()).to.equal(CircuitState.HALF_OPEN);
+            // Close
+            breaker.recordSuccess();
+            expect(breaker.getState()).to.equal(CircuitState.CLOSED);
+            // Open again
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            expect(breaker.getState()).to.equal(CircuitState.OPEN);
+        });
+        it('should not open before timeout expires in OPEN state', async () => {
+            // Open circuit
+            breaker.recordFailure();
+            breaker.recordFailure();
+            breaker.recordFailure();
+            expect(breaker.getState()).to.equal(CircuitState.OPEN);
+            // Wait less than timeout
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            // Should still be closed
+            expect(breaker.shouldAllowRequest()).to.equal(false);
+            expect(breaker.getState()).to.equal(CircuitState.OPEN);
+        });
+    });
+});

package/dist/src/utils/leader-request-wrapper.d.ts

@@ -1,32 +1,42 @@
 import { oObject, oAddress } from '@olane/o-core';
+import { CircuitBreakerConfig } from './circuit-breaker.js';
 export interface LeaderRetryConfig {
     enabled: boolean;
     maxAttempts: number;
     baseDelayMs: number;
     maxDelayMs: number;
     timeoutMs: number;
+    circuitBreaker?: CircuitBreakerConfig;
 }
 /**
  * Leader Request Wrapper
  *
- * Wraps requests to leader/registry with aggressive retry logic.
+ * Wraps requests to leader/registry with retry logic and circuit breaker.
  * Used when leader may be temporarily unavailable (healing, maintenance).
  *
  * Strategy:
  * 1. Detect if request is to leader or registry
- * 2. Apply retry logic with exponential backoff
- * 3. Timeout individual attempts
- * 4. Log retries for observability
+ * 2. Check circuit breaker state (fast-fail if open)
+ * 3. Apply retry logic with exponential backoff
+ * 4. Timeout individual attempts
+ * 5. Record success/failure in circuit breaker
+ * 6. Log retries for observability
  */
 export declare class LeaderRequestWrapper extends oObject {
     private config;
+    private leaderCircuitBreaker;
+    private registryCircuitBreaker;
     constructor(config: LeaderRetryConfig);
     /**
      * Check if address is a leader-related address that needs retry
      */
     private isLeaderAddress;
     /**
-     * Execute request with retry logic
+     * Get the appropriate circuit breaker for the address
+     */
+    private getCircuitBreaker;
+    /**
+     * Execute request with retry logic and circuit breaker
      */
     execute<T>(requestFn: () => Promise<T>, address: oAddress, context?: string): Promise<T>;
     /**
@@ -41,5 +51,16 @@ export declare class LeaderRequestWrapper extends oObject {
      * Get current configuration
      */
     getConfig(): LeaderRetryConfig;
+    /**
+     * Get circuit breaker statistics for observability
+     */
+    getCircuitBreakerStats(): {
+        leader: import("./circuit-breaker.js").CircuitStats;
+        registry: import("./circuit-breaker.js").CircuitStats;
+    };
+    /**
+     * Reset circuit breakers (for testing or manual recovery)
+     */
+    resetCircuitBreakers(): void;
 }
 //# sourceMappingURL=leader-request-wrapper.d.ts.map

package/dist/src/utils/leader-request-wrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"leader-request-wrapper.d.ts","sourceRoot":"","sources":["../../../src/utils/leader-request-wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAuB,MAAM,eAAe,CAAC;AAEvE,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,oBAAqB,SAAQ,OAAO;IACnC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,iBAAiB;IAI7C;;OAEG;IACH,OAAO,CAAC,eAAe;IAKvB;;OAEG;IACG,OAAO,CAAC,CAAC,EACb,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,OAAO,EAAE,QAAQ,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,CAAC,CAAC;IAoEb;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAK7B;;OAEG;IACH,OAAO,CAAC,KAAK;IAIb;;OAEG;IACH,SAAS,IAAI,iBAAiB;CAG/B"}
+{"version":3,"file":"leader-request-wrapper.d.ts","sourceRoot":"","sources":["../../../src/utils/leader-request-wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAuB,MAAM,eAAe,CAAC;AACvE,OAAO,EAEL,oBAAoB,EAErB,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,oBAAoB,CAAC;CACvC;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,oBAAqB,SAAQ,OAAO;IAInC,OAAO,CAAC,MAAM;IAH1B,OAAO,CAAC,oBAAoB,CAAiB;IAC7C,OAAO,CAAC,sBAAsB,CAAiB;gBAE3B,MAAM,EAAE,iBAAiB;IAuB7C;;OAEG;IACH,OAAO,CAAC,eAAe;IAKvB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAWzB;;OAEG;IACG,OAAO,CAAC,CAAC,EACb,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,OAAO,EAAE,QAAQ,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,CAAC,CAAC;IA2Gb;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAK7B;;OAEG;IACH,OAAO,CAAC,KAAK;IAIb;;OAEG;IACH,SAAS,IAAI,iBAAiB;IAI9B;;OAEG;IACH,sBAAsB;;;;IAOtB;;OAEG;IACH,oBAAoB,IAAI,IAAI;CAI7B"}

package/dist/src/utils/leader-request-wrapper.js

@@ -1,20 +1,36 @@
 import { oObject } from '@olane/o-core';
+import { CircuitBreaker, CircuitState, } from './circuit-breaker.js';
 /**
  * Leader Request Wrapper
  *
- * Wraps requests to leader/registry with aggressive retry logic.
+ * Wraps requests to leader/registry with retry logic and circuit breaker.
  * Used when leader may be temporarily unavailable (healing, maintenance).
  *
  * Strategy:
  * 1. Detect if request is to leader or registry
- * 2. Apply retry logic with exponential backoff
- * 3. Timeout individual attempts
- * 4. Log retries for observability
+ * 2. Check circuit breaker state (fast-fail if open)
+ * 3. Apply retry logic with exponential backoff
+ * 4. Timeout individual attempts
+ * 5. Record success/failure in circuit breaker
+ * 6. Log retries for observability
  */
 export class LeaderRequestWrapper extends oObject {
     constructor(config) {
         super();
         this.config = config;
+        // Initialize circuit breakers with defaults if not provided
+        const defaultCircuitBreakerConfig = {
+            failureThreshold: 3,
+            openTimeoutMs: 30000, // 30 seconds
+            halfOpenMaxAttempts: 1,
+            enabled: true,
+        };
+        const circuitConfig = {
+            ...defaultCircuitBreakerConfig,
+            ...(config.circuitBreaker || {}),
+        };
+        this.leaderCircuitBreaker = new CircuitBreaker('leader', circuitConfig);
+        this.registryCircuitBreaker = new CircuitBreaker('registry', circuitConfig);
     }
     /**
      * Check if address is a leader-related address that needs retry
@@ -24,27 +40,56 @@ export class LeaderRequestWrapper extends oObject {
         return addressStr === 'o://leader' || addressStr === 'o://registry';
     }
     /**
-     * Execute request with retry logic
+     * Get the appropriate circuit breaker for the address
+     */
+    getCircuitBreaker(address) {
+        const addressStr = address.toString();
+        if (addressStr === 'o://leader') {
+            return this.leaderCircuitBreaker;
+        }
+        if (addressStr === 'o://registry') {
+            return this.registryCircuitBreaker;
+        }
+        return null;
+    }
+    /**
+     * Execute request with retry logic and circuit breaker
      */
     async execute(requestFn, address, context) {
         // If retry disabled or not a leader address, execute directly
         if (!this.config.enabled || !this.isLeaderAddress(address)) {
             return await requestFn();
         }
+        const circuitBreaker = this.getCircuitBreaker(address);
+        // Check circuit breaker state before attempting
+        if (circuitBreaker && !circuitBreaker.shouldAllowRequest()) {
+            const stats = circuitBreaker.getStats();
+            const error = new Error(`Circuit breaker is ${stats.state} for ${address.toString()}. ` +
+                `Consecutive failures: ${stats.consecutiveFailures}. ` +
+                `Fast-failing to prevent cascading failures.`);
+            this.logger.warn(`Circuit breaker blocked request to ${address.toString()}` +
+                (context ? ` (${context})` : ''));
+            throw error;
+        }
         let attempt = 0;
         let lastError;
         while (attempt < this.config.maxAttempts) {
             attempt++;
             try {
-                this.logger.debug(`Leader request attempt ${attempt}/${this.config.maxAttempts}` +
-                    (context ? ` (${context})` : ''));
+                if (attempt > 5) {
+                    this.logger.debug(`Retrying... Leader request attempt ${attempt}/${this.config.maxAttempts}` +
+                        (context ? ` (${context})` : ''));
+                }
                 // Create timeout promise
                 const timeoutPromise = new Promise((_, reject) => {
                     setTimeout(() => reject(new Error(`Leader request timeout after ${this.config.timeoutMs}ms`)), this.config.timeoutMs);
                 });
                 // Race between request and timeout
                 const result = await Promise.race([requestFn(), timeoutPromise]);
-                // Success!
+                // Success! Record in circuit breaker
+                if (circuitBreaker) {
+                    circuitBreaker.recordSuccess();
+                }
                 if (attempt > 1) {
                     this.logger.info(`Leader request succeeded after ${attempt} attempts` +
                         (context ? ` (${context})` : ''));
@@ -53,8 +98,18 @@ export class LeaderRequestWrapper extends oObject {
             }
             catch (error) {
                 lastError = error instanceof Error ? error : new Error(String(error));
+                // Record failure in circuit breaker
+                if (circuitBreaker) {
+                    circuitBreaker.recordFailure();
+                }
                 this.logger.warn(`Leader request attempt ${attempt} failed: ${lastError.message}` +
                     (context ? ` (${context})` : ''));
+                // Check if circuit breaker has opened during retries
+                if (circuitBreaker && circuitBreaker.getState() === CircuitState.OPEN) {
+                    this.logger.error(`Circuit breaker opened during retries for ${address.toString()}, stopping retry attempts` +
+                        (context ? ` (${context})` : ''));
+                    throw new Error(`Circuit breaker opened after ${attempt} attempts: ${lastError.message}`);
+                }
                 if (attempt < this.config.maxAttempts) {
                     const delay = this.calculateBackoffDelay(attempt);
                     this.logger.debug(`Waiting ${delay}ms before next attempt...`);
@@ -86,4 +141,20 @@ export class LeaderRequestWrapper extends oObject {
     getConfig() {
         return { ...this.config };
     }
+    /**
+     * Get circuit breaker statistics for observability
+     */
+    getCircuitBreakerStats() {
+        return {
+            leader: this.leaderCircuitBreaker.getStats(),
+            registry: this.registryCircuitBreaker.getStats(),
+        };
+    }
+    /**
+     * Reset circuit breakers (for testing or manual recovery)
+     */
+    resetCircuitBreakers() {
+        this.leaderCircuitBreaker.reset();
+        this.registryCircuitBreaker.reset();
+    }
 }

package/dist/src/utils/leader-request-wrapper.test.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=leader-request-wrapper.test.d.ts.map

package/dist/src/utils/leader-request-wrapper.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leader-request-wrapper.test.d.ts","sourceRoot":"","sources":["../../../src/utils/leader-request-wrapper.test.ts"],"names":[],"mappings":""}

package/dist/src/utils/leader-request-wrapper.test.js

@@ -0,0 +1,246 @@
+"use strict";
+// import { expect } from 'chai';
+// import { LeaderRequestWrapper } from './leader-request-wrapper.js';
+// import { oAddress } from '@olane/o-core';
+// import { CircuitState } from './circuit-breaker.js';
+// describe('LeaderRequestWrapper with Circuit Breaker', () => {
+//   let wrapper: LeaderRequestWrapper;
+//   const leaderAddress = new oAddress('o://leader');
+//   const registryAddress = new oAddress('o://registry');
+//   const regularAddress = new oAddress('o://some-service');
+//   beforeEach(() => {
+//     wrapper = new LeaderRequestWrapper({
+//       enabled: true,
+//       maxAttempts: 5,
+//       baseDelayMs: 10,
+//       maxDelayMs: 100,
+//       timeoutMs: 1000,
+//       circuitBreaker: {
+//         enabled: true,
+//         failureThreshold: 3,
+//         openTimeoutMs: 500,
+//         halfOpenMaxAttempts: 1,
+//       },
+//     });
+//   });
+//   describe('Circuit Breaker Integration', () => {
+//     it('should execute request successfully and record success', async () => {
+//       const mockRequest = vi.fn().mockResolvedValue('success');
+//       const result = await wrapper.execute(mockRequest, leaderAddress);
+//       expect(result).toBe('success');
+//       expect(mockRequest).toHaveBeenCalledTimes(1);
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.totalSuccesses).toBe(1);
+//       expect(stats.leader.state).toBe(CircuitState.CLOSED);
+//     });
+//     it('should record failures in circuit breaker', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Service down'));
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.totalFailures).toBeGreaterThan(0);
+//       expect(stats.leader.consecutiveFailures).toBeGreaterThan(0);
+//     });
+//     it('should open circuit after threshold failures', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Service down'));
+//       // Attempt request multiple times to trigger circuit breaker
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.state).toBe(CircuitState.OPEN);
+//     });
+//     it('should fast-fail when circuit is open', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Service down'));
+//       // First request to open circuit
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       // Reset mock to verify it's not called
+//       mockRequest.mockClear();
+//       // Second request should fast-fail
+//       await expect(wrapper.execute(mockRequest, leaderAddress)).rejects.toThrow(
+//         /Circuit breaker is OPEN/,
+//       );
+//       // Request function should not have been called
+//       expect(mockRequest).not.toHaveBeenCalled();
+//     });
+//     it('should stop retrying when circuit opens mid-retry', async () => {
+//       let callCount = 0;
+//       const mockRequest = vi.fn().mockImplementation(() => {
+//         callCount++;
+//         throw new Error('Service down');
+//       });
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       // Should have stopped retrying after circuit opened
+//       expect(callCount).toBeLessThan(5); // Less than maxAttempts
+//       expect(callCount).toBeGreaterThanOrEqual(3); // At least threshold attempts
+//     });
+//     it('should track separate circuits for leader and registry', async () => {
+//       const failingRequest = vi
+//         .fn()
+//         .mockRejectedValue(new Error('Service down'));
+//       // Fail leader requests
+//       await expect(
+//         wrapper.execute(failingRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.state).toBe(CircuitState.OPEN);
+//       expect(stats.registry.state).toBe(CircuitState.CLOSED);
+//     });
+//     it('should allow recovery after timeout in HALF_OPEN state', async () => {
+//       const mockRequest = vi
+//         .fn()
+//         .mockRejectedValueOnce(new Error('Service down'))
+//         .mockResolvedValue('recovered');
+//       // Open circuit
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       expect(wrapper.getCircuitBreakerStats().leader.state).toBe(
+//         CircuitState.OPEN,
+//       );
+//       // Wait for circuit to attempt recovery
+//       await new Promise((resolve) => setTimeout(resolve, 600));
+//       // Should succeed and close circuit
+//       const result = await wrapper.execute(mockRequest, leaderAddress);
+//       expect(result).toBe('recovered');
+//       expect(wrapper.getCircuitBreakerStats().leader.state).toBe(
+//         CircuitState.CLOSED,
+//       );
+//     });
+//   });
+//   describe('Non-Leader Addresses', () => {
+//     it('should not use circuit breaker for non-leader addresses', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Service down'));
+//       await expect(
+//         wrapper.execute(mockRequest, regularAddress),
+//       ).rejects.toThrow('Service down');
+//       // Should execute directly without retry
+//       expect(mockRequest).toHaveBeenCalledTimes(1);
+//       // Should not affect circuit breaker stats
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.totalFailures).toBe(0);
+//       expect(stats.registry.totalFailures).toBe(0);
+//     });
+//     it('should execute successful requests directly', async () => {
+//       const mockRequest = vi.fn().mockResolvedValue('success');
+//       const result = await wrapper.execute(mockRequest, regularAddress);
+//       expect(result).toBe('success');
+//       expect(mockRequest).toHaveBeenCalledTimes(1);
+//     });
+//   });
+//   describe('Timeout Handling', () => {
+//     it('should timeout long-running requests', async () => {
+//       const longRequest = vi.fn().mockImplementation(
+//         () =>
+//           new Promise((resolve) => {
+//             setTimeout(() => resolve('too-late'), 2000);
+//           }),
+//       );
+//       await expect(wrapper.execute(longRequest, leaderAddress)).rejects.toThrow(
+//         /timeout/,
+//       );
+//     });
+//     it('should record timeout as failure in circuit breaker', async () => {
+//       const longRequest = vi.fn().mockImplementation(
+//         () =>
+//           new Promise((resolve) => {
+//             setTimeout(() => resolve('too-late'), 2000);
+//           }),
+//       );
+//       await expect(
+//         wrapper.execute(longRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.leader.totalFailures).toBeGreaterThan(0);
+//     });
+//   });
+//   describe('Configuration', () => {
+//     it('should bypass retry when disabled', async () => {
+//       const disabledWrapper = new LeaderRequestWrapper({
+//         enabled: false,
+//         maxAttempts: 5,
+//         baseDelayMs: 10,
+//         maxDelayMs: 100,
+//         timeoutMs: 1000,
+//       });
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Fail'));
+//       await expect(
+//         disabledWrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow('Fail');
+//       // Should only call once (no retry)
+//       expect(mockRequest).toHaveBeenCalledTimes(1);
+//     });
+//     it('should allow circuit breaker to be disabled', async () => {
+//       const noBreakerWrapper = new LeaderRequestWrapper({
+//         enabled: true,
+//         maxAttempts: 3,
+//         baseDelayMs: 10,
+//         maxDelayMs: 100,
+//         timeoutMs: 1000,
+//         circuitBreaker: {
+//           enabled: false,
+//           failureThreshold: 3,
+//           openTimeoutMs: 500,
+//           halfOpenMaxAttempts: 1,
+//         },
+//       });
+//       let callCount = 0;
+//       const mockRequest = vi.fn().mockImplementation(() => {
+//         callCount++;
+//         throw new Error('Fail');
+//       });
+//       await expect(
+//         noBreakerWrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       // Should retry all attempts even with failures
+//       expect(callCount).toBe(3);
+//     });
+//   });
+//   describe('Manual Reset', () => {
+//     it('should reset circuit breakers manually', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Service down'));
+//       // Open circuit
+//       await expect(
+//         wrapper.execute(mockRequest, leaderAddress),
+//       ).rejects.toThrow();
+//       expect(wrapper.getCircuitBreakerStats().leader.state).toBe(
+//         CircuitState.OPEN,
+//       );
+//       // Reset
+//       wrapper.resetCircuitBreakers();
+//       expect(wrapper.getCircuitBreakerStats().leader.state).toBe(
+//         CircuitState.CLOSED,
+//       );
+//       expect(wrapper.getCircuitBreakerStats().registry.state).toBe(
+//         CircuitState.CLOSED,
+//       );
+//     });
+//   });
+//   describe('Registry Address', () => {
+//     it('should use separate circuit breaker for registry', async () => {
+//       const mockRequest = vi.fn().mockRejectedValue(new Error('Registry down'));
+//       await expect(
+//         wrapper.execute(mockRequest, registryAddress),
+//       ).rejects.toThrow();
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats.registry.totalFailures).toBeGreaterThan(0);
+//       expect(stats.registry.state).toBe(CircuitState.OPEN);
+//       expect(stats.leader.state).toBe(CircuitState.CLOSED);
+//     });
+//   });
+//   describe('Statistics', () => {
+//     it('should provide circuit breaker statistics', () => {
+//       const stats = wrapper.getCircuitBreakerStats();
+//       expect(stats).toHaveProperty('leader');
+//       expect(stats).toHaveProperty('registry');
+//       expect(stats.leader).toHaveProperty('state');
+//       expect(stats.leader).toHaveProperty('consecutiveFailures');
+//       expect(stats.registry).toHaveProperty('state');
+//     });
+//   });
+// });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-node",
-  "version": "0.7.12-alpha.10",
+  "version": "0.7.12-alpha.12",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -54,12 +54,12 @@
     "typescript": "5.4.5"
   },
   "dependencies": {
-    "@olane/o-config": "0.7.12-alpha.10",
-    "@olane/o-core": "0.7.12-alpha.10",
-    "@olane/o-protocol": "0.7.12-alpha.10",
-    "@olane/o-tool": "0.7.12-alpha.10",
+    "@olane/o-config": "0.7.12-alpha.12",
+    "@olane/o-core": "0.7.12-alpha.12",
+    "@olane/o-protocol": "0.7.12-alpha.12",
+    "@olane/o-tool": "0.7.12-alpha.12",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0"
   },
-  "gitHead": "e8d0e489c955172d3bf7818984cfcf8770fb8710"
+  "gitHead": "590e95c1281ce1df427ba57816cd825c9f52154e"
 }