@bpmsoftwaresolutions/ai-engine-client 1.1.99 → 1.1.102

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmsoftwaresolutions/ai-engine-client",
-  "version": "1.1.99",
+  "version": "1.1.102",
   "description": "Thin npm client for the AI Engine operator and retrieval APIs",
   "type": "module",
   "main": "./src/index.js",

package/src/client.js

@@ -1,7 +1,5 @@
 import { AI_ENGINE_CLIENT_CAPABILITIES } from './constants/governance.js';
-import { AGENT_COMMUNICATION_CONTRACT_VERSION, AGENT_COMMUNICATION_MESSAGE_KINDS, AGENT_COMMUNICATION_RECIPIENT_MODES, AGENT_COMMUNICATION_THREAD_TYPES, AGENT_COMMUNICATION_TRANSFER_KINDS, AGENT_COMMUNICATION_TRANSFER_LIFECYCLE_STATES, AGENT_COMMUNICATION_TRANSFER_MODES, AGENT_COMMUNICATION_TRANSFER_RECEIPT_TYPES } from './constants/agent-communications.js';
 import { AI_ENGINE_CLIENT_VERSION, DEFAULT_TIMEOUT_MS } from './constants/client.js';
-import { LOGA_CONTRACT, LOGA_INTERACTION_CONTRACT, LOGA_NAVIGATION_CONTRACT, LOGA_PROJECTION_WORKFLOW } from './constants/loga.js';
 import { createActionsDomain } from './domains/actions.js';
 import { createBenchmarksDomain } from './domains/benchmarks.js';
 import { createCapabilitiesDomain } from './domains/capabilities.js';
@@ -73,183 +71,7 @@ import { createWorkflowsDomain } from './domains/workflows.js';
 import { createWarehouseDomain } from './domains/warehouse.js';
 import { installClientCompatibilityDelegates } from './compat/aliases.js';
 import { buildHeaders, requestBinary, requestJson, requestLogaProjection, requestText, resolveAccessToken } from './transport/index.js';
-import { normalizeEnum, trimTrailingSlash } from './utils/text.js';
-
-function normalizeThreadType(value) {
-  return normalizeEnum(value, AGENT_COMMUNICATION_THREAD_TYPES, 'coordination', 'thread_type', {
-    task_request: 'request',
-    task: 'request',
-    review_request: 'review',
-    handoff_request: 'handoff',
-  });
-}
-
-function normalizeMessageKind(value) {
-  return normalizeEnum(value, AGENT_COMMUNICATION_MESSAGE_KINDS, 'request', 'message_kind', {
-    task: 'request',
-    note: 'request',
-    update: 'response',
-  });
-}
-
-function normalizeConnectionFirstMessageKind(value, transferKind) {
-  const text = cleanText(value);
-  if (!text) {
-    return normalizeMessageKind(transferKind === 'handoff' ? 'handoff' : 'request');
-  }
-  const normalized = text.toLowerCase();
-  const aliases = {
-    connection_request: 'request',
-    connection_accepted: 'response',
-    connection_acceptance: 'response',
-    handoff_request: 'handoff',
-    handoff_acceptance: 'response',
-    handoff_response: 'response',
-    acceptance: 'response',
-    decline: 'response',
-  };
-  const candidate = aliases[normalized] || text;
-  try {
-    return normalizeMessageKind(candidate);
-  } catch (error) {
-    void error;
-    return normalizeMessageKind(transferKind === 'handoff' ? 'handoff' : 'request');
-  }
-}
-
-function normalizeTransferKind(value) {
-  return normalizeEnum(value, AGENT_COMMUNICATION_TRANSFER_KINDS, 'upstream_remediation', 'transfer_kind', {
-    remediation_request: 'upstream_remediation',
-    review: 'review_request',
-  });
-}
-
-function normalizeTransferMode(value) {
-  return normalizeEnum(value, AGENT_COMMUNICATION_TRANSFER_MODES, 'inline_payload', 'transfer_mode');
-}
-
-function normalizeTransferLifecycleStatus(value) {
-  return normalizeEnum(value, AGENT_COMMUNICATION_TRANSFER_LIFECYCLE_STATES, 'created', 'lifecycle_status');
-}
-
-function normalizeTransferReceiptType(value) {
-  return normalizeEnum(value, AGENT_COMMUNICATION_TRANSFER_RECEIPT_TYPES, 'delivery_receipt', 'receipt_type');
-}
-
-function normalizeRecipientMode(value) {
-  return normalizeEnum(value, AGENT_COMMUNICATION_RECIPIENT_MODES, 'role', 'recipient_mode');
-}
-
-function appendQuery(url, query) {
-  const target = new URL(url);
-  for (const [key, value] of Object.entries(query || {})) {
-    if (value === undefined || value === null || value === '') continue;
-    target.searchParams.set(key, String(value));
-  }
-  return target;
-}
-
-async function readJson(response) {
-  const contentType = response.headers.get('content-type') || '';
-  if (contentType.includes('application/json')) return response.json();
-  const text = await response.text();
-  return { message: text };
-}
-
-function parseContentDispositionFilename(headerValue) {
-  const value = String(headerValue || '');
-  const quotedMatch = value.match(/filename="([^"]+)"/i);
-  if (quotedMatch) return quotedMatch[1];
-  const plainMatch = value.match(/filename=([^;]+)/i);
-  return plainMatch ? plainMatch[1].trim() : null;
-}
-
-function readResponseHeader(headers, name) {
-  if (!headers || typeof headers.get !== 'function') return null;
-  return headers.get(name) || headers.get(name.toLowerCase()) || null;
-}
-
-function extractLogaProjectionMetadata(headers) {
-  const projectionWorkflow = readResponseHeader(headers, 'x-projection-workflow');
-  const projectionVersion = readResponseHeader(headers, 'x-projection-version');
-  const sourceVersion = readResponseHeader(headers, 'x-source-version');
-  const correlationId = readResponseHeader(headers, 'x-correlation-id');
-  const logaContract = readResponseHeader(headers, 'x-loga-contract');
-  const navigationContract = readResponseHeader(headers, 'x-navigation-contract');
-  const projectionType = readResponseHeader(headers, 'x-projection-type');
-  const sourceTruth = readResponseHeader(headers, 'x-source-truth');
-  const refreshPolicy = readResponseHeader(headers, 'x-refresh-policy');
-  const generatedAt = readResponseHeader(headers, 'x-generated-at');
-
-  return {
-    logaContract,
-    navigationContract,
-    interactionContract: LOGA_INTERACTION_CONTRACT,
-    projectionType,
-    projectionWorkflow,
-    projectionVersion,
-    sourceTruth,
-    sourceVersion,
-    correlationId,
-    refreshPolicy,
-    generatedAt,
-    provenance: {
-      sourceTruth,
-      sourceVersion,
-      projectionVersion,
-      projectionWorkflow,
-      correlationId,
-      generatedAt,
-    },
-  };
-}
-
-function isFormDataBody(value) {
-  return typeof FormData !== 'undefined' && value instanceof FormData;
-}
-
-function isBinaryBody(value) {
-  return (
-    value instanceof ArrayBuffer
-    || ArrayBuffer.isView(value)
-    || (typeof Blob !== 'undefined' && value instanceof Blob)
-    || value instanceof URLSearchParams
-    || typeof value === 'string'
-  );
-}
-
-function isJsonBody(value) {
-  if (value === undefined || value === null) return false;
-  if (isFormDataBody(value) || isBinaryBody(value)) return false;
-  return typeof value === 'object';
-}
-
-function cleanText(value) {
-  const text = String(value || '').trim();
-  return text || null;
-}
-
-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;
-}
-
-function cleanList(value) {
-  if (!Array.isArray(value)) return [];
-  return value.map((item) => cleanText(item)).filter(Boolean);
-}
-
-function isPlainObject(value) {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
+import { cleanText, isPlainObject, trimTrailingSlash } from './utils/text.js';
 
 export class AIEngineClient {
   constructor({ baseUrl, accessToken, tokenProvider, apiKey, clientId, actorId, agentSessionId, fetchImpl, timeoutMs } = {}) {
@@ -324,6 +146,7 @@ export class AIEngineClient {
     this.reports = createReportsDomain(this);
     this.projections = createProjectionsDomain(this);
     this.workflowComposition = createWorkflowCompositionDomain(this);
+    this.workflowComposition.searchCodeByIntent = (request) => this.searchCodeByIntent(request);
     this.warehouse = createWarehouseDomain(this);
     this.actions = createActionsDomain(this);
     this.transferBundles = createTransferBundlesDomain(this);
@@ -340,6 +163,7 @@ export class AIEngineClient {
     this.collaborationDomain = createCollaborationDomain(this);
     this.agentComms = createAgentCommunicationsFacade(this);
     this.collaboration = createCollaborationFacade(this);
+    this.collaboration.postCollaborationProposal = (request) => this.postCollaborationProposal(request);
   }
 
   static fromEnv(options = {}) {
@@ -358,922 +182,10 @@ export class AIEngineClient {
 
   // ─── Health ────────────────────────────────────────────────────────────────
 
-  async startAgentConnection({
-    workflowRunId,
-    workflow_run_id,
-    upstreamAgent,
-    upstream_agent,
-    upstreamAgentSessionId,
-    upstream_agent_session_id,
-    upstreamAgentId,
-    upstream_agent_id,
-    upstreamRole,
-    upstream_role,
-    recipientMode,
-    recipient_mode,
-    purpose,
-    objective,
-    mode = 'handoff',
-    firstMessage = {},
-    first_message = {},
-    expectedMessageKind,
-    expected_message_kind,
-    participantRole,
-    participant_role,
-    participantLabel,
-    participant_label,
-    senderAgentSessionId,
-    sender_agent_session_id,
-    senderActorSessionId,
-    sender_actor_session_id,
-    cleanupPolicy,
-    cleanup_policy,
-    staleAfterSeconds = 300,
-    stale_after_seconds,
-    operatorNudge,
-    operator_nudge,
-    metadata = {},
-  } = {}) {
-    return this.agentCommunications.startAgentConnection(arguments[0]);
-  }
-
-  async establishAgentCommunicationChannel({
-    projectIdentifier,
-    projectId,
-    claimId,
-    actorId,
-    actorMode = 'operator',
-    executionIntent = 'establish agent communication channel',
-    workflowRunLimit = 5,
-    startWorkBody = {},
-    startWorkRequest = {},
-    resumeProjectWorkOptions = {},
-    transferKind = 'coordination',
-    objective,
-    requestedOutcome,
-    transferChannelId,
-    transfer_channel_id,
-    channelId,
-    channel_id,
-    workTransferPacketId,
-    work_transfer_packet_id,
-    packetId,
-    packet_id,
-    participantRole,
-    participant_role,
-    participantLabel,
-    participant_label,
-    participantKind,
-    participant_kind,
-    agentSessionId,
-    agent_session_id,
-    actorSessionId,
-    actor_session_id,
-    upstreamAgentSessionId,
-    upstream_agent_session_id,
-    upstreamActorSessionId,
-    upstream_actor_session_id,
-    downstreamAgentSessionId,
-    downstream_agent_session_id,
-    downstreamActorSessionId,
-    downstream_actor_session_id,
-    expectedMessageKind = 'connection_accepted',
-    expected_message_kind,
-    expectedNextMessage,
-    expected_next_message,
-    currentPhase = 'channel_ready',
-    current_phase,
-    currentTaskSummary,
-    current_task_summary,
-    channelKind = 'bidirectional',
-    channel_kind,
-    includeTransferChannelProjection = true,
-    includeChannelPresenceProjection = true,
-    includeOperatorProjectionMetadata = true,
-    metadata = {},
-  } = {}) {
-    return this.agentCommunications.establishAgentCommunicationChannel(arguments[0]);
-  }
-
-  async runInterAgentMessagingLoop({
-    transferChannelId,
-    transfer_channel_id,
-    channelId,
-    channel_id,
-    workTransferPacketId,
-    work_transfer_packet_id,
-    workflowRunId,
-    workflow_run_id,
-    participantRole,
-    participant_role,
-    watchingAgentRole,
-    watching_agent_role,
-    expectedFromRole,
-    expected_from_role,
-    expectedMessageKind,
-    expected_message_kind,
-    expectedNextMessage,
-    expected_next_message,
-    replyRequest = {},
-    reply_request = {},
-    replyBodyMarkdown,
-    reply_body_markdown,
-    replyMessageKind,
-    reply_message_kind,
-    replyPayload = {},
-    reply_payload = {},
-    replyScope = {},
-    reply_scope = {},
-    replyEvidenceRefs = [],
-    reply_evidence_refs = [],
-    replyRecipientAgentSessionId,
-    reply_recipient_agent_session_id,
-    replyRecipientActorSessionId,
-    reply_recipient_actor_session_id,
-    replySenderAgentSessionId,
-    reply_sender_agent_session_id,
-    replySenderActorSessionId,
-    reply_sender_actor_session_id,
-    watchRequest = {},
-    watch_request = {},
-    acknowledgeRequest = {},
-    acknowledge_request = {},
-    heartbeatRequest = {},
-    heartbeat_request = {},
-    closeWhenAcknowledged = false,
-    close_when_acknowledged = false,
-    requestClosure = false,
-    request_closure = false,
-    closureReason,
-    closure_reason,
-    failureReason,
-    failure_reason,
-    closureEvidence = {},
-    closure_evidence = {},
-    closureEvidenceManifestSha256,
-    closure_evidence_manifest_sha256,
-    includeTransferChannelProjection = true,
-    includeOperatorProjectionMetadata = true,
-    metadata = {},
-  } = {}) {
-    return this.agentCommunications.runInterAgentMessagingLoop(arguments[0]);
-  }
-
-  async createCrossAgentRemediationTicket({
-    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,
-  } = {}) {
-    return this.communicationTickets.createCrossAgentRemediationTicket(arguments[0]);
-  }
-
-  async transferRefactoringBundle(request = {}) {
-    return this.refactoringTransfers.transferRefactoringBundle(request);
-  }
-
-  async postAgentHeartbeat(request = {}) {
-    return this.transferChannels.postAgentHeartbeat(request);
-  }
-
   async postAgentMessage(request = {}) {
     return this._sendAgentCommsMessage(request);
   }
 
-  async acknowledgeAgentMessage({
-    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 this._resolveMessageWatchId({ transfer_channel_id, transferChannelId, channel_id, channelId });
-    if (!normalizedWatchId) throw new Error('message_watch_id is required.');
-    return this._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 : {},
-      },
-    });
-  }
-
-  async closeAgentChannel(request = {}) {
-    return this.transferChannels.closeAgentChannel(request);
-  }
-
-  async reviseCollaborationProposal(request = {}) {
-    return this.collaborationDomain.reviseCollaborationProposal(request);
-  }
-
-  async raiseCollaborationBlocker(request = {}) {
-    return this.collaborationDomain.raiseCollaborationBlocker(request);
-  }
-
-  async beginCollaborationImplementation(request = {}) {
-    return this.collaborationDomain.beginCollaborationImplementation(request);
-  }
-
-  async bootstrapCommunication() {
-    return this._request('/api/agent-communications/bootstrap');
-  }
-
-  async negotiateCommunicationTransfer({
-    preferredModes,
-    preferred_modes,
-    preferred,
-    capabilities = {},
-    estimatedPayloadKb,
-    estimated_payload_kb,
-    requiresReceipts = true,
-    requires_receipts = true,
-    supportsHashValidation = true,
-    supports_hash_validation = true,
-    transferKind,
-    transfer_kind,
-    workflowRunId,
-    workflow_run_id,
-  } = {}) {
-    const normalizedPreferredModes = Array.isArray(preferred_modes)
-      ? preferred_modes
-      : (Array.isArray(preferredModes) ? preferredModes : (Array.isArray(preferred) ? preferred : ['bundle', 'artifact_refs', 'inline_payload']));
-    return this._request('/api/agent-communications/transfers/negotiate', {
-      method: 'POST',
-      body: {
-        preferred_modes: normalizedPreferredModes.map((mode) => normalizeTransferMode(mode)),
-        capabilities: isPlainObject(capabilities) ? capabilities : {},
-        estimated_payload_kb: Number(estimated_payload_kb ?? estimatedPayloadKb ?? 0) || undefined,
-        requires_receipts: Boolean(requires_receipts ?? requiresReceipts),
-        supports_hash_validation: Boolean(supports_hash_validation ?? supportsHashValidation),
-        transfer_kind: normalizeTransferKind(transfer_kind ?? transferKind ?? 'upstream_remediation'),
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-      },
-    });
-  }
-
-  async resolveCommunicationTarget({
-    intent,
-    transferKind,
-    transfer_kind,
-    recipientMode,
-    recipient_mode,
-    preferredRoleKey,
-    preferred_role_key,
-    preferredAgentSessionId,
-    preferred_agent_session_id,
-    workflowRunId,
-    workflow_run_id,
-  } = {}) {
-    return this._request('/api/agent-communications/targets/resolve', {
-      method: 'POST',
-      body: {
-        intent: cleanText(intent) || cleanText(transfer_kind) || cleanText(transferKind),
-        recipient_mode: normalizeRecipientMode(recipient_mode ?? recipientMode ?? 'role'),
-        preferred_role_key: cleanText(preferred_role_key) || cleanText(preferredRoleKey),
-        preferred_agent_session_id: cleanText(preferred_agent_session_id) || cleanText(preferredAgentSessionId),
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-      },
-    });
-  }
-
-  async createCommunicationEvidencePacket({
-    workflowRunId,
-    workflow_run_id,
-    transferKind,
-    transfer_kind,
-    objective,
-    requestedOutcome,
-    requested_outcome,
-    artifacts = [],
-    artifactRefs,
-    artifact_refs,
-    issues = [],
-    issueRefs,
-    issue_refs,
-    expectedEvidence = [],
-    expected_evidence,
-    metadata = {},
-  } = {}) {
-    return this._request('/api/agent-communications/evidence-packets', {
-      method: 'POST',
-      body: {
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-        transfer_kind: normalizeTransferKind(transfer_kind ?? transferKind ?? 'upstream_remediation'),
-        objective: cleanText(objective),
-        requested_outcome: cleanText(requested_outcome) || cleanText(requestedOutcome),
-        artifacts: Array.isArray(artifacts) ? artifacts : (Array.isArray(artifact_refs) ? artifact_refs : (Array.isArray(artifactRefs) ? artifactRefs : [])),
-        issues: Array.isArray(issues) ? issues : (Array.isArray(issue_refs) ? issue_refs : (Array.isArray(issueRefs) ? issueRefs : [])),
-        expected_evidence: Array.isArray(expected_evidence) ? expected_evidence : (Array.isArray(expectedEvidence) ? expectedEvidence : []),
-        metadata: isPlainObject(metadata) ? metadata : {},
-      },
-    });
-  }
-
-  async listCommunicationFrictionTaxonomy({
-    categoryGroup,
-    category_group,
-    isActive,
-    is_active,
-  } = {}) {
-    return this._request('/api/agent-communications/friction-taxonomy', {
-      query: {
-        category_group: cleanText(category_group) || cleanText(categoryGroup),
-        is_active: is_active !== undefined ? String(Boolean(is_active)) : (isActive !== undefined ? String(Boolean(isActive)) : undefined),
-      },
-    });
-  }
-
-  async recordCommunicationFrictionEvent({
-    workflowRunId,
-    workflow_run_id,
-    workTransferPacketId,
-    work_transfer_packet_id,
-    communicationThreadId,
-    communication_thread_id,
-    communicationMessageId,
-    communication_message_id,
-    taxonomyKey,
-    taxonomy_key,
-    frictionType,
-    friction_type,
-    severity,
-    observedBehavior,
-    observed_behavior,
-    attemptedAction,
-    attempted_action,
-    resolutionPath,
-    resolution_path,
-    missingSurfaceKey,
-    missing_surface_key,
-    promotionCandidate,
-    promotion_candidate,
-    repeatedCount,
-    repeated_count,
-    metadata = {},
-  } = {}) {
-    return this._request('/api/agent-communications/friction-events', {
-      method: 'POST',
-      body: {
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-        work_transfer_packet_id: cleanText(work_transfer_packet_id) || cleanText(workTransferPacketId),
-        communication_thread_id: cleanText(communication_thread_id) || cleanText(communicationThreadId),
-        communication_message_id: cleanText(communication_message_id) || cleanText(communicationMessageId),
-        taxonomy_key: cleanText(taxonomy_key) || cleanText(taxonomyKey) || 'enum_drift',
-        friction_type: cleanText(friction_type) || cleanText(frictionType) || 'discovery',
-        severity: cleanText(severity) || 'warning',
-        observed_behavior: cleanText(observed_behavior) || cleanText(observedBehavior),
-        attempted_action: cleanText(attempted_action) || cleanText(attemptedAction),
-        resolution_path: cleanText(resolution_path) || cleanText(resolutionPath),
-        missing_surface_key: cleanText(missing_surface_key) || cleanText(missingSurfaceKey),
-        promotion_candidate: Boolean(promotion_candidate ?? promotionCandidate),
-        repeated_count: Number(repeated_count ?? repeatedCount ?? 1) || 1,
-        metadata: isPlainObject(metadata) ? metadata : {},
-      },
-    });
-  }
-
-  async openCommunicationThread({
-    workflowRunId,
-    workflow_run_id,
-    threadType,
-    thread_type,
-    subject,
-    objective,
-    parentThreadId,
-    parent_thread_id,
-    createdByAgentSessionId,
-    created_by_agent_session_id,
-    createdByActorSessionId,
-    created_by_actor_session_id,
-    metadata,
-  } = {}) {
-    return this._request('/api/agent-communications/threads', {
-      method: 'POST',
-      body: {
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-        parent_thread_id: cleanText(parent_thread_id) || cleanText(parentThreadId),
-        thread_type: normalizeThreadType(cleanText(thread_type) || cleanText(threadType)),
-        subject: cleanText(subject),
-        objective: cleanText(objective),
-        created_by_agent_session_id: cleanText(created_by_agent_session_id) || cleanText(createdByAgentSessionId),
-        created_by_actor_session_id: cleanText(created_by_actor_session_id) || cleanText(createdByActorSessionId),
-        metadata: isPlainObject(metadata) ? metadata : {},
-      },
-    });
-  }
-
-  async getCommunicationThread(threadId) {
-    return this._request(`/api/agent-communications/threads/${encodeURIComponent(threadId)}`);
-  }
-
-  async listCommunicationInbox({
-    recipientAgentSessionId,
-    recipient_agent_session_id,
-    recipientRoleKey,
-    recipient_role_key,
-    workflowRunId,
-    workflow_run_id,
-  } = {}) {
-    return this._request('/api/agent-communications/inbox', {
-      query: {
-        recipient_agent_session_id: cleanText(recipient_agent_session_id) || cleanText(recipientAgentSessionId),
-        recipient_role_key: cleanText(recipient_role_key) || cleanText(recipientRoleKey),
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-      },
-    });
-  }
-
-  async getMyInbox({
-    recipientAgentSessionId,
-    recipient_agent_session_id,
-    recipientRoleKey,
-    recipient_role_key,
-    workflowRunId,
-    workflow_run_id,
-  } = {}) {
-    return this._request('/api/agent-communications/inbox/me', {
-      query: {
-        recipient_agent_session_id: cleanText(recipient_agent_session_id) || cleanText(recipientAgentSessionId),
-        recipient_role_key: cleanText(recipient_role_key) || cleanText(recipientRoleKey),
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-      },
-    });
-  }
-
-  async verifyMessageSent({ messageId, message_id } = {}) {
-    const normalizedMessageId = cleanText(message_id) || cleanText(messageId);
-    if (!normalizedMessageId) throw new Error('message_id is required.');
-    return this._request(`/api/agent-communications/messages/${encodeURIComponent(normalizedMessageId)}/verify-sent`, {
-      method: 'POST',
-      body: { message_id: normalizedMessageId },
-    });
-  }
-
-  async verifyMessageReceived({
-    messageId,
-    message_id,
-    recipientAgentSessionId,
-    recipient_agent_session_id,
-    recipientRole,
-    recipient_role,
-    role,
-    participantId,
-    participant_id,
-  } = {}) {
-    const normalizedMessageId = cleanText(message_id) || cleanText(messageId);
-    if (!normalizedMessageId) throw new Error('message_id is required.');
-    return this._request(`/api/agent-communications/messages/${encodeURIComponent(normalizedMessageId)}/verify-received`, {
-      method: 'POST',
-      body: {
-        message_id: normalizedMessageId,
-        recipient_agent_session_id: cleanText(recipient_agent_session_id) || cleanText(recipientAgentSessionId),
-        recipient_role: cleanText(recipient_role) || cleanText(recipientRole) || cleanText(role),
-        participant_id: cleanText(participant_id) || cleanText(participantId),
-      },
-    });
-  }
-
-  async getMessageDeliveryReceipt({ messageId, message_id } = {}) {
-    const normalizedMessageId = cleanText(message_id) || cleanText(messageId);
-    if (!normalizedMessageId) throw new Error('message_id is required.');
-    return this._request(`/api/agent-communications/messages/${encodeURIComponent(normalizedMessageId)}/delivery-receipt`, {
-      method: 'GET',
-    });
-  }
-
-  async _sendAgentCommsMessage(request = {}) {
-    const hasThreadContext = Boolean(
-      cleanText(request.communication_thread_id)
-      || cleanText(request.communicationThreadId)
-      || cleanText(request.thread_id)
-      || cleanText(request.threadId)
-      || cleanText(request.recipient_role_key)
-      || cleanText(request.recipientRoleKey)
-    );
-    const hasTransferChannelContext = Boolean(
-      cleanText(request.transfer_channel_id)
-      || cleanText(request.transferChannelId)
-      || cleanText(request.channel_id)
-      || cleanText(request.channelId)
-      || cleanText(request.sender_role)
-      || cleanText(request.senderRole)
-      || cleanText(request.recipient_role)
-      || cleanText(request.recipientRole)
-      || cleanText(request.role)
-      || cleanText(request.participant_role)
-      || cleanText(request.participantRole)
-      || cleanText(request.participant_id)
-      || cleanText(request.participantId)
-      || cleanText(request.recipient_participant_id)
-      || cleanText(request.recipientParticipantId)
-    );
-    if (hasTransferChannelContext && !hasThreadContext) {
-      if (
-        cleanText(request.participant_id)
-        || cleanText(request.participantId)
-        || cleanText(request.recipient_participant_id)
-        || cleanText(request.recipientParticipantId)
-        || cleanText(request.recipient_agent_session_id)
-        || cleanText(request.recipientAgentSessionId)
-      ) {
-        return this.sendToParticipant(request);
-      }
-      return this.sendToRole(request);
-    }
-    return this.sendCommunicationMessage(request);
-  }
-
-  async sendCommunicationMessage({
-    communicationThreadId,
-    communication_thread_id,
-    threadId,
-    communicationBundleId,
-    communication_bundle_id,
-    senderAgentSessionId,
-    sender_agent_session_id,
-    recipientAgentSessionId,
-    recipient_agent_session_id,
-    recipientRoleKey,
-    recipient_role_key,
-    messageKind,
-    message_kind,
-    bodyMarkdown,
-    body_markdown,
-    messageStatus,
-    message_status,
-    payload = {},
-    scope = {},
-    requiredResponseSchema = {},
-    required_response_schema = {},
-    metadata = {},
-  } = {}) {
-    return this._request('/api/agent-communications/messages', {
-      method: 'POST',
-      body: {
-        communication_thread_id: cleanText(communication_thread_id) || cleanText(communicationThreadId) || cleanText(threadId),
-        communication_bundle_id: cleanText(communication_bundle_id) || cleanText(communicationBundleId),
-        sender_agent_session_id: cleanText(sender_agent_session_id) || cleanText(senderAgentSessionId) || this.agentSessionId,
-        recipient_agent_session_id: cleanText(recipient_agent_session_id) || cleanText(recipientAgentSessionId),
-        recipient_role_key: cleanText(recipient_role_key) || cleanText(recipientRoleKey),
-        message_kind: normalizeMessageKind(cleanText(message_kind) || cleanText(messageKind)),
-        message_status: cleanText(message_status) || cleanText(messageStatus) || 'sent',
-        body_markdown: cleanText(body_markdown) || cleanText(bodyMarkdown),
-        payload: isPlainObject(payload) ? payload : {},
-        scope: isPlainObject(scope) ? scope : {},
-        required_response_schema: isPlainObject(requiredResponseSchema)
-          ? requiredResponseSchema
-          : (isPlainObject(required_response_schema) ? required_response_schema : {}),
-        metadata: isPlainObject(metadata) ? metadata : {},
-      },
-    });
-  }
-
-  async acceptCommunicationTransferPacket({
-    workTransferPacketId,
-    work_transfer_packet_id,
-    acceptedByAgentSessionId,
-    accepted_by_agent_session_id,
-    acceptedByActorSessionId,
-    accepted_by_actor_session_id,
-    acceptedByClaimId,
-    accepted_by_claim_id,
-    advanceToInProgress,
-    advance_to_in_progress,
-    metadata = {},
-  } = {}) {
-    const normalizedPacketId = cleanText(work_transfer_packet_id) || cleanText(workTransferPacketId);
-    if (!normalizedPacketId) throw new Error('work_transfer_packet_id is required.');
-    return this._request(`/api/agent-communications/transfers/${encodeURIComponent(normalizedPacketId)}/accept`, {
-      method: 'POST',
-      body: {
-        accepted_by_agent_session_id: cleanText(accepted_by_agent_session_id) || cleanText(acceptedByAgentSessionId),
-        accepted_by_actor_session_id: cleanText(accepted_by_actor_session_id) || cleanText(acceptedByActorSessionId),
-        accepted_by_claim_id: cleanText(accepted_by_claim_id) || cleanText(acceptedByClaimId),
-        advance_to_in_progress: Boolean(advance_to_in_progress ?? advanceToInProgress),
-        metadata: isPlainObject(metadata) ? metadata : {},
-      },
-    });
-  }
-
-  async closeCommunicationTransferPacket({
-    workTransferPacketId,
-    work_transfer_packet_id,
-    closureStatus,
-    closure_status,
-    closureReason,
-    closure_reason,
-    failureReason,
-    failure_reason,
-    closedByAgentSessionId,
-    closed_by_agent_session_id,
-    closedByActorSessionId,
-    closed_by_actor_session_id,
-    closedByClaimId,
-    closed_by_claim_id,
-    evidence = {},
-    evidenceManifestSha256,
-    evidence_manifest_sha256,
-    metadata = {},
-  } = {}) {
-    const normalizedPacketId = cleanText(work_transfer_packet_id) || cleanText(workTransferPacketId);
-    if (!normalizedPacketId) throw new Error('work_transfer_packet_id is required.');
-    return this._request(`/api/agent-communications/transfers/${encodeURIComponent(normalizedPacketId)}/close`, {
-      method: 'POST',
-      body: {
-        closure_status: normalizeTransferLifecycleStatus(cleanText(closure_status) || cleanText(closureStatus) || 'closed'),
-        closure_reason: cleanText(closure_reason) || cleanText(closureReason),
-        failure_reason: cleanText(failure_reason) || cleanText(failureReason),
-        closed_by_agent_session_id: cleanText(closed_by_agent_session_id) || cleanText(closedByAgentSessionId),
-        closed_by_actor_session_id: cleanText(closed_by_actor_session_id) || cleanText(closedByActorSessionId),
-        closed_by_claim_id: cleanText(closed_by_claim_id) || cleanText(closedByClaimId),
-        evidence: isPlainObject(evidence) ? evidence : {},
-        evidence_manifest_sha256: cleanText(evidence_manifest_sha256) || cleanText(evidenceManifestSha256),
-        metadata: isPlainObject(metadata) ? metadata : {},
-      },
-    });
-  }
-
-  async getCommunicationTransferHealth({
-    workflowRunId,
-    workflow_run_id,
-    workTransferPacketId,
-    work_transfer_packet_id,
-  } = {}) {
-    return this._request('/api/agent-communications/transfers/health', {
-      query: {
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-        work_transfer_packet_id: cleanText(work_transfer_packet_id) || cleanText(workTransferPacketId),
-      },
-    });
-  }
-
-  async acceptCommunicationMessage(messageId) {
-    return this._request(`/api/agent-communications/messages/${encodeURIComponent(messageId)}/accept`, {
-      method: 'POST',
-      body: {},
-    });
-  }
-
-  async respondToCommunicationMessage({
-    agentMessageId,
-    agent_message_id,
-    messageId,
-    status,
-    bodyMarkdown,
-    body_markdown,
-    payload = {},
-    metadata = {},
-    evidenceRefs,
-    evidence_refs,
-  } = {}) {
-    const normalizedMessageId = cleanText(agent_message_id) || cleanText(agentMessageId) || cleanText(messageId);
-    if (!normalizedMessageId) {
-      throw new Error('agent_message_id is required.');
-    }
-    return this._request(`/api/agent-communications/messages/${encodeURIComponent(normalizedMessageId)}/respond-with-evidence`, {
-      method: 'POST',
-      body: {
-        status: cleanText(status) || 'answered',
-        body_markdown: cleanText(body_markdown) || cleanText(bodyMarkdown),
-        payload: isPlainObject(payload) ? payload : {},
-        metadata: isPlainObject(metadata) ? metadata : {},
-        evidence_refs: Array.isArray(evidence_refs) ? evidence_refs : (Array.isArray(evidenceRefs) ? evidenceRefs : []),
-      },
-    });
-  }
-
-  async attachCommunicationMessageEvidence({
-    agentMessageId,
-    agent_message_id,
-    messageId,
-    evidenceType,
-    evidence_type,
-    evidenceRef,
-    evidence_ref,
-    sourceTruth,
-    source_truth,
-    trustLevel,
-    trust_level,
-    metadata = {},
-  } = {}) {
-    const normalizedMessageId = cleanText(agent_message_id) || cleanText(agentMessageId) || cleanText(messageId);
-    if (!normalizedMessageId) {
-      throw new Error('agent_message_id is required.');
-    }
-    return this._request(`/api/agent-communications/messages/${encodeURIComponent(normalizedMessageId)}/evidence-links`, {
-      method: 'POST',
-      body: {
-        evidence_type: cleanText(evidence_type) || cleanText(evidenceType),
-        evidence_ref: cleanText(evidence_ref) || cleanText(evidenceRef),
-        source_truth: cleanText(source_truth) || cleanText(sourceTruth),
-        trust_level: cleanText(trust_level) || cleanText(trustLevel) || 'candidate',
-        metadata: isPlainObject(metadata) ? metadata : {},
-      },
-    });
-  }
-
-  async createCommunicationHandoff({
-    workflowRunId,
-    workflow_run_id,
-    title,
-    agentSessionId,
-    agent_session_id,
-    handoffKind,
-    handoff_kind,
-    handoffPriority,
-    handoff_priority,
-    summaryText,
-    summary_text,
-    handoffPayload = {},
-    handoff_payload = {},
-    createdBy,
-    created_by,
-    supersedesHandoffId,
-    supersedes_handoff_id,
-  } = {}) {
-    return this._request('/api/agent-communications/handoffs', {
-      method: 'POST',
-      body: {
-        workflow_run_id: cleanText(workflow_run_id) || cleanText(workflowRunId),
-        title: cleanText(title),
-        agent_session_id: cleanText(agent_session_id) || cleanText(agentSessionId) || this.agentSessionId,
-        handoff_kind: cleanText(handoff_kind) || cleanText(handoffKind) || 'general',
-        handoff_priority: cleanText(handoff_priority) || cleanText(handoffPriority) || 'normal',
-        summary_text: cleanText(summary_text) || cleanText(summaryText),
-        handoff_payload: isPlainObject(handoffPayload)
-          ? handoffPayload
-          : (isPlainObject(handoff_payload) ? handoff_payload : {}),
-        created_by: cleanText(created_by) || cleanText(createdBy),
-        supersedes_handoff_id: cleanText(supersedes_handoff_id) || cleanText(supersedesHandoffId),
-      },
-    });
-  }
-
-  async acceptCommunicationHandoff(handoffId) {
-    return this._request(`/api/agent-communications/handoffs/${encodeURIComponent(handoffId)}/accept`, {
-      method: 'POST',
-      body: {},
-    });
-  }
-
-  async describeDatabaseCatalog({ includeSystemSchemas, limit } = {}) {
-    return this.database.schema.getOverview({ includeSystemSchemas, limit });
-  }
-
-  async listDatabaseSchemas({ includeSystemSchemas, limit } = {}) {
-    return this.database.schema.listSchemas({ includeSystemSchemas, limit });
-  }
-
-  async listDatabaseTables({ schemaName, includeSystemSchemas, limit } = {}) {
-    return this.database.schema.listTables({ schemaName, includeSystemSchemas, limit });
-  }
-
-  async listDatabaseColumns({ schemaName, tableName } = {}) {
-    return this.database.schema.listColumns({ schemaName, tableName });
-  }
-
-  async listDatabaseIndexes({ schemaName, tableName, includeSystemSchemas, limit } = {}) {
-    return this.database.schema.listIndexes({ schemaName, tableName, includeSystemSchemas, limit });
-  }
-
-  async describeDatabaseTable({ schemaName, tableName, includeSystemSchemas } = {}) {
-    return this.database.schema.describeTable({ schemaName, tableName, includeSystemSchemas });
-  }
-
-  async createDatabaseBackup({ databaseName, outputName, noWait } = {}) {
-    return this._request('/api/operator/database/backups', {
-      method: 'POST',
-      body: {
-        database_name: databaseName,
-        output_name: outputName,
-        no_wait: noWait,
-      },
-    });
-  }
-
-  async getExternalProjectStatus(projectId) {
-    return this._request(`/api/v1/projects/${projectId}/status`);
-  }
-
-  async getExternalProjectRoadmapSummary(projectId) {
-    return this._request(`/api/v1/projects/${projectId}/implementation-roadmap/summary`);
-  }
-
-  async getExternalProjectRoadmapActiveItem(projectId) {
-    return this._request(`/api/v1/projects/${projectId}/implementation-roadmap/active-item`);
-  }
-
-  async listExternalProjectOpenTasks(projectId) {
-    return this._request(`/api/v1/projects/${projectId}/open-tasks`);
-  }
-
-  async getExternalProjectStatusBundle(projectId) {
-    return this._request(`/api/v1/projects/${projectId}/status-bundle`);
-  }
-
-  async createExternalAudioRender({ 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 this._request('/api/v1/audio-renders', { method: 'POST', body: form });
-    }
-    return this._request('/api/v1/audio-renders', {
-      method: 'POST',
-      body: { text, voice, model, speed },
-    });
-  }
-
-  async getExternalAudioRender(audioRenderRunId) {
-    return this._request(`/api/v1/audio-renders/${audioRenderRunId}`);
-  }
-
-  async downloadExternalAudioRender(audioRenderRunId) {
-    return this._requestBinary(`/api/v1/audio-renders/${audioRenderRunId}/download`);
-  }
-
-  async listExternalWorkflowRunArtifacts(workflowRunId) {
-    return this._request(`/api/v1/runs/${workflowRunId}/artifacts`);
-  }
-
-  async downloadExternalWorkflowRunArtifact(workflowRunId, artifactType) {
-    return this._requestBinary(`/api/v1/runs/${workflowRunId}/artifacts/${artifactType}/download`);
-  }
-
   // ─── Core HTTP ─────────────────────────────────────────────────────────────
 
   async _resolveAccessToken() {

package/src/compat/aliases.js

@@ -5,6 +5,7 @@ export const COMPATIBILITY_ALIAS_GROUPS = [
       'ping',
       'query',
       'getPortfolioClosureReadiness',
+      'searchCodeByIntent',
       'registerModernizationAsset',
       'classifyModernizationAsset',
       'discoverSalvageCandidates',
@@ -41,6 +42,9 @@ export const COMPATIBILITY_ALIAS_GROUPS = [
   {
     namespace: 'agentCommunications',
     aliases: [
+      'startAgentConnection',
+      'establishAgentCommunicationChannel',
+      'runInterAgentMessagingLoop',
       'bootstrapCommunication',
       'negotiateCommunicationTransfer',
       'resolveCommunicationTarget',
@@ -184,7 +188,7 @@ export function installClientCompatibilityDelegates(ClientClass) {
   defineCompatibilityMethods(proto, 'presence', ['getPresenceBoard', 'getChannelPresence', 'markParticipantOnline', 'markParticipantOffline', 'whoIsOnline', 'findOnlineParticipant', 'sendToParticipant', 'sendToRole', 'postPresenceHeartbeat']);
   defineCompatibilityMethods(proto, 'collaborationDomain', ['reviewCollaborationProposal', 'reviseCollaborationProposal', 'postCollaborationProposal', 'acceptCollaborationProposal', 'assignCollaborationOwnership', 'raiseCollaborationBlocker', 'resolveCollaborationBlocker', 'postCollaborationHeartbeat', 'beginCollaborationImplementation', 'requestCollaborationClosure']);
   defineCompatibilityMethods(proto, 'transferBundles', ['transferWorkPacket', 'getTransferBundle', 'listTransferBundles', 'createTransferReceipt', 'listTransferReceipts', 'createCommunicationBundle', 'getCommunicationBundle', 'listCommunicationBundles', 'addCommunicationBundleItem', 'uploadCommunicationBundle', 'attachCommunicationBundleToMessage', 'recordCommunicationBundleReceipt', 'recordCommunicationBundleCleanupEvent', 'claimCommunicationBundle', 'recordCommunicationTransferReceipt']);
-  defineCompatibilityMethods(proto, 'workflowComposition', ['registerModernizationAsset', 'classifyModernizationAsset', 'discoverSalvageCandidates', 'createModernizationWorkPacket', 'requestModernizationWrapperExecution', 'getModernizationWrapperEvidence', 'decideModernizationGate']);
+  defineCompatibilityMethods(proto, 'workflowComposition', ['registerModernizationAsset', 'classifyModernizationAsset', 'discoverSalvageCandidates', 'createModernizationWorkPacket', 'requestModernizationWrapperExecution', 'getModernizationWrapperEvidence', 'decideModernizationGate', 'searchCodeByIntent']);
   defineCompatibilityMethods(proto, 'currentProject', ['currentProjectStatus']);
   defineCompatibilityMethods(proto, 'projections', ['renderProjection', 'getLogaOperatorHomeProjection', 'getLogaProjectCatalogProjection', 'getLogaProjectPortfolioProjection', 'getLogaProjectRoadmapProjection', 'getLogaRoadmapItemProjection', 'getLogaWorkflowRunProjection', 'getLogaEvidencePacketProjection', 'getLogaTransferHomeProjection', 'getLogaTransferInboxProjection', 'getLogaTransferPacketProjection', 'getLogaTransferNegotiationEventsProjection', 'getLogaTransferFrictionLaneProjection', 'getLogaTransferReceiptsProjection', 'getLogaTransferClosureReviewProjection', 'getTransferChannelProjection']);
   defineCompatibilityAliases(proto, 'projections', { getLogaTransferChannelThreadProjection: 'getTransferChannelProjection' });
@@ -209,7 +213,7 @@ export function installClientCompatibilityDelegates(ClientClass) {
   defineCompatibilityMethods(proto, 'contextSessions', ['openContextSession', 'getOrientationWindow', 'acknowledgeReminder', 'completeOrientation', 'lockContextSessionClaim', 'getContextSessionGateStatus']);
   defineCompatibilityMethods(proto, 'contextOrientation', ['conductOrientation']);
   defineCompatibilityMethods(proto, 'portfolio', ['getPortfolioStatus', 'getPortfolioBundle', 'getPortfolioClosureReadiness']);
-  defineCompatibilityMethods(proto, 'agentCommunications', ['bootstrapCommunication', 'negotiateCommunicationTransfer', 'resolveCommunicationTarget', 'createCommunicationEvidencePacket', 'listCommunicationFrictionTaxonomy', 'recordCommunicationFrictionEvent', 'openCommunicationThread', 'getCommunicationThread', 'listCommunicationInbox', 'getMyInbox', 'verifyMessageSent', 'verifyMessageReceived', 'getMessageDeliveryReceipt', '_sendAgentCommsMessage', 'sendCommunicationMessage', 'acceptCommunicationTransferPacket', 'closeCommunicationTransferPacket', 'getCommunicationTransferHealth', 'acceptCommunicationMessage', 'respondToCommunicationMessage', 'attachCommunicationMessageEvidence', 'createCommunicationHandoff', 'acceptCommunicationHandoff']);
+  defineCompatibilityMethods(proto, 'agentCommunications', ['startAgentConnection', 'establishAgentCommunicationChannel', 'runInterAgentMessagingLoop', 'bootstrapCommunication', 'negotiateCommunicationTransfer', 'resolveCommunicationTarget', 'createCommunicationEvidencePacket', 'listCommunicationFrictionTaxonomy', 'recordCommunicationFrictionEvent', 'openCommunicationThread', 'getCommunicationThread', 'listCommunicationInbox', 'getMyInbox', 'verifyMessageSent', 'verifyMessageReceived', 'getMessageDeliveryReceipt', '_sendAgentCommsMessage', 'sendCommunicationMessage', 'acceptCommunicationTransferPacket', 'closeCommunicationTransferPacket', 'getCommunicationTransferHealth', 'acceptCommunicationMessage', 'respondToCommunicationMessage', 'attachCommunicationMessageEvidence', 'createCommunicationHandoff', 'acceptCommunicationHandoff']);
   defineCompatibilityMethods(proto, 'communicationTickets', ['createCrossAgentRemediationTicket']);
   defineCompatibilityMethods(proto, 'refactoringTransfers', ['transferRefactoringBundle']);
   defineCompatibilityMethods(proto, 'externalProjects', ['getExternalProjectStatus', 'getExternalProjectRoadmapSummary', 'getExternalProjectRoadmapActiveItem', 'listExternalProjectOpenTasks', 'getExternalProjectStatusBundle']);

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);

package/src/index.js

@@ -1,5 +1,5 @@
 export { AIEngineClient, createAIEngineClient } from './client.js';
-export const AI_ENGINE_CLIENT_VERSION = '1.1.99';
+export const AI_ENGINE_CLIENT_VERSION = '1.1.102';
 export { GOVERNED_MUTATION_REQUIRED_CAPABILITIES, AI_ENGINE_CLIENT_CAPABILITIES, TASK_BOUND_SUBSTRATE_EXECUTION_POLICY } from './constants/governance.js';
 export { LOGA_CONTRACT, LOGA_INTERACTION_CONTRACT, LOGA_NAVIGATION_CONTRACT, LOGA_PROJECTION_WORKFLOW } from './constants/loga.js';
 export {

package/src/transport/index.js

@@ -1,4 +1,5 @@
-import { appendQuery, extractLogaProjectionMetadata, isJsonBody, parseContentDispositionFilename, readJson } from '../utils/http.js';
+import { appendQuery, isJsonBody, parseContentDispositionFilename, readJson } from '../utils/request.js';
+import { extractLogaProjectionMetadata } from '../utils/loga.js';
 
 export async function resolveAccessToken(client) {
   if (typeof client.tokenProvider === 'function') {

package/src/utils/communication.js

@@ -16,7 +16,7 @@ function normalizeEnum(value, allowedValues, fallback, label, aliases = {}) {
   const lower = normalized.toLowerCase();
   const match = allowedValues.find((item) => item.toLowerCase() === lower);
   if (match) return match;
-  throw new Error(`Invalid ${label || 'value'}: ${value}`);
+  throw new Error(`${label || 'value'} must be one of ${allowedValues.join(', ')}.`);
 }
 
 export function cleanText(value) {

package/src/utils/loga.js

@@ -0,0 +1 @@
+export { extractLogaProjectionMetadata } from './http.js';

package/src/utils/request.js

@@ -0,0 +1,10 @@
+export {
+  appendQuery,
+  extractLogaProjectionMetadata,
+  isBinaryBody,
+  isFormDataBody,
+  isJsonBody,
+  parseContentDispositionFilename,
+  readJson,
+  readResponseHeader,
+} from './http.js';

package/src/utils/version.js

@@ -0,0 +1,12 @@
+export 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;
+}