@burdenoff/mcp-libs 2026.627.3 → 2026.627.5

package/dist/modules/semanticfed/index.cjs

@@ -0,0 +1,1846 @@
+'use strict';
+
+var zod = require('zod');
+require('graphql-request');
+require('cross-fetch');
+require('@modelcontextprotocol/sdk/server/mcp.js');
+require('@modelcontextprotocol/sdk/types.js');
+
+// src/modules/semanticfed/tools/connectors.ts
+
+// src/core/errors.ts
+var McpInternalError = class extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "McpInternalError";
+    this.cause = cause;
+  }
+};
+
+// src/core/result.ts
+function jsonResult(data, structured) {
+  const result = {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+  return result;
+}
+function errorResult(message, hint) {
+  const text = hint ? `${message}
+
+Hint: ${hint}` : message;
+  return { content: [{ type: "text", text }], isError: true };
+}
+
+// src/core/tool-name.ts
+var MAX_TOOL_NAME_LENGTH = 63;
+function assertSafeName(name, kind) {
+  if (name.length > MAX_TOOL_NAME_LENGTH) {
+    throw new McpInternalError(
+      `Tool name '${name}' exceeds ${MAX_TOOL_NAME_LENGTH} characters (some MCP clients truncate at 64).`
+    );
+  }
+  return name;
+}
+function mcpToolName(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpToolName: productName is required");
+  }
+  const name = [productName, ...parts].filter(Boolean).join("_");
+  return assertSafeName(name);
+}
+function mcpResourceUri(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpResourceUri: productName is required");
+  }
+  return `${productName}://${parts.filter(Boolean).join("/")}`;
+}
+function mcpPromptName(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpPromptName: productName is required");
+  }
+  return [productName, ...parts].filter(Boolean).join("-");
+}
+
+// src/modules/semanticfed/operations.ts
+var CONNECTOR_FIELDS = `
+  id name description kind isActive capabilities workspaceId createdAt updatedAt
+`;
+var CONNECTION_FIELDS = `
+  id dataSourceId health latencyMs message probedAt workspaceId createdAt updatedAt
+`;
+var DATA_SOURCE_FIELDS = `
+  id connectorId name description endpoint status pushdownEnabled secretRef tags
+  lastIntrospectedAt workspaceId createdAt updatedAt
+`;
+var DIMENSION_FIELDS = `
+  id entityId name description dataType expression isPrimary workspaceId createdAt updatedAt
+`;
+var METRIC_FIELDS = `
+  id entityId name description aggregation expression format workspaceId createdAt updatedAt
+`;
+var ENTITY_FIELDS = `
+  id modelId dataSourceId name description kind physicalName primaryKey sqlDefinition
+  workspaceId createdAt updatedAt
+`;
+var RELATIONSHIP_FIELDS = `
+  id modelId name description kind fromEntityId fromField toEntityId toField
+  workspaceId createdAt updatedAt
+`;
+var MODEL_FIELDS = `
+  id name description status version tags publishedAt workspaceId createdAt updatedAt
+`;
+var QUERY_FIELDS = `
+  id modelId name description queryText parameters status cacheable cacheTtlSeconds
+  tags workspaceId createdAt updatedAt
+`;
+var QUERY_RUN_FIELDS = `
+  id queryId status fromCache rowCount sourcesTouched durationMs planSummary
+  errorMessage runById startedAt finishedAt workspaceId createdAt updatedAt
+`;
+var ACCESS_POLICY_FIELDS = `
+  id name description modelId entityId principal effect scope rule isActive
+  workspaceId createdAt updatedAt
+`;
+var PAGE_INFO = `pageInfo { cursor hasMore }`;
+var GET_CONNECTOR = `
+  query SemGetConnector($id: ID!) {
+    semConnector(id: $id) {
+      ${CONNECTOR_FIELDS}
+      dataSources { ${DATA_SOURCE_FIELDS} }
+    }
+  }
+`;
+var LIST_CONNECTORS = `
+  query SemListConnectors($kind: SemConnectorKind, $pagination: PaginationInput) {
+    semListConnectors(kind: $kind, pagination: $pagination) {
+      items { ${CONNECTOR_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_CONNECTOR = `
+  mutation SemCreateConnector($input: SemCreateConnectorInput!) {
+    semCreateConnector(input: $input) {
+      ${CONNECTOR_FIELDS}
+    }
+  }
+`;
+var UPDATE_CONNECTOR = `
+  mutation SemUpdateConnector($id: ID!, $input: SemUpdateConnectorInput!) {
+    semUpdateConnector(id: $id, input: $input) {
+      ${CONNECTOR_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_CONNECTOR = `
+  mutation SemArchiveConnector($id: ID!) {
+    semArchiveConnector(id: $id)
+  }
+`;
+var GET_DATA_SOURCE = `
+  query SemGetDataSource($id: ID!) {
+    semDataSource(id: $id) {
+      ${DATA_SOURCE_FIELDS}
+      connector { ${CONNECTOR_FIELDS} }
+      connections { ${CONNECTION_FIELDS} }
+    }
+  }
+`;
+var LIST_DATA_SOURCES = `
+  query SemListDataSources(
+    $connectorId: ID
+    $status: SemDataSourceStatus
+    $pagination: PaginationInput
+  ) {
+    semListDataSources(connectorId: $connectorId, status: $status, pagination: $pagination) {
+      items { ${DATA_SOURCE_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_DATA_SOURCE = `
+  mutation SemCreateDataSource($input: SemCreateDataSourceInput!) {
+    semCreateDataSource(input: $input) {
+      ${DATA_SOURCE_FIELDS}
+    }
+  }
+`;
+var UPDATE_DATA_SOURCE = `
+  mutation SemUpdateDataSource($id: ID!, $input: SemUpdateDataSourceInput!) {
+    semUpdateDataSource(id: $id, input: $input) {
+      ${DATA_SOURCE_FIELDS}
+    }
+  }
+`;
+var TRANSITION_DATA_SOURCE = `
+  mutation SemTransitionDataSource($id: ID!, $status: SemDataSourceStatus!) {
+    semTransitionDataSource(id: $id, status: $status) {
+      ${DATA_SOURCE_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_DATA_SOURCE = `
+  mutation SemArchiveDataSource($id: ID!) {
+    semArchiveDataSource(id: $id)
+  }
+`;
+var LIST_CONNECTIONS = `
+  query SemListConnections($dataSourceId: ID!) {
+    semListConnections(dataSourceId: $dataSourceId) {
+      ${CONNECTION_FIELDS}
+    }
+  }
+`;
+var RECORD_CONNECTION = `
+  mutation SemRecordConnection($input: SemRecordConnectionInput!) {
+    semRecordConnection(input: $input) {
+      ${CONNECTION_FIELDS}
+    }
+  }
+`;
+var GET_MODEL = `
+  query SemGetModel($id: ID!) {
+    semModel(id: $id) {
+      ${MODEL_FIELDS}
+      entities { ${ENTITY_FIELDS} }
+      relationships { ${RELATIONSHIP_FIELDS} }
+    }
+  }
+`;
+var LIST_MODELS = `
+  query SemListModels($status: SemModelStatus, $pagination: PaginationInput) {
+    semListModels(status: $status, pagination: $pagination) {
+      items { ${MODEL_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_MODEL = `
+  mutation SemCreateModel($input: SemCreateModelInput!) {
+    semCreateModel(input: $input) {
+      ${MODEL_FIELDS}
+    }
+  }
+`;
+var UPDATE_MODEL = `
+  mutation SemUpdateModel($id: ID!, $input: SemUpdateModelInput!) {
+    semUpdateModel(id: $id, input: $input) {
+      ${MODEL_FIELDS}
+    }
+  }
+`;
+var PUBLISH_MODEL = `
+  mutation SemPublishModel($id: ID!) {
+    semPublishModel(id: $id) {
+      ${MODEL_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_MODEL = `
+  mutation SemArchiveModel($id: ID!) {
+    semArchiveModel(id: $id)
+  }
+`;
+var GET_ENTITY = `
+  query SemGetEntity($id: ID!) {
+    semEntity(id: $id) {
+      ${ENTITY_FIELDS}
+      dimensions { ${DIMENSION_FIELDS} }
+      metrics { ${METRIC_FIELDS} }
+    }
+  }
+`;
+var LIST_ENTITIES = `
+  query SemListEntities($modelId: ID!) {
+    semListEntities(modelId: $modelId) {
+      ${ENTITY_FIELDS}
+    }
+  }
+`;
+var CREATE_ENTITY = `
+  mutation SemCreateEntity($input: SemCreateEntityInput!) {
+    semCreateEntity(input: $input) {
+      ${ENTITY_FIELDS}
+    }
+  }
+`;
+var UPDATE_ENTITY = `
+  mutation SemUpdateEntity($id: ID!, $input: SemUpdateEntityInput!) {
+    semUpdateEntity(id: $id, input: $input) {
+      ${ENTITY_FIELDS}
+    }
+  }
+`;
+var DELETE_ENTITY = `
+  mutation SemDeleteEntity($id: ID!) {
+    semDeleteEntity(id: $id)
+  }
+`;
+var CREATE_DIMENSION = `
+  mutation SemCreateDimension($input: SemCreateDimensionInput!) {
+    semCreateDimension(input: $input) {
+      ${DIMENSION_FIELDS}
+    }
+  }
+`;
+var CREATE_METRIC = `
+  mutation SemCreateMetric($input: SemCreateMetricInput!) {
+    semCreateMetric(input: $input) {
+      ${METRIC_FIELDS}
+    }
+  }
+`;
+var LIST_RELATIONSHIPS = `
+  query SemListRelationships($modelId: ID!) {
+    semListRelationships(modelId: $modelId) {
+      ${RELATIONSHIP_FIELDS}
+    }
+  }
+`;
+var CREATE_RELATIONSHIP = `
+  mutation SemCreateRelationship($input: SemCreateRelationshipInput!) {
+    semCreateRelationship(input: $input) {
+      ${RELATIONSHIP_FIELDS}
+    }
+  }
+`;
+var GET_QUERY = `
+  query SemGetQuery($id: ID!) {
+    semQuery(id: $id) {
+      ${QUERY_FIELDS}
+      runs { ${QUERY_RUN_FIELDS} }
+    }
+  }
+`;
+var LIST_QUERIES = `
+  query SemListQueries(
+    $modelId: ID
+    $status: SemQueryStatus
+    $pagination: PaginationInput
+  ) {
+    semListQueries(modelId: $modelId, status: $status, pagination: $pagination) {
+      items { ${QUERY_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var CREATE_QUERY = `
+  mutation SemCreateQuery($input: SemCreateQueryInput!) {
+    semCreateQuery(input: $input) {
+      ${QUERY_FIELDS}
+    }
+  }
+`;
+var UPDATE_QUERY = `
+  mutation SemUpdateQuery($id: ID!, $input: SemUpdateQueryInput!) {
+    semUpdateQuery(id: $id, input: $input) {
+      ${QUERY_FIELDS}
+    }
+  }
+`;
+var PUBLISH_QUERY = `
+  mutation SemPublishQuery($id: ID!) {
+    semPublishQuery(id: $id) {
+      ${QUERY_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_QUERY = `
+  mutation SemArchiveQuery($id: ID!) {
+    semArchiveQuery(id: $id)
+  }
+`;
+var RUN_QUERY = `
+  mutation SemRunQuery($id: ID!) {
+    semRunQuery(id: $id) {
+      ${QUERY_RUN_FIELDS}
+    }
+  }
+`;
+var LIST_QUERY_RUNS = `
+  query SemListQueryRuns(
+    $queryId: ID!
+    $status: SemQueryRunStatus
+    $pagination: PaginationInput
+  ) {
+    semListQueryRuns(queryId: $queryId, status: $status, pagination: $pagination) {
+      items { ${QUERY_RUN_FIELDS} }
+      ${PAGE_INFO}
+    }
+  }
+`;
+var LIST_ACCESS_POLICIES = `
+  query SemListAccessPolicies($modelId: ID, $entityId: ID) {
+    semListAccessPolicies(modelId: $modelId, entityId: $entityId) {
+      ${ACCESS_POLICY_FIELDS}
+    }
+  }
+`;
+var CREATE_ACCESS_POLICY = `
+  mutation SemCreateAccessPolicy($input: SemCreateAccessPolicyInput!) {
+    semCreateAccessPolicy(input: $input) {
+      ${ACCESS_POLICY_FIELDS}
+    }
+  }
+`;
+var SET_ACCESS_POLICY_ACTIVE = `
+  mutation SemSetAccessPolicyActive($id: ID!, $isActive: Boolean!) {
+    semSetAccessPolicyActive(id: $id, isActive: $isActive) {
+      ${ACCESS_POLICY_FIELDS}
+    }
+  }
+`;
+var HEALTH = `
+  query SemHealth {
+    semHealth
+  }
+`;
+var ConnectorKindEnum = zod.z.enum([
+  "BIGQUERY",
+  "CLICKHOUSE",
+  "DATABRICKS",
+  "GRAPHQL_API",
+  "MONGODB",
+  "MYSQL",
+  "OTHER",
+  "POSTGRES",
+  "REDSHIFT",
+  "REST_API",
+  "S3_PARQUET",
+  "SNOWFLAKE"
+]).describe("Backing technology of a connector");
+var DataSourceStatusEnum = zod.z.enum(["CONNECTED", "DEGRADED", "DISABLED", "DISCONNECTED", "DRAFT"]).describe("Connectivity lifecycle status of a data source");
+var ConnectionHealthEnum = zod.z.enum(["DEGRADED", "HEALTHY", "UNKNOWN", "UNREACHABLE"]).describe("Health classification reported by a connection probe");
+var ModelStatusEnum = zod.z.enum(["ARCHIVED", "DEPRECATED", "DRAFT", "PUBLISHED"]).describe("Lifecycle status of a semantic model");
+var EntityKindEnum = zod.z.enum(["DERIVED", "EXTERNAL", "TABLE", "VIEW"]).describe("Physical/logical kind of a semantic entity");
+var DataTypeEnum = zod.z.enum(["BOOLEAN", "DATE", "DECIMAL", "GEO", "INTEGER", "JSON", "STRING", "TIMESTAMP"]).describe("Data type of a dimension");
+var AggregationEnum = zod.z.enum(["AVG", "COUNT", "COUNT_DISTINCT", "CUSTOM", "MAX", "MEDIAN", "MIN", "SUM"]).describe("Aggregation function of a metric");
+var RelationshipKindEnum = zod.z.enum(["MANY_TO_MANY", "MANY_TO_ONE", "ONE_TO_MANY", "ONE_TO_ONE"]).describe("Cardinality of a relationship between entities");
+var QueryStatusEnum = zod.z.enum(["ARCHIVED", "DRAFT", "PUBLISHED"]).describe("Lifecycle status of a saved federated query");
+var QueryRunStatusEnum = zod.z.enum(["CANCELLED", "FAILED", "PLANNING", "QUEUED", "RUNNING", "SUCCEEDED"]).describe("Execution status of a query run");
+var PolicyEffectEnum = zod.z.enum(["ALLOW", "DENY"]).describe("Whether an access policy ALLOWs or DENYs");
+var PolicyScopeEnum = zod.z.enum(["COLUMN", "ENTITY", "ROW"]).describe("Governance scope an access policy applies at");
+var JsonObject = zod.z.record(zod.z.string(), zod.z.unknown());
+
+// src/modules/semanticfed/tools/connectors.ts
+function registerConnectorTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "connectors_get")),
+    {
+      title: "Get Connector",
+      description: "Fetch a single SemanticFed connector by ID, including its data sources.",
+      inputSchema: { id: zod.z.string().describe("Connector ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_CONNECTOR, { id });
+        if (!data.semConnector) return errorResult(`Connector ${id} not found`);
+        return jsonResult(data.semConnector);
+      } catch (error) {
+        ctx.logger.error("semanticfed connectors_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get connector: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "connectors_list")),
+    {
+      title: "List Connectors",
+      description: "List connectors in the bound workspace, optionally filtered by kind, with limit/offset pagination.",
+      inputSchema: {
+        kind: ConnectorKindEnum.optional().describe("Filter by backing technology"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ kind, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_CONNECTORS, {
+          kind,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0 }
+        });
+        return jsonResult(data.semListConnectors);
+      } catch (error) {
+        ctx.logger.error("semanticfed connectors_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list connectors: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "connectors_create")),
+    {
+      title: "Create Connector",
+      description: "Register a new connector. `name` is required; `kind` defaults to POSTGRES. `capabilities` is optional JSON describing supported pushdown/features.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Connector display name"),
+        kind: ConnectorKindEnum.optional().describe("Backing technology (default POSTGRES)"),
+        description: zod.z.string().optional().describe("Description"),
+        capabilities: JsonObject.optional().describe("Capabilities JSON (pushdown/features)")
+      }
+    },
+    async ({ name, kind, description, capabilities }) => {
+      try {
+        const input = { name };
+        if (kind !== void 0) input.kind = kind;
+        if (description !== void 0) input.description = description;
+        if (capabilities !== void 0) input.capabilities = capabilities;
+        const data = await ctx.gql.workspace.request(CREATE_CONNECTOR, { input });
+        return jsonResult(data.semCreateConnector);
+      } catch (error) {
+        ctx.logger.error("semanticfed connectors_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create connector: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "connectors_update")),
+    {
+      title: "Update Connector",
+      description: "Update a connector. At least one mutable field must be provided. Use `isActive` to enable/disable it.",
+      inputSchema: {
+        id: zod.z.string().describe("Connector ID"),
+        name: zod.z.string().optional().describe("Updated name"),
+        description: zod.z.string().optional().describe("Updated description"),
+        kind: ConnectorKindEnum.optional().describe("Updated backing technology"),
+        isActive: zod.z.boolean().optional().describe("Updated active flag"),
+        capabilities: JsonObject.optional().describe("Updated capabilities JSON")
+      }
+    },
+    async ({ id, name, description, kind, isActive, capabilities }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (description !== void 0) input.description = description;
+        if (kind !== void 0) input.kind = kind;
+        if (isActive !== void 0) input.isActive = isActive;
+        if (capabilities !== void 0) input.capabilities = capabilities;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/description/kind/isActive/capabilities"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_CONNECTOR, { id, input });
+        return jsonResult(data.semUpdateConnector);
+      } catch (error) {
+        ctx.logger.error("semanticfed connectors_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update connector: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "connectors_archive")),
+    {
+      title: "Archive Connector",
+      description: "Archive (soft-delete) a connector by ID. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Connector ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_CONNECTOR,
+          { id }
+        );
+        return jsonResult({ archived: data.semArchiveConnector });
+      } catch (error) {
+        ctx.logger.error("semanticfed connectors_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive connector: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerDataSourceTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "data_sources_get")),
+    {
+      title: "Get Data Source",
+      description: "Fetch a single SemanticFed data source by ID, including its connector and connection probes.",
+      inputSchema: { id: zod.z.string().describe("Data source ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_DATA_SOURCE, { id });
+        if (!data.semDataSource) return errorResult(`Data source ${id} not found`);
+        return jsonResult(data.semDataSource);
+      } catch (error) {
+        ctx.logger.error("semanticfed data_sources_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get data source: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "data_sources_list")),
+    {
+      title: "List Data Sources",
+      description: "List data sources, optionally filtered by connector and/or status, with limit/offset pagination.",
+      inputSchema: {
+        connectorId: zod.z.string().optional().describe("Filter by connector ID"),
+        status: DataSourceStatusEnum.optional().describe("Filter by connectivity status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ connectorId, status, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_DATA_SOURCES, {
+          connectorId,
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0 }
+        });
+        return jsonResult(data.semListDataSources);
+      } catch (error) {
+        ctx.logger.error("semanticfed data_sources_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list data sources: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "data_sources_create")),
+    {
+      title: "Create Data Source",
+      description: "Register a new data source against a connector. `connectorId` and `name` are required; `endpoint` is connection JSON and `pushdownEnabled` defaults to true.",
+      inputSchema: {
+        connectorId: zod.z.string().min(1).describe("Parent connector ID"),
+        name: zod.z.string().min(1).describe("Data source display name"),
+        description: zod.z.string().optional().describe("Description"),
+        endpoint: JsonObject.optional().describe("Endpoint/connection JSON"),
+        secretRef: zod.z.string().optional().describe("Key Vault secret reference for credentials"),
+        pushdownEnabled: zod.z.boolean().optional().describe("Whether query pushdown is enabled (default true)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Tag labels")
+      }
+    },
+    async ({ connectorId, name, description, endpoint, secretRef, pushdownEnabled, tags }) => {
+      try {
+        const input = { connectorId, name };
+        if (description !== void 0) input.description = description;
+        if (endpoint !== void 0) input.endpoint = endpoint;
+        if (secretRef !== void 0) input.secretRef = secretRef;
+        if (pushdownEnabled !== void 0) input.pushdownEnabled = pushdownEnabled;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_DATA_SOURCE, { input });
+        return jsonResult(data.semCreateDataSource);
+      } catch (error) {
+        ctx.logger.error("semanticfed data_sources_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create data source: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "data_sources_update")),
+    {
+      title: "Update Data Source",
+      description: "Update a data source. At least one mutable field must be provided. Use `data_sources_transition` to change connectivity status.",
+      inputSchema: {
+        id: zod.z.string().describe("Data source ID"),
+        name: zod.z.string().optional().describe("Updated name"),
+        description: zod.z.string().optional().describe("Updated description"),
+        endpoint: JsonObject.optional().describe("Updated endpoint/connection JSON"),
+        secretRef: zod.z.string().optional().describe("Updated secret reference"),
+        pushdownEnabled: zod.z.boolean().optional().describe("Updated pushdown flag"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tag labels")
+      }
+    },
+    async ({ id, name, description, endpoint, secretRef, pushdownEnabled, tags }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (description !== void 0) input.description = description;
+        if (endpoint !== void 0) input.endpoint = endpoint;
+        if (secretRef !== void 0) input.secretRef = secretRef;
+        if (pushdownEnabled !== void 0) input.pushdownEnabled = pushdownEnabled;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/description/endpoint/secretRef/pushdownEnabled/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_DATA_SOURCE, { id, input });
+        return jsonResult(data.semUpdateDataSource);
+      } catch (error) {
+        ctx.logger.error("semanticfed data_sources_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update data source: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "data_sources_transition")),
+    {
+      title: "Transition Data Source",
+      description: "Move a data source through its connectivity lifecycle via a validated transition (DRAFT \u2192 CONNECTED \u2192 DEGRADED/DISCONNECTED/DISABLED).",
+      inputSchema: {
+        id: zod.z.string().describe("Data source ID"),
+        status: DataSourceStatusEnum.describe("Target connectivity status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_DATA_SOURCE, { id, status });
+        return jsonResult(data.semTransitionDataSource);
+      } catch (error) {
+        ctx.logger.error("semanticfed data_sources_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition data source: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "data_sources_archive")),
+    {
+      title: "Archive Data Source",
+      description: "Archive (soft-delete) a data source by ID. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Data source ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_DATA_SOURCE,
+          { id }
+        );
+        return jsonResult({ archived: data.semArchiveDataSource });
+      } catch (error) {
+        ctx.logger.error("semanticfed data_sources_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive data source: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerConnectionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "connections_list")),
+    {
+      title: "List Connection Probes",
+      description: "List the recorded connection health probes for a data source.",
+      inputSchema: { dataSourceId: zod.z.string().describe("Data source ID") }
+    },
+    async ({ dataSourceId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_CONNECTIONS, { dataSourceId });
+        return jsonResult(data.semListConnections);
+      } catch (error) {
+        ctx.logger.error("semanticfed connections_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list connections: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "connections_record")),
+    {
+      title: "Record Connection Probe",
+      description: "Record a connection health probe for a data source and reconcile its status. `dataSourceId` and `health` are required.",
+      inputSchema: {
+        dataSourceId: zod.z.string().min(1).describe("Data source ID"),
+        health: ConnectionHealthEnum.describe("Observed health"),
+        latencyMs: zod.z.number().int().optional().describe("Probe round-trip latency in ms"),
+        message: zod.z.string().optional().describe("Probe message / diagnostic detail")
+      }
+    },
+    async ({ dataSourceId, health, latencyMs, message }) => {
+      try {
+        const input = { dataSourceId, health };
+        if (latencyMs !== void 0) input.latencyMs = latencyMs;
+        if (message !== void 0) input.message = message;
+        const data = await ctx.gql.workspace.request(RECORD_CONNECTION, { input });
+        return jsonResult(data.semRecordConnection);
+      } catch (error) {
+        ctx.logger.error("semanticfed connections_record failed", { error: String(error) });
+        return errorResult(
+          `Failed to record connection: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerModelTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "models_get")),
+    {
+      title: "Get Semantic Model",
+      description: "Fetch a single semantic model by ID, including its entities and relationships.",
+      inputSchema: { id: zod.z.string().describe("Semantic model ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_MODEL, { id });
+        if (!data.semModel) return errorResult(`Semantic model ${id} not found`);
+        return jsonResult(data.semModel);
+      } catch (error) {
+        ctx.logger.error("semanticfed models_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get semantic model: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "models_list")),
+    {
+      title: "List Semantic Models",
+      description: "List semantic models in the bound workspace, optionally filtered by status, with limit/offset pagination.",
+      inputSchema: {
+        status: ModelStatusEnum.optional().describe("Filter by model status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ status, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MODELS, {
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0 }
+        });
+        return jsonResult(data.semListModels);
+      } catch (error) {
+        ctx.logger.error("semanticfed models_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list semantic models: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "models_create")),
+    {
+      title: "Create Semantic Model",
+      description: "Create a new draft semantic model. `name` is required; entities/relationships are added separately.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Model display name"),
+        description: zod.z.string().optional().describe("Description"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Tag labels")
+      }
+    },
+    async ({ name, description, tags }) => {
+      try {
+        const input = { name };
+        if (description !== void 0) input.description = description;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_MODEL, { input });
+        return jsonResult(data.semCreateModel);
+      } catch (error) {
+        ctx.logger.error("semanticfed models_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create semantic model: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "models_update")),
+    {
+      title: "Update Semantic Model",
+      description: "Update a semantic model. At least one mutable field must be provided. Use `models_publish` to publish a draft.",
+      inputSchema: {
+        id: zod.z.string().describe("Semantic model ID"),
+        name: zod.z.string().optional().describe("Updated name"),
+        description: zod.z.string().optional().describe("Updated description"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tag labels")
+      }
+    },
+    async ({ id, name, description, tags }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (description !== void 0) input.description = description;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/description/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_MODEL, { id, input });
+        return jsonResult(data.semUpdateModel);
+      } catch (error) {
+        ctx.logger.error("semanticfed models_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update semantic model: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "models_publish")),
+    {
+      title: "Publish Semantic Model",
+      description: "Publish a draft model \u2014 bumps its version and flips status to PUBLISHED. Returns the published model.",
+      inputSchema: { id: zod.z.string().describe("Semantic model ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(PUBLISH_MODEL, { id });
+        return jsonResult(data.semPublishModel);
+      } catch (error) {
+        ctx.logger.error("semanticfed models_publish failed", { error: String(error) });
+        return errorResult(
+          `Failed to publish semantic model: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "models_archive")),
+    {
+      title: "Archive Semantic Model",
+      description: "Archive (soft-delete) a semantic model by ID. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Semantic model ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_MODEL,
+          { id }
+        );
+        return jsonResult({ archived: data.semArchiveModel });
+      } catch (error) {
+        ctx.logger.error("semanticfed models_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive semantic model: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerEntityTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "entities_get")),
+    {
+      title: "Get Entity",
+      description: "Fetch a single entity by ID, including its dimensions and metrics.",
+      inputSchema: { id: zod.z.string().describe("Entity ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_ENTITY, { id });
+        if (!data.semEntity) return errorResult(`Entity ${id} not found`);
+        return jsonResult(data.semEntity);
+      } catch (error) {
+        ctx.logger.error("semanticfed entities_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get entity: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "entities_list")),
+    {
+      title: "List Entities",
+      description: "List the entities that belong to a semantic model.",
+      inputSchema: { modelId: zod.z.string().describe("Owning semantic model ID") }
+    },
+    async ({ modelId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ENTITIES, { modelId });
+        return jsonResult(data.semListEntities);
+      } catch (error) {
+        ctx.logger.error("semanticfed entities_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list entities: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "entities_create")),
+    {
+      title: "Create Entity",
+      description: "Create an entity in a model. `modelId` and `name` are required; `kind` defaults to TABLE. Bind it to a `dataSourceId` or define it with `sqlDefinition` for derived entities.",
+      inputSchema: {
+        modelId: zod.z.string().min(1).describe("Owning semantic model ID"),
+        name: zod.z.string().min(1).describe("Entity display name"),
+        kind: EntityKindEnum.optional().describe("Entity kind (default TABLE)"),
+        dataSourceId: zod.z.string().optional().describe("Backing data source ID"),
+        description: zod.z.string().optional().describe("Description"),
+        physicalName: zod.z.string().optional().describe("Physical table/view name"),
+        primaryKey: zod.z.string().optional().describe("Primary-key column"),
+        sqlDefinition: zod.z.string().optional().describe("SQL definition (for DERIVED/VIEW entities)")
+      }
+    },
+    async ({
+      modelId,
+      name,
+      kind,
+      dataSourceId,
+      description,
+      physicalName,
+      primaryKey,
+      sqlDefinition
+    }) => {
+      try {
+        const input = { modelId, name };
+        if (kind !== void 0) input.kind = kind;
+        if (dataSourceId !== void 0) input.dataSourceId = dataSourceId;
+        if (description !== void 0) input.description = description;
+        if (physicalName !== void 0) input.physicalName = physicalName;
+        if (primaryKey !== void 0) input.primaryKey = primaryKey;
+        if (sqlDefinition !== void 0) input.sqlDefinition = sqlDefinition;
+        const data = await ctx.gql.workspace.request(CREATE_ENTITY, { input });
+        return jsonResult(data.semCreateEntity);
+      } catch (error) {
+        ctx.logger.error("semanticfed entities_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create entity: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "entities_update")),
+    {
+      title: "Update Entity",
+      description: "Update an entity. At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Entity ID"),
+        name: zod.z.string().optional().describe("Updated name"),
+        kind: EntityKindEnum.optional().describe("Updated entity kind"),
+        dataSourceId: zod.z.string().optional().describe("Updated backing data source ID"),
+        description: zod.z.string().optional().describe("Updated description"),
+        physicalName: zod.z.string().optional().describe("Updated physical table/view name"),
+        primaryKey: zod.z.string().optional().describe("Updated primary-key column"),
+        sqlDefinition: zod.z.string().optional().describe("Updated SQL definition")
+      }
+    },
+    async ({
+      id,
+      name,
+      kind,
+      dataSourceId,
+      description,
+      physicalName,
+      primaryKey,
+      sqlDefinition
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (kind !== void 0) input.kind = kind;
+        if (dataSourceId !== void 0) input.dataSourceId = dataSourceId;
+        if (description !== void 0) input.description = description;
+        if (physicalName !== void 0) input.physicalName = physicalName;
+        if (primaryKey !== void 0) input.primaryKey = primaryKey;
+        if (sqlDefinition !== void 0) input.sqlDefinition = sqlDefinition;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/kind/dataSourceId/description/physicalName/primaryKey/sqlDefinition"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_ENTITY, { id, input });
+        return jsonResult(data.semUpdateEntity);
+      } catch (error) {
+        ctx.logger.error("semanticfed entities_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update entity: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "entities_delete")),
+    {
+      title: "Delete Entity",
+      description: "Delete an entity by ID (also removes its dimensions/metrics). Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Entity ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          DELETE_ENTITY,
+          { id }
+        );
+        return jsonResult({ deleted: data.semDeleteEntity });
+      } catch (error) {
+        ctx.logger.error("semanticfed entities_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete entity: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerDimensionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "dimensions_create")),
+    {
+      title: "Create Dimension",
+      description: "Add a dimension (descriptive attribute) to an entity. `entityId` and `name` are required; `dataType` defaults to STRING and `isPrimary` to false.",
+      inputSchema: {
+        entityId: zod.z.string().min(1).describe("Owning entity ID"),
+        name: zod.z.string().min(1).describe("Dimension display name"),
+        dataType: DataTypeEnum.optional().describe("Data type (default STRING)"),
+        description: zod.z.string().optional().describe("Description"),
+        expression: zod.z.string().optional().describe("SQL expression backing the dimension"),
+        isPrimary: zod.z.boolean().optional().describe("Whether this is the primary dimension (default false)")
+      }
+    },
+    async ({ entityId, name, dataType, description, expression, isPrimary }) => {
+      try {
+        const input = { entityId, name };
+        if (dataType !== void 0) input.dataType = dataType;
+        if (description !== void 0) input.description = description;
+        if (expression !== void 0) input.expression = expression;
+        if (isPrimary !== void 0) input.isPrimary = isPrimary;
+        const data = await ctx.gql.workspace.request(CREATE_DIMENSION, { input });
+        return jsonResult(data.semCreateDimension);
+      } catch (error) {
+        ctx.logger.error("semanticfed dimensions_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create dimension: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerMetricTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "metrics_create")),
+    {
+      title: "Create Metric",
+      description: "Add a metric (aggregated measure) to an entity. `entityId` and `name` are required; `aggregation` defaults to SUM. Use `expression` for a custom SQL measure and `format` for display formatting.",
+      inputSchema: {
+        entityId: zod.z.string().min(1).describe("Owning entity ID"),
+        name: zod.z.string().min(1).describe("Metric display name"),
+        aggregation: AggregationEnum.optional().describe("Aggregation function (default SUM)"),
+        description: zod.z.string().optional().describe("Description"),
+        expression: zod.z.string().optional().describe("SQL expression backing the metric"),
+        format: zod.z.string().optional().describe("Display format hint (e.g. currency, percent)")
+      }
+    },
+    async ({ entityId, name, aggregation, description, expression, format }) => {
+      try {
+        const input = { entityId, name };
+        if (aggregation !== void 0) input.aggregation = aggregation;
+        if (description !== void 0) input.description = description;
+        if (expression !== void 0) input.expression = expression;
+        if (format !== void 0) input.format = format;
+        const data = await ctx.gql.workspace.request(CREATE_METRIC, { input });
+        return jsonResult(data.semCreateMetric);
+      } catch (error) {
+        ctx.logger.error("semanticfed metrics_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create metric: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerRelationshipTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "relationships_list")),
+    {
+      title: "List Relationships",
+      description: "List the relationships (entity joins) that belong to a semantic model.",
+      inputSchema: { modelId: zod.z.string().describe("Owning semantic model ID") }
+    },
+    async ({ modelId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_RELATIONSHIPS, { modelId });
+        return jsonResult(data.semListRelationships);
+      } catch (error) {
+        ctx.logger.error("semanticfed relationships_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list relationships: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "relationships_create")),
+    {
+      title: "Create Relationship",
+      description: "Define a join between two entities in a model. `modelId`, `name`, `fromEntityId`, `fromField`, `toEntityId`, and `toField` are required; `kind` defaults to MANY_TO_ONE.",
+      inputSchema: {
+        modelId: zod.z.string().min(1).describe("Owning semantic model ID"),
+        name: zod.z.string().min(1).describe("Relationship display name"),
+        fromEntityId: zod.z.string().min(1).describe("Source entity ID"),
+        fromField: zod.z.string().min(1).describe("Source join field"),
+        toEntityId: zod.z.string().min(1).describe("Target entity ID"),
+        toField: zod.z.string().min(1).describe("Target join field"),
+        kind: RelationshipKindEnum.optional().describe("Cardinality (default MANY_TO_ONE)"),
+        description: zod.z.string().optional().describe("Description")
+      }
+    },
+    async ({ modelId, name, fromEntityId, fromField, toEntityId, toField, kind, description }) => {
+      try {
+        const input = {
+          modelId,
+          name,
+          fromEntityId,
+          fromField,
+          toEntityId,
+          toField
+        };
+        if (kind !== void 0) input.kind = kind;
+        if (description !== void 0) input.description = description;
+        const data = await ctx.gql.workspace.request(CREATE_RELATIONSHIP, { input });
+        return jsonResult(data.semCreateRelationship);
+      } catch (error) {
+        ctx.logger.error("semanticfed relationships_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create relationship: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerQueryTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "queries_get")),
+    {
+      title: "Get Query",
+      description: "Fetch a single saved query by ID, including its run history.",
+      inputSchema: { id: zod.z.string().describe("Query ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_QUERY, { id });
+        if (!data.semQuery) return errorResult(`Query ${id} not found`);
+        return jsonResult(data.semQuery);
+      } catch (error) {
+        ctx.logger.error("semanticfed queries_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get query: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "queries_list")),
+    {
+      title: "List Queries",
+      description: "List saved queries, optionally filtered by model and/or status, with limit/offset pagination.",
+      inputSchema: {
+        modelId: zod.z.string().optional().describe("Filter by semantic model ID"),
+        status: QueryStatusEnum.optional().describe("Filter by query status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ modelId, status, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_QUERIES, {
+          modelId,
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0 }
+        });
+        return jsonResult(data.semListQueries);
+      } catch (error) {
+        ctx.logger.error("semanticfed queries_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list queries: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "queries_create")),
+    {
+      title: "Create Query",
+      description: "Create a new draft saved query. `name` and `queryText` are required; `cacheable` defaults to true. Bind to a `modelId` to resolve entities/metrics by name.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Query display name"),
+        queryText: zod.z.string().min(1).describe("Federated query text"),
+        modelId: zod.z.string().optional().describe("Semantic model ID the query resolves against"),
+        description: zod.z.string().optional().describe("Description"),
+        parameters: JsonObject.optional().describe("Parameter defaults/schema JSON"),
+        cacheable: zod.z.boolean().optional().describe("Whether results are cacheable (default true)"),
+        cacheTtlSeconds: zod.z.number().int().optional().describe("Cache TTL in seconds"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Tag labels")
+      }
+    },
+    async ({
+      name,
+      queryText,
+      modelId,
+      description,
+      parameters,
+      cacheable,
+      cacheTtlSeconds,
+      tags
+    }) => {
+      try {
+        const input = { name, queryText };
+        if (modelId !== void 0) input.modelId = modelId;
+        if (description !== void 0) input.description = description;
+        if (parameters !== void 0) input.parameters = parameters;
+        if (cacheable !== void 0) input.cacheable = cacheable;
+        if (cacheTtlSeconds !== void 0) input.cacheTtlSeconds = cacheTtlSeconds;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_QUERY, { input });
+        return jsonResult(data.semCreateQuery);
+      } catch (error) {
+        ctx.logger.error("semanticfed queries_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create query: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "queries_update")),
+    {
+      title: "Update Query",
+      description: "Update a saved query. At least one mutable field must be provided. Use `queries_publish` to publish a draft.",
+      inputSchema: {
+        id: zod.z.string().describe("Query ID"),
+        name: zod.z.string().optional().describe("Updated name"),
+        queryText: zod.z.string().optional().describe("Updated query text"),
+        modelId: zod.z.string().optional().describe("Updated semantic model ID"),
+        description: zod.z.string().optional().describe("Updated description"),
+        parameters: JsonObject.optional().describe("Updated parameter JSON"),
+        cacheable: zod.z.boolean().optional().describe("Updated cacheable flag"),
+        cacheTtlSeconds: zod.z.number().int().optional().describe("Updated cache TTL in seconds"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tag labels")
+      }
+    },
+    async ({
+      id,
+      name,
+      queryText,
+      modelId,
+      description,
+      parameters,
+      cacheable,
+      cacheTtlSeconds,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (queryText !== void 0) input.queryText = queryText;
+        if (modelId !== void 0) input.modelId = modelId;
+        if (description !== void 0) input.description = description;
+        if (parameters !== void 0) input.parameters = parameters;
+        if (cacheable !== void 0) input.cacheable = cacheable;
+        if (cacheTtlSeconds !== void 0) input.cacheTtlSeconds = cacheTtlSeconds;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/queryText/modelId/description/parameters/cacheable/cacheTtlSeconds/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_QUERY, { id, input });
+        return jsonResult(data.semUpdateQuery);
+      } catch (error) {
+        ctx.logger.error("semanticfed queries_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update query: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "queries_publish")),
+    {
+      title: "Publish Query",
+      description: "Publish a draft query (flips status to PUBLISHED). Returns the published query.",
+      inputSchema: { id: zod.z.string().describe("Query ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(PUBLISH_QUERY, { id });
+        return jsonResult(data.semPublishQuery);
+      } catch (error) {
+        ctx.logger.error("semanticfed queries_publish failed", { error: String(error) });
+        return errorResult(
+          `Failed to publish query: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "queries_archive")),
+    {
+      title: "Archive Query",
+      description: "Archive (soft-delete) a saved query by ID. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Query ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_QUERY,
+          { id }
+        );
+        return jsonResult({ archived: data.semArchiveQuery });
+      } catch (error) {
+        ctx.logger.error("semanticfed queries_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive query: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "queries_run")),
+    {
+      title: "Run Query",
+      description: "Enqueue a federated execution of a saved query. Returns the new run record; poll it with `runs_list`.",
+      inputSchema: { id: zod.z.string().describe("Query ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(RUN_QUERY, { id });
+        return jsonResult(data.semRunQuery);
+      } catch (error) {
+        ctx.logger.error("semanticfed queries_run failed", { error: String(error) });
+        return errorResult(
+          `Failed to run query: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerRunTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "query_runs_list")),
+    {
+      title: "List Query Runs",
+      description: "List the execution runs for a saved query, optionally filtered by status, with limit/offset pagination.",
+      inputSchema: {
+        queryId: zod.z.string().describe("Owning query ID"),
+        status: QueryRunStatusEnum.optional().describe("Filter by run status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ queryId, status, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_QUERY_RUNS, {
+          queryId,
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0 }
+        });
+        return jsonResult(data.semListQueryRuns);
+      } catch (error) {
+        ctx.logger.error("semanticfed query_runs_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list query runs: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerPolicyTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "access_policies_list")),
+    {
+      title: "List Access Policies",
+      description: "List access policies, optionally scoped to a specific model and/or entity.",
+      inputSchema: {
+        modelId: zod.z.string().optional().describe("Filter by semantic model ID"),
+        entityId: zod.z.string().optional().describe("Filter by entity ID")
+      }
+    },
+    async ({ modelId, entityId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ACCESS_POLICIES, { modelId, entityId });
+        return jsonResult(data.semListAccessPolicies);
+      } catch (error) {
+        ctx.logger.error("semanticfed access_policies_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list access policies: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "access_policies_create")),
+    {
+      title: "Create Access Policy",
+      description: "Create a governance policy. `name` and `principal` are required; `effect` defaults to ALLOW and `scope` to ROW. Scope it to a model and/or entity, and supply a `rule` JSON for ROW/COLUMN predicates.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Policy display name"),
+        principal: zod.z.string().min(1).describe("Principal the policy applies to (role/group/user expression)"),
+        effect: PolicyEffectEnum.optional().describe("ALLOW or DENY (default ALLOW)"),
+        scope: PolicyScopeEnum.optional().describe("ROW, COLUMN, or ENTITY (default ROW)"),
+        modelId: zod.z.string().optional().describe("Semantic model ID the policy applies to"),
+        entityId: zod.z.string().optional().describe("Entity ID the policy applies to"),
+        description: zod.z.string().optional().describe("Description"),
+        rule: JsonObject.optional().describe("Rule JSON (predicate / column mask)")
+      }
+    },
+    async ({ name, principal, effect, scope, modelId, entityId, description, rule }) => {
+      try {
+        const input = { name, principal };
+        if (effect !== void 0) input.effect = effect;
+        if (scope !== void 0) input.scope = scope;
+        if (modelId !== void 0) input.modelId = modelId;
+        if (entityId !== void 0) input.entityId = entityId;
+        if (description !== void 0) input.description = description;
+        if (rule !== void 0) input.rule = rule;
+        const data = await ctx.gql.workspace.request(CREATE_ACCESS_POLICY, { input });
+        return jsonResult(data.semCreateAccessPolicy);
+      } catch (error) {
+        ctx.logger.error("semanticfed access_policies_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create access policy: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "access_policies_set_active")),
+    {
+      title: "Set Access Policy Active",
+      description: "Enable or disable an access policy by ID. Returns the updated policy.",
+      inputSchema: {
+        id: zod.z.string().describe("Access policy ID"),
+        isActive: zod.z.boolean().describe("Whether the policy should be active")
+      }
+    },
+    async ({ id, isActive }) => {
+      try {
+        const data = await ctx.gql.workspace.request(SET_ACCESS_POLICY_ACTIVE, { id, isActive });
+        return jsonResult(data.semSetAccessPolicyActive);
+      } catch (error) {
+        ctx.logger.error("semanticfed access_policies_set_active failed", { error: String(error) });
+        return errorResult(
+          `Failed to set access policy active state: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/semanticfed/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health_check")),
+    {
+      title: "SemanticFed Health Check",
+      description: "Public health probe for the SemanticFed subgraph (semHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.semHealth });
+      } catch (error) {
+        ctx.logger.error("semanticfed health failed", { error: String(error) });
+        return errorResult(
+          `SemanticFed health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/semanticfed/resources.ts
+function registerSemanticfedResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const connectorsUri = track(mcpResourceUri(ctx.productName, "connectors"));
+  const dataSourcesUri = track(mcpResourceUri(ctx.productName, "data-sources"));
+  const modelsUri = track(mcpResourceUri(ctx.productName, "models"));
+  server.registerResource(
+    "semanticfed-schema",
+    schemaUri,
+    {
+      title: "SemanticFed Domain Schema",
+      description: "Overview of the SemanticFed data-federation domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# SemanticFed Domain (Overview)
+
+The data-federation platform \u2014 unifies databases, warehouses, lakes, and APIs
+behind one governed semantic layer so teams can query everything in place
+without moving it. System of record for data sources & connectors, the
+versioned semantic model, saved federated queries with run history, and access
+governance.
+
+## Entities
+- SemConnector \u2014 a connection-technology registry entry (has data sources)
+- SemDataSource \u2014 a physical/logical source behind a connector (has connections)
+- SemConnection \u2014 a recorded health probe for a data source
+- SemSemanticModel \u2014 the versioned modelling unit (has entities + relationships)
+- SemEntity \u2014 a table/view/derived entity (has dimensions + metrics)
+- SemDimension \u2014 a descriptive attribute on an entity
+- SemMetric \u2014 an aggregated measure on an entity
+- SemRelationship \u2014 a join between two entities
+- SemQuery \u2014 a saved federated query (has runs)
+- SemQueryRun \u2014 an execution of a saved query
+- SemAccessPolicy \u2014 a row/column/entity governance policy
+
+## Enums
+- SemConnectorKind: BIGQUERY, CLICKHOUSE, DATABRICKS, GRAPHQL_API, MONGODB, MYSQL, OTHER, POSTGRES, REDSHIFT, REST_API, S3_PARQUET, SNOWFLAKE
+- SemDataSourceStatus: DRAFT, CONNECTED, DEGRADED, DISCONNECTED, DISABLED
+- SemConnectionHealth: HEALTHY, DEGRADED, UNREACHABLE, UNKNOWN
+- SemModelStatus: DRAFT, PUBLISHED, DEPRECATED, ARCHIVED
+- SemEntityKind: TABLE, VIEW, DERIVED, EXTERNAL
+- SemDataType: STRING, INTEGER, DECIMAL, BOOLEAN, DATE, TIMESTAMP, JSON, GEO
+- SemAggregation: SUM, AVG, COUNT, COUNT_DISTINCT, MIN, MAX, MEDIAN, CUSTOM
+- SemRelationshipKind: ONE_TO_ONE, ONE_TO_MANY, MANY_TO_ONE, MANY_TO_MANY
+- SemQueryStatus: DRAFT, PUBLISHED, ARCHIVED
+- SemQueryRunStatus: QUEUED, PLANNING, RUNNING, SUCCEEDED, FAILED, CANCELLED
+- SemPolicyEffect: ALLOW, DENY
+- SemPolicyScope: ROW, COLUMN, ENTITY
+
+## Tool groups
+connectors, data_sources, connections, models, entities, dimensions, metrics,
+relationships, queries, query_runs, access_policies, health. All run against the WORKSPACE
+gateway (workspace-scoped) except the public health probe.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "semanticfed-connectors",
+    connectorsUri,
+    {
+      title: "SemanticFed Connectors",
+      description: "The first 50 connectors in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${connectorsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_CONNECTORS,
+          { pagination: { limit: 50, offset: 0 } }
+        );
+        return {
+          contents: [
+            {
+              uri: connectorsUri,
+              text: JSON.stringify(data.semListConnectors, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: connectorsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "semanticfed-data-sources",
+    dataSourcesUri,
+    {
+      title: "SemanticFed Data Sources",
+      description: "The first 50 data sources in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${dataSourcesUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_DATA_SOURCES,
+          { pagination: { limit: 50, offset: 0 } }
+        );
+        return {
+          contents: [
+            {
+              uri: dataSourcesUri,
+              text: JSON.stringify(data.semListDataSources, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: dataSourcesUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "semanticfed-models",
+    modelsUri,
+    {
+      title: "SemanticFed Semantic Models",
+      description: "The first 50 semantic models in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${modelsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MODELS, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: modelsUri,
+              text: JSON.stringify(data.semListModels, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: modelsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerSemanticfedPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const modellingName = track(mcpPromptName(p, "model-build"));
+  const federationName = track(mcpPromptName(p, "query-federation"));
+  server.registerPrompt(
+    modellingName,
+    {
+      title: "Build Semantic Model",
+      description: "Guide for building a SemanticFed semantic model end to end: register a connector, attach a data source, create the model, add entities with dimensions/metrics, define relationships, and publish.",
+      argsSchema: {
+        name: zod.z.string().optional().describe("Semantic model name"),
+        connectorKind: zod.z.string().optional().describe("Connector technology (e.g. POSTGRES)")
+      }
+    },
+    ({ name, connectorKind }) => {
+      ctx.logger.debug(`Prompt ${modellingName} called`, { name, connectorKind });
+      const nameNote = name ? `Use the model name "${name}".` : "Ask the user for the model name.";
+      const kindNote = connectorKind ? `Use connector kind ${connectorKind}.` : "Help the user pick a SemConnectorKind (e.g. POSTGRES, SNOWFLAKE, BIGQUERY).";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me build a new SemanticFed semantic model.
+
+1. **Register Connector**: Use ${p}_connectors_create. ${kindNote}
+2. **Attach Data Source**: Use ${p}_data_sources_create with the new connectorId, an endpoint JSON, and a secretRef for credentials; then ${p}_data_sources_transition to CONNECTED once reachable (optionally record a probe with ${p}_connections_record).
+3. **Create Model**: Use ${p}_models_create. ${nameNote}
+4. **Add Entities**: Use ${p}_entities_create (modelId + kind TABLE/VIEW/DERIVED) for each table/view; bind to the dataSourceId.
+5. **Dimensions + Metrics**: Use ${p}_dimensions_create and ${p}_metrics_create on each entity.
+6. **Relationships**: Use ${p}_relationships_create to join entities (fromEntityId/fromField \u2192 toEntityId/toField, kind MANY_TO_ONE etc.).
+7. **Publish**: Use ${p}_models_publish to bump the version and flip status to PUBLISHED.
+
+Show results at each step and confirm before publishing.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    federationName,
+    {
+      title: "Federated Query",
+      description: "Workflow to author a saved federated query against a published model, govern it with an access policy, publish it, execute it, and inspect run results.",
+      argsSchema: {
+        modelId: zod.z.string().optional().describe("Published model ID to query")
+      }
+    },
+    ({ modelId }) => {
+      ctx.logger.debug(`Prompt ${federationName} called`, { modelId });
+      const modelNote = modelId ? `Query against model "${modelId}".` : `First list published models with ${p}_models_list (status=PUBLISHED) and pick one.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run a SemanticFed federated query workflow. ${modelNote}
+
+1. **Author**: Use ${p}_queries_create with the modelId, a queryText, and optional parameters; set cacheable + cacheTtlSeconds.
+2. **Govern**: Use ${p}_access_policies_create to add a row/column access policy (principal, effect, scope) and ${p}_access_policies_set_active to enable it.
+3. **Publish**: Use ${p}_queries_publish to move the query to PUBLISHED.
+4. **Execute**: Use ${p}_queries_run to enqueue a federated execution; it returns a run record.
+5. **Inspect**: Poll ${p}_query_runs_list (filter by status) to watch QUEUED \u2192 PLANNING \u2192 RUNNING \u2192 SUCCEEDED and read rowCount / sourcesTouched / planSummary.
+
+Summarize what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/semanticfed/index.ts
+var semanticfedModule = {
+  id: "semanticfed",
+  version: "0.0.1",
+  displayName: "SemanticFed",
+  dependsOn: ["auth"],
+  capabilities: { tools: {}, resources: {}, prompts: {} },
+  register(server, ctx) {
+    const tools = [];
+    const resources = [];
+    const prompts = [];
+    const trackTool = (n) => {
+      tools.push(n);
+      return n;
+    };
+    const trackResource = (uri) => {
+      resources.push(uri);
+      return uri;
+    };
+    const trackPrompt = (n) => {
+      prompts.push(n);
+      return n;
+    };
+    registerConnectorTools(server, ctx, trackTool);
+    registerDataSourceTools(server, ctx, trackTool);
+    registerConnectionTools(server, ctx, trackTool);
+    registerModelTools(server, ctx, trackTool);
+    registerEntityTools(server, ctx, trackTool);
+    registerDimensionTools(server, ctx, trackTool);
+    registerMetricTools(server, ctx, trackTool);
+    registerRelationshipTools(server, ctx, trackTool);
+    registerQueryTools(server, ctx, trackTool);
+    registerRunTools(server, ctx, trackTool);
+    registerPolicyTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerSemanticfedResources(server, ctx, trackResource);
+    registerSemanticfedPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var semanticfed_default = semanticfedModule;
+
+module.exports = semanticfed_default;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map