macp-sdk-typescript 0.7.1 → 0.9.0

package/dist/projections/proposal.js

@@ -2,16 +2,77 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProposalProjection = void 0;
 const constants_1 = require("../constants");
+const logging_1 = require("../logging");
 class ProposalProjection {
     proposals = new Map();
     accepts = [];
     rejections = [];
+    /**
+     * Each sender's current (unsuperseded) `Accept`, keyed by sender.
+     * RFC-MACP-0008 §5 rule 5 (`:70`): "A participant MAY change its
+     * acceptance target by sending a later `Accept` for a different live
+     * proposal. The latest accepted `Accept` from a participant supersedes
+     * earlier accepts from the same participant." `accepts` above retains the
+     * full append-only history (including superseded accepts) for audit
+     * purposes; `isAccepted` and `acceptedProposal` read from this map instead
+     * so they reflect the live acceptance set — required for determinism by
+     * §7 (`:89`): "Given the same accepted history and the same version-bound
+     * rules, implementations MUST derive the same live proposal set, the same
+     * acceptance set, and the same commitment eligibility."
+     */
+    latestAcceptBySender = new Map();
+    /**
+     * The session's accepted history, one envelope per unique `message_id`. See
+     * `BaseProjection.transcript` (`src/projections/base.ts`) for the full
+     * redelivery-idempotence contract (RFC-MACP-0006 §3.2); duplicated here
+     * only as a one-line pointer.
+     */
     transcript = [];
+    /**
+     * Cardinality anomalies recorded while replaying this projection's accepted
+     * transcript. See `BaseProjection.anomalies` (`src/projections/base.ts`)
+     * for the canonical description; duplicated here only as a one-line
+     * pointer. No built-in detection populates this for Proposal mode.
+     */
+    anomalies = [];
     phase = 'Negotiating';
     commitment;
+    /**
+     * `message_id`s already applied to this projection. See
+     * `BaseProjection.seenMessageIds` (`src/projections/base.ts`) for the full
+     * redelivery-idempotence rationale (RFC-MACP-0006 §3.2); duplicated here
+     * only as a one-line pointer.
+     */
+    seenMessageIds = new Set();
+    /**
+     * Apply one envelope to this projection's in-process state.
+     *
+     * Input contract: **accepted-only**, caller-maintained (`Envelope` carries
+     * no acceptance marker). Canonical source: `schemas/conformance/README.md`
+     * "Notes:", RFC-MACP-0007 §5.3, RFC-MACP-0011 §5. Full rationale and failure
+     * mode are documented once, on `BaseProjection.applyEnvelope`
+     * (`src/projections/base.ts`), and duplicated here only as a one-line
+     * pointer so six independent copies of the same prose cannot drift.
+     *
+     * Redelivery idempotence: a redelivered envelope (same `message_id`) is a
+     * non-event — not appended to `transcript`, not passed to the `switch`.
+     * See `BaseProjection.applyEnvelope` for the full RFC-MACP-0006 §3.2
+     * citation; duplicated here only as a one-line pointer.
+     */
     applyEnvelope(envelope, protoRegistry) {
         if (envelope.mode !== constants_1.MODE_PROPOSAL)
             return;
+        if (envelope.messageId) {
+            if (this.seenMessageIds.has(envelope.messageId)) {
+                logging_1.logger.debug('projection redelivery ignored', {
+                    messageId: envelope.messageId,
+                    mode: envelope.mode,
+                    messageType: envelope.messageType,
+                });
+                return;
+            }
+            this.seenMessageIds.add(envelope.messageId);
+        }
         this.transcript.push(envelope);
         const payload = protoRegistry.decodeKnownPayload(envelope.mode, envelope.messageType, envelope.payload);
         switch (envelope.messageType) {
@@ -41,7 +102,11 @@ class ProposalProjection {
             }
             case 'Accept': {
                 const record = payload;
-                this.accepts.push({ ...record, sender: envelope.sender });
+                const accept = { ...record, sender: envelope.sender };
+                this.accepts.push(accept);
+                // RFC-MACP-0008 §5 rule 5 (`:70`): this Accept supersedes any earlier
+                // one from the same sender for the live acceptance set.
+                this.latestAcceptBySender.set(envelope.sender, accept);
                 break;
             }
             case 'Reject': {
@@ -77,6 +142,14 @@ class ProposalProjection {
                 break;
         }
     }
+    /**
+     * True once at least one `ProjectionAnomaly` has been recorded. See
+     * `BaseProjection.hasAnomalies` (`src/projections/base.ts`) for the
+     * canonical description; duplicated here only as a one-line pointer.
+     */
+    get hasAnomalies() {
+        return this.anomalies.length > 0;
+    }
     get isCommitted() {
         return this.commitment !== undefined;
     }
@@ -94,8 +167,19 @@ class ProposalProjection {
         const all = [...this.proposals.values()];
         return all[all.length - 1];
     }
+    /**
+     * True if some participant's *current* (unsuperseded) `Accept` targets
+     * `proposalId` — RFC-MACP-0008 §5 rule 5 (`:70`). Note this reads from the
+     * live acceptance set, not from `accepts`' full history: a participant
+     * whose only accept for `proposalId` was later superseded by a re-accept
+     * of a different proposal is not counted.
+     */
     isAccepted(proposalId) {
-        return this.accepts.some((a) => a.proposalId === proposalId);
+        for (const accept of this.latestAcceptBySender.values()) {
+            if (accept.proposalId === proposalId)
+                return true;
+        }
+        return false;
     }
     isTerminallyRejected(proposalId) {
         return this.rejections.some((r) => r.proposalId === proposalId && r.terminal);
@@ -108,10 +192,19 @@ class ProposalProjection {
         }
         return result;
     }
+    /**
+     * The single proposal every participant's *current* accept targets, or
+     * `undefined` if no one has an outstanding accept or outstanding accepts
+     * are split across more than one proposal. Computed from the live
+     * acceptance set (see `isAccepted`), not from `accepts`' full history — a
+     * participant who accepts `p1` and later re-accepts `p2` (RFC-MACP-0008 §5
+     * rule 5, `:70`) contributes only `p2`, so this correctly returns `p2`
+     * rather than `undefined`.
+     */
     acceptedProposal() {
-        if (this.accepts.length === 0)
+        if (this.latestAcceptBySender.size === 0)
             return undefined;
-        const ids = new Set(this.accepts.map((a) => a.proposalId));
+        const ids = new Set([...this.latestAcceptBySender.values()].map((a) => a.proposalId));
         if (ids.size === 1)
             return ids.values().next().value;
         return undefined;

package/dist/projections/quorum.d.ts

@@ -1,3 +1,4 @@
+import type { ProjectionAnomaly } from './base';
 import type { Envelope } from '../types';
 import type { ProtoRegistry } from '../proto-registry';
 export interface ApprovalRequestRecord {
@@ -16,10 +17,52 @@ export interface BallotRecord {
 export declare class QuorumProjection {
     readonly requests: Map<string, ApprovalRequestRecord>;
     readonly ballots: Map<string, Map<string, BallotRecord>>;
+    /**
+     * The session's accepted history, one envelope per unique `message_id`. See
+     * `BaseProjection.transcript` (`src/projections/base.ts`) for the full
+     * redelivery-idempotence contract (RFC-MACP-0006 §3.2); duplicated here
+     * only as a one-line pointer.
+     */
     readonly transcript: Envelope[];
+    /**
+     * Cardinality anomalies recorded while replaying this projection's accepted
+     * transcript (e.g. a duplicate ballot across `Approve`/`Reject`/`Abstain`
+     * from the same sender for the same `request_id`). See
+     * `BaseProjection.anomalies` (`src/projections/base.ts`) for the canonical
+     * description; duplicated here only as a one-line pointer.
+     */
+    readonly anomalies: ProjectionAnomaly[];
     phase: 'Pending' | 'Voting' | 'Committed';
     commitment?: Record<string, unknown>;
+    /**
+     * `message_id`s already applied to this projection. See
+     * `BaseProjection.seenMessageIds` (`src/projections/base.ts`) for the full
+     * redelivery-idempotence rationale (RFC-MACP-0006 §3.2); duplicated here
+     * only as a one-line pointer.
+     */
+    private readonly seenMessageIds;
+    /**
+     * Apply one envelope to this projection's in-process state.
+     *
+     * Input contract: **accepted-only**, caller-maintained (`Envelope` carries
+     * no acceptance marker). Canonical source: `schemas/conformance/README.md`
+     * "Notes:", RFC-MACP-0007 §5.3, RFC-MACP-0011 §5. Full rationale and failure
+     * mode are documented once, on `BaseProjection.applyEnvelope`
+     * (`src/projections/base.ts`), and duplicated here only as a one-line
+     * pointer so six independent copies of the same prose cannot drift.
+     *
+     * Redelivery idempotence: a redelivered envelope (same `message_id`) is a
+     * non-event — not appended to `transcript`, not passed to the `switch`.
+     * See `BaseProjection.applyEnvelope` for the full RFC-MACP-0006 §3.2
+     * citation; duplicated here only as a one-line pointer.
+     */
     applyEnvelope(envelope: Envelope, protoRegistry: ProtoRegistry): void;
+    /**
+     * True once at least one `ProjectionAnomaly` has been recorded. See
+     * `BaseProjection.hasAnomalies` (`src/projections/base.ts`) for the
+     * canonical description; duplicated here only as a one-line pointer.
+     */
+    get hasAnomalies(): boolean;
     get isCommitted(): boolean;
     get isPositiveOutcome(): boolean | undefined;
     private setBallot;

package/dist/projections/quorum.js

@@ -2,15 +2,63 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QuorumProjection = void 0;
 const constants_1 = require("../constants");
+const logging_1 = require("../logging");
 class QuorumProjection {
     requests = new Map();
     ballots = new Map();
+    /**
+     * The session's accepted history, one envelope per unique `message_id`. See
+     * `BaseProjection.transcript` (`src/projections/base.ts`) for the full
+     * redelivery-idempotence contract (RFC-MACP-0006 §3.2); duplicated here
+     * only as a one-line pointer.
+     */
     transcript = [];
+    /**
+     * Cardinality anomalies recorded while replaying this projection's accepted
+     * transcript (e.g. a duplicate ballot across `Approve`/`Reject`/`Abstain`
+     * from the same sender for the same `request_id`). See
+     * `BaseProjection.anomalies` (`src/projections/base.ts`) for the canonical
+     * description; duplicated here only as a one-line pointer.
+     */
+    anomalies = [];
     phase = 'Pending';
     commitment;
+    /**
+     * `message_id`s already applied to this projection. See
+     * `BaseProjection.seenMessageIds` (`src/projections/base.ts`) for the full
+     * redelivery-idempotence rationale (RFC-MACP-0006 §3.2); duplicated here
+     * only as a one-line pointer.
+     */
+    seenMessageIds = new Set();
+    /**
+     * Apply one envelope to this projection's in-process state.
+     *
+     * Input contract: **accepted-only**, caller-maintained (`Envelope` carries
+     * no acceptance marker). Canonical source: `schemas/conformance/README.md`
+     * "Notes:", RFC-MACP-0007 §5.3, RFC-MACP-0011 §5. Full rationale and failure
+     * mode are documented once, on `BaseProjection.applyEnvelope`
+     * (`src/projections/base.ts`), and duplicated here only as a one-line
+     * pointer so six independent copies of the same prose cannot drift.
+     *
+     * Redelivery idempotence: a redelivered envelope (same `message_id`) is a
+     * non-event — not appended to `transcript`, not passed to the `switch`.
+     * See `BaseProjection.applyEnvelope` for the full RFC-MACP-0006 §3.2
+     * citation; duplicated here only as a one-line pointer.
+     */
     applyEnvelope(envelope, protoRegistry) {
         if (envelope.mode !== constants_1.MODE_QUORUM)
             return;
+        if (envelope.messageId) {
+            if (this.seenMessageIds.has(envelope.messageId)) {
+                logging_1.logger.debug('projection redelivery ignored', {
+                    messageId: envelope.messageId,
+                    mode: envelope.mode,
+                    messageType: envelope.messageType,
+                });
+                return;
+            }
+            this.seenMessageIds.add(envelope.messageId);
+        }
         this.transcript.push(envelope);
         const payload = protoRegistry.decodeKnownPayload(envelope.mode, envelope.messageType, envelope.payload);
         switch (envelope.messageType) {
@@ -22,17 +70,17 @@ class QuorumProjection {
             }
             case 'Approve': {
                 const record = payload;
-                this.setBallot(record.requestId, envelope.sender, 'approve', record.reason);
+                this.setBallot(envelope, record.requestId, 'approve', record.reason);
                 break;
             }
             case 'Reject': {
                 const record = payload;
-                this.setBallot(record.requestId, envelope.sender, 'reject', record.reason);
+                this.setBallot(envelope, record.requestId, 'reject', record.reason);
                 break;
             }
             case 'Abstain': {
                 const record = payload;
-                this.setBallot(record.requestId, envelope.sender, 'abstain', record.reason);
+                this.setBallot(envelope, record.requestId, 'abstain', record.reason);
                 break;
             }
             case 'Commitment': {
@@ -44,6 +92,14 @@ class QuorumProjection {
                 break;
         }
     }
+    /**
+     * True once at least one `ProjectionAnomaly` has been recorded. See
+     * `BaseProjection.hasAnomalies` (`src/projections/base.ts`) for the
+     * canonical description; duplicated here only as a one-line pointer.
+     */
+    get hasAnomalies() {
+        return this.anomalies.length > 0;
+    }
     get isCommitted() {
         return this.commitment !== undefined;
     }
@@ -54,9 +110,39 @@ class QuorumProjection {
             this.commitment.outcome_positive;
         return val !== undefined ? Boolean(val) : true;
     }
-    setBallot(requestId, sender, vote, reason) {
+    setBallot(envelope, requestId, vote, reason) {
         const senderMap = this.ballots.get(requestId) ?? new Map();
-        senderMap.set(sender, { requestId, vote, reason, sender });
+        const kept = senderMap.get(envelope.sender);
+        if (kept !== undefined) {
+            // RFC-MACP-0011 §5 rule 3 (`:67`): participation is MAY (a participant need
+            // not cast a ballot), but the cap of one ballot per participant ACROSS
+            // Approve, Reject, and Abstain is enforced under §5's opening sentence,
+            // "Implementations MUST enforce the following:" (`:63`). Do NOT phrase this
+            // as "a participant MUST cast at most one ballot" — RFC-0011 puts the MUST
+            // on the implementation, not the participant (contrast RFC-MACP-0007 §5.3,
+            // which puts it directly on the participant; same obligation, different
+            // addressee). A later ballot of a *different* type is still a duplicate,
+            // not a change of vote, so this guard is keyed on the sender ALONE within
+            // the request — never on sender + vote. macp-runtime enforces this
+            // identically in all three arms (quorum.rs:164/184/204).
+            // Keeping the sender's FIRST ballot (rather than the last) is not stated
+            // by RFC-0011 either; it is parity with RFC-MACP-0007 §5 item 3's
+            // explicit first-stands rule for `Vote`, plus macp-runtime's enforced
+            // first-wins behaviour.
+            const anomaly = {
+                kind: 'duplicate_ballot',
+                mode: envelope.mode,
+                messageType: envelope.messageType,
+                messageId: envelope.messageId,
+                sender: envelope.sender,
+                subjectId: requestId,
+                detail: `sender ${envelope.sender} already cast '${kept.vote}' on request ${requestId}; discarded '${vote}'`,
+            };
+            this.anomalies.push(anomaly);
+            logging_1.logger.warn('projection anomaly', anomaly);
+            return;
+        }
+        senderMap.set(envelope.sender, { requestId, vote, reason, sender: envelope.sender });
         this.ballots.set(requestId, senderMap);
     }
     approvalCount(requestId) {

package/dist/projections/task.d.ts

@@ -1,3 +1,4 @@
+import type { ProjectionAnomaly } from './base';
 import type { Envelope } from '../types';
 import type { ProtoRegistry } from '../proto-registry';
 export interface TaskRecord {
@@ -37,10 +38,51 @@ export declare class TaskProjection {
     readonly updates: TaskUpdateRecord[];
     readonly completions: TaskCompletionRecord[];
     readonly failures: TaskFailureRecord[];
+    /**
+     * The session's accepted history, one envelope per unique `message_id`. See
+     * `BaseProjection.transcript` (`src/projections/base.ts`) for the full
+     * redelivery-idempotence contract (RFC-MACP-0006 §3.2); duplicated here
+     * only as a one-line pointer.
+     */
     readonly transcript: Envelope[];
+    /**
+     * Cardinality anomalies recorded while replaying this projection's accepted
+     * transcript. See `BaseProjection.anomalies` (`src/projections/base.ts`)
+     * for the canonical description; duplicated here only as a one-line
+     * pointer. No built-in detection populates this for Task mode.
+     */
+    readonly anomalies: ProjectionAnomaly[];
     phase: 'Pending' | 'Requested' | 'InProgress' | 'Completed' | 'Failed' | 'Committed';
     commitment?: Record<string, unknown>;
+    /**
+     * `message_id`s already applied to this projection. See
+     * `BaseProjection.seenMessageIds` (`src/projections/base.ts`) for the full
+     * redelivery-idempotence rationale (RFC-MACP-0006 §3.2); duplicated here
+     * only as a one-line pointer.
+     */
+    private readonly seenMessageIds;
+    /**
+     * Apply one envelope to this projection's in-process state.
+     *
+     * Input contract: **accepted-only**, caller-maintained (`Envelope` carries
+     * no acceptance marker). Canonical source: `schemas/conformance/README.md`
+     * "Notes:", RFC-MACP-0007 §5.3, RFC-MACP-0011 §5. Full rationale and failure
+     * mode are documented once, on `BaseProjection.applyEnvelope`
+     * (`src/projections/base.ts`), and duplicated here only as a one-line
+     * pointer so six independent copies of the same prose cannot drift.
+     *
+     * Redelivery idempotence: a redelivered envelope (same `message_id`) is a
+     * non-event — not appended to `transcript`, not passed to the `switch`.
+     * See `BaseProjection.applyEnvelope` for the full RFC-MACP-0006 §3.2
+     * citation; duplicated here only as a one-line pointer.
+     */
     applyEnvelope(envelope: Envelope, protoRegistry: ProtoRegistry): void;
+    /**
+     * True once at least one `ProjectionAnomaly` has been recorded. See
+     * `BaseProjection.hasAnomalies` (`src/projections/base.ts`) for the
+     * canonical description; duplicated here only as a one-line pointer.
+     */
+    get hasAnomalies(): boolean;
     get isCommitted(): boolean;
     get isPositiveOutcome(): boolean | undefined;
     getTask(taskId: string): TaskRecord | undefined;

package/dist/projections/task.js

@@ -2,17 +2,64 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskProjection = void 0;
 const constants_1 = require("../constants");
+const logging_1 = require("../logging");
 class TaskProjection {
     tasks = new Map();
     updates = [];
     completions = [];
     failures = [];
+    /**
+     * The session's accepted history, one envelope per unique `message_id`. See
+     * `BaseProjection.transcript` (`src/projections/base.ts`) for the full
+     * redelivery-idempotence contract (RFC-MACP-0006 §3.2); duplicated here
+     * only as a one-line pointer.
+     */
     transcript = [];
+    /**
+     * Cardinality anomalies recorded while replaying this projection's accepted
+     * transcript. See `BaseProjection.anomalies` (`src/projections/base.ts`)
+     * for the canonical description; duplicated here only as a one-line
+     * pointer. No built-in detection populates this for Task mode.
+     */
+    anomalies = [];
     phase = 'Pending';
     commitment;
+    /**
+     * `message_id`s already applied to this projection. See
+     * `BaseProjection.seenMessageIds` (`src/projections/base.ts`) for the full
+     * redelivery-idempotence rationale (RFC-MACP-0006 §3.2); duplicated here
+     * only as a one-line pointer.
+     */
+    seenMessageIds = new Set();
+    /**
+     * Apply one envelope to this projection's in-process state.
+     *
+     * Input contract: **accepted-only**, caller-maintained (`Envelope` carries
+     * no acceptance marker). Canonical source: `schemas/conformance/README.md`
+     * "Notes:", RFC-MACP-0007 §5.3, RFC-MACP-0011 §5. Full rationale and failure
+     * mode are documented once, on `BaseProjection.applyEnvelope`
+     * (`src/projections/base.ts`), and duplicated here only as a one-line
+     * pointer so six independent copies of the same prose cannot drift.
+     *
+     * Redelivery idempotence: a redelivered envelope (same `message_id`) is a
+     * non-event — not appended to `transcript`, not passed to the `switch`.
+     * See `BaseProjection.applyEnvelope` for the full RFC-MACP-0006 §3.2
+     * citation; duplicated here only as a one-line pointer.
+     */
     applyEnvelope(envelope, protoRegistry) {
         if (envelope.mode !== constants_1.MODE_TASK)
             return;
+        if (envelope.messageId) {
+            if (this.seenMessageIds.has(envelope.messageId)) {
+                logging_1.logger.debug('projection redelivery ignored', {
+                    messageId: envelope.messageId,
+                    mode: envelope.mode,
+                    messageType: envelope.messageType,
+                });
+                return;
+            }
+            this.seenMessageIds.add(envelope.messageId);
+        }
         this.transcript.push(envelope);
         const payload = protoRegistry.decodeKnownPayload(envelope.mode, envelope.messageType, envelope.payload);
         switch (envelope.messageType) {
@@ -34,7 +81,30 @@ class TaskProjection {
             case 'TaskAccept': {
                 const record = payload;
                 const task = this.tasks.get(record.taskId);
-                if (task) {
+                // RFC-MACP-0009 §5 rules 3/3a (`:69-71`): "Only one assignee may
+                // become active for the Session in base v1. The first accepted
+                // `TaskAccept` from any eligible participant designates that
+                // participant as the active assignee. Subsequent `TaskAccept`
+                // messages for the same session MUST be rejected if an active
+                // assignee is already designated." A conforming runtime rejects the
+                // second `TaskAccept` before it reaches accepted history; this guard
+                // makes the projection first-accept-wins too, so a rogue second one
+                // (e.g. an unfiltered transcript) cannot silently reassign the task.
+                //
+                // Rule 3c's policy-gated reassignment path (`allow_reassignment_on_reject`,
+                // RFC-MACP-0012 `:135`) is deliberately NOT modelled here:
+                // `TaskProjection` has no session-policy input today, and rule 3b
+                // makes an unconditional reassignment wrong by default ("`TaskAccept`
+                // is irrevocable unless policy explicitly permits reassignment").
+                // Plumbing policy into this projection needs its own decision (see
+                // plans/cross-repo/macp-sdk-typescript-conformance-and-transport.md,
+                // Phase 3 open question 4) before that path can be implemented.
+                //
+                // An anomaly would be recorded when this guard discards a second
+                // `TaskAccept`, but `ProjectionAnomalyKind` (`base.ts:8-9`) is
+                // deliberately frozen pending cross-SDK agreement with
+                // macp-sdk-python.
+                if (task && task.assignee === undefined) {
                     task.assignee = record.assignee;
                     task.status = 'accepted';
                 }
@@ -44,6 +114,11 @@ class TaskProjection {
             case 'TaskReject': {
                 const record = payload;
                 const task = this.tasks.get(record.taskId);
+                // Deliberately does not clear `task.assignee`: rule 3c's
+                // policy-gated reassignment path is not modelled here (see the
+                // `TaskAccept` case above), so `assignee` is treated as sticky once
+                // set, per rule 3b's default ("irrevocable unless policy explicitly
+                // permits reassignment").
                 if (task)
                     task.status = 'rejected';
                 break;
@@ -87,6 +162,14 @@ class TaskProjection {
                 break;
         }
     }
+    /**
+     * True once at least one `ProjectionAnomaly` has been recorded. See
+     * `BaseProjection.hasAnomalies` (`src/projections/base.ts`) for the
+     * canonical description; duplicated here only as a one-line pointer.
+     */
+    get hasAnomalies() {
+        return this.anomalies.length > 0;
+    }
     get isCommitted() {
         return this.commitment !== undefined;
     }

package/dist/version.d.ts

@@ -4,4 +4,4 @@
  * Kept in sync with package.json by release-please (see the
  * `x-release-please-version` annotation).
  */
-export declare const VERSION = "0.7.1";
+export declare const VERSION = "0.9.0";

package/dist/version.js

@@ -7,4 +7,4 @@ exports.VERSION = void 0;
  * Kept in sync with package.json by release-please (see the
  * `x-release-please-version` annotation).
  */
-exports.VERSION = '0.7.1'; // x-release-please-version
+exports.VERSION = '0.9.0'; // x-release-please-version

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "macp-sdk-typescript",
-  "version": "0.7.1",
+  "version": "0.9.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.8",
+    "@multiagentcoordinationprotocol/proto": "^0.1.9",
     "protobufjs": "^8.6.5"
   },
   "devDependencies": {