@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/src/template-validation/two-stage-contracts.ts

@@ -0,0 +1,41 @@
+export interface ValidationTrigger {
+  topic?: string;
+  logic?: { script?: string };
+}
+
+export interface ValidationAgentConfig {
+  id: string;
+  role?: string;
+  triggers?: ValidationTrigger[];
+  hooks?: { onComplete?: unknown };
+}
+
+export interface ValidationTemplateConfig {
+  agents: ValidationAgentConfig[];
+}
+
+export interface ValidationCluster {
+  id: string;
+  agents: Array<{ id: string; role: string | undefined }>;
+}
+
+export interface ValidatorFixture {
+  sender: string;
+  error: string;
+}
+
+export interface ValidationStageSpec {
+  templateId: 'quick-validation' | 'heavy-validation';
+  clusterId: string;
+  triggerTopic: string;
+  stageStartTopic: string;
+  stageStartSender: string;
+  validators: readonly ValidatorFixture[];
+  passTopic?: string;
+  gateFailure: string;
+  missingPassFailure: string;
+  missingResultFailure: string;
+  aggregateFailure: string;
+}
+
+export type ScenarioOutcome = { ok: true } | { ok: false; error: string };

package/src/template-validation/two-stage-inputs.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishScenarioInputs = publishScenarioInputs;
+function publishScenarioInputs(spec, cluster, messageBus) {
+    const now = Date.now();
+    messageBus.publish({
+        cluster_id: cluster.id,
+        topic: spec.stageStartTopic,
+        sender: spec.stageStartSender,
+        timestamp: now,
+    });
+    spec.validators.forEach((validator, index) => {
+        messageBus.publish({
+            cluster_id: cluster.id,
+            topic: spec.triggerTopic,
+            sender: validator.sender,
+            timestamp: now + (index + 1) * 10,
+            content: { data: { approved: true, errors: [validator.error] } },
+        });
+    });
+}

package/src/template-validation/two-stage-inputs.ts

@@ -0,0 +1,29 @@
+import type { ValidationCluster, ValidationStageSpec } from './two-stage-contracts';
+
+interface SimulationMessageBus {
+  publish(message: unknown): unknown;
+}
+
+export function publishScenarioInputs(
+  spec: ValidationStageSpec,
+  cluster: ValidationCluster,
+  messageBus: SimulationMessageBus
+): void {
+  const now = Date.now();
+  messageBus.publish({
+    cluster_id: cluster.id,
+    topic: spec.stageStartTopic,
+    sender: spec.stageStartSender,
+    timestamp: now,
+  });
+
+  spec.validators.forEach((validator, index) => {
+    messageBus.publish({
+      cluster_id: cluster.id,
+      topic: spec.triggerTopic,
+      sender: validator.sender,
+      timestamp: now + (index + 1) * 10,
+      content: { data: { approved: true, errors: [validator.error] } },
+    });
+  });
+}

package/src/template-validation/two-stage-results.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateScenarioMessages = evaluateScenarioMessages;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function getValidationErrors(message) {
+    if (!isRecord(message))
+        return [];
+    const content = message.content;
+    if (!isRecord(content))
+        return [];
+    const data = content.data;
+    if (!isRecord(data) || !Array.isArray(data.errors))
+        return [];
+    return data.errors.filter((error) => typeof error === 'string');
+}
+function evaluateScenarioMessages(spec, allApproved, messages) {
+    if (allApproved && spec.passTopic) {
+        return messages.passed ? { ok: true } : { ok: false, error: spec.missingPassFailure };
+    }
+    if (!messages.validationResult) {
+        return { ok: false, error: spec.missingResultFailure };
+    }
+    const errors = getValidationErrors(messages.validationResult);
+    if (!spec.validators.every((validator) => errors.includes(validator.error))) {
+        return { ok: false, error: spec.aggregateFailure };
+    }
+    return { ok: true };
+}

package/src/template-validation/two-stage-results.ts

@@ -0,0 +1,40 @@
+import type { ScenarioOutcome, ValidationStageSpec } from './two-stage-contracts';
+
+interface ScenarioMessages {
+  passed: unknown;
+  validationResult: unknown;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function getValidationErrors(message: unknown): string[] {
+  if (!isRecord(message)) return [];
+  const content = message.content;
+  if (!isRecord(content)) return [];
+  const data = content.data;
+  if (!isRecord(data) || !Array.isArray(data.errors)) return [];
+  return data.errors.filter((error): error is string => typeof error === 'string');
+}
+
+export function evaluateScenarioMessages(
+  spec: ValidationStageSpec,
+  allApproved: boolean,
+  messages: ScenarioMessages
+): ScenarioOutcome {
+  if (allApproved && spec.passTopic) {
+    return messages.passed ? { ok: true } : { ok: false, error: spec.missingPassFailure };
+  }
+
+  if (!messages.validationResult) {
+    return { ok: false, error: spec.missingResultFailure };
+  }
+
+  const errors = getValidationErrors(messages.validationResult);
+  if (!spec.validators.every((validator) => errors.includes(validator.error))) {
+    return { ok: false, error: spec.aggregateFailure };
+  }
+
+  return { ok: true };
+}

package/src/template-validation/two-stage-scenario.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simulateValidationStage = simulateValidationStage;
+const assert = require("node:assert");
+const simulationRuntime = require("./simulation-runtime");
+const simulationAgentRuntime = require("./simulation-agent-runtime");
+const simulation_agent_1 = require("./simulation-agent");
+const two_stage_inputs_1 = require("./two-stage-inputs");
+const two_stage_results_1 = require("./two-stage-results");
+function resolveCoordinator(spec, config) {
+    const coordinator = config.agents.find((agent) => agent.id === 'consensus-coordinator');
+    assert.ok(coordinator, `${spec.templateId}: consensus-coordinator missing`);
+    const trigger = coordinator.triggers?.find((candidate) => candidate.topic === spec.triggerTopic);
+    const script = trigger?.logic?.script;
+    assert.ok(script, `${spec.templateId}: coordinator trigger logic missing`);
+    const hook = coordinator.hooks?.onComplete;
+    assert.ok(hook, `${spec.templateId}: coordinator onComplete missing`);
+    return { coordinator, script, hook };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : undefined;
+}
+async function runScenario(spec, cluster, context, allApproved) {
+    const { ledger, messageBus, logicEngine } = simulationRuntime.createSimulationRuntime(cluster);
+    (0, two_stage_inputs_1.publishScenarioInputs)(spec, cluster, messageBus);
+    const gateOpen = logicEngine.evaluate(context.script, { id: 'consensus-coordinator', cluster_id: cluster.id }, { topic: spec.triggerTopic });
+    if (!gateOpen) {
+        ledger.close();
+        return { ok: false, error: spec.gateFailure };
+    }
+    const simulationAgent = (0, simulation_agent_1.createSimulationAgent)({
+        agentConfig: context.coordinator,
+        cluster,
+        messageBus,
+    });
+    const triggeringMessage = messageBus.findLast({
+        cluster_id: cluster.id,
+        topic: spec.triggerTopic,
+    });
+    try {
+        await simulationAgentRuntime.executeHook({
+            hook: context.hook,
+            agent: simulationAgent,
+            message: triggeringMessage,
+            result: {
+                output: JSON.stringify({ allApproved, summary: allApproved ? 'ok' : 'nope' }),
+                success: true,
+                taskId: 'sim-task',
+            },
+            messageBus,
+            cluster,
+        });
+    }
+    catch (error) {
+        ledger.close();
+        return {
+            ok: false,
+            error: `${spec.templateId}: onComplete failed: ${errorMessage(error)}`,
+        };
+    }
+    const messages = {
+        passed: spec.passTopic
+            ? messageBus.findLast({ cluster_id: cluster.id, topic: spec.passTopic })
+            : null,
+        validationResult: messageBus.findLast({
+            cluster_id: cluster.id,
+            topic: 'VALIDATION_RESULT',
+        }),
+    };
+    ledger.close();
+    return (0, two_stage_results_1.evaluateScenarioMessages)(spec, allApproved, messages);
+}
+async function simulateValidationStage(spec, config) {
+    const cluster = {
+        id: spec.clusterId,
+        agents: config.agents.map((agent) => ({ id: agent.id, role: agent.role })),
+    };
+    const context = resolveCoordinator(spec, config);
+    const failures = [];
+    for (const allApproved of [true, false]) {
+        const result = await runScenario(spec, cluster, context, allApproved);
+        if (result.ok === false)
+            failures.push(result.error);
+    }
+    return failures;
+}

package/src/template-validation/two-stage-scenario.ts

@@ -0,0 +1,120 @@
+import assert = require('node:assert');
+import simulationRuntime = require('./simulation-runtime');
+import simulationAgentRuntime = require('./simulation-agent-runtime');
+import { createSimulationAgent } from './simulation-agent';
+import { publishScenarioInputs } from './two-stage-inputs';
+import { evaluateScenarioMessages } from './two-stage-results';
+import type {
+  ScenarioOutcome,
+  ValidationAgentConfig,
+  ValidationCluster,
+  ValidationStageSpec,
+  ValidationTemplateConfig,
+} from './two-stage-contracts';
+
+interface CoordinatorContext {
+  coordinator: ValidationAgentConfig;
+  script: string;
+  hook: unknown;
+}
+
+function resolveCoordinator(
+  spec: ValidationStageSpec,
+  config: ValidationTemplateConfig
+): CoordinatorContext {
+  const coordinator = config.agents.find((agent) => agent.id === 'consensus-coordinator');
+  assert.ok(coordinator, `${spec.templateId}: consensus-coordinator missing`);
+
+  const trigger = coordinator.triggers?.find((candidate) => candidate.topic === spec.triggerTopic);
+  const script = trigger?.logic?.script;
+  assert.ok(script, `${spec.templateId}: coordinator trigger logic missing`);
+
+  const hook = coordinator.hooks?.onComplete;
+  assert.ok(hook, `${spec.templateId}: coordinator onComplete missing`);
+  return { coordinator, script, hook };
+}
+
+function errorMessage(error: unknown): string | undefined {
+  return error instanceof Error ? error.message : undefined;
+}
+
+async function runScenario(
+  spec: ValidationStageSpec,
+  cluster: ValidationCluster,
+  context: CoordinatorContext,
+  allApproved: boolean
+): Promise<ScenarioOutcome> {
+  const { ledger, messageBus, logicEngine } = simulationRuntime.createSimulationRuntime(cluster);
+  publishScenarioInputs(spec, cluster, messageBus);
+
+  const gateOpen = logicEngine.evaluate(
+    context.script,
+    { id: 'consensus-coordinator', cluster_id: cluster.id },
+    { topic: spec.triggerTopic }
+  );
+  if (!gateOpen) {
+    ledger.close();
+    return { ok: false, error: spec.gateFailure };
+  }
+
+  const simulationAgent = createSimulationAgent({
+    agentConfig: context.coordinator,
+    cluster,
+    messageBus,
+  });
+  const triggeringMessage = messageBus.findLast({
+    cluster_id: cluster.id,
+    topic: spec.triggerTopic,
+  });
+
+  try {
+    await simulationAgentRuntime.executeHook({
+      hook: context.hook,
+      agent: simulationAgent,
+      message: triggeringMessage,
+      result: {
+        output: JSON.stringify({ allApproved, summary: allApproved ? 'ok' : 'nope' }),
+        success: true,
+        taskId: 'sim-task',
+      },
+      messageBus,
+      cluster,
+    });
+  } catch (error) {
+    ledger.close();
+    return {
+      ok: false,
+      error: `${spec.templateId}: onComplete failed: ${errorMessage(error)}`,
+    };
+  }
+
+  const messages = {
+    passed: spec.passTopic
+      ? messageBus.findLast({ cluster_id: cluster.id, topic: spec.passTopic })
+      : null,
+    validationResult: messageBus.findLast({
+      cluster_id: cluster.id,
+      topic: 'VALIDATION_RESULT',
+    }),
+  };
+  ledger.close();
+  return evaluateScenarioMessages(spec, allApproved, messages);
+}
+
+export async function simulateValidationStage(
+  spec: ValidationStageSpec,
+  config: ValidationTemplateConfig
+): Promise<string[]> {
+  const cluster: ValidationCluster = {
+    id: spec.clusterId,
+    agents: config.agents.map((agent) => ({ id: agent.id, role: agent.role })),
+  };
+  const context = resolveCoordinator(spec, config);
+  const failures: string[] = [];
+
+  for (const allApproved of [true, false]) {
+    const result = await runScenario(spec, cluster, context, allApproved);
+    if (result.ok === false) failures.push(result.error);
+  }
+  return failures;
+}