@agentvalet/mcp-server 0.3.3 → 0.3.5

package/dist/index.js

@@ -325,6 +325,40 @@ async function fetchWithAuth(url, init) {
 function errorContent(message) {
     return { content: [{ type: "text", text: message }], isError: true };
 }
+// Return helper that gives an MCP-aware host the structured content directly
+// (no parse step), while still emitting the text-content envelope every MCP
+// client understands. Avoids the "list of length 1 with empty fields → let me
+// parse the wrapper" round-trip Claude does on tool results that are raw
+// JSON strings — every read-heavy use_platform call pays that cost otherwise.
+//
+// If `body` isn't valid JSON, we just return the text envelope unchanged —
+// callers that emit prose (summaries, error strings) get the old behaviour.
+function jsonContent(body) {
+    const parsed = tryParseJson(body);
+    if (parsed === undefined) {
+        return { content: [{ type: "text", text: body }] };
+    }
+    return {
+        content: [{ type: "text", text: body }],
+        structuredContent: parsed,
+    };
+}
+function tryParseJson(text) {
+    const trimmed = text.trim();
+    // Only attempt parse if it looks structured. Avoids parsing a stray "true"
+    // / number / etc. into structuredContent and confusing the host.
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("["))
+        return undefined;
+    try {
+        const v = JSON.parse(trimmed);
+        if (v && typeof v === "object")
+            return v;
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 // ---------------------------------------------------------------------------
 // Tool handlers
 // ---------------------------------------------------------------------------
@@ -343,7 +377,7 @@ async function handleListPlatforms() {
     const body = await response.text();
     if (!response.ok)
         return errorContent(`Proxy error ${response.status}: ${body}`);
-    return { content: [{ type: "text", text: body }] };
+    return jsonContent(body);
 }
 // Translates a fetch() failure into something an end-user can actually act on.
 // The default "Network error: fetch failed" message tells a non-developer
@@ -409,7 +443,7 @@ async function handleUsePlatform(params, progressToken) {
     }
     if (!response.ok)
         return errorContent(`Proxy error ${response.status}: ${body}`);
-    return { content: [{ type: "text", text: body }] };
+    return jsonContent(body);
 }
 async function waitForApproval(approvalId, originalCall, progressToken) {
     const startedAt = Date.now();
@@ -437,13 +471,27 @@ async function waitForApproval(approvalId, originalCall, progressToken) {
             // Re-execution complete. Return the upstream response transparently —
             // the agent sees this as if the original use_platform call just succeeded.
             const r = status.result;
-            const summary = `[Owner approved after ${Math.round(elapsed / 1000)}s]\n` +
-                JSON.stringify(r.data ?? null);
             // Mirror the non-2xx-from-upstream behaviour of the regular path.
             if (r.status < 200 || r.status >= 300) {
                 return errorContent(`Upstream returned ${r.status}: ${JSON.stringify(r.data)}`);
             }
-            return { content: [{ type: "text", text: summary }] };
+            // Two-channel return: the text envelope carries the human-readable
+            // "[Owner approved after Ns]" prefix (visible to non-structured-aware
+            // clients), and structuredContent carries the parsed upstream JSON
+            // directly so MCP-aware hosts (Claude Desktop ≥ MCP spec 2025-06-18)
+            // never have to strip-the-prefix-and-reparse. Without the second
+            // channel the prefix forces Claude into the same wrapper-parse
+            // round-trip the bare /v1/actions path used to.
+            const data = r.data ?? null;
+            const summary = `[Owner approved after ${Math.round(elapsed / 1000)}s]\n` +
+                JSON.stringify(data);
+            const result = {
+                content: [{ type: "text", text: summary }],
+            };
+            if (data && typeof data === "object" && !Array.isArray(data)) {
+                result.structuredContent = data;
+            }
+            return result;
         }
         if (status.status === "denied") {
             return errorContent(`Owner denied this action${status.execution_error ? `: ${status.execution_error}` : "."}`);
@@ -465,18 +513,13 @@ async function waitForApproval(approvalId, originalCall, progressToken) {
     // Timed out — fall through to async-recap path. The action is still
     // queued and will run when the owner approves; the user is notified via
     // push/email at that point. Layer 4's list_my_pending_actions surfaces it.
-    return {
-        content: [{
-                type: "text",
-                text: JSON.stringify({
-                    status: "pending_approval",
-                    approval_id: approvalId,
-                    message: `Owner hasn't approved within ${APPROVAL_POLL_BUDGET_MS / 1000}s. ` +
-                        `The action is queued — your owner will be notified, and you'll see it ` +
-                        `complete next time we chat (or you can ask me to check pending actions).`,
-                }),
-            }],
-    };
+    return jsonContent(JSON.stringify({
+        status: "pending_approval",
+        approval_id: approvalId,
+        message: `Owner hasn't approved within ${APPROVAL_POLL_BUDGET_MS / 1000}s. ` +
+            `The action is queued — your owner will be notified, and you'll see it ` +
+            `complete next time we chat (or you can ask me to check pending actions).`,
+    }));
 }
 function safeJsonParse(text) {
     try {
@@ -517,7 +560,7 @@ async function handleAgentRegister(args) {
     const body = await response.text();
     if (!response.ok)
         return errorContent(`Proxy error ${response.status}: ${body}`);
-    return { content: [{ type: "text", text: body }] };
+    return jsonContent(body);
 }
 async function handleAgentStatus(token) {
     let response;
@@ -533,7 +576,7 @@ async function handleAgentStatus(token) {
     const body = await response.text();
     if (!response.ok)
         return errorContent(`Proxy error ${response.status}: ${body}`);
-    return { content: [{ type: "text", text: body }] };
+    return jsonContent(body);
 }
 async function handleAuthzenEvaluate(platformId, scope) {
     const authzenBody = {
@@ -554,7 +597,7 @@ async function handleAuthzenEvaluate(platformId, scope) {
     const body = await response.text();
     if (!response.ok)
         return errorContent(`Proxy error ${response.status}: ${body}`);
-    return { content: [{ type: "text", text: body }] };
+    return jsonContent(body);
 }
 async function handleListMyPendingActions() {
     if (AGENT_PRIVATE_KEY_RAW === null) {
@@ -571,7 +614,7 @@ async function handleListMyPendingActions() {
     const text = await response.text();
     if (!response.ok)
         return errorContent(`Proxy error ${response.status}: ${text}`);
-    return { content: [{ type: "text", text }] };
+    return jsonContent(text);
 }
 async function handleReportSelfDiagnostic(args) {
     if (AGENT_PRIVATE_KEY_RAW === null) {
@@ -600,7 +643,7 @@ async function handleReportSelfDiagnostic(args) {
     const text = await response.text();
     if (!response.ok)
         return errorContent(`Proxy error ${response.status}: ${text}`);
-    return { content: [{ type: "text", text }] };
+    return jsonContent(text);
 }
 // ---------------------------------------------------------------------------
 // Connect transport

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentvalet/mcp-server",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "AgentValet MCP server — lets AI agents call approved platforms via the AgentValet proxy",
   "type": "module",
   "main": "dist/index.js",