@inf-monkeys-tech/monkeys 1.0.20 → 1.0.22

package/lib/esm/runtime/index.mjs

@@ -7646,7 +7646,11 @@ var AgentSessionCapabilitySchema = z5.enum([
   "diff",
   "workspaceFiles",
   "terminal",
-  "testResults"
+  "testResults",
+  "threadForking",
+  "editAndRerun",
+  "steering",
+  "summary"
 ]);
 var AgentSessionCapabilitiesSchema = z5.object({
   text: z5.boolean().default(true),
@@ -7665,7 +7669,11 @@ var AgentSessionCapabilitiesSchema = z5.object({
   diff: z5.boolean().default(false),
   workspaceFiles: z5.boolean().default(false),
   terminal: z5.boolean().default(false),
-  testResults: z5.boolean().default(false)
+  testResults: z5.boolean().default(false),
+  threadForking: z5.boolean().default(false),
+  editAndRerun: z5.boolean().default(false),
+  steering: z5.boolean().default(false),
+  summary: z5.boolean().default(false)
 }).strict();
 var AGENT_SESSION_RUNTIME_CAPABILITIES = Object.freeze({
   chatbot: AgentSessionCapabilitiesSchema.parse({ text: true, tools: true, mcp: true, skills: true, approval: true, usage: true }),
@@ -7688,7 +7696,11 @@ var AGENT_SESSION_CAPABILITY_EVIDENCE = Object.freeze({
   diff: { eventTypes: ["diff"], commandTypes: [] },
   workspaceFiles: { eventTypes: ["workspace-file"], commandTypes: [] },
   terminal: { eventTypes: ["terminal"], commandTypes: [] },
-  testResults: { eventTypes: ["test-result"], commandTypes: [] }
+  testResults: { eventTypes: ["test-result"], commandTypes: [] },
+  threadForking: { eventTypes: [], commandTypes: ["fork"] },
+  editAndRerun: { eventTypes: [], commandTypes: ["edit-and-rerun"] },
+  steering: { eventTypes: [], commandTypes: ["steer"] },
+  summary: { eventTypes: ["summary"], commandTypes: [] }
 });
 var AgentSessionSnapshotSchema = z5.object({
   mode: AgentModeSchema,
@@ -7704,11 +7716,98 @@ var AgentSessionStatusSchema = z5.enum([
   "completed",
   "failed"
 ]);
-var AgentSessionCommandTypeSchema = z5.enum(["stop", "resume", "retry", "approval"]);
+var AgentSessionTerminalStatusSchema = z5.enum(["stopped", "completed", "failed"]);
+var AgentSessionLineageSchema = z5.object({
+  forkedFromThreadId: ContractIdentifierSchema,
+  forkedFromMessageId: ContractIdentifierSchema,
+  sourceRunId: ContractIdentifierSchema
+}).strict();
+var AgentSessionContextInheritanceSchema = z5.object({
+  messages: z5.enum(["through-source-message", "exclude"]),
+  attachments: z5.enum(["inherit", "exclude"]),
+  summaries: z5.enum(["inherit", "exclude"]),
+  toolResults: z5.enum(["inherit", "exclude"]),
+  codeChanges: z5.enum(["inherit", "exclude"])
+}).strict();
+var AgentSessionActiveBranchSchema = z5.object({
+  branchId: ContractIdentifierSchema,
+  threadId: ContractIdentifierSchema,
+  sourceMessageId: ContractIdentifierSchema,
+  runId: ContractIdentifierSchema,
+  lineage: AgentSessionLineageSchema.optional(),
+  createdAt: IsoDateTimeSchema
+}).strict();
+var AgentSessionRunSchema = z5.object({
+  runId: ContractIdentifierSchema,
+  sessionId: ContractIdentifierSchema,
+  sourceMessageId: ContractIdentifierSchema,
+  status: AgentSessionStatusSchema,
+  startedAt: IsoDateTimeSchema,
+  stoppingRequestedAt: IsoDateTimeSchema.optional(),
+  stoppedAt: IsoDateTimeSchema.optional(),
+  completedAt: IsoDateTimeSchema.optional(),
+  failedAt: IsoDateTimeSchema.optional(),
+  durationMs: z5.number().nonnegative().optional()
+}).strict().superRefine((value, context) => {
+  const terminalTimestamps = [value.stoppedAt, value.completedAt, value.failedAt].filter(Boolean);
+  if (terminalTimestamps.length > 1) {
+    context.addIssue({
+      code: "custom",
+      path: ["status"],
+      message: "A run may declare only one terminal timestamp."
+    });
+  }
+  const expectedTimestamp = value.status === "stopped" ? value.stoppedAt : value.status === "completed" ? value.completedAt : value.status === "failed" ? value.failedAt : void 0;
+  if (AgentSessionTerminalStatusSchema.safeParse(value.status).success && !expectedTimestamp) {
+    context.addIssue({
+      code: "custom",
+      path: [value.status === "stopped" ? "stoppedAt" : value.status === "completed" ? "completedAt" : "failedAt"],
+      message: `Run status ${value.status} requires its matching terminal timestamp.`
+    });
+  }
+  if (!AgentSessionTerminalStatusSchema.safeParse(value.status).success && terminalTimestamps.length > 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["status"],
+      message: "A non-terminal run must not declare a terminal timestamp."
+    });
+  }
+  if ((value.status === "stopping" || value.status === "stopped") && !value.stoppingRequestedAt) {
+    context.addIssue({
+      code: "custom",
+      path: ["stoppingRequestedAt"],
+      message: `Run status ${value.status} requires stoppingRequestedAt.`
+    });
+  }
+  if (!isAgentSessionTerminalStatus(value.status) && value.durationMs !== void 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["durationMs"],
+      message: "Only a terminal run may declare durationMs."
+    });
+  }
+  if (isAgentSessionTerminalStatus(value.status) && value.durationMs === void 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["durationMs"],
+      message: `Terminal run status ${value.status} requires durationMs.`
+    });
+  }
+});
+var AgentSessionCommandTypeSchema = z5.enum([
+  "stop",
+  "resume",
+  "retry",
+  "approval",
+  "fork",
+  "edit-and-rerun",
+  "steer"
+]);
 var AgentSessionCommandHeaderSchema = z5.object({
   contract: z5.literal("AgentSessionCommand"),
   commandId: ContractIdentifierSchema,
   sessionId: ContractIdentifierSchema,
+  runId: ContractIdentifierSchema.optional(),
   idempotencyKey: ContractIdentifierSchema,
   expectedSequence: z5.number().int().min(-1),
   issuedAt: IsoDateTimeSchema
@@ -7731,10 +7830,41 @@ var AgentSessionCommandSchema = z5.discriminatedUnion("commandType", [
     approvalId: ContractIdentifierSchema,
     decision: z5.enum(["approved", "rejected"]),
     reason: z5.string().trim().min(1).optional()
+  }),
+  sessionCommand("fork", {
+    sourceThreadId: ContractIdentifierSchema,
+    sourceMessageId: ContractIdentifierSchema,
+    sourceRunId: ContractIdentifierSchema,
+    inheritance: AgentSessionContextInheritanceSchema
+  }),
+  sessionCommand("edit-and-rerun", {
+    sourceThreadId: ContractIdentifierSchema,
+    sourceMessageId: ContractIdentifierSchema,
+    sourceRunId: ContractIdentifierSchema,
+    replacementParts: z5.array(JsonValueSchema).min(1),
+    inheritance: AgentSessionContextInheritanceSchema
+  }),
+  sessionCommand("steer", {
+    targetRunId: ContractIdentifierSchema,
+    guidanceParts: z5.array(JsonValueSchema).min(1)
   })
-]);
+]).superRefine((value, context) => {
+  if (value.commandType === "steer" && value.runId !== value.payload.targetRunId) {
+    context.addIssue({
+      code: "custom",
+      path: ["payload", "targetRunId"],
+      message: "Steering targetRunId must match the command runId."
+    });
+  }
+});
+var AgentSessionTargetedCommandSchema = AgentSessionCommandSchema.and(
+  z5.object({ runId: ContractIdentifierSchema })
+);
 var AgentSessionCommandErrorCodeSchema = z5.enum([
   "SESSION_NOT_FOUND",
+  "RUN_NOT_FOUND",
+  "RUN_ALREADY_FINISHED",
+  "STOP_TIMEOUT",
   "COMMAND_NOT_SUPPORTED",
   "CAPABILITY_UNAVAILABLE",
   "SEQUENCE_CONFLICT",
@@ -7743,17 +7873,28 @@ var AgentSessionCommandErrorCodeSchema = z5.enum([
   "TARGET_EVENT_NOT_RETRYABLE",
   "APPROVAL_NOT_FOUND",
   "APPROVAL_ALREADY_RESOLVED",
+  "SOURCE_THREAD_NOT_FOUND",
+  "SOURCE_MESSAGE_NOT_FOUND",
+  "SOURCE_RUN_NOT_FOUND",
+  "SOURCE_LINEAGE_INVALID",
+  "ACTIVE_BRANCH_NOT_FOUND",
   "COMMAND_EXECUTION_FAILED"
 ]);
 var AgentSessionCommandResultSchema = z5.object({
   contract: z5.literal("AgentSessionCommandResult"),
   commandId: ContractIdentifierSchema,
   sessionId: ContractIdentifierSchema,
+  runId: ContractIdentifierSchema.optional(),
   idempotencyKey: ContractIdentifierSchema,
   outcome: z5.enum(["accepted", "duplicate", "rejected", "failed"]),
   sessionStatus: AgentSessionStatusSchema,
   acceptedSequence: z5.number().int().nonnegative().optional(),
   resultEventIds: z5.array(ContractIdentifierSchema).default([]),
+  operation: z5.object({
+    lineage: AgentSessionLineageSchema,
+    activeBranch: AgentSessionActiveBranchSchema
+  }).strict().optional(),
+  termination: z5.enum(["requested", "confirmed"]).optional(),
   error: z5.object({
     code: AgentSessionCommandErrorCodeSchema,
     message: z5.string(),
@@ -7769,11 +7910,121 @@ var AgentSessionCommandResultSchema = z5.object({
       message: requiresError ? "Rejected and failed command results require an error." : "Accepted and duplicate command results must not contain an error."
     });
   }
+  if (value.termination === "requested" && value.sessionStatus !== "stopping") {
+    context.addIssue({
+      code: "custom",
+      path: ["termination"],
+      message: "A requested termination must leave the run in stopping status."
+    });
+  }
+  if (value.termination === "confirmed" && !isAgentSessionTerminalStatus(value.sessionStatus)) {
+    context.addIssue({
+      code: "custom",
+      path: ["termination"],
+      message: "A confirmed termination requires a terminal run status."
+    });
+  }
+  if (value.operation && !value.operation.activeBranch.lineage) {
+    context.addIssue({
+      code: "custom",
+      path: ["operation", "activeBranch", "lineage"],
+      message: "A branch operation result requires lineage on its active branch."
+    });
+  }
+  const operation = value.operation;
+  if (operation?.activeBranch.lineage) {
+    const { lineage } = operation;
+    const branchLineage = operation.activeBranch.lineage;
+    if (lineage.forkedFromThreadId !== branchLineage.forkedFromThreadId || lineage.forkedFromMessageId !== branchLineage.forkedFromMessageId || lineage.sourceRunId !== branchLineage.sourceRunId) {
+      context.addIssue({
+        code: "custom",
+        path: ["operation", "activeBranch", "lineage"],
+        message: "Active branch lineage must match the operation lineage."
+      });
+    }
+  }
+  if (value.operation && value.runId !== value.operation.activeBranch.runId) {
+    context.addIssue({
+      code: "custom",
+      path: ["operation", "activeBranch", "runId"],
+      message: "Active branch runId must match the command result runId."
+    });
+  }
+});
+var AgentSessionCommandPolicySchema = z5.object({
+  capability: AgentSessionCapabilitySchema.optional(),
+  allowedStatuses: z5.array(AgentSessionStatusSchema).min(1),
+  requiresRunId: z5.boolean(),
+  sourceSessionEffect: z5.enum(["transition", "preserve"]),
+  idempotencyScope: z5.literal("session-command"),
+  sequenceRule: z5.literal("match-current")
+}).strict();
+var sessionCommandPolicy = (policy) => AgentSessionCommandPolicySchema.parse(policy);
+var AGENT_SESSION_COMMAND_POLICIES = Object.freeze({
+  stop: sessionCommandPolicy({
+    allowedStatuses: ["queued", "running", "waiting_approval"],
+    requiresRunId: true,
+    sourceSessionEffect: "transition",
+    idempotencyScope: "session-command",
+    sequenceRule: "match-current"
+  }),
+  resume: sessionCommandPolicy({
+    capability: "resume",
+    allowedStatuses: ["stopped", "completed", "failed"],
+    requiresRunId: true,
+    sourceSessionEffect: "transition",
+    idempotencyScope: "session-command",
+    sequenceRule: "match-current"
+  }),
+  retry: sessionCommandPolicy({
+    allowedStatuses: ["failed"],
+    requiresRunId: true,
+    sourceSessionEffect: "transition",
+    idempotencyScope: "session-command",
+    sequenceRule: "match-current"
+  }),
+  approval: sessionCommandPolicy({
+    capability: "approval",
+    allowedStatuses: ["waiting_approval"],
+    requiresRunId: true,
+    sourceSessionEffect: "transition",
+    idempotencyScope: "session-command",
+    sequenceRule: "match-current"
+  }),
+  fork: sessionCommandPolicy({
+    capability: "threadForking",
+    allowedStatuses: AgentSessionStatusSchema.options,
+    requiresRunId: false,
+    sourceSessionEffect: "preserve",
+    idempotencyScope: "session-command",
+    sequenceRule: "match-current"
+  }),
+  "edit-and-rerun": sessionCommandPolicy({
+    capability: "editAndRerun",
+    allowedStatuses: ["stopped", "completed", "failed"],
+    requiresRunId: false,
+    sourceSessionEffect: "preserve",
+    idempotencyScope: "session-command",
+    sequenceRule: "match-current"
+  }),
+  steer: sessionCommandPolicy({
+    capability: "steering",
+    allowedStatuses: ["queued", "running"],
+    requiresRunId: true,
+    sourceSessionEffect: "preserve",
+    idempotencyScope: "session-command",
+    sequenceRule: "match-current"
+  })
 });
+function isAgentSessionTerminalStatus(status) {
+  return AgentSessionTerminalStatusSchema.safeParse(status).success;
+}
 var AgentSessionEventHeaderSchema = z5.object({
   contract: z5.literal("AgentSessionEvent"),
   eventId: ContractIdentifierSchema,
   sessionId: ContractIdentifierSchema,
+  runId: ContractIdentifierSchema.optional(),
+  sourceMessageId: ContractIdentifierSchema.optional(),
   sequence: z5.number().int().nonnegative(),
   idempotencyKey: ContractIdentifierSchema,
   occurredAt: IsoDateTimeSchema
@@ -7833,7 +8084,13 @@ var AgentSessionEventSchema = z5.discriminatedUnion("eventType", [
   }),
   sessionEvent("status", {
     status: AgentSessionStatusSchema,
-    detail: z5.string().optional()
+    detail: z5.string().optional(),
+    startedAt: IsoDateTimeSchema.optional(),
+    stoppingRequestedAt: IsoDateTimeSchema.optional(),
+    stoppedAt: IsoDateTimeSchema.optional(),
+    completedAt: IsoDateTimeSchema.optional(),
+    failedAt: IsoDateTimeSchema.optional(),
+    durationMs: z5.number().nonnegative().optional()
   }),
   sessionEvent("artifact", {
     artifactId: ContractIdentifierSchema,
@@ -7887,8 +8144,52 @@ var AgentSessionEventSchema = z5.discriminatedUnion("eventType", [
     status: z5.enum(["running", "passed", "failed", "skipped"]),
     durationMs: z5.number().nonnegative().optional(),
     output: z5.string().optional()
+  }),
+  sessionEvent("summary", {
+    summaryId: ContractIdentifierSchema,
+    runId: ContractIdentifierSchema,
+    text: z5.string(),
+    highlights: z5.array(z5.string()),
+    pendingItems: z5.array(z5.string()),
+    status: z5.enum(["generating", "completed", "failed"])
   })
-]);
+]).superRefine((value, context) => {
+  if (value.eventType === "summary" && value.runId !== value.payload.runId) {
+    context.addIssue({
+      code: "custom",
+      path: ["payload", "runId"],
+      message: "Summary payload runId must match the event runId."
+    });
+  }
+});
+var AgentSessionRunEventSchema = AgentSessionEventSchema.superRefine((value, context) => {
+  if (!value.runId) {
+    context.addIssue({ code: "custom", path: ["runId"], message: "Run events require runId." });
+  }
+  if (!value.sourceMessageId) {
+    context.addIssue({
+      code: "custom",
+      path: ["sourceMessageId"],
+      message: "Run events require sourceMessageId."
+    });
+  }
+  if (value.eventType !== "status") return;
+  const requiredTimeField = value.payload.status === "running" ? "startedAt" : value.payload.status === "stopping" ? "stoppingRequestedAt" : value.payload.status === "stopped" ? "stoppedAt" : value.payload.status === "completed" ? "completedAt" : value.payload.status === "failed" ? "failedAt" : void 0;
+  if (requiredTimeField && !value.payload[requiredTimeField]) {
+    context.addIssue({
+      code: "custom",
+      path: ["payload", requiredTimeField],
+      message: `Run status ${value.payload.status} requires ${requiredTimeField}.`
+    });
+  }
+  if (isAgentSessionTerminalStatus(value.payload.status) && value.payload.durationMs === void 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["payload", "durationMs"],
+      message: `Terminal run status ${value.payload.status} requires durationMs.`
+    });
+  }
+});
 var AgentSessionViewModelSchema = z5.object({
   contract: z5.literal("AgentSessionViewModel"),
   sessionId: ContractIdentifierSchema,
@@ -7896,7 +8197,9 @@ var AgentSessionViewModelSchema = z5.object({
   status: AgentSessionStatusSchema,
   events: z5.array(AgentSessionEventSchema),
   lastSequence: z5.number().int().min(-1),
-  resumable: z5.boolean().default(false)
+  resumable: z5.boolean().default(false),
+  lineage: AgentSessionLineageSchema.optional(),
+  activeBranch: AgentSessionActiveBranchSchema.optional()
 }).strict().superRefine((value, context) => {
   const eventIds = /* @__PURE__ */ new Set();
   const idempotencyKeys = /* @__PURE__ */ new Set();