@heybeaux/lattice-adapter-parliament 0.2.1

package/dist/index.d.ts

@@ -0,0 +1,138 @@
+import { TieredCircuitBreakerConfig, TieredCircuitBreaker, ConsensusReducerConfig, StateContract } from '@heybeaux/lattice-core';
+
+/**
+ * @heybeaux/lattice-adapter-parliament
+ *
+ * Wraps Parliament's multi-model deliberations with Lattice State Contracts,
+ * Circuit Breakers, and ConsensusReducer for coordinated, auditable synthesis.
+ */
+
+/**
+ * A Parliament model participant.
+ */
+interface ParliamentModel {
+    /** Unique identifier for the model (e.g., 'claude-opus-4-6') */
+    id: string;
+    /** Role in the deliberation (proposer, expander, pragmatist, etc.) */
+    role: string;
+    /** Whether this model is adversarial (skeptic, devils-advocate) */
+    isAdversarial?: boolean;
+}
+/**
+ * Configuration for wrapping a Parliament model.
+ */
+interface ParliamentModelConfig {
+    /** Circuit breaker configuration (defaults: L1+L2 for cooperative, L1 for adversarial) */
+    breaker?: TieredCircuitBreakerConfig;
+    /** Whether to redact sensitive data before validation (default: true) */
+    redactForValidation?: boolean;
+    /** Whether to run in shadow mode (validate but don't block) (default: true) */
+    shadowMode?: boolean;
+}
+/**
+ * Configuration for the Parliament integration.
+ */
+interface ParliamentConfig {
+    /** Audit log path (optional — if provided, all deliberations are logged) */
+    auditLogPath?: string;
+    /** ConsensusReducer configuration */
+    reducer?: ConsensusReducerConfig;
+    /** Per-model configurations (optional) */
+    modelConfigs?: Record<string, ParliamentModelConfig>;
+    /** Default model configuration (applied to all models without specific config) */
+    defaultModelConfig?: ParliamentModelConfig;
+}
+/**
+ * Result from wrapping a Parliament deliberation.
+ */
+interface ParliamentDeliberationResult {
+    /** State Contracts for each model response */
+    modelContracts: StateContract[];
+    /** The consensus/synthesis output */
+    consensus: unknown;
+    /** Conflicts detected between models */
+    conflicts: Array<{
+        field: string;
+        values: Array<{
+            agentId: string;
+            value: unknown;
+        }>;
+        resolution: string;
+    }>;
+    /** Agreement ratio (0-1) */
+    agreementRatio: number;
+    /** Whether consensus was reached */
+    consensusReached: boolean;
+    /** Total deliberation time in milliseconds */
+    totalDurationMs: number;
+    /** Trace ID for the deliberation */
+    traceId: string;
+}
+/**
+ * Wrap a Parliament model call with Lattice State Contracts and Circuit Breakers.
+ *
+ * The wrapped model:
+ * 1. Executes the original model call
+ * 2. Creates a State Contract with the model's response
+ * 3. Validates through Circuit Breaker (L1+L2 for cooperative, L1 for adversarial)
+ * 4. Returns the State Contract
+ *
+ * @param model - The Parliament model definition
+ * @param modelCall - The model call function: (prompt) => Promise<response>
+ * @param config - Configuration for this model
+ * @returns A wrapped function that returns StateContract instead of raw response
+ */
+declare function wrapParliamentModel(model: ParliamentModel, modelCall: (prompt: string) => Promise<unknown>, config?: ParliamentModelConfig): (prompt: string, traceId?: string) => Promise<{
+    contract: StateContract;
+    passed: boolean;
+}>;
+/**
+ * A pre-configured circuit breaker for Parliament model responses.
+ *
+ * Cooperative models use L1+L2 validation.
+ * Adversarial models use L1 only (they're supposed to be contrarian).
+ */
+declare class ParliamentCircuitBreaker {
+    private breakers;
+    constructor(models: ParliamentModel[], configs?: Record<string, TieredCircuitBreakerConfig>);
+    get(agentId: string): TieredCircuitBreaker | undefined;
+}
+/**
+ * A ConsensusReducer configured for Parliament synthesis.
+ *
+ * Detects disagreements between model responses, computes agreement
+ * ratios, and flags conflicts for the synthesizer to resolve.
+ */
+declare class ParliamentReducer {
+    private reducer;
+    constructor(config?: ConsensusReducerConfig);
+    /**
+     * Reduce multiple model responses into a consensus.
+     */
+    reduce(contracts: StateContract[], traceId?: string): {
+        consensus: unknown;
+        conflicts: Array<{
+            field: string;
+            values: Array<{
+                agentId: string;
+                value: unknown;
+            }>;
+            resolution: string;
+        }>;
+        agreementRatio: number;
+        consensusReached: boolean;
+        reducedContract: StateContract;
+    };
+}
+/**
+ * Run a full Parliament deliberation with Lattice coordination.
+ *
+ * @param topic - The deliberation topic
+ * @param models - Array of Parliament models to run
+ * @param modelCalls - Map of model ID to model call function
+ * @param config - Parliament configuration
+ * @returns ParliamentDeliberationResult
+ */
+declare function runParliamentDeliberation(topic: string, models: ParliamentModel[], modelCalls: Map<string, (prompt: string) => Promise<unknown>>, config?: ParliamentConfig): Promise<ParliamentDeliberationResult>;
+
+export { ParliamentCircuitBreaker, type ParliamentConfig, type ParliamentDeliberationResult, type ParliamentModel, type ParliamentModelConfig, ParliamentReducer, runParliamentDeliberation, wrapParliamentModel };

package/dist/index.js

@@ -0,0 +1,140 @@
+// src/index.ts
+import {
+  createContract,
+  TieredCircuitBreaker,
+  ConsensusReducer,
+  ComplianceAuditLog,
+  wrapAgent,
+  HandoffFailure
+} from "@heybeaux/lattice-core";
+function wrapParliamentModel(model, modelCall, config) {
+  const shadowMode = config?.shadowMode ?? true;
+  const breakerConfig = config?.breaker ?? (model.isAdversarial ? { tier: "L1" } : { tier: "L1+L2", l2Threshold: 0.7 });
+  const wrapped = wrapAgent(
+    async (prompt) => modelCall(prompt),
+    {
+      id: model.id,
+      breaker: breakerConfig
+    }
+  );
+  return async (prompt, traceId) => {
+    try {
+      const contract = await wrapped(prompt, traceId);
+      return { contract, passed: true };
+    } catch (error) {
+      if (error instanceof HandoffFailure) {
+        if (shadowMode) {
+          return { contract: error.contract, passed: false };
+        }
+        throw error;
+      }
+      throw error;
+    }
+  };
+}
+var ParliamentCircuitBreaker = class {
+  breakers = /* @__PURE__ */ new Map();
+  constructor(models, configs) {
+    for (const model of models) {
+      const config = configs?.[model.id] ?? (model.isAdversarial ? { tier: "L1" } : { tier: "L1+L2", l2Threshold: 0.7 });
+      this.breakers.set(model.id, new TieredCircuitBreaker(config));
+    }
+  }
+  get(agentId) {
+    return this.breakers.get(agentId);
+  }
+};
+var ParliamentReducer = class {
+  reducer;
+  constructor(config) {
+    this.reducer = new ConsensusReducer({
+      conflictStrategy: config?.conflictStrategy ?? "flag-only",
+      minAgreementRatio: config?.minAgreementRatio ?? 0.6,
+      consensusFields: config?.consensusFields ?? ["mainPoint", "supportingArguments", "conclusion"],
+      includeIndividualOutputs: config?.includeIndividualOutputs ?? true
+    });
+  }
+  /**
+   * Reduce multiple model responses into a consensus.
+   */
+  reduce(contracts, traceId) {
+    const result = this.reducer.reduce(contracts);
+    const reducedContract = this.reducer.createReducedContract(result, contracts, "parliament-reducer", null);
+    return {
+      consensus: result.output,
+      conflicts: result.conflicts,
+      agreementRatio: result.agreementRatio,
+      consensusReached: result.consensus,
+      reducedContract
+    };
+  }
+};
+async function runParliamentDeliberation(topic, models, modelCalls, config) {
+  const start = Date.now();
+  const traceId = createContract({
+    fromAgent: "parliament-topic",
+    inputs: { topic },
+    outputs: {},
+    budget: { tokensUsed: 0, callsMade: 0, wallClockMs: 0 }
+  }).traceId;
+  let auditLog;
+  if (config?.auditLogPath) {
+    auditLog = new ComplianceAuditLog({ logPath: config.auditLogPath });
+  }
+  const modelContracts = [];
+  const modelResults = [];
+  for (const model of models) {
+    const modelCall = modelCalls.get(model.id);
+    if (!modelCall) {
+      continue;
+    }
+    const modelConfig = config?.modelConfigs?.[model.id] ?? config?.defaultModelConfig;
+    const wrappedModel = wrapParliamentModel(model, modelCall, modelConfig);
+    const result = await wrappedModel(topic, traceId);
+    modelContracts.push(result.contract);
+    modelResults.push({ model, result });
+    if (auditLog) {
+      auditLog.append({
+        agentId: model.id,
+        modelRole: model.role,
+        isAdversarial: model.isAdversarial ?? false,
+        passed: result.passed,
+        traceId,
+        contractId: result.contract.id
+      });
+    }
+  }
+  const reducer = new ParliamentReducer(config?.reducer);
+  const reduction = reducer.reduce(modelContracts, traceId);
+  if (auditLog) {
+    auditLog.append({
+      type: "consensus",
+      traceId,
+      agreementRatio: reduction.agreementRatio,
+      consensusReached: reduction.consensusReached,
+      conflictCount: reduction.conflicts.length,
+      modelCount: modelContracts.length,
+      validModelCount: modelResults.filter((r) => r.result.passed).length
+    });
+  }
+  return {
+    modelContracts,
+    consensus: reduction.consensus,
+    conflicts: reduction.conflicts.map((c) => ({
+      field: c.field,
+      values: c.values.map((v) => ({ agentId: v.agentId, value: v.value })),
+      resolution: c.resolution
+    })),
+    agreementRatio: reduction.agreementRatio,
+    consensusReached: reduction.consensusReached,
+    totalDurationMs: Date.now() - start,
+    traceId
+  };
+}
+export {
+  ParliamentCircuitBreaker,
+  ParliamentReducer,
+  runParliamentDeliberation,
+  wrapParliamentModel
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * @heybeaux/lattice-adapter-parliament\n *\n * Wraps Parliament's multi-model deliberations with Lattice State Contracts,\n * Circuit Breakers, and ConsensusReducer for coordinated, auditable synthesis.\n */\n\nimport {\n  createContract,\n  TieredCircuitBreaker,\n  ConsensusReducer,\n  ComplianceAuditLog,\n  wrapAgent,\n  HandoffFailure,\n  EventEmitter,\n  globalEmitter,\n  redactContract,\n} from '@heybeaux/lattice-core';\nimport type {\n  TieredCircuitBreakerConfig,\n  ConsensusReducerConfig,\n  StateContract,\n} from '@heybeaux/lattice-core';\n\n// ─── Types ────────────────────────────────────────────────\n\n/**\n * A Parliament model participant.\n */\nexport interface ParliamentModel {\n  /** Unique identifier for the model (e.g., 'claude-opus-4-6') */\n  id: string;\n  /** Role in the deliberation (proposer, expander, pragmatist, etc.) */\n  role: string;\n  /** Whether this model is adversarial (skeptic, devils-advocate) */\n  isAdversarial?: boolean;\n}\n\n/**\n * Configuration for wrapping a Parliament model.\n */\nexport interface ParliamentModelConfig {\n  /** Circuit breaker configuration (defaults: L1+L2 for cooperative, L1 for adversarial) */\n  breaker?: TieredCircuitBreakerConfig;\n  /** Whether to redact sensitive data before validation (default: true) */\n  redactForValidation?: boolean;\n  /** Whether to run in shadow mode (validate but don't block) (default: true) */\n  shadowMode?: boolean;\n}\n\n/**\n * Configuration for the Parliament integration.\n */\nexport interface ParliamentConfig {\n  /** Audit log path (optional — if provided, all deliberations are logged) */\n  auditLogPath?: string;\n  /** ConsensusReducer configuration */\n  reducer?: ConsensusReducerConfig;\n  /** Per-model configurations (optional) */\n  modelConfigs?: Record<string, ParliamentModelConfig>;\n  /** Default model configuration (applied to all models without specific config) */\n  defaultModelConfig?: ParliamentModelConfig;\n}\n\n/**\n * Result from wrapping a Parliament deliberation.\n */\nexport interface ParliamentDeliberationResult {\n  /** State Contracts for each model response */\n  modelContracts: StateContract[];\n  /** The consensus/synthesis output */\n  consensus: unknown;\n  /** Conflicts detected between models */\n  conflicts: Array<{\n    field: string;\n    values: Array<{ agentId: string; value: unknown }>;\n    resolution: string;\n  }>;\n  /** Agreement ratio (0-1) */\n  agreementRatio: number;\n  /** Whether consensus was reached */\n  consensusReached: boolean;\n  /** Total deliberation time in milliseconds */\n  totalDurationMs: number;\n  /** Trace ID for the deliberation */\n  traceId: string;\n}\n\n// ─── wrapParliamentModel ──────────────────────────────────\n\n/**\n * Wrap a Parliament model call with Lattice State Contracts and Circuit Breakers.\n *\n * The wrapped model:\n * 1. Executes the original model call\n * 2. Creates a State Contract with the model's response\n * 3. Validates through Circuit Breaker (L1+L2 for cooperative, L1 for adversarial)\n * 4. Returns the State Contract\n *\n * @param model - The Parliament model definition\n * @param modelCall - The model call function: (prompt) => Promise<response>\n * @param config - Configuration for this model\n * @returns A wrapped function that returns StateContract instead of raw response\n */\nexport function wrapParliamentModel(\n  model: ParliamentModel,\n  modelCall: (prompt: string) => Promise<unknown>,\n  config?: ParliamentModelConfig,\n) {\n  const shadowMode = config?.shadowMode ?? true;\n  const breakerConfig = config?.breaker ?? (\n    model.isAdversarial\n      ? { tier: 'L1' as const }\n      : { tier: 'L1+L2' as const, l2Threshold: 0.7 }\n  );\n\n  const wrapped = wrapAgent(\n    async (prompt: string) => modelCall(prompt),\n    {\n      id: model.id,\n      breaker: breakerConfig,\n    },\n  );\n\n  return async (\n    prompt: string,\n    traceId?: string,\n  ): Promise<{ contract: StateContract; passed: boolean }> => {\n    try {\n      const contract = await wrapped(prompt, traceId);\n      return { contract, passed: true };\n    } catch (error) {\n      if (error instanceof HandoffFailure) {\n        // In shadow mode, return the failed contract without blocking\n        if (shadowMode) {\n          return { contract: error.contract, passed: false };\n        }\n        throw error;\n      }\n      throw error;\n    }\n  };\n}\n\n// ─── ParliamentCircuitBreaker ─────────────────────────────\n\n/**\n * A pre-configured circuit breaker for Parliament model responses.\n *\n * Cooperative models use L1+L2 validation.\n * Adversarial models use L1 only (they're supposed to be contrarian).\n */\nexport class ParliamentCircuitBreaker {\n  private breakers: Map<string, TieredCircuitBreaker> = new Map();\n\n  constructor(models: ParliamentModel[], configs?: Record<string, TieredCircuitBreakerConfig>) {\n    for (const model of models) {\n      const config = configs?.[model.id] ?? (\n        model.isAdversarial\n          ? { tier: 'L1' as const }\n          : { tier: 'L1+L2' as const, l2Threshold: 0.7 }\n      );\n      this.breakers.set(model.id, new TieredCircuitBreaker(config));\n    }\n  }\n\n  get(agentId: string): TieredCircuitBreaker | undefined {\n    return this.breakers.get(agentId);\n  }\n}\n\n// ─── ParliamentReducer ────────────────────────────────────\n\n/**\n * A ConsensusReducer configured for Parliament synthesis.\n *\n * Detects disagreements between model responses, computes agreement\n * ratios, and flags conflicts for the synthesizer to resolve.\n */\nexport class ParliamentReducer {\n  private reducer: ConsensusReducer;\n\n  constructor(config?: ConsensusReducerConfig) {\n    this.reducer = new ConsensusReducer({\n      conflictStrategy: config?.conflictStrategy ?? 'flag-only',\n      minAgreementRatio: config?.minAgreementRatio ?? 0.6,\n      consensusFields: config?.consensusFields ?? ['mainPoint', 'supportingArguments', 'conclusion'],\n      includeIndividualOutputs: config?.includeIndividualOutputs ?? true,\n    });\n  }\n\n  /**\n   * Reduce multiple model responses into a consensus.\n   */\n  reduce(\n    contracts: StateContract[],\n    traceId?: string,\n  ): {\n    consensus: unknown;\n    conflicts: Array<{\n      field: string;\n      values: Array<{ agentId: string; value: unknown }>;\n      resolution: string;\n    }>;\n    agreementRatio: number;\n    consensusReached: boolean;\n    reducedContract: StateContract;\n  } {\n    const result = this.reducer.reduce(contracts);\n    const reducedContract = this.reducer.createReducedContract(result, contracts, 'parliament-reducer', null);\n\n    return {\n      consensus: result.output,\n      conflicts: result.conflicts,\n      agreementRatio: result.agreementRatio,\n      consensusReached: result.consensus,\n      reducedContract,\n    };\n  }\n}\n\n// ─── ParliamentDeliberation ───────────────────────────────\n\n/**\n * Run a full Parliament deliberation with Lattice coordination.\n *\n * @param topic - The deliberation topic\n * @param models - Array of Parliament models to run\n * @param modelCalls - Map of model ID to model call function\n * @param config - Parliament configuration\n * @returns ParliamentDeliberationResult\n */\nexport async function runParliamentDeliberation(\n  topic: string,\n  models: ParliamentModel[],\n  modelCalls: Map<string, (prompt: string) => Promise<unknown>>,\n  config?: ParliamentConfig,\n): Promise<ParliamentDeliberationResult> {\n  const start = Date.now();\n  const traceId = createContract({\n    fromAgent: 'parliament-topic',\n    inputs: { topic },\n    outputs: {},\n    budget: { tokensUsed: 0, callsMade: 0, wallClockMs: 0 },\n  }).traceId;\n\n  // Set up audit log if configured\n  let auditLog: ComplianceAuditLog | undefined;\n  if (config?.auditLogPath) {\n    auditLog = new ComplianceAuditLog({ logPath: config.auditLogPath });\n  }\n\n  // Run each model\n  const modelContracts: StateContract[] = [];\n  const modelResults: Array<{ model: ParliamentModel; result: { contract: StateContract; passed: boolean } }> = [];\n\n  for (const model of models) {\n    const modelCall = modelCalls.get(model.id);\n    if (!modelCall) {\n      continue;\n    }\n\n    const modelConfig = config?.modelConfigs?.[model.id] ?? config?.defaultModelConfig;\n    const wrappedModel = wrapParliamentModel(model, modelCall, modelConfig);\n    const result = await wrappedModel(topic, traceId);\n\n    modelContracts.push(result.contract);\n    modelResults.push({ model, result });\n\n    // Log to audit if configured\n    if (auditLog) {\n      auditLog.append({\n        agentId: model.id,\n        modelRole: model.role,\n        isAdversarial: model.isAdversarial ?? false,\n        passed: result.passed,\n        traceId,\n        contractId: result.contract.id,\n      });\n    }\n  }\n\n  // Run consensus reduction\n  const reducer = new ParliamentReducer(config?.reducer);\n  const reduction = reducer.reduce(modelContracts, traceId);\n\n  // Log consensus to audit\n  if (auditLog) {\n    auditLog.append({\n      type: 'consensus',\n      traceId,\n      agreementRatio: reduction.agreementRatio,\n      consensusReached: reduction.consensusReached,\n      conflictCount: reduction.conflicts.length,\n      modelCount: modelContracts.length,\n      validModelCount: modelResults.filter(r => r.result.passed).length,\n    });\n  }\n\n  return {\n    modelContracts,\n    consensus: reduction.consensus,\n    conflicts: reduction.conflicts.map(c => ({\n      field: c.field,\n      values: c.values.map(v => ({ agentId: v.agentId, value: v.value })),\n      resolution: c.resolution,\n    })),\n    agreementRatio: reduction.agreementRatio,\n    consensusReached: reduction.consensusReached,\n    totalDurationMs: Date.now() - start,\n    traceId,\n  };\n}\n\n\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@heybeaux/lattice-adapter-parliament",
+  "version": "0.2.1",
+  "description": "Lattice coordination layer for Parliament — wraps multi-model deliberations with State Contracts and Circuit Breakers",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --sourcemap",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "lattice",
+    "parliament",
+    "ai-agents",
+    "multi-model",
+    "coordination",
+    "state-contract",
+    "circuit-breaker"
+  ],
+  "author": "heybeaux <https://heybeaux.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/heybeaux/lattice.git",
+    "directory": "packages/adapter-parliament"
+  },
+  "dependencies": {
+    "@heybeaux/lattice-core": "workspace:*"
+  },
+  "peerDependencies": {
+    "zod": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.3",
+    "zod": "^3.23.0"
+  }
+}