chainlesschain 0.166.20 → 0.166.22

package/src/lib/evolution/agent-evolution-runtime-composition.js

@@ -18,11 +18,17 @@ import {
   createEvolutionLedgerFileBackend,
 } from "./evolution-ledger-file-backend.js";
 import { EvolutionRunLedgerAdapter } from "./evolution-run-ledger-adapter.js";
+import { EvolutionWorkbenchMetricsLedgerAdapter } from "./evolution-workbench-metrics-ledger-adapter.js";
+import { captureSkillOutcomeSourceCatalogAuthority } from "./skill-outcome-source-catalog-authority.js";
 import {
   captureAgentEvolutionIngress,
   createAgentEvolutionIngress,
 } from "./agent-evolution-ingress.js";
-import { sealAgentEvolutionRuntimeComposition } from "./agent-evolution-runtime-composition-brand.js";
+import {
+  captureAgentEvolutionRuntimeComposition,
+  sealAgentSkillOutcomeIndex,
+  sealAgentEvolutionRuntimeComposition,
+} from "./agent-evolution-runtime-composition-brand.js";
 
 export {
   AGENT_EVOLUTION_RUNTIME_COMPOSITION_SCHEMA,
@@ -46,6 +52,9 @@ const ARTIFACT_AUTHORITY_KEYS = new Set([
   "envelopeSigner",
   "envelopeVerifier",
 ]);
+const SKILL_OUTCOME_SOURCE_KEYS = new Set(["composition", "skillName"]);
+const SKILL_OUTCOME_CATALOG_ENTRY_KEYS = new Set(["runId", "skillNames"]);
+const MAX_SKILL_OUTCOME_SOURCES = 128;
 
 function exactRecord(value, keys, label) {
   if (
@@ -346,6 +355,27 @@ export function createAgentEvolutionRuntimeComposition({
     ledgerArtifactResolver,
     now: clock,
   });
+  const skillOutcomeReaders = new Map();
+  const createSkillOutcomeReader = Object.freeze((skillNameInput) => {
+    const skillName = identifier(skillNameInput, "skillName");
+    const cached = skillOutcomeReaders.get(skillName);
+    if (cached) return cached;
+    const reader = new EvolutionWorkbenchMetricsLedgerAdapter({
+      descriptor: {
+        tenantId,
+        artifactTenantId: tenantId,
+        evolutionRunId: runId,
+        skillName,
+        audience,
+        purpose: "evolution-ledger",
+      },
+      artifactPorts,
+      ledger: backend.ledger,
+      ledgerArtifactResolver,
+    }).createOutcomeReader();
+    skillOutcomeReaders.set(skillName, reader);
+    return reader;
+  });
   const evolutionIngress = createAgentEvolutionIngress({
     evidenceAdapter,
     runAdapter,
@@ -361,9 +391,143 @@ export function createAgentEvolutionRuntimeComposition({
     tenantId,
     runId,
     evolutionIngress,
+    createSkillOutcomeReader,
     loadRun: Object.freeze(() => runAdapter.load()),
     ledgerDescriptor: backend.descriptor,
     storage,
   });
   return composition;
 }
+
+export function assembleAgentSkillOutcomeIndex({ sources } = {}) {
+  if (
+    !Array.isArray(sources) ||
+    utilTypes.isProxy(sources) ||
+    sources.length < 1 ||
+    sources.length > MAX_SKILL_OUTCOME_SOURCES
+  ) {
+    throw new TypeError("Skill outcome index sources are invalid or unbounded");
+  }
+  let tenantId = null;
+  const sourceIds = new Set();
+  const readers = sources.map((input, index) => {
+    const source = exactRecord(
+      input,
+      SKILL_OUTCOME_SOURCE_KEYS,
+      `sources[${index}]`,
+    );
+    const composition = captureAgentEvolutionRuntimeComposition(
+      source.composition,
+    );
+    const skillName = identifier(
+      source.skillName,
+      `sources[${index}].skillName`,
+    );
+    if (tenantId === null) tenantId = composition.tenantId;
+    if (composition.tenantId !== tenantId) {
+      throw new Error("Skill outcome index sources crossed a tenant boundary");
+    }
+    const sourceId = `${composition.runId}\0${skillName}`;
+    if (sourceIds.has(sourceId)) {
+      throw new Error("Skill outcome index sources contain a duplicate");
+    }
+    sourceIds.add(sourceId);
+    if (typeof composition.createSkillOutcomeReader !== "function") {
+      throw new TypeError(
+        "Agent evolution composition lacks an outcome reader",
+      );
+    }
+    return composition.createSkillOutcomeReader(skillName);
+  });
+  return sealAgentSkillOutcomeIndex({
+    tenantId,
+    readers: Object.freeze(readers),
+  });
+}
+
+export async function assembleAgentSkillOutcomeIndexFromCatalog({
+  tenantId: tenantIdInput,
+  catalogAuthority: catalogAuthorityInput,
+  openComposition,
+} = {}) {
+  const tenantId = identifier(tenantIdInput, "tenantId");
+  const catalogAuthority = captureSkillOutcomeSourceCatalogAuthority(
+    catalogAuthorityInput,
+  );
+  if (
+    typeof openComposition !== "function" ||
+    utilTypes.isProxy(openComposition)
+  ) {
+    throw new TypeError("Skill outcome composition opener is invalid");
+  }
+  const loaded = await catalogAuthority.loadCatalog();
+  if (
+    loaded?.authenticated !== true ||
+    loaded.durable !== true ||
+    loaded.tenantId !== tenantId ||
+    !Array.isArray(loaded.entries)
+  ) {
+    throw new Error("Skill outcome source catalog authority is invalid");
+  }
+  const catalog = loaded.entries;
+  const runIds = new Set();
+  let sourceCount = 0;
+  const normalizedCatalog = catalog.map((input, index) => {
+    const entry = exactRecord(
+      input,
+      SKILL_OUTCOME_CATALOG_ENTRY_KEYS,
+      `catalog[${index}]`,
+    );
+    const runId = identifier(entry.runId, `catalog[${index}].runId`);
+    if (runIds.has(runId)) {
+      throw new TypeError(
+        "Skill outcome source catalog contains a duplicate run",
+      );
+    }
+    runIds.add(runId);
+    if (
+      !Array.isArray(entry.skillNames) ||
+      utilTypes.isProxy(entry.skillNames) ||
+      entry.skillNames.length < 1 ||
+      entry.skillNames.length > MAX_SKILL_OUTCOME_SOURCES
+    ) {
+      throw new TypeError(
+        `catalog[${index}].skillNames is invalid or unbounded`,
+      );
+    }
+    const skillNames = entry.skillNames.map((skillName, skillIndex) =>
+      identifier(skillName, `catalog[${index}].skillNames[${skillIndex}]`),
+    );
+    if (new Set(skillNames).size !== skillNames.length) {
+      throw new TypeError(
+        "Skill outcome source catalog contains a duplicate Skill",
+      );
+    }
+    sourceCount += skillNames.length;
+    if (sourceCount > MAX_SKILL_OUTCOME_SOURCES) {
+      throw new TypeError(
+        "Skill outcome source catalog is invalid or unbounded",
+      );
+    }
+    return Object.freeze({ runId, skillNames: Object.freeze(skillNames) });
+  });
+  const sources = [];
+  for (const entry of normalizedCatalog) {
+    const context = Object.freeze({ tenantId, runId: entry.runId });
+    const composition = captureAgentEvolutionRuntimeComposition(
+      await openComposition(context),
+    );
+    if (
+      composition.tenantId !== tenantId ||
+      composition.runId !== entry.runId
+    ) {
+      throw new TypeError(
+        "Skill outcome catalog opener returned an unbound composition",
+      );
+    }
+    for (const skillName of entry.skillNames) {
+      sources.push(Object.freeze({ composition, skillName }));
+    }
+  }
+  return assembleAgentSkillOutcomeIndex({ sources });
+}