@inf-monkeys-tech/monkeys 1.0.18 → 1.0.19

package/lib/esm/index.mjs

@@ -7626,7 +7626,7 @@ var ApplicationRunSchema = z7.object({
   contract: z7.literal("ApplicationRun"),
   runId: ContractIdentifierSchema,
   definitionRef: EntityRefSchema,
-  runtimeLedgerRef: EntityRefSchema,
+  runtimeLedgerRef: EntityRefSchema.optional(),
   requestId: ContractIdentifierSchema,
   actorRef: EntityRefSchema,
   status: z7.enum(["PENDING", "RUNNING", "COMPLETED", "FAILED", "CANCELLED", "EXPIRED"]),
@@ -7636,7 +7636,43 @@ var ApplicationRunSchema = z7.object({
   completedAt: IsoDateTimeSchema.optional(),
   expiresAt: IsoDateTimeSchema.optional(),
   metadata: JsonObjectSchema.default({})
-}).strict();
+}).strict().superRefine((run, context) => {
+  if (run.definitionRef.kind !== "workflow-definition") {
+    context.addIssue({
+      code: "custom",
+      path: ["definitionRef", "kind"],
+      message: "definitionRef must reference a workflow-definition."
+    });
+  }
+  if (run.runtimeLedgerRef && run.runtimeLedgerRef.kind !== "workflow-run") {
+    context.addIssue({
+      code: "custom",
+      path: ["runtimeLedgerRef", "kind"],
+      message: "runtimeLedgerRef must reference a workflow-run."
+    });
+  }
+  if ((run.status === "RUNNING" || run.status === "COMPLETED" || run.status === "CANCELLED") && !run.runtimeLedgerRef) {
+    context.addIssue({
+      code: "custom",
+      path: ["runtimeLedgerRef"],
+      message: `${run.status} ApplicationRun requires runtimeLedgerRef.`
+    });
+  }
+  if (run.status === "RUNNING" && !run.startedAt) {
+    context.addIssue({
+      code: "custom",
+      path: ["startedAt"],
+      message: "RUNNING ApplicationRun requires startedAt."
+    });
+  }
+  if (["COMPLETED", "FAILED", "CANCELLED", "EXPIRED"].includes(run.status) && !run.completedAt) {
+    context.addIssue({
+      code: "custom",
+      path: ["completedAt"],
+      message: `Terminal ApplicationRun status ${run.status} requires completedAt.`
+    });
+  }
+});
 var ExpiringAccessGrantSchema = z7.object({
   contract: z7.literal("ExpiringAccessGrant"),
   grantId: ContractIdentifierSchema,
@@ -11517,6 +11553,181 @@ var WorkflowDefinitionSchema = z14.object({
   if (definition.revision.kind === "release" && definition.metadata.version !== definition.revision.recordVersion) context.addIssue({ code: "custom", path: ["revision", "recordVersion"], message: "Release recordVersion must equal metadata.version." });
 });
 
+// src/contracts/workflow-runtime.ts
+import { z as z15 } from "zod";
+var WorkflowCatalogEntrySchema = z15.object({
+  contract: z15.literal("WorkflowCatalogEntry"),
+  workflowId: ContractIdentifierSchema,
+  teamId: ContractIdentifierSchema,
+  creatorRef: EntityRefSchema,
+  currentDefinitionRef: EntityRefSchema,
+  lifecycle: z15.enum(["ACTIVE", "DELETED"]),
+  asset: z15.object({
+    preset: z15.boolean(),
+    marketplacePublished: z15.boolean(),
+    publishConfig: JsonObjectSchema.optional(),
+    sort: z15.number().int(),
+    forkFromRef: EntityRefSchema.optional(),
+    notAuthorized: z15.boolean()
+  }).strict(),
+  createdAt: IsoDateTimeSchema,
+  updatedAt: IsoDateTimeSchema,
+  deletedAt: IsoDateTimeSchema.optional()
+}).strict().superRefine((entry, context) => {
+  if (entry.creatorRef.kind !== "user" && entry.creatorRef.kind !== "service") {
+    context.addIssue({
+      code: "custom",
+      path: ["creatorRef", "kind"],
+      message: "creatorRef must reference a user or service."
+    });
+  }
+  if (entry.currentDefinitionRef.kind !== "workflow-definition") {
+    context.addIssue({
+      code: "custom",
+      path: ["currentDefinitionRef", "kind"],
+      message: "currentDefinitionRef must reference a workflow-definition."
+    });
+  }
+  if (entry.lifecycle === "DELETED" && !entry.deletedAt) {
+    context.addIssue({
+      code: "custom",
+      path: ["deletedAt"],
+      message: "Deleted workflow catalog entries require deletedAt."
+    });
+  }
+  if (entry.lifecycle === "ACTIVE" && entry.deletedAt) {
+    context.addIssue({
+      code: "custom",
+      path: ["deletedAt"],
+      message: "Active workflow catalog entries cannot declare deletedAt."
+    });
+  }
+});
+var WorkflowPublicationSchema = z15.object({
+  contract: z15.literal("WorkflowPublication"),
+  publicationId: ContractIdentifierSchema,
+  definitionRef: EntityRefSchema,
+  runtimeDefinitionRef: EntityRefSchema,
+  sourceHash: Sha256Schema,
+  compiledHash: Sha256Schema,
+  status: z15.enum(["PENDING", "PUBLISHED", "FAILED", "RETIRED"]),
+  publisherRef: EntityRefSchema,
+  publishedAt: IsoDateTimeSchema.optional(),
+  failureReason: z15.string().trim().min(1).optional()
+}).strict().superRefine((publication, context) => {
+  if (publication.definitionRef.kind !== "workflow-definition") {
+    context.addIssue({
+      code: "custom",
+      path: ["definitionRef", "kind"],
+      message: "definitionRef must reference a workflow-definition."
+    });
+  }
+  if (publication.runtimeDefinitionRef.kind !== "conductor-workflow-definition") {
+    context.addIssue({
+      code: "custom",
+      path: ["runtimeDefinitionRef", "kind"],
+      message: "runtimeDefinitionRef must reference a conductor-workflow-definition."
+    });
+  }
+  if (publication.status === "PUBLISHED" && !publication.publishedAt) {
+    context.addIssue({
+      code: "custom",
+      path: ["publishedAt"],
+      message: "Published workflow publications require publishedAt."
+    });
+  }
+  if (publication.status === "FAILED" && !publication.failureReason) {
+    context.addIssue({
+      code: "custom",
+      path: ["failureReason"],
+      message: "Failed workflow publications require failureReason."
+    });
+  }
+});
+var WorkflowCompletionCommitSchema = z15.object({
+  contract: z15.literal("WorkflowCompletionCommit"),
+  commitId: ContractIdentifierSchema,
+  run: ApplicationRunSchema,
+  outputs: z15.array(OutputRecordSchema),
+  artifacts: z15.array(ArtifactManifestSchema),
+  lineage: LineageRecordSchema,
+  completedAt: IsoDateTimeSchema
+}).strict().superRefine((commit, context) => {
+  const expectedRunId = commit.run.runId;
+  const referencesRun = (value) => value.runRef.kind === "application-run" && value.runRef.id === expectedRunId;
+  commit.outputs.forEach((output, index) => {
+    if (!referencesRun(output)) {
+      context.addIssue({
+        code: "custom",
+        path: ["outputs", index, "runRef"],
+        message: "Every output must reference the committed ApplicationRun."
+      });
+    }
+  });
+  commit.artifacts.forEach((artifact, index) => {
+    if (!referencesRun(artifact)) {
+      context.addIssue({
+        code: "custom",
+        path: ["artifacts", index, "runRef"],
+        message: "Every artifact must reference the committed ApplicationRun."
+      });
+    }
+  });
+  if (commit.lineage.subjectRef.kind !== "application-run" || commit.lineage.subjectRef.id !== expectedRunId) {
+    context.addIssue({
+      code: "custom",
+      path: ["lineage", "subjectRef"],
+      message: "Completion lineage must use the committed ApplicationRun as its subject."
+    });
+  }
+  const outputIds = new Set(commit.outputs.map((output) => output.outputId));
+  commit.artifacts.forEach((artifact, index) => {
+    if (artifact.outputRef.kind !== "workflow-output" || !outputIds.has(artifact.outputRef.id)) {
+      context.addIssue({
+        code: "custom",
+        path: ["artifacts", index, "outputRef"],
+        message: "Artifact outputRef must reference an output in the same commit."
+      });
+    }
+  });
+});
+var WorkflowCompletionReceiptSchema = z15.object({
+  contract: z15.literal("WorkflowCompletionReceipt"),
+  commitId: ContractIdentifierSchema,
+  runRef: EntityRefSchema,
+  outputRefs: z15.array(EntityRefSchema),
+  artifactRefs: z15.array(EntityRefSchema),
+  contentHash: Sha256Schema,
+  committedAt: IsoDateTimeSchema,
+  idempotentReplay: z15.boolean()
+}).strict().superRefine((receipt, context) => {
+  if (receipt.runRef.kind !== "application-run") {
+    context.addIssue({
+      code: "custom",
+      path: ["runRef", "kind"],
+      message: "runRef must reference an application-run."
+    });
+  }
+  receipt.outputRefs.forEach((ref2, index) => {
+    if (ref2.kind !== "workflow-output") {
+      context.addIssue({
+        code: "custom",
+        path: ["outputRefs", index, "kind"],
+        message: "outputRefs must reference workflow-output records."
+      });
+    }
+  });
+  receipt.artifactRefs.forEach((ref2, index) => {
+    if (ref2.kind !== "artifact") {
+      context.addIssue({
+        code: "custom",
+        path: ["artifactRefs", index, "kind"],
+        message: "artifactRefs must reference artifacts."
+      });
+    }
+  });
+});
+
 // src/schemas/index.ts
 var canonicalContractSchemas = {
   "agent-session-command": AgentSessionCommandSchema,
@@ -11575,7 +11786,11 @@ var canonicalContractSchemas = {
   "trend-metric-snapshot": TrendMetricSnapshotSchema,
   "trend-source-record": TrendSourceRecordSchema,
   "view-provider-descriptor": ViewProviderDescriptorSchema,
-  "workflow-definition": WorkflowDefinitionSchema
+  "workflow-definition": WorkflowDefinitionSchema,
+  "workflow-catalog-entry": WorkflowCatalogEntrySchema,
+  "workflow-publication": WorkflowPublicationSchema,
+  "workflow-completion-commit": WorkflowCompletionCommitSchema,
+  "workflow-completion-receipt": WorkflowCompletionReceiptSchema
 };
 
 // src/runtime/capability-registry.ts
@@ -12951,12 +13166,16 @@ export {
   ValidationIssueType,
   ValidationReasonType,
   ViewProviderDescriptorSchema,
+  WorkflowCatalogEntrySchema,
+  WorkflowCompletionCommitSchema,
+  WorkflowCompletionReceiptSchema,
   WorkflowDefinitionSchema,
   WorkflowEdgeSchema,
   WorkflowNodeSchema,
   WorkflowOutputBindingSchema,
   WorkflowParameterSchema,
   WorkflowParameterTypeSchema,
+  WorkflowPublicationSchema,
   WorkflowTriggerSchema,
   WorkflowTriggerType,
   WorkflowValidationIssueSchema,