@unbrained/pm-cli 2026.10.13 → 2026.10.15

package/dist/sdk/mcp/discovery.d.ts

@@ -1,147 +1,147 @@
-import { type PmCommandCapabilityFamily, type PmCommandVisibilityTier, type PmMcpToolProfile } from "../agent-capability-contracts.js";
+import { type PmCommandCapabilityFamily,type PmCommandVisibilityTier,type PmMcpToolProfile } from "../agent-capability-contracts.js";
 /** Namespaced MCP extension that opts a client into progressive tool discovery. */
 export declare const PM_MCP_PROGRESSIVE_DISCOVERY_EXTENSION = "dev.unbrained.pm/progressive-tool-discovery";
 /** Versioned server capability advertised for progressive tool discovery. */
-export declare const PM_MCP_PROGRESSIVE_DISCOVERY_SERVER_CAPABILITY: Readonly<{
-version: 1;
-discoveryTool: "pm_discover";
-canonicalResult: "structuredContent.result";
-compatibilityText: "pointer";
+export declare const PM_MCP_PROGRESSIVE_DISCOVERY_SERVER_CAPABILITY:Readonly<{
+version:1;
+discoveryTool:"pm_discover";
+canonicalResult:"structuredContent.result";
+compatibilityText:"pointer";
 }>;
 /** Small stable tool catalog returned to clients that negotiate the extension. */
-export declare const PM_MCP_ENTRY_TOOL_NAMES: readonly string[];
+export declare const PM_MCP_ENTRY_TOOL_NAMES:readonly string[];
 /** Ranking signals composed by the public discovery contract. */
 export type PmToolDiscoverySignalName = "lexical" | "semantic" | "graph" | "permission" | "freshness" | "usage";
 /** Optional host-owned signals supplied for one tool. */
 export interface PmToolDiscoverySignalInput {
 /** Semantic relevance normalized to the inclusive range zero through one. */
-semantic?: number;
+semantic?:number;
 /** Graph proximity normalized to the inclusive range zero through one. */
-graph?: number;
+graph?:number;
 /** Definition freshness normalized to the inclusive range zero through one. */
-freshness?: number;
+freshness?:number;
 /** Historical selection usefulness normalized to the inclusive range zero through one. */
-usage?: number;
+usage?:number;
 }
 /** One tool definition accepted by the SDK discovery engine. */
 export interface PmToolDiscoveryCandidate {
 /** Stable callable tool name. */
-name: string;
+name:string;
 /** Agent-facing tool description. */
-description: string;
+description:string;
 /** JSON Schema supplied when callers request schema expansion. */
-inputSchema: Record<string, unknown>;
+inputSchema:Record<string,unknown>;
 /** Whether the current caller is authorized to invoke the tool. */
-authorized?: boolean;
+authorized?:boolean;
 /** Optional host-owned ranking signals. */
-signals?: PmToolDiscoverySignalInput;
+signals?:PmToolDiscoverySignalInput;
 }
 /** Options controlling one progressive discovery page. */
 export interface PmToolDiscoveryOptions {
 /** Free-text capability intent. Empty text lists by deterministic policy order. */
-query?: string;
+query?:string;
 /** Restrict results to one stable capability family. */
-family?: PmCommandCapabilityFamily;
+family?:PmCommandCapabilityFamily;
 /** Restrict results to tools visible at or below this tier. */
-tier?: Exclude<PmCommandVisibilityTier, "internal">;
+tier?:Exclude<PmCommandVisibilityTier,"internal">;
 /** Maximum result rows, from one through one hundred. */
-limit?: number;
+limit?:number;
 /** Opaque continuation cursor from an equivalent discovery request. */
-cursor?: string;
+cursor?:string;
 /** Include complete input schemas instead of the default compact projection. */
-includeSchema?: boolean;
+includeSchema?:boolean;
 /** Estimated-token ceiling, or unbounded for the complete selected page. */
-outputBudget?: number | "unbounded";
+outputBudget?:number | "unbounded";
 /** MCP profile that produced the authorized candidate catalog. */
-profile?: PmMcpToolProfile;
+profile?:PmMcpToolProfile;
 /** Host-owned HMAC key of at least 32 bytes for restart-stable cursors. */
-cursorIntegrityKey?: Uint8Array;
+cursorIntegrityKey?:Uint8Array;
 }
 /** Applied score for one signal with explicit provenance. */
 export interface PmToolDiscoveryAppliedSignal {
 /** Normalized signal value. */
-value: number;
+value:number;
 /** Public policy weight. */
-weight: number;
+weight:number;
 /** Whether the signal was computed or supplied rather than defaulted. */
-available: boolean;
+available:boolean;
 /** Transparent source of the normalized value. */
-source: "computed" | "host" | "authorization" | "unavailable";
+source:"computed" | "host" | "authorization" | "unavailable";
 }
 /** One ranked discovery result. */
 export interface PmToolDiscoveryResultRow {
 /** Stable callable tool name. */
-name: string;
+name:string;
 /** Agent-facing description. */
-description: string;
+description:string;
 /** Canonical CLI command backing the tool. */
-command: string;
+command:string;
 /** Minimum visibility tier inherited from the command contract. */
-tier: PmCommandVisibilityTier;
+tier:PmCommandVisibilityTier;
 /** Stable capability family inherited from the command contract. */
-family: PmCommandCapabilityFamily;
+family:PmCommandCapabilityFamily;
 /** Weighted aggregate score used for ordering. */
-score: number;
+score:number;
 /** Complete per-signal score explanation. */
-signals: Readonly<Record<PmToolDiscoverySignalName, PmToolDiscoveryAppliedSignal>>;
+signals:Readonly<Record<PmToolDiscoverySignalName,PmToolDiscoveryAppliedSignal>>;
 /** Complete JSON Schema when explicitly requested. */
-input_schema?: Record<string, unknown>;
+input_schema?:Record<string,unknown>;
 }
 /** Explicit receipt for information omitted from a discovery page. */
 export interface PmToolDiscoveryOmissionReceipt {
 /** Whether any result rows or schemas were omitted. */
-has_omissions: boolean;
+has_omissions:boolean;
 /** Stable omitted field groups. */
-omitted: Array<{
-name: "input_schema" | "tools";
-reason: "compact_projection" | "limit" | "token_budget";
-restore_with: string;
+omitted:Array<{
+name:"input_schema" | "tools";
+reason:"compact_projection" | "limit" | "token_budget";
+restore_with:string;
 }>;
 }
 /** Deterministic progressive tool discovery response. */
 export interface PmToolDiscoveryResult {
 /** Stable result discriminator for model and host routing. */
-result_type: "pm_tool_discovery";
+result_type:"pm_tool_discovery";
 /** Public contract revision. */
-contract_version: 1;
+contract_version:1;
 /** Normalized query used by ranking and cursor binding. */
-query: string;
+query:string;
 /** MCP profile that produced the candidate catalog. */
-profile: PmMcpToolProfile;
+profile:PmMcpToolProfile;
 /** Ranked page of authorized tools. */
-tools: PmToolDiscoveryResultRow[];
+tools:PmToolDiscoveryResultRow[];
 /** Total authorized rows after filters and before pagination. */
-total: number;
+total:number;
 /** Rows returned on this page. */
-returned: number;
+returned:number;
 /** Whether a later ranked row remains. */
-has_more: boolean;
+has_more:boolean;
 /** Opaque continuation cursor bound to query, filters, and catalog. */
-next_cursor?: string;
+next_cursor?:string;
 /** Exact estimated serialized result cost. */
-token_cost: {
-estimated_tokens: number;
-budget: number | "unbounded";
-within_budget: boolean;
+token_cost:{
+estimated_tokens:number;
+budget:number | "unbounded";
+within_budget:boolean;
 };
 /** Public ranking formula and weights. */
-ranking_policy: {
-version: 1;
-formula: "weighted_sum_then_name";
-weights: Readonly<Record<PmToolDiscoverySignalName, number>>;
+ranking_policy:{
+version:1;
+formula:"weighted_sum_then_name";
+weights:Readonly<Record<PmToolDiscoverySignalName,number>>;
 };
 /** Cache identity and invalidation contract for deterministic pages. */
-cache: {
-key: string;
-ttl_ms: number;
-scope: "private";
-invalidates_on: readonly string[];
+cache:{
+key:string;
+ttl_ms:number;
+scope:"private";
+invalidates_on:readonly string[];
 };
 /** Explicit recovery for compacted fields and rows. */
-omission_receipt: PmToolDiscoveryOmissionReceipt;
+omission_receipt:PmToolDiscoveryOmissionReceipt;
 }
 /** Parse untrusted adapter input without discarding malformed discovery values. */
-export declare function parsePmToolDiscoveryOptions(input: Record<string, unknown>): PmToolDiscoveryOptions;
+export declare function parsePmToolDiscoveryOptions(input:Record<string,unknown>):PmToolDiscoveryOptions;
 /**
  * Rank and page an authorized MCP tool catalog under an explicit token budget.
  *
@@ -149,4 +149,4 @@ export declare function parsePmToolDiscoveryOptions(input: Record<string, unknow
  * catalog, or ranking inputs change. Host signals override documented local
  * fallbacks without changing the public formula or hiding signal provenance.
  */
-export declare function discoverPmTools(candidates: readonly PmToolDiscoveryCandidate[], options?: PmToolDiscoveryOptions): PmToolDiscoveryResult;
+export declare function discoverPmTools(candidates:readonly PmToolDiscoveryCandidate[],options?:PmToolDiscoveryOptions):PmToolDiscoveryResult;

package/dist/sdk/mcp/interactions.d.ts

@@ -1,32 +1,32 @@
-import { type PmMcpImplementation, type PmMcpRequestContext } from "./protocol.js";
+import { type PmMcpImplementation,type PmMcpRequestContext } from "./protocol.js";
 /** Methods permitted inside a 2026-07-28 MRTR input request map. */
-export declare const PM_MCP_INPUT_REQUEST_METHODS: readonly ["elicitation/create", "roots/list", "sampling/createMessage"];
+export declare const PM_MCP_INPUT_REQUEST_METHODS:readonly ["elicitation/create","roots/list","sampling/createMessage"];
 /** One typed request that a host must fulfill before retrying an operation. */
 export interface PmMcpInputRequest {
 /** Current MCP server-to-client request method. */
-method: (typeof PM_MCP_INPUT_REQUEST_METHODS)[number];
+method:(typeof PM_MCP_INPUT_REQUEST_METHODS)[number];
 /** Method-specific parameters retained as an open protocol object. */
-params: Record<string, unknown>;
+params:Record<string,unknown>;
 }
 /** Server-assigned MRTR input identifiers mapped to bounded requests. */
-export type PmMcpInputRequests = Record<string, PmMcpInputRequest>;
+export type PmMcpInputRequests = Record<string,PmMcpInputRequest>;
 /** Host responses keyed by the identifiers in an earlier input request map. */
-export type PmMcpInputResponses = Record<string, Record<string, unknown>>;
+export type PmMcpInputResponses = Record<string,Record<string,unknown>>;
 /** Modern interim result returned when an operation needs more host input. */
 export interface PmMcpInputRequiredResult {
 /** MRTR discriminator required by the current protocol. */
-resultType: "input_required";
+resultType:"input_required";
 /** Optional bounded requests the host must fulfill. */
-inputRequests?: PmMcpInputRequests;
+inputRequests?:PmMcpInputRequests;
 /** Optional integrity-protected state echoed unchanged on retry. */
-requestState?: string;
+requestState?:string;
 /** Result-local MCP metadata. */
-_meta: {
+_meta:{
 /** Server identity repeated on every modern result. */
-"io.modelcontextprotocol/serverInfo": PmMcpImplementation;
+"io.modelcontextprotocol/serverInfo":PmMcpImplementation;
 };
 /** Additional forward-compatible result fields. */
-[key: string]: unknown;
+[key:string]:unknown;
 }
 /**
  * Transport-neutral control signal used by SDK handlers to request an MRTR
@@ -34,68 +34,68 @@ _meta: {
  */
 export declare class PmMcpInputRequiredError extends Error {
 /** Server-authored input requests validated by the adapter. */
-readonly inputRequests?: unknown;
+readonly inputRequests?:unknown;
 /** Optional opaque continuation state echoed on retry. */
-readonly requestState?: string;
+readonly requestState?:string;
 /** Create an input-required control signal. */
-constructor(input: {
-inputRequests?: unknown;
-requestState?: string;
+constructor(input:{
+inputRequests?:unknown;
+requestState?:string;
 });
 }
 /** Cache fields required on current list and read results. */
 export interface PmMcpCachePolicy {
 /** Milliseconds for which a client may consider the response fresh. */
-ttlMs: number;
+ttlMs:number;
 /** Whether shared intermediaries may reuse the response. */
-cacheScope: "private" | "public";
+cacheScope:"private" | "public";
 /** Additional forward-compatible cache fields. */
-[key: string]: unknown;
+[key:string]:unknown;
 }
 /** Work bounds applied while validating an advertised JSON Schema. */
 export interface PmMcpJsonSchemaBounds {
 /** Maximum serialized schema bytes. */
-maxBytes?: number;
+maxBytes?:number;
 /** Maximum nested object or array depth. */
-maxDepth?: number;
+maxDepth?:number;
 /** Maximum visited object, array, and scalar nodes. */
-maxNodes?: number;
+maxNodes?:number;
 }
 /** State sealed into an opaque MRTR requestState value. */
 export interface PmMcpRequestStatePayload {
 /** Absolute expiration timestamp in milliseconds. */
-expiresAt: number;
+expiresAt:number;
 /** Original JSON-RPC method this state may resume. */
-method: string;
+method:string;
 /** Digest of the original request's salient parameters. */
-parameterDigest: string;
+parameterDigest:string;
 /** Principal binding chosen by the host or authorization layer. */
-principal: string;
+principal:string;
 /** Application-owned continuation data. */
-state: unknown;
+state:unknown;
 }
 /** Validate and clone a server-authored MRTR request map. */
-export declare function parseMcpInputRequests(value: unknown, requestContext: PmMcpRequestContext): PmMcpInputRequests;
+export declare function parseMcpInputRequests(value:unknown,requestContext:PmMcpRequestContext):PmMcpInputRequests;
 /** Validate and clone client-supplied input responses from an MRTR retry. */
-export declare function parseMcpInputResponses(value: unknown): PmMcpInputResponses;
+export declare function parseMcpInputResponses(value:unknown):PmMcpInputResponses;
 /** Build a modern input-required result after validating capability and size bounds. */
-export declare function buildMcpInputRequiredResult(input: {
-requestContext: PmMcpRequestContext;
-serverInfo: PmMcpImplementation;
-inputRequests?: unknown;
-requestState?: string;
-}): PmMcpInputRequiredResult;
+export declare function buildMcpInputRequiredResult(input:{
+requestContext:PmMcpRequestContext;
+serverInfo:PmMcpImplementation;
+inputRequests?:unknown;
+requestState?:string;
+}):PmMcpInputRequiredResult;
 /** Seal integrity-protected continuation state for an MRTR retry. */
-export declare function sealMcpRequestState(payload: PmMcpRequestStatePayload, secret: string | Uint8Array): string;
+export declare function sealMcpRequestState(payload:PmMcpRequestStatePayload,secret:string | Uint8Array):string;
 /** Verify an MRTR requestState value against method, principal, digest, and expiry. */
-export declare function openMcpRequestState(value: string, secret: string | Uint8Array, expected: {
-method: string;
-parameterDigest: string;
-principal: string;
-nowMs?: number;
-}): PmMcpRequestStatePayload;
+export declare function openMcpRequestState(value:string,secret:string | Uint8Array,expected:{
+method:string;
+parameterDigest:string;
+principal:string;
+nowMs?:number;
+}):PmMcpRequestStatePayload;
 /** Compute a stable-sized digest for application-selected salient request data. */
-export declare function digestMcpRequestParameters(value: unknown): string;
+export declare function digestMcpRequestParameters(value:unknown):string;
 /**
  * Bound single-use MRTR state consumption within one server process. Callers
  * requiring cross-process one-time semantics should persist the resulting hash.
@@ -103,16 +103,16 @@ export declare function digestMcpRequestParameters(value: unknown): string;
 export declare class PmMcpRequestStateReplayGuard {
 #private;
 /** Create a bounded in-process replay guard. */
-constructor(maximumEntries?: number);
+constructor(maximumEntries?:number);
 /** Consume one opaque requestState value exactly once in this process. */
-consume(value: string): void;
+consume(value:string):void;
 }
 /** Validate and clone a required MCP cache policy. */
-export declare function parseMcpCachePolicy(value: PmMcpCachePolicy): PmMcpCachePolicy;
+export declare function parseMcpCachePolicy(value:PmMcpCachePolicy):PmMcpCachePolicy;
 /** Attach required cache fields without mutating a method-specific payload. */
-export declare function withMcpCachePolicy<Payload extends Record<string, unknown>>(payload: Payload, policy: PmMcpCachePolicy): Payload & PmMcpCachePolicy;
+export declare function withMcpCachePolicy<Payload extends Record<string,unknown>>(payload:Payload,policy:PmMcpCachePolicy):Payload & PmMcpCachePolicy;
 /**
  * Validate JSON Schema 2020-12 structure under explicit byte, depth, node, and
  * local-reference work bounds while allowing the complete keyword vocabulary.
  */
-export declare function validateMcpJsonSchema(schema: unknown, bounds?: PmMcpJsonSchemaBounds): unknown;
+export declare function validateMcpJsonSchema(schema:unknown,bounds?:PmMcpJsonSchemaBounds):unknown;

package/dist/sdk/mcp/protocol.d.ts

@@ -5,7 +5,7 @@
  * discovery, result-envelope, and bounded legacy-compatibility contracts.
  */
 /** Canonical stateless MCP revision implemented by pm. */
-export declare const PM_MCP_PROTOCOL_VERSION: "2026-07-28";
+export declare const PM_MCP_PROTOCOL_VERSION:"2026-07-28";
 /**
  * Legacy initialize-era revisions accepted only by the bounded stdio adapter.
  *
@@ -15,143 +15,143 @@ export declare const PM_MCP_PROTOCOL_VERSION: "2026-07-28";
  * Ordered newest first: element zero is the revision offered to a client that
  * omits `protocolVersion`.
  */
-export declare const PM_MCP_LEGACY_PROTOCOL_VERSIONS: readonly ["2025-11-25", "2025-06-18"];
+export declare const PM_MCP_LEGACY_PROTOCOL_VERSIONS:readonly ["2025-11-25","2025-06-18"];
 /** Modern per-request protocol versions accepted by the stateless core. */
-export declare const PM_MCP_SUPPORTED_PROTOCOL_VERSIONS: readonly ["2026-07-28"];
+export declare const PM_MCP_SUPPORTED_PROTOCOL_VERSIONS:readonly ["2026-07-28"];
 /** Allocated MCP 2026-07-28 protocol error codes. */
-export declare const PM_MCP_ERROR_CODES: {
-readonly headerMismatch: -32020;
-readonly missingRequiredClientCapability: -32021;
-readonly unsupportedProtocolVersion: -32022;
-readonly invalidParams: -32602;
+export declare const PM_MCP_ERROR_CODES:{
+readonly headerMismatch:-32020;
+readonly missingRequiredClientCapability:-32021;
+readonly unsupportedProtocolVersion:-32022;
+readonly invalidParams:-32602;
 };
 /** Namespaced metadata keys owned by the MCP specification. */
-export declare const PM_MCP_META_KEYS: {
-readonly clientCapabilities: "io.modelcontextprotocol/clientCapabilities";
-readonly clientInfo: "io.modelcontextprotocol/clientInfo";
-readonly logLevel: "io.modelcontextprotocol/logLevel";
-readonly protocolVersion: "io.modelcontextprotocol/protocolVersion";
-readonly serverInfo: "io.modelcontextprotocol/serverInfo";
+export declare const PM_MCP_META_KEYS:{
+readonly clientCapabilities:"io.modelcontextprotocol/clientCapabilities";
+readonly clientInfo:"io.modelcontextprotocol/clientInfo";
+readonly logLevel:"io.modelcontextprotocol/logLevel";
+readonly protocolVersion:"io.modelcontextprotocol/protocolVersion";
+readonly serverInfo:"io.modelcontextprotocol/serverInfo";
 };
 /** Request-local severity vocabulary retained by the deprecated logging contract. */
-export declare const PM_MCP_LOG_LEVELS: readonly ["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"];
+export declare const PM_MCP_LOG_LEVELS:readonly ["debug","info","notice","warning","error","critical","alert","emergency"];
 /** An explicit logging opt-in applies only to the request carrying it. */
 export type PmMcpLogLevel = (typeof PM_MCP_LOG_LEVELS)[number];
 /** MCP implementation identity carried in request and result metadata. */
 export interface PmMcpImplementation {
 /** Stable implementation name. */
-name: string;
+name:string;
 /** Implementation version. */
-version: string;
+version:string;
 /** Optional human-readable implementation description. */
-description?: string;
+description?:string;
 /** Optional implementation website. */
-websiteUrl?: string;
+websiteUrl?:string;
 }
 /** Open MCP client capability map declared independently on every request. */
-export type PmMcpClientCapabilities = Record<string, unknown>;
+export type PmMcpClientCapabilities = Record<string,unknown>;
 /** Server capabilities advertised by pm discovery. */
 export interface PmMcpServerCapabilities {
 /** Prompt surface and change-notification support. */
-prompts?: {
-listChanged?: boolean;
+prompts?:{
+listChanged?:boolean;
 };
 /** Resource surface and change-notification support. */
-resources?: {
-listChanged?: boolean;
-subscribe?: boolean;
+resources?:{
+listChanged?:boolean;
+subscribe?:boolean;
 };
 /** Tool surface and change-notification support. */
-tools?: {
-listChanged?: boolean;
+tools?:{
+listChanged?:boolean;
 };
 /** Negotiated optional extension settings keyed by extension identifier. */
-extensions?: Record<string, Record<string, unknown>>;
+extensions?:Record<string,Record<string,unknown>>;
 /** Additional capability declarations retained for forward compatibility. */
-[key: string]: unknown;
+[key:string]:unknown;
 }
 /** Validated request-local metadata for one modern MCP operation. */
 export interface PmMcpRequestContext {
 /** Exact modern protocol revision used by this request. */
-protocolVersion: (typeof PM_MCP_SUPPORTED_PROTOCOL_VERSIONS)[number];
+protocolVersion:(typeof PM_MCP_SUPPORTED_PROTOCOL_VERSIONS)[number];
 /** Capabilities declared for this request only. */
-clientCapabilities: PmMcpClientCapabilities;
+clientCapabilities:PmMcpClientCapabilities;
 /** Optional bounded client identity used only for diagnostics/provenance. */
-clientInfo?: PmMcpImplementation;
+clientInfo?:PmMcpImplementation;
 /** Optional request-local logging threshold; absence forbids protocol log notifications. */
-logLevel?: PmMcpLogLevel;
+logLevel?:PmMcpLogLevel;
 }
 /** Required fields attached to every modern successful result. */
 export interface PmMcpResultEnvelope {
 /** Ordinary successful results are complete. */
-resultType: "complete";
+resultType:"complete";
 /** Result-local MCP metadata. */
-_meta: {
+_meta:{
 /** Server identity is repeated on every modern result. */
-"io.modelcontextprotocol/serverInfo": PmMcpImplementation;
+"io.modelcontextprotocol/serverInfo":PmMcpImplementation;
 };
 /** Additional method-specific result fields. */
-[key: string]: unknown;
+[key:string]:unknown;
 }
 /** Required server identity metadata attached to every modern result shape. */
 export interface PmMcpServerResultMetadata {
 /** Result-local MCP metadata. */
-_meta: {
+_meta:{
 /** Server identity is repeated on every modern result. */
-"io.modelcontextprotocol/serverInfo": PmMcpImplementation;
+"io.modelcontextprotocol/serverInfo":PmMcpImplementation;
 /** Additional namespaced or application metadata. */
-[key: string]: unknown;
+[key:string]:unknown;
 };
 }
 /** Modern discovery response contract. */
 export interface PmMcpDiscoverResult extends PmMcpResultEnvelope {
 /** Modern stateless revisions accepted through per-request metadata. */
-supportedVersions: string[];
+supportedVersions:string[];
 /** Deterministic server capability declaration. */
-capabilities: PmMcpServerCapabilities;
+capabilities:PmMcpServerCapabilities;
 /** Cache freshness hint required by the current schema. */
-ttlMs: number;
+ttlMs:number;
 /** Discovery is public because it contains no caller-specific data. */
-cacheScope: "public";
+cacheScope:"public";
 /** Optional model-facing usage guidance. */
-instructions?: string;
+instructions?:string;
 }
 /** Protocol-era interpretation used at explicit compatibility boundaries. */
 export type PmMcpProtocolEra = "modern" | "legacy";
 /** Structured MCP protocol error safe for JSON-RPC adapters. */
 export declare class PmMcpProtocolError extends Error {
 /** JSON-RPC/MCP error code. */
-readonly code: number;
+readonly code:number;
 /** Structured recovery or mismatch detail. */
-readonly data: Record<string, unknown>;
+readonly data:Record<string,unknown>;
 /** Create one typed protocol error. */
-constructor(message: string, code: number, data?: Record<string, unknown>);
+constructor(message:string,code:number,data?:Record<string,unknown>);
 }
 /** Return whether an unknown value is a non-array object. */
-export declare function isMcpRecord(value: unknown): value is Record<string, unknown>;
+export declare function isMcpRecord(value:unknown):value is Record<string,unknown>;
 /** Parse an optional MCP implementation identity without guessing missing fields. */
-export declare function parseMcpImplementation(value: unknown): PmMcpImplementation | undefined;
+export declare function parseMcpImplementation(value:unknown):PmMcpImplementation | undefined;
 /** Validate the stateless metadata required on every modern MCP request. */
-export declare function resolveMcpRequestContext(params: unknown): PmMcpRequestContext;
+export declare function resolveMcpRequestContext(params:unknown):PmMcpRequestContext;
 /** Validate the HTTP protocol-version header against request-local metadata. */
-export declare function assertMcpProtocolHeader(requestContext: PmMcpRequestContext, headerValue: string | undefined): void;
+export declare function assertMcpProtocolHeader(requestContext:PmMcpRequestContext,headerValue:string | undefined):void;
 /** Require named client capabilities without consulting prior requests. */
-export declare function assertMcpClientCapabilities(requestContext: PmMcpRequestContext, requiredCapabilities: readonly string[]): void;
+export declare function assertMcpClientCapabilities(requestContext:PmMcpRequestContext,requiredCapabilities:readonly string[]):void;
 /** Return whether this request independently negotiated one named extension. */
-export declare function hasMcpClientExtension(requestContext: PmMcpRequestContext, extension: string): boolean;
+export declare function hasMcpClientExtension(requestContext:PmMcpRequestContext,extension:string):boolean;
 /** Attach required server identity while preserving a non-complete result discriminator. */
-export declare function attachMcpServerInfo<Payload extends Record<string, unknown>>(payload: Payload, serverInfo: PmMcpImplementation): Payload & PmMcpServerResultMetadata;
+export declare function attachMcpServerInfo<Payload extends Record<string,unknown>>(payload:Payload,serverInfo:PmMcpImplementation):Payload & PmMcpServerResultMetadata;
 /** Attach required modern result fields without mutating the caller payload. */
-export declare function buildMcpCompleteResult<Payload extends Record<string, unknown>>(payload: Payload, serverInfo: PmMcpImplementation): Payload & PmMcpResultEnvelope;
+export declare function buildMcpCompleteResult<Payload extends Record<string,unknown>>(payload:Payload,serverInfo:PmMcpImplementation):Payload & PmMcpResultEnvelope;
 /** Build deterministic current-revision server discovery. */
-export declare function buildMcpDiscoverResult(input: {
-serverInfo: PmMcpImplementation;
-capabilities: PmMcpServerCapabilities;
-instructions?: string;
-ttlMs?: number;
-}): PmMcpDiscoverResult;
+export declare function buildMcpDiscoverResult(input:{
+serverInfo:PmMcpImplementation;
+capabilities:PmMcpServerCapabilities;
+instructions?:string;
+ttlMs?:number;
+}):PmMcpDiscoverResult;
 /**
  * Interpret resultType only at an explicit protocol-era boundary. Legacy
  * results may omit it; modern results fail closed when it is absent.
  */
-export declare function interpretMcpResultType(result: unknown, era: PmMcpProtocolEra): string;
+export declare function interpretMcpResultType(result:unknown,era:PmMcpProtocolEra):string;