@openshain/mcp 0.4.1 → 0.5.0

package/dist/server.js

@@ -194,6 +194,7 @@ const WORK_TOOLS = [
                         "model.completed",
                         "model.failed",
                         "usage.recorded",
+                        "conversation.compacted",
                     ],
                 },
                 payload: { type: "object" },
@@ -213,6 +214,8 @@ const RECORDABLE_TYPES = new Set([
     "model.completed",
     "model.failed",
     "usage.recorded",
+    // The conversation is the client's to shorten: the runtime holds the events either way.
+    "conversation.compacted",
 ]);
 const SESSION_HAS_NO_TOOLS = "a session records the conversation and runs no tools: call work_create with parent set to the session's id, then call the tool inside that work";
 const NO_WORK = "no current work: call work_create to start one for the person's request, or work_select to pick an existing one";
@@ -235,6 +238,20 @@ export async function createMcpServer(options) {
         authority: () => authority,
     });
     const works = new WorkStore(workspaceRoot);
+    /**
+     * Opens a work for one piece of work on it, and closes it however that ends. The lock a work
+     * holds is the single-writer rule, so it must not outlive the call that took it; releasing it
+     * here means no caller can forget to.
+     */
+    async function withWork(id, use) {
+        const opened = await works.open(id);
+        try {
+            return await use(opened);
+        }
+        finally {
+            await opened.close();
+        }
+    }
     const session = new Session();
     const server = new Server({ name: "openshain", version: pkg.version }, { capabilities: { tools: {} } });
     /** The current work when it can still take events; otherwise the reason it cannot. */
@@ -290,6 +307,11 @@ export async function createMcpServer(options) {
                 const work = await works.get(id);
                 if (isTerminal(work.status))
                     return failure(`work ${id} is already ${work.status}`);
+                // Selecting is what lets a client record into a work. Another person's conversation is
+                // theirs: a client that could select it could write what they never said.
+                if (work.principal !== config.principal.id) {
+                    return failure(`work ${id} belongs to ${work.principal}; a client selects only the works of the person it acts for`);
+                }
                 session.select(id);
                 return json({ ...work, history: workHistory(await works.events(id)) });
             }
@@ -315,18 +337,14 @@ export async function createMcpServer(options) {
                 }
                 const { question } = input;
                 const callId = newCallId();
-                const opened = await works.open(gate.id);
-                try {
+                await withWork(gate.id, async (opened) => {
                     await opened.append({
                         type: "tool.called",
                         payload: { callId, provider: RUNTIME_PROVIDER_ID, name: ASK_USER.name, input },
                     });
                     await opened.append({ type: "human.input_requested", payload: { callId, question } });
                     await opened.transition("waiting_input", "the agent asked the person a question");
-                }
-                finally {
-                    await opened.close();
-                }
+                });
                 return json({ pending: true, call_id: callId, question });
             }
             case "work_answer": {
@@ -342,8 +360,7 @@ export async function createMcpServer(options) {
                 if (!pending.some((q) => q.callId === callId)) {
                     return failure(`no unanswered question with call_id ${callId}; pending: ${pending.map((q) => q.callId).join(", ") || "none"}`);
                 }
-                const opened = await works.open(gate.id);
-                try {
+                return await withWork(gate.id, async (opened) => {
                     await opened.append({ type: "human.input_provided", payload: { callId, answer } });
                     await opened.append({
                         type: "tool.completed",
@@ -351,10 +368,7 @@ export async function createMcpServer(options) {
                     });
                     await opened.transition("in_progress", "the person answered");
                     return json(await opened.current());
-                }
-                finally {
-                    await opened.close();
-                }
+                });
             }
             case "work_record": {
                 const { work_id, type, payload } = input;
@@ -372,17 +386,13 @@ export async function createMcpServer(options) {
                 if (type === "usage.recorded" && parsed.kind !== "model_inference") {
                     return failure("usage.recorded from a client must have kind model_inference");
                 }
-                const opened = await works.open(id);
-                try {
+                return await withWork(id, async (opened) => {
                     const status = (await opened.current()).status;
                     if (isTerminal(status))
                         return failure(`work ${id} is already ${status}`);
                     const event = await opened.append({ type, payload: parsed });
                     return json({ id: event.id, seq: event.seq });
-                }
-                finally {
-                    await opened.close();
-                }
+                });
             }
             case "context": {
                 const now = new Date();
@@ -402,8 +412,7 @@ export async function createMcpServer(options) {
                 const current = session.current;
                 if (current && !isTerminal((await works.get(current)).status)) {
                     const callId = newCallId();
-                    const opened = await works.open(current);
-                    try {
+                    await withWork(current, async (opened) => {
                         await opened.append({
                             type: "tool.called",
                             payload: { callId, provider: RUNTIME_PROVIDER_ID, name: "context", input: {} },
@@ -412,10 +421,7 @@ export async function createMcpServer(options) {
                             type: "tool.completed",
                             payload: { callId, content: [{ type: "json", value: info }], isError: false },
                         });
-                    }
-                    finally {
-                        await opened.close();
-                    }
+                    });
                 }
                 return result;
             }
@@ -444,8 +450,7 @@ export async function createMcpServer(options) {
                 if (approval.approvers && !approval.approvers.includes(by)) {
                     return failure(`${by} may not decide ${approvalId}; approvers: ${approval.approvers.join(", ")}`);
                 }
-                const opened = await works.open(workId);
-                try {
+                return await withWork(workId, async (opened) => {
                     // Under the lock: another connection may have decided this approval in between.
                     if (!pendingApprovals(await opened.events()).some((a) => a.approvalId === approvalId)) {
                         return failure(`approval ${approvalId} was already decided`);
@@ -475,10 +480,7 @@ export async function createMcpServer(options) {
                         work_id: workId,
                         result: { content: result.content, isError: result.isError ?? false },
                     });
-                }
-                finally {
-                    await opened.close();
-                }
+                });
             }
             case "review_decide": {
                 const { approval_id: approvalId, decision, reviewer, interpretation, modified_input: modifiedInput, effective_from: effectiveFrom, effective_until: effectiveUntil, applies_to: appliesTo, } = input;
@@ -523,8 +525,7 @@ export async function createMcpServer(options) {
                     }
                     record = parsed.data;
                 }
-                const opened = await works.open(workId);
-                try {
+                return await withWork(workId, async (opened) => {
                     // Under the lock: another connection may have decided this approval in between.
                     if (!pendingApprovals(await opened.events()).some((a) => a.approvalId === approvalId)) {
                         return failure(`approval ${approvalId} was already decided`);
@@ -573,10 +574,7 @@ export async function createMcpServer(options) {
                         decision_file: relative(workspaceRoot, file),
                         result: { content: ran.content, isError: ran.isError ?? false },
                     });
-                }
-                finally {
-                    await opened.close();
-                }
+                });
             }
             case "work_list": {
                 const { works: all, problems } = await works.list();
@@ -602,7 +600,7 @@ export async function createMcpServer(options) {
                 if ("refused" in gate)
                     return gate.refused;
                 const { summary, artifacts } = input;
-                const work = await complete(works, workspaceRoot, gate.id, summary, artifacts ?? []);
+                const work = await withWork(gate.id, (opened) => complete(workspaceRoot, opened, summary, artifacts ?? []));
                 session.clear();
                 return json(work);
             }
@@ -611,13 +609,9 @@ export async function createMcpServer(options) {
                 if ("refused" in gate)
                     return gate.refused;
                 const { reason, detail } = input;
-                const opened = await works.open(gate.id);
-                try {
+                await withWork(gate.id, async (opened) => {
                     await opened.append({ type: "work.failed", payload: { reason, detail: detail ?? "" } });
-                }
-                finally {
-                    await opened.close();
-                }
+                });
                 session.clear();
                 return json(await works.get(gate.id));
             }
@@ -634,8 +628,7 @@ export async function createMcpServer(options) {
                 if (work.status === "waiting_approval") {
                     return failure(`work ${gate.id} is waiting for an approval; decide it with approval_decide (see approval_list) before calling tools`);
                 }
-                const opened = await works.open(gate.id);
-                try {
+                return await withWork(gate.id, async (opened) => {
                     const limit = config.limits.maxToolCalls;
                     if (countToolCalls(await opened.events()) >= limit) {
                         const reason = `this work has reached its limit of ${limit} tool calls; finish it with work_complete or work_fail`;
@@ -647,10 +640,7 @@ export async function createMcpServer(options) {
                     }
                     const result = await callTool(opened, { id: newCallId(), name, input });
                     return toMcpResult(result);
-                }
-                finally {
-                    await opened.close();
-                }
+                });
             }
         }
     }
@@ -674,38 +664,32 @@ export async function createMcpServer(options) {
  * wrote; every path must be inside the workspace, and the runtime hashes them all. A path no tool
  * of this work wrote is marked claimed, so a reader can tell the agent's word from the record.
  */
-async function complete(works, workspaceRoot, id, summary, claimed) {
+async function complete(workspaceRoot, opened, summary, claimed) {
     for (const { path } of claimed)
         await resolveWorkspacePath(workspaceRoot, path);
-    const opened = await works.open(id);
-    try {
-        const events = await opened.events();
-        const refs = [];
-        const byPath = new Map();
-        for (const event of writesWithAfter(events)) {
-            refs.push(event.id);
-            for (const { path, sha256 } of event.payload.after ?? [])
-                byPath.set(path, sha256);
-        }
-        const written = new Set(byPath.keys());
-        for (const { path, sha256 } of claimed)
-            if (!byPath.has(path))
-                byPath.set(path, sha256 ?? "");
-        const artifacts = [];
-        for (const [path, reported] of byPath) {
-            const artifact = await verifyArtifact(workspaceRoot, path, reported);
-            artifacts.push(written.has(path) ? artifact : { ...artifact, claimed: true });
-        }
-        await opened.append({
-            type: "evidence.recorded",
-            payload: { claim: summary, refs, artifacts },
-        });
-        await opened.append({ type: "work.completed", payload: { summary } });
-        return opened.current();
+    const events = await opened.events();
+    const refs = [];
+    const byPath = new Map();
+    for (const event of writesWithAfter(events)) {
+        refs.push(event.id);
+        for (const { path, sha256 } of event.payload.after ?? [])
+            byPath.set(path, sha256);
     }
-    finally {
-        await opened.close();
+    const written = new Set(byPath.keys());
+    for (const { path, sha256 } of claimed)
+        if (!byPath.has(path))
+            byPath.set(path, sha256 ?? "");
+    const artifacts = [];
+    for (const [path, reported] of byPath) {
+        const artifact = await verifyArtifact(workspaceRoot, path, reported);
+        artifacts.push(written.has(path) ? artifact : { ...artifact, claimed: true });
     }
+    await opened.append({
+        type: "evidence.recorded",
+        payload: { claim: summary, refs, artifacts },
+    });
+    await opened.append({ type: "work.completed", payload: { summary } });
+    return opened.current();
 }
 function writesWithAfter(events) {
     return events.filter((e) => e.type === "tool.completed" &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openshain/mcp",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "MCP server that exposes an openshain workspace to any agent",
   "keywords": [
     "openshain",
@@ -46,10 +46,10 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",
-    "@openshain/core": "0.4.1"
+    "@openshain/core": "0.5.0"
   },
   "devDependencies": {
-    "@openshain/tools": "0.4.1"
+    "@openshain/tools": "0.5.0"
   },
   "publishConfig": {
     "access": "public"

package/src/server.ts

@@ -40,6 +40,7 @@ import {
   uuidv7,
   verifyArtifact,
   type Work,
+  type WorkHandle,
   type WorkId,
   WorkStore,
   workHistory,
@@ -254,6 +255,7 @@ const WORK_TOOLS: Tool[] = [
             "model.completed",
             "model.failed",
             "usage.recorded",
+            "conversation.compacted",
           ],
         },
         payload: { type: "object" },
@@ -275,6 +277,8 @@ const RECORDABLE_TYPES: ReadonlySet<string> = new Set([
   "model.completed",
   "model.failed",
   "usage.recorded",
+  // The conversation is the client's to shorten: the runtime holds the events either way.
+  "conversation.compacted",
 ]);
 
 const SESSION_HAS_NO_TOOLS =
@@ -305,6 +309,20 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
     authority: () => authority,
   });
   const works = new WorkStore(workspaceRoot);
+
+  /**
+   * Opens a work for one piece of work on it, and closes it however that ends. The lock a work
+   * holds is the single-writer rule, so it must not outlive the call that took it; releasing it
+   * here means no caller can forget to.
+   */
+  async function withWork<T>(id: WorkId, use: (opened: WorkHandle) => Promise<T>): Promise<T> {
+    const opened = await works.open(id);
+    try {
+      return await use(opened);
+    } finally {
+      await opened.close();
+    }
+  }
   const session = new Session();
   const server = new Server(
     { name: "openshain", version: pkg.version },
@@ -371,6 +389,13 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
         const id = parseWorkId((input as { id: string }).id);
         const work = await works.get(id);
         if (isTerminal(work.status)) return failure(`work ${id} is already ${work.status}`);
+        // Selecting is what lets a client record into a work. Another person's conversation is
+        // theirs: a client that could select it could write what they never said.
+        if (work.principal !== config.principal.id) {
+          return failure(
+            `work ${id} belongs to ${work.principal}; a client selects only the works of the person it acts for`,
+          );
+        }
         session.select(id);
         return json({ ...work, history: workHistory(await works.events(id)) });
       }
@@ -394,17 +419,14 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
         }
         const { question } = input as { question: string };
         const callId = newCallId();
-        const opened = await works.open(gate.id);
-        try {
+        await withWork(gate.id, async (opened) => {
           await opened.append({
             type: "tool.called",
             payload: { callId, provider: RUNTIME_PROVIDER_ID, name: ASK_USER.name, input },
           });
           await opened.append({ type: "human.input_requested", payload: { callId, question } });
           await opened.transition("waiting_input", "the agent asked the person a question");
-        } finally {
-          await opened.close();
-        }
+        });
         return json({ pending: true, call_id: callId, question });
       }
       case "work_answer": {
@@ -421,8 +443,7 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
             `no unanswered question with call_id ${callId}; pending: ${pending.map((q) => q.callId).join(", ") || "none"}`,
           );
         }
-        const opened = await works.open(gate.id);
-        try {
+        return await withWork(gate.id, async (opened) => {
           await opened.append({ type: "human.input_provided", payload: { callId, answer } });
           await opened.append({
             type: "tool.completed",
@@ -430,9 +451,7 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
           });
           await opened.transition("in_progress", "the person answered");
           return json(await opened.current());
-        } finally {
-          await opened.close();
-        }
+        });
       }
       case "work_record": {
         const { work_id, type, payload } = input as {
@@ -456,15 +475,12 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
         if (type === "usage.recorded" && (parsed as { kind: string }).kind !== "model_inference") {
           return failure("usage.recorded from a client must have kind model_inference");
         }
-        const opened = await works.open(id);
-        try {
+        return await withWork(id, async (opened) => {
           const status = (await opened.current()).status;
           if (isTerminal(status)) return failure(`work ${id} is already ${status}`);
           const event = await opened.append({ type, payload: parsed } as never);
           return json({ id: event.id, seq: event.seq });
-        } finally {
-          await opened.close();
-        }
+        });
       }
       case "context": {
         const now = new Date();
@@ -484,8 +500,7 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
         const current = session.current;
         if (current && !isTerminal((await works.get(current)).status)) {
           const callId = newCallId();
-          const opened = await works.open(current);
-          try {
+          await withWork(current, async (opened) => {
             await opened.append({
               type: "tool.called",
               payload: { callId, provider: RUNTIME_PROVIDER_ID, name: "context", input: {} },
@@ -494,9 +509,7 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
               type: "tool.completed",
               payload: { callId, content: [{ type: "json", value: info }], isError: false },
             });
-          } finally {
-            await opened.close();
-          }
+          });
         }
         return result;
       }
@@ -531,8 +544,7 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
             `${by} may not decide ${approvalId}; approvers: ${approval.approvers.join(", ")}`,
           );
         }
-        const opened = await works.open(workId);
-        try {
+        return await withWork(workId, async (opened) => {
           // Under the lock: another connection may have decided this approval in between.
           if (!pendingApprovals(await opened.events()).some((a) => a.approvalId === approvalId)) {
             return failure(`approval ${approvalId} was already decided`);
@@ -566,9 +578,7 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
             work_id: workId,
             result: { content: result.content, isError: result.isError ?? false },
           });
-        } finally {
-          await opened.close();
-        }
+        });
       }
       case "review_decide": {
         const {
@@ -638,8 +648,7 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
           }
           record = parsed.data;
         }
-        const opened = await works.open(workId);
-        try {
+        return await withWork(workId, async (opened) => {
           // Under the lock: another connection may have decided this approval in between.
           if (!pendingApprovals(await opened.events()).some((a) => a.approvalId === approvalId)) {
             return failure(`approval ${approvalId} was already decided`);
@@ -693,9 +702,7 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
             decision_file: relative(workspaceRoot, file),
             result: { content: ran.content, isError: ran.isError ?? false },
           });
-        } finally {
-          await opened.close();
-        }
+        });
       }
       case "work_list": {
         const { works: all, problems } = await works.list();
@@ -723,7 +730,9 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
           summary: string;
           artifacts?: { path: string; sha256?: string }[];
         };
-        const work = await complete(works, workspaceRoot, gate.id, summary, artifacts ?? []);
+        const work = await withWork(gate.id, (opened) =>
+          complete(workspaceRoot, opened, summary, artifacts ?? []),
+        );
         session.clear();
         return json(work);
       }
@@ -731,12 +740,9 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
         const gate = await openWork();
         if ("refused" in gate) return gate.refused;
         const { reason, detail } = input as { reason: string; detail?: string };
-        const opened = await works.open(gate.id);
-        try {
+        await withWork(gate.id, async (opened) => {
           await opened.append({ type: "work.failed", payload: { reason, detail: detail ?? "" } });
-        } finally {
-          await opened.close();
-        }
+        });
         session.clear();
         return json(await works.get(gate.id));
       }
@@ -755,8 +761,7 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
             `work ${gate.id} is waiting for an approval; decide it with approval_decide (see approval_list) before calling tools`,
           );
         }
-        const opened = await works.open(gate.id);
-        try {
+        return await withWork(gate.id, async (opened) => {
           const limit = config.limits.maxToolCalls;
           if (countToolCalls(await opened.events()) >= limit) {
             const reason = `this work has reached its limit of ${limit} tool calls; finish it with work_complete or work_fail`;
@@ -768,9 +773,7 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
           }
           const result = await callTool(opened, { id: newCallId(), name, input });
           return toMcpResult(result);
-        } finally {
-          await opened.close();
-        }
+        });
       }
     }
   }
@@ -799,38 +802,32 @@ export async function createMcpServer(options: McpServerOptions): Promise<Server
  * of this work wrote is marked claimed, so a reader can tell the agent's word from the record.
  */
 async function complete(
-  works: WorkStore,
   workspaceRoot: string,
-  id: WorkId,
+  opened: WorkHandle,
   summary: string,
   claimed: { path: string; sha256?: string }[],
 ): Promise<Work> {
   for (const { path } of claimed) await resolveWorkspacePath(workspaceRoot, path);
-  const opened = await works.open(id);
-  try {
-    const events = await opened.events();
-    const refs: string[] = [];
-    const byPath = new Map<string, string>();
-    for (const event of writesWithAfter(events)) {
-      refs.push(event.id);
-      for (const { path, sha256 } of event.payload.after ?? []) byPath.set(path, sha256);
-    }
-    const written = new Set(byPath.keys());
-    for (const { path, sha256 } of claimed) if (!byPath.has(path)) byPath.set(path, sha256 ?? "");
-    const artifacts: Artifact[] = [];
-    for (const [path, reported] of byPath) {
-      const artifact = await verifyArtifact(workspaceRoot, path, reported);
-      artifacts.push(written.has(path) ? artifact : { ...artifact, claimed: true });
-    }
-    await opened.append({
-      type: "evidence.recorded",
-      payload: { claim: summary, refs, artifacts },
-    });
-    await opened.append({ type: "work.completed", payload: { summary } });
-    return opened.current();
-  } finally {
-    await opened.close();
+  const events = await opened.events();
+  const refs: string[] = [];
+  const byPath = new Map<string, string>();
+  for (const event of writesWithAfter(events)) {
+    refs.push(event.id);
+    for (const { path, sha256 } of event.payload.after ?? []) byPath.set(path, sha256);
+  }
+  const written = new Set(byPath.keys());
+  for (const { path, sha256 } of claimed) if (!byPath.has(path)) byPath.set(path, sha256 ?? "");
+  const artifacts: Artifact[] = [];
+  for (const [path, reported] of byPath) {
+    const artifact = await verifyArtifact(workspaceRoot, path, reported);
+    artifacts.push(written.has(path) ? artifact : { ...artifact, claimed: true });
   }
+  await opened.append({
+    type: "evidence.recorded",
+    payload: { claim: summary, refs, artifacts },
+  });
+  await opened.append({ type: "work.completed", payload: { summary } });
+  return opened.current();
 }
 
 function writesWithAfter(events: AnyEvent[]): Event<"tool.completed">[] {