@burdenoff/mcp-libs 2026.626.1 → 2026.627.2

package/dist/modules/assethandler/index.js

@@ -0,0 +1,1540 @@
+import { mcpToolName, errorResult, jsonResult, mcpResourceUri, mcpPromptName } from '../../chunk-H2OYWLOA.js';
+import { z } from 'zod';
+
+// src/modules/assethandler/operations.ts
+var ASSET_FIELDS = `
+  id assetNumber name description category serialNumber status condition
+  locationName assignedTo tags customAttributes workspaceId createdAt updatedAt
+`;
+var SOFTWARE_ASSET_FIELDS = `
+  id name vendor version licenseType seatsPurchased seatsUsed compliancePercent
+  workspaceId createdAt updatedAt
+`;
+var CONFIGURATION_ITEM_FIELDS = `
+  id ciNumber ciType name status environment owner attributes workspaceId
+  createdAt updatedAt
+`;
+var DISCOVERY_JOB_FIELDS = `
+  id name source status assetsDiscovered createdBy errorSummary startedAt
+  completedAt workspaceId createdAt updatedAt
+`;
+var INCIDENT_FIELDS = `
+  id title description category priority status reportedBy reportedAt resolvedAt
+  slaBreached assignedTo workspaceId
+`;
+var PROBLEM_FIELDS = `
+  id title description category priority status rootCause workaround
+  relatedIncidents assignedTo workspaceId createdAt updatedAt
+`;
+var CHANGE_REQUEST_FIELDS = `
+  id title description type status risk requestedBy assignedTo affectedAssets
+  approvals scheduledStart scheduledEnd workspaceId createdAt updatedAt
+`;
+var WORK_ORDER_FIELDS = `
+  id title description type status priority assetId assignedTo workspaceId
+  createdAt updatedAt
+`;
+var MAINTENANCE_RECORD_FIELDS = `
+  id assetId title description type status priority estimatedCost actualCost
+  checklist scheduledAt completedAt workspaceId createdAt updatedAt
+`;
+var KNOWLEDGE_ARTICLE_FIELDS = `
+  id title slug summary content status tags relatedAssetId relatedIncidentId
+  views createdBy updatedBy publishedAt workspaceId createdAt updatedAt
+`;
+var BUDGET_FIELDS = `
+  id name category department period allocated spent remaining status
+  workspaceId createdAt updatedAt
+`;
+var TRANSACTION_FIELDS = `
+  id type category description amount currency vendor department status
+  occurredAt workspaceId
+`;
+var INVOICE_FIELDS = `
+  id number vendor amount currency status issueDate dueDate items relatedPO
+  workspaceId createdAt updatedAt
+`;
+var COMPLIANCE_FRAMEWORK_FIELDS = `
+  id name version status score totalControls passedControls failedControls
+  lastAssessment nextAssessment workspaceId createdAt updatedAt
+`;
+var SECURITY_POLICY_FIELDS = `
+  id name version status category description owner applicableTo effectiveDate
+  reviewDate workspaceId createdAt updatedAt
+`;
+var SECURITY_EVENT_FIELDS = `
+  id title description eventType severity source resolved ipAddress userId
+  occurredAt workspaceId createdAt
+`;
+var ESG_METRIC_FIELDS = `
+  id category metricKey metricName value unit target trend periodStart periodEnd
+  updatedBy workspaceId createdAt updatedAt
+`;
+var DIGITAL_TWIN_FIELDS = `
+  id assetId fidelityLevel modelRef geometryRef properties workspaceId
+  createdAt updatedAt
+`;
+var IOT_DEVICE_FIELDS = `
+  id deviceId name type protocol status metadata assetId workspaceId
+  createdAt updatedAt
+`;
+var AI_PREDICTION_FIELDS = `
+  id assetId predictionType modelVersion score confidence recommendation status
+  features generatedAt workspaceId createdAt
+`;
+var PROVENANCE_RECORD_FIELDS = `
+  id assetId chainNetwork hash txHash blockNumber attestedBy attestedAt metadata
+  workspaceId createdAt
+`;
+var GET_ASSET = `
+  query AssetHandlerGetAsset($id: ID!) {
+    asset(id: $id) {
+      ${ASSET_FIELDS}
+    }
+  }
+`;
+var LIST_ASSETS = `
+  query AssetHandlerListAssets($pagination: AssetHandlerPaginationInput) {
+    assets(pagination: $pagination) {
+      ${ASSET_FIELDS}
+    }
+  }
+`;
+var CREATE_ASSET = `
+  mutation AssetHandlerCreateAsset($input: CreateAssetInput!) {
+    createAsset(input: $input) {
+      ${ASSET_FIELDS}
+    }
+  }
+`;
+var LIST_SOFTWARE_ASSETS = `
+  query AssetHandlerListSoftwareAssets($pagination: AssetHandlerPaginationInput) {
+    softwareAssets(pagination: $pagination) {
+      ${SOFTWARE_ASSET_FIELDS}
+    }
+  }
+`;
+var UPSERT_SOFTWARE_ASSET = `
+  mutation AssetHandlerUpsertSoftwareAsset($input: UpsertSoftwareAssetInput!) {
+    upsertSoftwareAsset(input: $input) {
+      ${SOFTWARE_ASSET_FIELDS}
+    }
+  }
+`;
+var LIST_CONFIGURATION_ITEMS = `
+  query AssetHandlerListConfigurationItems($pagination: AssetHandlerPaginationInput) {
+    configurationItems(pagination: $pagination) {
+      ${CONFIGURATION_ITEM_FIELDS}
+    }
+  }
+`;
+var UPSERT_CONFIGURATION_ITEM = `
+  mutation AssetHandlerUpsertConfigurationItem($input: UpsertConfigurationItemInput!) {
+    upsertConfigurationItem(input: $input) {
+      ${CONFIGURATION_ITEM_FIELDS}
+    }
+  }
+`;
+var LIST_DISCOVERY_JOBS = `
+  query AssetHandlerListDiscoveryJobs($pagination: AssetHandlerPaginationInput) {
+    discoveryJobs(pagination: $pagination) {
+      ${DISCOVERY_JOB_FIELDS}
+    }
+  }
+`;
+var START_DISCOVERY_JOB = `
+  mutation AssetHandlerStartDiscoveryJob($input: StartDiscoveryJobInput!) {
+    startDiscoveryJob(input: $input) {
+      ${DISCOVERY_JOB_FIELDS}
+    }
+  }
+`;
+var LIST_INCIDENTS = `
+  query AssetHandlerListIncidents($pagination: AssetHandlerPaginationInput) {
+    incidents(pagination: $pagination) {
+      ${INCIDENT_FIELDS}
+    }
+  }
+`;
+var CREATE_INCIDENT = `
+  mutation AssetHandlerCreateIncident($input: CreateIncidentInput!) {
+    createIncident(input: $input) {
+      ${INCIDENT_FIELDS}
+    }
+  }
+`;
+var LIST_PROBLEMS = `
+  query AssetHandlerListProblems($pagination: AssetHandlerPaginationInput) {
+    problems(pagination: $pagination) {
+      ${PROBLEM_FIELDS}
+    }
+  }
+`;
+var LIST_CHANGE_REQUESTS = `
+  query AssetHandlerListChangeRequests($pagination: AssetHandlerPaginationInput) {
+    changeRequests(pagination: $pagination) {
+      ${CHANGE_REQUEST_FIELDS}
+    }
+  }
+`;
+var LIST_WORK_ORDERS = `
+  query AssetHandlerListWorkOrders($pagination: AssetHandlerPaginationInput) {
+    workOrders(pagination: $pagination) {
+      ${WORK_ORDER_FIELDS}
+    }
+  }
+`;
+var CREATE_WORK_ORDER = `
+  mutation AssetHandlerCreateWorkOrder($input: CreateWorkOrderInput!) {
+    createWorkOrder(input: $input) {
+      ${WORK_ORDER_FIELDS}
+    }
+  }
+`;
+var LIST_MAINTENANCE_RECORDS = `
+  query AssetHandlerListMaintenanceRecords($pagination: AssetHandlerPaginationInput) {
+    maintenanceRecords(pagination: $pagination) {
+      ${MAINTENANCE_RECORD_FIELDS}
+    }
+  }
+`;
+var LIST_KNOWLEDGE_ARTICLES = `
+  query AssetHandlerListKnowledgeArticles($pagination: AssetHandlerPaginationInput) {
+    knowledgeArticles(pagination: $pagination) {
+      ${KNOWLEDGE_ARTICLE_FIELDS}
+    }
+  }
+`;
+var CREATE_KNOWLEDGE_ARTICLE = `
+  mutation AssetHandlerCreateKnowledgeArticle($input: CreateKnowledgeArticleInput!) {
+    createKnowledgeArticle(input: $input) {
+      ${KNOWLEDGE_ARTICLE_FIELDS}
+    }
+  }
+`;
+var LIST_BUDGETS = `
+  query AssetHandlerListBudgets($pagination: AssetHandlerPaginationInput) {
+    budgets(pagination: $pagination) {
+      ${BUDGET_FIELDS}
+    }
+  }
+`;
+var LIST_TRANSACTIONS = `
+  query AssetHandlerListTransactions($pagination: AssetHandlerPaginationInput) {
+    transactions(pagination: $pagination) {
+      ${TRANSACTION_FIELDS}
+    }
+  }
+`;
+var CREATE_TRANSACTION = `
+  mutation AssetHandlerCreateTransaction($input: CreateTransactionInput!) {
+    createTransaction(input: $input) {
+      ${TRANSACTION_FIELDS}
+    }
+  }
+`;
+var LIST_INVOICES = `
+  query AssetHandlerListInvoices($pagination: AssetHandlerPaginationInput) {
+    invoices(pagination: $pagination) {
+      ${INVOICE_FIELDS}
+    }
+  }
+`;
+var LIST_COMPLIANCE_FRAMEWORKS = `
+  query AssetHandlerListComplianceFrameworks($pagination: AssetHandlerPaginationInput) {
+    complianceFrameworks(pagination: $pagination) {
+      ${COMPLIANCE_FRAMEWORK_FIELDS}
+    }
+  }
+`;
+var LIST_SECURITY_POLICIES = `
+  query AssetHandlerListSecurityPolicies($pagination: AssetHandlerPaginationInput) {
+    assetSecurityPolicies(pagination: $pagination) {
+      ${SECURITY_POLICY_FIELDS}
+    }
+  }
+`;
+var LIST_SECURITY_EVENTS = `
+  query AssetHandlerListSecurityEvents($pagination: AssetHandlerPaginationInput) {
+    securityEvents(pagination: $pagination) {
+      ${SECURITY_EVENT_FIELDS}
+    }
+  }
+`;
+var LIST_ESG_METRICS = `
+  query AssetHandlerListEsgMetrics($pagination: AssetHandlerPaginationInput) {
+    esgMetrics(pagination: $pagination) {
+      ${ESG_METRIC_FIELDS}
+    }
+  }
+`;
+var UPSERT_ESG_METRIC = `
+  mutation AssetHandlerUpsertEsgMetric($input: UpsertEsgMetricInput!) {
+    upsertEsgMetric(input: $input) {
+      ${ESG_METRIC_FIELDS}
+    }
+  }
+`;
+var LIST_DIGITAL_TWINS = `
+  query AssetHandlerListDigitalTwins($pagination: AssetHandlerPaginationInput) {
+    digitalTwins(pagination: $pagination) {
+      ${DIGITAL_TWIN_FIELDS}
+    }
+  }
+`;
+var CREATE_DIGITAL_TWIN = `
+  mutation AssetHandlerCreateDigitalTwin($input: CreateDigitalTwinInput!) {
+    createDigitalTwin(input: $input) {
+      ${DIGITAL_TWIN_FIELDS}
+    }
+  }
+`;
+var LIST_IOT_DEVICES = `
+  query AssetHandlerListIotDevices($pagination: AssetHandlerPaginationInput) {
+    iotDevices(pagination: $pagination) {
+      ${IOT_DEVICE_FIELDS}
+    }
+  }
+`;
+var REGISTER_IOT_DEVICE = `
+  mutation AssetHandlerRegisterIoTDevice($input: RegisterIoTDeviceInput!) {
+    registerIoTDevice(input: $input) {
+      ${IOT_DEVICE_FIELDS}
+    }
+  }
+`;
+var LIST_AI_PREDICTIONS = `
+  query AssetHandlerListAiPredictions($pagination: AssetHandlerPaginationInput) {
+    aiPredictions(pagination: $pagination) {
+      ${AI_PREDICTION_FIELDS}
+    }
+  }
+`;
+var REQUEST_AI_PREDICTION = `
+  mutation AssetHandlerRequestAIPrediction($input: RequestAIPredictionInput!) {
+    requestAIPrediction(input: $input) {
+      ${AI_PREDICTION_FIELDS}
+    }
+  }
+`;
+var LIST_PROVENANCE_RECORDS = `
+  query AssetHandlerListProvenanceRecords($pagination: AssetHandlerPaginationInput) {
+    provenanceRecords(pagination: $pagination) {
+      ${PROVENANCE_RECORD_FIELDS}
+    }
+  }
+`;
+var RECORD_PROVENANCE = `
+  mutation AssetHandlerRecordProvenance($input: RecordProvenanceInput!) {
+    recordProvenance(input: $input) {
+      ${PROVENANCE_RECORD_FIELDS}
+    }
+  }
+`;
+var DASHBOARD_OVERVIEW = `
+  query AssetHandlerDashboardOverview {
+    dashboardOverview {
+      totalAssets
+      totalTransactions
+      openIncidents
+      openWorkOrders
+    }
+  }
+`;
+var AssetConditionEnum = z.enum(["DAMAGED", "EXCELLENT", "FAIR", "GOOD", "POOR"]).describe("Physical condition of an asset");
+var AssetStatusEnum = z.enum(["ACTIVE", "DISPOSED", "INACTIVE", "MAINTENANCE", "RETIRED"]).describe("Lifecycle status of an asset");
+var PriorityEnum = z.enum(["CRITICAL", "HIGH", "LOW", "MEDIUM"]).describe("Priority of an incident or work order");
+var KnowledgeArticleStatusEnum = z.enum(["ARCHIVED", "DRAFT", "PUBLISHED"]).describe("Publication status of a knowledge article");
+var TransactionTypeEnum = z.enum(["DISPOSAL", "LEASE", "MAINTENANCE", "PURCHASE", "TRANSFER"]).describe("Category of an asset financial transaction");
+var TransactionStatusEnum = z.enum(["APPROVED", "COMPLETED", "PENDING", "REJECTED"]).describe("Approval status of a transaction");
+var WorkOrderTypeEnum = z.enum(["CORRECTIVE", "EMERGENCY", "PREDICTIVE", "PREVENTIVE"]).describe("Type of maintenance work order");
+var WorkOrderStatusEnum = z.enum(["APPROVED", "CANCELLED", "COMPLETED", "DRAFT", "IN_PROGRESS", "SCHEDULED"]).describe("Lifecycle status of a work order");
+var JsonObject = z.record(z.string(), z.unknown());
+var PaginationArgs = {
+  limit: z.number().int().optional().describe("Page size (server-clamped to \u2264100)"),
+  cursor: z.string().optional().describe("Opaque cursor \u2014 the `id` returned from the previous page")
+};
+function buildPagination(limit, cursor) {
+  const pagination = {};
+  if (limit !== void 0) pagination.limit = limit;
+  if (cursor !== void 0) pagination.cursor = cursor;
+  return Object.keys(pagination).length > 0 ? pagination : void 0;
+}
+
+// src/modules/assethandler/tools/assets.ts
+function registerAssetTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "assets_get")),
+    {
+      title: "Get Asset",
+      description: "Fetch a single asset by ID from the bound workspace.",
+      inputSchema: { id: z.string().describe("Asset ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_ASSET, { id });
+        if (!data.asset) return errorResult(`Asset ${id} not found`);
+        return jsonResult(data.asset);
+      } catch (error) {
+        ctx.logger.error("assethandler assets_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get asset: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "assets_list")),
+    {
+      title: "List Assets",
+      description: "List assets in the bound workspace with cursor-based pagination ({ limit, cursor }).",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ASSETS, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.assets);
+      } catch (error) {
+        ctx.logger.error("assethandler assets_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list assets: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "assets_create")),
+    {
+      title: "Create Asset",
+      description: "Register a new asset. `assetNumber`, `name`, and `category` are required; `condition`/`status` default server-side.",
+      inputSchema: {
+        assetNumber: z.string().min(1).describe("Unique asset/tag number"),
+        name: z.string().min(1).describe("Asset display name"),
+        category: z.string().min(1).describe("Asset category (free-form)"),
+        condition: AssetConditionEnum.optional().describe("Physical condition"),
+        status: AssetStatusEnum.optional().describe("Lifecycle status"),
+        description: z.string().optional().describe("Asset description"),
+        serialNumber: z.string().optional().describe("Manufacturer serial number"),
+        locationName: z.string().optional().describe("Physical location name"),
+        assignedTo: z.string().optional().describe("User/owner the asset is assigned to"),
+        tags: z.array(z.string()).optional().describe("Free-form tags"),
+        customAttributes: JsonObject.optional().describe("Arbitrary custom attribute JSON")
+      }
+    },
+    async ({
+      assetNumber,
+      name,
+      category,
+      condition,
+      status,
+      description,
+      serialNumber,
+      locationName,
+      assignedTo,
+      tags,
+      customAttributes
+    }) => {
+      try {
+        const input = { assetNumber, name, category };
+        if (condition !== void 0) input.condition = condition;
+        if (status !== void 0) input.status = status;
+        if (description !== void 0) input.description = description;
+        if (serialNumber !== void 0) input.serialNumber = serialNumber;
+        if (locationName !== void 0) input.locationName = locationName;
+        if (assignedTo !== void 0) input.assignedTo = assignedTo;
+        if (tags !== void 0) input.tags = tags;
+        if (customAttributes !== void 0) input.customAttributes = customAttributes;
+        const data = await ctx.gql.workspace.request(CREATE_ASSET, { input });
+        return jsonResult(data.createAsset);
+      } catch (error) {
+        ctx.logger.error("assethandler assets_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create asset: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "software_list")),
+    {
+      title: "List Software Assets",
+      description: "List software-license assets with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SOFTWARE_ASSETS, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.softwareAssets);
+      } catch (error) {
+        ctx.logger.error("assethandler software_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list software assets: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "software_upsert")),
+    {
+      title: "Upsert Software Asset",
+      description: "Create or update a software-license asset. Provide `id` to update an existing record; omit it to create.",
+      inputSchema: {
+        name: z.string().min(1).describe("Software product name"),
+        vendor: z.string().min(1).describe("Software vendor"),
+        version: z.string().min(1).describe("Version string"),
+        licenseType: z.string().min(1).describe("License type (e.g. perpetual, subscription)"),
+        id: z.string().optional().describe("Existing software-asset ID (omit to create)"),
+        seatsPurchased: z.number().int().optional().describe("Number of seats purchased"),
+        seatsUsed: z.number().int().optional().describe("Number of seats in use")
+      }
+    },
+    async ({ name, vendor, version, licenseType, id, seatsPurchased, seatsUsed }) => {
+      try {
+        const input = { name, vendor, version, licenseType };
+        if (id !== void 0) input.id = id;
+        if (seatsPurchased !== void 0) input.seatsPurchased = seatsPurchased;
+        if (seatsUsed !== void 0) input.seatsUsed = seatsUsed;
+        const data = await ctx.gql.workspace.request(UPSERT_SOFTWARE_ASSET, { input });
+        return jsonResult(data.upsertSoftwareAsset);
+      } catch (error) {
+        ctx.logger.error("assethandler software_upsert failed", { error: String(error) });
+        return errorResult(
+          `Failed to upsert software asset: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "configuration_list")),
+    {
+      title: "List Configuration Items",
+      description: "List CMDB configuration items with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_CONFIGURATION_ITEMS, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.configurationItems);
+      } catch (error) {
+        ctx.logger.error("assethandler configuration_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list configuration items: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "configuration_upsert")),
+    {
+      title: "Upsert Configuration Item",
+      description: "Create or update a CMDB configuration item. Provide `id` to update an existing CI; omit it to create.",
+      inputSchema: {
+        ciNumber: z.string().min(1).describe("Unique CI number"),
+        ciType: z.string().min(1).describe("CI type (e.g. server, database, application)"),
+        name: z.string().min(1).describe("CI display name"),
+        status: z.string().min(1).describe("CI status (free-form)"),
+        id: z.string().optional().describe("Existing CI ID (omit to create)"),
+        environment: z.string().optional().describe("Environment (e.g. prod, staging)"),
+        owner: z.string().optional().describe("Owning user/team"),
+        attributes: JsonObject.optional().describe("Arbitrary CI attribute JSON")
+      }
+    },
+    async ({ ciNumber, ciType, name, status, id, environment, owner, attributes }) => {
+      try {
+        const input = { ciNumber, ciType, name, status };
+        if (id !== void 0) input.id = id;
+        if (environment !== void 0) input.environment = environment;
+        if (owner !== void 0) input.owner = owner;
+        if (attributes !== void 0) input.attributes = attributes;
+        const data = await ctx.gql.workspace.request(UPSERT_CONFIGURATION_ITEM, { input });
+        return jsonResult(data.upsertConfigurationItem);
+      } catch (error) {
+        ctx.logger.error("assethandler configuration_upsert failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to upsert configuration item: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "discovery_list")),
+    {
+      title: "List Discovery Jobs",
+      description: "List asset-discovery jobs with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_DISCOVERY_JOBS, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.discoveryJobs);
+      } catch (error) {
+        ctx.logger.error("assethandler discovery_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list discovery jobs: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "discovery_start")),
+    {
+      title: "Start Discovery Job",
+      description: "Kick off an asset-discovery job against a named source.",
+      inputSchema: {
+        name: z.string().min(1).describe("Discovery job name"),
+        source: z.string().min(1).describe("Discovery source (e.g. network range, cloud account)")
+      }
+    },
+    async ({ name, source }) => {
+      try {
+        const data = await ctx.gql.workspace.request(START_DISCOVERY_JOB, { input: { name, source } });
+        return jsonResult(data.startDiscoveryJob);
+      } catch (error) {
+        ctx.logger.error("assethandler discovery_start failed", { error: String(error) });
+        return errorResult(
+          `Failed to start discovery job: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerServiceTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "incidents_list")),
+    {
+      title: "List Incidents",
+      description: "List service incidents with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_INCIDENTS, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.incidents);
+      } catch (error) {
+        ctx.logger.error("assethandler incidents_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list incidents: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "incidents_create")),
+    {
+      title: "Create Incident",
+      description: "Open a new service incident. `title`, `description`, and `category` are required; optionally link an asset and set priority.",
+      inputSchema: {
+        title: z.string().min(1).describe("Incident title"),
+        description: z.string().min(1).describe("Incident description"),
+        category: z.string().min(1).describe("Incident category (free-form)"),
+        priority: PriorityEnum.optional().describe("Incident priority"),
+        assetId: z.string().optional().describe("Related asset ID"),
+        assignedTo: z.string().optional().describe("Assignee user ID")
+      }
+    },
+    async ({ title, description, category, priority, assetId, assignedTo }) => {
+      try {
+        const input = { title, description, category };
+        if (priority !== void 0) input.priority = priority;
+        if (assetId !== void 0) input.assetId = assetId;
+        if (assignedTo !== void 0) input.assignedTo = assignedTo;
+        const data = await ctx.gql.workspace.request(CREATE_INCIDENT, { input });
+        return jsonResult(data.createIncident);
+      } catch (error) {
+        ctx.logger.error("assethandler incidents_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create incident: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "problems_list")),
+    {
+      title: "List Problems",
+      description: "List problem records (root-cause investigations) with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PROBLEMS, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.problems);
+      } catch (error) {
+        ctx.logger.error("assethandler problems_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list problems: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "changes_list")),
+    {
+      title: "List Change Requests",
+      description: "List change requests with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_CHANGE_REQUESTS, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.changeRequests);
+      } catch (error) {
+        ctx.logger.error("assethandler changes_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list change requests: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "work_orders_list")),
+    {
+      title: "List Work Orders",
+      description: "List maintenance work orders with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_WORK_ORDERS, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.workOrders);
+      } catch (error) {
+        ctx.logger.error("assethandler work_orders_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list work orders: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "work_orders_create")),
+    {
+      title: "Create Work Order",
+      description: "Create a maintenance work order. `title` and `type` are required; optionally link an asset, assign it, and set priority/status.",
+      inputSchema: {
+        title: z.string().min(1).describe("Work order title"),
+        type: WorkOrderTypeEnum.describe("Work order type"),
+        description: z.string().optional().describe("Work order description"),
+        priority: PriorityEnum.optional().describe("Work order priority"),
+        status: WorkOrderStatusEnum.optional().describe("Initial status"),
+        assetId: z.string().optional().describe("Related asset ID"),
+        assignedTo: z.string().optional().describe("Assignee user ID")
+      }
+    },
+    async ({ title, type, description, priority, status, assetId, assignedTo }) => {
+      try {
+        const input = { title, type };
+        if (description !== void 0) input.description = description;
+        if (priority !== void 0) input.priority = priority;
+        if (status !== void 0) input.status = status;
+        if (assetId !== void 0) input.assetId = assetId;
+        if (assignedTo !== void 0) input.assignedTo = assignedTo;
+        const data = await ctx.gql.workspace.request(CREATE_WORK_ORDER, { input });
+        return jsonResult(data.createWorkOrder);
+      } catch (error) {
+        ctx.logger.error("assethandler work_orders_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create work order: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "maintenance_list")),
+    {
+      title: "List Maintenance Records",
+      description: "List asset maintenance records with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MAINTENANCE_RECORDS, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.maintenanceRecords);
+      } catch (error) {
+        ctx.logger.error("assethandler maintenance_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list maintenance records: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "knowledge_list")),
+    {
+      title: "List Knowledge Articles",
+      description: "List knowledge-base articles with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_KNOWLEDGE_ARTICLES, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.knowledgeArticles);
+      } catch (error) {
+        ctx.logger.error("assethandler knowledge_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list knowledge articles: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "knowledge_create")),
+    {
+      title: "Create Knowledge Article",
+      description: "Author a knowledge-base article. `title`, `slug`, and `content` are required; `slug` must be unique. Optionally link an asset/incident and set publication status.",
+      inputSchema: {
+        title: z.string().min(1).describe("Article title"),
+        slug: z.string().min(1).describe("URL slug, unique within the workspace"),
+        content: z.string().min(1).describe("Article body (markdown/plain)"),
+        summary: z.string().optional().describe("Short summary"),
+        status: KnowledgeArticleStatusEnum.optional().describe("Publication status"),
+        tags: z.array(z.string()).optional().describe("Free-form tags"),
+        relatedAssetId: z.string().optional().describe("Related asset ID"),
+        relatedIncidentId: z.string().optional().describe("Related incident ID")
+      }
+    },
+    async ({ title, slug, content, summary, status, tags, relatedAssetId, relatedIncidentId }) => {
+      try {
+        const input = { title, slug, content };
+        if (summary !== void 0) input.summary = summary;
+        if (status !== void 0) input.status = status;
+        if (tags !== void 0) input.tags = tags;
+        if (relatedAssetId !== void 0) input.relatedAssetId = relatedAssetId;
+        if (relatedIncidentId !== void 0) input.relatedIncidentId = relatedIncidentId;
+        const data = await ctx.gql.workspace.request(CREATE_KNOWLEDGE_ARTICLE, { input });
+        return jsonResult(data.createKnowledgeArticle);
+      } catch (error) {
+        ctx.logger.error("assethandler knowledge_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create knowledge article: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerFinanceTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "finance_budgets")),
+    {
+      title: "List Asset Budgets",
+      description: "List asset budgets with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_BUDGETS, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.budgets);
+      } catch (error) {
+        ctx.logger.error("assethandler finance_budgets failed", { error: String(error) });
+        return errorResult(
+          `Failed to list budgets: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "finance_transactions")),
+    {
+      title: "List Transactions",
+      description: "List asset financial transactions with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_TRANSACTIONS, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.transactions);
+      } catch (error) {
+        ctx.logger.error("assethandler finance_transactions failed", { error: String(error) });
+        return errorResult(
+          `Failed to list transactions: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "finance_create_transaction")),
+    {
+      title: "Create Transaction",
+      description: "Record an asset financial transaction. `amount`, `category`, `description`, and `type` are required.",
+      inputSchema: {
+        amount: z.number().describe("Transaction amount"),
+        category: z.string().min(1).describe("Transaction category (free-form)"),
+        description: z.string().min(1).describe("Transaction description"),
+        type: TransactionTypeEnum.describe("Transaction type"),
+        currency: z.string().optional().describe("ISO currency code (defaults server-side)"),
+        department: z.string().optional().describe("Owning department"),
+        status: TransactionStatusEnum.optional().describe("Approval status"),
+        vendor: z.string().optional().describe("Vendor name")
+      }
+    },
+    async ({ amount, category, description, type, currency, department, status, vendor }) => {
+      try {
+        const input = { amount, category, description, type };
+        if (currency !== void 0) input.currency = currency;
+        if (department !== void 0) input.department = department;
+        if (status !== void 0) input.status = status;
+        if (vendor !== void 0) input.vendor = vendor;
+        const data = await ctx.gql.workspace.request(CREATE_TRANSACTION, { input });
+        return jsonResult(data.createTransaction);
+      } catch (error) {
+        ctx.logger.error("assethandler finance_create_transaction failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to create transaction: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "finance_invoices")),
+    {
+      title: "List Invoices",
+      description: "List vendor invoices with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_INVOICES, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.invoices);
+      } catch (error) {
+        ctx.logger.error("assethandler finance_invoices failed", { error: String(error) });
+        return errorResult(
+          `Failed to list invoices: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerGovernanceTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "compliance_frameworks")),
+    {
+      title: "List Compliance Frameworks",
+      description: "List compliance frameworks and their control scores with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_COMPLIANCE_FRAMEWORKS, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.complianceFrameworks);
+      } catch (error) {
+        ctx.logger.error("assethandler compliance_frameworks failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to list compliance frameworks: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "security_policies")),
+    {
+      title: "List Security Policies",
+      description: "List asset-security policies with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SECURITY_POLICIES, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.assetSecurityPolicies);
+      } catch (error) {
+        ctx.logger.error("assethandler security_policies failed", { error: String(error) });
+        return errorResult(
+          `Failed to list security policies: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "security_events")),
+    {
+      title: "List Security Events",
+      description: "List security events with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SECURITY_EVENTS, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.securityEvents);
+      } catch (error) {
+        ctx.logger.error("assethandler security_events failed", { error: String(error) });
+        return errorResult(
+          `Failed to list security events: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "esg_list")),
+    {
+      title: "List ESG Metrics",
+      description: "List ESG (environmental/social/governance) metrics with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ESG_METRICS, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.esgMetrics);
+      } catch (error) {
+        ctx.logger.error("assethandler esg_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list ESG metrics: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "esg_upsert")),
+    {
+      title: "Upsert ESG Metric",
+      description: "Record or update an ESG metric data point for a reporting period. `metricKey` + period identify the metric.",
+      inputSchema: {
+        category: z.string().min(1).describe("ESG category (Environmental/Social/Governance)"),
+        metricKey: z.string().min(1).describe("Stable metric key"),
+        metricName: z.string().min(1).describe("Human-readable metric name"),
+        value: z.number().describe("Measured value"),
+        unit: z.string().min(1).describe("Unit of measure"),
+        periodStart: z.string().describe("Reporting-period start (ISO DateTime)"),
+        periodEnd: z.string().describe("Reporting-period end (ISO DateTime)"),
+        target: z.number().optional().describe("Target value"),
+        trend: z.string().optional().describe("Trend indicator (e.g. up, down, flat)")
+      }
+    },
+    async ({
+      category,
+      metricKey,
+      metricName,
+      value,
+      unit,
+      periodStart,
+      periodEnd,
+      target,
+      trend
+    }) => {
+      try {
+        const input = {
+          category,
+          metricKey,
+          metricName,
+          value,
+          unit,
+          periodStart,
+          periodEnd
+        };
+        if (target !== void 0) input.target = target;
+        if (trend !== void 0) input.trend = trend;
+        const data = await ctx.gql.workspace.request(UPSERT_ESG_METRIC, { input });
+        return jsonResult(data.upsertEsgMetric);
+      } catch (error) {
+        ctx.logger.error("assethandler esg_upsert failed", { error: String(error) });
+        return errorResult(
+          `Failed to upsert ESG metric: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerInnovationTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "digital_twins_list")),
+    {
+      title: "List Digital Twins",
+      description: "List asset digital twins with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_DIGITAL_TWINS, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.digitalTwins);
+      } catch (error) {
+        ctx.logger.error("assethandler digital_twins_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list digital twins: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "digital_twins_create")),
+    {
+      title: "Create Digital Twin",
+      description: "Create a digital twin for an asset. `assetId`, `fidelityLevel`, and `modelRef` are required.",
+      inputSchema: {
+        assetId: z.string().min(1).describe("Asset ID this twin models"),
+        fidelityLevel: z.string().min(1).describe("Fidelity level (e.g. low, medium, high)"),
+        modelRef: z.string().min(1).describe("Reference/URI of the 3D/simulation model"),
+        geometryRef: z.string().optional().describe("Reference/URI of the geometry asset"),
+        properties: JsonObject.optional().describe("Arbitrary twin property JSON")
+      }
+    },
+    async ({ assetId, fidelityLevel, modelRef, geometryRef, properties }) => {
+      try {
+        const input = { assetId, fidelityLevel, modelRef };
+        if (geometryRef !== void 0) input.geometryRef = geometryRef;
+        if (properties !== void 0) input.properties = properties;
+        const data = await ctx.gql.workspace.request(CREATE_DIGITAL_TWIN, { input });
+        return jsonResult(data.createDigitalTwin);
+      } catch (error) {
+        ctx.logger.error("assethandler digital_twins_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create digital twin: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "iot_list")),
+    {
+      title: "List IoT Devices",
+      description: "List registered IoT devices with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_IOT_DEVICES, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.iotDevices);
+      } catch (error) {
+        ctx.logger.error("assethandler iot_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list IoT devices: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "iot_register")),
+    {
+      title: "Register IoT Device",
+      description: "Register an IoT device. `deviceId`, `name`, `protocol`, and `type` are required; optionally link an asset.",
+      inputSchema: {
+        deviceId: z.string().min(1).describe("Stable device identifier"),
+        name: z.string().min(1).describe("Device display name"),
+        protocol: z.string().min(1).describe("Comms protocol (e.g. MQTT, CoAP, Modbus)"),
+        type: z.string().min(1).describe("Device type (free-form)"),
+        status: z.string().optional().describe("Initial status (free-form)"),
+        assetId: z.string().optional().describe("Asset this device is attached to"),
+        metadata: JsonObject.optional().describe("Arbitrary device metadata JSON")
+      }
+    },
+    async ({ deviceId, name, protocol, type, status, assetId, metadata }) => {
+      try {
+        const input = { deviceId, name, protocol, type };
+        if (status !== void 0) input.status = status;
+        if (assetId !== void 0) input.assetId = assetId;
+        if (metadata !== void 0) input.metadata = metadata;
+        const data = await ctx.gql.workspace.request(REGISTER_IOT_DEVICE, { input });
+        return jsonResult(data.registerIoTDevice);
+      } catch (error) {
+        ctx.logger.error("assethandler iot_register failed", { error: String(error) });
+        return errorResult(
+          `Failed to register IoT device: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "predictions_list")),
+    {
+      title: "List AI Predictions",
+      description: "List AI asset predictions with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_AI_PREDICTIONS, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.aiPredictions);
+      } catch (error) {
+        ctx.logger.error("assethandler predictions_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list AI predictions: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "predictions_request")),
+    {
+      title: "Request AI Prediction",
+      description: "Request an AI prediction for an asset. `assetId` and `predictionType` are required; optionally supply a feature vector.",
+      inputSchema: {
+        assetId: z.string().min(1).describe("Asset ID to predict on"),
+        predictionType: z.string().min(1).describe("Prediction type (e.g. failure, depreciation, utilization)"),
+        featureVector: JsonObject.optional().describe("Optional feature-vector JSON")
+      }
+    },
+    async ({ assetId, predictionType, featureVector }) => {
+      try {
+        const input = { assetId, predictionType };
+        if (featureVector !== void 0) input.featureVector = featureVector;
+        const data = await ctx.gql.workspace.request(REQUEST_AI_PREDICTION, { input });
+        return jsonResult(data.requestAIPrediction);
+      } catch (error) {
+        ctx.logger.error("assethandler predictions_request failed", { error: String(error) });
+        return errorResult(
+          `Failed to request AI prediction: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "provenance_list")),
+    {
+      title: "List Provenance Records",
+      description: "List blockchain provenance-attestation records with cursor-based pagination.",
+      inputSchema: { ...PaginationArgs }
+    },
+    async ({ limit, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PROVENANCE_RECORDS, { pagination: buildPagination(limit, cursor) });
+        return jsonResult(data.provenanceRecords);
+      } catch (error) {
+        ctx.logger.error("assethandler provenance_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list provenance records: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "provenance_record")),
+    {
+      title: "Record Provenance",
+      description: "Attest an asset provenance record on-chain. `assetId`, `chainNetwork`, and `hash` are required.",
+      inputSchema: {
+        assetId: z.string().min(1).describe("Asset ID being attested"),
+        chainNetwork: z.string().min(1).describe("Chain network (e.g. ethereum, polygon)"),
+        hash: z.string().min(1).describe("Attestation hash"),
+        blockNumber: z.number().int().optional().describe("Block number"),
+        txHash: z.string().optional().describe("Transaction hash"),
+        metadata: JsonObject.optional().describe("Arbitrary attestation metadata JSON")
+      }
+    },
+    async ({ assetId, chainNetwork, hash, blockNumber, txHash, metadata }) => {
+      try {
+        const input = { assetId, chainNetwork, hash };
+        if (blockNumber !== void 0) input.blockNumber = blockNumber;
+        if (txHash !== void 0) input.txHash = txHash;
+        if (metadata !== void 0) input.metadata = metadata;
+        const data = await ctx.gql.workspace.request(RECORD_PROVENANCE, { input });
+        return jsonResult(data.recordProvenance);
+      } catch (error) {
+        ctx.logger.error("assethandler provenance_record failed", { error: String(error) });
+        return errorResult(
+          `Failed to record provenance: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/assethandler/tools/analytics.ts
+function registerAnalyticsTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "dashboard_overview")),
+    {
+      title: "AssetHandler Dashboard Overview",
+      description: "Headline asset-management KPIs: total assets, total transactions, open incidents, and open work orders.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(DASHBOARD_OVERVIEW, {});
+        return jsonResult(data.dashboardOverview);
+      } catch (error) {
+        ctx.logger.error("assethandler dashboard_overview failed", { error: String(error) });
+        return errorResult(
+          `Failed to get dashboard overview: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/assethandler/resources.ts
+function registerAssetHandlerResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const dashboardUri = track(mcpResourceUri(ctx.productName, "dashboard"));
+  const assetsUri = track(mcpResourceUri(ctx.productName, "assets"));
+  const incidentsUri = track(mcpResourceUri(ctx.productName, "incidents"));
+  server.registerResource(
+    "assethandler-schema",
+    schemaUri,
+    {
+      title: "AssetHandler Domain Schema",
+      description: "Overview of the AssetHandler enterprise-asset / ITSM / ITAM domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# AssetHandler Domain (Overview)
+
+Enterprise asset management + IT service management (ITSM) + IT asset
+management (ITAM) platform.
+
+## Entities
+- Asset \u2014 the core asset register (category, condition, status, custom attributes)
+- SoftwareAsset \u2014 software-license assets (seats, compliance)
+- ConfigurationItem \u2014 CMDB configuration items
+- DiscoveryJob \u2014 automated asset-discovery runs
+- Incident / Problem / ChangeRequest \u2014 ITSM tickets
+- WorkOrder / MaintenanceRecord \u2014 maintenance management
+- KnowledgeArticle \u2014 knowledge base
+- AssetBudget / Transaction / Invoice \u2014 asset finance
+- ComplianceFramework / AssetSecurityPolicy / SecurityEvent \u2014 governance, risk & compliance
+- EsgMetric \u2014 ESG reporting
+- DigitalTwin / IoTDevice / AIPrediction / ProvenanceRecord \u2014 advanced (twins, IoT, AI, blockchain)
+
+## Enums (input-bearing)
+- AssetCondition: DAMAGED, EXCELLENT, FAIR, GOOD, POOR
+- AssetStatus: ACTIVE, DISPOSED, INACTIVE, MAINTENANCE, RETIRED
+- Priority: CRITICAL, HIGH, LOW, MEDIUM
+- KnowledgeArticleStatus: ARCHIVED, DRAFT, PUBLISHED
+- TransactionType: DISPOSAL, LEASE, MAINTENANCE, PURCHASE, TRANSFER
+- TransactionStatus: APPROVED, COMPLETED, PENDING, REJECTED
+- WorkOrderType: CORRECTIVE, EMERGENCY, PREDICTIVE, PREVENTIVE
+- WorkOrderStatus: APPROVED, CANCELLED, COMPLETED, DRAFT, IN_PROGRESS, SCHEDULED
+
+## Tool groups
+assets, service (ITSM), finance, governance, innovation, analytics.
+All run against the WORKSPACE gateway (workspace-scoped). List tools use
+cursor-based pagination ({ limit, cursor }). There is no public health probe.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "assethandler-dashboard",
+    dashboardUri,
+    {
+      title: "AssetHandler Dashboard Overview",
+      description: "Live headline KPIs (total assets, total transactions, open incidents, open work orders).",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${dashboardUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          DASHBOARD_OVERVIEW,
+          {}
+        );
+        return {
+          contents: [
+            {
+              uri: dashboardUri,
+              text: JSON.stringify(data.dashboardOverview, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: dashboardUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "assethandler-assets",
+    assetsUri,
+    {
+      title: "AssetHandler Asset Register",
+      description: "The first 50 assets in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${assetsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ASSETS, {
+          pagination: { limit: 50 }
+        });
+        return {
+          contents: [
+            {
+              uri: assetsUri,
+              text: JSON.stringify(data.assets, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: assetsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "assethandler-incidents",
+    incidentsUri,
+    {
+      title: "AssetHandler Incident Queue",
+      description: "The first 50 service incidents in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${incidentsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_INCIDENTS, {
+          pagination: { limit: 50 }
+        });
+        return {
+          contents: [
+            {
+              uri: incidentsUri,
+              text: JSON.stringify(data.incidents, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: incidentsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerAssetHandlerPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const onboardingName = track(mcpPromptName(p, "asset-onboarding"));
+  const opsName = track(mcpPromptName(p, "itsm-ops"));
+  server.registerPrompt(
+    onboardingName,
+    {
+      title: "Asset Onboarding",
+      description: "Guide for onboarding a new asset end to end: register the asset, attach a CMDB configuration item, optionally a digital twin / IoT device, and seed a maintenance/work-order baseline.",
+      argsSchema: {
+        name: z.string().optional().describe("Asset name"),
+        category: z.string().optional().describe("Asset category")
+      }
+    },
+    ({ name, category }) => {
+      ctx.logger.debug(`Prompt ${onboardingName} called`, { name, category });
+      const nameNote = name ? `Use the asset name "${name}".` : "Ask the user for the asset name.";
+      const categoryNote = category ? `Use category "${category}".` : "Help the user pick a category.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me onboard a new AssetHandler asset.
+
+1. **Register Asset**: Use ${p}_assets_create. ${nameNote} ${categoryNote} Provide a unique assetNumber; optionally set condition/status, serialNumber, locationName, assignedTo, tags, and customAttributes.
+2. **CMDB**: Use ${p}_configuration_upsert to register a matching configuration item (ciNumber, ciType, status) if the asset is an IT CI.
+3. **(Optional) Digital Twin**: Use ${p}_digital_twins_create with the new assetId, a fidelityLevel, and a modelRef.
+4. **(Optional) IoT Device**: Use ${p}_iot_register to attach a sensor/device (deviceId, name, protocol, type) to the asset.
+5. **Baseline Maintenance**: Use ${p}_work_orders_create (type=PREVENTIVE) to seed a preventive-maintenance work order.
+6. **Verify**: Use ${p}_assets_get to confirm the asset, then ${p}_assets_list to see it in the register.
+
+Show results at each step and confirm before creating downstream records.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    opsName,
+    {
+      title: "ITSM Operations",
+      description: "Daily IT service-management workflow: review KPIs, triage incidents, advance work orders, check problems/changes, and review compliance posture.",
+      argsSchema: {
+        focus: z.string().optional().describe("Optional area to focus on (incidents/maintenance/compliance)")
+      }
+    },
+    ({ focus }) => {
+      ctx.logger.debug(`Prompt ${opsName} called`, { focus });
+      const focusNote = focus ? `Focus this run on: ${focus}.` : "Cover all areas below.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run daily AssetHandler ITSM operations. ${focusNote}
+
+1. **KPIs**: Use ${p}_dashboard_overview for headline numbers (assets, transactions, open incidents, open work orders).
+2. **Incident Triage**: Use ${p}_incidents_list to find open incidents; open new ones with ${p}_incidents_create as needed.
+3. **Problems & Changes**: Use ${p}_problems_list and ${p}_changes_list to review root-cause work and pending changes.
+4. **Maintenance**: Use ${p}_work_orders_list and ${p}_maintenance_list to check the maintenance backlog; create work orders with ${p}_work_orders_create.
+5. **Knowledge**: Use ${p}_knowledge_list; document recurring fixes with ${p}_knowledge_create.
+6. **Governance**: Use ${p}_compliance_frameworks, ${p}_security_policies, and ${p}_security_events to review compliance/security posture.
+
+Summarize what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/assethandler/index.ts
+var assethandlerModule = {
+  id: "assethandler",
+  version: "0.0.1",
+  displayName: "AssetHandler",
+  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;
+    };
+    registerAssetTools(server, ctx, trackTool);
+    registerServiceTools(server, ctx, trackTool);
+    registerFinanceTools(server, ctx, trackTool);
+    registerGovernanceTools(server, ctx, trackTool);
+    registerInnovationTools(server, ctx, trackTool);
+    registerAnalyticsTools(server, ctx, trackTool);
+    registerAssetHandlerResources(server, ctx, trackResource);
+    registerAssetHandlerPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var assethandler_default = assethandlerModule;
+
+export { assethandler_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map