macp-sdk-typescript 0.2.2 → 0.3.0

package/dist/errors.d.ts

@@ -5,6 +5,18 @@ export declare class MacpSdkError extends Error {
 export declare class MacpTransportError extends MacpSdkError {
     constructor(message: string);
 }
+/**
+ * Structured NACK record. Mirrors python-sdk's `AckFailure` dataclass so
+ * cross-SDK code can share the same shape when logging or persisting a
+ * rejected message.
+ */
+export interface AckFailure {
+    code: string;
+    message: string;
+    sessionId: string;
+    messageId: string;
+    reasons: string[];
+}
 export declare class MacpAckError extends MacpSdkError {
     readonly ack: Ack;
     /** Optional gRPC trailing metadata for extracting additional error details. */
@@ -12,14 +24,15 @@ export declare class MacpAckError extends MacpSdkError {
         key: string;
         value: string | Buffer;
     }>;
+    /** Structured NACK record — parity with python-sdk `MacpAckError.failure`. */
+    readonly failure: AckFailure;
     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;
+    private static _extractReasons;
+    private static _parseAckReasons;
+    private static _parseGrpcMetadataReasons;
 }
 export declare class MacpSessionError extends MacpSdkError {
     constructor(message: string);

package/dist/errors.js

@@ -19,26 +19,35 @@ class MacpAckError extends MacpSdkError {
     ack;
     /** Optional gRPC trailing metadata for extracting additional error details. */
     grpcMetadata;
+    /** Structured NACK record — parity with python-sdk `MacpAckError.failure`. */
+    failure;
     constructor(ack, grpcMetadata) {
         super(`${ack.error?.code ?? 'UNKNOWN'}: ${ack.error?.message ?? 'runtime returned nack'}`);
         this.name = 'MacpAckError';
         this.ack = ack;
         this.grpcMetadata = grpcMetadata;
+        const reasons = MacpAckError._extractReasons(ack, grpcMetadata);
+        this.failure = {
+            code: ack.error?.code ?? 'UNKNOWN',
+            message: ack.error?.message ?? 'runtime returned nack',
+            sessionId: ack.sessionId ?? ack.error?.sessionId ?? '',
+            messageId: ack.messageId ?? ack.error?.messageId ?? '',
+            reasons,
+        };
     }
-    /** Extract structured denial reasons from the ACK error details and/or gRPC trailing metadata. */
-    get reasons() {
+    static _extractReasons(ack, grpcMetadata) {
         // First try: parse from ack.error.details (matches Python _parse_ack_reasons)
-        const fromDetails = this._parseAckReasons();
+        const fromDetails = MacpAckError._parseAckReasons(ack);
         if (fromDetails.length > 0)
             return fromDetails;
         // Second try: parse from gRPC trailing metadata (matches Python _parse_grpc_metadata_reasons)
-        return this._parseGrpcMetadataReasons();
+        return MacpAckError._parseGrpcMetadataReasons(grpcMetadata);
     }
-    _parseAckReasons() {
-        if (!this.ack.error?.details)
+    static _parseAckReasons(ack) {
+        if (!ack.error?.details)
             return [];
         try {
-            const details = this.ack.error.details;
+            const details = ack.error.details;
             const raw = Buffer.isBuffer(details) ? details.toString('utf-8') : String(details);
             const parsed = JSON.parse(raw);
             const reasons = parsed.reasons;
@@ -48,11 +57,11 @@ class MacpAckError extends MacpSdkError {
             return [];
         }
     }
-    _parseGrpcMetadataReasons() {
-        if (!this.grpcMetadata)
+    static _parseGrpcMetadataReasons(grpcMetadata) {
+        if (!grpcMetadata)
             return [];
         try {
-            for (const item of this.grpcMetadata) {
+            for (const item of grpcMetadata) {
                 if (item.key === 'macp-error-details-bin') {
                     const data = Buffer.isBuffer(item.value)
                         ? item.value.toString('utf-8')

package/dist/handoff.d.ts

@@ -40,14 +40,6 @@ export declare class HandoffSession {
         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;

package/dist/handoff.js

@@ -6,14 +6,6 @@ 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;
@@ -95,14 +87,6 @@ class HandoffSession {
         });
         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)({

package/dist/index.d.ts

@@ -1,10 +1,12 @@
-export * from './auth';
+export { Auth, type AuthConfig, type BearerAuthOptions } from './auth';
+export * from './base-session';
 export * from './client';
 export * from './constants';
 export * from './decision';
 export * from './envelope';
 export * from './errors';
 export * from './handoff';
+export * from './logging';
 export * from './policy';
 export * from './projections';
 export * from './proposal';

package/dist/index.js

@@ -36,14 +36,22 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.agent = void 0;
-__exportStar(require("./auth"), exports);
+exports.agent = exports.Auth = void 0;
+// Auth: export only the public constructors and types. The helpers
+// `validateAuth`, `authSender`, `assertSenderMatchesIdentity`, and
+// `metadataFromAuth` are SDK-internal — importable from the `./auth`
+// submodule if needed, but intentionally absent from the top-level surface
+// to match python-sdk's `__all__` (which only exposes `AuthConfig`).
+var auth_1 = require("./auth");
+Object.defineProperty(exports, "Auth", { enumerable: true, get: function () { return auth_1.Auth; } });
+__exportStar(require("./base-session"), 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("./logging"), exports);
 __exportStar(require("./policy"), exports);
 __exportStar(require("./projections"), exports);
 __exportStar(require("./proposal"), exports);

package/dist/logging.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Structured logger for the MACP SDK.
+ *
+ * Parity with python-sdk's `macp_sdk._logging.logger` + `configure_logging()`:
+ * production Node apps need controllable log levels (silent by default-ish,
+ * opt-in verbose) and the ability to re-route to Pino / Winston / etc.
+ */
+export type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug';
+export type LogSink = (level: Exclude<LogLevel, 'silent'>, args: unknown[]) => void;
+export declare const logger: {
+    error: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+};
+export declare function configureLogging(options: {
+    level?: LogLevel;
+    sink?: LogSink;
+}): void;
+/** Test-only: reset to env-derived level + default sink. */
+export declare function _resetLoggingForTests(): void;

package/dist/logging.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Structured logger for the MACP SDK.
+ *
+ * Parity with python-sdk's `macp_sdk._logging.logger` + `configure_logging()`:
+ * production Node apps need controllable log levels (silent by default-ish,
+ * opt-in verbose) and the ability to re-route to Pino / Winston / etc.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+exports.configureLogging = configureLogging;
+exports._resetLoggingForTests = _resetLoggingForTests;
+const LEVEL_ORDER = {
+    silent: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4,
+};
+const defaultSink = (level, args) => {
+    const method = level === 'debug' || level === 'info' ? 'log' : level;
+    // eslint-disable-next-line no-console
+    (console[method] ?? console.log)('[macp-sdk]', ...args);
+};
+function envLevel() {
+    const raw = typeof process !== 'undefined' ? process.env?.MACP_LOG_LEVEL?.toLowerCase() : undefined;
+    if (raw && raw in LEVEL_ORDER)
+        return raw;
+    return 'warn';
+}
+const state = {
+    level: envLevel(),
+    sink: defaultSink,
+};
+function shouldLog(level) {
+    return LEVEL_ORDER[state.level] >= LEVEL_ORDER[level];
+}
+function emit(level, args) {
+    if (!shouldLog(level))
+        return;
+    state.sink(level, args);
+}
+exports.logger = {
+    error: (...args) => emit('error', args),
+    warn: (...args) => emit('warn', args),
+    info: (...args) => emit('info', args),
+    debug: (...args) => emit('debug', args),
+};
+function configureLogging(options) {
+    if (options.level !== undefined) {
+        if (!(options.level in LEVEL_ORDER)) {
+            throw new Error(`configureLogging: unknown level "${options.level}"`);
+        }
+        state.level = options.level;
+    }
+    if (options.sink !== undefined) {
+        state.sink = options.sink;
+    }
+}
+/** Test-only: reset to env-derived level + default sink. */
+function _resetLoggingForTests() {
+    state.level = envLevel();
+    state.sink = defaultSink;
+}

package/dist/policy.d.ts

@@ -1,9 +1,11 @@
 import type { PolicyDescriptor } from './types';
-export interface CommitmentRulesInput {
+export interface CommitmentRules {
     authority?: 'initiator_only' | 'any_participant' | 'designated_role';
     designatedRoles?: string[];
+    /** Decision-specific: require quorum before commit. Ignored for other modes. */
+    requireVoteQuorum?: boolean;
 }
-export interface DecisionVotingRules {
+export interface VotingRules {
     algorithm?: 'none' | 'majority' | 'supermajority' | 'unanimous' | 'weighted' | 'plurality';
     threshold?: number;
     quorum?: {
@@ -12,62 +14,65 @@ export interface DecisionVotingRules {
     };
     weights?: Record<string, number>;
 }
-export interface DecisionObjectionHandling {
+export interface ObjectionHandlingRules {
     criticalSeverityVetoes?: boolean;
     vetoThreshold?: number;
 }
-export interface DecisionEvaluationRules {
+export interface EvaluationRules {
     minimumConfidence?: number;
     requiredBeforeVoting?: boolean;
 }
-export interface DecisionCommitmentRules {
-    authority?: 'initiator_only' | 'any_participant' | 'designated_role';
-    designatedRoles?: string[];
-    requireVoteQuorum?: boolean;
+export interface QuorumThreshold {
+    type: 'n_of_m' | 'percentage' | 'weighted';
+    value: number;
+}
+export interface AbstentionRules {
+    countsTowardQuorum?: boolean;
+    interpretation?: 'neutral' | 'implicit_reject' | 'ignored';
+}
+export interface ProposalAcceptanceRules {
+    criterion?: 'all_parties' | 'counterparty' | 'initiator';
+}
+export interface CounterProposalRules {
+    maxRounds?: number;
+}
+export interface RejectionRules {
+    terminalOnAnyReject?: boolean;
+}
+export interface TaskAssignmentRules {
+    allowReassignmentOnReject?: boolean;
+}
+export interface TaskCompletionRules {
+    requireOutput?: boolean;
+}
+export interface HandoffAcceptanceRules {
+    implicitAcceptTimeoutMs?: number;
 }
 export interface DecisionPolicyRulesInput {
-    voting?: DecisionVotingRules;
-    objectionHandling?: DecisionObjectionHandling;
-    evaluation?: DecisionEvaluationRules;
-    commitment?: DecisionCommitmentRules;
+    voting?: VotingRules;
+    objectionHandling?: ObjectionHandlingRules;
+    evaluation?: EvaluationRules;
+    commitment?: CommitmentRules;
 }
 export interface QuorumPolicyRulesInput {
-    threshold?: {
-        type: 'n_of_m' | 'percentage' | 'weighted';
-        value: number;
-    };
-    abstention?: {
-        countsTowardQuorum?: boolean;
-        interpretation?: 'neutral' | 'implicit_reject' | 'ignored';
-    };
-    commitment?: CommitmentRulesInput;
+    threshold?: QuorumThreshold;
+    abstention?: AbstentionRules;
+    commitment?: CommitmentRules;
 }
 export interface ProposalPolicyRulesInput {
-    acceptance?: {
-        criterion?: 'all_parties' | 'counterparty' | 'initiator';
-    };
-    counterProposal?: {
-        maxRounds?: number;
-    };
-    rejection?: {
-        terminalOnAnyReject?: boolean;
-    };
-    commitment?: CommitmentRulesInput;
+    acceptance?: ProposalAcceptanceRules;
+    counterProposal?: CounterProposalRules;
+    rejection?: RejectionRules;
+    commitment?: CommitmentRules;
 }
 export interface TaskPolicyRulesInput {
-    assignment?: {
-        allowReassignmentOnReject?: boolean;
-    };
-    completion?: {
-        requireOutput?: boolean;
-    };
-    commitment?: CommitmentRulesInput;
+    assignment?: TaskAssignmentRules;
+    completion?: TaskCompletionRules;
+    commitment?: CommitmentRules;
 }
 export interface HandoffPolicyRulesInput {
-    acceptance?: {
-        implicitAcceptTimeoutMs?: number;
-    };
-    commitment?: CommitmentRulesInput;
+    acceptance?: HandoffAcceptanceRules;
+    commitment?: CommitmentRules;
 }
 export declare function buildDecisionPolicy(policyId: string, description: string, rules: DecisionPolicyRulesInput): PolicyDescriptor;
 export declare function buildQuorumPolicy(policyId: string, description: string, rules: QuorumPolicyRulesInput): PolicyDescriptor;

package/dist/policy.js

@@ -5,13 +5,13 @@ exports.buildQuorumPolicy = buildQuorumPolicy;
 exports.buildProposalPolicy = buildProposalPolicy;
 exports.buildTaskPolicy = buildTaskPolicy;
 exports.buildHandoffPolicy = buildHandoffPolicy;
+// ── Builder helpers ─────────────────────────────────────────────────
 function serializeCommitment(commitment) {
     return {
         authority: commitment?.authority ?? 'initiator_only',
         designated_roles: commitment?.designatedRoles ?? [],
     };
 }
-// ── Builder helpers ─────────────────────────────────────────────────
 function buildDecisionPolicy(policyId, description, rules) {
     const rulesJson = {
         voting: {

package/dist/projections/base.d.ts

@@ -0,0 +1,20 @@
+import type { ProtoRegistry } from '../proto-registry';
+import type { Envelope } from '../types';
+/**
+ * Abstract base for in-process mode-state tracking — parity with python-sdk's
+ * `macp_sdk.base_projection.BaseProjection`. Maintains a shared transcript,
+ * phase string, and commitment payload; subclasses override `applyMode`
+ * to handle mode-specific envelopes. `SessionStart` and `Commitment` are
+ * handled here so custom modes get the common lifecycle for free.
+ */
+export declare abstract class BaseProjection {
+    readonly transcript: Envelope[];
+    phase: string;
+    commitment?: Record<string, unknown>;
+    protected abstract readonly mode: string;
+    get isCommitted(): boolean;
+    get isPositiveOutcome(): boolean | undefined;
+    applyEnvelope(envelope: Envelope, protoRegistry: ProtoRegistry): void;
+    /** Handle a mode-specific (non-Commitment) envelope. */
+    protected abstract applyMode(envelope: Envelope, protoRegistry: ProtoRegistry): void;
+}

package/dist/projections/base.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProjection = void 0;
+/**
+ * Abstract base for in-process mode-state tracking — parity with python-sdk's
+ * `macp_sdk.base_projection.BaseProjection`. Maintains a shared transcript,
+ * phase string, and commitment payload; subclasses override `applyMode`
+ * to handle mode-specific envelopes. `SessionStart` and `Commitment` are
+ * handled here so custom modes get the common lifecycle for free.
+ */
+class BaseProjection {
+    transcript = [];
+    phase = '';
+    commitment;
+    get isCommitted() {
+        return this.commitment !== undefined;
+    }
+    get isPositiveOutcome() {
+        if (!this.commitment)
+            return undefined;
+        const val = this.commitment.outcomePositive ??
+            this.commitment.outcome_positive;
+        return val !== undefined ? Boolean(val) : true;
+    }
+    applyEnvelope(envelope, protoRegistry) {
+        if (envelope.mode !== this.mode)
+            return;
+        this.transcript.push(envelope);
+        if (envelope.messageType === 'Commitment') {
+            this.commitment = protoRegistry.decodeKnownPayload(envelope.mode, envelope.messageType, envelope.payload);
+            this.phase = 'Committed';
+            return;
+        }
+        this.applyMode(envelope, protoRegistry);
+    }
+}
+exports.BaseProjection = BaseProjection;

package/dist/projections.d.ts

@@ -1,3 +1,4 @@
+export * from './projections/base';
 export * from './projections/decision';
 export * from './projections/proposal';
 export * from './projections/task';

package/dist/projections.js

@@ -14,6 +14,7 @@ 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);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./projections/base"), exports);
 __exportStar(require("./projections/decision"), exports);
 __exportStar(require("./projections/proposal"), exports);
 __exportStar(require("./projections/task"), exports);

package/dist/task.d.ts

@@ -32,7 +32,7 @@ export declare class TaskSession {
         }[];
         sender?: string;
     }): Promise<Ack>;
-    request(input: TaskRequestPayload & {
+    requestTask(input: TaskRequestPayload & {
         sender?: string;
         auth?: AuthConfig;
     }): Promise<Ack>;
@@ -44,15 +44,15 @@ export declare class TaskSession {
         sender?: string;
         auth?: AuthConfig;
     }): Promise<Ack>;
-    update(input: TaskUpdatePayload & {
+    updateTask(input: TaskUpdatePayload & {
         sender?: string;
         auth?: AuthConfig;
     }): Promise<Ack>;
-    complete(input: TaskCompletePayload & {
+    completeTask(input: TaskCompletePayload & {
         sender?: string;
         auth?: AuthConfig;
     }): Promise<Ack>;
-    fail(input: TaskFailPayload & {
+    failTask(input: TaskFailPayload & {
         sender?: string;
         auth?: AuthConfig;
     }): Promise<Ack>;

package/dist/task.js

@@ -63,7 +63,7 @@ class TaskSession {
         });
         return this.sendAndTrack(envelope, this.auth);
     }
-    async request(input) {
+    async requestTask(input) {
         (0, validation_1.validateRequiredField)('taskId', input.taskId);
         (0, validation_1.validateRequiredField)('title', input.title);
         (0, validation_1.validateRequiredField)('instructions', input.instructions);
@@ -98,7 +98,7 @@ class TaskSession {
         });
         return this.sendAndTrack(envelope, input.auth);
     }
-    async update(input) {
+    async updateTask(input) {
         (0, validation_1.validateRequiredField)('taskId', input.taskId);
         const envelope = (0, envelope_1.buildEnvelope)({
             mode: constants_1.MODE_TASK,
@@ -109,7 +109,7 @@ class TaskSession {
         });
         return this.sendAndTrack(envelope, input.auth);
     }
-    async complete(input) {
+    async completeTask(input) {
         (0, validation_1.validateRequiredField)('taskId', input.taskId);
         const envelope = (0, envelope_1.buildEnvelope)({
             mode: constants_1.MODE_TASK,
@@ -120,7 +120,7 @@ class TaskSession {
         });
         return this.sendAndTrack(envelope, input.auth);
     }
-    async fail(input) {
+    async failTask(input) {
         (0, validation_1.validateRequiredField)('taskId', input.taskId);
         const envelope = (0, envelope_1.buildEnvelope)({
             mode: constants_1.MODE_TASK,

package/dist/watchers.d.ts

@@ -48,10 +48,22 @@ export declare class PolicyWatcher {
 export declare class SessionLifecycleWatcher {
     private readonly client;
     private readonly auth?;
+    private deprecatedEventsWarned;
+    private deprecatedNextEventWarned;
     constructor(client: MacpClient, options?: {
         auth?: AuthConfig;
     });
-    events(signal?: AbortSignal): AsyncGenerator<SessionLifecycleEvent, void, void>;
+    changes(signal?: AbortSignal): AsyncGenerator<SessionLifecycleEvent, void, void>;
     watch(handler: (event: SessionLifecycleEvent) => void | Promise<void>): Promise<void>;
+    nextChange(): Promise<SessionLifecycleEvent>;
+    /**
+     * @deprecated Use {@link changes} — renamed for parity with python-sdk's
+     * `SessionLifecycleWatcher.changes()` and the uniform `changes()` name
+     * used by all other watchers in both SDKs. Will be removed in 0.5.0.
+     */
+    events(signal?: AbortSignal): AsyncGenerator<SessionLifecycleEvent, void, void>;
+    /**
+     * @deprecated Use {@link nextChange}. Will be removed in 0.5.0.
+     */
     nextEvent(): Promise<SessionLifecycleEvent>;
 }

package/dist/watchers.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionLifecycleWatcher = exports.PolicyWatcher = exports.SignalWatcher = exports.RootsWatcher = exports.ModeRegistryWatcher = void 0;
+const logging_1 = require("./logging");
 function serverStreamToAsyncGenerator(stream) {
     const queue = [];
     let resolve = null;
@@ -177,11 +178,13 @@ exports.PolicyWatcher = PolicyWatcher;
 class SessionLifecycleWatcher {
     client;
     auth;
+    deprecatedEventsWarned = false;
+    deprecatedNextEventWarned = false;
     constructor(client, options) {
         this.client = client;
         this.auth = options?.auth;
     }
-    async *events(signal) {
+    async *changes(signal) {
         const stream = this.client.watchSessions(this.auth);
         if (signal) {
             signal.addEventListener('abort', () => stream.cancel(), { once: true });
@@ -193,17 +196,39 @@ class SessionLifecycleWatcher {
         }
     }
     async watch(handler) {
-        for await (const event of this.events()) {
+        for await (const event of this.changes()) {
             await handler(event);
         }
     }
-    async nextEvent() {
-        const gen = this.events();
+    async nextChange() {
+        const gen = this.changes();
         const result = await gen.next();
         await gen.return(undefined);
         if (result.done)
             throw new Error('stream ended before receiving a session lifecycle event');
         return result.value;
     }
+    /**
+     * @deprecated Use {@link changes} — renamed for parity with python-sdk's
+     * `SessionLifecycleWatcher.changes()` and the uniform `changes()` name
+     * used by all other watchers in both SDKs. Will be removed in 0.5.0.
+     */
+    async *events(signal) {
+        if (!this.deprecatedEventsWarned) {
+            this.deprecatedEventsWarned = true;
+            logging_1.logger.warn('[deprecated] SessionLifecycleWatcher.events() — use changes() instead');
+        }
+        yield* this.changes(signal);
+    }
+    /**
+     * @deprecated Use {@link nextChange}. Will be removed in 0.5.0.
+     */
+    async nextEvent() {
+        if (!this.deprecatedNextEventWarned) {
+            this.deprecatedNextEventWarned = true;
+            logging_1.logger.warn('[deprecated] SessionLifecycleWatcher.nextEvent() — use nextChange() instead');
+        }
+        return this.nextChange();
+    }
 }
 exports.SessionLifecycleWatcher = SessionLifecycleWatcher;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "macp-sdk-typescript",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "TypeScript SDK for the MACP Rust runtime",
   "license": "Apache-2.0",
   "type": "commonjs",
@@ -55,7 +55,7 @@
   "dependencies": {
     "@grpc/grpc-js": "^1.14.3",
     "@grpc/proto-loader": "^0.8.0",
-    "@multiagentcoordinationprotocol/proto": "^0.1.1",
+    "@multiagentcoordinationprotocol/proto": "^0.1.2",
     "protobufjs": "^8.0.0"
   },
   "devDependencies": {