offnadir-delta-mcp 1.26.0 → 1.28.0

package/README.md

@@ -16,7 +16,7 @@ satellite can actually resolve it, and produce a collection-ready plan.
 Real-time event and geospatial intelligence for OSINT, geopolitical risk, and GEOINT work —
 source-linked, geolocated, and current, not a training snapshot.
 
-`40` tools · MCP server version `1.26.0` · [full reference](https://offnadir-delta.com/docs/mcp)
+`41` tools · MCP server version `1.28.0` · [full reference](https://offnadir-delta.com/docs/mcp)
 
 ## What it does
 
@@ -77,7 +77,7 @@ locally from a generated catalog, so registries can introspect it without creden
 
 ### First call — free
 
-23 of the 40 tools cost nothing, so the first thing you run is free:
+23 of the 41 tools cost nothing, so the first thing you run is free:
 
 > Give me the latest Daily World Brief. Lead with the three most significant developments,
 > explain why each matters, and cite the supporting signals.
@@ -116,6 +116,7 @@ Whether a satellite can resolve it, which one, and when it next passes.
 | `rank_imaging_priority` | WHERE — and with what class (and therefore cost) of satellite — is observation most worthwhile right now? | 1 tok |
 | `survey_observable_events` | Which events in a window can a given in-app sensor actually RESOLVE? | 1 tok |
 | `predict_satellite_passes` | WHEN can this place next be imaged, and by WHAT — the timing half of collection planning. | 2 tok |
+| `test_hypotheses` | Given competing statements, return the observation that would REFUTE the most of them — and, in the same answer, the observations that would refute none of them however convincing they look. | 3 tok |
 | `lookup_elevation` | Measure terrain height from the Copernicus DEM GLO-30 — a point (lat + lon), an area (bbox), or a drawn polygon, for which the statistics are computed over the samples INSIDE the ring rather than its bounding box. | free |
 | `analyze_terrain` | Compute FROM the terrain rather than reading heights out of it (that is lookup_elevation). | free |
 

package/dist/catalog.js

@@ -13,7 +13,7 @@
  * Actual `tools/call` / `resources/read` / `prompts/get` requests are forwarded
  * to the remote server with the caller's OFFNADIR_DELTA_API_KEY (see index.ts).
  */
-// Generated for Off-Nadir Delta MCP 1.26.0.
+// Generated for Off-Nadir Delta MCP 1.28.0.
 export const TOOLS = [
     {
         "name": "query_signals",
@@ -815,10 +815,11 @@ export const TOOLS = [
                             "synspective",
                             "iqps",
                             "radarsat-2",
-                            "cosmo-skymed"
+                            "cosmo-skymed",
+                            "nisar"
                         ]
                     },
-                    "description": "Families to consider. Omit for all seven. Use this to compare \"free systematic only\" against \"what could I task\"."
+                    "description": "Families to consider. Omit for all thirteen. Use this to compare \"free systematic only\" (Sentinel, Landsat, NISAR) against \"what could I task\"."
                 },
                 "max_passes": {
                     "type": "number",
@@ -1189,7 +1190,7 @@ export const TOOLS = [
                 },
                 "event_id": {
                     "type": "number",
-                    "description": "Only claims about this event (global event id). Claims carry no event id — they are matched through the registry facilities the event is linked to, so an event with no facility link returns nothing rather than a guess (`event_link.linked` says which happened)."
+                    "description": "Only claims about this event (global event id). Two deterministic anchors are tried: the claim’s own recorded event, and the registry facilities the event is linked to. Neither is a guess — when neither resolves, nothing is returned and `event_link.linked` says so."
                 },
                 "limit": {
                     "type": "number",
@@ -1230,6 +1231,93 @@ export const TOOLS = [
             "destructiveHint": false
         }
     },
+    {
+        "name": "test_hypotheses",
+        "description": "Given competing statements, return the observation that would REFUTE the most of them — and, in the same answer, the observations that would refute none of them however convincing they look. Each statement is decomposed into the observables it requires (vessel presence, berth occupancy, burn extent, ground deformation, a running total…), and the observables are scored by how many statements their ABSENCE would eliminate. Read the direction carefully, because it only runs one way: an observable that is absent refutes every statement requiring it; an observable that is PRESENT refutes nothing, since a statement that does not require it is not predicting its absence. Four verdicts come back: `actionable` (Delta serves it today), `procurable` (real, but bought or fetched elsewhere — `how_to_obtain` says where), `not_observable` (no overhead collection settles it; a record or a transponder might), and `no_diagnostic_value` (every statement requires it, so measuring it cannot separate them). Pass `hypotheses` for a comparison you define, or `event_id` to test the claims you were already given about that event. Answering \"nothing you can collect would change this\" is a supported outcome, not a failure.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "hypotheses": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "minItems": 2,
+                    "maxItems": 8,
+                    "description": "Two to eight competing statements, one assertion each (up to 500 characters). Omit when using event_id."
+                },
+                "mode": {
+                    "type": "string",
+                    "enum": [
+                        "competing",
+                        "joint"
+                    ],
+                    "description": "`competing` (default): the statements are mutually exclusive, so the goal is to separate them and an observable required by all of them has no diagnostic value. `joint`: they are held together, so the goal is to falsify the most at once and an observable required by all of them is the best one. Ignored with event_id, which is always joint."
+                },
+                "event_id": {
+                    "type": "number",
+                    "description": "Use the standing claims you were given about this event (global event id) as the statements. Restated claims are excluded — only what currently stands is tested."
+                }
+            },
+            "required": []
+        },
+        "outputSchema": {
+            "type": "object",
+            "properties": {
+                "summary": {
+                    "type": "string",
+                    "description": "One-line natural-language summary of the result, ready to relay to a user."
+                },
+                "meta": {
+                    "type": "object",
+                    "description": "Query echo, token charge/balance (meta.tokens), and pagination where applicable."
+                },
+                "hypotheses": {
+                    "type": "array",
+                    "items": {
+                        "type": "object"
+                    }
+                },
+                "best": {
+                    "type": "object"
+                },
+                "discriminators": {
+                    "type": "array",
+                    "items": {
+                        "type": "object"
+                    }
+                },
+                "no_diagnostic_value": {
+                    "type": "array",
+                    "items": {
+                        "type": "object"
+                    }
+                },
+                "undecomposable": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                },
+                "no_discriminator_reason": {
+                    "type": "string"
+                },
+                "note": {
+                    "type": "string"
+                }
+            },
+            "required": [
+                "summary",
+                "discriminators",
+                "note"
+            ]
+        },
+        "annotations": {
+            "readOnlyHint": false,
+            "openWorldHint": false,
+            "destructiveHint": true
+        }
+    },
     {
         "name": "query_developments",
         "description": "What actually CHANGED about the events in an area — not which articles are new. Polling query_signals and diffing the ids finds new REPORTING: a 2025 attack re-reported in 2026 with a fresh attribution is indistinguishable from a fresh attack. This returns changes as changes, each with what it was and what it became. Two kinds, labelled: `world` = the event's own state moved (a death toll revised, a perpetrator named, a report disputed); `measurement` = what WE can now see moved (a location resolved, post-event imagery arrived, a SAR before/after pair became ready). This is the right source for \"what is new since last time\" and for a standing watch. By default only changes worth a person's attention are returned — set notable_only=false for the full ledger, including changes deliberately judged too minor to notify on.",
@@ -2216,7 +2304,7 @@ export const TOOLS = [
     },
     {
         "name": "get_entity",
-        "description": "What has happened at one place. Returns the registry record plus every event linked to it, each carrying HOW it was linked — `alias_exact_location` means a report named this facility, `geo_proximity` means a report was geolocated within range of it and the distance is given. Read the basis before treating a link as established: proximity is an association, not a statement that the event happened at this facility. Also returns how many Analyst claims mention it. Costs 1 token per lookup.",
+        "description": "What has happened at one place. Returns the registry record plus every event linked to it, each carrying HOW it was linked — `alias_exact_location` means a report named this facility, `geo_proximity` means a report was geolocated within range of it and the distance is given. Read the basis before treating a link as established: proximity is an association, not a statement that the event happened at this facility. Also returns how many Analyst claims mention it, and an OBSERVABILITY profile: the events linked here are decomposed into the observables that would have tested them, counted, and marked with whether Delta serves each one or where it could be obtained instead. That profile is derived from what actually happened at this place — it is not a general claim about places of this type, and a place with no linked events returns no profile rather than a guess. Costs 1 token per lookup.",
         "inputSchema": {
             "type": "object",
             "properties": {
@@ -2253,6 +2341,9 @@ export const TOOLS = [
                 },
                 "claim_count": {
                     "type": "number"
+                },
+                "observability": {
+                    "type": "object"
                 }
             },
             "required": [

package/dist/index.js

@@ -21,7 +21,7 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { PROMPTS, RESOURCES, RESOURCE_TEMPLATES, TOOLS } from './catalog.js';
-const VERSION = '1.26.0';
+const VERSION = '1.28.0';
 const REMOTE_URL = new URL(process.env.OFFNADIR_DELTA_MCP_URL ?? 'https://offnadir-delta.com/api/v1/mcp');
 /** Lazily-connected client to the hosted remote MCP server. */
 let remote = null;
@@ -38,7 +38,16 @@ async function getRemote() {
     }
     connecting = (async () => {
         const transport = new StreamableHTTPClientTransport(REMOTE_URL, {
-            requestInit: { headers: { Authorization: `Bearer ${apiKey}` } },
+            requestInit: {
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    // Identify the proxy in the server's request log. Without it every call through this
+                    // package arrives as a bare `node` and cannot be told apart from any other Node client,
+                    // so "how much traffic comes through npm" has no answer. Same shape as the Python SDK
+                    // (`offnadir-delta-python/x.y.z`), which the server already parses.
+                    'User-Agent': `offnadir-delta-mcp/${VERSION}`,
+                },
+            },
         });
         const client = new Client({ name: 'offnadir-delta-mcp-proxy', version: VERSION }, { capabilities: {} });
         await client.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "offnadir-delta-mcp",
-  "version": "1.26.0",
+  "version": "1.28.0",
   "description": "Local (stdio) MCP server for Off-Nadir Delta \u2014 live, geolocated world-event intelligence, a Daily World Brief, satellite-imagery search, and an OSINT/GEOINT analyst. Forwards to the hosted server with your API key.",
   "type": "module",
   "bin": {