@edda-business/mcp 0.71.0 → 0.72.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edda-business/mcp",
-  "version": "0.71.0",
+  "version": "0.72.0",
   "description": "Edda — the company data layer for AI agents.",
   "license": "Apache-2.0",
   "publishConfig": {

package/src/client.js

@@ -156,6 +156,34 @@ async function request(method, path, { body, query } = {}) {
   return res.json();
 }
 
+// Stream raw bytes with metadata on headers — the shape POST /v2/company/river/original expects.
+// A real file (a spreadsheet, a scanned contract) has no business being base64'd into a JSON tool
+// argument: it inflates by a third, buffers whole in memory at both ends, and blows the body limit.
+export async function postRaw(path, bytes, headers = {}) {
+  const apiKey = currentApiKey();
+  if (!apiKey) throw new Error("Missing Edda API key. Pass it as an Authorization: Bearer header.");
+  if (isReadOnly() && !currentApiUrl()) {
+    throw new Error("Read-only seat mode requires an explicit company API URL (EDDA_API_URL or the login config's apiUrl). No request was made.");
+  }
+  const url = new URL(path, currentApiUrl());
+  const res = await fetch(url.toString(), {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/octet-stream",
+      "X-Edda-Client": "mcp",
+      ...headers,
+    },
+    body: bytes,
+  });
+  if (!res.ok) {
+    let err = {};
+    try { err = await res.json(); } catch { /* non-JSON body */ }
+    throw new Error(`Edda API error (${res.status}): ${err.error || err.detail || res.statusText}`);
+  }
+  return res.json();
+}
+
 export function get(path, query) {
   return request("GET", path, { query });
 }

package/src/server.js

@@ -33,7 +33,7 @@
 
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
-import { get, post, patch, isReadOnly } from "./client.js";
+import { get, post, patch, postRaw, isReadOnly } from "./client.js";
 
 export const SERVER_VERSION = "0.66.0";
 
@@ -88,6 +88,28 @@ async function resolvePathToId(path) {
 
 // ─── factory ──────────────────────────────────────────────────────────────────
 
+// A real file goes up as a STREAM with a declared hash, not as base64 in a tool argument. The
+// agent names a path on its own disk; the MCP reads it, uploads the bytes to the original store,
+// and stages a candidate that references the registered original. `sha256` is declared so the
+// server fails closed if what arrived is not what the agent read.
+async function uploadLocalFile(filePath, { sourceId } = {}) {
+  const { readFile } = await import("node:fs/promises");
+  const { basename } = await import("node:path");
+  const crypto = await import("node:crypto");
+  let bytes;
+  try { bytes = await readFile(filePath); }
+  catch (e) { throw new Error(`Could not read ${filePath}: ${e.code === "ENOENT" ? "no such file" : e.message}`); }
+  const sha256 = crypto.createHash("sha256").update(bytes).digest("hex");
+  const name = basename(filePath);
+  const r = await postRaw("/v2/company/river/original", bytes, {
+    // The hash doubles as the idempotency key: the same bytes re-uploaded register once.
+    "X-Source-Id": sourceId || `mcp:${sha256}`,
+    "X-Original-Filename": encodeURIComponent(name),
+    "X-Sha256": sha256,
+  });
+  return { originalId: r?.original?.id ?? null, name, sha256, bytes: r?.original?.byte_size ?? bytes.length };
+}
+
 export function createServer() {
   // EfB seat boundary: with EDDA_MCP_READONLY set (the flag Hermes EfB box profiles use),
   // the personal agent gets EXACTLY search + read — the write tools (push/update/create) are
@@ -288,6 +310,7 @@ export function createServer() {
     {
       name: z.string().describe("File/page name, e.g. 'MCP Overview EFB' or 'Q3 invoices.xlsx'. A '.md' suffix is added to markdown items if missing."),
       content: z.string().optional().describe("The full markdown content, when you are sharing text you wrote. Omit when sending a FILE via file_base64."),
+      file_path: z.string().optional().describe("Absolute path to a file on THIS machine — PDF, Word, Excel, image, CSV. PREFER THIS over file_base64 for any real file: the bytes stream up with a checksum instead of being encoded into this argument. Use file_base64 only when you hold the bytes in memory and have no path."),
       file_base64: z.string().optional().describe(
         "A real FILE, base64-encoded — a proposal, invoice, report, financial model, scan. The server extracts the text: " +
         "PDF (scans are OCR'd), Word, Excel and legacy .xls (one heading per sheet), images (OCR'd), CSV and plain text. " +
@@ -320,10 +343,18 @@ export function createServer() {
         "and are applied only when a person approves the item. Cite nothing yourself — the filed document becomes the evidence."
       ),
     },
-    async ({ name, content, file_base64, mime, suggested, grade, audience, idempotency_key, claims }) => {
+    async ({ name, content, file_path, file_base64, mime, suggested, grade, audience, idempotency_key, claims }) => {
       try {
-        if (!content && !file_base64) return text(`Give "${name}" either markdown content or a file (file_base64) to stage.`);
-        const r = await post("/v2/company/river/stage", { name, content, file_base64, mime, suggested, grade, audience, idempotency_key, claims });
+        if (!content && !file_base64 && !file_path) return text(`Give "${name}" either markdown content or a file (file_path) to stage.`);
+        // A path wins: stream the bytes into the original store first, then stage a candidate that
+        // references the registered original. The server extracts the text from the original.
+        let original_id = null;
+        if (file_path) {
+          const up = await uploadLocalFile(file_path, { sourceId: idempotency_key ? `mcp:${idempotency_key}` : undefined });
+          original_id = up.originalId;
+          if (!name) name = up.name;
+        }
+        const r = await post("/v2/company/river/stage", { name, content, file_base64, original_id, mime, suggested, grade, audience, idempotency_key, claims });
         const rc = r?.receipt ?? r;
         if (rc?.idempotent) return text(`Already staged — "${name}" is in the company Inbox (${rc.location}). Nothing duplicated.`);
         if (rc?.rejected === "hash_mismatch") return text(`Couldn't stage "${name}": the content didn't match its declared checksum (it may have changed after approval). Re-capture and try again.`);
@@ -367,7 +398,8 @@ export function createServer() {
       items: z.array(z.object({
         name: z.string().describe("File/page name, e.g. 'Cook Street construction proposal.pdf'."),
         content: z.string().optional().describe("Markdown content, when sharing text you wrote. Omit when sending a file."),
-        file_base64: z.string().optional().describe("The file itself, base64-encoded — PDF, Word, Excel, image, CSV. Send the file rather than a summary of it."),
+        file_path: z.string().optional().describe("Absolute path to a file on THIS machine. PREFER THIS for any real file — the bytes stream up with a checksum instead of riding inside this argument."),
+        file_base64: z.string().optional().describe("The file itself, base64-encoded. Only when you hold the bytes in memory and have no path. Send the file rather than a summary of it."),
         mime: z.string().optional().describe("MIME type when known."),
         suggested: z.string().optional().describe("Optional destination HINT. A path you cannot see is dropped, and the item still lands in the Inbox."),
         grade: z.enum(["fact", "summary", "full"]).optional(),
@@ -386,10 +418,26 @@ export function createServer() {
     },
     async ({ items }) => {
       try {
-        const r = await post("/v2/company/river/stage-batch", { candidates: items });
+        // Upload any local files first, so the batch body stays small however large the documents
+        // are. A per-file failure becomes that item's receipt rather than killing the whole run.
+        const prepared = [];
+        for (const it of items) {
+          if (!it.file_path) { prepared.push(it); continue; }
+          try {
+            const up = await uploadLocalFile(it.file_path, { sourceId: it.idempotency_key ? `mcp:${it.idempotency_key}` : undefined });
+            const { file_path: _drop, ...rest } = it;
+            prepared.push({ ...rest, name: it.name || up.name, original_id: up.originalId });
+          } catch (e) {
+            prepared.push({ ...it, __upload_error: String(e.message || e) });
+          }
+        }
+        const failedUploads = prepared.filter((p) => p.__upload_error);
+        const sendable = prepared.filter((p) => !p.__upload_error);
+        const r = await post("/v2/company/river/stage-batch", { candidates: sendable });
         const staged = r?.staged ?? 0;
         const failed = r?.failed ?? 0;
-        const lines = [`Staged ${staged} item(s) into the company Inbox${failed ? `, ${failed} rejected` : ""}.`];
+        const lines = [`Staged ${staged} item(s) into the company Inbox${failed ? `, ${failed} rejected` : ""}${failedUploads.length ? `, ${failedUploads.length} unreadable` : ""}.`];
+        for (const f of failedUploads) lines.push(`  ✗ ${f.name ?? f.file_path} — ${f.__upload_error}`);
         for (const rec of r?.receipts ?? []) {
           if (rec.staged === false) lines.push(`  ✗ ${rec.name ?? "(unnamed)"} — ${rec.reason ?? rec.rejected ?? "unknown"}`);
           else if (rec.suggestion_dropped) lines.push(`  • ${rec.name} — staged; your suggested destination was dropped (not visible to you)`);