nostr-bray 1.27.2 → 1.27.4

package/dist/catalog.d.ts

@@ -32,4 +32,25 @@ export declare class ActionCatalog {
  * Promoted tools go to the real server; everything else goes to the catalog.
  */
 export declare function createCatalogProxy(server: McpServer, catalog: ActionCatalog, promoted: Set<string>): McpServer;
+/**
+ * Coerce execute-action's `params`/`parameters` argument into a plain object.
+ *
+ * Accepts either:
+ *   - an object (the canonical shape), passed through unchanged
+ *   - a JSON string literal that parses to an object (some MCP clients serialise
+ *     record-typed fields this way because the compiled JSON Schema has no
+ *     fixed properties list)
+ *   - undefined (returns an empty object)
+ *
+ * Rejects malformed JSON strings and JSON that does not parse to a plain object
+ * (e.g. arrays, numbers, null), returning a structured error the caller can
+ * surface to the client without crashing.
+ */
+export declare function coerceActionParams(raw: unknown): {
+    ok: true;
+    value: Record<string, unknown>;
+} | {
+    ok: false;
+    error: string;
+};
 export {};

package/dist/catalog.js

@@ -104,21 +104,48 @@ export class ActionCatalog {
                     }],
             };
         });
+        // Accept either an object (the natural shape) or a JSON string literal.
+        // Some MCP clients (notably the Claude Code harness as of April 2026)
+        // serialise schema fields typed as z.record(z.unknown()) as a JSON string
+        // rather than a nested object, because the compiled JSON Schema has no
+        // fixed `properties` list. The handler below coerces strings by parsing
+        // them, returning a clean error on malformed JSON.
+        const paramsSchema = z.union([
+            z.record(z.string(), z.unknown()),
+            z.string(),
+        ]);
         server.registerTool('execute-action', {
             description: 'Execute an action found via search-actions. Pass the exact action name and its parameters.',
             inputSchema: {
                 action: z.string().describe('Action name from search-actions results'),
-                params: z.record(z.string(), z.unknown()).optional().describe('Parameters for the action (see search-actions results for expected params). Alias: parameters.'),
+                params: paramsSchema.optional().describe('Parameters for the action (see search-actions results for expected params). ' +
+                    'Alias: parameters. Accepts a JSON object or a JSON string literal.'),
                 // Alias for clients that naturally reach for "parameters" rather than "params".
                 // Without this, MCP SDK strips unknown keys from the validated args and the
                 // inner action handler receives an empty object, causing spurious
                 // "expected string, received undefined" validation failures.
-                parameters: z.record(z.string(), z.unknown()).optional().describe('Alias for params. Either field is accepted.'),
+                parameters: paramsSchema.optional().describe('Alias for params. Either field is accepted. ' +
+                    'Accepts a JSON object or a JSON string literal.'),
             },
             annotations: { openWorldHint: true },
         }, async ({ action, params, parameters }) => {
-            const resolved = (params ?? parameters ?? {});
-            return catalog.execute(action, resolved);
+            const raw = params ?? parameters;
+            const coerced = coerceActionParams(raw);
+            if (!coerced.ok) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: coerced.error,
+                                action,
+                                hint: 'Pass params (or parameters) as a JSON object like ' +
+                                    '{"pubkeyHex":"..."}, or as a JSON string literal of the ' +
+                                    'same shape. Malformed JSON strings are rejected.',
+                            }, null, 2),
+                        }],
+                };
+            }
+            return catalog.execute(action, coerced.value);
         });
     }
 }
@@ -152,3 +179,53 @@ function extractParams(schema) {
     }
     return params;
 }
+/**
+ * Coerce execute-action's `params`/`parameters` argument into a plain object.
+ *
+ * Accepts either:
+ *   - an object (the canonical shape), passed through unchanged
+ *   - a JSON string literal that parses to an object (some MCP clients serialise
+ *     record-typed fields this way because the compiled JSON Schema has no
+ *     fixed properties list)
+ *   - undefined (returns an empty object)
+ *
+ * Rejects malformed JSON strings and JSON that does not parse to a plain object
+ * (e.g. arrays, numbers, null), returning a structured error the caller can
+ * surface to the client without crashing.
+ */
+export function coerceActionParams(raw) {
+    if (raw === undefined || raw === null) {
+        return { ok: true, value: {} };
+    }
+    if (typeof raw === 'string') {
+        const trimmed = raw.trim();
+        if (trimmed === '') {
+            return { ok: true, value: {} };
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                ok: false,
+                error: `Invalid parameters: could not parse JSON string (${message})`,
+            };
+        }
+        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return {
+                ok: false,
+                error: 'Invalid parameters: JSON string must decode to an object, not an array or primitive',
+            };
+        }
+        return { ok: true, value: parsed };
+    }
+    if (typeof raw === 'object' && !Array.isArray(raw)) {
+        return { ok: true, value: raw };
+    }
+    return {
+        ok: false,
+        error: `Invalid parameters: expected an object or JSON string, received ${typeof raw}`,
+    };
+}

package/dist/relay-pool.d.ts

@@ -6,6 +6,25 @@ export interface PoolLike {
     querySync(relays: string[], filter: Filter): Promise<NostrEvent[]>;
     destroy(): void;
 }
+/**
+ * Summarise a publish attempt into the two boolean flags on {@link PublishResult}.
+ *
+ * `success` is true when the event reached the network as a majority: at least
+ * one relay accepted AND at least 50% of attempted relays accepted. This is the
+ * default "did my publish work" signal. Paywalled, whitelisted, or transient
+ * failures routinely leave some relays in the rejected list, so requiring every
+ * relay to accept produces far too many false negatives.
+ *
+ * `allAccepted` preserves the strict "every attempted relay accepted" semantic
+ * for callers that genuinely need it (e.g. high-assurance publishing to a
+ * small curated list of private relays).
+ *
+ * Zero attempted relays is treated as failure on both flags.
+ */
+export declare function summarisePublish(acceptedCount: number, attempted: number): {
+    success: boolean;
+    allAccepted: boolean;
+};
 export interface RelayPoolConfig {
     torProxy?: string;
     allowClearnet: boolean;

package/dist/relay-pool.js

@@ -1,3 +1,26 @@
+/**
+ * Summarise a publish attempt into the two boolean flags on {@link PublishResult}.
+ *
+ * `success` is true when the event reached the network as a majority: at least
+ * one relay accepted AND at least 50% of attempted relays accepted. This is the
+ * default "did my publish work" signal. Paywalled, whitelisted, or transient
+ * failures routinely leave some relays in the rejected list, so requiring every
+ * relay to accept produces far too many false negatives.
+ *
+ * `allAccepted` preserves the strict "every attempted relay accepted" semantic
+ * for callers that genuinely need it (e.g. high-assurance publishing to a
+ * small curated list of private relays).
+ *
+ * Zero attempted relays is treated as failure on both flags.
+ */
+export function summarisePublish(acceptedCount, attempted) {
+    if (attempted <= 0)
+        return { success: false, allAccepted: false };
+    return {
+        success: acceptedCount >= 1 && acceptedCount * 2 >= attempted,
+        allAccepted: acceptedCount === attempted,
+    };
+}
 /** Initialise WebSocket and create a real SimplePool — lazy-loaded to avoid side effects at import */
 async function createRealPool(torProxy) {
     const { useWebSocketImplementation, SimplePool } = await import('nostr-tools/pool');
@@ -72,7 +95,7 @@ export class RelayPool {
         const relays = this.getRelays(npub);
         const writeRelays = relays.write;
         if (writeRelays.length === 0) {
-            return { success: false, accepted: [], rejected: [], errors: ['no write relays configured'] };
+            return { success: false, allAccepted: false, accepted: [], rejected: [], errors: ['no write relays configured'] };
         }
         const promises = pool.publish(writeRelays, event);
         const accepted = [];
@@ -91,7 +114,7 @@ export class RelayPool {
             }
         }
         return {
-            success: accepted.length === writeRelays.length,
+            ...summarisePublish(accepted.length, writeRelays.length),
             accepted,
             rejected,
             errors,
@@ -101,7 +124,7 @@ export class RelayPool {
     async publishDirect(relays, event) {
         const pool = await this.poolReady;
         if (relays.length === 0) {
-            return { success: false, accepted: [], rejected: [], errors: ['no relays specified'] };
+            return { success: false, allAccepted: false, accepted: [], rejected: [], errors: ['no relays specified'] };
         }
         const promises = pool.publish(relays, event);
         const accepted = [];
@@ -120,7 +143,7 @@ export class RelayPool {
             }
         }
         return {
-            success: accepted.length === relays.length,
+            ...summarisePublish(accepted.length, relays.length),
             accepted,
             rejected,
             errors,

package/dist/social/scheduled.js

@@ -123,7 +123,12 @@ export async function handlePublishScheduled(pool, npub, queueDir) {
                 published++;
             }
             else {
-                console.error(`Failed to publish ${data.event.id}: rejected by all relays`);
+                // success is the majority-quorum flag: treat as failure only when
+                // we did not reach at least 50% of attempted relays.
+                const reason = result.accepted.length === 0
+                    ? 'rejected by all relays'
+                    : `only ${result.accepted.length}/${result.accepted.length + result.rejected.length} relays accepted`;
+                console.error(`Failed to publish ${data.event.id}: ${reason}`);
                 failed++;
             }
         }

package/dist/social/tools.js

@@ -25,7 +25,7 @@ export function registerSocialTools(server, deps) {
         maxEntries: deps.veilCacheMax ?? 500,
     });
     server.registerTool('social-post', {
-        description: 'Post a text note (kind 1) signed by the active identity and publish to relays. Returns { id, pubkey, publish: { success, accepted, rejected } }. The most common social action.',
+        description: 'Post a text note (kind 1) signed by the active identity and publish to relays. Returns { id, pubkey, publish: { success, allAccepted, accepted, rejected } } where success is the majority-quorum signal (true when at least one relay accepted and at least half of attempted relays accepted) and allAccepted is true only when every attempted relay accepted. The most common social action.',
         inputSchema: {
             content: z.string().describe('Text content of the note'),
         },

package/dist/types.d.ts

@@ -21,7 +21,18 @@ export interface RelaySet {
 }
 /** Result of a publish operation */
 export interface PublishResult {
+    /**
+     * True when the event is reliably published: at least one relay accepted
+     * AND at least 50% of attempted relays accepted. Captures both "reached
+     * the network" and "reached a majority", which matches real-world
+     * expectations where paywalled or whitelisted relays routinely reject.
+     */
     success: boolean;
+    /**
+     * True when every attempted relay accepted. Use this for high-assurance
+     * publishing to a small curated list of private relays.
+     */
+    allAccepted: boolean;
     accepted: string[];
     rejected: string[];
     errors: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-bray",
-  "version": "1.27.2",
+  "version": "1.27.4",
   "description": "Trust-aware Nostr for AI and humans. Three dimensions of trust -- verification, proximity, and access -- woven into every interaction.",
   "type": "module",
   "main": "dist/index.js",