macp-sdk-typescript 0.2.0

package/dist/client.js

@@ -0,0 +1,384 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MacpClient = exports.MacpStream = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any --
+ * The gRPC service client returned by `protoLoader.loadSync()` is typed as
+ * `any` by `@grpc/proto-loader`; method signatures (Send, StreamSession,
+ * WatchModeRegistry, …) are runtime-generated. Narrowing these with hand-rolled
+ * interfaces would drift as the proto evolves. This file isolates that `any`
+ * boundary — no other file in `src/` should need the rule disabled. See
+ * CLAUDE.md (`warnings for \`any\` in gRPC layer are expected`).
+ */
+const path = __importStar(require("node:path"));
+const grpc = __importStar(require("@grpc/grpc-js"));
+const protoLoader = __importStar(require("@grpc/proto-loader"));
+const auth_1 = require("./auth");
+const envelope_1 = require("./envelope");
+const errors_1 = require("./errors");
+const proto_registry_1 = require("./proto-registry");
+const validation_1 = require("./validation");
+class AsyncQueue {
+    items = [];
+    resolvers = [];
+    push(item) {
+        const resolve = this.resolvers.shift();
+        if (resolve)
+            resolve(item);
+        else
+            this.items.push(item);
+    }
+    shift() {
+        const item = this.items.shift();
+        if (item !== undefined)
+            return Promise.resolve(item);
+        return new Promise((resolve) => this.resolvers.push(resolve));
+    }
+}
+const STREAM_END = Symbol('stream-end');
+class MacpStream {
+    call;
+    queue = new AsyncQueue();
+    closed = false;
+    inlineErrorCallbacks = [];
+    constructor(call) {
+        this.call = call;
+        call.on('data', (chunk) => {
+            // Support both old format (chunk.envelope) and new oneof format (chunk.response.envelope)
+            const envelope = chunk?.response?.envelope ?? chunk?.envelope;
+            if (envelope) {
+                this.queue.push(envelope);
+            }
+            else if (chunk?.response?.error) {
+                // Inline application-level error — stream stays open
+                for (const cb of this.inlineErrorCallbacks)
+                    cb(chunk.response.error);
+            }
+        });
+        call.on('error', (error) => {
+            this.queue.push(new errors_1.MacpTransportError(error.details || error.message));
+        });
+        call.on('end', () => {
+            this.queue.push(STREAM_END);
+        });
+    }
+    onInlineError(callback) {
+        this.inlineErrorCallbacks.push(callback);
+    }
+    send(envelope) {
+        if (this.closed)
+            return Promise.reject(new errors_1.MacpSdkError('stream is already closed'));
+        return new Promise((resolve, reject) => {
+            this.call.write({ envelope }, (error) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            });
+        });
+    }
+    async *responses() {
+        while (true) {
+            const item = await this.queue.shift();
+            if (item === STREAM_END)
+                return;
+            if (item instanceof Error)
+                throw item;
+            yield item;
+        }
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.call.end();
+    }
+}
+exports.MacpStream = MacpStream;
+class MacpClient {
+    auth;
+    protoRegistry;
+    client;
+    secure;
+    defaultDeadlineMs;
+    clientName;
+    clientVersion;
+    constructor(options) {
+        this.auth = options.auth;
+        this.secure = options.secure ?? true;
+        if (!this.secure && options.allowInsecure !== true) {
+            throw new errors_1.MacpSdkError('MacpClient requires TLS. Pass secure: true (default) or, for local development only, ' +
+                'both secure: false and allowInsecure: true. See RFC-MACP-0006 §3.');
+        }
+        this.defaultDeadlineMs = options.defaultDeadlineMs;
+        this.clientName = options.clientName ?? 'macp-sdk-typescript';
+        this.clientVersion = options.clientVersion ?? '0.2.0';
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { protoDir: defaultProtoDir } = require('@multiagentcoordinationprotocol/proto');
+        const protoDir = options.protoDir ?? defaultProtoDir;
+        this.protoRegistry = new proto_registry_1.ProtoRegistry(protoDir);
+        const packageDefinition = protoLoader.loadSync([
+            path.join(protoDir, 'macp/v1/core.proto'),
+            path.join(protoDir, 'macp/v1/envelope.proto'),
+            path.join(protoDir, 'macp/v1/policy.proto'),
+        ], {
+            keepCase: false,
+            longs: String,
+            enums: String,
+            defaults: true,
+            oneofs: true,
+            includeDirs: [protoDir],
+        });
+        const descriptor = grpc.loadPackageDefinition(packageDefinition);
+        const credentials = this.secure
+            ? grpc.credentials.createSsl(options.rootCertificates)
+            : grpc.credentials.createInsecure();
+        this.client = new descriptor.macp.v1.MACPRuntimeService(options.address, credentials);
+    }
+    requireAuth(auth) {
+        const selected = auth ?? this.auth;
+        if (!selected)
+            throw new errors_1.MacpSdkError('this operation requires auth; pass auth= or configure client.auth');
+        return selected;
+    }
+    metadata(auth) {
+        const selected = auth ?? this.auth;
+        if (!selected)
+            return undefined;
+        return (0, auth_1.metadataFromAuth)(selected);
+    }
+    deadline(deadlineMs) {
+        const resolved = deadlineMs ?? this.defaultDeadlineMs;
+        return resolved ? new Date(Date.now() + resolved) : undefined;
+    }
+    unary(method, request, auth, deadlineMs) {
+        return new Promise((resolve, reject) => {
+            const callback = (error, response) => {
+                if (error)
+                    reject(new errors_1.MacpTransportError(error.details || error.message));
+                else
+                    resolve(response);
+            };
+            const deadline = this.deadline(deadlineMs);
+            const metadata = this.metadata(auth);
+            if (metadata && deadline)
+                this.client[method](request, metadata, { deadline }, callback);
+            else if (metadata)
+                this.client[method](request, metadata, callback);
+            else if (deadline)
+                this.client[method](request, { deadline }, callback);
+            else
+                this.client[method](request, callback);
+        });
+    }
+    async initialize(deadlineMs) {
+        return this.unary('Initialize', {
+            supportedProtocolVersions: ['1.0'],
+            clientInfo: {
+                name: this.clientName,
+                title: this.clientName,
+                version: this.clientVersion,
+                description: 'TypeScript SDK for the MACP runtime',
+                websiteUrl: '',
+            },
+            capabilities: {
+                sessions: { stream: true },
+                cancellation: { cancelSession: true },
+                progress: { progress: true },
+                manifest: { getManifest: true },
+                modeRegistry: { listModes: true, listChanged: true },
+                roots: { listRoots: true, listChanged: true },
+                policyRegistry: { registerPolicy: true, listPolicies: true, listChanged: true },
+                experimental: { features: {} },
+            },
+        }, undefined, deadlineMs);
+    }
+    async send(envelope, options) {
+        const auth = this.requireAuth(options?.auth);
+        const response = await this.unary('Send', { envelope }, auth, options?.deadlineMs);
+        const ack = response.ack;
+        // Duplicate acks are success — the message was already accepted
+        if (ack?.duplicate)
+            return ack;
+        if (options?.raiseOnNack !== false && !ack?.ok)
+            throw new errors_1.MacpAckError(ack ?? {});
+        return ack;
+    }
+    async getSession(sessionId, options) {
+        const auth = this.requireAuth(options?.auth);
+        return this.unary('GetSession', { sessionId }, auth, options?.deadlineMs);
+    }
+    async cancelSession(sessionId, reason, options) {
+        const auth = this.requireAuth(options?.auth);
+        const request = { sessionId, reason };
+        if (options?.cancelledBy)
+            request.cancelledBy = options.cancelledBy;
+        const response = await this.unary('CancelSession', request, auth, options?.deadlineMs);
+        const ack = response.ack;
+        if (options?.raiseOnNack !== false && !ack?.ok)
+            throw new errors_1.MacpAckError(ack ?? {});
+        return ack;
+    }
+    async getManifest(agentId = '', deadlineMs) {
+        return this.unary('GetManifest', { agentId }, undefined, deadlineMs);
+    }
+    async listModes(deadlineMs) {
+        return this.unary('ListModes', {}, undefined, deadlineMs);
+    }
+    async listExtModes(deadlineMs) {
+        return this.unary('ListExtModes', {}, undefined, deadlineMs);
+    }
+    async listRoots(deadlineMs) {
+        return this.unary('ListRoots', {}, undefined, deadlineMs);
+    }
+    async registerExtMode(descriptor, options) {
+        const auth = this.requireAuth(options?.auth);
+        return this.unary('RegisterExtMode', { modeDescriptor: descriptor }, auth, options?.deadlineMs);
+    }
+    async unregisterExtMode(mode, options) {
+        const auth = this.requireAuth(options?.auth);
+        return this.unary('UnregisterExtMode', { mode }, auth, options?.deadlineMs);
+    }
+    async promoteMode(mode, promotedModeName = '', options) {
+        const auth = this.requireAuth(options?.auth);
+        return this.unary('PromoteMode', { mode, promotedModeName }, auth, options?.deadlineMs);
+    }
+    async registerPolicy(descriptor, options) {
+        const auth = this.requireAuth(options?.auth);
+        return this.unary('RegisterPolicy', { policyDescriptor: descriptor }, auth, options?.deadlineMs);
+    }
+    async unregisterPolicy(policyId, options) {
+        const auth = this.requireAuth(options?.auth);
+        return this.unary('UnregisterPolicy', { policyId }, auth, options?.deadlineMs);
+    }
+    async getPolicy(policyId, options) {
+        const auth = this.requireAuth(options?.auth);
+        const res = await this.unary('GetPolicy', { policyId }, auth, options?.deadlineMs);
+        return res.policyDescriptor;
+    }
+    async listPolicies(mode, options) {
+        const auth = this.requireAuth(options?.auth);
+        const res = await this.unary('ListPolicies', { mode: mode || '' }, auth, options?.deadlineMs);
+        return res.descriptors || [];
+    }
+    watchPolicies(auth) {
+        const metadata = this.metadata(auth);
+        return metadata ? this.client.WatchPolicies({}, metadata) : this.client.WatchPolicies({});
+    }
+    /** @deprecated Use {@link watchPolicies}. Scheduled for removal in 0.4.0. */
+    _watchPolicies(auth) {
+        return this.watchPolicies(auth);
+    }
+    openStream(options) {
+        const auth = this.requireAuth(options?.auth);
+        const metadata = this.metadata(auth);
+        const call = this.client.StreamSession(metadata);
+        return new MacpStream(call);
+    }
+    watchModeRegistry(auth) {
+        const metadata = this.metadata(auth);
+        return metadata ? this.client.WatchModeRegistry({}, metadata) : this.client.WatchModeRegistry({});
+    }
+    watchRoots(auth) {
+        const metadata = this.metadata(auth);
+        return metadata ? this.client.WatchRoots({}, metadata) : this.client.WatchRoots({});
+    }
+    watchSignals(auth) {
+        const metadata = this.metadata(auth);
+        return metadata ? this.client.WatchSignals({}, metadata) : this.client.WatchSignals({});
+    }
+    /**
+     * @deprecated Use {@link watchModeRegistry}, {@link watchRoots},
+     * {@link watchSignals}. Scheduled for removal in 0.4.0 — the underscored
+     * aliases were kept while `src/watchers.ts` migrated.
+     */
+    _watchModeRegistry(auth) {
+        return this.watchModeRegistry(auth);
+    }
+    /** @deprecated Use {@link watchRoots}. Scheduled for removal in 0.4.0. */
+    _watchRoots(auth) {
+        return this.watchRoots(auth);
+    }
+    /** @deprecated Use {@link watchSignals}. Scheduled for removal in 0.4.0. */
+    _watchSignals(auth) {
+        return this.watchSignals(auth);
+    }
+    async sendSignal(options) {
+        (0, validation_1.validateSignalType)(options.signalType, options.data);
+        const auth = this.requireAuth(options.auth);
+        (0, auth_1.assertSenderMatchesIdentity)(auth, options.sender);
+        const payload = this.protoRegistry.encodeKnownPayload('', 'Signal', {
+            signalType: options.signalType,
+            data: options.data ?? Buffer.alloc(0),
+            confidence: options.confidence ?? 0,
+            correlationSessionId: options.correlationSessionId ?? '',
+        });
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: '',
+            messageType: 'Signal',
+            sessionId: '',
+            sender: options.sender ?? this.senderHint(auth) ?? '',
+            payload,
+        });
+        return this.send(envelope, { auth, deadlineMs: options.deadlineMs });
+    }
+    async sendProgress(options) {
+        const auth = this.requireAuth(options.auth);
+        (0, auth_1.assertSenderMatchesIdentity)(auth, options.sender);
+        const payload = this.protoRegistry.encodeKnownPayload('', 'Progress', {
+            progressToken: options.progressToken,
+            progress: options.progress,
+            total: options.total,
+            message: options.message ?? '',
+            targetMessageId: options.targetMessageId ?? '',
+        });
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: options.mode ?? '',
+            messageType: 'Progress',
+            sessionId: options.sessionId ?? '',
+            sender: options.sender ?? this.senderHint(auth) ?? '',
+            payload,
+        });
+        return this.send(envelope, { auth, deadlineMs: options.deadlineMs });
+    }
+    senderHint(auth) {
+        return (0, auth_1.authSender)(auth ?? this.auth);
+    }
+    close() {
+        if (typeof this.client.close === 'function')
+            this.client.close();
+    }
+}
+exports.MacpClient = MacpClient;

package/dist/constants.d.ts

@@ -0,0 +1,26 @@
+export declare const MACP_VERSION = "1.0";
+export declare const DEFAULT_MODE_VERSION = "1.0.0";
+export declare const DEFAULT_CONFIGURATION_VERSION = "config.default";
+export declare const DEFAULT_POLICY_VERSION = "policy.default";
+export declare const MODE_DECISION = "macp.mode.decision.v1";
+export declare const MODE_PROPOSAL = "macp.mode.proposal.v1";
+export declare const MODE_TASK = "macp.mode.task.v1";
+export declare const MODE_HANDOFF = "macp.mode.handoff.v1";
+export declare const MODE_QUORUM = "macp.mode.quorum.v1";
+export declare const MODE_MULTI_ROUND = "ext.multi_round.v1";
+export declare const ERR_UNSUPPORTED_PROTOCOL_VERSION = "UNSUPPORTED_PROTOCOL_VERSION";
+export declare const ERR_INVALID_ENVELOPE = "INVALID_ENVELOPE";
+export declare const ERR_SESSION_ALREADY_EXISTS = "SESSION_ALREADY_EXISTS";
+export declare const ERR_SESSION_NOT_FOUND = "SESSION_NOT_FOUND";
+export declare const ERR_SESSION_NOT_OPEN = "SESSION_NOT_OPEN";
+export declare const ERR_MODE_NOT_SUPPORTED = "MODE_NOT_SUPPORTED";
+export declare const ERR_FORBIDDEN = "FORBIDDEN";
+export declare const ERR_UNAUTHENTICATED = "UNAUTHENTICATED";
+export declare const ERR_DUPLICATE_MESSAGE = "DUPLICATE_MESSAGE";
+export declare const ERR_PAYLOAD_TOO_LARGE = "PAYLOAD_TOO_LARGE";
+export declare const ERR_RATE_LIMITED = "RATE_LIMITED";
+export declare const ERR_INTERNAL_ERROR = "INTERNAL_ERROR";
+export declare const ERR_POLICY_DENIED = "POLICY_DENIED";
+export declare const ERR_INVALID_SESSION_ID = "INVALID_SESSION_ID";
+export declare const ERR_UNKNOWN_POLICY_VERSION = "UNKNOWN_POLICY_VERSION";
+export declare const ERR_INVALID_POLICY_DEFINITION = "INVALID_POLICY_DEFINITION";

package/dist/constants.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERR_INVALID_POLICY_DEFINITION = exports.ERR_UNKNOWN_POLICY_VERSION = exports.ERR_INVALID_SESSION_ID = exports.ERR_POLICY_DENIED = exports.ERR_INTERNAL_ERROR = exports.ERR_RATE_LIMITED = exports.ERR_PAYLOAD_TOO_LARGE = exports.ERR_DUPLICATE_MESSAGE = exports.ERR_UNAUTHENTICATED = exports.ERR_FORBIDDEN = exports.ERR_MODE_NOT_SUPPORTED = exports.ERR_SESSION_NOT_OPEN = exports.ERR_SESSION_NOT_FOUND = exports.ERR_SESSION_ALREADY_EXISTS = exports.ERR_INVALID_ENVELOPE = exports.ERR_UNSUPPORTED_PROTOCOL_VERSION = exports.MODE_MULTI_ROUND = exports.MODE_QUORUM = exports.MODE_HANDOFF = exports.MODE_TASK = exports.MODE_PROPOSAL = exports.MODE_DECISION = exports.DEFAULT_POLICY_VERSION = exports.DEFAULT_CONFIGURATION_VERSION = exports.DEFAULT_MODE_VERSION = exports.MACP_VERSION = void 0;
+exports.MACP_VERSION = '1.0';
+exports.DEFAULT_MODE_VERSION = '1.0.0';
+exports.DEFAULT_CONFIGURATION_VERSION = 'config.default';
+exports.DEFAULT_POLICY_VERSION = 'policy.default';
+exports.MODE_DECISION = 'macp.mode.decision.v1';
+exports.MODE_PROPOSAL = 'macp.mode.proposal.v1';
+exports.MODE_TASK = 'macp.mode.task.v1';
+exports.MODE_HANDOFF = 'macp.mode.handoff.v1';
+exports.MODE_QUORUM = 'macp.mode.quorum.v1';
+exports.MODE_MULTI_ROUND = 'ext.multi_round.v1';
+exports.ERR_UNSUPPORTED_PROTOCOL_VERSION = 'UNSUPPORTED_PROTOCOL_VERSION';
+exports.ERR_INVALID_ENVELOPE = 'INVALID_ENVELOPE';
+exports.ERR_SESSION_ALREADY_EXISTS = 'SESSION_ALREADY_EXISTS';
+exports.ERR_SESSION_NOT_FOUND = 'SESSION_NOT_FOUND';
+exports.ERR_SESSION_NOT_OPEN = 'SESSION_NOT_OPEN';
+exports.ERR_MODE_NOT_SUPPORTED = 'MODE_NOT_SUPPORTED';
+exports.ERR_FORBIDDEN = 'FORBIDDEN';
+exports.ERR_UNAUTHENTICATED = 'UNAUTHENTICATED';
+exports.ERR_DUPLICATE_MESSAGE = 'DUPLICATE_MESSAGE';
+exports.ERR_PAYLOAD_TOO_LARGE = 'PAYLOAD_TOO_LARGE';
+exports.ERR_RATE_LIMITED = 'RATE_LIMITED';
+exports.ERR_INTERNAL_ERROR = 'INTERNAL_ERROR';
+exports.ERR_POLICY_DENIED = 'POLICY_DENIED';
+exports.ERR_INVALID_SESSION_ID = 'INVALID_SESSION_ID';
+exports.ERR_UNKNOWN_POLICY_VERSION = 'UNKNOWN_POLICY_VERSION';
+exports.ERR_INVALID_POLICY_DEFINITION = 'INVALID_POLICY_DEFINITION';

package/dist/decision.d.ts

@@ -0,0 +1,65 @@
+import { type AuthConfig } from './auth';
+import type { MacpClient, MacpStream } from './client';
+import { DecisionProjection } from './projections';
+import type { Ack, DecisionEvaluationPayload, DecisionObjectionPayload, DecisionProposalPayload, DecisionVotePayload, SessionMetadata } from './types';
+interface DecisionSessionOptions {
+    sessionId?: string;
+    modeVersion?: string;
+    configurationVersion?: string;
+    policyVersion?: string;
+    auth?: AuthConfig;
+}
+export declare class DecisionSession {
+    readonly client: MacpClient;
+    readonly sessionId: string;
+    readonly modeVersion: string;
+    readonly configurationVersion: string;
+    readonly policyVersion: string;
+    readonly auth?: AuthConfig;
+    readonly projection: DecisionProjection;
+    constructor(client: MacpClient, options?: DecisionSessionOptions);
+    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>;
+    propose(input: DecisionProposalPayload & {
+        sender?: string;
+        auth?: AuthConfig;
+    }): Promise<Ack>;
+    evaluate(input: DecisionEvaluationPayload & {
+        sender?: string;
+        auth?: AuthConfig;
+    }): Promise<Ack>;
+    raiseObjection(input: DecisionObjectionPayload & {
+        sender?: string;
+        auth?: AuthConfig;
+    }): Promise<Ack>;
+    vote(input: DecisionVotePayload & {
+        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/decision.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecisionSession = void 0;
+const auth_1 = require("./auth");
+const constants_1 = require("./constants");
+const envelope_1 = require("./envelope");
+const projections_1 = require("./projections");
+const validation_1 = require("./validation");
+class DecisionSession {
+    client;
+    sessionId;
+    modeVersion;
+    configurationVersion;
+    policyVersion;
+    auth;
+    projection = new projections_1.DecisionProjection();
+    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_DECISION,
+            messageType: 'SessionStart',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_DECISION, 'SessionStart', (0, envelope_1.toProtoPayload)(payload)),
+        });
+        return this.sendAndTrack(envelope, this.auth);
+    }
+    async propose(input) {
+        (0, validation_1.validateRequiredField)('proposalId', input.proposalId);
+        (0, validation_1.validateRequiredField)('option', input.option);
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_DECISION,
+            messageType: 'Proposal',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_DECISION, 'Proposal', (0, envelope_1.toProtoPayload)(input)),
+        });
+        return this.sendAndTrack(envelope, input.auth);
+    }
+    async evaluate(input) {
+        (0, validation_1.validateRequiredField)('proposalId', input.proposalId);
+        (0, validation_1.validateRecommendation)(input.recommendation);
+        (0, validation_1.validateConfidence)(input.confidence);
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_DECISION,
+            messageType: 'Evaluation',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_DECISION, 'Evaluation', (0, envelope_1.toProtoPayload)(input)),
+        });
+        return this.sendAndTrack(envelope, input.auth);
+    }
+    async raiseObjection(input) {
+        (0, validation_1.validateRequiredField)('proposalId', input.proposalId);
+        if (input.severity)
+            (0, validation_1.validateSeverity)(input.severity);
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_DECISION,
+            messageType: 'Objection',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_DECISION, 'Objection', (0, envelope_1.toProtoPayload)(input)),
+        });
+        return this.sendAndTrack(envelope, input.auth);
+    }
+    async vote(input) {
+        (0, validation_1.validateRequiredField)('proposalId', input.proposalId);
+        (0, validation_1.validateVote)(input.vote);
+        const envelope = (0, envelope_1.buildEnvelope)({
+            mode: constants_1.MODE_DECISION,
+            messageType: 'Vote',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_DECISION, 'Vote', (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_DECISION,
+            messageType: 'Commitment',
+            sessionId: this.sessionId,
+            sender: this.senderFor(input.sender, input.auth),
+            payload: this.client.protoRegistry.encodeKnownPayload(constants_1.MODE_DECISION, '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.DecisionSession = DecisionSession;