agent-contracts 0.6.1 → 0.7.0

package/dist/index.d.ts

@@ -571,6 +571,7 @@ declare const RenderTargetSchema: z.ZodObject<{
 type RenderTarget = z.infer<typeof RenderTargetSchema>;
 declare const AgentContractsConfigSchema: z.ZodObject<{
     dsl: z.ZodString;
+    vars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     renders: z.ZodArray<z.ZodObject<{
         template: z.ZodString;
         context: z.ZodEnum<{
@@ -599,6 +600,7 @@ interface ResolvedRenderTarget {
 }
 interface ResolvedConfig {
     dsl: string;
+    vars?: Record<string, string>;
     renders: ResolvedRenderTarget[];
     configDir: string;
 }
@@ -640,6 +642,12 @@ interface PerArtifactContext {
     artifact: Artifact & {
         id: string;
     };
+    relatedTools: Dsl["tools"];
+    relatedValidations: Dsl["validations"];
+    producerAgents: Dsl["agents"];
+    consumerAgents: Dsl["agents"];
+    editorAgents: Dsl["agents"];
+    createdInWorkflows: string[];
     dsl: Dsl;
     [key: string]: unknown;
 }
@@ -647,6 +655,9 @@ interface PerToolContext {
     tool: Tool & {
         id: string;
     };
+    invokableAgents: Dsl["agents"];
+    inputArtifactDetails: Dsl["artifacts"];
+    outputArtifactDetails: Dsl["artifacts"];
     dsl: Dsl;
     [key: string]: unknown;
 }
@@ -671,6 +682,13 @@ interface PerWorkflowContext {
     workflow: Workflow & {
         id: string;
     };
+    relatedAgents: Dsl["agents"];
+    relatedTasks: Array<(Task & Record<string, unknown>) & {
+        id: string;
+    }>;
+    relatedTools: Dsl["tools"];
+    relatedArtifacts: Dsl["artifacts"];
+    relatedValidations: Dsl["validations"];
     dsl: Dsl;
     [key: string]: unknown;
 }

package/dist/index.js

@@ -60196,12 +60196,76 @@ function buildTaskContext(dsl, taskId) {
 function buildArtifactContext(dsl, artifactId) {
   const artifactDef = dsl.artifacts[artifactId];
   const artifact = { ...artifactDef, id: artifactId };
-  return { artifact, dsl };
+  const relatedTools = {};
+  for (const [id, tool] of Object.entries(dsl.tools)) {
+    if (tool.input_artifacts.includes(artifactId) || tool.output_artifacts.includes(artifactId)) {
+      relatedTools[id] = tool;
+    }
+  }
+  const relatedValidations = {};
+  for (const [id, val] of Object.entries(dsl.validations)) {
+    if (val.target_artifact === artifactId) {
+      relatedValidations[id] = val;
+    }
+  }
+  const pickAgents = (ids) => {
+    const result = {};
+    for (const id of ids) {
+      if (dsl.agents[id]) result[id] = dsl.agents[id];
+    }
+    return result;
+  };
+  const producerAgents = pickAgents(artifactDef.producers);
+  const consumerAgents = pickAgents(artifactDef.consumers);
+  const editorAgents = pickAgents(artifactDef.editors);
+  const createdInWorkflows = [];
+  for (const [_taskId, task] of Object.entries(dsl.tasks)) {
+    if (createdInWorkflows.includes(task.workflow)) continue;
+    const targetAgent = dsl.agents[task.target_agent];
+    if (targetAgent?.can_write_artifacts.includes(artifactId)) {
+      createdInWorkflows.push(task.workflow);
+      continue;
+    }
+    const steps = task.execution_steps ?? [];
+    for (const step of steps) {
+      if (step["produces_artifact"] === artifactId) {
+        createdInWorkflows.push(task.workflow);
+        break;
+      }
+    }
+  }
+  return {
+    artifact,
+    relatedTools,
+    relatedValidations,
+    producerAgents,
+    consumerAgents,
+    editorAgents,
+    createdInWorkflows,
+    dsl
+  };
 }
 function buildToolContext(dsl, toolId) {
   const toolDef = dsl.tools[toolId];
   const tool = { ...toolDef, id: toolId };
-  return { tool, dsl };
+  const invokableAgents = {};
+  for (const agentId of toolDef.invokable_by) {
+    if (dsl.agents[agentId]) invokableAgents[agentId] = dsl.agents[agentId];
+  }
+  const pickArtifacts = (ids) => {
+    const result = {};
+    for (const id of ids) {
+      if (dsl.artifacts[id]) result[id] = dsl.artifacts[id];
+    }
+    return result;
+  };
+  return {
+    tool,
+    invokableAgents,
+    inputArtifactDetails: pickArtifacts(toolDef.input_artifacts),
+    outputArtifactDetails: pickArtifacts(toolDef.output_artifacts),
+    dsl
+  };
 }
 function buildValidationContext(dsl, validationId) {
   const validationDef = dsl.validations[validationId];
@@ -60219,7 +60283,76 @@ function buildHandoffTypeContext(dsl, handoffTypeId) {
 function buildWorkflowContext(dsl, workflowId) {
   const wfDef = dsl.workflow[workflowId];
   const workflow = { ...wfDef, id: workflowId };
-  return { workflow, dsl };
+  const relatedTasks = Object.entries(dsl.tasks).filter(([, t3]) => t3.workflow === workflowId).map(([id, t3]) => ({ ...t3, id }));
+  const agentIds = /* @__PURE__ */ new Set();
+  for (const task of relatedTasks) {
+    agentIds.add(task.target_agent);
+    for (const fromAgent of task.allowed_from_agents) {
+      agentIds.add(fromAgent);
+    }
+  }
+  for (const step of wfDef.steps) {
+    if (step.type === "handoff" && step.from_agent) {
+      agentIds.add(step.from_agent);
+    }
+    if (step.type === "validation") {
+      const val = dsl.validations[step.validation];
+      if (val?.executor_type === "agent" && val.executor) {
+        agentIds.add(val.executor);
+      }
+    }
+  }
+  const relatedAgents = {};
+  for (const id of agentIds) {
+    if (dsl.agents[id]) relatedAgents[id] = dsl.agents[id];
+  }
+  const toolIds = /* @__PURE__ */ new Set();
+  for (const id of agentIds) {
+    const agent = dsl.agents[id];
+    if (agent) {
+      for (const toolId of agent.can_execute_tools) {
+        toolIds.add(toolId);
+      }
+    }
+  }
+  const relatedTools = {};
+  for (const id of toolIds) {
+    if (dsl.tools[id]) relatedTools[id] = dsl.tools[id];
+  }
+  const artifactIds = /* @__PURE__ */ new Set();
+  for (const task of relatedTasks) {
+    for (const artId of task.input_artifacts) artifactIds.add(artId);
+  }
+  for (const id of agentIds) {
+    const agent = dsl.agents[id];
+    if (agent) {
+      for (const artId of agent.can_read_artifacts) artifactIds.add(artId);
+      for (const artId of agent.can_write_artifacts) artifactIds.add(artId);
+    }
+  }
+  const relatedArtifacts = {};
+  for (const id of artifactIds) {
+    if (dsl.artifacts[id]) relatedArtifacts[id] = dsl.artifacts[id];
+  }
+  const validationIds = /* @__PURE__ */ new Set();
+  for (const step of wfDef.steps) {
+    if (step.type === "validation") {
+      validationIds.add(step.validation);
+    }
+  }
+  const relatedValidations = {};
+  for (const id of validationIds) {
+    if (dsl.validations[id]) relatedValidations[id] = dsl.validations[id];
+  }
+  return {
+    workflow,
+    relatedAgents,
+    relatedTasks,
+    relatedTools,
+    relatedArtifacts,
+    relatedValidations,
+    dsl
+  };
 }
 function buildPolicyContext(dsl, policyId) {
   const policyDef = dsl.policies[policyId];
@@ -60427,6 +60560,72 @@ function toYamlLines(obj, indent) {
 Handlebars.registerHelper("yamlBlock", (obj) => {
   return toYamlLines(obj, 0).join("\n");
 });
+Handlebars.registerHelper(
+  "join",
+  (arr, separator) => {
+    if (!Array.isArray(arr)) return "";
+    const sep = typeof separator === "string" ? separator : ", ";
+    return arr.join(sep);
+  }
+);
+Handlebars.registerHelper("contains", (arr, value) => {
+  if (!Array.isArray(arr)) return false;
+  return arr.includes(value);
+});
+Handlebars.registerHelper(
+  "groupBy",
+  (arr, key) => {
+    if (!Array.isArray(arr)) return {};
+    const result = {};
+    for (const item of arr) {
+      const k2 = String(
+        item?.[key] ?? "undefined"
+      );
+      (result[k2] ??= []).push(item);
+    }
+    return result;
+  }
+);
+Handlebars.registerHelper(
+  "keys",
+  (obj) => {
+    if (!obj || typeof obj !== "object") return [];
+    return Object.keys(obj);
+  }
+);
+Handlebars.registerHelper(
+  "values",
+  (obj) => {
+    if (!obj || typeof obj !== "object") return [];
+    return Object.values(obj);
+  }
+);
+Handlebars.registerHelper(
+  "filterByField",
+  (arr, field, value) => {
+    if (!Array.isArray(arr)) return [];
+    return arr.filter(
+      (item) => item?.[field] === value
+    );
+  }
+);
+Handlebars.registerHelper("not", (value) => !value);
+Handlebars.registerHelper("or", (...args) => {
+  const _options = args.pop();
+  return args.some((a3) => !!a3);
+});
+Handlebars.registerHelper("and", (...args) => {
+  const _options = args.pop();
+  return args.every((a3) => !!a3);
+});
+Handlebars.registerHelper("gt", (a3, b3) => a3 > b3);
+Handlebars.registerHelper("gte", (a3, b3) => a3 >= b3);
+Handlebars.registerHelper("lt", (a3, b3) => a3 < b3);
+Handlebars.registerHelper("size", (obj) => {
+  if (Array.isArray(obj)) return obj.length;
+  if (obj && typeof obj === "object") return Object.keys(obj).length;
+  return 0;
+});
 function getDslSection(dsl, context) {
   const sectionMap = {
     agent: dsl.agents,
@@ -60574,6 +60773,7 @@ var RenderTargetSchema = z14.object({
 );
 var AgentContractsConfigSchema = z14.object({
   dsl: z14.string(),
+  vars: z14.record(z14.string(), z14.string()).optional(),
   renders: z14.array(RenderTargetSchema).min(1)
 });
 
@@ -60642,6 +60842,7 @@ ${issues}`,
   const config = result.data;
   return {
     dsl: resolve4(configDir, config.dsl),
+    vars: config.vars,
     renders: config.renders.map((r3) => ({
       ...r3,
       template: resolve4(configDir, r3.template),