macp-sdk-typescript 0.2.0

package/dist/proto-registry.js

@@ -0,0 +1,165 @@
+"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 __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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtoRegistry = void 0;
+const path = __importStar(require("node:path"));
+const protobufjs_1 = __importDefault(require("protobufjs"));
+const constants_1 = require("./constants");
+const CORE_MAP = {
+    SessionStart: 'macp.v1.SessionStartPayload',
+    Commitment: 'macp.v1.CommitmentPayload',
+    Signal: 'macp.v1.SignalPayload',
+    Progress: 'macp.v1.ProgressPayload',
+};
+const MODE_MAP = {
+    [constants_1.MODE_DECISION]: {
+        Proposal: 'macp.modes.decision.v1.ProposalPayload',
+        Evaluation: 'macp.modes.decision.v1.EvaluationPayload',
+        Objection: 'macp.modes.decision.v1.ObjectionPayload',
+        Vote: 'macp.modes.decision.v1.VotePayload',
+    },
+    [constants_1.MODE_PROPOSAL]: {
+        Proposal: 'macp.modes.proposal.v1.ProposalPayload',
+        CounterProposal: 'macp.modes.proposal.v1.CounterProposalPayload',
+        Accept: 'macp.modes.proposal.v1.AcceptPayload',
+        Reject: 'macp.modes.proposal.v1.RejectPayload',
+        Withdraw: 'macp.modes.proposal.v1.WithdrawPayload',
+    },
+    [constants_1.MODE_TASK]: {
+        TaskRequest: 'macp.modes.task.v1.TaskRequestPayload',
+        TaskAccept: 'macp.modes.task.v1.TaskAcceptPayload',
+        TaskReject: 'macp.modes.task.v1.TaskRejectPayload',
+        TaskUpdate: 'macp.modes.task.v1.TaskUpdatePayload',
+        TaskComplete: 'macp.modes.task.v1.TaskCompletePayload',
+        TaskFail: 'macp.modes.task.v1.TaskFailPayload',
+    },
+    [constants_1.MODE_HANDOFF]: {
+        HandoffOffer: 'macp.modes.handoff.v1.HandoffOfferPayload',
+        HandoffContext: 'macp.modes.handoff.v1.HandoffContextPayload',
+        HandoffAccept: 'macp.modes.handoff.v1.HandoffAcceptPayload',
+        HandoffDecline: 'macp.modes.handoff.v1.HandoffDeclinePayload',
+    },
+    [constants_1.MODE_QUORUM]: {
+        ApprovalRequest: 'macp.modes.quorum.v1.ApprovalRequestPayload',
+        Approve: 'macp.modes.quorum.v1.ApprovePayload',
+        Reject: 'macp.modes.quorum.v1.RejectPayload',
+        Abstain: 'macp.modes.quorum.v1.AbstainPayload',
+    },
+    [constants_1.MODE_MULTI_ROUND]: {
+        Contribute: '__json__',
+    },
+};
+const PROTO_FILES = [
+    'macp/v1/core.proto',
+    'macp/v1/envelope.proto',
+    'macp/v1/policy.proto',
+    'macp/modes/decision/v1/decision.proto',
+    'macp/modes/proposal/v1/proposal.proto',
+    'macp/modes/task/v1/task.proto',
+    'macp/modes/handoff/v1/handoff.proto',
+    'macp/modes/quorum/v1/quorum.proto',
+];
+class ProtoRegistry {
+    protoDir;
+    root;
+    constructor(protoDir) {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { protoDir: defaultProtoDir } = require('@multiagentcoordinationprotocol/proto');
+        this.protoDir = path.resolve(protoDir ?? defaultProtoDir);
+        this.root = new protobufjs_1.default.Root();
+        this.root.resolvePath = (_origin, target) => {
+            if (path.isAbsolute(target))
+                return target;
+            return path.join(this.protoDir, target);
+        };
+        this.root.loadSync(PROTO_FILES.map((file) => path.join(this.protoDir, file)));
+        this.root.resolveAll();
+    }
+    getKnownTypeName(mode, messageType) {
+        return MODE_MAP[mode]?.[messageType] ?? CORE_MAP[messageType];
+    }
+    encodeMessage(typeName, value) {
+        const type = this.lookupType(typeName);
+        const message = type.fromObject(value);
+        return Buffer.from(type.encode(message).finish());
+    }
+    decodeMessage(typeName, payload) {
+        const type = this.lookupType(typeName);
+        const decoded = type.decode(payload);
+        return type.toObject(decoded, {
+            longs: String,
+            enums: String,
+            bytes: Buffer,
+            defaults: false,
+        });
+    }
+    encodeKnownPayload(mode, messageType, value) {
+        const typeName = this.getKnownTypeName(mode, messageType);
+        if (!typeName)
+            throw new Error(`unknown payload mapping for ${mode}/${messageType}`);
+        if (typeName === '__json__')
+            return Buffer.from(JSON.stringify(value), 'utf8');
+        return this.encodeMessage(typeName, value);
+    }
+    decodeKnownPayload(mode, messageType, payload) {
+        const typeName = this.getKnownTypeName(mode, messageType);
+        if (!typeName)
+            return this.tryDecodeUtf8(payload);
+        if (typeName === '__json__')
+            return this.tryDecodeUtf8(payload);
+        return this.decodeMessage(typeName, payload);
+    }
+    lookupType(typeName) {
+        const lookedUp = this.root.lookupType(typeName);
+        if (!(lookedUp instanceof protobufjs_1.default.Type))
+            throw new Error(`protobuf type '${typeName}' not found`);
+        return lookedUp;
+    }
+    tryDecodeUtf8(payload) {
+        if (!payload.length)
+            return undefined;
+        const text = payload.toString('utf8');
+        try {
+            return { encoding: 'json', json: JSON.parse(text) };
+        }
+        catch {
+            return { encoding: 'text', text, payloadBase64: payload.toString('base64') };
+        }
+    }
+}
+exports.ProtoRegistry = ProtoRegistry;

package/dist/quorum.d.ts

@@ -0,0 +1,65 @@
+import { type AuthConfig } from './auth';
+import type { MacpClient, MacpStream } from './client';
+import { QuorumProjection } from './projections/quorum';
+import type { AbstainPayload, Ack, ApprovalRequestPayload, ApprovePayload, QuorumRejectPayload, SessionMetadata } from './types';
+interface QuorumSessionOptions {
+    sessionId?: string;
+    modeVersion?: string;
+    configurationVersion?: string;
+    policyVersion?: string;
+    auth?: AuthConfig;
+}
+export declare class QuorumSession {
+    readonly client: MacpClient;
+    readonly sessionId: string;
+    readonly modeVersion: string;
+    readonly configurationVersion: string;
+    readonly policyVersion: string;
+    readonly auth?: AuthConfig;
+    readonly projection: QuorumProjection;
+    constructor(client: MacpClient, options?: QuorumSessionOptions);
+    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>;
+    requestApproval(input: ApprovalRequestPayload & {
+        sender?: string;
+        auth?: AuthConfig;
+    }): Promise<Ack>;
+    approve(input: ApprovePayload & {
+        sender?: string;
+        auth?: AuthConfig;
+    }): Promise<Ack>;
+    reject(input: QuorumRejectPayload & {
+        sender?: string;
+        auth?: AuthConfig;
+    }): Promise<Ack>;
+    abstain(input: AbstainPayload & {
+        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/quorum.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuorumSession = void 0;
+const auth_1 = require("./auth");
+const constants_1 = require("./constants");
+const envelope_1 = require("./envelope");
+const quorum_1 = require("./projections/quorum");
+const validation_1 = require("./validation");
+class QuorumSession {
+    client;
+    sessionId;
+    modeVersion;
+    configurationVersion;
+    policyVersion;
+    auth;
+    projection = new quorum_1.QuorumProjection();
+    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_QUORUM,
+            messageType: 'SessionStart',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_QUORUM, 'SessionStart', (0, envelope_1.toProtoPayload)(payload)),
+        });
+        return this.sendAndTrack(envelope, this.auth);
+    }
+    async requestApproval(input) {
+        (0, validation_1.validateRequiredField)('requestId', input.requestId);
+        (0, validation_1.validateRequiredField)('action', input.action);
+        (0, validation_1.validateRequiredField)('summary', input.summary);
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_QUORUM,
+            messageType: 'ApprovalRequest',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_QUORUM, 'ApprovalRequest', (0, envelope_1.toProtoPayload)(input)),
+        });
+        return this.sendAndTrack(envelope, input.auth);
+    }
+    async approve(input) {
+        (0, validation_1.validateRequiredField)('requestId', input.requestId);
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_QUORUM,
+            messageType: 'Approve',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_QUORUM, 'Approve', (0, envelope_1.toProtoPayload)(input)),
+        });
+        return this.sendAndTrack(envelope, input.auth);
+    }
+    async reject(input) {
+        (0, validation_1.validateRequiredField)('requestId', input.requestId);
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_QUORUM,
+            messageType: 'Reject',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_QUORUM, 'Reject', (0, envelope_1.toProtoPayload)(input)),
+        });
+        return this.sendAndTrack(envelope, input.auth);
+    }
+    async abstain(input) {
+        (0, validation_1.validateRequiredField)('requestId', input.requestId);
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_QUORUM,
+            messageType: 'Abstain',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_QUORUM, 'Abstain', (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_QUORUM,
+            messageType: 'Commitment',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_QUORUM, '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.QuorumSession = QuorumSession;

package/dist/retry.d.ts

@@ -0,0 +1,14 @@
+import type { AuthConfig } from './auth';
+import type { MacpClient } from './client';
+import type { Ack, Envelope } from './types';
+export interface RetryPolicy {
+    maxRetries: number;
+    backoffBase: number;
+    backoffMax: number;
+    retryableCodes: Set<string>;
+}
+export declare const DEFAULT_RETRY_POLICY: RetryPolicy;
+export declare function retrySend(client: MacpClient, envelope: Envelope, options?: {
+    policy?: Partial<RetryPolicy>;
+    auth?: AuthConfig;
+}): Promise<Ack>;

package/dist/retry.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_RETRY_POLICY = void 0;
+exports.retrySend = retrySend;
+const errors_1 = require("./errors");
+exports.DEFAULT_RETRY_POLICY = {
+    maxRetries: 3,
+    backoffBase: 0.1,
+    backoffMax: 2.0,
+    retryableCodes: new Set(['RATE_LIMITED', 'INTERNAL_ERROR']),
+};
+function sleep(seconds) {
+    return new Promise((resolve) => setTimeout(resolve, seconds * 1000));
+}
+async function retrySend(client, envelope, options) {
+    const policy = {
+        ...exports.DEFAULT_RETRY_POLICY,
+        ...options?.policy,
+    };
+    let lastError;
+    for (let attempt = 0; attempt <= policy.maxRetries; attempt++) {
+        try {
+            return await client.send(envelope, { auth: options?.auth, raiseOnNack: true });
+        }
+        catch (err) {
+            if (err instanceof errors_1.MacpTransportError) {
+                lastError = err;
+            }
+            else if (err instanceof errors_1.MacpAckError) {
+                if (!policy.retryableCodes.has(err.ack.error?.code ?? '')) {
+                    throw err;
+                }
+                lastError = err;
+            }
+            else {
+                throw err;
+            }
+        }
+        if (attempt < policy.maxRetries) {
+            const delay = Math.min(policy.backoffBase * 2 ** attempt, policy.backoffMax);
+            await sleep(delay);
+        }
+    }
+    const error = new errors_1.MacpRetryError(`retries exhausted after ${policy.maxRetries} attempts`);
+    if (lastError)
+        error.cause = lastError;
+    throw error;
+}

package/dist/task.d.ts

@@ -0,0 +1,73 @@
+import { type AuthConfig } from './auth';
+import type { MacpClient, MacpStream } from './client';
+import { TaskProjection } from './projections/task';
+import type { Ack, SessionMetadata, TaskAcceptPayload, TaskCompletePayload, TaskFailPayload, TaskRejectPayload, TaskRequestPayload, TaskUpdatePayload } from './types';
+interface TaskSessionOptions {
+    sessionId?: string;
+    modeVersion?: string;
+    configurationVersion?: string;
+    policyVersion?: string;
+    auth?: AuthConfig;
+}
+export declare class TaskSession {
+    readonly client: MacpClient;
+    readonly sessionId: string;
+    readonly modeVersion: string;
+    readonly configurationVersion: string;
+    readonly policyVersion: string;
+    readonly auth?: AuthConfig;
+    readonly projection: TaskProjection;
+    constructor(client: MacpClient, options?: TaskSessionOptions);
+    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>;
+    request(input: TaskRequestPayload & {
+        sender?: string;
+        auth?: AuthConfig;
+    }): Promise<Ack>;
+    acceptTask(input: TaskAcceptPayload & {
+        sender?: string;
+        auth?: AuthConfig;
+    }): Promise<Ack>;
+    rejectTask(input: TaskRejectPayload & {
+        sender?: string;
+        auth?: AuthConfig;
+    }): Promise<Ack>;
+    update(input: TaskUpdatePayload & {
+        sender?: string;
+        auth?: AuthConfig;
+    }): Promise<Ack>;
+    complete(input: TaskCompletePayload & {
+        sender?: string;
+        auth?: AuthConfig;
+    }): Promise<Ack>;
+    fail(input: TaskFailPayload & {
+        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/task.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskSession = void 0;
+const auth_1 = require("./auth");
+const constants_1 = require("./constants");
+const envelope_1 = require("./envelope");
+const task_1 = require("./projections/task");
+const validation_1 = require("./validation");
+class TaskSession {
+    client;
+    sessionId;
+    modeVersion;
+    configurationVersion;
+    policyVersion;
+    auth;
+    projection = new task_1.TaskProjection();
+    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_TASK,
+            messageType: 'SessionStart',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_TASK, 'SessionStart', (0, envelope_1.toProtoPayload)(payload)),
+        });
+        return this.sendAndTrack(envelope, this.auth);
+    }
+    async request(input) {
+        (0, validation_1.validateRequiredField)('taskId', input.taskId);
+        (0, validation_1.validateRequiredField)('title', input.title);
+        (0, validation_1.validateRequiredField)('instructions', input.instructions);
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_TASK,
+            messageType: 'TaskRequest',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_TASK, 'TaskRequest', (0, envelope_1.toProtoPayload)(input)),
+        });
+        return this.sendAndTrack(envelope, input.auth);
+    }
+    async acceptTask(input) {
+        (0, validation_1.validateRequiredField)('taskId', input.taskId);
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_TASK,
+            messageType: 'TaskAccept',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_TASK, 'TaskAccept', (0, envelope_1.toProtoPayload)(input)),
+        });
+        return this.sendAndTrack(envelope, input.auth);
+    }
+    async rejectTask(input) {
+        (0, validation_1.validateRequiredField)('taskId', input.taskId);
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_TASK,
+            messageType: 'TaskReject',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_TASK, 'TaskReject', (0, envelope_1.toProtoPayload)(input)),
+        });
+        return this.sendAndTrack(envelope, input.auth);
+    }
+    async update(input) {
+        (0, validation_1.validateRequiredField)('taskId', input.taskId);
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_TASK,
+            messageType: 'TaskUpdate',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_TASK, 'TaskUpdate', (0, envelope_1.toProtoPayload)(input)),
+        });
+        return this.sendAndTrack(envelope, input.auth);
+    }
+    async complete(input) {
+        (0, validation_1.validateRequiredField)('taskId', input.taskId);
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_TASK,
+            messageType: 'TaskComplete',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_TASK, 'TaskComplete', (0, envelope_1.toProtoPayload)(input)),
+        });
+        return this.sendAndTrack(envelope, input.auth);
+    }
+    async fail(input) {
+        (0, validation_1.validateRequiredField)('taskId', input.taskId);
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_TASK,
+            messageType: 'TaskFail',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_TASK, 'TaskFail', (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_TASK,
+            messageType: 'Commitment',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_TASK, '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.TaskSession = TaskSession;