@the-open-engine/zeroshot 6.38.1 → 6.39.0

package/src/task-runner.ts

@@ -0,0 +1,28 @@
+interface TaskRunnerOptions {
+  agentId: string;
+  model: string;
+  provider?: string;
+  modelSpec?: object;
+  outputFormat?: string;
+  jsonSchema?: object;
+  cwd?: string;
+  isolation?: boolean;
+}
+
+interface TaskRunnerResult {
+  success: boolean;
+  output: string;
+  error: string | null;
+  taskId?: string;
+}
+
+/**
+ * TaskRunner - Strategy Pattern interface for executing provider tasks.
+ */
+class TaskRunner {
+  run(_context: string, _options: TaskRunnerOptions): Promise<TaskRunnerResult> {
+    throw new Error('TaskRunner.run() not implemented');
+  }
+}
+
+export = TaskRunner;

package/src/task-startup-error.js

@@ -1,68 +1,83 @@
+"use strict";
 const TASK_STARTUP_ERROR_PREFIX = 'ZEROSHOT_TASK_STARTUP_ERROR:';
 const SUPPORTED_STARTUP_ERROR_CODES = new Set(['unsupported-capability']);
-
+function hasTaskStartupErrorFields(value) {
+    return value !== null && (typeof value === 'object' || typeof value === 'function');
+}
+function isTaskStartupErrorCode(value) {
+    return typeof value === 'string' && SUPPORTED_STARTUP_ERROR_CODES.has(value);
+}
+function isOptionalString(value) {
+    return value === undefined || typeof value === 'string';
+}
+function isSerializedTaskStartupError(value) {
+    return Boolean(hasTaskStartupErrorFields(value) &&
+        value.version === 1 &&
+        isTaskStartupErrorCode(value.code) &&
+        value.permanent === true &&
+        typeof value.message === 'string' &&
+        value.message.length > 0 &&
+        isOptionalString(value.provider) &&
+        isOptionalString(value.capability));
+}
 function createUnsupportedProviderCapabilityError(provider, capability, message) {
-  const error = new Error(message);
-  error.name = 'UnsupportedProviderCapabilityError';
-  error.code = 'unsupported-capability';
-  error.permanent = true;
-  error.provider = provider;
-  error.capability = capability;
-  return error;
+    const error = new Error(message);
+    error.name = 'UnsupportedProviderCapabilityError';
+    const metadata = {
+        code: 'unsupported-capability',
+        permanent: true,
+        provider,
+        capability,
+    };
+    return Object.assign(error, metadata);
 }
-
 function serializeTaskStartupError(error) {
-  if (
-    !SUPPORTED_STARTUP_ERROR_CODES.has(error?.code) ||
-    error?.permanent !== true
-  ) {
-    return null;
-  }
-  const payload = {
-    version: 1,
-    code: error.code,
-    permanent: true,
-    message: String(error.message || error.code),
-  };
-  if (typeof error.provider === 'string') payload.provider = error.provider;
-  if (typeof error.capability === 'string') payload.capability = error.capability;
-  return `${TASK_STARTUP_ERROR_PREFIX}${JSON.stringify(payload)}`;
+    if (!hasTaskStartupErrorFields(error) ||
+        !isTaskStartupErrorCode(error.code) ||
+        error.permanent !== true) {
+        return null;
+    }
+    const payload = {
+        version: 1,
+        code: error.code,
+        permanent: true,
+        message: String(error.message || error.code),
+    };
+    if (typeof error.provider === 'string')
+        payload.provider = error.provider;
+    if (typeof error.capability === 'string')
+        payload.capability = error.capability;
+    return `${TASK_STARTUP_ERROR_PREFIX}${JSON.stringify(payload)}`;
 }
-
 function parseTaskStartupError(stderr) {
-  const lines = String(stderr || '').split(/\r?\n/);
-  let line = lines.pop();
-  while (line === '' && lines.length > 0) line = lines.pop();
-  if (!line?.startsWith(TASK_STARTUP_ERROR_PREFIX)) return null;
-
-  let parsed;
-  try {
-    parsed = JSON.parse(line.slice(TASK_STARTUP_ERROR_PREFIX.length));
-  } catch {
-    return null;
-  }
-  if (
-    parsed?.version !== 1 ||
-    !SUPPORTED_STARTUP_ERROR_CODES.has(parsed.code) ||
-    parsed.permanent !== true ||
-    typeof parsed.message !== 'string' ||
-    parsed.message.length === 0 ||
-    (parsed.provider !== undefined && typeof parsed.provider !== 'string') ||
-    (parsed.capability !== undefined && typeof parsed.capability !== 'string')
-  ) {
-    return null;
-  }
-  const error = new Error(parsed.message);
-  error.code = parsed.code;
-  error.permanent = true;
-  if (parsed.provider !== undefined) error.provider = parsed.provider;
-  if (parsed.capability !== undefined) error.capability = parsed.capability;
-  return error;
+    const lines = String(stderr || '').split(/\r?\n/);
+    let line = lines.pop();
+    while (line === '' && lines.length > 0)
+        line = lines.pop();
+    if (!line?.startsWith(TASK_STARTUP_ERROR_PREFIX))
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(line.slice(TASK_STARTUP_ERROR_PREFIX.length));
+    }
+    catch {
+        return null;
+    }
+    if (!isSerializedTaskStartupError(parsed))
+        return null;
+    const metadata = {
+        code: parsed.code,
+        permanent: true,
+    };
+    if (parsed.provider !== undefined)
+        metadata.provider = parsed.provider;
+    if (parsed.capability !== undefined)
+        metadata.capability = parsed.capability;
+    return Object.assign(new Error(parsed.message), metadata);
 }
-
 module.exports = {
-  TASK_STARTUP_ERROR_PREFIX,
-  createUnsupportedProviderCapabilityError,
-  parseTaskStartupError,
-  serializeTaskStartupError,
+    TASK_STARTUP_ERROR_PREFIX,
+    createUnsupportedProviderCapabilityError,
+    parseTaskStartupError,
+    serializeTaskStartupError,
 };

package/src/task-startup-error.ts

@@ -0,0 +1,126 @@
+const TASK_STARTUP_ERROR_PREFIX = 'ZEROSHOT_TASK_STARTUP_ERROR:';
+const SUPPORTED_STARTUP_ERROR_CODES = new Set<string>(['unsupported-capability']);
+
+type TaskStartupErrorCode = 'unsupported-capability';
+
+interface TaskStartupErrorFields {
+  version?: unknown;
+  code?: unknown;
+  permanent?: unknown;
+  message?: unknown;
+  provider?: unknown;
+  capability?: unknown;
+}
+
+interface TaskStartupError extends Error {
+  code: TaskStartupErrorCode;
+  permanent: true;
+  provider?: string;
+  capability?: string;
+}
+
+interface TaskStartupErrorMetadata {
+  code: TaskStartupErrorCode;
+  permanent: true;
+  provider?: string;
+  capability?: string;
+}
+
+interface SerializedTaskStartupError {
+  version: 1;
+  code: TaskStartupErrorCode;
+  permanent: true;
+  message: string;
+  provider?: string;
+  capability?: string;
+}
+
+function hasTaskStartupErrorFields(value: unknown): value is TaskStartupErrorFields {
+  return value !== null && (typeof value === 'object' || typeof value === 'function');
+}
+
+function isTaskStartupErrorCode(value: unknown): value is TaskStartupErrorCode {
+  return typeof value === 'string' && SUPPORTED_STARTUP_ERROR_CODES.has(value);
+}
+
+function isOptionalString(value: unknown): value is string | undefined {
+  return value === undefined || typeof value === 'string';
+}
+
+function isSerializedTaskStartupError(value: unknown): value is SerializedTaskStartupError {
+  return Boolean(
+    hasTaskStartupErrorFields(value) &&
+    value.version === 1 &&
+    isTaskStartupErrorCode(value.code) &&
+    value.permanent === true &&
+    typeof value.message === 'string' &&
+    value.message.length > 0 &&
+    isOptionalString(value.provider) &&
+    isOptionalString(value.capability)
+  );
+}
+
+function createUnsupportedProviderCapabilityError(
+  provider: string,
+  capability: string,
+  message: string
+): TaskStartupError {
+  const error = new Error(message);
+  error.name = 'UnsupportedProviderCapabilityError';
+  const metadata: TaskStartupErrorMetadata = {
+    code: 'unsupported-capability',
+    permanent: true,
+    provider,
+    capability,
+  };
+  return Object.assign(error, metadata);
+}
+
+function serializeTaskStartupError(error: unknown): string | null {
+  if (
+    !hasTaskStartupErrorFields(error) ||
+    !isTaskStartupErrorCode(error.code) ||
+    error.permanent !== true
+  ) {
+    return null;
+  }
+  const payload: SerializedTaskStartupError = {
+    version: 1,
+    code: error.code,
+    permanent: true,
+    message: String(error.message || error.code),
+  };
+  if (typeof error.provider === 'string') payload.provider = error.provider;
+  if (typeof error.capability === 'string') payload.capability = error.capability;
+  return `${TASK_STARTUP_ERROR_PREFIX}${JSON.stringify(payload)}`;
+}
+
+function parseTaskStartupError(stderr: unknown): TaskStartupError | null {
+  const lines = String(stderr || '').split(/\r?\n/);
+  let line = lines.pop();
+  while (line === '' && lines.length > 0) line = lines.pop();
+  if (!line?.startsWith(TASK_STARTUP_ERROR_PREFIX)) return null;
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(line.slice(TASK_STARTUP_ERROR_PREFIX.length));
+  } catch {
+    return null;
+  }
+  if (!isSerializedTaskStartupError(parsed)) return null;
+
+  const metadata: TaskStartupErrorMetadata = {
+    code: parsed.code,
+    permanent: true,
+  };
+  if (parsed.provider !== undefined) metadata.provider = parsed.provider;
+  if (parsed.capability !== undefined) metadata.capability = parsed.capability;
+  return Object.assign(new Error(parsed.message), metadata);
+}
+
+export = {
+  TASK_STARTUP_ERROR_PREFIX,
+  createUnsupportedProviderCapabilityError,
+  parseTaskStartupError,
+  serializeTaskStartupError,
+};

package/src/template-validation/consensus-gate-contracts.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/template-validation/consensus-gate-contracts.ts

@@ -0,0 +1,70 @@
+export type StageStartTopic = 'IMPLEMENTATION_READY' | 'QUICK_VALIDATION_PASSED';
+export type TopicProducers = Map<string, Set<string>>;
+export type ConsensusProducers = [string, string, ...string[]];
+
+export interface RequiredQualityGate {
+  id: string;
+  scope?: string;
+}
+
+interface CompletionHook {
+  action?: string;
+  config?: { topic?: unknown };
+}
+
+export interface TemplateTrigger {
+  topic?: string;
+  action?: string;
+  logic?: { script?: string };
+}
+
+export interface TemplateAgent {
+  id: string;
+  role?: string;
+  requiredQualityGates?: RequiredQualityGate[];
+  triggers?: TemplateTrigger[];
+  hooks?: { onComplete?: CompletionHook };
+}
+
+export interface TemplateConfig {
+  agents?: TemplateAgent[];
+}
+
+export interface ConsensusSimulationOptions {
+  allowExternalTopics?: string[];
+}
+
+interface SimulationClusterAgent {
+  id: string;
+  role: string | undefined;
+  requiredQualityGates: RequiredQualityGate[];
+}
+
+export interface SimulationCluster {
+  id: string;
+  agents: SimulationClusterAgent[];
+}
+
+export interface SimulationContext {
+  agents: TemplateAgent[];
+  producersByTopic: TopicProducers;
+  allowExternalTopics: string[];
+  cluster: SimulationCluster;
+}
+
+export interface ScenarioContext {
+  agentId: string;
+  cluster: SimulationCluster;
+  topic: string;
+  script: string;
+  requiredQualityGates: RequiredQualityGate[];
+  producers: ConsensusProducers;
+  producersByTopic: TopicProducers;
+  requiredStageTopics: StageStartTopic[];
+  allowExternalTopics: string[];
+}
+
+export type ConsensusScenario =
+  | { failure: string }
+  | { failure: null }
+  | { failure: null; context: ScenarioContext };

package/src/template-validation/consensus-gate-scenarios.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDuplicateProducerScenario = checkDuplicateProducerScenario;
+exports.checkDistinctProducerScenario = checkDistinctProducerScenario;
+const simulationRuntime = require("./simulation-runtime");
+const consensus_gate_stage_1 = require("./consensus-gate-stage");
+function evaluateScenario({ agentId, cluster, topic, script, requiredQualityGates, producers, producersByTopic, requiredStageTopics, allowExternalTopics, publishMessages, }) {
+    const { ledger, messageBus, logicEngine } = simulationRuntime.createSimulationRuntime(cluster);
+    (0, consensus_gate_stage_1.publishStageStartMessages)({
+        messageBus,
+        clusterId: cluster.id,
+        producersByTopic,
+        requiredStageTopics,
+        allowExternalTopics,
+    });
+    publishMessages(messageBus, producers, cluster.id);
+    const result = logicEngine.evaluate(script, { id: agentId, cluster_id: cluster.id, requiredQualityGates }, { topic });
+    ledger.close();
+    return result;
+}
+function getPassingQualityGate(requiredGate) {
+    const scope = requiredGate.scope || 'template-sim';
+    return {
+        id: requiredGate.id,
+        status: 'PASS',
+        scope,
+        completedAt: Date.now(),
+        evidence: {
+            command: `quality-check --scope ${scope}`,
+            exitCode: 0,
+            output: 'template simulation quality pass',
+        },
+    };
+}
+function getApprovedResultData(context) {
+    const data = { approved: true };
+    const requiredQualityGates = Array.isArray(context.requiredQualityGates)
+        ? context.requiredQualityGates
+        : [];
+    if (context.agentId === 'git-pusher' &&
+        context.topic === 'VALIDATION_RESULT' &&
+        requiredQualityGates.length > 0) {
+        data.qualityGates = requiredQualityGates.map(getPassingQualityGate);
+    }
+    return data;
+}
+function checkDuplicateProducerScenario(context) {
+    return evaluateScenario({
+        ...context,
+        publishMessages(messageBus, producers, clusterId) {
+            const message = {
+                cluster_id: clusterId,
+                topic: context.topic,
+                sender: producers[0],
+                content: { data: getApprovedResultData(context) },
+            };
+            messageBus.publish(message);
+            messageBus.publish(message);
+        },
+    });
+}
+function checkDistinctProducerScenario(context) {
+    return evaluateScenario({
+        ...context,
+        publishMessages(messageBus, producers, clusterId) {
+            for (const producer of producers) {
+                messageBus.publish({
+                    cluster_id: clusterId,
+                    topic: context.topic,
+                    sender: producer,
+                    content: { data: getApprovedResultData(context) },
+                });
+            }
+        },
+    });
+}

package/src/template-validation/consensus-gate-scenarios.ts

@@ -0,0 +1,130 @@
+import simulationRuntime = require('./simulation-runtime');
+import { publishStageStartMessages } from './consensus-gate-stage';
+import type {
+  ConsensusProducers,
+  RequiredQualityGate,
+  ScenarioContext,
+} from './consensus-gate-contracts';
+
+interface SimulationMessageBus {
+  publish(message: unknown): unknown;
+}
+
+interface EvaluateScenarioOptions extends ScenarioContext {
+  publishMessages(
+    messageBus: SimulationMessageBus,
+    producers: ConsensusProducers,
+    clusterId: string
+  ): void;
+}
+
+interface PassingQualityGate {
+  id: string;
+  status: 'PASS';
+  scope: string;
+  completedAt: number;
+  evidence: {
+    command: string;
+    exitCode: 0;
+    output: string;
+  };
+}
+
+interface ApprovedResultData {
+  approved: true;
+  qualityGates?: PassingQualityGate[];
+}
+
+function evaluateScenario({
+  agentId,
+  cluster,
+  topic,
+  script,
+  requiredQualityGates,
+  producers,
+  producersByTopic,
+  requiredStageTopics,
+  allowExternalTopics,
+  publishMessages,
+}: EvaluateScenarioOptions): boolean {
+  const { ledger, messageBus, logicEngine } = simulationRuntime.createSimulationRuntime(cluster);
+
+  publishStageStartMessages({
+    messageBus,
+    clusterId: cluster.id,
+    producersByTopic,
+    requiredStageTopics,
+    allowExternalTopics,
+  });
+  publishMessages(messageBus, producers, cluster.id);
+
+  const result = logicEngine.evaluate(
+    script,
+    { id: agentId, cluster_id: cluster.id, requiredQualityGates },
+    { topic }
+  );
+  ledger.close();
+  return result;
+}
+
+function getPassingQualityGate(requiredGate: RequiredQualityGate): PassingQualityGate {
+  const scope = requiredGate.scope || 'template-sim';
+  return {
+    id: requiredGate.id,
+    status: 'PASS',
+    scope,
+    completedAt: Date.now(),
+    evidence: {
+      command: `quality-check --scope ${scope}`,
+      exitCode: 0,
+      output: 'template simulation quality pass',
+    },
+  };
+}
+
+function getApprovedResultData(context: ScenarioContext): ApprovedResultData {
+  const data: ApprovedResultData = { approved: true };
+  const requiredQualityGates = Array.isArray(context.requiredQualityGates)
+    ? context.requiredQualityGates
+    : [];
+  if (
+    context.agentId === 'git-pusher' &&
+    context.topic === 'VALIDATION_RESULT' &&
+    requiredQualityGates.length > 0
+  ) {
+    data.qualityGates = requiredQualityGates.map(getPassingQualityGate);
+  }
+  return data;
+}
+
+export function checkDuplicateProducerScenario(context: ScenarioContext): boolean {
+  return evaluateScenario({
+    ...context,
+    publishMessages(messageBus, producers, clusterId) {
+      const message = {
+        cluster_id: clusterId,
+        topic: context.topic,
+        sender: producers[0],
+        content: { data: getApprovedResultData(context) },
+      };
+      messageBus.publish(message);
+      messageBus.publish(message);
+    },
+  });
+}
+
+export function checkDistinctProducerScenario(context: ScenarioContext): boolean {
+  return evaluateScenario({
+    ...context,
+    publishMessages(messageBus, producers, clusterId) {
+      for (const producer of producers) {
+        messageBus.publish({
+          cluster_id: clusterId,
+          topic: context.topic,
+          sender: producer,
+          content: { data: getApprovedResultData(context) },
+        });
+      }
+    },
+  });
+}

package/src/template-validation/consensus-gate-stage.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRequiredStageTopics = getRequiredStageTopics;
+exports.publishStageStartMessages = publishStageStartMessages;
+const STAGE_START_TOPICS = [
+    'IMPLEMENTATION_READY',
+    'QUICK_VALIDATION_PASSED',
+];
+const EXTERNAL_STAGE_SENDERS = {
+    IMPLEMENTATION_READY: 'worker',
+    QUICK_VALIDATION_PASSED: 'consensus-coordinator',
+};
+function scriptReferencesTopic(logicScript, topic) {
+    return logicScript.includes(`topic: '${topic}'`) || logicScript.includes(`topic: "${topic}"`);
+}
+function getRequiredStageTopics(logicScript) {
+    return STAGE_START_TOPICS.filter((topic) => scriptReferencesTopic(logicScript, topic));
+}
+function publishStageStartMessages({ messageBus, clusterId, producersByTopic, requiredStageTopics, allowExternalTopics, }) {
+    let timestamp = Date.now();
+    for (const topic of requiredStageTopics) {
+        const producers = Array.from(producersByTopic.get(topic) || []);
+        const sender = producers.at(0) ??
+            (allowExternalTopics.includes(topic) ? EXTERNAL_STAGE_SENDERS[topic] : null);
+        if (!sender)
+            continue;
+        messageBus.publish({
+            cluster_id: clusterId,
+            topic,
+            sender,
+            timestamp: timestamp++,
+        });
+    }
+}

package/src/template-validation/consensus-gate-stage.ts

@@ -0,0 +1,56 @@
+import type { StageStartTopic, TopicProducers } from './consensus-gate-contracts';
+
+const STAGE_START_TOPICS = [
+  'IMPLEMENTATION_READY',
+  'QUICK_VALIDATION_PASSED',
+] as const satisfies readonly StageStartTopic[];
+
+const EXTERNAL_STAGE_SENDERS: Readonly<Record<StageStartTopic, string>> = {
+  IMPLEMENTATION_READY: 'worker',
+  QUICK_VALIDATION_PASSED: 'consensus-coordinator',
+};
+
+interface SimulationMessageBus {
+  publish(message: unknown): unknown;
+}
+
+interface PublishStageStartOptions {
+  messageBus: SimulationMessageBus;
+  clusterId: string;
+  producersByTopic: TopicProducers;
+  requiredStageTopics: StageStartTopic[];
+  allowExternalTopics: string[];
+}
+
+function scriptReferencesTopic(logicScript: string, topic: string): boolean {
+  return logicScript.includes(`topic: '${topic}'`) || logicScript.includes(`topic: "${topic}"`);
+}
+
+export function getRequiredStageTopics(logicScript: string): StageStartTopic[] {
+  return STAGE_START_TOPICS.filter((topic) => scriptReferencesTopic(logicScript, topic));
+}
+
+export function publishStageStartMessages({
+  messageBus,
+  clusterId,
+  producersByTopic,
+  requiredStageTopics,
+  allowExternalTopics,
+}: PublishStageStartOptions): void {
+  let timestamp = Date.now();
+
+  for (const topic of requiredStageTopics) {
+    const producers = Array.from(producersByTopic.get(topic) || []);
+    const sender =
+      producers.at(0) ??
+      (allowExternalTopics.includes(topic) ? EXTERNAL_STAGE_SENDERS[topic] : null);
+    if (!sender) continue;
+
+    messageBus.publish({
+      cluster_id: clusterId,
+      topic,
+      sender,
+      timestamp: timestamp++,
+    });
+  }
+}

package/src/template-validation/random-topology-contracts.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });