@hirey/hi-mcp-server 0.1.1 → 0.1.2

package/node_modules/@hirey/hi-agent-contracts/dist/index.js

@@ -0,0 +1,741 @@
+// Hi external agent gateway 的正式公共合同。
+// 这个包只承载协议常量、类型与输入归一化，不承载任何数据库或 HTTP 逻辑。
+export const AGENT_ENDPOINT_KINDS = ['webhook', 'http_api', 'pull_stream'];
+export const AGENT_DELIVERY_PROFILES = [
+    'generic.event-webhook.v1',
+    'openclaw.hooks.agent.v1',
+    'openresponses.v1',
+    'hi.sse.v1',
+];
+export const AGENT_INSTALLATION_RECEIVING_CAPABILITIES = [
+    'pull_stream',
+    'claim_ack',
+    'generic_webhook',
+    'claude_channel',
+    'openclaw_hooks',
+    'openresponses',
+    'local_receiver',
+];
+export const AGENT_INSTALLATION_RECEIVING_CAPABILITY_STATUSES = ['active', 'disabled'];
+export const AGENT_CAPABILITY_BINDING_PROFILES = [
+    'hi.capability-http.v1',
+    'hi.mcp.tool-call.v1',
+];
+export const AGENT_DELIVERY_ENDPOINT_STATUSES = ['active', 'disabled'];
+export const AGENT_SUBSCRIPTION_STATUSES = ['active', 'disabled'];
+export const AGENT_EVENT_STATUSES = ['queued', 'processing', 'consumed', 'failed'];
+export const AGENT_EVENT_ACK_STATUSES = ['consumed', 'failed', 'queued'];
+export const AGENT_GATEWAY_EVENT_TOPICS = [
+    'agent.message.created',
+    'pairing.created',
+    'pairing.updated',
+    'listing_matching_session.updated',
+    'meeting.negotiation.updated',
+    'meeting.execution.requested',
+];
+export const AGENT_GATEWAY_PUBLIC_SCOPES = [
+    'agent.register',
+    'agent.connect',
+    'agent.activate',
+    'agent.me.read',
+    'agent.installation.read',
+    'agent.installation.write',
+    'agent.endpoints.read',
+    'agent.endpoints.write',
+    'agent.subscriptions.read',
+    'agent.subscriptions.write',
+    'agent.delivery.test',
+    'agent.events.stream',
+    'agent.events.claim',
+    'agent.events.fetch',
+    'agent.events.ack',
+];
+function isPlainObject(input) {
+    return !!input && typeof input === 'object' && !Array.isArray(input);
+}
+export function normalizeText(input) {
+    return String(input || '').trim();
+}
+function normalizeStringArray(input, max) {
+    if (!Array.isArray(input))
+        return [];
+    const values = Array.from(new Set(input
+        .map((value) => normalizeText(value))
+        .filter(Boolean)));
+    return values.slice(0, Math.max(0, max));
+}
+function normalizeJsonRecord(input) {
+    return isPlainObject(input) ? input : null;
+}
+function normalizeNullableUrl(input) {
+    const raw = normalizeText(input);
+    if (!raw)
+        return null;
+    const parsed = new URL(raw);
+    if (!/^https?:$/i.test(parsed.protocol))
+        throw new Error('invalid_agent_endpoint_url');
+    return parsed.toString();
+}
+export function normalizeAgentEndpointKind(input) {
+    const kind = normalizeText(input).toLowerCase();
+    if (AGENT_ENDPOINT_KINDS.includes(kind))
+        return kind;
+    throw new Error('invalid_agent_endpoint_kind');
+}
+export function normalizeAgentDeliveryProfile(input) {
+    const profile = normalizeText(input);
+    if (AGENT_DELIVERY_PROFILES.includes(profile))
+        return profile;
+    throw new Error('invalid_agent_endpoint_profile');
+}
+export function normalizeAgentInstallationReceivingCapabilityKind(input) {
+    const kind = normalizeText(input).toLowerCase();
+    if (AGENT_INSTALLATION_RECEIVING_CAPABILITIES.includes(kind)) {
+        return kind;
+    }
+    throw new Error('invalid_agent_installation_capability_kind');
+}
+export function normalizeAgentInstallationReceivingCapabilityStatus(input) {
+    const status = normalizeText(input).toLowerCase();
+    if (!status)
+        return 'active';
+    if (AGENT_INSTALLATION_RECEIVING_CAPABILITY_STATUSES.includes(status)) {
+        return status;
+    }
+    throw new Error('invalid_agent_installation_capability_status');
+}
+export function normalizeAgentDeliveryEndpointStatus(input) {
+    const status = normalizeText(input).toLowerCase();
+    if (!status)
+        return 'active';
+    if (AGENT_DELIVERY_ENDPOINT_STATUSES.includes(status)) {
+        return status;
+    }
+    throw new Error('invalid_agent_endpoint_status');
+}
+export function normalizeAgentSubscriptionStatus(input) {
+    const status = normalizeText(input).toLowerCase();
+    if (!status)
+        return 'active';
+    if (AGENT_SUBSCRIPTION_STATUSES.includes(status)) {
+        return status;
+    }
+    throw new Error('invalid_agent_subscription_status');
+}
+export function normalizeAgentEventStatus(input) {
+    const status = normalizeText(input).toLowerCase();
+    if (!status)
+        return 'queued';
+    if (AGENT_EVENT_STATUSES.includes(status))
+        return status;
+    throw new Error('invalid_agent_event_status');
+}
+export function normalizeAgentEventAckStatus(input) {
+    const status = normalizeText(input).toLowerCase();
+    if (AGENT_EVENT_ACK_STATUSES.includes(status))
+        return status;
+    throw new Error('invalid_agent_event_ack_status');
+}
+export function normalizeAgentGatewayTopic(input) {
+    const topic = normalizeText(input).toLowerCase();
+    if (AGENT_GATEWAY_EVENT_TOPICS.includes(topic))
+        return topic;
+    throw new Error('unsupported_agent_gateway_topic');
+}
+function normalizeGenericEventWebhookEndpointConfig(input) {
+    if (input == null)
+        return null;
+    const row = isPlainObject(input) ? input : {};
+    const mode = normalizeText(row.mode);
+    if (mode && mode !== 'accepted_is_terminal') {
+        throw new Error('invalid_agent_endpoint_config');
+    }
+    return mode ? { mode: 'accepted_is_terminal' } : null;
+}
+function normalizeOpenClawHooksAgentEndpointConfig(input) {
+    if (input == null)
+        return null;
+    const row = isPlainObject(input) ? input : {};
+    const wakeMode = normalizeText(row.wake_mode);
+    if (wakeMode && wakeMode !== 'now' && wakeMode !== 'next-heartbeat') {
+        throw new Error('invalid_agent_endpoint_config');
+    }
+    const timeoutSeconds = row.timeout_seconds == null || row.timeout_seconds === ''
+        ? null
+        : Number(row.timeout_seconds);
+    if (timeoutSeconds != null && (!Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0)) {
+        throw new Error('invalid_agent_endpoint_config');
+    }
+    return {
+        name: normalizeText(row.name) || null,
+        agent_id: normalizeText(row.agent_id) || null,
+        session_key_prefix: normalizeText(row.session_key_prefix) || null,
+        message_prefix: normalizeText(row.message_prefix) || null,
+        wake_mode: wakeMode ? wakeMode : null,
+        deliver: typeof row.deliver === 'boolean' ? row.deliver : null,
+        channel: normalizeText(row.channel) || null,
+        to: normalizeText(row.to) || null,
+        model: normalizeText(row.model) || null,
+        thinking: normalizeText(row.thinking) || null,
+        timeout_seconds: timeoutSeconds == null ? null : Math.floor(timeoutSeconds),
+    };
+}
+function normalizeOpenResponsesEndpointConfig(input) {
+    const row = isPlainObject(input) ? input : {};
+    const model = normalizeText(row.model);
+    if (!model)
+        throw new Error('invalid_agent_endpoint_config');
+    return {
+        model,
+        agent_id: normalizeText(row.agent_id) || null,
+        session_key: normalizeText(row.session_key) || null,
+        session_key_prefix: normalizeText(row.session_key_prefix) || null,
+        instructions: normalizeText(row.instructions) || null,
+        user: normalizeText(row.user) || null,
+    };
+}
+export function normalizeAgentEndpointConfigForProfile(profile, input) {
+    if (profile === 'generic.event-webhook.v1') {
+        return normalizeGenericEventWebhookEndpointConfig(input);
+    }
+    if (profile === 'openclaw.hooks.agent.v1') {
+        return normalizeOpenClawHooksAgentEndpointConfig(input);
+    }
+    if (profile === 'openresponses.v1') {
+        return normalizeOpenResponsesEndpointConfig(input);
+    }
+    if (profile === 'hi.sse.v1') {
+        if (input == null)
+            return null;
+        if (!isPlainObject(input) || Object.keys(input).length === 0)
+            return null;
+        throw new Error('invalid_agent_endpoint_config');
+    }
+    return normalizeJsonRecord(input);
+}
+export function normalizeAgentEndpointInput(input) {
+    const row = isPlainObject(input) ? input : {};
+    const kind = normalizeAgentEndpointKind(row.kind);
+    const profile = normalizeAgentDeliveryProfile(row.profile);
+    const url = profile === 'hi.sse.v1'
+        ? null
+        : normalizeNullableUrl(row.url);
+    return {
+        kind,
+        profile,
+        status: normalizeAgentDeliveryEndpointStatus(row.status),
+        capability_ids: normalizeStringArray(row.capability_ids, 100),
+        url,
+        auth: normalizeJsonRecord(row.auth),
+        config: normalizeAgentEndpointConfigForProfile(profile, row.config),
+    };
+}
+export const normalizeAgentDeliveryEndpointInput = normalizeAgentEndpointInput;
+export function normalizeAgentEndpointList(input) {
+    if (isPlainObject(input) && Array.isArray(input.endpoints)) {
+        return input.endpoints.map((row) => normalizeAgentEndpointInput(row));
+    }
+    if (Array.isArray(input)) {
+        return input.map((row) => normalizeAgentEndpointInput(row));
+    }
+    if (isPlainObject(input)) {
+        if (Object.prototype.hasOwnProperty.call(input, 'kind')) {
+            return [normalizeAgentEndpointInput(input)];
+        }
+        if (isPlainObject(input.endpoint)) {
+            return [normalizeAgentEndpointInput(input.endpoint)];
+        }
+    }
+    throw new Error('missing_agent_endpoints');
+}
+export const normalizeAgentDeliveryEndpointList = normalizeAgentEndpointList;
+export function normalizeAgentSubscriptionInput(input) {
+    const row = isPlainObject(input) ? input : {};
+    return {
+        topic: normalizeAgentGatewayTopic(row.topic),
+        status: normalizeAgentSubscriptionStatus(row.status),
+        filter: normalizeJsonRecord(row.filter),
+    };
+}
+export function normalizeAgentSubscriptionList(input) {
+    if (isPlainObject(input) && Array.isArray(input.subscriptions)) {
+        return input.subscriptions.map((row) => normalizeAgentSubscriptionInput(row));
+    }
+    if (Array.isArray(input)) {
+        return input.map((row) => normalizeAgentSubscriptionInput(row));
+    }
+    if (isPlainObject(input)) {
+        if (Object.prototype.hasOwnProperty.call(input, 'topic')) {
+            return [normalizeAgentSubscriptionInput(input)];
+        }
+        if (isPlainObject(input.subscription)) {
+            return [normalizeAgentSubscriptionInput(input.subscription)];
+        }
+    }
+    throw new Error('missing_agent_subscriptions');
+}
+export function normalizeAgentInstallationReceivingCapabilityInput(input) {
+    const row = isPlainObject(input) ? input : {};
+    return {
+        kind: normalizeAgentInstallationReceivingCapabilityKind(row.kind),
+        status: normalizeAgentInstallationReceivingCapabilityStatus(row.status),
+        config: normalizeJsonRecord(row.config),
+    };
+}
+export function normalizeAgentInstallationDeliveryDeclaration(input) {
+    if (input == null)
+        return null;
+    const row = isPlainObject(input) ? input : {};
+    const sourceCapabilities = Array.isArray(row.capabilities)
+        ? row.capabilities
+        : (Array.isArray(input) ? input : []);
+    const deduped = new Map();
+    for (const entry of sourceCapabilities) {
+        const normalized = normalizeAgentInstallationReceivingCapabilityInput(entry);
+        deduped.set(normalized.kind, normalized);
+    }
+    const capabilities = Array.from(deduped.values());
+    const preferredRaw = normalizeText(row.preferred);
+    const preferred = preferredRaw
+        ? normalizeAgentInstallationReceivingCapabilityKind(preferredRaw)
+        : null;
+    if (preferred && !capabilities.some((entry) => entry.kind === preferred && entry.status !== 'disabled')) {
+        throw new Error('invalid_agent_installation_preferred_capability');
+    }
+    return {
+        capabilities,
+        preferred,
+    };
+}
+export function applyAgentInstallationDeliveryDeclarationMetadata(metadata, declaration) {
+    const next = metadata ? { ...metadata } : {};
+    if (declaration == null) {
+        delete next.delivery_capabilities;
+    }
+    else {
+        next.delivery_capabilities = declaration;
+    }
+    return Object.keys(next).length > 0 ? next : null;
+}
+export function extractAgentInstallationDeliveryDeclaration(metadata) {
+    if (!metadata || !isPlainObject(metadata))
+        return null;
+    if (!Object.prototype.hasOwnProperty.call(metadata, 'delivery_capabilities'))
+        return null;
+    return normalizeAgentInstallationDeliveryDeclaration(metadata.delivery_capabilities);
+}
+export function normalizeAgentGatewayResourceRef(input) {
+    const row = isPlainObject(input) ? input : {};
+    const resourceType = normalizeText(row.resource_type);
+    const resourceId = normalizeText(row.resource_id);
+    if (!resourceType || !resourceId) {
+        throw new Error('invalid_agent_gateway_resource_ref');
+    }
+    return {
+        resource_type: resourceType,
+        resource_id: resourceId,
+        scope_type: normalizeText(row.scope_type) || null,
+        scope_id: normalizeText(row.scope_id) || null,
+        pairing_id: normalizeText(row.pairing_id) || null,
+        conversation_id: normalizeText(row.conversation_id) || null,
+        source_message_id: normalizeText(row.source_message_id) || null,
+    };
+}
+export function normalizeAgentGatewayPreview(input) {
+    const row = isPlainObject(input) ? input : null;
+    if (!row)
+        return null;
+    const preview = {
+        title: normalizeText(row.title) || null,
+        text: normalizeText(row.text) || null,
+        actor_agent_id: normalizeText(row.actor_agent_id) || null,
+        status: normalizeText(row.status) || null,
+        direction: normalizeText(row.direction) || null,
+    };
+    return Object.values(preview).some((value) => !!value) ? preview : null;
+}
+export function parseAgentEventAfterSeq(input) {
+    if (input == null || input === '')
+        return 0;
+    const value = Number(input);
+    if (!Number.isFinite(value) || value < 0)
+        throw new Error('invalid_agent_event_after_seq');
+    return Math.floor(value);
+}
+export function parseAgentEventBatchLimit(input, fallback = 20, max = 100) {
+    if (input == null || input === '')
+        return fallback;
+    const value = Number(input);
+    if (!Number.isFinite(value) || value <= 0)
+        throw new Error('invalid_agent_event_batch_limit');
+    return Math.max(1, Math.min(max, Math.floor(value)));
+}
+export function parseAgentEventRetryAfterMs(input) {
+    if (input == null || input === '')
+        return null;
+    const value = Number(input);
+    if (!Number.isFinite(value) || value < 0)
+        throw new Error('invalid_agent_event_retry_after_ms');
+    return Math.floor(value);
+}
+export function buildAgentEventFetchUri(eventId) {
+    return `/v1/agent-events/${normalizeText(eventId)}`;
+}
+export const GATE_ANCHOR_TYPES = ['crm_message_id', 'call_intent_id', 'system_event_id'];
+export const MEETING_MODALITIES = ['phone', 'zoom'];
+export const MEETING_NEGOTIATION_ACTIONS = ['propose', 'reschedule', 'commit', 'cancel'];
+export const MEETING_PROPOSAL_APPROVAL_KINDS = ['select', 'approve', 'reject'];
+const MEETING_EXECUTION_OPERATIONS = [
+    'schedule_zoom',
+    'schedule_phone',
+    'change_zoom',
+    'change_phone',
+    'cancel_zoom',
+    'cancel_phone',
+];
+function toNullableInt(input) {
+    if (input == null || input === '')
+        return null;
+    const value = Number(input);
+    if (!Number.isFinite(value))
+        return null;
+    return Math.floor(value);
+}
+function toNullableBoolean(input) {
+    if (input === true)
+        return true;
+    if (input === false)
+        return false;
+    return null;
+}
+export function normalizeGateAnchor(input) {
+    if (!isPlainObject(input))
+        return { ok: false, reason: 'missing_anchor' };
+    const type = normalizeText(input.type);
+    const id = normalizeText(input.id);
+    if (!type && !id)
+        return { ok: false, reason: 'missing_anchor' };
+    if (!type || !id || !GATE_ANCHOR_TYPES.includes(type)) {
+        return {
+            ok: false,
+            reason: 'invalid_anchor',
+            detail: {
+                received_type: type || null,
+                received_id: id || null,
+            },
+        };
+    }
+    return { ok: true, anchor: { type: type, id } };
+}
+export function normalizeMeetingCommitToken(input) {
+    if (!isPlainObject(input)) {
+        return {
+            ok: false,
+            reason: 'missing_commit_token',
+            missing_fields: ['commit_token'],
+            detail: {
+                received_type: input == null ? 'null' : (Array.isArray(input) ? 'array' : typeof input),
+            },
+        };
+    }
+    const ticketId = normalizeText(input.ticket_id || input.id);
+    const scenario = normalizeText(input.scenario).toLowerCase();
+    const missingFields = [];
+    if (!ticketId)
+        missingFields.push('commit_token.ticket_id');
+    if (!scenario)
+        missingFields.push('commit_token.scenario');
+    let anchor = null;
+    if ((input.anchor ?? null) !== null) {
+        const anchorResult = normalizeGateAnchor(input.anchor);
+        if (!anchorResult.ok) {
+            return {
+                ok: false,
+                reason: anchorResult.reason === 'missing_anchor' ? 'missing_commit_token' : 'invalid_commit_token',
+                missing_fields: ['commit_token.anchor.type', 'commit_token.anchor.id'],
+                detail: anchorResult.detail,
+            };
+        }
+        anchor = anchorResult.anchor;
+    }
+    if (missingFields.length > 0) {
+        return {
+            ok: false,
+            reason: 'invalid_commit_token',
+            missing_fields: Array.from(new Set(missingFields)),
+        };
+    }
+    return {
+        ok: true,
+        token: {
+            ticket_id: ticketId,
+            scenario,
+            status: normalizeText(input.status) || null,
+            version: toNullableInt(input.version),
+            anchor,
+            left_committed: toNullableBoolean(input.left_committed),
+            right_committed: toNullableBoolean(input.right_committed),
+        },
+    };
+}
+export function buildMeetingCommitToken(input) {
+    const ticket = isPlainObject(input.ticket) ? input.ticket : null;
+    if (!ticket)
+        return null;
+    const ticketId = normalizeText(ticket.ticket_id || ticket.id);
+    const scenario = (normalizeText(ticket.scenario) || normalizeText(input.fallback_scenario)).toLowerCase();
+    if (!ticketId || !scenario)
+        return null;
+    let anchor = null;
+    if ((ticket.anchor ?? null) !== null) {
+        const anchorResult = normalizeGateAnchor(ticket.anchor);
+        if (!anchorResult.ok)
+            return null;
+        anchor = anchorResult.anchor;
+    }
+    else if (input.fallback_anchor) {
+        anchor = input.fallback_anchor;
+    }
+    return {
+        ticket_id: ticketId,
+        scenario,
+        status: normalizeText(ticket.status) || null,
+        version: toNullableInt(ticket.version),
+        anchor,
+        left_committed: toNullableBoolean(ticket.left_committed),
+        right_committed: toNullableBoolean(ticket.right_committed),
+    };
+}
+function normalizeMeetingProposalApprovalKind(input) {
+    const value = normalizeText(input).toLowerCase();
+    return MEETING_PROPOSAL_APPROVAL_KINDS.includes(value)
+        ? value
+        : '';
+}
+export function normalizeMeetingProposalApprovalRef(input) {
+    if (!isPlainObject(input))
+        return null;
+    const approvalId = normalizeText(input.approval_id || input.id);
+    const proposalId = normalizeText(input.proposal_id);
+    const pairingId = normalizeText(input.pairing_id);
+    const approvalKind = normalizeMeetingProposalApprovalKind(input.approval_kind);
+    const sourceAgentId = normalizeText(input.source_agent_id);
+    const sourceMessageId = normalizeText(input.source_message_id);
+    const responseText = normalizeText(input.response_text);
+    const selectedOptionKey = normalizeText(input.selected_option_key) || null;
+    const slotKey = normalizeText(input.slot_key) || null;
+    if (!approvalId || !proposalId || !pairingId || !approvalKind || !sourceAgentId || !sourceMessageId || !responseText) {
+        return null;
+    }
+    return {
+        approval_id: approvalId,
+        proposal_id: proposalId,
+        pairing_id: pairingId,
+        approval_kind: approvalKind,
+        source_agent_id: sourceAgentId,
+        source_message_id: sourceMessageId,
+        response_text: responseText,
+        selected_option_key: selectedOptionKey,
+        slot_key: slotKey,
+    };
+}
+export function normalizeMeetingCommitAuthorityRef(input) {
+    if (!isPlainObject(input))
+        return null;
+    const pairingId = normalizeText(input.pairing_id);
+    const scenario = normalizeText(input.scenario).toLowerCase();
+    const modality = normalizeText(input.modality).toLowerCase();
+    const negotiationKey = normalizeText(input.negotiation_key);
+    const negotiationVersion = toNullableInt(input.negotiation_version);
+    const proposalId = normalizeText(input.proposal_id) || null;
+    const slotKey = normalizeText(input.slot_key);
+    const slotStartAt = normalizeText(input.slot_start_at) || null;
+    const slotEndAt = normalizeText(input.slot_end_at) || null;
+    const timezone = normalizeText(input.timezone) || null;
+    const durationMinutes = toNullableInt(input.duration_minutes);
+    const sourceAgentId = normalizeText(input.source_agent_id);
+    const targetAgentId = normalizeText(input.target_agent_id);
+    const sourceMessageId = normalizeText(input.source_message_id);
+    const targetMessageId = normalizeText(input.target_message_id);
+    if (!pairingId
+        || !scenario
+        || !MEETING_MODALITIES.includes(modality)
+        || !negotiationKey
+        || negotiationVersion == null
+        || !slotKey
+        || !sourceAgentId
+        || !targetAgentId
+        || !sourceMessageId
+        || !targetMessageId) {
+        return null;
+    }
+    return {
+        pairing_id: pairingId,
+        scenario,
+        modality: modality,
+        negotiation_key: negotiationKey,
+        negotiation_version: negotiationVersion,
+        proposal_id: proposalId,
+        slot_key: slotKey,
+        slot_start_at: slotStartAt,
+        slot_end_at: slotEndAt,
+        timezone,
+        duration_minutes: durationMinutes,
+        source_agent_id: sourceAgentId,
+        target_agent_id: targetAgentId,
+        source_message_id: sourceMessageId,
+        target_message_id: targetMessageId,
+    };
+}
+export function normalizeMeetingAuthorityBindingRef(input) {
+    if (!isPlainObject(input))
+        return null;
+    const authorityBindingId = normalizeText(input.authority_binding_id || input.binding_id || input.id);
+    const pairingId = normalizeText(input.pairing_id);
+    const proposalId = normalizeText(input.proposal_id);
+    const proposalApprovalId = normalizeText(input.proposal_approval_id);
+    const commitAuthorityId = normalizeText(input.commit_authority_id);
+    const negotiationKey = normalizeText(input.negotiation_key);
+    const negotiationVersion = toNullableInt(input.negotiation_version);
+    const slotKey = normalizeText(input.slot_key);
+    const sourceAgentId = normalizeText(input.source_agent_id);
+    const targetAgentId = normalizeText(input.target_agent_id);
+    const sourceMessageId = normalizeText(input.source_message_id);
+    const targetMessageId = normalizeText(input.target_message_id);
+    if (!authorityBindingId
+        || !pairingId
+        || !proposalId
+        || !proposalApprovalId
+        || !commitAuthorityId
+        || !negotiationKey
+        || negotiationVersion == null
+        || !slotKey
+        || !sourceAgentId
+        || !targetAgentId
+        || !sourceMessageId
+        || !targetMessageId) {
+        return null;
+    }
+    return {
+        authority_binding_id: authorityBindingId,
+        pairing_id: pairingId,
+        proposal_id: proposalId,
+        proposal_approval_id: proposalApprovalId,
+        commit_authority_id: commitAuthorityId,
+        negotiation_key: negotiationKey,
+        negotiation_version: negotiationVersion,
+        slot_key: slotKey,
+        source_agent_id: sourceAgentId,
+        target_agent_id: targetAgentId,
+        source_message_id: sourceMessageId,
+        target_message_id: targetMessageId,
+    };
+}
+export function normalizeMeetingExecutionTypedRefs(input) {
+    if (!isPlainObject(input))
+        return null;
+    const proposalId = normalizeText(input.proposal_id);
+    const proposalApprovalId = normalizeText(input.proposal_approval_id);
+    const commitAuthorityId = normalizeText(input.commit_authority_id);
+    const authorityBindingId = normalizeText(input.authority_binding_id);
+    if (!proposalId || !proposalApprovalId || !commitAuthorityId || !authorityBindingId)
+        return null;
+    const proposalApprovalRef = input.proposal_approval_ref == null
+        ? null
+        : normalizeMeetingProposalApprovalRef(input.proposal_approval_ref);
+    const commitAuthorityRef = input.commit_authority_ref == null
+        ? null
+        : normalizeMeetingCommitAuthorityRef(input.commit_authority_ref);
+    const authorityBindingRef = input.authority_binding_ref == null
+        ? null
+        : normalizeMeetingAuthorityBindingRef(input.authority_binding_ref);
+    if (input.proposal_approval_ref != null && !proposalApprovalRef)
+        return null;
+    if (input.commit_authority_ref != null && !commitAuthorityRef)
+        return null;
+    if (input.authority_binding_ref != null && !authorityBindingRef)
+        return null;
+    return {
+        proposal_id: proposalId,
+        proposal_approval_id: proposalApprovalId,
+        commit_authority_id: commitAuthorityId,
+        authority_binding_id: authorityBindingId,
+        proposal_approval_ref: proposalApprovalRef,
+        commit_authority_ref: commitAuthorityRef,
+        authority_binding_ref: authorityBindingRef,
+    };
+}
+export function normalizeMeetingExecutionCommand(input) {
+    if (!isPlainObject(input))
+        return null;
+    const executionId = normalizeText(input.execution_id);
+    const outboxId = normalizeText(input.outbox_id);
+    const negotiationId = normalizeText(input.negotiation_id);
+    const negotiationKey = normalizeText(input.negotiation_key);
+    const pairingId = normalizeText(input.pairing_id);
+    const scenario = normalizeText(input.scenario).toLowerCase();
+    const modality = normalizeText(input.modality).toLowerCase();
+    const operation = normalizeText(input.operation).toLowerCase();
+    const sourceAgentId = normalizeText(input.source_agent_id);
+    const targetAgentId = normalizeText(input.target_agent_id);
+    const payload = isPlainObject(input.payload) ? { ...input.payload } : null;
+    const participantAgentIds = normalizeStringArray(input.participant_agent_ids, 100);
+    const taskRefIds = normalizeStringArray(input.task_ref_ids, 100);
+    const needRefIds = normalizeStringArray(input.need_ref_ids, 100);
+    if (!executionId
+        || !outboxId
+        || !negotiationId
+        || !negotiationKey
+        || !pairingId
+        || !scenario
+        || !MEETING_MODALITIES.includes(modality)
+        || !MEETING_EXECUTION_OPERATIONS.includes(operation)
+        || !sourceAgentId
+        || !targetAgentId
+        || !payload) {
+        return null;
+    }
+    const commitTokenResult = input.commit_token == null ? null : normalizeMeetingCommitToken(input.commit_token);
+    if (input.commit_token != null && !(commitTokenResult && commitTokenResult.ok))
+        return null;
+    const typedRefs = input.typed_refs == null ? null : normalizeMeetingExecutionTypedRefs(input.typed_refs);
+    if (input.typed_refs != null && !typedRefs)
+        return null;
+    return {
+        execution_id: executionId,
+        outbox_id: outboxId,
+        negotiation_id: negotiationId,
+        negotiation_key: negotiationKey,
+        pairing_id: pairingId,
+        scenario,
+        modality: modality,
+        operation: operation,
+        source_agent_id: sourceAgentId,
+        target_agent_id: targetAgentId,
+        pairing_kind: normalizeText(input.pairing_kind) || null,
+        participant_agent_ids: participantAgentIds.length > 0 ? participantAgentIds : null,
+        task_ref_ids: taskRefIds.length > 0 ? taskRefIds : null,
+        need_ref_ids: needRefIds.length > 0 ? needRefIds : null,
+        commit_token: commitTokenResult && commitTokenResult.ok ? commitTokenResult.token : null,
+        authority_binding_id: normalizeText(input.authority_binding_id) || null,
+        typed_refs: typedRefs,
+        payload,
+        created_at: normalizeText(input.created_at) || null,
+    };
+}
+export function normalizeMeetingExecutionReceipt(input) {
+    if (!isPlainObject(input))
+        return null;
+    const executionId = normalizeText(input.execution_id);
+    const outboxId = normalizeText(input.outbox_id);
+    const status = normalizeText(input.status).toLowerCase();
+    if (!executionId || !outboxId || (status !== 'sent' && status !== 'failed'))
+        return null;
+    return {
+        execution_id: executionId,
+        outbox_id: outboxId,
+        status: status,
+        result: isPlainObject(input.result) ? { ...input.result } : null,
+        error: normalizeText(input.error) || null,
+    };
+}