@axiom-lattice/protocols 4.11.0 → 5.0.0

package/dist/index.mjs

@@ -2,15 +2,11 @@
 var AgentType = /* @__PURE__ */ ((AgentType2) => {
   AgentType2["REACT"] = "react";
   AgentType2["DEEP_AGENT"] = "deep_agent";
-  AgentType2["TEAM"] = "team";
   AgentType2["PROCESSING"] = "processing";
   AgentType2["A2A_REMOTE"] = "a2a_remote";
   AgentType2["WORKFLOW"] = "workflow";
   return AgentType2;
 })(AgentType || {});
-function isTeamAgentConfig(config) {
-  return config.type === "team" /* TEAM */;
-}
 function isA2ARemoteAgentConfig(config) {
   return config.type === "a2a_remote" /* A2A_REMOTE */;
 }
@@ -579,6 +575,108 @@ function isRecord2(value) {
 var PROJECT_ROOM_TASK_DELEGATED_LABEL = "Task delegated";
 var PROJECT_ROOM_TASK_DELEGATED_SEPARATOR = " \xB7 ";
 
+// src/StoreProtocol.ts
+var STORE_IDENTITY_SEPARATOR = "";
+var StoreValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.code = "STORE_IDENTITY_INVALID";
+    this.name = "StoreValidationError";
+  }
+};
+function validStoreSegment(value) {
+  return typeof value === "string" && value.length > 0 && !value.includes(STORE_IDENTITY_SEPARATOR);
+}
+function assertStoreIdentity(namespace, key) {
+  if (!Array.isArray(namespace) || namespace.length === 0) {
+    throw new StoreValidationError("namespace must be a non-empty string array");
+  }
+  for (const segment of namespace) {
+    if (!validStoreSegment(segment)) {
+      throw new StoreValidationError(
+        "namespace segments must be non-empty strings without the reserved separator"
+      );
+    }
+  }
+  if (!validStoreSegment(key)) {
+    throw new StoreValidationError(
+      "key must be a non-empty string without the reserved separator"
+    );
+  }
+}
+function assertStoreNamespacePrefix(prefix) {
+  if (!Array.isArray(prefix)) {
+    throw new StoreValidationError("namespace prefix must be a string array");
+  }
+  for (const segment of prefix) {
+    if (!validStoreSegment(segment)) {
+      throw new StoreValidationError(
+        "namespace segments must be non-empty strings without the reserved separator"
+      );
+    }
+  }
+}
+function storeExpiresAt(ttlMinutes, now = /* @__PURE__ */ new Date()) {
+  if (ttlMinutes === void 0) return void 0;
+  if (typeof ttlMinutes !== "number" || !Number.isFinite(ttlMinutes) || ttlMinutes <= 0) {
+    throw new StoreValidationError("ttlMinutes must be a positive number");
+  }
+  const expiresAt = new Date(now.getTime() + ttlMinutes * 6e4);
+  if (!Number.isFinite(expiresAt.getTime()) || expiresAt.getUTCFullYear() > 9999) {
+    throw new StoreValidationError("ttlMinutes is out of range");
+  }
+  return expiresAt;
+}
+function storePaginationValue(value, fallback) {
+  if (value === void 0) return fallback;
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new StoreValidationError("limit/offset must be a non-negative safe integer");
+  }
+  return value;
+}
+
+// src/ChannelReplyJobProtocol.ts
+var CHANNEL_REPLY_JOB_LIST_LIMIT_MIN = 1;
+var CHANNEL_REPLY_JOB_LIST_LIMIT_MAX = 200;
+var CHANNEL_REPLY_JOB_LIST_LIMIT_DEFAULT = 100;
+function normalizeChannelReplyJobListLimit(limit) {
+  if (limit === void 0 || !Number.isFinite(limit)) {
+    return CHANNEL_REPLY_JOB_LIST_LIMIT_DEFAULT;
+  }
+  return Math.min(
+    CHANNEL_REPLY_JOB_LIST_LIMIT_MAX,
+    Math.max(CHANNEL_REPLY_JOB_LIST_LIMIT_MIN, Math.trunc(limit))
+  );
+}
+function assertValidCreateChannelReplyJobInput(input) {
+  if (input === null || typeof input !== "object") {
+    throw new Error("ChannelReplyJob create input is required");
+  }
+  const required = [
+    ["runId", input.runId],
+    ["tenantId", input.tenantId],
+    ["assistantId", input.assistantId],
+    ["threadId", input.threadId],
+    ["adapterChannel", input.adapterChannel],
+    ["channelInstallationId", input.channelInstallationId],
+    ["inputMessageId", input.inputMessageId]
+  ];
+  for (const [field, value] of required) {
+    if (typeof value !== "string" || value.trim() === "") {
+      throw new Error(`ChannelReplyJob requires a non-empty ${field}`);
+    }
+  }
+  if (typeof input.replyTarget !== "object" || input.replyTarget === null || Array.isArray(input.replyTarget)) {
+    throw new Error("ChannelReplyJob requires a replyTarget object");
+  }
+  if (typeof input.availableAt !== "number" || !Number.isFinite(input.availableAt)) {
+    throw new Error("ChannelReplyJob requires a finite availableAt");
+  }
+  if (input.streamCursor !== void 0 && input.streamCursor !== null && typeof input.streamCursor !== "string") {
+    throw new Error("ChannelReplyJob streamCursor must be a string");
+  }
+}
+
 // src/ExactDataSnapshot.ts
 function ownDescriptorField(descriptor, key) {
   const field = Object.getOwnPropertyDescriptor(descriptor, key);
@@ -941,6 +1039,32 @@ function resolveRunScope(runConfig) {
   };
 }
 
+// src/RunCancelProtocol.ts
+import { z } from "zod";
+var MAX_FIELD_LENGTH = 64 * 1024;
+var boundedString = z.string().min(1).max(MAX_FIELD_LENGTH);
+var RUN_CANCEL_REASONS = ["abort", "a2a.cancel", "shutdown"];
+var runCancelSignalSchema = z.object({
+  commandId: boundedString,
+  tenantId: boundedString,
+  assistantId: boundedString,
+  threadId: boundedString,
+  runId: boundedString,
+  reason: z.enum(RUN_CANCEL_REASONS),
+  createdAt: boundedString
+}).strict();
+var interruptAnswerKeySchema = z.object({
+  tenantId: boundedString,
+  assistantId: boundedString,
+  threadId: boundedString,
+  interruptId: boundedString
+}).strict();
+var a2aEventCursorSchema = z.object({
+  taskId: boundedString,
+  lastEventId: boundedString,
+  updatedAt: boundedString
+}).strict();
+
 // src/AgentAffinity.ts
 var AGENT_AFFINITY_HEADER = "x-axiom-affinity";
 var REPLICA_HEADER = "x-axiom-replica";
@@ -1005,6 +1129,9 @@ export {
   AFFINITY_MISS_CODE,
   AGENT_AFFINITY_HEADER,
   AgentType,
+  CHANNEL_REPLY_JOB_LIST_LIMIT_DEFAULT,
+  CHANNEL_REPLY_JOB_LIST_LIMIT_MAX,
+  CHANNEL_REPLY_JOB_LIST_LIMIT_MIN,
   ChannelBindingMigrationConflictError,
   DuplicateChannelBindingSubjectError,
   EXECUTION_RESULT_EVENT_KEY_PATTERN,
@@ -1025,13 +1152,19 @@ export {
   ProjectTaskStoreUnsupportedError,
   QueueType,
   REPLICA_HEADER,
+  STORE_IDENTITY_SEPARATOR,
   ScheduleExecutionType,
   ScheduleType,
   ScheduledTaskStatus,
+  StoreValidationError,
   UIComponentType,
   WORKSPACE_PUBLIC_ROOM_PROJECT_PREFIX,
+  a2aEventCursorSchema,
   affinityEchoHeaders,
   assertGenericProjectConfig,
+  assertStoreIdentity,
+  assertStoreNamespacePrefix,
+  assertValidCreateChannelReplyJobInput,
   buildAffinityMissChunk,
   createAgentWebAppStreamProjectionContext,
   descriptorDataValue,
@@ -1040,15 +1173,16 @@ export {
   getSubAgentsFromConfig,
   getToolsFromConfig,
   hasTools,
+  interruptAnswerKeySchema,
   isA2ARemoteAgentConfig,
   isDeepAgentConfig,
   isExecutionResultEventKey,
   isMcpUiRef,
   isProcessingAgentConfig,
   isProjectRoomEventId,
-  isTeamAgentConfig,
   isWorkflowAgentConfig,
   isWorkspacePublicRoomProjectId,
+  normalizeChannelReplyJobListLimit,
   normalizeTaskMetadataScalar,
   parseAgentWebAppGenUIBlock,
   parseMcpUiRef,
@@ -1062,11 +1196,14 @@ export {
   replaceTaskBeliefState,
   requireProjectTaskWorkItemStore,
   resolveRunScope,
+  runCancelSignalSchema,
   snapshotExactArray,
   snapshotExactRecord,
   snapshotProjectRoomBotMembershipRealtime,
   snapshotProjectRoomMembershipRealtime,
   snapshotProjectRoomMessageRealtime,
+  storeExpiresAt,
+  storePaginationValue,
   taskBeliefStatesEqual,
   threadAffinityHeaders,
   toModelKey,