agent-contracts-runtime/dist/chunk-MWZXU25C.js

Runtime bridge for executing agent-contracts workflows on Agent SDKs

import {
  buildGuardrailContext
} from "./chunk-LTZA6QWC.js";
import {
  buildRegistriesFromDsl
} from "./chunk-D2QTXQB2.js";

// src/lib/bound-resolver.ts
import { readFile } from "fs/promises";
import YAML from "yaml";
function getEffectiveGuardrailIds(dsl, agentId) {
  const ids = /* @__PURE__ */ new Set();
  const agents = dsl.agents ?? {};
  const agent = agents[agentId];
  if (agent) {
    for (const ref of agent.guardrails ?? []) {
      ids.add(ref);
    }
  }
  const guardrails = dsl.guardrails ?? {};
  for (const [guardrailId, guardrail] of Object.entries(guardrails)) {
    if (guardrail.scope?.agents?.includes(agentId)) {
      ids.add(guardrailId);
    }
  }
  return ids;
}
function guardrailCheckToCommandRule(c) {
  return {
    guardrail_id: c.guardrail_id,
    pattern: c.pattern,
    action: c.action,
    message: c.message
  };
}
function guardrailCheckToFileRule(c) {
  return {
    guardrail_id: c.guardrail_id,
    pattern: c.pattern,
    action: c.action,
    message: c.message,
    ...c.exclude_glob ? { exclude_glob: c.exclude_glob } : {}
  };
}
function guardrailCheckToContentRule(c) {
  return {
    guardrail_id: c.guardrail_id,
    pattern: c.pattern,
    action: c.action,
    message: c.message,
    ...c.file_glob ? { file_glob: c.file_glob } : {},
    ...c.exclude_glob ? { exclude_glob: c.exclude_glob } : {}
  };
}
function guardrailContextToRuleData(ctx, effectiveIds) {
  const filter = (checks) => effectiveIds ? checks.filter((c) => effectiveIds.has(c.guardrail_id)) : checks;
  return {
    commandRules: filter(ctx.commandChecks).map(guardrailCheckToCommandRule),
    fileRules: filter(ctx.fileChecks).map(guardrailCheckToFileRule),
    contentRules: filter(ctx.contentChecks).map(guardrailCheckToContentRule)
  };
}
function buildPerAgentGuardrails(dsl, guardrailCtx) {
  const perAgent = /* @__PURE__ */ new Map();
  const agents = dsl.agents ?? {};
  for (const agentId of Object.keys(agents)) {
    const effectiveIds = getEffectiveGuardrailIds(dsl, agentId);
    const rules = guardrailContextToRuleData(guardrailCtx, effectiveIds);
    if (rules.commandRules.length > 0 || rules.fileRules.length > 0 || rules.contentRules.length > 0) {
      perAgent.set(agentId, rules);
    }
  }
  return perAgent;
}
function hasGuardrailRules(rules) {
  return rules.commandRules.length > 0 || rules.fileRules.length > 0 || rules.contentRules.length > 0;
}
var BoundResolver = class {
  cache = /* @__PURE__ */ new Map();
  /**
   * Resolve binding + policy in one pass. Results are cached by component id.
   */
  async resolve(opts) {
    const cached = this.cache.get(opts.id);
    if (cached) return cached;
    const diagnostics = [];
    let dsl;
    if (opts.embeddedDsl) {
      dsl = opts.embeddedDsl;
    } else if (opts.dslPath) {
      const { resolve: resolveDsl } = await import("agent-contracts");
      const result = await resolveDsl(opts.dslPath);
      dsl = result.data;
    } else {
      throw new Error("BoundResolver.resolve requires embeddedDsl or dslPath");
    }
    if (opts.artifactBinding) {
      const { resolveBound } = await import("agent-contracts");
      const boundResult = await resolveBound(dsl, {
        artifactBinding: opts.artifactBinding,
        paths: opts.paths
      });
      dsl = boundResult.data;
      for (const d of boundResult.diagnostics) {
        diagnostics.push({
          path: d.rule,
          message: d.message,
          severity: d.severity
        });
      }
    }
    let guardrailCtx = {
      commandChecks: [],
      fileChecks: [],
      contentChecks: [],
      allChecks: [],
      hasGuardrails: false
    };
    if (opts.bindingPaths && opts.bindingPaths.length > 0) {
      for (const bindingPath of opts.bindingPaths) {
        const raw = await readFile(bindingPath, "utf8");
        const binding = YAML.parse(raw);
        guardrailCtx = buildGuardrailContext(
          dsl,
          binding,
          opts.activeGuardrailPolicy
        );
      }
    }
    const perAgent = guardrailCtx.hasGuardrails ? buildPerAgentGuardrails(dsl, guardrailCtx) : /* @__PURE__ */ new Map();
    const component = {
      id: opts.id,
      dsl,
      registries: buildRegistriesFromDsl(dsl),
      guardrails: { perAgent },
      diagnostics
    };
    this.cache.set(opts.id, component);
    return component;
  }
  /** Clear cached components (e.g. for testing). */
  clearCache() {
    this.cache.clear();
  }
};
function getGuardrailRulesForAgent(component, agentId, fallbackDsl) {
  const perAgent = component.guardrails.perAgent.get(agentId);
  if (perAgent && hasGuardrailRules(perAgent)) {
    return perAgent;
  }
  if (fallbackDsl) {
    const raw = fallbackDsl._guardrailRules;
    if (raw) {
      return {
        commandRules: raw.commandRules ?? [],
        fileRules: raw.fileRules ?? [],
        contentRules: raw.contentRules ?? []
      };
    }
  }
  return void 0;
}

export {
  getEffectiveGuardrailIds,
  guardrailContextToRuleData,
  buildPerAgentGuardrails,
  BoundResolver,
  getGuardrailRulesForAgent
};
//# sourceMappingURL=chunk-MWZXU25C.js.map