@integraledger/lcp-mcp-server 0.9.0

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { readOnlyToolAnnotations, type ToolReach, } from "./annotations.js";
+export { manifestSummary, refusalResult, resolveAdapter, } from "./dispatch.js";
+export { isoNow, nodePorts, REVERSE_DOMAIN_ENV } from "./node-ports.js";
+export type { LcpMcpPorts } from "./ports.js";
+export { createLcpMcpServer, LCP_TOOL_NAMES, SERVER_NAME } from "./server.js";
+export { serveLcpStdio } from "./stdio.js";
+export { serverVersion } from "./version.js";
+export { legalContextUrl, WELL_KNOWN_PATH } from "./well-known.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,KAAK,SAAS,GACf,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,eAAe,EACf,aAAa,EACb,cAAc,GACf,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACxE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export { readOnlyToolAnnotations, } from "./annotations.js";
+export { manifestSummary, refusalResult, resolveAdapter, } from "./dispatch.js";
+export { isoNow, nodePorts, REVERSE_DOMAIN_ENV } from "./node-ports.js";
+export { createLcpMcpServer, LCP_TOOL_NAMES, SERVER_NAME } from "./server.js";
+export { serveLcpStdio } from "./stdio.js";
+export { serverVersion } from "./version.js";
+export { legalContextUrl, WELL_KNOWN_PATH } from "./well-known.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,GAExB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,eAAe,EACf,aAAa,EACb,cAAc,GACf,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAExE,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/node-ports.d.ts

@@ -0,0 +1,21 @@
+import type { LcpMcpPorts } from "./ports.js";
+/** The environment variable a deployment states its own reverse-domain namespace in. */
+export declare const REVERSE_DOMAIN_ENV = "LCP_MCP_REVERSE_DOMAIN";
+/** The wall clock as an ISO-8601 instant — the `now` port the terms fetcher requires. */
+export declare function isoNow(): string;
+/**
+ * The Node wiring: the real, guarded terms fetcher plus whatever the environment states.
+ *
+ * The fetcher is `agent-guard`'s — HTTPS-only, `redirect: "error"`, every resolved address checked public
+ * unicast on every network fetch, body capped while streaming, LCP §2.6 cache discipline. This server
+ * fetches URLs a COUNTERPARTY chose, so that is not hardening, it is the minimum: bare `fetch` here would
+ * turn `lcp_verify_before_pay` into an SSRF primitive an agent can be talked into aiming anywhere.
+ *
+ * `LCP_MCP_REVERSE_DOMAIN` is absent by default and stays absent. It is only needed by placements whose
+ * carrier is namespaced under the deployment's own domain (Mastercard VI's custom Layer-2 constraint type),
+ * and LCP §8 canonizes no per-protocol integration profile — so a default here would write Integra's domain
+ * into someone else's signed document in every deployment that forgot to set it. Unset, that one placement
+ * throws and names what is missing; every other tool is unaffected.
+ */
+export declare function nodePorts(env: Readonly<Record<string, string | undefined>>): LcpMcpPorts;
+//# sourceMappingURL=node-ports.d.ts.map

package/dist/node-ports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-ports.d.ts","sourceRoot":"","sources":["../src/node-ports.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,wFAAwF;AACxF,eAAO,MAAM,kBAAkB,2BAA2B,CAAC;AAE3D,yFAAyF;AACzF,wBAAgB,MAAM,IAAI,MAAM,CAE/B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CACvB,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,GAChD,WAAW,CAUb"}

package/dist/node-ports.js

@@ -0,0 +1,33 @@
+import { makeCachingFetcher, nodeDnsLookup } from "@integraledger/agent-guard";
+/** The environment variable a deployment states its own reverse-domain namespace in. */
+export const REVERSE_DOMAIN_ENV = "LCP_MCP_REVERSE_DOMAIN";
+/** The wall clock as an ISO-8601 instant — the `now` port the terms fetcher requires. */
+export function isoNow() {
+    return new Date().toISOString();
+}
+/**
+ * The Node wiring: the real, guarded terms fetcher plus whatever the environment states.
+ *
+ * The fetcher is `agent-guard`'s — HTTPS-only, `redirect: "error"`, every resolved address checked public
+ * unicast on every network fetch, body capped while streaming, LCP §2.6 cache discipline. This server
+ * fetches URLs a COUNTERPARTY chose, so that is not hardening, it is the minimum: bare `fetch` here would
+ * turn `lcp_verify_before_pay` into an SSRF primitive an agent can be talked into aiming anywhere.
+ *
+ * `LCP_MCP_REVERSE_DOMAIN` is absent by default and stays absent. It is only needed by placements whose
+ * carrier is namespaced under the deployment's own domain (Mastercard VI's custom Layer-2 constraint type),
+ * and LCP §8 canonizes no per-protocol integration profile — so a default here would write Integra's domain
+ * into someone else's signed document in every deployment that forgot to set it. Unset, that one placement
+ * throws and names what is missing; every other tool is unaffected.
+ */
+export function nodePorts(env) {
+    const reverseDomain = env[REVERSE_DOMAIN_ENV];
+    return {
+        fetcher: makeCachingFetcher({
+            httpFetch: fetch,
+            now: isoNow,
+            lookup: nodeDnsLookup,
+        }),
+        ...(reverseDomain !== undefined ? { deployment: { reverseDomain } } : {}),
+    };
+}
+//# sourceMappingURL=node-ports.js.map

package/dist/node-ports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-ports.js","sourceRoot":"","sources":["../src/node-ports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG/E,wFAAwF;AACxF,MAAM,CAAC,MAAM,kBAAkB,GAAG,wBAAwB,CAAC;AAE3D,yFAAyF;AACzF,MAAM,UAAU,MAAM;IACpB,OAAO,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;AAClC,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,SAAS,CACvB,GAAiD;IAEjD,MAAM,aAAa,GAAG,GAAG,CAAC,kBAAkB,CAAC,CAAC;IAC9C,OAAO;QACL,OAAO,EAAE,kBAAkB,CAAC;YAC1B,SAAS,EAAE,KAAK;YAChB,GAAG,EAAE,MAAM;YACX,MAAM,EAAE,aAAa;SACtB,CAAC;QACF,GAAG,CAAC,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,EAAE,aAAa,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC1E,CAAC;AACJ,CAAC"}

package/dist/ports.d.ts

@@ -0,0 +1,23 @@
+import type { TermsFetcher } from "@integraledger/agent-guard";
+import type { PlacementDeployment } from "@integraledger/lcp-placements";
+/**
+ * What a deployment supplies before this server can serve anything.
+ *
+ * NO DEFAULTS, and both entries are the reason. The fetcher is the buyer gate's own HTTPS-only,
+ * SSRF-guarded, size-capped, LCP §2.6-cached implementation (`agent-guard`'s `makeCachingFetcher`) — the
+ * URLs this server fetches are chosen by a *counterparty*, so a server that quietly defaulted to bare
+ * `fetch` would silently drop the guard that makes those fetches safe. `nodePorts` wires the real one for a
+ * Node deployment; a Workers deployment supplies its own `lookup`.
+ *
+ * `deployment` is genuinely optional rather than defaulted: eight of the nine registered placements are
+ * singletons needing nothing from it, and only Mastercard VI's namespaced factory requires a reverse domain.
+ * Omitting it makes `lcp_place_reference` throw for that ONE protocol, naming what is missing — which is the
+ * registry's own rule, not a second copy of it here.
+ */
+export interface LcpMcpPorts {
+    /** Fetches terms and discovery documents. See `@integraledger/agent-guard`'s `makeCachingFetcher`. */
+    readonly fetcher: TermsFetcher;
+    /** The deployment's own reverse-domain namespace, for namespaced placement registrations. */
+    readonly deployment?: PlacementDeployment;
+}
+//# sourceMappingURL=ports.d.ts.map

package/dist/ports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../src/ports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAEzE;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,WAAW;IAC1B,sGAAsG;IACtG,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,6FAA6F;IAC7F,QAAQ,CAAC,UAAU,CAAC,EAAE,mBAAmB,CAAC;CAC3C"}

package/dist/ports.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ports.js.map

package/dist/ports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ports.js","sourceRoot":"","sources":["../src/ports.ts"],"names":[],"mappings":""}

package/dist/server.d.ts

@@ -0,0 +1,45 @@
+import { McpServer } from "@modelcontextprotocol/server";
+import type { LcpMcpPorts } from "./ports.js";
+/**
+ * The MCP server name, and the reason it is not the one the specification illustrates.
+ *
+ * LCP v1.38 §C.9 shows a different tool vocabulary (`get_legal_context`, `verify_terms`, …) and says in the
+ * same breath that "the standard does not canonize a particular tool registry" and that the MCP stewards
+ * are invited to publish canonical names. An appendix example is not an interoperability fact: names an
+ * agent host has already learned are, because a host that has learned a name breaks when it changes.
+ * Renaming these to match an illustration the specification itself declines to canonize would break working
+ * integrations and make nothing canonical in exchange.
+ */
+export declare const SERVER_NAME = "lcp-mcp";
+/**
+ * Every tool this server exposes, in registration order.
+ *
+ * Exported so the boundary can be ASSERTED rather than described. LCP §C.9's illustrative table also lists
+ * `accept_terms`, `create_agreement`, `get_agreement`, `initiate_dispute` and `get_dispute_status`; none of
+ * them is here and none is coming. Recording an acceptance, holding the agreement record, or running the
+ * dispute are the roles of a custodian and a forum — we are neither. Integra is the record engine; the
+ * custodian of the record and the forum for the dispute are the deployment's and the counterparties' own.
+ * A server that offered `initiate_dispute` would be asserting an operating role the mandate forbids, and it
+ * is far easier to not add a seventh tool than to remove it after an agent has learned to call it.
+ */
+export declare const LCP_TOOL_NAMES: readonly ["lcp_compute_atrhash", "lcp_generate_legal_context", "lcp_verify_before_pay", "lcp_scaffold_integration", "lcp_place_reference", "lcp_extract_reference"];
+/**
+ * Build the LCP MCP server.
+ *
+ * A FACTORY, not a singleton, because that is what the transports want: `serveStdio` and
+ * `createMcpHandler` both take a factory and may build one instance per connection or per era. Handing
+ * them a shared instance would make one client's state another's.
+ *
+ * The server ends up declaring `tools` and nothing else, and it declares it by REGISTERING tools rather
+ * than by asserting a capability in the constructor. MCP requires a server that supports tools to declare
+ * the capability and does not permit declaring one that is not served; the SDK derives the declaration from
+ * the registrations, so a constructor-side `{ capabilities: { tools: {} } }` is a second statement of the
+ * same fact that cannot be wrong today and could be wrong tomorrow. Measured: removing it changes nothing a
+ * client sees, which is exactly why it does not belong.
+ *
+ * There are no resources and no prompts. §C.9 illustrates both — `lcp://agreement/{id}`,
+ * `dispute_evidence_assembly` — and every one of its examples is an agreement or dispute surface, which is
+ * the boundary above. When there is a resource to serve that is not one of those, it is declared then.
+ */
+export declare function createLcpMcpServer(ports: LcpMcpPorts): McpServer;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAS9C;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,YAAY,CAAC;AAErC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,YACzB,qBAAqB,EACrB,4BAA4B,EAC5B,uBAAuB,EACvB,0BAA0B,EAC1B,qBAAqB,EACrB,uBAAuB,CACf,CAAC;AAEX;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,CAShE"}

package/dist/server.js

@@ -0,0 +1,67 @@
+import { McpServer } from "@modelcontextprotocol/server";
+import { registerComputeAtrHash } from "./tools/compute-atrhash.js";
+import { registerExtractReference } from "./tools/extract-reference.js";
+import { registerGenerateLegalContext } from "./tools/generate-legal-context.js";
+import { registerPlaceReference } from "./tools/place-reference.js";
+import { registerScaffoldIntegration } from "./tools/scaffold-integration.js";
+import { registerVerifyBeforePay } from "./tools/verify-before-pay.js";
+import { serverVersion } from "./version.js";
+/**
+ * The MCP server name, and the reason it is not the one the specification illustrates.
+ *
+ * LCP v1.38 §C.9 shows a different tool vocabulary (`get_legal_context`, `verify_terms`, …) and says in the
+ * same breath that "the standard does not canonize a particular tool registry" and that the MCP stewards
+ * are invited to publish canonical names. An appendix example is not an interoperability fact: names an
+ * agent host has already learned are, because a host that has learned a name breaks when it changes.
+ * Renaming these to match an illustration the specification itself declines to canonize would break working
+ * integrations and make nothing canonical in exchange.
+ */
+export const SERVER_NAME = "lcp-mcp";
+/**
+ * Every tool this server exposes, in registration order.
+ *
+ * Exported so the boundary can be ASSERTED rather than described. LCP §C.9's illustrative table also lists
+ * `accept_terms`, `create_agreement`, `get_agreement`, `initiate_dispute` and `get_dispute_status`; none of
+ * them is here and none is coming. Recording an acceptance, holding the agreement record, or running the
+ * dispute are the roles of a custodian and a forum — we are neither. Integra is the record engine; the
+ * custodian of the record and the forum for the dispute are the deployment's and the counterparties' own.
+ * A server that offered `initiate_dispute` would be asserting an operating role the mandate forbids, and it
+ * is far easier to not add a seventh tool than to remove it after an agent has learned to call it.
+ */
+export const LCP_TOOL_NAMES = [
+    "lcp_compute_atrhash",
+    "lcp_generate_legal_context",
+    "lcp_verify_before_pay",
+    "lcp_scaffold_integration",
+    "lcp_place_reference",
+    "lcp_extract_reference",
+];
+/**
+ * Build the LCP MCP server.
+ *
+ * A FACTORY, not a singleton, because that is what the transports want: `serveStdio` and
+ * `createMcpHandler` both take a factory and may build one instance per connection or per era. Handing
+ * them a shared instance would make one client's state another's.
+ *
+ * The server ends up declaring `tools` and nothing else, and it declares it by REGISTERING tools rather
+ * than by asserting a capability in the constructor. MCP requires a server that supports tools to declare
+ * the capability and does not permit declaring one that is not served; the SDK derives the declaration from
+ * the registrations, so a constructor-side `{ capabilities: { tools: {} } }` is a second statement of the
+ * same fact that cannot be wrong today and could be wrong tomorrow. Measured: removing it changes nothing a
+ * client sees, which is exactly why it does not belong.
+ *
+ * There are no resources and no prompts. §C.9 illustrates both — `lcp://agreement/{id}`,
+ * `dispute_evidence_assembly` — and every one of its examples is an agreement or dispute surface, which is
+ * the boundary above. When there is a resource to serve that is not one of those, it is declared then.
+ */
+export function createLcpMcpServer(ports) {
+    const server = new McpServer({ name: SERVER_NAME, version: serverVersion() });
+    registerComputeAtrHash(server, ports);
+    registerGenerateLegalContext(server, ports);
+    registerVerifyBeforePay(server, ports);
+    registerScaffoldIntegration(server);
+    registerPlaceReference(server, ports);
+    registerExtractReference(server, ports);
+    return server;
+}
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAEzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAC;AACjF,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAE7C;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,SAAS,CAAC;AAErC;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,qBAAqB;IACrB,4BAA4B;IAC5B,uBAAuB;IACvB,0BAA0B;IAC1B,qBAAqB;IACrB,uBAAuB;CACf,CAAC;AAEX;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAkB;IACnD,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,EAAE,EAAE,CAAC,CAAC;IAC9E,sBAAsB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACtC,4BAA4B,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC5C,uBAAuB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACvC,2BAA2B,CAAC,MAAM,CAAC,CAAC;IACpC,sBAAsB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACtC,wBAAwB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACxC,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/stdio.d.ts

@@ -0,0 +1,15 @@
+import { type ServeStdioOptions, type StdioServerHandle } from "@modelcontextprotocol/server/stdio";
+import type { LcpMcpPorts } from "./ports.js";
+/**
+ * Serve this server over stdio — the transport every desktop agent host speaks.
+ *
+ * `serveStdio` rather than a hand-wired `StdioServerTransport`: the MCP v2 entry owns the era decision for
+ * the connection, pinning ONE instance from the factory for its lifetime, so a 2025-era client and a
+ * 2026-07-28 client are both served correctly from the same registration. Hand-wiring a single transport
+ * would serve only one of them, and which one would depend on the SDK version rather than on the client.
+ *
+ * `options` is passed straight through — a test drives a linked in-memory transport through it, and a
+ * deployment that binds stdio to a socket per MCP's custom-transport guidance uses the same door.
+ */
+export declare function serveLcpStdio(ports: LcpMcpPorts, options?: ServeStdioOptions): StdioServerHandle;
+//# sourceMappingURL=stdio.d.ts.map

package/dist/stdio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../src/stdio.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EAEvB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAG9C;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,WAAW,EAClB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,iBAAiB,CAEnB"}

package/dist/stdio.js

@@ -0,0 +1,17 @@
+import { serveStdio, } from "@modelcontextprotocol/server/stdio";
+import { createLcpMcpServer } from "./server.js";
+/**
+ * Serve this server over stdio — the transport every desktop agent host speaks.
+ *
+ * `serveStdio` rather than a hand-wired `StdioServerTransport`: the MCP v2 entry owns the era decision for
+ * the connection, pinning ONE instance from the factory for its lifetime, so a 2025-era client and a
+ * 2026-07-28 client are both served correctly from the same registration. Hand-wiring a single transport
+ * would serve only one of them, and which one would depend on the SDK version rather than on the client.
+ *
+ * `options` is passed straight through — a test drives a linked in-memory transport through it, and a
+ * deployment that binds stdio to a socket per MCP's custom-transport guidance uses the same door.
+ */
+export function serveLcpStdio(ports, options) {
+    return serveStdio(() => createLcpMcpServer(ports), options);
+}
+//# sourceMappingURL=stdio.js.map

package/dist/stdio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.js","sourceRoot":"","sources":["../src/stdio.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,UAAU,GACX,MAAM,oCAAoC,CAAC;AAE5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEjD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,aAAa,CAC3B,KAAkB,EAClB,OAA2B;IAE3B,OAAO,UAAU,CAAC,GAAG,EAAE,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC;AAC9D,CAAC"}

package/dist/tools/compute-atrhash.d.ts

@@ -0,0 +1,15 @@
+import type { McpServer } from "@modelcontextprotocol/server";
+import type { LcpMcpPorts } from "../ports.js";
+/**
+ * `lcp_compute_atrhash` — the ATR fingerprint of a terms document, from inline text or a fetchable URL.
+ *
+ * Grounded on `kernel.hashAtr` (the one implementation of the ATR fingerprint) and
+ * `binding-core.encodeLegalContextString` (the one implementation of the §8.1 carrier), rather than on a
+ * local `createHash("sha256")` and a template literal. The carrier string it returns is the exact input
+ * `lcp_place_reference` takes, so compute → place composes without the agent reformatting anything.
+ *
+ * EXACTLY ONE of `terms`/`termsUrl`. Neither is a caller who has not said what to hash; both is a caller
+ * whose two inputs may disagree, and picking one would silently hash something the caller did not mean.
+ */
+export declare function registerComputeAtrHash(server: McpServer, ports: LcpMcpPorts): void;
+//# sourceMappingURL=compute-atrhash.d.ts.map

package/dist/tools/compute-atrhash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-atrhash.d.ts","sourceRoot":"","sources":["../../src/tools/compute-atrhash.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAG9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAyB/C;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,WAAW,GACjB,IAAI,CA0CN"}

package/dist/tools/compute-atrhash.js

@@ -0,0 +1,66 @@
+import { encodeLegalContextString } from "@integraledger/lcp-binding-core";
+import { hashAtr } from "@integraledger/lcp-kernel";
+import { z } from "zod";
+import { readOnlyToolAnnotations } from "../annotations.js";
+const inputSchema = z.object({
+    terms: z
+        .string()
+        .optional()
+        .describe("Raw terms text to hash, as UTF-8 bytes. Provide this OR termsUrl, never both."),
+    termsUrl: z
+        .url()
+        .optional()
+        .describe("HTTPS URL of the terms document to fetch and hash. Provide this OR terms, never both."),
+});
+const outputSchema = z.object({
+    atrHash: z.string().describe("0x-prefixed SHA-256 of the terms bytes."),
+    bytes: z.number().int().describe("How many bytes were hashed."),
+    reference: z
+        .string()
+        .describe("The LCP §8.1 carrier string, `lcp:sha256:0x…`."),
+});
+/**
+ * `lcp_compute_atrhash` — the ATR fingerprint of a terms document, from inline text or a fetchable URL.
+ *
+ * Grounded on `kernel.hashAtr` (the one implementation of the ATR fingerprint) and
+ * `binding-core.encodeLegalContextString` (the one implementation of the §8.1 carrier), rather than on a
+ * local `createHash("sha256")` and a template literal. The carrier string it returns is the exact input
+ * `lcp_place_reference` takes, so compute → place composes without the agent reformatting anything.
+ *
+ * EXACTLY ONE of `terms`/`termsUrl`. Neither is a caller who has not said what to hash; both is a caller
+ * whose two inputs may disagree, and picking one would silently hash something the caller did not mean.
+ */
+export function registerComputeAtrHash(server, ports) {
+    server.registerTool("lcp_compute_atrhash", {
+        description: "Compute the LCP ATR hash — the SHA-256 over the exact terms bytes — from inline `terms` text " +
+            "or a fetchable `termsUrl`. Returns `{ atrHash, bytes, reference }`, where `reference` is the " +
+            "canonical `lcp:sha256:0x…` carrier string. A `termsUrl` is fetched over HTTPS only, is not " +
+            "followed through redirects, and is size-capped.",
+        inputSchema,
+        outputSchema,
+        annotations: readOnlyToolAnnotations("Compute LCP ATR hash", "network"),
+    }, async (args) => {
+        if (args.terms !== undefined && args.termsUrl !== undefined)
+            throw new Error("provide exactly one of `terms` or `termsUrl` — both were supplied, and they may disagree");
+        let bytes;
+        if (args.termsUrl !== undefined)
+            bytes = (await ports.fetcher.fetch(args.termsUrl)).bytes;
+        else if (args.terms !== undefined)
+            bytes = new TextEncoder().encode(args.terms);
+        else
+            throw new Error("provide exactly one of `terms` or `termsUrl` — neither was supplied");
+        const atrHash = await hashAtr(bytes);
+        const out = {
+            atrHash,
+            bytes: bytes.byteLength,
+            reference: encodeLegalContextString({ type: "sha256", value: atrHash }),
+        };
+        return {
+            content: [
+                { type: "text", text: JSON.stringify(out, null, 2) },
+            ],
+            structuredContent: out,
+        };
+    });
+}
+//# sourceMappingURL=compute-atrhash.js.map

package/dist/tools/compute-atrhash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute-atrhash.js","sourceRoot":"","sources":["../../src/tools/compute-atrhash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAEpD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAG5D,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3B,KAAK,EAAE,CAAC;SACL,MAAM,EAAE;SACR,QAAQ,EAAE;SACV,QAAQ,CACP,+EAA+E,CAChF;IACH,QAAQ,EAAE,CAAC;SACR,GAAG,EAAE;SACL,QAAQ,EAAE;SACV,QAAQ,CACP,uFAAuF,CACxF;CACJ,CAAC,CAAC;AAEH,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5B,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,yCAAyC,CAAC;IACvE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,6BAA6B,CAAC;IAC/D,SAAS,EAAE,CAAC;SACT,MAAM,EAAE;SACR,QAAQ,CAAC,gDAAgD,CAAC;CAC9D,CAAC,CAAC;AAEH;;;;;;;;;;GAUG;AACH,MAAM,UAAU,sBAAsB,CACpC,MAAiB,EACjB,KAAkB;IAElB,MAAM,CAAC,YAAY,CACjB,qBAAqB,EACrB;QACE,WAAW,EACT,+FAA+F;YAC/F,+FAA+F;YAC/F,6FAA6F;YAC7F,iDAAiD;QACnD,WAAW;QACX,YAAY;QACZ,WAAW,EAAE,uBAAuB,CAAC,sBAAsB,EAAE,SAAS,CAAC;KACxE,EACD,KAAK,EAAE,IAAI,EAAE,EAAE;QACb,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS;YACzD,MAAM,IAAI,KAAK,CACb,0FAA0F,CAC3F,CAAC;QACJ,IAAI,KAAiB,CAAC;QACtB,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS;YAC7B,KAAK,GAAG,CAAC,MAAM,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC;aACtD,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS;YAC/B,KAAK,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;;YAE7C,MAAM,IAAI,KAAK,CACb,qEAAqE,CACtE,CAAC;QAEJ,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC;QACrC,MAAM,GAAG,GAAG;YACV,OAAO;YACP,KAAK,EAAE,KAAK,CAAC,UAAU;YACvB,SAAS,EAAE,wBAAwB,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;SACxE,CAAC;QACF,OAAO;YACL,OAAO,EAAE;gBACP,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE;aAC9D;YACD,iBAAiB,EAAE,GAAG;SACvB,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/tools/extract-reference.d.ts

@@ -0,0 +1,19 @@
+import type { McpServer } from "@modelcontextprotocol/server";
+import type { LcpMcpPorts } from "../ports.js";
+/**
+ * `lcp_extract_reference` — recover an LCP reference from a commerce protocol's own document.
+ *
+ * The read half of `lcp_place_reference`, through the same placement registry, so a document one produces the
+ * other reads. It is what lets an agent on the receiving side of a counterparty's ACP session, x402
+ * challenge or A2A task ask "which terms does this document say govern it?" without knowing where that
+ * protocol keeps them.
+ *
+ * A DOCUMENT WITH NO REFERENCE REFUSES; it never returns a placeholder. That refusal is the answer — the
+ * counterparty placed nothing — and an empty string or a null would read as a reference to nothing.
+ *
+ * The adapter reads the manifest's declared field AND its declared aliases, so a counterparty using a
+ * spelling the manifest records as accepted is read rather than refused. Which spellings those are is the
+ * manifest's data, not this tool's opinion.
+ */
+export declare function registerExtractReference(server: McpServer, ports: LcpMcpPorts): void;
+//# sourceMappingURL=extract-reference.d.ts.map

package/dist/tools/extract-reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-reference.d.ts","sourceRoot":"","sources":["../../src/tools/extract-reference.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAS9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAsB/C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,WAAW,GACjB,IAAI,CAkCN"}

package/dist/tools/extract-reference.js

@@ -0,0 +1,65 @@
+import { encodeLegalContextString } from "@integraledger/lcp-binding-core";
+import { supportedProtocols } from "@integraledger/lcp-placements";
+import { z } from "zod";
+import { readOnlyToolAnnotations } from "../annotations.js";
+import { manifestSummary, PLACEMENT_SUMMARY_SCHEMA, refusalResult, resolveAdapter, } from "../dispatch.js";
+const inputSchema = z.object({
+    protocol: z
+        .string()
+        .describe("The commerce protocol this document belongs to. See the description for the set this build reads."),
+    document: z
+        .record(z.string(), z.unknown())
+        .describe("The host protocol's own document, as JSON."),
+});
+const outputSchema = z.object({
+    reference: z
+        .string()
+        .describe("The LCP §8.1 carrier string recovered from the document."),
+    type: z.string().describe("The §8.2 carrier type, e.g. `sha256`."),
+    value: z.string().describe("The carrier value, e.g. the 0x ATR hash."),
+    placement: PLACEMENT_SUMMARY_SCHEMA,
+});
+/**
+ * `lcp_extract_reference` — recover an LCP reference from a commerce protocol's own document.
+ *
+ * The read half of `lcp_place_reference`, through the same placement registry, so a document one produces the
+ * other reads. It is what lets an agent on the receiving side of a counterparty's ACP session, x402
+ * challenge or A2A task ask "which terms does this document say govern it?" without knowing where that
+ * protocol keeps them.
+ *
+ * A DOCUMENT WITH NO REFERENCE REFUSES; it never returns a placeholder. That refusal is the answer — the
+ * counterparty placed nothing — and an empty string or a null would read as a reference to nothing.
+ *
+ * The adapter reads the manifest's declared field AND its declared aliases, so a counterparty using a
+ * spelling the manifest records as accepted is read rather than refused. Which spellings those are is the
+ * manifest's data, not this tool's opinion.
+ */
+export function registerExtractReference(server, ports) {
+    server.registerTool("lcp_extract_reference", {
+        description: "Recover the LCP legal-context reference from a commerce protocol's own document, reading the " +
+            "field that protocol's placement manifest declares. Supported protocols in this build: " +
+            `${supportedProtocols().join(", ")}. Returns the \`lcp:{type}:{value}\` carrier string and where ` +
+            "it was found. A document carrying no reference is refused, not answered with an empty value.",
+        inputSchema,
+        outputSchema,
+        annotations: readOnlyToolAnnotations("Extract an LCP reference", "closed"),
+    }, (args) => {
+        const adapter = resolveAdapter(args.protocol, ports);
+        const outcome = adapter.extract(args.document);
+        if (!("ok" in outcome))
+            return refusalResult(outcome);
+        const out = {
+            reference: encodeLegalContextString(outcome.value),
+            type: outcome.value.type,
+            value: outcome.value.value,
+            placement: manifestSummary(adapter.manifest),
+        };
+        return {
+            content: [
+                { type: "text", text: JSON.stringify(out, null, 2) },
+            ],
+            structuredContent: out,
+        };
+    });
+}
+//# sourceMappingURL=extract-reference.js.map

package/dist/tools/extract-reference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-reference.js","sourceRoot":"","sources":["../../src/tools/extract-reference.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EACL,eAAe,EACf,wBAAwB,EACxB,aAAa,EACb,cAAc,GACf,MAAM,gBAAgB,CAAC;AAGxB,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3B,QAAQ,EAAE,CAAC;SACR,MAAM,EAAE;SACR,QAAQ,CACP,mGAAmG,CACpG;IACH,QAAQ,EAAE,CAAC;SACR,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;SAC/B,QAAQ,CAAC,4CAA4C,CAAC;CAC1D,CAAC,CAAC;AAEH,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5B,SAAS,EAAE,CAAC;SACT,MAAM,EAAE;SACR,QAAQ,CAAC,0DAA0D,CAAC;IACvE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,uCAAuC,CAAC;IAClE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,0CAA0C,CAAC;IACtE,SAAS,EAAE,wBAAwB;CACpC,CAAC,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,wBAAwB,CACtC,MAAiB,EACjB,KAAkB;IAElB,MAAM,CAAC,YAAY,CACjB,uBAAuB,EACvB;QACE,WAAW,EACT,+FAA+F;YAC/F,wFAAwF;YACxF,GAAG,kBAAkB,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,gEAAgE;YAClG,8FAA8F;QAChG,WAAW;QACX,YAAY;QACZ,WAAW,EAAE,uBAAuB,CAClC,0BAA0B,EAC1B,QAAQ,CACT;KACF,EACD,CAAC,IAAI,EAAE,EAAE;QACP,MAAM,OAAO,GAAG,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QACrD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC/C,IAAI,CAAC,CAAC,IAAI,IAAI,OAAO,CAAC;YAAE,OAAO,aAAa,CAAC,OAAO,CAAC,CAAC;QACtD,MAAM,GAAG,GAAG;YACV,SAAS,EAAE,wBAAwB,CAAC,OAAO,CAAC,KAAK,CAAC;YAClD,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,IAAI;YACxB,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK;YAC1B,SAAS,EAAE,eAAe,CAAC,OAAO,CAAC,QAAQ,CAAC;SAC7C,CAAC;QACF,OAAO;YACL,OAAO,EAAE;gBACP,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE;aAC9D;YACD,iBAAiB,EAAE,GAAG;SACvB,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/tools/generate-legal-context.d.ts

@@ -0,0 +1,20 @@
+import type { McpServer } from "@modelcontextprotocol/server";
+import type { LcpMcpPorts } from "../ports.js";
+/**
+ * `lcp_generate_legal_context` — build a ready-to-publish `/.well-known/legal-context.json`.
+ *
+ * Grounded on `discovery.emit`, which drops undefined fields and then VALIDATES what is left, so a profile
+ * this tool cannot legally emit fails loudly here rather than 404-ing an agent later. The `atrHash` is
+ * `kernel.hashAtr` over the bytes actually served at `termsUrl` — never a value the caller supplies, because
+ * a hash the author asserts rather than computes is the one field an author can get wrong and never notice.
+ *
+ * `termsFormat` is checked against `discovery.KNOWN_TERMS_FORMATS` rather than re-declared as an enum here:
+ * the token set is the protocol's, and a second copy in this package would be free to drift from it. The
+ * free-string `termsFormat` invites values like `text/plain` and `application/pdf`,
+ * neither of which is an LCP §2.5 token.
+ *
+ * IT RETURNS THE DOCUMENT; IT DOES NOT PUBLISH ONE. Serving it is the deployment's act, on the deployment's
+ * origin, under the deployment's name.
+ */
+export declare function registerGenerateLegalContext(server: McpServer, ports: LcpMcpPorts): void;
+//# sourceMappingURL=generate-legal-context.d.ts.map

package/dist/tools/generate-legal-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-legal-context.d.ts","sourceRoot":"","sources":["../../src/tools/generate-legal-context.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAG9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAsD/C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,WAAW,GACjB,IAAI,CA2CN"}

package/dist/tools/generate-legal-context.js

@@ -0,0 +1,99 @@
+import { emit, isKnownTermsFormat, KNOWN_TERMS_FORMATS, } from "@integraledger/lcp-discovery";
+import { hashAtr } from "@integraledger/lcp-kernel";
+import { z } from "zod";
+import { readOnlyToolAnnotations } from "../annotations.js";
+const inputSchema = z.object({
+    termsUrl: z
+        .url()
+        .describe("HTTPS URL of the terms document. Fetched, so it must be live."),
+    termsFormat: z
+        .string()
+        .describe(`The LCP §2.5 format token for the terms document — one of: ${KNOWN_TERMS_FORMATS.join(", ")}.`),
+    acceptanceRequired: z
+        .boolean()
+        .optional()
+        .describe("Set true where the service requires explicit signed acceptance before transacting (LCP §3, Level 3)."),
+    disputeResolution: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe("The service's dispute-resolution metadata (LCP §3, Level 4), e.g. { method, jurisdiction }."),
+    returns: z.string().optional().describe("URL of the returns policy."),
+    api: z
+        .url()
+        .optional()
+        .describe("Entry point to richer legal functionality (LCP §3, Level 4)."),
+});
+const outputSchema = z.object({
+    terms: z.string().describe("The terms document URL, echoed from the input."),
+    termsFormat: z.string().describe("The LCP §2.5 format token."),
+    atrHash: z
+        .string()
+        .describe("SHA-256 over the bytes served at `terms`, computed here."),
+    acceptanceRequired: z
+        .boolean()
+        .optional()
+        .describe("Present only where the input declared it."),
+    disputeResolution: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe("Present only where the input declared it."),
+    returns: z
+        .string()
+        .optional()
+        .describe("Present only where the input declared it."),
+    api: z
+        .string()
+        .optional()
+        .describe("Present only where the input declared it."),
+});
+/**
+ * `lcp_generate_legal_context` — build a ready-to-publish `/.well-known/legal-context.json`.
+ *
+ * Grounded on `discovery.emit`, which drops undefined fields and then VALIDATES what is left, so a profile
+ * this tool cannot legally emit fails loudly here rather than 404-ing an agent later. The `atrHash` is
+ * `kernel.hashAtr` over the bytes actually served at `termsUrl` — never a value the caller supplies, because
+ * a hash the author asserts rather than computes is the one field an author can get wrong and never notice.
+ *
+ * `termsFormat` is checked against `discovery.KNOWN_TERMS_FORMATS` rather than re-declared as an enum here:
+ * the token set is the protocol's, and a second copy in this package would be free to drift from it. The
+ * free-string `termsFormat` invites values like `text/plain` and `application/pdf`,
+ * neither of which is an LCP §2.5 token.
+ *
+ * IT RETURNS THE DOCUMENT; IT DOES NOT PUBLISH ONE. Serving it is the deployment's act, on the deployment's
+ * origin, under the deployment's name.
+ */
+export function registerGenerateLegalContext(server, ports) {
+    server.registerTool("lcp_generate_legal_context", {
+        description: "Build a ready-to-publish `/.well-known/legal-context.json` document. Fetches `termsUrl`, " +
+            "computes the ATR hash over the served bytes, validates the result against the LCP discovery " +
+            "schema, and returns the document to serve. It does not publish anything.",
+        inputSchema,
+        outputSchema,
+        annotations: readOnlyToolAnnotations("Generate LCP legal-context.json", "network"),
+    }, async (args) => {
+        if (!isKnownTermsFormat(args.termsFormat))
+            throw new Error(`termsFormat "${args.termsFormat}" is not an LCP §2.5 token — expected one of: ${KNOWN_TERMS_FORMATS.join(", ")}`);
+        const bytes = (await ports.fetcher.fetch(args.termsUrl)).bytes;
+        const profile = {
+            terms: args.termsUrl,
+            termsFormat: args.termsFormat,
+            atrHash: await hashAtr(bytes),
+            ...(args.acceptanceRequired !== undefined
+                ? { acceptanceRequired: args.acceptanceRequired }
+                : {}),
+            ...(args.disputeResolution !== undefined
+                ? { disputeResolution: args.disputeResolution }
+                : {}),
+            ...(args.returns !== undefined ? { returns: args.returns } : {}),
+            ...(args.api !== undefined ? { api: args.api } : {}),
+        };
+        const doc = emit(profile);
+        return {
+            content: [
+                { type: "text", text: JSON.stringify(doc, null, 2) },
+            ],
+            structuredContent: doc,
+        };
+    });
+}
+//# sourceMappingURL=generate-legal-context.js.map

package/dist/tools/generate-legal-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-legal-context.js","sourceRoot":"","sources":["../../src/tools/generate-legal-context.ts"],"names":[],"mappings":"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"}