@treeseed/sdk 0.13.0-rc.5 → 0.13.0-rc.6

package/dist/entrypoints/clients/control-plane-client.d.ts

@@ -0,0 +1,62 @@
+import type { ApiPrincipal } from './remote.js';
+export declare const DEFAULT_CONTROL_PLANE_BASE_URL = "http://127.0.0.1:3002";
+export declare const CONTROL_PLANE_BASE_URL_ENV = "TREESEED_API_BASE_URL";
+export interface ControlPlaneServerProfile {
+    serverId: string;
+    label: string;
+    baseUrl: string;
+}
+export interface ControlPlaneServerSession {
+    serverId: string;
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: string;
+    principal?: ApiPrincipal | null;
+}
+export interface ControlPlaneClientOptions {
+    profile: ControlPlaneServerProfile;
+    accessToken?: string | null;
+    fetchImpl?: typeof fetch;
+    userAgent?: string;
+}
+export interface ControlPlaneResponseEnvelope<T> {
+    data: T;
+    meta?: Record<string, unknown>;
+    links?: Record<string, string>;
+}
+export interface ProblemDetails {
+    type: string;
+    title: string;
+    status: number;
+    detail?: string;
+    instance?: string;
+    code: string;
+    requestId?: string;
+    traceId?: string;
+    fields?: Record<string, string[]>;
+}
+export interface ControlPlaneCallOptions {
+    method?: 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';
+    path: `/v1/${string}` | '/openapi.json';
+    input?: unknown;
+    headers?: Record<string, string>;
+    idempotencyKey?: string;
+    ifMatch?: string;
+    signal?: AbortSignal;
+}
+export declare class ControlPlaneClientError extends Error {
+    readonly status: number;
+    readonly problem: ProblemDetails;
+    readonly responseHeaders: Headers;
+    constructor(message: string, status: number, problem: ProblemDetails, responseHeaders: Headers);
+}
+export declare function defaultLocalControlPlaneServer(env?: Record<string, string | undefined>): ControlPlaneServerProfile;
+export declare class ControlPlaneClient {
+    readonly options: ControlPlaneClientOptions;
+    readonly baseUrl: string;
+    readonly accessToken: string | null;
+    readonly fetchImpl: typeof fetch;
+    readonly userAgent?: string;
+    constructor(options: ControlPlaneClientOptions);
+    call<T>(options: ControlPlaneCallOptions): Promise<ControlPlaneResponseEnvelope<T>>;
+}

package/dist/entrypoints/clients/control-plane-client.js

@@ -0,0 +1,96 @@
+const DEFAULT_CONTROL_PLANE_BASE_URL = "http://127.0.0.1:3002";
+const CONTROL_PLANE_BASE_URL_ENV = "TREESEED_API_BASE_URL";
+class ControlPlaneClientError extends Error {
+  constructor(message, status, problem, responseHeaders) {
+    super(message);
+    this.status = status;
+    this.problem = problem;
+    this.responseHeaders = responseHeaders;
+    this.name = "ControlPlaneClientError";
+  }
+  status;
+  problem;
+  responseHeaders;
+}
+function normalizeBaseUrl(value) {
+  const normalized = value.trim().replace(/\/+$/u, "");
+  if (!/^https?:\/\//u.test(normalized)) throw new Error("Control-plane server URLs must use HTTP or HTTPS.");
+  return normalized;
+}
+function defaultLocalControlPlaneServer(env = process.env) {
+  return {
+    serverId: "local",
+    label: "Local TreeSeed control plane",
+    baseUrl: normalizeBaseUrl(env[CONTROL_PLANE_BASE_URL_ENV] ?? DEFAULT_CONTROL_PLANE_BASE_URL)
+  };
+}
+async function responsePayload(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("json")) return response.json();
+  const text = await response.text();
+  return text.length > 0 ? text : null;
+}
+function problemFrom(payload, status) {
+  const source = payload && typeof payload === "object" ? payload : {};
+  return {
+    type: typeof source.type === "string" ? source.type : "about:blank",
+    title: typeof source.title === "string" ? source.title : "Control-plane request failed",
+    status,
+    detail: typeof source.detail === "string" ? source.detail : void 0,
+    instance: typeof source.instance === "string" ? source.instance : void 0,
+    code: typeof source.code === "string" ? source.code : "control_plane_request_failed",
+    requestId: typeof source.requestId === "string" ? source.requestId : void 0,
+    traceId: typeof source.traceId === "string" ? source.traceId : void 0,
+    fields: source.fields && typeof source.fields === "object" ? source.fields : void 0
+  };
+}
+class ControlPlaneClient {
+  constructor(options) {
+    this.options = options;
+    this.baseUrl = normalizeBaseUrl(options.profile.baseUrl);
+    this.accessToken = options.accessToken ?? null;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.userAgent = options.userAgent;
+  }
+  options;
+  baseUrl;
+  accessToken;
+  fetchImpl;
+  userAgent;
+  async call(options) {
+    const headers = new Headers(options.headers);
+    headers.set("accept", "application/json, application/problem+json");
+    if (this.accessToken) headers.set("authorization", `Bearer ${this.accessToken}`);
+    if (this.userAgent) headers.set("user-agent", this.userAgent);
+    if (options.idempotencyKey) headers.set("idempotency-key", options.idempotencyKey);
+    if (options.ifMatch) headers.set("if-match", options.ifMatch);
+    if (options.input !== void 0) headers.set("content-type", "application/json");
+    const response = await this.fetchImpl(`${this.baseUrl}${options.path}`, {
+      method: options.method ?? "GET",
+      headers,
+      body: options.input === void 0 ? void 0 : JSON.stringify(options.input),
+      signal: options.signal
+    });
+    const payload = await responsePayload(response);
+    if (!response.ok) {
+      const problem = problemFrom(payload, response.status);
+      throw new ControlPlaneClientError(problem.detail ?? problem.title, response.status, problem, response.headers);
+    }
+    if (!payload || typeof payload !== "object" || !("data" in payload)) {
+      throw new ControlPlaneClientError("The control plane returned an invalid success envelope.", 502, {
+        type: "https://treeseed.dev/problems/invalid-upstream-response",
+        title: "Invalid control-plane response",
+        status: 502,
+        code: "control_plane_response_invalid"
+      }, response.headers);
+    }
+    return payload;
+  }
+}
+export {
+  CONTROL_PLANE_BASE_URL_ENV,
+  ControlPlaneClient,
+  ControlPlaneClientError,
+  DEFAULT_CONTROL_PLANE_BASE_URL,
+  defaultLocalControlPlaneServer
+};

package/dist/operator-contracts/control-plane-operation.d.ts

@@ -0,0 +1,60 @@
+export declare const CONTROL_PLANE_OPERATION_SCHEMA_VERSION: "treeseed.control-plane-operation/v1";
+export type ControlPlaneHttpMethod = 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';
+export type ControlPlaneOperationKind = 'read' | 'mutation';
+export type ControlPlaneRiskClass = 'ordinary' | 'destructive' | 'credential' | 'authority' | 'production' | 'irreversible';
+export type ControlPlaneConfirmationPolicy = 'never' | 'input_required';
+export type ControlPlaneOperationSurface = 'rest' | 'cli' | 'mcp_tool' | 'mcp_resource' | 'internal';
+export type ControlPlaneCacheScope = 'none' | 'principal' | 'team' | 'project' | 'public';
+export type ControlPlanePaginationKind = 'none' | 'cursor';
+export interface ControlPlaneRestBinding {
+    method: ControlPlaneHttpMethod;
+    path: `/v1/${string}`;
+}
+export interface ControlPlaneSchemaBinding {
+    input: string;
+    output: string;
+    parameters?: string;
+    errors: string;
+}
+export interface ControlPlaneIdempotencyContract {
+    required: boolean;
+    header: 'Idempotency-Key';
+}
+export interface ControlPlaneConcurrencyContract {
+    required: boolean;
+    readHeader: 'ETag';
+    writeHeader: 'If-Match';
+}
+export interface ControlPlaneOperationDescriptor {
+    schemaVersion: typeof CONTROL_PLANE_OPERATION_SCHEMA_VERSION;
+    operationId: `${string}.${string}`;
+    description: string;
+    rest?: ControlPlaneRestBinding;
+    schemas: ControlPlaneSchemaBinding;
+    capability: string;
+    oauthScopes: OAuthScope[];
+    kind: ControlPlaneOperationKind;
+    riskClass: ControlPlaneRiskClass;
+    confirmation: ControlPlaneConfirmationPolicy;
+    idempotency: ControlPlaneIdempotencyContract;
+    concurrency: ControlPlaneConcurrencyContract;
+    surfaces: ControlPlaneOperationSurface[];
+    cacheScope: ControlPlaneCacheScope;
+    pagination: ControlPlanePaginationKind;
+    audited: boolean;
+    receipt: boolean;
+    redactedPaths: string[];
+}
+export declare const TREESEED_OAUTH_SCOPES: readonly ["treeseed:read", "treeseed:knowledge:write", "treeseed:governance:write", "treeseed:projects:write", "treeseed:execution", "treeseed:admin"];
+export type OAuthScope = typeof TREESEED_OAUTH_SCOPES[number];
+export interface ControlPlaneCatalog {
+    schemaVersion: 'treeseed.control-plane-catalog/v1';
+    operations: ControlPlaneOperationDescriptor[];
+}
+export interface ControlPlaneCatalogDiagnostic {
+    code: string;
+    path: string;
+    message: string;
+}
+export declare function validateControlPlaneCatalog(catalog: ControlPlaneCatalog): ControlPlaneCatalogDiagnostic[];
+export declare function indexControlPlaneCatalog(catalog: ControlPlaneCatalog): Map<`${string}.${string}`, ControlPlaneOperationDescriptor>;

package/dist/operator-contracts/control-plane-operation.js

@@ -0,0 +1,75 @@
+const CONTROL_PLANE_OPERATION_SCHEMA_VERSION = "treeseed.control-plane-operation/v1";
+const TREESEED_OAUTH_SCOPES = [
+  "treeseed:read",
+  "treeseed:knowledge:write",
+  "treeseed:governance:write",
+  "treeseed:projects:write",
+  "treeseed:execution",
+  "treeseed:admin"
+];
+const OPERATION_ID = /^[a-z][a-z0-9]*(?:\.[a-z][a-z0-9]*)+$/u;
+const PATH_PARAMETER = /\{([A-Za-z][A-Za-z0-9]*)\}/gu;
+function duplicates(values) {
+  const seen = /* @__PURE__ */ new Set();
+  return values.filter((value) => seen.size === seen.add(value).size);
+}
+function validateControlPlaneCatalog(catalog) {
+  const diagnostics = [];
+  const operationIds = /* @__PURE__ */ new Set();
+  const restBindings = /* @__PURE__ */ new Set();
+  for (const [index, operation] of catalog.operations.entries()) {
+    const path = `operations.${index}`;
+    if (operation.schemaVersion !== CONTROL_PLANE_OPERATION_SCHEMA_VERSION) {
+      diagnostics.push({ code: "operation_schema_version_invalid", path: `${path}.schemaVersion`, message: "Operation schemaVersion is not supported." });
+    }
+    if (!OPERATION_ID.test(operation.operationId)) {
+      diagnostics.push({ code: "operation_id_invalid", path: `${path}.operationId`, message: "Operation IDs must be stable dotted lowercase words." });
+    }
+    if (operationIds.has(operation.operationId)) {
+      diagnostics.push({ code: "operation_id_duplicate", path: `${path}.operationId`, message: `Duplicate operation ID ${operation.operationId}.` });
+    }
+    operationIds.add(operation.operationId);
+    if (operation.surfaces.includes("rest") !== Boolean(operation.rest)) {
+      diagnostics.push({ code: "rest_binding_mismatch", path: `${path}.rest`, message: "REST surface and REST binding must be declared together." });
+    }
+    if (operation.rest) {
+      const binding = `${operation.rest.method} ${operation.rest.path}`;
+      if (restBindings.has(binding)) diagnostics.push({ code: "rest_binding_duplicate", path: `${path}.rest`, message: `Duplicate REST binding ${binding}.` });
+      restBindings.add(binding);
+      const parameters = [...operation.rest.path.matchAll(PATH_PARAMETER)].map((match) => match[1]);
+      if (parameters.length > 0 && !operation.schemas.parameters) {
+        diagnostics.push({ code: "parameter_schema_required", path: `${path}.schemas.parameters`, message: "Parameterized REST paths require a parameter schema." });
+      }
+    }
+    for (const scope of operation.oauthScopes) {
+      if (!TREESEED_OAUTH_SCOPES.includes(scope)) diagnostics.push({ code: "oauth_scope_invalid", path: `${path}.oauthScopes`, message: `Unknown OAuth scope ${scope}.` });
+    }
+    for (const duplicate of duplicates(operation.surfaces)) diagnostics.push({ code: "surface_duplicate", path: `${path}.surfaces`, message: `Duplicate operation surface ${duplicate}.` });
+    for (const duplicate of duplicates(operation.oauthScopes)) diagnostics.push({ code: "oauth_scope_duplicate", path: `${path}.oauthScopes`, message: `Duplicate OAuth scope ${duplicate}.` });
+    const elevatedRisk = operation.riskClass !== "ordinary";
+    if (elevatedRisk !== (operation.confirmation === "input_required")) {
+      diagnostics.push({ code: "confirmation_policy_invalid", path: `${path}.confirmation`, message: "Elevated-risk operations require input_required; ordinary operations must not." });
+    }
+    if (operation.kind === "read" && (operation.idempotency.required || operation.concurrency.required || operation.receipt)) {
+      diagnostics.push({ code: "read_mutation_contract_invalid", path, message: "Read operations cannot require mutation idempotency, write concurrency, or mutation receipts." });
+    }
+    if (operation.kind === "mutation" && operation.surfaces.some((surface) => surface !== "internal") && !operation.audited) {
+      diagnostics.push({ code: "mutation_audit_required", path: `${path}.audited`, message: "Every externally reachable mutation must be audited." });
+    }
+    if (operation.kind === "mutation" && !operation.receipt) {
+      diagnostics.push({ code: "mutation_receipt_required", path: `${path}.receipt`, message: "Mutations must return durable receipts." });
+    }
+  }
+  return diagnostics.sort((left, right) => `${left.path}:${left.code}`.localeCompare(`${right.path}:${right.code}`));
+}
+function indexControlPlaneCatalog(catalog) {
+  const diagnostics = validateControlPlaneCatalog(catalog);
+  if (diagnostics.length > 0) throw new Error(`Invalid control-plane catalog: ${diagnostics.map((entry) => entry.code).join(", ")}`);
+  return new Map(catalog.operations.map((operation) => [operation.operationId, operation]));
+}
+export {
+  CONTROL_PLANE_OPERATION_SCHEMA_VERSION,
+  TREESEED_OAUTH_SCOPES,
+  indexControlPlaneCatalog,
+  validateControlPlaneCatalog
+};

package/dist/operator-contracts/index.d.ts

@@ -2,3 +2,6 @@ export * from './command-tree.js';
 export * from './canonical-command-tree.js';
 export * from './workday-profile.js';
 export * from './workday-lifecycle.js';
+export * from './control-plane-operation.js';
+export * from './mcp.js';
+export * from './oauth.js';

package/dist/operator-contracts/index.js

@@ -2,3 +2,6 @@ export * from "./command-tree.js";
 export * from "./canonical-command-tree.js";
 export * from "./workday-profile.js";
 export * from "./workday-lifecycle.js";
+export * from "./control-plane-operation.js";
+export * from "./mcp.js";
+export * from "./oauth.js";

package/dist/operator-contracts/mcp.d.ts

@@ -0,0 +1,78 @@
+import type { ControlPlaneOperationDescriptor, OAuthScope } from './control-plane-operation.js';
+export declare const MCP_PROTOCOL_VERSION: "2026-07-28";
+export interface ResourceLink {
+    type: 'resource_link';
+    uri: `treeseed://${string}`;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+}
+export interface ActorChain {
+    principalId: string;
+    delegatedAgentId?: string;
+    oauthClientId: string;
+    interface: 'rest' | 'cli' | 'mcp' | 'site_bff' | 'internal';
+    conversationId?: string;
+    modelClaim?: string;
+    skillClaim?: string;
+    traceId: string;
+}
+export interface ConfirmationState {
+    schemaVersion: 'treeseed.confirmation-state/v1';
+    principalId: string;
+    clientId: string;
+    operationId: string;
+    argumentsDigest: `sha256:${string}`;
+    expiresAt: string;
+    nonce: string;
+    signature: string;
+}
+export interface InputRequired {
+    type: 'input_required';
+    requestId: string;
+    prompt: string;
+    confirmation: ConfirmationState;
+}
+export interface McpToolDescriptor {
+    name: string;
+    description: string;
+    inputSchemaId: string;
+    outputSchemaId: string;
+    operationId: string;
+    readOnlyHint: boolean;
+    destructiveHint: boolean;
+    idempotentHint: boolean;
+    openWorldHint: boolean;
+}
+export interface McpResourceDescriptor {
+    uriTemplate: `treeseed://${string}`;
+    name: string;
+    description: string;
+    mimeType: string;
+    operationId: string;
+    subscribable: boolean;
+    cacheTtlSeconds?: number;
+}
+export interface McpPromptDescriptor {
+    name: string;
+    description: string;
+    argumentSchemaId: string;
+    requiredScopes: OAuthScope[];
+}
+export interface McpCatalog {
+    schemaVersion: 'treeseed.mcp-catalog/v1';
+    protocolVersion: typeof MCP_PROTOCOL_VERSION;
+    tools: McpToolDescriptor[];
+    resources: McpResourceDescriptor[];
+    prompts: McpPromptDescriptor[];
+    capabilities: {
+        completion: true;
+        progress: true;
+        cancellation: true;
+        inputRequired: true;
+        resourceSubscriptions: true;
+    };
+}
+export declare function operationToMcpTool(operation: ControlPlaneOperationDescriptor): McpToolDescriptor | null;
+export declare function buildMcpTools(operations: readonly ControlPlaneOperationDescriptor[]): McpToolDescriptor[];

package/dist/operator-contracts/mcp.js

@@ -0,0 +1,23 @@
+const MCP_PROTOCOL_VERSION = "2026-07-28";
+function operationToMcpTool(operation) {
+  if (!operation.surfaces.includes("mcp_tool")) return null;
+  return {
+    name: operation.operationId,
+    description: operation.description,
+    inputSchemaId: operation.schemas.input,
+    outputSchemaId: operation.schemas.output,
+    operationId: operation.operationId,
+    readOnlyHint: operation.kind === "read",
+    destructiveHint: operation.riskClass !== "ordinary",
+    idempotentHint: operation.kind === "read" || operation.idempotency.required,
+    openWorldHint: false
+  };
+}
+function buildMcpTools(operations) {
+  return operations.map(operationToMcpTool).filter((tool) => tool !== null).sort((left, right) => left.name.localeCompare(right.name));
+}
+export {
+  MCP_PROTOCOL_VERSION,
+  buildMcpTools,
+  operationToMcpTool
+};

package/dist/operator-contracts/oauth.d.ts

@@ -0,0 +1,38 @@
+import type { OAuthScope } from './control-plane-operation.js';
+export interface OAuthAuthorizationServerMetadata {
+    issuer: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    device_authorization_endpoint: string;
+    revocation_endpoint: string;
+    response_types_supported: ['code'];
+    grant_types_supported: ['authorization_code', 'refresh_token', 'urn:ietf:params:oauth:grant-type:device_code'];
+    code_challenge_methods_supported: ['S256'];
+    scopes_supported: OAuthScope[];
+}
+export interface OAuthProtectedResourceMetadata {
+    resource: string;
+    authorization_servers: string[];
+    scopes_supported: OAuthScope[];
+    bearer_methods_supported: ['header'];
+}
+export interface OAuthDeviceAuthorizationRequest {
+    clientId: string;
+    scope: OAuthScope[];
+}
+export interface OAuthDeviceAuthorizationResponse {
+    deviceCode: string;
+    userCode: string;
+    verificationUri: string;
+    verificationUriComplete: string;
+    expiresIn: number;
+    interval: number;
+}
+export interface OAuthTokenReceipt {
+    tokenType: 'Bearer';
+    accessToken: string;
+    expiresIn: number;
+    refreshToken?: string;
+    scope: OAuthScope[];
+    audience: string;
+}

package/dist/standards/mcp/compare.d.ts

@@ -0,0 +1,2 @@
+import type { McpCompatibilityComparison, McpContractModel } from './contracts.js';
+export declare function compareMcp(baseline: McpContractModel, candidate: McpContractModel): McpCompatibilityComparison;

package/dist/standards/mcp/compare.js

@@ -0,0 +1,38 @@
+const rank = { unchanged: 0, compatible_addition: 1, breaking: 2 };
+function same(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function compareMcp(baseline, candidate) {
+  const findings = [];
+  const add = (code, path, message, classification) => findings.push({ code, path, message, classification });
+  if (baseline.protocolVersion !== candidate.protocolVersion) add("mcp_protocol_changed", "protocolVersion", "The MCP protocol version changed.", "breaking");
+  for (const [name, tool] of Object.entries(baseline.tools)) {
+    const next = candidate.tools[name];
+    if (!next) {
+      add("mcp_tool_removed", `tools.${name}`, "An MCP tool was removed.", "breaking");
+      continue;
+    }
+    if (!same(tool.inputSchema, next.inputSchema)) add("mcp_tool_input_changed", `tools.${name}.inputSchema`, "Tool input changed.", "breaking");
+    if (!same(tool.outputSchema, next.outputSchema)) add("mcp_tool_output_changed", `tools.${name}.outputSchema`, "Tool output changed.", "breaking");
+    if (next.requiredScopes.some((scope) => !tool.requiredScopes.includes(scope))) add("mcp_tool_scope_escalated", `tools.${name}.requiredScopes`, "Tool scope requirements increased.", "breaking");
+    if (tool.riskClass !== next.riskClass) add("mcp_tool_risk_changed", `tools.${name}.riskClass`, "Tool risk classification changed.", "breaking");
+  }
+  for (const name of Object.keys(candidate.tools).filter((name2) => !(name2 in baseline.tools))) add("mcp_tool_added", `tools.${name}`, "An MCP tool was added.", "compatible_addition");
+  for (const [uri, resource] of Object.entries(baseline.resources)) {
+    const next = candidate.resources[uri];
+    if (!next) add("mcp_resource_removed", `resources.${uri}`, "An MCP resource was removed.", "breaking");
+    else if (!same(resource, next)) add("mcp_resource_changed", `resources.${uri}`, "An MCP resource contract changed.", "breaking");
+  }
+  for (const uri of Object.keys(candidate.resources).filter((uri2) => !(uri2 in baseline.resources))) add("mcp_resource_added", `resources.${uri}`, "An MCP resource was added.", "compatible_addition");
+  for (const [name, prompt] of Object.entries(baseline.prompts)) {
+    const next = candidate.prompts[name];
+    if (!next) add("mcp_prompt_removed", `prompts.${name}`, "An MCP prompt was removed.", "breaking");
+    else if (!same(prompt, next)) add("mcp_prompt_changed", `prompts.${name}`, "An MCP prompt contract changed.", "breaking");
+  }
+  for (const name of Object.keys(candidate.prompts).filter((name2) => !(name2 in baseline.prompts))) add("mcp_prompt_added", `prompts.${name}`, "An MCP prompt was added.", "compatible_addition");
+  findings.sort((left, right) => `${left.path}:${left.code}`.localeCompare(`${right.path}:${right.code}`));
+  return { classification: findings.reduce((value, finding) => rank[finding.classification] > rank[value] ? finding.classification : value, "unchanged"), findings };
+}
+export {
+  compareMcp
+};

package/dist/standards/mcp/contracts.d.ts

@@ -0,0 +1,34 @@
+import type { CompatibilityClassification } from '../contracts.js';
+import type { OAuthScope } from '../../operator-contracts/control-plane-operation.js';
+export interface McpNormalizedTool {
+    inputSchema: unknown;
+    outputSchema: unknown;
+    requiredScopes: OAuthScope[];
+    riskClass: string;
+}
+export interface McpNormalizedResource {
+    uriTemplate: string;
+    operationId: string;
+    subscribable: boolean;
+}
+export interface McpNormalizedPrompt {
+    argumentSchema: unknown;
+    requiredScopes: OAuthScope[];
+}
+export interface McpContractModel {
+    schemaVersion: 1;
+    protocolVersion: string;
+    tools: Record<string, McpNormalizedTool>;
+    resources: Record<string, McpNormalizedResource>;
+    prompts: Record<string, McpNormalizedPrompt>;
+}
+export interface McpCompatibilityFinding {
+    code: string;
+    path: string;
+    message: string;
+    classification: CompatibilityClassification;
+}
+export interface McpCompatibilityComparison {
+    classification: CompatibilityClassification;
+    findings: McpCompatibilityFinding[];
+}

package/dist/standards/mcp/index.d.ts

@@ -0,0 +1,3 @@
+export * from './contracts.js';
+export * from './normalize.js';
+export * from './compare.js';

package/dist/standards/mcp/index.js

@@ -0,0 +1,3 @@
+export * from "./contracts.js";
+export * from "./normalize.js";
+export * from "./compare.js";

package/dist/standards/mcp/normalize.d.ts

@@ -0,0 +1,4 @@
+import type { McpCatalog } from '../../operator-contracts/mcp.js';
+import type { ControlPlaneOperationDescriptor } from '../../operator-contracts/control-plane-operation.js';
+import type { McpContractModel } from './contracts.js';
+export declare function normalizeMcpCatalog(catalog: McpCatalog, operations: readonly ControlPlaneOperationDescriptor[], schemas: Readonly<Record<string, unknown>>): McpContractModel;

package/dist/standards/mcp/normalize.js

@@ -0,0 +1,30 @@
+import { canonicalizeStandardsValue } from "../canonicalize.js";
+function normalizeMcpCatalog(catalog, operations, schemas) {
+  const operationById = new Map(operations.map((operation) => [operation.operationId, operation]));
+  return {
+    schemaVersion: 1,
+    protocolVersion: catalog.protocolVersion,
+    tools: Object.fromEntries([...catalog.tools].sort((left, right) => left.name.localeCompare(right.name)).map((tool) => {
+      const operation = operationById.get(tool.operationId);
+      if (!operation) throw new Error(`MCP tool ${tool.name} references unknown operation ${tool.operationId}.`);
+      return [tool.name, {
+        inputSchema: canonicalizeStandardsValue(schemas[tool.inputSchemaId] ?? {}),
+        outputSchema: canonicalizeStandardsValue(schemas[tool.outputSchemaId] ?? {}),
+        requiredScopes: [...operation.oauthScopes].sort(),
+        riskClass: operation.riskClass
+      }];
+    })),
+    resources: Object.fromEntries([...catalog.resources].sort((left, right) => left.uriTemplate.localeCompare(right.uriTemplate)).map((resource) => [resource.uriTemplate, {
+      uriTemplate: resource.uriTemplate,
+      operationId: resource.operationId,
+      subscribable: resource.subscribable
+    }])),
+    prompts: Object.fromEntries([...catalog.prompts].sort((left, right) => left.name.localeCompare(right.name)).map((prompt) => [prompt.name, {
+      argumentSchema: canonicalizeStandardsValue(schemas[prompt.argumentSchemaId] ?? {}),
+      requiredScopes: [...prompt.requiredScopes].sort()
+    }]))
+  };
+}
+export {
+  normalizeMcpCatalog
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-	"version": "0.13.0-rc.5",
+	"version": "0.13.0-rc.6",
   "description": "Shared Treeseed SDK for content-backed and D1-backed object models.",
   "license": "Apache-2.0",
   "repository": {
@@ -135,6 +135,10 @@
       "types": "./dist/standards/openapi/index.d.ts",
       "default": "./dist/standards/openapi/index.js"
     },
+    "./standards/mcp": {
+      "types": "./dist/standards/mcp/index.d.ts",
+      "default": "./dist/standards/mcp/index.js"
+    },
     "./operator-contracts": {
       "types": "./dist/operator-contracts/index.d.ts",
       "default": "./dist/operator-contracts/index.js"
@@ -215,6 +219,10 @@
       "types": "./dist/entrypoints/clients/market-client.d.ts",
       "default": "./dist/entrypoints/clients/market-client.js"
     },
+    "./control-plane-client": {
+      "types": "./dist/entrypoints/clients/control-plane-client.d.ts",
+      "default": "./dist/entrypoints/clients/control-plane-client.js"
+    },
     "./market-gateway": {
       "types": "./dist/gateway/index.d.ts",
       "default": "./dist/gateway/index.js"