@axiom-lattice/protocols 4.1.0 → 4.1.2

package/dist/index.js

@@ -21,27 +21,54 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AgentType: () => AgentType,
+  ChannelBindingMigrationConflictError: () => ChannelBindingMigrationConflictError,
+  DuplicateChannelBindingSubjectError: () => DuplicateChannelBindingSubjectError,
+  EXECUTION_RESULT_EVENT_KEY_PATTERN: () => EXECUTION_RESULT_EVENT_KEY_PATTERN,
+  EXECUTION_RESULT_EVENT_KEY_PATTERN_SOURCE: () => EXECUTION_RESULT_EVENT_KEY_PATTERN_SOURCE,
+  EXECUTION_RESULT_EVENT_KEY_PREFIX: () => EXECUTION_RESULT_EVENT_KEY_PREFIX,
+  InvalidProjectCapabilityBundleConfigError: () => InvalidProjectCapabilityBundleConfigError,
   LoggerType: () => LoggerType,
+  MAX_PENDING_EXECUTION_RESULTS_LIMIT: () => MAX_PENDING_EXECUTION_RESULTS_LIMIT,
   McpMessageType: () => McpMessageType,
   MemoryType: () => MemoryType,
   MessageChunkTypes: () => MessageChunkTypes,
+  PROJECT_TASK_LIFECYCLE_ACTIONS: () => PROJECT_TASK_LIFECYCLE_ACTIONS,
+  ProjectRoomBrokerCapacityError: () => ProjectRoomBrokerCapacityError,
+  ProjectRoomCursorError: () => ProjectRoomCursorError,
+  ProjectTaskStoreUnsupportedError: () => ProjectTaskStoreUnsupportedError,
   QueueType: () => QueueType,
   ScheduleExecutionType: () => ScheduleExecutionType,
   ScheduleType: () => ScheduleType,
   ScheduledTaskStatus: () => ScheduledTaskStatus,
   UIComponentType: () => UIComponentType,
+  assertGenericProjectConfig: () => assertGenericProjectConfig,
+  descriptorDataValue: () => descriptorDataValue,
   getSubAgentsFromConfig: () => getSubAgentsFromConfig,
   getToolsFromConfig: () => getToolsFromConfig,
   hasTools: () => hasTools,
   isA2ARemoteAgentConfig: () => isA2ARemoteAgentConfig,
   isDeepAgentConfig: () => isDeepAgentConfig,
+  isExecutionResultEventKey: () => isExecutionResultEventKey,
   isProcessingAgentConfig: () => isProcessingAgentConfig,
+  isProjectRoomEventId: () => isProjectRoomEventId,
   isTeamAgentConfig: () => isTeamAgentConfig,
   isWorkflowAgentConfig: () => isWorkflowAgentConfig,
   parseAgentWebAppGenUIBlock: () => parseAgentWebAppGenUIBlock,
+  parseProjectRoomEventId: () => parseProjectRoomEventId,
+  parseQueuedExecutionMode: () => parseQueuedExecutionMode,
   parseTaskBeliefState: () => parseTaskBeliefState,
+  parseTrustedRunContext: () => parseTrustedRunContext,
   replaceTaskBeliefState: () => replaceTaskBeliefState,
-  taskBeliefStatesEqual: () => taskBeliefStatesEqual
+  requireProjectTaskWorkItemStore: () => requireProjectTaskWorkItemStore,
+  snapshotExactArray: () => snapshotExactArray,
+  snapshotExactRecord: () => snapshotExactRecord,
+  snapshotProjectRoomBotMembershipRealtime: () => snapshotProjectRoomBotMembershipRealtime,
+  snapshotProjectRoomMembershipRealtime: () => snapshotProjectRoomMembershipRealtime,
+  snapshotProjectRoomMessageRealtime: () => snapshotProjectRoomMessageRealtime,
+  taskBeliefStatesEqual: () => taskBeliefStatesEqual,
+  toProjectRoomPublicBotMembership: () => toProjectRoomPublicBotMembership,
+  toProjectRoomPublicMembership: () => toProjectRoomPublicMembership,
+  toProjectRoomPublicMessage: () => toProjectRoomPublicMessage
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -172,6 +199,75 @@ var McpMessageType = /* @__PURE__ */ ((McpMessageType2) => {
   return McpMessageType2;
 })(McpMessageType || {});
 
+// src/WorkspaceStoreProtocol.ts
+var InvalidProjectCapabilityBundleConfigError = class extends Error {
+  /** Creates the reserved-config error returned by generic Project writes. */
+  constructor() {
+    super("Use the project capability-bundles endpoint to update capability bundle IDs");
+    /** Stable machine-readable error code. */
+    this.code = "INVALID_BUNDLE_CONFIG";
+    this.name = "InvalidProjectCapabilityBundleConfigError";
+  }
+};
+function assertGenericProjectConfig(config) {
+  if (config !== void 0 && Object.prototype.hasOwnProperty.call(config, "capabilityBundleIds")) {
+    throw new InvalidProjectCapabilityBundleConfigError();
+  }
+}
+
+// src/BindingProtocol.ts
+var DuplicateChannelBindingSubjectError = class extends Error {
+  constructor() {
+    super("A binding already exists for this channel subject");
+    this.name = "DuplicateChannelBindingSubjectError";
+  }
+};
+var ChannelBindingMigrationConflictError = class extends Error {
+  constructor(conflicts) {
+    super(`Channel binding migration found ${conflicts.length} duplicate subject(s)`);
+    this.name = "ChannelBindingMigrationConflictError";
+    this.conflicts = conflicts;
+  }
+};
+
+// src/TaskWorkItemProtocol.ts
+var EXECUTION_RESULT_EVENT_KEY_PREFIX = "execution-result:";
+var EXECUTION_RESULT_EVENT_KEY_PATTERN_SOURCE = "^execution-result:[A-Za-z0-9._:-]+$";
+var EXECUTION_RESULT_EVENT_KEY_PATTERN = new RegExp(EXECUTION_RESULT_EVENT_KEY_PATTERN_SOURCE);
+var MAX_PENDING_EXECUTION_RESULTS_LIMIT = 1e3;
+function isExecutionResultEventKey(value) {
+  return typeof value === "string" && EXECUTION_RESULT_EVENT_KEY_PATTERN.test(value);
+}
+var PROJECT_TASK_LIFECYCLE_ACTIONS = [
+  "in_progress",
+  "interrupted",
+  "failed",
+  "completed",
+  "cancelled",
+  "reassigned"
+];
+var ProjectTaskStoreUnsupportedError = class extends Error {
+  constructor(missingMethods) {
+    super(`Project Task WorkItem store is missing: ${missingMethods.join(", ")}`);
+    this.missingMethods = missingMethods;
+    this.code = "PROJECT_TASK_STORE_UNSUPPORTED";
+    this.name = "ProjectTaskStoreUnsupportedError";
+  }
+};
+function requireProjectTaskWorkItemStore(store) {
+  const missingMethods = ["createIfTaskSnapshot", "listProjectLifecycleEvents"].filter((name) => {
+    try {
+      return typeof Reflect.get(store, name) !== "function";
+    } catch {
+      return true;
+    }
+  });
+  if (missingMethods.length > 0) {
+    throw new ProjectTaskStoreUnsupportedError(missingMethods);
+  }
+  return store;
+}
+
 // src/TaskBeliefProtocol.ts
 var BELIEF_HEADING = "## Belief State";
 var ACCEPTANCE_HEADING = "## Acceptance Criteria";
@@ -428,29 +524,379 @@ function hasOnlyKeys(value, required, optional) {
   const keys = Object.keys(value);
   return required.every((key) => key in value) && keys.every((key) => required.includes(key) || optional.includes(key));
 }
+
+// src/ExactDataSnapshot.ts
+function ownDescriptorField(descriptor, key) {
+  const field = Object.getOwnPropertyDescriptor(descriptor, key);
+  return field && Object.prototype.hasOwnProperty.call(field, "value") ? field.value : void 0;
+}
+function descriptorDataValue(descriptor) {
+  if (typeof descriptor !== "object" || descriptor === null) return void 0;
+  try {
+    const keys = Reflect.ownKeys(descriptor);
+    if (!keys.includes("value") || !keys.includes("enumerable") || keys.includes("get") || keys.includes("set")) return void 0;
+    const valueField = Object.getOwnPropertyDescriptor(descriptor, "value");
+    if (!valueField || !Object.prototype.hasOwnProperty.call(valueField, "value") || ownDescriptorField(descriptor, "enumerable") !== true) return void 0;
+    return { ok: true, value: valueField.value };
+  } catch {
+    return void 0;
+  }
+}
+function snapshotExactRecord(value, required, optional = []) {
+  try {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+    const keys = Reflect.ownKeys(value);
+    const allowed = /* @__PURE__ */ new Set([...required, ...optional]);
+    if (required.some((key) => !keys.includes(key)) || keys.some((key) => typeof key !== "string" || !allowed.has(key))) return void 0;
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const descriptorKeys = Reflect.ownKeys(descriptors);
+    if (descriptorKeys.length !== keys.length || keys.some((key) => !descriptorKeys.includes(key))) return void 0;
+    const result = {};
+    for (const key of keys) {
+      if (typeof key !== "string") return void 0;
+      const descriptor = descriptors[key];
+      const data = descriptorDataValue(descriptor);
+      if (!data) return void 0;
+      Object.defineProperty(result, key, {
+        value: data.value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+    return result;
+  } catch {
+    return void 0;
+  }
+}
+function snapshotExactArray(value) {
+  try {
+    if (!Array.isArray(value)) return void 0;
+    const keys = Reflect.ownKeys(value);
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const descriptorKeys = Reflect.ownKeys(descriptors);
+    if (descriptorKeys.length !== keys.length || keys.some((key) => !descriptorKeys.includes(key))) return void 0;
+    const lengthDescriptorField = Object.getOwnPropertyDescriptor(descriptors, "length");
+    const lengthDescriptor = lengthDescriptorField && Object.prototype.hasOwnProperty.call(lengthDescriptorField, "value") ? lengthDescriptorField.value : void 0;
+    if (typeof lengthDescriptor !== "object" || lengthDescriptor === null || Reflect.ownKeys(lengthDescriptor).some((key) => key === "get" || key === "set") || !Object.prototype.hasOwnProperty.call(lengthDescriptor, "value")) return void 0;
+    const length = ownDescriptorField(lengthDescriptor, "value");
+    if (ownDescriptorField(lengthDescriptor, "enumerable") !== false || ownDescriptorField(lengthDescriptor, "configurable") !== false || ownDescriptorField(lengthDescriptor, "writable") !== true || !Number.isSafeInteger(length) || typeof length !== "number" || length < 0 || keys.length !== length + 1) return void 0;
+    const result = [];
+    for (let index = 0; index < length; index += 1) {
+      const key = String(index);
+      const descriptor = descriptors[key];
+      const data = descriptorDataValue(descriptor);
+      if (!keys.includes(key) || !data) return void 0;
+      result.push(data.value);
+    }
+    if (keys.some((key) => typeof key !== "string" || key !== "length" && !/^(0|[1-9]\d*)$/.test(key))) return void 0;
+    return result;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/ProjectRoomRealtimeProtocol.ts
+var ProjectRoomCursorError = class extends Error {
+  constructor(code) {
+    super(`Project Room realtime cursor requires resynchronization: ${code}`);
+    this.code = code;
+    this.name = "ProjectRoomCursorError";
+  }
+};
+var ProjectRoomBrokerCapacityError = class extends Error {
+  constructor() {
+    super("Project Room realtime event sequence is exhausted");
+    this.name = "ProjectRoomBrokerCapacityError";
+    this.code = "PROJECT_ROOM_EVENT_SEQUENCE_EXHAUSTED";
+  }
+};
+var PROJECT_ROOM_EVENT_ID_PATTERN = /^([0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}):([1-9][0-9]*)$/i;
+function parseProjectRoomEventId(value) {
+  if (typeof value !== "string") return void 0;
+  const match = PROJECT_ROOM_EVENT_ID_PATTERN.exec(value);
+  if (!match) return void 0;
+  const sequence = Number(match[2]);
+  if (!Number.isSafeInteger(sequence)) return void 0;
+  if (match[1] !== match[1].toLowerCase()) return void 0;
+  return { epoch: match[1], sequence };
+}
+function isProjectRoomEventId(value) {
+  return parseProjectRoomEventId(value) !== void 0;
+}
+function isoDate(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  try {
+    const time = Date.prototype.getTime.call(value);
+    return Number.isFinite(time) ? new Date(time).toISOString() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function stringField(record, key) {
+  return typeof record[key] === "string" ? record[key] : void 0;
+}
+function isOneOf(value, values) {
+  return typeof value === "string" && values.includes(value);
+}
+var messageSources = ["user", "agent", "task", "routine", "system"];
+var humanRoles = ["owner", "admin", "member", "viewer"];
+var membershipStatuses = ["active", "removed"];
+var botRoles = ["coordinator", "specialist"];
+var botStatuses = ["active", "paused", "removed"];
+function mapPublicMessageRecord(record) {
+  const id = stringField(record, "id");
+  const roomId = stringField(record, "roomId");
+  const source = stringField(record, "source");
+  const createdAt = isoDate(record.createdAt);
+  const content = snapshotExactRecord(record.content, ["type", "text"]);
+  const mentions = snapshotPublicMentions(record.mentions);
+  const author = snapshotExactRecord(record.author, ["type"], ["userId", "membershipId", "assistantId"]);
+  if (!id || !roomId || !isOneOf(source, messageSources) || !createdAt || !content || content.type !== "text" || typeof content.text !== "string" || !mentions || !author || typeof author.type !== "string") return void 0;
+  const publicAuthor = author.type === "human" && typeof author.userId === "string" ? { type: "human", userId: author.userId } : author.type === "bot" && typeof author.membershipId === "string" ? { type: "bot", membershipId: author.membershipId } : author.type === "system" ? { type: "system" } : void 0;
+  if (!publicAuthor) return void 0;
+  const result = { id, roomId, author: publicAuthor, content: { type: "text", text: content.text }, mentions, source, createdAt };
+  if (record.replyToMessageId !== void 0) {
+    if (typeof record.replyToMessageId !== "string") return void 0;
+    result.replyToMessageId = record.replyToMessageId;
+  }
+  return result;
+}
+function snapshotPublicMentions(value) {
+  const rows = snapshotExactArray(value);
+  if (!rows) return void 0;
+  const result = [];
+  for (const row of rows) {
+    const team = snapshotExactRecord(row, ["type"]);
+    if (team?.type === "team") {
+      result.push({ type: "team" });
+      continue;
+    }
+    const bot = snapshotExactRecord(row, ["type", "membershipId"]);
+    if (bot?.type === "bot" && typeof bot.membershipId === "string") {
+      result.push({ type: "bot", membershipId: bot.membershipId });
+      continue;
+    }
+    return void 0;
+  }
+  return result;
+}
+function mapPublicMembershipRecord(record) {
+  const joinedAt = isoDate(record.joinedAt);
+  const updatedAt = isoDate(record.updatedAt);
+  if (typeof record.id !== "string" || typeof record.userId !== "string" || !isOneOf(record.role, humanRoles) || !isOneOf(record.status, membershipStatuses) || !joinedAt || !updatedAt) return void 0;
+  return { id: record.id, userId: record.userId, role: record.role, status: record.status, joinedAt, updatedAt };
+}
+function mapPublicBotMembershipRecord(record) {
+  const joinedAt = isoDate(record.joinedAt);
+  const updatedAt = isoDate(record.updatedAt);
+  if (typeof record.id !== "string" || !isOneOf(record.role, botRoles) || typeof record.title !== "string" || typeof record.mentionName !== "string" || !isOneOf(record.status, botStatuses) || !joinedAt || !updatedAt || record.responsibility !== void 0 && typeof record.responsibility !== "string") return void 0;
+  return { id: record.id, role: record.role, title: record.title, ...record.responsibility === void 0 ? {} : { responsibility: record.responsibility }, mentionName: record.mentionName, status: record.status, joinedAt, updatedAt };
+}
+function toProjectRoomPublicMessage(value) {
+  const record = snapshotExactRecord(value, [
+    "id",
+    "tenantId",
+    "workspaceId",
+    "projectId",
+    "roomId",
+    "author",
+    "content",
+    "mentions",
+    "source",
+    "createdAt"
+  ], ["replyToMessageId", "sourceId", "idempotencyKey"]);
+  if (!record) return void 0;
+  return mapPublicMessageRecord(record);
+}
+function snapshotProjectRoomMessageRealtime(value) {
+  const record = snapshotExactRecord(value, ["id", "tenantId", "workspaceId", "projectId", "roomId", "author", "content", "mentions", "source", "createdAt"], ["replyToMessageId", "sourceId", "idempotencyKey"]);
+  if (!record) return void 0;
+  const publicMessage = mapPublicMessageRecord(record);
+  if (!publicMessage || typeof record.tenantId !== "string" || typeof record.projectId !== "string") return void 0;
+  return { scope: { tenantId: record.tenantId, roomId: publicMessage.roomId, projectId: record.projectId }, publicMessage };
+}
+function toProjectRoomPublicMembership(value) {
+  const record = snapshotExactRecord(
+    value,
+    ["id", "tenantId", "projectId", "userId", "role", "status", "joinedAt", "updatedAt"]
+  );
+  if (!record || typeof record.id !== "string" || typeof record.userId !== "string" || !isOneOf(record.role, humanRoles) || !isOneOf(record.status, membershipStatuses)) return void 0;
+  const joinedAt = isoDate(record.joinedAt);
+  const updatedAt = isoDate(record.updatedAt);
+  if (!joinedAt || !updatedAt) return void 0;
+  return {
+    id: record.id,
+    userId: record.userId,
+    role: record.role,
+    status: record.status,
+    joinedAt,
+    updatedAt
+  };
+}
+function snapshotProjectRoomMembershipRealtime(value) {
+  const record = snapshotExactRecord(value, ["id", "tenantId", "projectId", "userId", "role", "status", "joinedAt", "updatedAt"]);
+  if (!record) return void 0;
+  const publicMembership = mapPublicMembershipRecord(record);
+  if (!publicMembership || typeof record.tenantId !== "string" || typeof record.projectId !== "string") return void 0;
+  return { scope: { tenantId: record.tenantId, projectId: record.projectId }, publicMembership };
+}
+function toProjectRoomPublicBotMembership(value) {
+  const record = snapshotExactRecord(
+    value,
+    ["id", "tenantId", "workspaceId", "projectId", "roomId", "assistantId", "role", "title", "mentionName", "status", "roomThreadId", "joinedAt", "updatedAt"],
+    ["responsibility"]
+  );
+  if (!record || typeof record.id !== "string" || !isOneOf(record.role, botRoles) || typeof record.title !== "string" || typeof record.mentionName !== "string" || !isOneOf(record.status, botStatuses)) return void 0;
+  if (record.responsibility !== void 0 && typeof record.responsibility !== "string") return void 0;
+  const joinedAt = isoDate(record.joinedAt);
+  const updatedAt = isoDate(record.updatedAt);
+  if (!joinedAt || !updatedAt) return void 0;
+  const result = {
+    id: record.id,
+    role: record.role,
+    title: record.title,
+    mentionName: record.mentionName,
+    status: record.status,
+    joinedAt,
+    updatedAt
+  };
+  if (record.responsibility !== void 0) result.responsibility = record.responsibility;
+  return result;
+}
+function snapshotProjectRoomBotMembershipRealtime(value) {
+  const record = snapshotExactRecord(value, ["id", "tenantId", "workspaceId", "projectId", "roomId", "assistantId", "role", "title", "mentionName", "status", "roomThreadId", "joinedAt", "updatedAt"], ["responsibility"]);
+  if (!record) return void 0;
+  const publicMembership = mapPublicBotMembershipRecord(record);
+  if (!publicMembership || typeof record.tenantId !== "string" || typeof record.roomId !== "string" || typeof record.projectId !== "string") return void 0;
+  return { scope: { tenantId: record.tenantId, roomId: record.roomId, projectId: record.projectId }, publicMembership };
+}
+
+// src/TrustedRunContextProtocol.ts
+function parseTrustedRunContext(value) {
+  const contextValues = snapshotExactRecord(value, [], ["projectRoom", "projectTask"]);
+  if (!contextValues || Object.keys(contextValues).length !== 1) {
+    throw new Error("Invalid trusted agent run context");
+  }
+  if (Object.prototype.hasOwnProperty.call(contextValues, "projectTask")) {
+    const requiredKeys2 = [
+      "tenantId",
+      "workspaceId",
+      "projectId",
+      "roomId",
+      "membershipId",
+      "assistantId",
+      "taskId",
+      "threadId",
+      "inputMessageId"
+    ];
+    const projectTaskValues = snapshotExactRecord(contextValues.projectTask, requiredKeys2);
+    if (!projectTaskValues || requiredKeys2.some((key) => typeof projectTaskValues[key] !== "string" || projectTaskValues[key].length === 0)) {
+      throw new Error("Invalid trusted agent run context");
+    }
+    return {
+      projectTask: {
+        tenantId: projectTaskValues.tenantId,
+        workspaceId: projectTaskValues.workspaceId,
+        projectId: projectTaskValues.projectId,
+        roomId: projectTaskValues.roomId,
+        membershipId: projectTaskValues.membershipId,
+        assistantId: projectTaskValues.assistantId,
+        taskId: projectTaskValues.taskId,
+        threadId: projectTaskValues.threadId,
+        inputMessageId: projectTaskValues.inputMessageId
+      }
+    };
+  }
+  const projectRoomValue = contextValues?.projectRoom;
+  const requiredKeys = [
+    "tenantId",
+    "workspaceId",
+    "projectId",
+    "roomId",
+    "sourceRoomMessageId",
+    "membershipId",
+    "assistantId",
+    "inputMessageId",
+    "role",
+    "title"
+  ];
+  const projectRoomValues = snapshotExactRecord(projectRoomValue, requiredKeys, ["responsibility"]);
+  const hasResponsibility = projectRoomValues !== void 0 && Object.prototype.hasOwnProperty.call(projectRoomValues, "responsibility");
+  if (!projectRoomValues || requiredKeys.some((key) => typeof projectRoomValues[key] !== "string" || projectRoomValues[key].length === 0) || hasResponsibility && projectRoomValues.responsibility !== void 0 && (typeof projectRoomValues.responsibility !== "string" || projectRoomValues.responsibility.length === 0) || projectRoomValues.role !== "coordinator" && projectRoomValues.role !== "specialist") {
+    throw new Error("Invalid trusted agent run context");
+  }
+  const parsedProjectRoom = {
+    tenantId: projectRoomValues.tenantId,
+    workspaceId: projectRoomValues.workspaceId,
+    projectId: projectRoomValues.projectId,
+    roomId: projectRoomValues.roomId,
+    sourceRoomMessageId: projectRoomValues.sourceRoomMessageId,
+    membershipId: projectRoomValues.membershipId,
+    assistantId: projectRoomValues.assistantId,
+    inputMessageId: projectRoomValues.inputMessageId,
+    role: projectRoomValues.role,
+    title: projectRoomValues.title
+  };
+  if (hasResponsibility && typeof projectRoomValues.responsibility === "string") {
+    parsedProjectRoom.responsibility = projectRoomValues.responsibility;
+  }
+  return { projectRoom: parsedProjectRoom };
+}
+function parseQueuedExecutionMode(value) {
+  if (value !== "followup") throw new Error("Invalid queued execution mode");
+  return value;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AgentType,
+  ChannelBindingMigrationConflictError,
+  DuplicateChannelBindingSubjectError,
+  EXECUTION_RESULT_EVENT_KEY_PATTERN,
+  EXECUTION_RESULT_EVENT_KEY_PATTERN_SOURCE,
+  EXECUTION_RESULT_EVENT_KEY_PREFIX,
+  InvalidProjectCapabilityBundleConfigError,
   LoggerType,
+  MAX_PENDING_EXECUTION_RESULTS_LIMIT,
   McpMessageType,
   MemoryType,
   MessageChunkTypes,
+  PROJECT_TASK_LIFECYCLE_ACTIONS,
+  ProjectRoomBrokerCapacityError,
+  ProjectRoomCursorError,
+  ProjectTaskStoreUnsupportedError,
   QueueType,
   ScheduleExecutionType,
   ScheduleType,
   ScheduledTaskStatus,
   UIComponentType,
+  assertGenericProjectConfig,
+  descriptorDataValue,
   getSubAgentsFromConfig,
   getToolsFromConfig,
   hasTools,
   isA2ARemoteAgentConfig,
   isDeepAgentConfig,
+  isExecutionResultEventKey,
   isProcessingAgentConfig,
+  isProjectRoomEventId,
   isTeamAgentConfig,
   isWorkflowAgentConfig,
   parseAgentWebAppGenUIBlock,
+  parseProjectRoomEventId,
+  parseQueuedExecutionMode,
   parseTaskBeliefState,
+  parseTrustedRunContext,
   replaceTaskBeliefState,
-  taskBeliefStatesEqual
+  requireProjectTaskWorkItemStore,
+  snapshotExactArray,
+  snapshotExactRecord,
+  snapshotProjectRoomBotMembershipRealtime,
+  snapshotProjectRoomMembershipRealtime,
+  snapshotProjectRoomMessageRealtime,
+  taskBeliefStatesEqual,
+  toProjectRoomPublicBotMembership,
+  toProjectRoomPublicMembership,
+  toProjectRoomPublicMessage
 });
 //# sourceMappingURL=index.js.map