@bpmsoftwaresolutions/ai-engine-client 1.1.98 → 1.1.101

package/src/domains/communication-tickets.js

@@ -0,0 +1,379 @@
+import { cleanText, isPlainObject } from '../utils/communication.js';
+
+export function createCommunicationTicketsDomain(client) {
+  return {
+    createCrossAgentRemediationTicket: (request) => createCrossAgentRemediationTicket(client, request),
+  };
+}
+
+export async function createCrossAgentRemediationTicket(client, {
+  transferChannelId,
+  transfer_channel_id,
+  channelId,
+  channel_id,
+  workTransferPacketId,
+  work_transfer_packet_id,
+  packetId,
+  packet_id,
+  workflowRunId,
+  workflow_run_id,
+  ownershipMove,
+  ownership_move,
+  transferOwnership,
+  transfer_ownership,
+  assignedTo,
+  assigned_to,
+  requestedBy,
+  requested_by,
+  severity,
+  sourceRef,
+  source_ref,
+  findingId,
+  finding_id,
+  blockerId,
+  blocker_id,
+  failedCheckId,
+  failed_check_id,
+  workflowGap,
+  workflow_gap,
+  blockerKind,
+  blocker_kind,
+  blockerSummary,
+  blocker_summary,
+  blockerDetails,
+  blocker_details,
+  expectedResponse,
+  expected_response,
+  participantRole,
+  participant_role,
+  watcherRole,
+  watcher_role,
+  proposalId,
+  proposal_id,
+  collaborationProposalId,
+  collaboration_proposal_id,
+  expectedMessageKind,
+  expected_message_kind,
+  messageWatchId,
+  message_watch_id,
+  replyBodyMarkdown,
+  reply_body_markdown,
+  replyPayload = {},
+  reply_payload = {},
+  replyScope = {},
+  reply_scope = {},
+  replyEvidenceRefs = [],
+  reply_evidence_refs = [],
+  metadata = {},
+  includeTransferChannelProjection = true,
+  includeOperatorProjectionMetadata = true,
+} = {}) {
+  const missingSurfaces = [];
+  const normalizedMetadata = isPlainObject(metadata) ? metadata : {};
+  const normalizedTransferChannelId = cleanText(transfer_channel_id) || cleanText(transferChannelId) || cleanText(channel_id) || cleanText(channelId);
+  const normalizedWorkTransferPacketId = cleanText(work_transfer_packet_id) || cleanText(workTransferPacketId) || cleanText(packet_id) || cleanText(packetId);
+  const normalizedWorkflowRunId = cleanText(workflow_run_id) || cleanText(workflowRunId);
+  const normalizedRequestedBy = cleanText(requested_by) || cleanText(requestedBy) || client.agentSessionId || client.actorId;
+  const normalizedAssignedTo = cleanText(assigned_to) || cleanText(assignedTo);
+  const normalizedSeverity = cleanText(severity) || 'medium';
+  const normalizedSourceRef = cleanText(source_ref) || cleanText(sourceRef) || cleanText(finding_id) || cleanText(findingId) || cleanText(blocker_id) || cleanText(blockerId) || cleanText(failed_check_id) || cleanText(failedCheckId) || cleanText(workflow_gap) || cleanText(workflowGap);
+  const normalizedExpectedResponse = cleanText(expected_response) || cleanText(expectedResponse) || 'assignee acknowledgement';
+  const normalizedParticipantRole = cleanText(participant_role) || cleanText(participantRole) || 'requester';
+  const normalizedWatcherRole = cleanText(watcher_role) || cleanText(watcherRole) || 'watcher';
+  const normalizedBlockerKind = cleanText(blocker_kind) || cleanText(blockerKind) || 'remediation';
+  const normalizedBlockerSummary = cleanText(blocker_summary) || cleanText(blockerSummary) || normalizedSourceRef || normalizedExpectedResponse;
+  const normalizedBlockerDetails = cleanText(blocker_details) || cleanText(blockerDetails) || normalizedExpectedResponse;
+  const normalizedExpectedMessageKind = cleanText(expected_message_kind) || cleanText(expectedMessageKind) || 'response';
+  const normalizedReplyPayload = isPlainObject(reply_payload) ? reply_payload : (isPlainObject(replyPayload) ? replyPayload : {});
+  const normalizedReplyScope = isPlainObject(reply_scope) ? reply_scope : (isPlainObject(replyScope) ? replyScope : {});
+  const normalizedReplyEvidenceRefs = Array.isArray(reply_evidence_refs) ? reply_evidence_refs : (Array.isArray(replyEvidenceRefs) ? replyEvidenceRefs : []);
+  const shouldMoveOwnership = Boolean(ownership_move ?? ownershipMove ?? transfer_ownership ?? transferOwnership);
+  const hasExplicitChannel = Boolean(normalizedTransferChannelId);
+
+  if (!hasExplicitChannel && !shouldMoveOwnership) {
+    throw new Error('channel_id is required unless ownershipMove is true.');
+  }
+
+  let resumedChannel = null;
+  let resolvedTransferChannelId = normalizedTransferChannelId;
+  let resolvedWorkTransferPacketId = normalizedWorkTransferPacketId;
+
+  if (hasExplicitChannel) {
+    const resumeSurface = typeof client.resumeTransferChannel === 'function'
+      ? client.resumeTransferChannel.bind(client)
+      : null;
+    if (!resumeSurface) missingSurfaces.push('resumeTransferChannel');
+    if (resumeSurface) {
+      resumedChannel = await resumeSurface({
+        transferChannelId: normalizedTransferChannelId,
+        workTransferPacketId: normalizedWorkTransferPacketId,
+        workflowRunId: normalizedWorkflowRunId,
+        participantRole: normalizedParticipantRole,
+        participantKind: 'agent_session',
+        participantLabel: normalizedParticipantRole,
+        agentSessionId: client.agentSessionId,
+        currentPhase: 'remediation',
+        currentTaskSummary: normalizedBlockerSummary,
+        lastSeenMessageId: cleanText(message_watch_id) || cleanText(messageWatchId),
+        metadata: {
+          ...normalizedMetadata,
+          source: 'createCrossAgentRemediationTicket',
+        },
+      });
+      const resumedPayload = isPlainObject(resumedChannel) ? resumedChannel : {};
+      resolvedTransferChannelId = cleanText(resumedPayload.transfer_channel_id)
+        || cleanText(resumedPayload.channel_id)
+        || cleanText(resumedPayload.transfer_channel?.transfer_channel_id)
+        || cleanText(resumedPayload.communication_transfer_channel?.transfer_channel_id)
+        || resolvedTransferChannelId;
+      resolvedWorkTransferPacketId = cleanText(resumedPayload.work_transfer_packet_id)
+        || cleanText(resumedPayload.work_transfer_packet?.work_transfer_packet_id)
+        || cleanText(resumedPayload.communication_transfer_channel?.work_transfer_packet_id)
+        || resolvedWorkTransferPacketId;
+    }
+  }
+
+  if (shouldMoveOwnership) {
+    const transferSurface = typeof client.transferWorkPacket === 'function'
+      ? client.transferWorkPacket.bind(client)
+      : null;
+    if (!transferSurface) missingSurfaces.push('transferWorkPacket');
+    if (transferSurface) {
+      const transferResult = await transferSurface({
+        workflowRunId: normalizedWorkflowRunId,
+        transferKind: 'upstream_remediation',
+        objective: normalizedBlockerSummary,
+        requestedOutcome: normalizedExpectedResponse,
+        target: {
+          intent: 'upstream_remediation',
+          recipient_mode: normalizedAssignedTo ? 'agent_session' : 'role',
+          preferred_agent_session_id: normalizedAssignedTo,
+          preferred_role_key: normalizedAssignedTo || normalizedWatcherRole,
+        },
+        artifacts: [],
+        issues: [],
+        expectedEvidence: [],
+        preferredModes: ['bundle', 'artifact_refs', 'inline_payload'],
+        capabilities: {},
+        senderAgentSessionId: client.agentSessionId,
+        senderActorSessionId: null,
+        subject: normalizedBlockerSummary,
+        bodyMarkdown: cleanText(reply_body_markdown) || cleanText(replyBodyMarkdown) || normalizedBlockerDetails,
+        messageKind: normalizedExpectedMessageKind,
+        metadata: {
+          ...normalizedMetadata,
+          source: 'createCrossAgentRemediationTicket',
+          source_ref: normalizedSourceRef,
+          assigned_to: normalizedAssignedTo,
+          requested_by: normalizedRequestedBy,
+        },
+      });
+      const transferPayload = isPlainObject(transferResult) ? transferResult : {};
+      resolvedWorkTransferPacketId = cleanText(transferPayload.work_transfer_packet?.work_transfer_packet_id)
+        || cleanText(transferPayload.work_transfer_packet_id)
+        || cleanText(transferPayload.transfer_packet_id)
+        || cleanText(transferPayload.packet_id)
+        || resolvedWorkTransferPacketId;
+      resolvedTransferChannelId = cleanText(transferPayload.communication_transfer_channel?.transfer_channel_id)
+        || cleanText(transferPayload.communication_transfer_channel?.channel_id)
+        || cleanText(transferPayload.channel_id)
+        || resolvedTransferChannelId;
+    }
+  }
+
+  if (!resolvedTransferChannelId) {
+    throw new Error('channel ownership is ambiguous.');
+  }
+  if (!resolvedWorkTransferPacketId) {
+    throw new Error('work_transfer_packet_id is required.');
+  }
+
+  const blockerSurface = typeof client.raiseCollaborationBlocker === 'function'
+    ? client.raiseCollaborationBlocker.bind(client)
+    : null;
+  if (!blockerSurface) missingSurfaces.push('raiseCollaborationBlocker');
+  const blockerResult = blockerSurface && resolvedTransferChannelId
+    ? await blockerSurface({
+        transferChannelId: resolvedTransferChannelId,
+        workTransferPacketId: resolvedWorkTransferPacketId,
+        workflowRunId: normalizedWorkflowRunId,
+        participantRole: normalizedParticipantRole,
+        blockerKind: normalizedBlockerKind,
+        blockerState: 'open',
+        blockedSide: normalizedWatcherRole,
+        blockerSummary: normalizedBlockerSummary,
+        blockerDetails: normalizedBlockerDetails,
+        expectedNextUpdate: normalizedExpectedResponse,
+        nextOwner: normalizedAssignedTo,
+        reviewerAgentSessionId: client.agentSessionId,
+        reviewerActorSessionId: null,
+        metadata: {
+          ...normalizedMetadata,
+          source: 'createCrossAgentRemediationTicket',
+          source_ref: normalizedSourceRef,
+          assigned_to: normalizedAssignedTo,
+          requested_by: normalizedRequestedBy,
+        },
+      })
+    : null;
+
+  const proposalIdCandidate = cleanText(collaboration_proposal_id) || cleanText(collaborationProposalId) || cleanText(proposal_id) || cleanText(proposalId);
+  const proposalSurface = proposalIdCandidate && typeof client.reviewCollaborationProposal === 'function'
+    ? client.reviewCollaborationProposal.bind(client)
+    : null;
+  if (proposalIdCandidate && !proposalSurface) missingSurfaces.push('reviewCollaborationProposal');
+  const proposalResult = proposalSurface && resolvedTransferChannelId
+    ? await proposalSurface({
+        transferChannelId: resolvedTransferChannelId,
+        collaborationProposalId: proposalIdCandidate,
+        decision: 'accept',
+        nextOwner: normalizedAssignedTo,
+        phase: 'remediation',
+        decisionReason: normalizedBlockerSummary,
+        evidenceRefs: normalizedReplyEvidenceRefs,
+        reviewerRole: normalizedParticipantRole,
+        reviewerAgentSessionId: client.agentSessionId,
+        reviewerActorSessionId: null,
+        reviewedByClaimId: null,
+        metadata: {
+          ...normalizedMetadata,
+          source: 'createCrossAgentRemediationTicket',
+          source_ref: normalizedSourceRef,
+        },
+      })
+    : null;
+
+  const watchSurface = typeof client.startMessageWatch === 'function'
+    ? client.startMessageWatch.bind(client)
+    : null;
+  if (!watchSurface) missingSurfaces.push('startMessageWatch');
+  const watchResult = watchSurface && resolvedTransferChannelId && resolvedWorkTransferPacketId
+    ? await watchSurface({
+        transferChannelId: resolvedTransferChannelId,
+        workTransferPacketId: resolvedWorkTransferPacketId,
+        workflowRunId: normalizedWorkflowRunId,
+        watchingAgentRole: normalizedWatcherRole,
+        expectedFromRole: normalizedAssignedTo || normalizedParticipantRole,
+        expectedMessageKind: normalizedExpectedMessageKind,
+        watchType: 'expected_peer_message',
+        watchingAgentSessionId: client.agentSessionId,
+        expectedPayload: {
+          source_ref: normalizedSourceRef,
+          severity: normalizedSeverity,
+          assigned_to: normalizedAssignedTo,
+          requested_by: normalizedRequestedBy,
+        },
+        currentStatus: 'watching',
+        operatorNudge: normalizedExpectedResponse,
+        metadata: {
+          ...normalizedMetadata,
+          source: 'createCrossAgentRemediationTicket',
+        },
+      })
+    : null;
+
+  const heartbeatSurface = typeof client.postCollaborationHeartbeat === 'function'
+    ? client.postCollaborationHeartbeat.bind(client)
+    : typeof client.postAgentHeartbeat === 'function'
+      ? client.postAgentHeartbeat.bind(client)
+      : null;
+  if (!heartbeatSurface) missingSurfaces.push('postCollaborationHeartbeat');
+  const heartbeatResult = heartbeatSurface && resolvedTransferChannelId && resolvedWorkTransferPacketId
+    ? await heartbeatSurface({
+        transferChannelId: resolvedTransferChannelId,
+        workTransferPacketId: resolvedWorkTransferPacketId,
+        workflowRunId: normalizedWorkflowRunId,
+        participantRole: normalizedParticipantRole,
+        activityState: 'active',
+        agentSessionId: client.agentSessionId,
+        currentPhase: 'remediation',
+        currentTaskSummary: normalizedBlockerSummary,
+        isActive: true,
+        metadata: {
+          ...normalizedMetadata,
+          source: 'createCrossAgentRemediationTicket',
+        },
+      })
+    : null;
+
+  const transferChannelProjectionSurface = typeof client.getTransferChannelProjection === 'function'
+    ? client.getTransferChannelProjection.bind(client)
+    : typeof client.getLogaTransferChannelThreadProjection === 'function'
+      ? client.getLogaTransferChannelThreadProjection.bind(client)
+      : null;
+  if (!transferChannelProjectionSurface) missingSurfaces.push('getTransferChannelProjection');
+  const transferChannelProjection = includeTransferChannelProjection && transferChannelProjectionSurface && resolvedTransferChannelId
+    ? await transferChannelProjectionSurface(resolvedTransferChannelId).catch(() => null)
+    : null;
+
+  const blockerPayload = isPlainObject(blockerResult) ? blockerResult : {};
+  const proposalPayload = isPlainObject(proposalResult) ? proposalResult : {};
+  const watchPayload = isPlainObject(watchResult) ? watchResult : {};
+  const heartbeatPayload = isPlainObject(heartbeatResult) ? heartbeatResult : {};
+  const blockerRecord = isPlainObject(blockerPayload.collaboration_blocker)
+    ? blockerPayload.collaboration_blocker
+    : blockerPayload;
+  const watchRecord = isPlainObject(watchPayload.message_watch)
+    ? watchPayload.message_watch
+    : watchPayload;
+  const heartbeatRecord = isPlainObject(heartbeatPayload.collaboration_heartbeat)
+    ? heartbeatPayload.collaboration_heartbeat
+    : heartbeatPayload;
+
+  const blockerRecordId = cleanText(blockerRecord.collaboration_blocker_id)
+    || cleanText(blockerRecord.blocker_id)
+    || cleanText(blockerPayload.collaboration_blocker_id)
+    || cleanText(blockerPayload.blocker_id)
+    || null;
+  const remediationTicketId = cleanText(transferChannelProjection?.remediation_ticket_id)
+    || cleanText(transferChannelProjection?.work_transfer_packet_id)
+    || cleanText(transferChannelProjection?.transfer_packet_id)
+    || resolvedWorkTransferPacketId
+    || null;
+  const watchId = cleanText(watchRecord.message_watch_id)
+    || cleanText(watchRecord.watch_id)
+    || null;
+  const heartbeatStatus = cleanText(heartbeatRecord.activity_state)
+    || cleanText(heartbeatRecord.status)
+    || 'active';
+  const waitingSide = cleanText(watchRecord.waiting_side)
+    || cleanText(blockerRecord.blocked_side)
+    || cleanText(proposalPayload.next_owner)
+    || normalizedWatcherRole;
+  const expectedResponseText = cleanText(blockerRecord.expected_next_update)
+    || cleanText(watchRecord.expected_message_kind)
+    || cleanText(heartbeatRecord.expected_message_kind)
+    || normalizedExpectedResponse;
+  const status = missingSurfaces.length > 0 ? 'partial' : 'ready';
+  const operatorProjectionMetadata = includeOperatorProjectionMetadata
+    ? {
+        transfer_channel_projection: transferChannelProjection,
+        blocker: blockerPayload,
+        proposal: proposalPayload,
+        message_watch: watchPayload,
+        heartbeat: heartbeatPayload,
+      }
+    : null;
+
+  return {
+    status,
+    remediation_ticket_id: remediationTicketId,
+    blocker_id: blockerRecordId,
+    channel_id: resolvedTransferChannelId || null,
+    transfer_packet_id: resolvedWorkTransferPacketId || null,
+    assigned_to: normalizedAssignedTo,
+    requested_by: normalizedRequestedBy,
+    severity: normalizedSeverity,
+    source_ref: normalizedSourceRef,
+    expected_response: expectedResponseText,
+    watch_id: watchId,
+    heartbeat_status: heartbeatStatus,
+    operator_projection_metadata: operatorProjectionMetadata,
+    missing_surfaces: [...new Set(missingSurfaces)],
+    resume_channel: resumedChannel,
+    blocker: blockerPayload,
+    proposal: proposalPayload,
+    watch: watchPayload,
+    heartbeat: heartbeatPayload,
+  };
+}

package/src/domains/database.js

@@ -139,6 +139,12 @@ export function createDatabaseDomain(client) {
         limit,
       },
     }),
+    describeDatabaseCatalog: ({ includeSystemSchemas, limit } = {}) => client.database.schema.getOverview({ includeSystemSchemas, limit }),
+    listDatabaseSchemas: ({ includeSystemSchemas, limit } = {}) => client.database.schema.listSchemas({ includeSystemSchemas, limit }),
+    listDatabaseTables: ({ schemaName, includeSystemSchemas, limit } = {}) => client.database.schema.listTables({ schemaName, includeSystemSchemas, limit }),
+    listDatabaseColumns: ({ schemaName, tableName } = {}) => client.database.schema.listColumns({ schemaName, tableName }),
+    listDatabaseIndexes: ({ schemaName, tableName, includeSystemSchemas, limit } = {}) => client.database.schema.listIndexes({ schemaName, tableName, includeSystemSchemas, limit }),
+    describeDatabaseTable: ({ schemaName, tableName, includeSystemSchemas } = {}) => client.database.schema.describeTable({ schemaName, tableName, includeSystemSchemas }),
     backups: createDatabaseBackupsDomain(client),
     schema: createDatabaseSchemaDomain(client),
   };

package/src/domains/external-audio.js

@@ -0,0 +1,30 @@
+export function createExternalAudioDomain(client) {
+  return {
+    createExternalAudioRender: (request) => createExternalAudioRender(client, request),
+    getExternalAudioRender: (audioRenderRunId) => getExternalAudioRender(client, audioRenderRunId),
+    downloadExternalAudioRender: (audioRenderRunId) => downloadExternalAudioRender(client, audioRenderRunId),
+  };
+}
+
+export async function createExternalAudioRender(client, { text, voice, model, speed, file } = {}) {
+  if (file) {
+    const form = new FormData();
+    form.append('file', file);
+    if (voice !== undefined) form.append('voice', String(voice));
+    if (model !== undefined) form.append('model', String(model));
+    if (speed !== undefined) form.append('speed', String(speed));
+    return client._request('/api/v1/audio-renders', { method: 'POST', body: form });
+  }
+  return client._request('/api/v1/audio-renders', {
+    method: 'POST',
+    body: { text, voice, model, speed },
+  });
+}
+
+export async function getExternalAudioRender(client, audioRenderRunId) {
+  return client._request(`/api/v1/audio-renders/${audioRenderRunId}`);
+}
+
+export async function downloadExternalAudioRender(client, audioRenderRunId) {
+  return client._requestBinary(`/api/v1/audio-renders/${audioRenderRunId}/download`);
+}

package/src/domains/external-projects.js

@@ -0,0 +1,29 @@
+export function createExternalProjectsDomain(client) {
+  return {
+    getExternalProjectStatus: (projectId) => getExternalProjectStatus(client, projectId),
+    getExternalProjectRoadmapSummary: (projectId) => getExternalProjectRoadmapSummary(client, projectId),
+    getExternalProjectRoadmapActiveItem: (projectId) => getExternalProjectRoadmapActiveItem(client, projectId),
+    listExternalProjectOpenTasks: (projectId) => listExternalProjectOpenTasks(client, projectId),
+    getExternalProjectStatusBundle: (projectId) => getExternalProjectStatusBundle(client, projectId),
+  };
+}
+
+export async function getExternalProjectStatus(client, projectId) {
+  return client._request(`/api/v1/projects/${projectId}/status`);
+}
+
+export async function getExternalProjectRoadmapSummary(client, projectId) {
+  return client._request(`/api/v1/projects/${projectId}/implementation-roadmap/summary`);
+}
+
+export async function getExternalProjectRoadmapActiveItem(client, projectId) {
+  return client._request(`/api/v1/projects/${projectId}/implementation-roadmap/active-item`);
+}
+
+export async function listExternalProjectOpenTasks(client, projectId) {
+  return client._request(`/api/v1/projects/${projectId}/open-tasks`);
+}
+
+export async function getExternalProjectStatusBundle(client, projectId) {
+  return client._request(`/api/v1/projects/${projectId}/status-bundle`);
+}

package/src/domains/external-workflow-artifacts.js

@@ -0,0 +1,14 @@
+export function createExternalWorkflowArtifactsDomain(client) {
+  return {
+    listExternalWorkflowRunArtifacts: (workflowRunId) => listExternalWorkflowRunArtifacts(client, workflowRunId),
+    downloadExternalWorkflowRunArtifact: (workflowRunId, artifactType) => downloadExternalWorkflowRunArtifact(client, workflowRunId, artifactType),
+  };
+}
+
+export async function listExternalWorkflowRunArtifacts(client, workflowRunId) {
+  return client._request(`/api/v1/runs/${workflowRunId}/artifacts`);
+}
+
+export async function downloadExternalWorkflowRunArtifact(client, workflowRunId, artifactType) {
+  return client._requestBinary(`/api/v1/runs/${workflowRunId}/artifacts/${artifactType}/download`);
+}

package/src/domains/message-watch.js

@@ -4,6 +4,7 @@ export function createMessageWatchDomain(client) {
   return {
     startMessageWatch: (request) => startMessageWatch(client, request),
     acknowledgeExpectedMessage: (request) => acknowledgeExpectedMessage(client, request),
+    acknowledgeAgentMessage: (request) => acknowledgeAgentMessage(client, request),
     expireMessageWatch: (request) => expireMessageWatch(client, request),
     respondToMessageWatch: (request) => respondToMessageWatch(client, request),
     acceptAgentChannel: (request) => acceptAgentChannel(client, request),
@@ -151,6 +152,40 @@ export async function acknowledgeExpectedMessage(client, {
   });
 }
 
+export async function acknowledgeAgentMessage(client, {
+  transferChannelId,
+  transfer_channel_id,
+  channelId,
+  channel_id,
+  messageWatchId,
+  message_watch_id,
+  watchId,
+  watch_id,
+  messageId,
+  message_id,
+  messageKind,
+  message_kind,
+  observedMessageId,
+  observed_message_id,
+  observedMessageKind,
+  observed_message_kind,
+  operatorNudge,
+  operator_nudge,
+  metadata = {},
+} = {}) {
+  const normalizedWatchId = cleanText(message_watch_id) || cleanText(messageWatchId) || cleanText(watch_id) || cleanText(watchId) || await resolveMessageWatchId(client, { transfer_channel_id, transferChannelId, channel_id, channelId });
+  if (!normalizedWatchId) throw new Error('message_watch_id is required.');
+  return client._request(`/api/agent-communications/message-watches/${encodeURIComponent(normalizedWatchId)}/acknowledge-message`, {
+    method: 'POST',
+    body: {
+      observed_message_id: cleanText(observed_message_id) || cleanText(observedMessageId) || cleanText(message_id) || cleanText(messageId),
+      observed_message_kind: cleanText(observed_message_kind) || cleanText(observedMessageKind) || cleanText(message_kind) || cleanText(messageKind),
+      operator_nudge: cleanText(operator_nudge) || cleanText(operatorNudge),
+      metadata: isPlainObject(metadata) ? metadata : {},
+    },
+  });
+}
+
 export async function expireMessageWatch(client, {
   messageWatchId,
   message_watch_id,

package/src/domains/ping-pong.js

@@ -1,18 +1,6 @@
 import { AI_ENGINE_CLIENT_VERSION } from '../constants/client.js';
 import { cleanText, isPlainObject } from '../utils/communication.js';
-
-function compareSemanticVersions(left, right) {
-  const leftParts = String(left || '').split('.').map((part) => Number.parseInt(part, 10) || 0);
-  const rightParts = String(right || '').split('.').map((part) => Number.parseInt(part, 10) || 0);
-  const width = Math.max(leftParts.length, rightParts.length);
-  for (let index = 0; index < width; index += 1) {
-    const a = leftParts[index] || 0;
-    const b = rightParts[index] || 0;
-    if (a > b) return 1;
-    if (a < b) return -1;
-  }
-  return 0;
-}
+import { compareSemanticVersions } from '../utils/version.js';
 
 function buildEligibilityError(message, details = {}) {
   const error = new Error(message);