@irisrun/channel-mcp 0.1.0 → 0.3.0

package/README.md

@@ -0,0 +1,33 @@
+# @irisrun/channel-mcp
+
+**Durable, replay-safe sessions — the agent exposed *as* an MCP server.** A minimal,
+faithful Model Context Protocol server over JSON-RPC 2.0 (stdio): `initialize` /
+`tools/list` / `tools/call {start, message}`. It speaks the same two-identifier
+protocol as every Iris channel — a stable `sessionId` plus a single-use
+`continuationToken` rotated every committed turn — and surfaces every failure as a
+**loud** JSON-RPC error, never a silent OK.
+
+## What it is
+
+`makeMcpChannel(...)` exposes `handle(req)` (the testable core) and `serve(in, out)`
+(newline-delimited JSON-RPC over stdin/stdout). It is **built on
+[`@irisrun/channel-core`](../channel-core/README.md)** — the shared channel **port** —
+so the token discipline (mint, rotate-only-on-a-committed-turn, atomic single-use) and
+the refusal taxonomy live in one place, and this transport just maps refusals to the
+JSON-RPC error range (`-32001` unknown session · `-32002` missing token · `-32003`
+stale token · `-32004` in-flight). It passes the same channel-port conformance suite
+`@irisrun/channel-rest` does — "channels behind one port" is an executed guarantee.
+
+Host-side (`node:crypto`); the pure core stays unchanged. MCP is dual-use; a
+real MCP stdio client is an env-gated smoke test.
+
+## Use it
+
+A client calls the `start` tool to begin a session and `message` to continue it,
+presenting the issued `continuationToken` each turn.
+
+See **[docs/Channels](../../docs/channels.md)** and the normative
+**[channel-port spec](../../docs/reference/channel-port-spec.md)**.
+
+---
+Part of [Iris](../../README.md) — own, portable, verifiable state.

package/dist/server.js

@@ -1,4 +1,4 @@
-// makeMcpChannel (ADR-0009, MCP is dual-use): the agent exposed AS an MCP server
+// makeMcpChannel (MCP is dual-use): the agent exposed AS an MCP server
 // over JSON-RPC 2.0. `handle(req)` is the testable core; `serve(in,out)` frames
 // newline-delimited JSON-RPC over a stream (stdin/stdout in production). It speaks
 // the SAME two-identifier protocol as channel-rest — the channel MINTS the
@@ -8,6 +8,7 @@
 // JSON-RPC error, never a silent OK. Host-side (node:crypto); core stays pure.
 import { randomUUID } from "node:crypto";
 import { runTurnOn } from "@irisrun/host";
+import { makeChannelSession } from "@irisrun/channel-core";
 // JSON-RPC + MCP error codes. Protocol errors use the standard codes; app errors
 // (token/session) use the implementation-defined -32000 range — all LOUD.
 const PARSE_ERROR = -32700;
@@ -34,11 +35,17 @@ const MESSAGE_TOOL = {
     },
 };
 export function makeMcpChannel(opts) {
-    const mintSessionId = opts.mintSessionId ?? (() => randomUUID());
-    const mintToken = opts.mintToken ?? (() => randomUUID());
     const serverInfo = opts.serverInfo ?? { name: "iris", version: "0.0.0" };
-    const tokens = new Map(); // the channel OWNS the current token per session
-    const inFlight = new Set(); // single-use guard under concurrency (see channel-rest)
+    // The two-identifier protocol (mint sessionId, own/rotate a single-use token, atomic
+    // single-use, committed-only rotation) lives in the shared channel-core port — the
+    // SAME driver channel-rest uses. This MCP transport just maps refusals to JSON-RPC
+    // error codes. (Previously this file rotated the token on EVERY committed-or-not turn;
+    // channel-core corrects that to rotate only on finished/parked.)
+    const session = makeChannelSession({
+        runTurn: async (sessionId, args) => runTurnOn(opts.adapter, { sessionId, ...opts.makeTurnInputs(sessionId, args) }),
+        mintSessionId: opts.mintSessionId ?? (() => randomUUID()),
+        mintToken: opts.mintToken ?? (() => randomUUID()),
+    });
     const ok = (id, result) => ({ jsonrpc: "2.0", id, result });
     const err = (id, code, message) => ({
         jsonrpc: "2.0",
@@ -46,7 +53,6 @@ export function makeMcpChannel(opts) {
         error: { code, message },
     });
     const toolResult = (payload) => ({ content: [{ type: "text", text: JSON.stringify(payload) }] });
-    const runOne = async (sessionId, args) => runTurnOn(opts.adapter, { sessionId, ...opts.makeTurnInputs(sessionId, args) });
     const turnPayload = (sessionId, token, outcome) => {
         const base = { sessionId, continuationToken: token, status: outcome.status };
         if (outcome.status === "finished" && outcome.output !== undefined)
@@ -57,36 +63,30 @@ export function makeMcpChannel(opts) {
             base.current = outcome.current;
         return base;
     };
+    // Map a channel-core refusal to its LOUD JSON-RPC error (the impl-defined -32000 range).
+    const refusalError = (id, reason, sessionId) => {
+        switch (reason) {
+            case "unknown-session":
+                return err(id, UNKNOWN_SESSION, `unknown session '${sessionId}'`);
+            case "missing-token":
+                return err(id, MISSING_TOKEN, "missing continuationToken");
+            case "stale-token":
+                return err(id, STALE_TOKEN, "stale or invalid continuationToken");
+            case "in-flight":
+                return err(id, IN_FLIGHT, "a turn is already in flight for this session");
+        }
+    };
     const callStart = async (id, args) => {
-        const sessionId = mintSessionId();
-        const outcome = await runOne(sessionId, args);
-        const token = mintToken();
-        tokens.set(sessionId, token);
-        return ok(id, toolResult(turnPayload(sessionId, token, outcome)));
+        const r = await session.start(args);
+        return ok(id, toolResult(turnPayload(r.sessionId, r.token, r.outcome)));
     };
     const callMessage = async (id, args) => {
         const sessionId = typeof args.sessionId === "string" ? args.sessionId : "";
-        if (!sessionId || !tokens.has(sessionId))
-            return err(id, UNKNOWN_SESSION, `unknown session '${sessionId}'`);
         const presented = typeof args.continuationToken === "string" ? args.continuationToken : null;
-        if (presented === null || presented === "")
-            return err(id, MISSING_TOKEN, "missing continuationToken");
-        if (presented !== tokens.get(sessionId))
-            return err(id, STALE_TOKEN, "stale or invalid continuationToken");
-        // ATOMIC single-use: the token check above and this claim run in ONE callback
-        // with no `await` between them; a concurrent second message is refused here.
-        if (inFlight.has(sessionId))
-            return err(id, IN_FLIGHT, "a turn is already in flight for this session");
-        inFlight.add(sessionId);
-        try {
-            const outcome = await runOne(sessionId, args);
-            const next = mintToken();
-            tokens.set(sessionId, next); // rotate ONLY after a committed turn → single-use
-            return ok(id, toolResult(turnPayload(sessionId, next, outcome)));
-        }
-        finally {
-            inFlight.delete(sessionId);
-        }
+        const r = await session.continueTurn(sessionId, presented, args);
+        if (!r.ok)
+            return refusalError(id, r.reason, sessionId);
+        return ok(id, toolResult(turnPayload(r.sessionId, r.token, r.outcome)));
     };
     const handle = async (raw) => {
         const req = raw;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@irisrun/channel-mcp",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "type": "module",
-  "description": "Iris MCP-server channel (ADR-0009, MCP dual-use) — the agent exposed AS an MCP server over JSON-RPC 2.0 (stdio). Same two-identifier protocol as channel-rest: the channel mints the sessionId, issues + rotates the continuationToken (atomically single-use), and surfaces every failure as a loud JSON-RPC error. A real MCP stdio client is a manual smoke.",
+  "description": "Iris MCP-server channel (MCP dual-use) — the agent exposed AS an MCP server over JSON-RPC 2.0 (stdio). Same two-identifier protocol as channel-rest: the channel mints the sessionId, issues + rotates the continuationToken (atomically single-use), and surfaces every failure as a loud JSON-RPC error. A real MCP stdio client is a manual smoke.",
   "exports": {
     ".": {
       "iris-src": "./src/index.ts",
@@ -11,8 +11,9 @@
     }
   },
   "dependencies": {
-    "@irisrun/core": "^0.1.0",
-    "@irisrun/host": "^0.1.0"
+    "@irisrun/core": "^0.3.0",
+    "@irisrun/channel-core": "^0.3.0",
+    "@irisrun/host": "^0.3.0"
   },
   "license": "MIT",
   "engines": {