@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/src/message-bus-bridge.js

@@ -1,144 +1,103 @@
+"use strict";
 /**
- * MessageBusBridge - Bridges parent and child message buses
- *
- * Forwards specified topics between parent and child clusters while maintaining
- * isolation and preventing message loops.
- *
- * Features:
- * - Forward specified parent topics to child (contextStrategy.parentTopics)
- * - Forward child completion events to parent
- * - Namespace child topics to avoid collisions
- * - Prevent message loops via forwarding flags
+ * Bridges parent and child message buses while preserving cluster isolation and
+ * preventing forwarding loops.
  */
-
+function parentTopicName(entry) {
+    if (typeof entry === 'string')
+        return entry;
+    if (typeof entry !== 'object' || entry === null)
+        return undefined;
+    return 'topic' in entry ? entry.topic : undefined;
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
 class MessageBusBridge {
-  constructor(parentBus, childBus, config) {
-    this.parentBus = parentBus;
-    this.childBus = childBus;
-    this.config = config;
-    this.parentTopicNames = new Set(
-      (config.parentTopics || [])
-        .map((entry) => (typeof entry === 'string' ? entry : entry?.topic))
-        .filter((topic) => typeof topic === 'string' && topic.length > 0)
-    );
-
-    this.parentUnsubscribe = null;
-    this.childUnsubscribe = null;
-    this.active = false;
-
-    this._setupBridge();
-  }
-
-  /**
-   * Set up bidirectional message forwarding
-   * @private
-   */
-  _setupBridge() {
-    // Forward specified parent topics to child
-    if (this.parentTopicNames.size > 0) {
-      this.parentUnsubscribe = this.parentBus.subscribe((message) => {
-        this._forwardParentToChild(message);
-      });
-    }
-
-    // Forward child completion/failure events to parent
-    this.childUnsubscribe = this.childBus.subscribe((message) => {
-      this._forwardChildToParent(message);
-    });
-
-    this.active = true;
-  }
-
-  /**
-   * Forward parent message to child cluster
-   * @private
-   */
-  _forwardParentToChild(message) {
-    // Only forward messages from parent cluster
-    if (message.cluster_id !== this.config.parentClusterId) {
-      return;
-    }
-
-    // Only forward topics specified in config
-    if (!this.parentTopicNames.has(message.topic)) {
-      return;
-    }
-
-    // Skip already-forwarded messages (prevent loops)
-    if (message.metadata?.forwarded) {
-      return;
+    parentBus;
+    childBus;
+    config;
+    parentTopicNames;
+    parentUnsubscribe;
+    childUnsubscribe;
+    active;
+    constructor(parentBus, childBus, config) {
+        this.parentBus = parentBus;
+        this.childBus = childBus;
+        this.config = config;
+        this.parentTopicNames = new Set((config.parentTopics || []).map(parentTopicName).filter(isNonEmptyString));
+        this.parentUnsubscribe = null;
+        this.childUnsubscribe = null;
+        this.active = false;
+        this._setupBridge();
     }
-
-    // Forward to child with metadata flag
-    this.childBus.publish({
-      ...message,
-      cluster_id: this.config.childClusterId,
-      metadata: {
-        ...message.metadata,
-        forwarded: true,
-        forwardedFrom: this.config.parentClusterId,
-      },
-    });
-  }
-
-  /**
-   * Forward child message to parent cluster
-   * @private
-   */
-  _forwardChildToParent(message) {
-    // Only forward messages from child cluster
-    if (message.cluster_id !== this.config.childClusterId) {
-      return;
+    _setupBridge() {
+        if (this.parentTopicNames.size > 0) {
+            this.parentUnsubscribe = this.parentBus.subscribe((message) => {
+                this._forwardParentToChild(message);
+            });
+        }
+        this.childUnsubscribe = this.childBus.subscribe((message) => {
+            this._forwardChildToParent(message);
+        });
+        this.active = true;
     }
-
-    // Only forward completion/failure events
-    const forwardTopics = ['CLUSTER_COMPLETE', 'CLUSTER_FAILED', 'AGENT_ERROR'];
-    if (!forwardTopics.includes(message.topic)) {
-      return;
+    _forwardParentToChild(message) {
+        if (message.cluster_id !== this.config.parentClusterId) {
+            return;
+        }
+        if (!this.parentTopicNames.has(message.topic)) {
+            return;
+        }
+        if (message.metadata?.forwarded) {
+            return;
+        }
+        this.childBus.publish({
+            ...message,
+            cluster_id: this.config.childClusterId,
+            metadata: {
+                ...message.metadata,
+                forwarded: true,
+                forwardedFrom: this.config.parentClusterId,
+            },
+        });
     }
-
-    // Skip already-forwarded messages (prevent loops)
-    if (message.metadata?.forwarded) {
-      return;
+    _forwardChildToParent(message) {
+        if (message.cluster_id !== this.config.childClusterId) {
+            return;
+        }
+        const forwardTopics = ['CLUSTER_COMPLETE', 'CLUSTER_FAILED', 'AGENT_ERROR'];
+        if (!forwardTopics.includes(message.topic)) {
+            return;
+        }
+        if (message.metadata?.forwarded) {
+            return;
+        }
+        this.parentBus.publish({
+            ...message,
+            cluster_id: this.config.parentClusterId,
+            topic: `CHILD_${message.topic}`,
+            metadata: {
+                ...message.metadata,
+                forwarded: true,
+                forwardedFrom: this.config.childClusterId,
+                childClusterId: this.config.childClusterId,
+            },
+        });
     }
-
-    // Forward to parent with namespaced topic and metadata flag
-    this.parentBus.publish({
-      ...message,
-      cluster_id: this.config.parentClusterId,
-      topic: `CHILD_${message.topic}`,
-      metadata: {
-        ...message.metadata,
-        forwarded: true,
-        forwardedFrom: this.config.childClusterId,
-        childClusterId: this.config.childClusterId,
-      },
-    });
-  }
-
-  /**
-   * Close the bridge and stop forwarding
-   */
-  close() {
-    if (this.parentUnsubscribe) {
-      this.parentUnsubscribe();
-      this.parentUnsubscribe = null;
+    close() {
+        if (this.parentUnsubscribe) {
+            this.parentUnsubscribe();
+            this.parentUnsubscribe = null;
+        }
+        if (this.childUnsubscribe) {
+            this.childUnsubscribe();
+            this.childUnsubscribe = null;
+        }
+        this.active = false;
     }
-
-    if (this.childUnsubscribe) {
-      this.childUnsubscribe();
-      this.childUnsubscribe = null;
+    isActive() {
+        return this.active;
     }
-
-    this.active = false;
-  }
-
-  /**
-   * Check if bridge is active
-   */
-  isActive() {
-    return this.active;
-  }
 }
-
 module.exports = MessageBusBridge;

package/src/message-bus-bridge.ts

@@ -0,0 +1,149 @@
+/**
+ * Bridges parent and child message buses while preserving cluster isolation and
+ * preventing forwarding loops.
+ */
+
+interface BridgeMetadata extends Record<string, unknown> {
+  forwarded?: unknown;
+}
+
+interface BridgeMessage extends Record<string, unknown> {
+  cluster_id: string;
+  topic: string;
+  metadata?: BridgeMetadata;
+}
+
+interface BridgeMessageBus {
+  subscribe(handler: (message: BridgeMessage) => void): () => void;
+  publish(message: BridgeMessage): unknown;
+}
+
+interface MessageBusBridgeConfig {
+  parentClusterId: string;
+  childClusterId: string;
+  parentTopics?: unknown[];
+}
+
+function parentTopicName(entry: unknown): unknown {
+  if (typeof entry === 'string') return entry;
+  if (typeof entry !== 'object' || entry === null) return undefined;
+  return 'topic' in entry ? entry.topic : undefined;
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === 'string' && value.length > 0;
+}
+
+class MessageBusBridge {
+  parentBus: BridgeMessageBus;
+  childBus: BridgeMessageBus;
+  config: MessageBusBridgeConfig;
+  parentTopicNames: Set<string>;
+  parentUnsubscribe: (() => void) | null;
+  childUnsubscribe: (() => void) | null;
+  active: boolean;
+
+  constructor(
+    parentBus: BridgeMessageBus,
+    childBus: BridgeMessageBus,
+    config: MessageBusBridgeConfig
+  ) {
+    this.parentBus = parentBus;
+    this.childBus = childBus;
+    this.config = config;
+    this.parentTopicNames = new Set(
+      (config.parentTopics || []).map(parentTopicName).filter(isNonEmptyString)
+    );
+
+    this.parentUnsubscribe = null;
+    this.childUnsubscribe = null;
+    this.active = false;
+
+    this._setupBridge();
+  }
+
+  _setupBridge(): void {
+    if (this.parentTopicNames.size > 0) {
+      this.parentUnsubscribe = this.parentBus.subscribe((message: BridgeMessage) => {
+        this._forwardParentToChild(message);
+      });
+    }
+
+    this.childUnsubscribe = this.childBus.subscribe((message: BridgeMessage) => {
+      this._forwardChildToParent(message);
+    });
+
+    this.active = true;
+  }
+
+  _forwardParentToChild(message: BridgeMessage): void {
+    if (message.cluster_id !== this.config.parentClusterId) {
+      return;
+    }
+
+    if (!this.parentTopicNames.has(message.topic)) {
+      return;
+    }
+
+    if (message.metadata?.forwarded) {
+      return;
+    }
+
+    this.childBus.publish({
+      ...message,
+      cluster_id: this.config.childClusterId,
+      metadata: {
+        ...message.metadata,
+        forwarded: true,
+        forwardedFrom: this.config.parentClusterId,
+      },
+    });
+  }
+
+  _forwardChildToParent(message: BridgeMessage): void {
+    if (message.cluster_id !== this.config.childClusterId) {
+      return;
+    }
+
+    const forwardTopics = ['CLUSTER_COMPLETE', 'CLUSTER_FAILED', 'AGENT_ERROR'];
+    if (!forwardTopics.includes(message.topic)) {
+      return;
+    }
+
+    if (message.metadata?.forwarded) {
+      return;
+    }
+
+    this.parentBus.publish({
+      ...message,
+      cluster_id: this.config.parentClusterId,
+      topic: `CHILD_${message.topic}`,
+      metadata: {
+        ...message.metadata,
+        forwarded: true,
+        forwardedFrom: this.config.childClusterId,
+        childClusterId: this.config.childClusterId,
+      },
+    });
+  }
+
+  close(): void {
+    if (this.parentUnsubscribe) {
+      this.parentUnsubscribe();
+      this.parentUnsubscribe = null;
+    }
+
+    if (this.childUnsubscribe) {
+      this.childUnsubscribe();
+      this.childUnsubscribe = null;
+    }
+
+    this.active = false;
+  }
+
+  isActive(): boolean {
+    return this.active;
+  }
+}
+
+export = MessageBusBridge;

package/src/name-generator-shared.js

@@ -0,0 +1,220 @@
+"use strict";
+const ADJECTIVES = [
+    // Colors
+    'amber',
+    'azure',
+    'crimson',
+    'emerald',
+    'golden',
+    'indigo',
+    'jade',
+    'ruby',
+    'sapphire',
+    'silver',
+    'violet',
+    'bronze',
+    'coral',
+    'ivory',
+    'pearl',
+    'platinum',
+    'scarlet',
+    'cobalt',
+    'copper',
+    'obsidian',
+    'onyx',
+    'opal',
+    'topaz',
+    'turquoise',
+    // Nature
+    'wandering',
+    'bright',
+    'silent',
+    'ancient',
+    'swift',
+    'noble',
+    'bold',
+    'wild',
+    'gentle',
+    'hidden',
+    'fierce',
+    'calm',
+    'frozen',
+    'misty',
+    'stormy',
+    'sunny',
+    // Cosmic
+    'cosmic',
+    'crystal',
+    'electric',
+    'lunar',
+    'solar',
+    'stellar',
+    'astral',
+    'orbital',
+    'mystic',
+    'quantum',
+    'radiant',
+    'twilight',
+    'vivid',
+    'zen',
+    'infinite',
+    'eternal',
+    // Tech/Abstract
+    'clever',
+    'rapid',
+    'steady',
+    'agile',
+    'nimble',
+    'keen',
+    'sharp',
+    'quick',
+    'prime',
+    'binary',
+    'neural',
+    'atomic',
+    'sonic',
+    'hyper',
+    'mega',
+    'ultra',
+    // Descriptive
+    'blazing',
+    'gleaming',
+    'glowing',
+    'shining',
+    'burning',
+    'flaming',
+    'sparkling',
+    'dazzling',
+    'roaring',
+    'rushing',
+    'soaring',
+    'flying',
+    'rising',
+    'falling',
+    'spinning',
+    'dancing',
+];
+const NOUNS = [
+    // Nature
+    'forest',
+    'river',
+    'mountain',
+    'ocean',
+    'thunder',
+    'canyon',
+    'summit',
+    'valley',
+    'cascade',
+    'glacier',
+    'volcano',
+    'desert',
+    'meadow',
+    'tundra',
+    'jungle',
+    'reef',
+    // Space
+    'star',
+    'comet',
+    'nebula',
+    'galaxy',
+    'pulsar',
+    'quasar',
+    'aurora',
+    'eclipse',
+    'meteor',
+    'nova',
+    'cosmos',
+    'orbit',
+    'void',
+    'horizon',
+    'zenith',
+    'equinox',
+    // Mythical
+    'phoenix',
+    'dragon',
+    'griffin',
+    'sphinx',
+    'hydra',
+    'kraken',
+    'titan',
+    'atlas',
+    'oracle',
+    'rune',
+    'sigil',
+    'glyph',
+    'totem',
+    'aegis',
+    'aether',
+    'flux',
+    // Animals
+    'falcon',
+    'eagle',
+    'wolf',
+    'bear',
+    'tiger',
+    'hawk',
+    'lion',
+    'panther',
+    'raven',
+    'serpent',
+    'shark',
+    'owl',
+    'fox',
+    'lynx',
+    'viper',
+    'condor',
+    // Architecture
+    'citadel',
+    'temple',
+    'spire',
+    'tower',
+    'fortress',
+    'bastion',
+    'vault',
+    'sanctum',
+    'beacon',
+    'arch',
+    'bridge',
+    'gate',
+    'hall',
+    'keep',
+    'dome',
+    'obelisk',
+    // Abstract
+    'cipher',
+    'echo',
+    'nexus',
+    'prism',
+    'relic',
+    'vertex',
+    'vortex',
+    'pulse',
+    'surge',
+    'spark',
+    'flame',
+    'storm',
+    'wave',
+    'drift',
+    'shift',
+    'core',
+];
+function isNameRandomSource(value) {
+    return typeof value === 'function';
+}
+function nextNameRandomValue() {
+    const randomSource = Reflect.get(Math, 'random');
+    if (!isNameRandomSource(randomSource)) {
+        throw new TypeError('Math.random must be a function');
+    }
+    return randomSource.call(Math);
+}
+function generateReadableName(adjectiveFallback, nounFallback) {
+    const adjective = ADJECTIVES[Math.floor(nextNameRandomValue() * ADJECTIVES.length)] ?? adjectiveFallback;
+    const noun = NOUNS[Math.floor(nextNameRandomValue() * NOUNS.length)] ?? nounFallback;
+    const number = Math.floor(nextNameRandomValue() * 100);
+    return `${adjective}-${noun}-${number}`;
+}
+function generateNameSuffix() {
+    return nextNameRandomValue().toString(36).slice(2, 6);
+}
+module.exports = { generateReadableName, generateNameSuffix };