@inf-monkeys-tech/monkeys 1.0.13 → 1.0.15

package/lib/esm/index.mjs

@@ -6770,6 +6770,41 @@ var AgentSessionCapabilitiesSchema = z3.object({
   terminal: z3.boolean().default(false),
   testResults: z3.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 }),
+  agent: AgentSessionCapabilitiesSchema.parse({ text: true, tools: true, mcp: true, shell: true, fileChange: true, skills: true, approval: true, artifacts: true, usage: true, resume: true })
+});
+function getAgentSessionRuntimeCapabilities(mode) {
+  return AGENT_SESSION_RUNTIME_CAPABILITIES[mode];
+}
+var AGENT_SESSION_CAPABILITY_EVIDENCE = Object.freeze({
+  text: { eventTypes: ["message"], commandTypes: [] },
+  reasoning: { eventTypes: ["reasoning"], commandTypes: [] },
+  plan: { eventTypes: ["plan"], commandTypes: [] },
+  tasks: { eventTypes: ["task"], commandTypes: [] },
+  tools: { eventTypes: ["tool"], commandTypes: [] },
+  mcp: { eventTypes: ["tool"], commandTypes: [] },
+  shell: { eventTypes: ["tool", "terminal"], commandTypes: [] },
+  fileChange: { eventTypes: ["tool", "diff", "workspace-file"], commandTypes: [] },
+  skills: { eventTypes: ["tool"], commandTypes: [] },
+  approval: { eventTypes: ["approval"], commandTypes: ["approval"] },
+  artifacts: { eventTypes: ["artifact"], commandTypes: [] },
+  usage: { eventTypes: ["usage"], commandTypes: [] },
+  resume: { eventTypes: ["resume"], commandTypes: ["resume"] },
+  diff: { eventTypes: ["diff"], commandTypes: [] },
+  workspaceFiles: { eventTypes: ["workspace-file"], commandTypes: [] },
+  terminal: { eventTypes: ["terminal"], commandTypes: [] },
+  testResults: { eventTypes: ["test-result"], commandTypes: [] }
+});
+function findUnsupportedAgentSessionCapabilities(capabilities, evidence) {
+  const eventTypes = new Set(evidence.eventTypes || []);
+  const commandTypes = new Set(evidence.commandTypes || []);
+  return AgentSessionCapabilitySchema.options.filter((capability) => {
+    if (!capabilities[capability]) return false;
+    const requirement = AGENT_SESSION_CAPABILITY_EVIDENCE[capability];
+    return !requirement.eventTypes.some((eventType) => eventTypes.has(eventType)) && !requirement.commandTypes.some((commandType) => commandTypes.has(commandType));
+  });
+}
 var AgentSessionSnapshotSchema = z3.object({
   mode: AgentModeSchema,
   modelId: z3.string().trim().min(1),
@@ -10715,13 +10750,13 @@ var TenantApplicationConfigSchema = z12.object({
     rememberWorkflowModelSelection: z12.boolean().optional()
   }).strict(),
   dataManagement: z12.object({
-    favoriteBucketId: z12.string().optional(),
-    pairedBucketId: z12.string().optional(),
-    galleryBucketId: z12.string().optional(),
-    dataBrowserDefaultBucketId: z12.string().optional(),
-    workflowResultBucketId: z12.string().optional(),
+    favoriteOntologyId: z12.string().optional(),
+    pairedOntologyId: z12.string().optional(),
+    galleryOntologyId: z12.string().optional(),
+    dataBrowserDefaultOntologyId: z12.string().optional(),
+    workflowResultOntologyId: z12.string().optional(),
     homeAdvertisement: z12.object({
-      bucketId: ContractIdentifierSchema,
+      ontologyId: ContractIdentifierSchema,
       viewId: ContractIdentifierSchema.optional(),
       viewType: z12.enum(["filter", "container", "share_link"]).optional(),
       teamId: ContractIdentifierSchema.optional(),
@@ -10733,7 +10768,7 @@ var TenantApplicationConfigSchema = z12.object({
       columnIds: z12.record(z12.string(), z12.string()).optional()
     }).strict().optional(),
     homeTrendAssistant: z12.object({
-      bucketId: ContractIdentifierSchema.optional(),
+      ontologyId: ContractIdentifierSchema.optional(),
       viewId: ContractIdentifierSchema.optional(),
       viewInstanceId: ContractIdentifierSchema.optional(),
       viewName: z12.string().optional(),
@@ -10743,7 +10778,7 @@ var TenantApplicationConfigSchema = z12.object({
       runtime: z12.object({ appId: ContractIdentifierSchema, tepBaseUrlConfigured: z12.boolean(), tepAuthorizationConfigured: z12.boolean(), tepCookieConfigured: z12.boolean() }).strict().optional()
     }).strict().optional(),
     sharing: z12.object({
-      silentViewLinks: z12.object({ enabled: z12.boolean().optional(), placement: z12.object({ mode: z12.enum(["sourceBucket", "bucket"]).optional(), bucketId: ContractIdentifierSchema.optional(), parentId: ContractIdentifierSchema.optional(), navId: ContractIdentifierSchema.optional() }).strict().optional() }).strict().optional(),
+      silentViewLinks: z12.object({ enabled: z12.boolean().optional(), placement: z12.object({ mode: z12.enum(["sourceOntology", "ontology"]).optional(), ontologyId: ContractIdentifierSchema.optional(), parentId: ContractIdentifierSchema.optional(), navId: ContractIdentifierSchema.optional() }).strict().optional() }).strict().optional(),
       shareAccess: z12.object({ publicLinksEnabled: z12.boolean().optional(), passwordGateEnabled: z12.boolean().optional(), passwordAccessTtlSeconds: z12.number().int().positive().optional(), defaultViewTreeDelivery: z12.enum(["manual", "auto"]).optional() }).strict().optional(),
       shareDialog: z12.object({
         audience: z12.object({ enabled: z12.boolean().optional(), allowed: z12.array(z12.enum(["user", "team", "public"])).optional(), default: z12.enum(["user", "team", "public"]).optional() }).strict().optional(),
@@ -11670,6 +11705,98 @@ var compileCapabilityRegistry = (sources) => {
   });
 };
 
+// src/runtime/agent-session-projector.ts
+function createAgentSessionEventProjection(sessionId) {
+  return {
+    sessionId,
+    events: [],
+    lastSequence: -1,
+    status: "queued",
+    resumable: false
+  };
+}
+function projectAgentSessionEvents(current, candidates) {
+  const parsed = candidates.map(
+    (candidate) => AgentSessionEventSchema.parse(candidate)
+  );
+  if (parsed.some((event) => event.sessionId !== current.sessionId)) {
+    throw new TypeError(
+      "Agent session event sessionId does not match the projection sessionId."
+    );
+  }
+  const eventIds = new Set(current.events.map((event) => event.eventId));
+  const idempotencyKeys = new Set(
+    current.events.map((event) => event.idempotencyKey)
+  );
+  const eventsBySequence = new Map(
+    current.events.map((event) => [event.sequence, event])
+  );
+  const acceptedCandidates = [];
+  for (const event of parsed.sort(
+    (left, right) => left.sequence - right.sequence
+  )) {
+    if (eventIds.has(event.eventId) || idempotencyKeys.has(event.idempotencyKey))
+      continue;
+    const existing = eventsBySequence.get(event.sequence);
+    if (existing) {
+      throw new TypeError(
+        `Conflicting Agent session events share sequence ${event.sequence}.`
+      );
+    }
+    eventsBySequence.set(event.sequence, event);
+    eventIds.add(event.eventId);
+    idempotencyKeys.add(event.idempotencyKey);
+    acceptedCandidates.push(event);
+  }
+  for (const event of acceptedCandidates)
+    eventsBySequence.delete(event.sequence);
+  let expectedSequence = current.lastSequence + 1;
+  let gap;
+  for (const event of acceptedCandidates) {
+    if (event.sequence < expectedSequence) {
+      throw new TypeError(
+        `Agent session event sequence ${event.sequence} is behind the recovery cursor.`
+      );
+    }
+    if (event.sequence > expectedSequence) {
+      gap = { expectedSequence, receivedSequence: event.sequence };
+      break;
+    }
+    eventsBySequence.set(event.sequence, event);
+    eventIds.add(event.eventId);
+    idempotencyKeys.add(event.idempotencyKey);
+    expectedSequence += 1;
+  }
+  const events = [...eventsBySequence.values()].sort(
+    (left, right) => left.sequence - right.sequence
+  );
+  let status = "queued";
+  let resumable = false;
+  for (const event of events) {
+    if (event.eventType === "status") status = event.payload.status;
+    if (event.eventType === "resume") resumable = event.payload.resumable;
+  }
+  return {
+    sessionId: current.sessionId,
+    events,
+    lastSequence: events.length > 0 ? events[events.length - 1].sequence : -1,
+    status,
+    resumable,
+    ...gap ? { gap } : {}
+  };
+}
+function toAgentSessionViewModel(projection, snapshot) {
+  return AgentSessionViewModelSchema.parse({
+    contract: "AgentSessionViewModel",
+    sessionId: projection.sessionId,
+    snapshot,
+    status: projection.status,
+    events: projection.events,
+    lastSequence: projection.lastSequence,
+    resumable: projection.resumable
+  });
+}
+
 // src/runtime/declaration-compiler.ts
 var uniqueIndex = (values, key, label) => {
   const result = /* @__PURE__ */ new Map();
@@ -12679,6 +12806,8 @@ var compileWorkflowPersistenceProjection = (input) => {
 };
 export {
   AGENT_MODE_CAPABILITIES,
+  AGENT_SESSION_CAPABILITY_EVIDENCE,
+  AGENT_SESSION_RUNTIME_CAPABILITIES,
   APPLICATION_HANDOFF_QUERY_PARAMETER,
   ActorRefSchema,
   AgentConfigurationCapabilitySchema,
@@ -12850,22 +12979,27 @@ export {
   compileViewProviderRegistry,
   compileWorkflowDefinitionFromConductor,
   compileWorkflowPersistenceProjection,
+  createAgentSessionEventProjection,
   createCapabilityRegistrySource,
   createOpenApiCapabilityRegistrySource,
   createToolCapabilityManifest,
   createWorkflowCapabilityManifest,
   extractOpenApiCapabilityManifests,
+  findUnsupportedAgentSessionCapabilities,
   getAgentModeCapabilities,
+  getAgentSessionRuntimeCapabilities,
   isAgentResourceModeCompatible,
   mergeThemeTokenDocuments,
   normalizeAgentExecutionMode,
   normalizeAgentMode,
   parseApplicationHandoff,
+  projectAgentSessionEvents,
   publishOpenApiToolCapabilityManifests,
   readApplicationHandoffFromUrl,
   resolveAgentSessionCommandTransition,
   resolveThemeTokens,
   serializeApplicationHandoff,
+  toAgentSessionViewModel,
   validateDomainCommand,
   validateThemeTokensDocument,
   validateThemeTokensDocumentStructure