@ema.co/mcp-toolkit 2026.2.27 → 2026.2.28

package/dist/mcp/handlers/conversation/send.js

@@ -0,0 +1,90 @@
+import { formatSendResponse } from "./formatters.js";
+/**
+ * Build a ChatbotMessage proto-dict from convenience parameters.
+ *
+ * Supports three message types:
+ *  - text:    Simple text message or text HITL continuation
+ *  - form:    Form HITL continuation (filled fields or cancellation)
+ *  - buttons: Button HITL continuation (selected button)
+ *
+ * If none of the convenience params are provided, falls back to `raw_message`
+ * which must be a pre-built ChatbotMessage dict with a valid `type` field.
+ */
+function buildChatbotMessage(args) {
+    const text = args.text;
+    const form = args.form;
+    const buttons = args.buttons;
+    const rawMessage = args.raw_message;
+    if (text !== undefined) {
+        return {
+            type: "MESSAGE_TYPE_TEXT",
+            textMessage: { contents: [text] },
+            isUserMessage: true,
+        };
+    }
+    if (buttons !== undefined) {
+        return {
+            type: "MESSAGE_TYPE_BUTTONS",
+            buttonsMessage: {
+                selectedButton: buttons.selected_button ?? buttons.selectedButton,
+            },
+            isUserMessage: true,
+        };
+    }
+    if (form !== undefined) {
+        return {
+            type: "MESSAGE_TYPE_FORM",
+            formMessage: {
+                fields: form.fields,
+                isCancelled: form.is_cancelled ?? form.isCancelled ?? false,
+                ...(form.content !== undefined && { content: form.content }),
+            },
+            isUserMessage: true,
+        };
+    }
+    if (rawMessage !== undefined) {
+        // Validate raw_message has a type field
+        if (!rawMessage.type || typeof rawMessage.type !== "string") {
+            return null; // Will trigger the "no content" error with a specific hint
+        }
+        return rawMessage;
+    }
+    return null;
+}
+/**
+ * Send a message in an existing conversation.
+ */
+export async function handleSend(args, client) {
+    const conversationId = args.conversation_id;
+    if (!conversationId) {
+        return {
+            error: "conversation_id is required",
+            hint: 'conversation(method="send", conversation_id="<uuid>", text="hello")',
+        };
+    }
+    const message = buildChatbotMessage(args);
+    if (!message) {
+        // Distinguish between raw_message validation failure and no content at all
+        if (args.raw_message) {
+            return {
+                error: "raw_message must include a 'type' field (e.g. 'MESSAGE_TYPE_TEXT')",
+                hint: 'raw_message={type:"MESSAGE_TYPE_TEXT", textMessage:{contents:["hello"]}, isUserMessage:true}',
+            };
+        }
+        return {
+            error: "No message content provided. Supply one of: text, form, buttons, or raw_message",
+            hint: 'conversation(method="send", conversation_id="...", text="your message")',
+            examples: [
+                'text="hello" - send a text message',
+                'buttons={selected_button:{label:"Yes",description:"Confirm"}} - select a button',
+                'raw_message={type:"MESSAGE_TYPE_FORM", formMessage:{...}} - submit a form (echo back formMessage with values)',
+                'form={is_cancelled:true} - cancel a form',
+            ],
+        };
+    }
+    const result = await client.sendMessage(conversationId, message, {
+        userContext: args.user_context,
+        originalMessageId: args.original_message_id,
+    });
+    return formatSendResponse(result);
+}

package/dist/mcp/handlers/data/index.js

@@ -18,6 +18,7 @@
  * - regenerate: Modify document section with new query
  * - replace: Replace entire document content (full replacement, not partial)
  * - sanitize: Sanitize data items for a persona
+ * - continue: Respond to HITL pause on a dashboard row (text, button, or form)
  *
  * Note: Schema is now at persona level: persona(method="schema", id="...")
  */
@@ -335,7 +336,11 @@ export async function handleData(args, client, readFile) {
                         persona_id: personaId,
                         uploaded_rows: results.length,
                         row_ids: results.map(r => r.row_id),
-                        _tip: "Dashboard rows created with file attachments trigger workflow execution automatically",
+                        _tip: "Rows created and workflow triggered. Poll for completion using method='result' with each row_id.",
+                        _next_step: results.length === 1
+                            ? `persona(id="${personaId}", data={method:"result", row_id:"${results[0].row_id}"})`
+                            : `Poll each row: ${results.map(r => `persona(id="${personaId}", data={method:"result", row_id:"${r.row_id}"})`).join(", ")}`,
+                        _poll_interval_seconds: 5,
                     };
                 }
                 catch (error) {
@@ -459,10 +464,40 @@ export async function handleData(args, client, readFile) {
                 return { error: `Failed to replace document: ${error instanceof Error ? error.message : String(error)}` };
             }
         }
+        case "result": {
+            // Get dashboard row result/output
+            const rowId = (dataArgs?.row_id ?? dataArgs?.id);
+            if (!rowId) {
+                return errorResult("data.result requires row_id parameter", {
+                    hint: "Get row_id from the upload response: persona(id='abc', data={method:'upload', items:[...]})",
+                });
+            }
+            const includeFileContents = (dataArgs?.include_file_contents ?? dataArgs?.include_files);
+            return handleDashboardResult(personaId, rowId, includeFileContents ?? false, client);
+        }
+        case "continue": {
+            // Respond to HITL pause on a dashboard row
+            const rowId = (dataArgs?.row_id ?? dataArgs?.id);
+            if (!rowId) {
+                return errorResult("data.continue requires row_id parameter", {
+                    hint: "Get row_id from the result response when requires_human_input=true",
+                });
+            }
+            const text = dataArgs?.text;
+            const buttons = dataArgs?.buttons;
+            const form = dataArgs?.form;
+            const rawContinuation = dataArgs?.raw_continuation;
+            if (!text && !buttons && !form && !rawContinuation) {
+                return errorResult("data.continue requires one of: text, buttons, form, or raw_continuation", {
+                    hint: "text='approved' for free-text, buttons={selected_button:{label:'Approve'}} for button selection, form={is_cancelled:true} for form cancellation, raw_continuation={formMessage:{...full form with values...}} for form submission",
+                });
+            }
+            return handleDashboardContinue(personaId, rowId, { text, buttons, form, raw: rawContinuation }, client);
+        }
         default:
             return {
                 error: `Unknown data method: ${method}`,
-                hint: "Valid methods: list, stats, templates, generate, get, copy, replicate, upload, delete, embedding, refresh, regenerate, replace, sanitize",
+                hint: "Valid methods: list, stats, templates, generate, get, copy, replicate, upload, delete, embed, refresh, result, continue, regenerate, replace, sanitize",
             };
     }
 }
@@ -684,6 +719,137 @@ async function handleDashboardRefresh(personaId, rowId, client) {
         return { error: `Failed to refresh dashboard row: ${error instanceof Error ? error.message : String(error)}` };
     }
 }
+/**
+ * Detect the type of continuation message (text, buttons, or form).
+ * Mirrors how chat's formatSendResponse detects MESSAGE_TYPE_BUTTONS/FORM/TEXT.
+ */
+function detectContinuationType(continuation) {
+    if (!continuation)
+        return "unknown";
+    // Check the oneof field that's populated in the ContinuationMessage proto
+    if (continuation.buttonsMessage)
+        return "buttons";
+    if (continuation.formMessage)
+        return "form";
+    if (continuation.textMessage)
+        return "text";
+    // Fallback: check for a `value` wrapper (some proto serializations)
+    const value = continuation.value;
+    if (value?.case === "buttonsMessage")
+        return "buttons";
+    if (value?.case === "formMessage")
+        return "form";
+    if (value?.case === "textMessage")
+        return "text";
+    return "unknown";
+}
+/**
+ * Get the result/output of a dashboard row.
+ * Detects row state and provides polling/debugging guidance.
+ */
+async function handleDashboardResult(personaId, rowId, includeFileContents, client) {
+    try {
+        const result = await client.getDashboardRowResult(personaId, rowId, includeFileContents);
+        const row = result.row;
+        const state = row?.state ?? "unknown";
+        const isComplete = state === "DASHBOARD_ROW_STATE_SUCCESS";
+        const isFailed = state === "DASHBOARD_ROW_STATE_FAILED";
+        const isReviewing = state === "DASHBOARD_ROW_STATE_REVIEWING";
+        const isRunning = [
+            "DASHBOARD_ROW_STATE_RUNNING",
+            "DASHBOARD_ROW_STATE_QUEUED",
+            "DASHBOARD_ROW_STATE_INITIAL",
+        ].includes(state);
+        const response = {
+            method: "result",
+            persona_id: personaId,
+            row_id: rowId,
+            state,
+            is_complete: isComplete,
+            row: result.row,
+        };
+        if (result.additional_column_details?.length) {
+            response.additional_column_details = result.additional_column_details;
+        }
+        if (isReviewing) {
+            // HITL — workflow is paused waiting for human input/approval
+            response.requires_human_input = true;
+            const continuation = (row?.continuationMessage ?? row?.continuation_message);
+            if (continuation) {
+                response.continuation_message = continuation;
+            }
+            // Detect continuation type for type-specific guidance (matches chat's formatSendResponse pattern)
+            const contType = detectContinuationType(continuation);
+            response.continuation_type = contType;
+            if (contType === "buttons") {
+                const buttonsMsg = continuation?.buttonsMessage;
+                const buttons = buttonsMsg?.buttons;
+                const labels = buttons?.map(b => b.label).filter(Boolean) ?? [];
+                response._tip = `HITL: The workflow is asking the user to select a button.${labels.length ? ` Options: ${labels.join(", ")}` : ""} Ask the user which to choose.`;
+                response._next_step = `persona(id="${personaId}", data={method:"continue", row_id:"${rowId}", buttons:{selected_button:{label:"<chosen label>"}}})`;
+            }
+            else if (contType === "form") {
+                const formMsg = continuation?.formMessage;
+                const isIntermediate = formMsg?.isIntermediate === true;
+                response._tip = `HITL: The workflow is asking the user to fill out a form.${isIntermediate ? " This is an INTERMEDIATE form — more fields will follow after submission." : ""} Review the fields in continuation_message.formMessage, ask the user for values, then echo back the full formMessage with values filled in using raw_continuation. Use form={is_cancelled:true} to cancel instead.`;
+                response._next_step = `persona(id="${personaId}", data={method:"continue", row_id:"${rowId}", raw_continuation:{formMessage:{...continuation_message.formMessage with field values filled in...}}})`;
+                response._form_value_guide = "Field values use wellKnown types: {wellKnown:{stringValue:'text'}} for strings, {wellKnown:{int64Value:'42'}} for ints (string-encoded), {wellKnown:{doubleValue:3.14}} for floats, {wellKnown:{boolValue:true}} for bools, {wellKnown:{dateValue:{year,month,day}}} for dates, {wellKnown:{datetimeValue:{utcTime:'ISO'}}} for datetimes. For struct dropdowns use Id as stringValue; for enum dropdowns use enumValue as stringValue.";
+            }
+            else {
+                response._tip = "HITL: Workflow is paused and waiting for human input. Review the continuation_message and ask the user what to do.";
+                response._next_step = `persona(id="${personaId}", data={method:"continue", row_id:"${rowId}", text:"user's response"})`;
+            }
+        }
+        else if (isRunning) {
+            response._tip = "Row is still processing. Poll again in 5-10 seconds.";
+            response._next_step = `persona(id="${personaId}", data={method:"result", row_id:"${rowId}"})`;
+            response._poll_interval_seconds = 5;
+        }
+        else if (isFailed) {
+            response._tip = "Row processing failed. Check workflow execution for details.";
+            const workflowRunId = row?.workflowRunId ?? row?.workflow_run_id;
+            if (workflowRunId) {
+                response._next_step = `debug(method="show_work", persona_id="${personaId}", workflow_run_id="${workflowRunId}")`;
+            }
+        }
+        else if (isComplete && !includeFileContents) {
+            response._tip = "Row complete. Add include_file_contents=true to get generated file contents.";
+        }
+        return response;
+    }
+    catch (error) {
+        return {
+            error: `Failed to get dashboard row result: ${error instanceof Error ? error.message : String(error)}`,
+            persona_id: personaId,
+            row_id: rowId,
+        };
+    }
+}
+/**
+ * Continue a paused (HITL) dashboard row with a response.
+ * Sends text, button selection, or form data to resume the workflow.
+ */
+async function handleDashboardContinue(personaId, rowId, continuation, client) {
+    try {
+        await client.continueDashboardRow(rowId, continuation);
+        return {
+            method: "continue",
+            persona_id: personaId,
+            row_id: rowId,
+            sent: continuation.raw ? "raw" : continuation.text ? "text" : continuation.buttons ? "buttons" : "form",
+            _tip: "Continuation sent. The workflow is resuming. Poll for the result.",
+            _next_step: `persona(id="${personaId}", data={method:"result", row_id:"${rowId}"})`,
+            _poll_interval_seconds: 5,
+        };
+    }
+    catch (error) {
+        return {
+            error: `Failed to continue dashboard row: ${error instanceof Error ? error.message : String(error)}`,
+            persona_id: personaId,
+            row_id: rowId,
+        };
+    }
+}
 // ─────────────────────────────────────────────────────────────────────────────
 // Method inference and clarification when method is omitted
 // ─────────────────────────────────────────────────────────────────────────────
@@ -733,7 +899,7 @@ function inferMethodAndClarify(args, dataArgs) {
     return {
         status: "clarification_needed",
         message: "What operation would you like to perform?",
-        options: ["list", "upload", "generate", "templates", "get", "delete", "copy", "replicate", "embedding", "sanitize", "refresh", "regenerate", "replace"],
+        options: ["list", "upload", "generate", "templates", "get", "delete", "copy", "replicate", "embedding", "sanitize", "refresh", "result", "continue", "regenerate", "replace"],
         hint: "Specify method='...' for direct execution. Example: data(persona_id='abc', method='list')",
     };
 }

package/dist/mcp/handlers/feedback/client-id.js

@@ -0,0 +1,49 @@
+/**
+ * Client Identity — Persistent anonymous client ID for feedback correlation.
+ *
+ * Generates a random UUID on first use and stores it at ~/.ema-mcp/client-id.
+ * This survives npm reinstalls, npx cache clears, and toolkit version bumps
+ * because it lives in the user's home directory, not in node_modules.
+ *
+ * No PII — just a random UUID for cross-session correlation.
+ */
+import { promises as fs } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { randomUUID } from "node:crypto";
+const EMA_MCP_DIR = join(homedir(), ".ema-mcp");
+const CLIENT_ID_PATH = join(EMA_MCP_DIR, "client-id");
+let cachedClientId = null;
+/**
+ * Get or create a persistent anonymous client ID.
+ * Cached in memory after first read — no repeated disk I/O.
+ */
+export async function getOrCreateClientId() {
+    if (cachedClientId)
+        return cachedClientId;
+    try {
+        const existing = await fs.readFile(CLIENT_ID_PATH, "utf-8");
+        const trimmed = existing.trim();
+        if (trimmed.length > 0) {
+            cachedClientId = trimmed;
+            return trimmed;
+        }
+    }
+    catch {
+        // File doesn't exist yet — will create below
+    }
+    const id = randomUUID();
+    try {
+        await fs.mkdir(dirname(CLIENT_ID_PATH), { recursive: true });
+        await fs.writeFile(CLIENT_ID_PATH, id + "\n", "utf-8");
+    }
+    catch {
+        // Best-effort persistence — if we can't write, use ephemeral ID for this session
+    }
+    cachedClientId = id;
+    return id;
+}
+/** The base directory for all MCP client-local state (~/.ema-mcp/). */
+export function getEmaMcpDir() {
+    return EMA_MCP_DIR;
+}

package/dist/mcp/handlers/feedback/coalesce.js

@@ -0,0 +1,167 @@
+/**
+ * Feedback Coalescing — Transform raw outbox entries into compact FeedbackDigest.
+ *
+ * Raw feedback and telemetry entries are accumulated locally. Before uploading,
+ * this module compresses them into a single digest that preserves signal while
+ * minimizing wire size.
+ *
+ * - Feedback: deduplicated by (category, message_prefix, tool, operation)
+ * - Telemetry: aggregated by (tool, operation) with error counts and latency stats
+ * - Resources: counted by URI
+ * - Probes: passed through as-is
+ */
+// ─────────────────────────────────────────────────────────────────────────────
+// Build Digest
+// ─────────────────────────────────────────────────────────────────────────────
+const MAX_MESSAGE_LEN = 200;
+const MAX_TOP_ERRORS = 3;
+export function buildDigest(entries, clientId, toolkitVersion) {
+    const feedbackEntries = [];
+    const telemetryEntries = [];
+    const probeResponses = [];
+    for (const entry of entries) {
+        switch (entry.kind) {
+            case "feedback":
+                feedbackEntries.push(entry.data);
+                break;
+            case "telemetry":
+                telemetryEntries.push(entry.data);
+                break;
+            case "probe_response":
+                probeResponses.push(entry.data);
+                break;
+        }
+    }
+    const allTimestamps = [
+        ...feedbackEntries.map((e) => e.ts),
+        ...telemetryEntries.map((e) => e.ts),
+        ...probeResponses.map((e) => e.ts),
+    ].sort();
+    const now = new Date().toISOString();
+    return {
+        schema_version: 1,
+        client_id: clientId,
+        toolkit_version: toolkitVersion,
+        flushed_at: now,
+        period: {
+            from: allTimestamps[0] ?? now,
+            to: allTimestamps[allTimestamps.length - 1] ?? now,
+        },
+        entry_count: entries.length,
+        feedback: deduplicateFeedback(feedbackEntries),
+        telemetry: coalesceTelemetry(telemetryEntries),
+        resource_usage: extractResourceUsage(telemetryEntries),
+        probe_responses: probeResponses.length > 0 ? probeResponses : undefined,
+        probes_shown: undefined, // Set by caller if probe tracking is available
+    };
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Feedback Deduplication
+// ─────────────────────────────────────────────────────────────────────────────
+function deduplicateFeedback(entries) {
+    const groups = new Map();
+    for (const e of entries) {
+        const msgPrefix = truncate(e.message, MAX_MESSAGE_LEN);
+        const key = `${e.category}|${msgPrefix}|${e.tool ?? ""}|${e.operation ?? ""}`;
+        const existing = groups.get(key);
+        if (existing) {
+            existing.count++;
+            if (e.ts < existing.first_seen)
+                existing.first_seen = e.ts;
+            if (e.ts > existing.last_seen)
+                existing.last_seen = e.ts;
+            if (e.severity && severityRank(e.severity) > severityRank(existing.severity)) {
+                existing.severity = e.severity;
+            }
+        }
+        else {
+            groups.set(key, {
+                category: e.category,
+                message: msgPrefix,
+                tool: e.tool,
+                operation: e.operation,
+                severity: e.severity,
+                count: 1,
+                first_seen: e.ts,
+                last_seen: e.ts,
+            });
+        }
+    }
+    return [...groups.values()].sort((a, b) => b.count - a.count);
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Telemetry Aggregation
+// ─────────────────────────────────────────────────────────────────────────────
+function coalesceTelemetry(entries) {
+    const groups = new Map();
+    for (const e of entries) {
+        if (e.type === "resource_fetch")
+            continue; // handled separately
+        const key = `${e.tool ?? "unknown"}:${e.op ?? ""}`;
+        let g = groups.get(key);
+        if (!g) {
+            g = { total: 0, errors: 0, latencies: [], errorMessages: new Map() };
+            groups.set(key, g);
+        }
+        g.total++;
+        if (!e.ok) {
+            g.errors++;
+            if (e.error_message) {
+                const normalized = truncate(e.error_message, 100);
+                g.errorMessages.set(normalized, (g.errorMessages.get(normalized) ?? 0) + 1);
+            }
+        }
+        if (e.ms != null) {
+            g.latencies.push(e.ms);
+        }
+    }
+    return [...groups.entries()].map(([key, g]) => {
+        const [tool, op] = key.split(":");
+        const agg = {
+            tool,
+            op: op || undefined,
+            total: g.total,
+            errors: g.errors,
+        };
+        if (g.latencies.length > 0) {
+            agg.avg_ms = Math.round(g.latencies.reduce((a, b) => a + b, 0) / g.latencies.length);
+            if (g.latencies.length >= 5) {
+                const sorted = [...g.latencies].sort((a, b) => a - b);
+                agg.p95_ms = sorted[Math.floor(sorted.length * 0.95)];
+            }
+        }
+        if (g.errorMessages.size > 0) {
+            agg.top_errors = [...g.errorMessages.entries()]
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, MAX_TOP_ERRORS)
+                .map(([message, count]) => ({ message, count }));
+        }
+        return agg;
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Resource Usage Extraction
+// ─────────────────────────────────────────────────────────────────────────────
+function extractResourceUsage(entries) {
+    const counts = new Map();
+    for (const e of entries) {
+        if (e.type === "resource_fetch" && e.resource_uri) {
+            counts.set(e.resource_uri, (counts.get(e.resource_uri) ?? 0) + 1);
+        }
+    }
+    if (counts.size === 0)
+        return undefined;
+    return [...counts.entries()]
+        .map(([uri, fetches]) => ({ uri, fetches }))
+        .sort((a, b) => b.fetches - a.fetches);
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+function truncate(value, maxLen) {
+    return value.length > maxLen ? value.slice(0, maxLen) + "..." : value;
+}
+const SEVERITY_RANK = { low: 1, medium: 2, high: 3 };
+function severityRank(severity) {
+    return severity ? (SEVERITY_RANK[severity] ?? 0) : 0;
+}

package/dist/mcp/handlers/feedback/index.js

@@ -9,15 +9,21 @@
  * - list    - View recent feedback entries
  * - analyze - Aggregate feedback + telemetry into actionable insights
  * - rotate  - Manually trigger log rotation
+ * - flush   - Force immediate outbox flush to remote storage
  */
 import { errorResult } from "../types.js";
 import { submitFeedback, listFeedback, listTelemetry, analyzeFeedback, rotateLogs, } from "./store.js";
+import { markProbeResponded } from "./probes.js";
+import { appendToOutbox, flushOutbox, getOutboxStats } from "./outbox.js";
+import { isRemoteEnabled } from "./remote-store.js";
+import { TOOLKIT_VERSION } from "../env/config.js";
 const VALID_CATEGORIES = [
     "gap",
     "confusion",
     "success",
     "error_unclear",
     "suggestion",
+    "probe_response",
 ];
 const VALID_SEVERITIES = ["low", "medium", "high"];
 /** Max lengths to prevent oversized entries from consuming disk/memory */
@@ -42,9 +48,11 @@ export async function handleFeedback(args) {
             return handleAnalyze();
         case "rotate":
             return handleRotate();
+        case "flush":
+            return handleFlush();
         default:
             return errorResult(`Unknown feedback method: ${method}`, {
-                hint: "Available methods: submit, list, analyze, rotate",
+                hint: "Available methods: submit, list, analyze, rotate, flush",
             });
     }
 }
@@ -83,6 +91,20 @@ async function handleSubmit(args) {
         context: args.context ? truncate(String(args.context), MAX_CONTEXT_LENGTH) : undefined,
         severity: severity,
     });
+    // Track probe responses for the probe system
+    if (category === "probe_response" && args.context) {
+        const probeId = String(args.context);
+        markProbeResponded(probeId);
+        // Also mirror to outbox as a dedicated probe_response entry
+        const probeResponse = {
+            id: probeId,
+            response: truncate(message, MAX_MESSAGE_LENGTH),
+            ts: entry.ts,
+        };
+        if (isRemoteEnabled()) {
+            appendToOutbox({ kind: "probe_response", data: probeResponse }).catch(() => { });
+        }
+    }
     return {
         success: true,
         feedback_id: entry.id,
@@ -137,3 +159,22 @@ async function handleRotate() {
         message: "Log files rotated successfully.",
     };
 }
+async function handleFlush() {
+    if (!isRemoteEnabled()) {
+        return {
+            success: false,
+            message: "Remote feedback collection is disabled (EMA_FEEDBACK_DISABLED=1).",
+            _tip: "Unset EMA_FEEDBACK_DISABLED to enable remote upload.",
+        };
+    }
+    const before = await getOutboxStats();
+    await flushOutbox(TOOLKIT_VERSION);
+    const after = await getOutboxStats();
+    return {
+        success: true,
+        message: `Outbox flushed. ${before.pending_entries} entries coalesced and uploaded.`,
+        before: { pending_entries: before.pending_entries, pending_size_bytes: before.pending_size_bytes },
+        after: { pending_entries: after.pending_entries, pending_size_bytes: after.pending_size_bytes },
+        total_digests_sent: after.sent_digests,
+    };
+}