macp-sdk-typescript 0.2.0

package/dist/envelope.d.ts

@@ -0,0 +1,50 @@
+import type { CommitmentPayload, Envelope, Root, SessionStartPayload } from './types';
+export declare function newSessionId(): string;
+export declare function newMessageId(): string;
+export declare function newCommitmentId(): string;
+export declare function nowUnixMs(): number;
+export declare function encodeContext(context?: Buffer | string | Record<string, unknown>): Buffer;
+export declare function buildSessionStartPayload(input: {
+    intent: string;
+    participants: string[];
+    ttlMs: number;
+    modeVersion?: string;
+    configurationVersion?: string;
+    policyVersion?: string;
+    context?: Buffer | string | Record<string, unknown>;
+    roots?: Root[];
+}): SessionStartPayload;
+export declare function inferOutcomePositive(action: string): boolean;
+export declare function buildCommitmentPayload(input: {
+    action: string;
+    authorityScope: string;
+    reason: string;
+    commitmentId?: string;
+    modeVersion?: string;
+    configurationVersion?: string;
+    policyVersion?: string;
+    outcomePositive?: boolean;
+}): CommitmentPayload;
+export declare function buildRoot(uri: string, name?: string): Root;
+/**
+ * Type-erasure helper for protobuf payload encoders.
+ *
+ * `ProtoRegistry.encodeKnownPayload(mode, messageType, value)` accepts a
+ * `Record<string, unknown>` because it does reflective field lookup. Our
+ * mode-specific payload interfaces (e.g. `DecisionProposalPayload`) carry
+ * stricter field types, so every call site otherwise ends up with
+ * `input as unknown as Record<string, unknown>`. Centralising the coercion
+ * keeps the `as unknown as` explanation in one place — the helper never
+ * narrows, it only erases.
+ */
+export declare function toProtoPayload<T extends object>(input: T): Record<string, unknown>;
+export declare function buildEnvelope(input: {
+    mode: string;
+    messageType: string;
+    sessionId: string;
+    payload: Buffer;
+    sender?: string;
+    messageId?: string;
+    macpVersion?: string;
+    timestampUnixMs?: string | number;
+}): Envelope;

package/dist/envelope.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newSessionId = newSessionId;
+exports.newMessageId = newMessageId;
+exports.newCommitmentId = newCommitmentId;
+exports.nowUnixMs = nowUnixMs;
+exports.encodeContext = encodeContext;
+exports.buildSessionStartPayload = buildSessionStartPayload;
+exports.inferOutcomePositive = inferOutcomePositive;
+exports.buildCommitmentPayload = buildCommitmentPayload;
+exports.buildRoot = buildRoot;
+exports.toProtoPayload = toProtoPayload;
+exports.buildEnvelope = buildEnvelope;
+const node_crypto_1 = require("node:crypto");
+const constants_1 = require("./constants");
+function newSessionId() {
+    return (0, node_crypto_1.randomUUID)();
+}
+function newMessageId() {
+    return (0, node_crypto_1.randomUUID)();
+}
+function newCommitmentId() {
+    return (0, node_crypto_1.randomUUID)();
+}
+function nowUnixMs() {
+    return Date.now();
+}
+function encodeContext(context) {
+    if (!context)
+        return Buffer.alloc(0);
+    if (Buffer.isBuffer(context))
+        return context;
+    if (typeof context === 'string')
+        return Buffer.from(context, 'utf8');
+    return Buffer.from(JSON.stringify(context), 'utf8');
+}
+function buildSessionStartPayload(input) {
+    return {
+        intent: input.intent,
+        participants: input.participants,
+        modeVersion: input.modeVersion ?? constants_1.DEFAULT_MODE_VERSION,
+        configurationVersion: input.configurationVersion ?? constants_1.DEFAULT_CONFIGURATION_VERSION,
+        policyVersion: input.policyVersion ?? constants_1.DEFAULT_POLICY_VERSION,
+        ttlMs: input.ttlMs,
+        context: encodeContext(input.context),
+        roots: input.roots ?? [],
+    };
+}
+const NEGATIVE_SUFFIXES = ['rejected', 'failed', 'declined'];
+function inferOutcomePositive(action) {
+    const lower = action.toLowerCase();
+    if (NEGATIVE_SUFFIXES.some((s) => lower.endsWith(s)))
+        return false;
+    return true;
+}
+function buildCommitmentPayload(input) {
+    return {
+        commitmentId: input.commitmentId ?? newCommitmentId(),
+        action: input.action,
+        authorityScope: input.authorityScope,
+        reason: input.reason,
+        modeVersion: input.modeVersion ?? constants_1.DEFAULT_MODE_VERSION,
+        configurationVersion: input.configurationVersion ?? constants_1.DEFAULT_CONFIGURATION_VERSION,
+        policyVersion: input.policyVersion ?? constants_1.DEFAULT_POLICY_VERSION,
+        outcomePositive: input.outcomePositive ?? inferOutcomePositive(input.action),
+    };
+}
+function buildRoot(uri, name = '') {
+    return { uri, name };
+}
+/**
+ * Type-erasure helper for protobuf payload encoders.
+ *
+ * `ProtoRegistry.encodeKnownPayload(mode, messageType, value)` accepts a
+ * `Record<string, unknown>` because it does reflective field lookup. Our
+ * mode-specific payload interfaces (e.g. `DecisionProposalPayload`) carry
+ * stricter field types, so every call site otherwise ends up with
+ * `input as unknown as Record<string, unknown>`. Centralising the coercion
+ * keeps the `as unknown as` explanation in one place — the helper never
+ * narrows, it only erases.
+ */
+function toProtoPayload(input) {
+    return input;
+}
+function buildEnvelope(input) {
+    const ts = input.timestampUnixMs ?? nowUnixMs();
+    return {
+        macpVersion: input.macpVersion ?? constants_1.MACP_VERSION,
+        mode: input.mode,
+        messageType: input.messageType,
+        messageId: input.messageId ?? newMessageId(),
+        sessionId: input.sessionId,
+        sender: input.sender ?? '',
+        timestampUnixMs: String(ts),
+        payload: input.payload,
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,44 @@
+import type { Ack } from './types';
+export declare class MacpSdkError extends Error {
+    constructor(message: string);
+}
+export declare class MacpTransportError extends MacpSdkError {
+    constructor(message: string);
+}
+export declare class MacpAckError extends MacpSdkError {
+    readonly ack: Ack;
+    /** Optional gRPC trailing metadata for extracting additional error details. */
+    readonly grpcMetadata?: Array<{
+        key: string;
+        value: string | Buffer;
+    }>;
+    constructor(ack: Ack, grpcMetadata?: Array<{
+        key: string;
+        value: string | Buffer;
+    }>);
+    /** Extract structured denial reasons from the ACK error details and/or gRPC trailing metadata. */
+    get reasons(): string[];
+    private _parseAckReasons;
+    private _parseGrpcMetadataReasons;
+}
+export declare class MacpSessionError extends MacpSdkError {
+    constructor(message: string);
+}
+export declare class MacpTimeoutError extends MacpTransportError {
+    constructor(message: string);
+}
+export declare class MacpRetryError extends MacpTransportError {
+    constructor(message: string);
+}
+/**
+ * Raised when an explicit `sender` supplied to a mode helper conflicts with
+ * the authenticated identity declared on {@link AuthConfig.expectedSender}.
+ *
+ * Surfaced by the SDK rather than the runtime so agents fail fast before
+ * forging an envelope the runtime would reject (RFC-MACP-0004 §4).
+ */
+export declare class MacpIdentityMismatchError extends MacpSdkError {
+    readonly expectedSender: string;
+    readonly actualSender: string;
+    constructor(expectedSender: string, actualSender: string);
+}

package/dist/errors.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MacpIdentityMismatchError = exports.MacpRetryError = exports.MacpTimeoutError = exports.MacpSessionError = exports.MacpAckError = exports.MacpTransportError = exports.MacpSdkError = void 0;
+class MacpSdkError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MacpSdkError';
+    }
+}
+exports.MacpSdkError = MacpSdkError;
+class MacpTransportError extends MacpSdkError {
+    constructor(message) {
+        super(message);
+        this.name = 'MacpTransportError';
+    }
+}
+exports.MacpTransportError = MacpTransportError;
+class MacpAckError extends MacpSdkError {
+    ack;
+    /** Optional gRPC trailing metadata for extracting additional error details. */
+    grpcMetadata;
+    constructor(ack, grpcMetadata) {
+        super(`${ack.error?.code ?? 'UNKNOWN'}: ${ack.error?.message ?? 'runtime returned nack'}`);
+        this.name = 'MacpAckError';
+        this.ack = ack;
+        this.grpcMetadata = grpcMetadata;
+    }
+    /** Extract structured denial reasons from the ACK error details and/or gRPC trailing metadata. */
+    get reasons() {
+        // First try: parse from ack.error.details (matches Python _parse_ack_reasons)
+        const fromDetails = this._parseAckReasons();
+        if (fromDetails.length > 0)
+            return fromDetails;
+        // Second try: parse from gRPC trailing metadata (matches Python _parse_grpc_metadata_reasons)
+        return this._parseGrpcMetadataReasons();
+    }
+    _parseAckReasons() {
+        if (!this.ack.error?.details)
+            return [];
+        try {
+            const details = this.ack.error.details;
+            const raw = Buffer.isBuffer(details) ? details.toString('utf-8') : String(details);
+            const parsed = JSON.parse(raw);
+            const reasons = parsed.reasons;
+            return Array.isArray(reasons) ? reasons : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    _parseGrpcMetadataReasons() {
+        if (!this.grpcMetadata)
+            return [];
+        try {
+            for (const item of this.grpcMetadata) {
+                if (item.key === 'macp-error-details-bin') {
+                    const data = Buffer.isBuffer(item.value)
+                        ? item.value.toString('utf-8')
+                        : typeof item.value === 'string'
+                            ? item.value
+                            : Buffer.from(item.value).toString('utf-8');
+                    const parsed = JSON.parse(data);
+                    const reasons = parsed.reasons;
+                    return Array.isArray(reasons) ? reasons : [];
+                }
+            }
+        }
+        catch {
+            // Intentionally swallowed — matches Python's bare except
+        }
+        return [];
+    }
+}
+exports.MacpAckError = MacpAckError;
+class MacpSessionError extends MacpSdkError {
+    constructor(message) {
+        super(message);
+        this.name = 'MacpSessionError';
+    }
+}
+exports.MacpSessionError = MacpSessionError;
+class MacpTimeoutError extends MacpTransportError {
+    constructor(message) {
+        super(message);
+        this.name = 'MacpTimeoutError';
+    }
+}
+exports.MacpTimeoutError = MacpTimeoutError;
+class MacpRetryError extends MacpTransportError {
+    constructor(message) {
+        super(message);
+        this.name = 'MacpRetryError';
+    }
+}
+exports.MacpRetryError = MacpRetryError;
+/**
+ * Raised when an explicit `sender` supplied to a mode helper conflicts with
+ * the authenticated identity declared on {@link AuthConfig.expectedSender}.
+ *
+ * Surfaced by the SDK rather than the runtime so agents fail fast before
+ * forging an envelope the runtime would reject (RFC-MACP-0004 §4).
+ */
+class MacpIdentityMismatchError extends MacpSdkError {
+    expectedSender;
+    actualSender;
+    constructor(expectedSender, actualSender) {
+        super(`envelope sender "${actualSender}" does not match the authenticated identity "${expectedSender}"; ` +
+            'remove the explicit sender or reconfigure Auth.bearer(token, { expectedSender })');
+        this.name = 'MacpIdentityMismatchError';
+        this.expectedSender = expectedSender;
+        this.actualSender = actualSender;
+    }
+}
+exports.MacpIdentityMismatchError = MacpIdentityMismatchError;

package/dist/handoff.d.ts

@@ -0,0 +1,73 @@
+import { type AuthConfig } from './auth';
+import type { MacpClient, MacpStream } from './client';
+import { HandoffProjection } from './projections/handoff';
+import type { Ack, HandoffAcceptPayload, HandoffContextPayload, HandoffDeclinePayload, HandoffOfferPayload, SessionMetadata } from './types';
+interface HandoffSessionOptions {
+    sessionId?: string;
+    modeVersion?: string;
+    configurationVersion?: string;
+    policyVersion?: string;
+    auth?: AuthConfig;
+}
+export declare class HandoffSession {
+    readonly client: MacpClient;
+    readonly sessionId: string;
+    readonly modeVersion: string;
+    readonly configurationVersion: string;
+    readonly policyVersion: string;
+    readonly auth?: AuthConfig;
+    readonly projection: HandoffProjection;
+    constructor(client: MacpClient, options?: HandoffSessionOptions);
+    private senderFor;
+    private sendAndTrack;
+    start(input: {
+        intent: string;
+        participants: string[];
+        ttlMs: number;
+        context?: Buffer | string | Record<string, unknown>;
+        roots?: {
+            uri: string;
+            name?: string;
+        }[];
+        sender?: string;
+    }): Promise<Ack>;
+    offer(input: HandoffOfferPayload & {
+        sender?: string;
+        auth?: AuthConfig;
+    }): Promise<Ack>;
+    addContext(input: HandoffContextPayload & {
+        sender?: string;
+        auth?: AuthConfig;
+    }): Promise<Ack>;
+    /**
+     * @deprecated Use {@link addContext} instead. Scheduled for removal in 0.4.0.
+     * First call logs a one-shot warning to guide migrations without spamming long-lived processes.
+     */
+    sendContext(input: HandoffContextPayload & {
+        sender?: string;
+        auth?: AuthConfig;
+    }): Promise<Ack>;
+    acceptHandoff(input: HandoffAcceptPayload & {
+        sender?: string;
+        auth?: AuthConfig;
+    }): Promise<Ack>;
+    decline(input: HandoffDeclinePayload & {
+        sender?: string;
+        auth?: AuthConfig;
+    }): Promise<Ack>;
+    commit(input: {
+        action: string;
+        authorityScope: string;
+        reason: string;
+        commitmentId?: string;
+        outcomePositive?: boolean;
+        sender?: string;
+        auth?: AuthConfig;
+    }): Promise<Ack>;
+    metadata(auth?: AuthConfig): Promise<{
+        metadata: SessionMetadata;
+    }>;
+    cancel(reason?: string, auth?: AuthConfig): Promise<Ack>;
+    openStream(auth?: AuthConfig): MacpStream;
+}
+export {};

package/dist/handoff.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HandoffSession = void 0;
+const auth_1 = require("./auth");
+const constants_1 = require("./constants");
+const envelope_1 = require("./envelope");
+const handoff_1 = require("./projections/handoff");
+const validation_1 = require("./validation");
+let sendContextWarned = false;
+function warnSendContextOnce() {
+    if (sendContextWarned)
+        return;
+    sendContextWarned = true;
+    // eslint-disable-next-line no-console
+    console.warn('[macp-sdk-typescript] HandoffSession.sendContext() is deprecated and will be removed in 0.4.0. Use addContext() instead.');
+}
+class HandoffSession {
+    client;
+    sessionId;
+    modeVersion;
+    configurationVersion;
+    policyVersion;
+    auth;
+    projection = new handoff_1.HandoffProjection();
+    constructor(client, options = {}) {
+        this.client = client;
+        if (options.sessionId)
+            (0, validation_1.validateSessionId)(options.sessionId);
+        this.sessionId = options.sessionId ?? (0, envelope_1.newSessionId)();
+        this.modeVersion = options.modeVersion ?? constants_1.DEFAULT_MODE_VERSION;
+        this.configurationVersion = options.configurationVersion ?? constants_1.DEFAULT_CONFIGURATION_VERSION;
+        this.policyVersion = options.policyVersion ?? constants_1.DEFAULT_POLICY_VERSION;
+        this.auth = options.auth;
+    }
+    senderFor(sender, auth) {
+        const effectiveAuth = auth ?? this.auth ?? this.client.auth;
+        (0, auth_1.assertSenderMatchesIdentity)(effectiveAuth, sender);
+        return sender ?? (0, auth_1.authSender)(effectiveAuth) ?? '';
+    }
+    async sendAndTrack(envelope, auth) {
+        const ack = await this.client.send(envelope, { auth: auth ?? this.auth });
+        if (ack.ok)
+            this.projection.applyEnvelope(envelope, this.client.protoRegistry);
+        return ack;
+    }
+    async start(input) {
+        (0, validation_1.validateSessionStart)({
+            intent: input.intent,
+            participants: input.participants,
+            ttlMs: input.ttlMs,
+            modeVersion: this.modeVersion,
+            configurationVersion: this.configurationVersion,
+        });
+        const payload = (0, envelope_1.buildSessionStartPayload)({
+            intent: input.intent,
+            participants: input.participants,
+            ttlMs: input.ttlMs,
+            context: input.context,
+            roots: input.roots,
+            modeVersion: this.modeVersion,
+            configurationVersion: this.configurationVersion,
+            policyVersion: this.policyVersion,
+        });
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_HANDOFF,
+            messageType: 'SessionStart',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_HANDOFF, 'SessionStart', (0, envelope_1.toProtoPayload)(payload)),
+        });
+        return this.sendAndTrack(envelope, this.auth);
+    }
+    async offer(input) {
+        (0, validation_1.validateRequiredField)('handoffId', input.handoffId);
+        (0, validation_1.validateRequiredField)('targetParticipant', input.targetParticipant);
+        const offerInput = { ...input, scope: input.scope ?? '' };
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_HANDOFF,
+            messageType: 'HandoffOffer',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_HANDOFF, 'HandoffOffer', (0, envelope_1.toProtoPayload)(offerInput)),
+        });
+        return this.sendAndTrack(envelope, input.auth);
+    }
+    async addContext(input) {
+        (0, validation_1.validateRequiredField)('handoffId', input.handoffId);
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_HANDOFF,
+            messageType: 'HandoffContext',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_HANDOFF, 'HandoffContext', (0, envelope_1.toProtoPayload)(input)),
+        });
+        return this.sendAndTrack(envelope, input.auth);
+    }
+    /**
+     * @deprecated Use {@link addContext} instead. Scheduled for removal in 0.4.0.
+     * First call logs a one-shot warning to guide migrations without spamming long-lived processes.
+     */
+    async sendContext(input) {
+        warnSendContextOnce();
+        return this.addContext(input);
+    }
+    async acceptHandoff(input) {
+        (0, validation_1.validateRequiredField)('handoffId', input.handoffId);
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_HANDOFF,
+            messageType: 'HandoffAccept',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_HANDOFF, 'HandoffAccept', (0, envelope_1.toProtoPayload)(input)),
+        });
+        return this.sendAndTrack(envelope, input.auth);
+    }
+    async decline(input) {
+        (0, validation_1.validateRequiredField)('handoffId', input.handoffId);
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_HANDOFF,
+            messageType: 'HandoffDecline',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_HANDOFF, 'HandoffDecline', (0, envelope_1.toProtoPayload)(input)),
+        });
+        return this.sendAndTrack(envelope, input.auth);
+    }
+    async commit(input) {
+        const payload = (0, envelope_1.buildCommitmentPayload)({
+            action: input.action,
+            authorityScope: input.authorityScope,
+            reason: input.reason,
+            commitmentId: input.commitmentId,
+            outcomePositive: input.outcomePositive,
+            modeVersion: this.modeVersion,
+            configurationVersion: this.configurationVersion,
+            policyVersion: this.policyVersion,
+        });
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_HANDOFF,
+            messageType: 'Commitment',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_HANDOFF, 'Commitment', (0, envelope_1.toProtoPayload)(payload)),
+        });
+        return this.sendAndTrack(envelope, input.auth);
+    }
+    metadata(auth) {
+        return this.client.getSession(this.sessionId, { auth: auth ?? this.auth });
+    }
+    async cancel(reason = '', auth) {
+        return this.client.cancelSession(this.sessionId, reason, {
+            auth: auth ?? this.auth,
+            raiseOnNack: true,
+        });
+    }
+    openStream(auth) {
+        return this.client.openStream({ auth: auth ?? this.auth });
+    }
+}
+exports.HandoffSession = HandoffSession;

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export * from './auth';
+export * from './client';
+export * from './constants';
+export * from './decision';
+export * from './envelope';
+export * from './errors';
+export * from './handoff';
+export * from './policy';
+export * from './projections';
+export * from './proposal';
+export * from './proto-registry';
+export * from './retry';
+export * from './quorum';
+export * from './task';
+export * from './types';
+export * from './validation';
+export * from './watchers';
+export * as agent from './agent';

package/dist/index.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agent = void 0;
+__exportStar(require("./auth"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./decision"), exports);
+__exportStar(require("./envelope"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./handoff"), exports);
+__exportStar(require("./policy"), exports);
+__exportStar(require("./projections"), exports);
+__exportStar(require("./proposal"), exports);
+__exportStar(require("./proto-registry"), exports);
+__exportStar(require("./retry"), exports);
+__exportStar(require("./quorum"), exports);
+__exportStar(require("./task"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./validation"), exports);
+__exportStar(require("./watchers"), exports);
+exports.agent = __importStar(require("./agent"));