@burdenoff/mcp-libs 2026.627.6 → 2026.629.1

package/dist/modules/subscriberbot/index.cjs

@@ -0,0 +1,2037 @@
+'use strict';
+
+require('graphql-request');
+require('cross-fetch');
+require('@modelcontextprotocol/sdk/server/mcp.js');
+require('@modelcontextprotocol/sdk/types.js');
+var zod = require('zod');
+
+// src/core/auth/store.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/subscriberbot/operations.ts
+var PROVIDER_FIELDS = `
+  id name slug description category status industry region language
+  logoFileId websiteUrl tags churnRiskScore vendorHealthScore
+  workspaceId createdAt updatedAt
+`;
+var PLAN_FIELDS = `
+  id name description amount currency interval features isActive
+  providerId workspaceId createdAt updatedAt
+`;
+var ENTITLEMENT_FIELDS = `
+  id name description type quota used unit isActive
+  relationshipId workspaceId createdAt updatedAt
+`;
+var ASSET_FIELDS = `
+  id name type secretRef expiresAt relationshipId workspaceId
+  createdAt updatedAt file { id }
+`;
+var RENEWAL_EVENT_FIELDS = `
+  id eventType detail amount currency occursAt notified
+  relationshipId workspaceId createdAt updatedAt
+`;
+var RELATIONSHIP_FIELDS = `
+  id label kind status amount currency interval autoRenew discoverySource
+  healthScore notes tags providerId planId ownerId startedAt renewsAt
+  trialEndsAt cancelledAt workspaceId createdAt updatedAt
+`;
+var PAYMENT_INSTRUMENT_FIELDS = `
+  id label type status brand last4 expiryMonth expiryYear isDefault
+  ownerId workspaceId createdAt updatedAt
+`;
+var INVOICE_FIELDS = `
+  id number status currency subtotal taxAmount total issueDate dueDate
+  paidAt lineItems paymentInstrumentId relationshipId workspaceId
+  createdAt updatedAt file { id }
+`;
+var CHANNEL_FIELDS = `
+  id type status address label ingestEnabled verifiedAt
+  ownerId workspaceId createdAt updatedAt
+`;
+var INBOX_MESSAGE_FIELDS = `
+  id subject preview category categoryConfidence actionRequired isRead
+  externalId receivedAt channelId relationshipId workspaceId
+  createdAt updatedAt
+`;
+var AGENT_FIELDS = `
+  id name description kind status config lastRunAt
+  ownerId workspaceId createdAt updatedAt
+`;
+var POLICY_FIELDS = `
+  id name description action condition isEnabled triggerCount
+  lastTriggeredAt agentId workspaceId createdAt updatedAt
+`;
+var WORKFLOW_FIELDS = `
+  id name description status triggerEvent steps runCount lastRunAt
+  workspaceId createdAt updatedAt
+`;
+var GET_PROVIDER = `
+  query SubscriberbotGetProvider($id: ID!) {
+    subProvider(id: $id) {
+      ${PROVIDER_FIELDS}
+      plans { ${PLAN_FIELDS} }
+    }
+  }
+`;
+var LIST_PROVIDERS = `
+  query SubscriberbotListProviders(
+    $category: SubProviderCategory
+    $status: SubProviderStatus
+    $search: String
+    $pagination: PaginationInput
+  ) {
+    subListProviders(
+      category: $category
+      status: $status
+      search: $search
+      pagination: $pagination
+    ) {
+      items { ${PROVIDER_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_PROVIDER = `
+  mutation SubscriberbotCreateProvider($input: SubCreateProviderInput!) {
+    subCreateProvider(input: $input) {
+      ${PROVIDER_FIELDS}
+    }
+  }
+`;
+var UPDATE_PROVIDER = `
+  mutation SubscriberbotUpdateProvider($id: ID!, $input: SubUpdateProviderInput!) {
+    subUpdateProvider(id: $id, input: $input) {
+      ${PROVIDER_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_PROVIDER = `
+  mutation SubscriberbotArchiveProvider($id: ID!) {
+    subArchiveProvider(id: $id)
+  }
+`;
+var LIST_PLANS = `
+  query SubscriberbotListPlans($providerId: ID) {
+    subListPlans(providerId: $providerId) {
+      ${PLAN_FIELDS}
+    }
+  }
+`;
+var CREATE_PLAN = `
+  mutation SubscriberbotCreatePlan($input: SubCreatePlanInput!) {
+    subCreatePlan(input: $input) {
+      ${PLAN_FIELDS}
+    }
+  }
+`;
+var GET_RELATIONSHIP = `
+  query SubscriberbotGetRelationship($id: ID!) {
+    subRelationship(id: $id) {
+      ${RELATIONSHIP_FIELDS}
+      provider { id name slug category status }
+      plan { id name amount currency interval }
+      entitlements { ${ENTITLEMENT_FIELDS} }
+      assets { ${ASSET_FIELDS} }
+      renewalEvents { ${RENEWAL_EVENT_FIELDS} }
+    }
+  }
+`;
+var LIST_RELATIONSHIPS = `
+  query SubscriberbotListRelationships(
+    $kind: SubRelationshipKind
+    $status: SubRelationshipStatus
+    $ownerId: ID
+    $providerId: ID
+    $pagination: PaginationInput
+  ) {
+    subListRelationships(
+      kind: $kind
+      status: $status
+      ownerId: $ownerId
+      providerId: $providerId
+      pagination: $pagination
+    ) {
+      items { ${RELATIONSHIP_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_RELATIONSHIP = `
+  mutation SubscriberbotCreateRelationship($input: SubCreateRelationshipInput!) {
+    subCreateRelationship(input: $input) {
+      ${RELATIONSHIP_FIELDS}
+    }
+  }
+`;
+var UPDATE_RELATIONSHIP = `
+  mutation SubscriberbotUpdateRelationship($id: ID!, $input: SubUpdateRelationshipInput!) {
+    subUpdateRelationship(id: $id, input: $input) {
+      ${RELATIONSHIP_FIELDS}
+    }
+  }
+`;
+var CANCEL_RELATIONSHIP = `
+  mutation SubscriberbotCancelRelationship($id: ID!) {
+    subCancelRelationship(id: $id) {
+      ${RELATIONSHIP_FIELDS}
+    }
+  }
+`;
+var TRANSITION_RELATIONSHIP = `
+  mutation SubscriberbotTransitionRelationship($id: ID!, $status: SubRelationshipStatus!) {
+    subTransitionRelationship(id: $id, status: $status) {
+      ${RELATIONSHIP_FIELDS}
+    }
+  }
+`;
+var LIST_ENTITLEMENTS = `
+  query SubscriberbotListEntitlements($relationshipId: ID!) {
+    subListEntitlements(relationshipId: $relationshipId) {
+      ${ENTITLEMENT_FIELDS}
+    }
+  }
+`;
+var CREATE_ENTITLEMENT = `
+  mutation SubscriberbotCreateEntitlement($input: SubCreateEntitlementInput!) {
+    subCreateEntitlement(input: $input) {
+      ${ENTITLEMENT_FIELDS}
+    }
+  }
+`;
+var LIST_ASSETS = `
+  query SubscriberbotListAssets($relationshipId: ID!) {
+    subListAssets(relationshipId: $relationshipId) {
+      ${ASSET_FIELDS}
+    }
+  }
+`;
+var CREATE_ASSET = `
+  mutation SubscriberbotCreateAsset($input: SubCreateAssetInput!) {
+    subCreateAsset(input: $input) {
+      ${ASSET_FIELDS}
+    }
+  }
+`;
+var LIST_RENEWAL_EVENTS = `
+  query SubscriberbotListRenewalEvents($relationshipId: ID, $upcomingOnly: Boolean) {
+    subListRenewalEvents(relationshipId: $relationshipId, upcomingOnly: $upcomingOnly) {
+      ${RENEWAL_EVENT_FIELDS}
+    }
+  }
+`;
+var LIST_PAYMENT_INSTRUMENTS = `
+  query SubscriberbotListPaymentInstruments($ownerId: ID) {
+    subListPaymentInstruments(ownerId: $ownerId) {
+      ${PAYMENT_INSTRUMENT_FIELDS}
+    }
+  }
+`;
+var CREATE_PAYMENT_INSTRUMENT = `
+  mutation SubscriberbotCreatePaymentInstrument($input: SubCreatePaymentInstrumentInput!) {
+    subCreatePaymentInstrument(input: $input) {
+      ${PAYMENT_INSTRUMENT_FIELDS}
+    }
+  }
+`;
+var REMOVE_PAYMENT_INSTRUMENT = `
+  mutation SubscriberbotRemovePaymentInstrument($id: ID!) {
+    subRemovePaymentInstrument(id: $id)
+  }
+`;
+var LIST_INVOICES = `
+  query SubscriberbotListInvoices(
+    $relationshipId: ID
+    $status: SubInvoiceStatus
+    $pagination: PaginationInput
+  ) {
+    subListInvoices(relationshipId: $relationshipId, status: $status, pagination: $pagination) {
+      items { ${INVOICE_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_INVOICE = `
+  mutation SubscriberbotCreateInvoice($input: SubCreateInvoiceInput!) {
+    subCreateInvoice(input: $input) {
+      ${INVOICE_FIELDS}
+    }
+  }
+`;
+var MARK_INVOICE_PAID = `
+  mutation SubscriberbotMarkInvoicePaid($id: ID!) {
+    subMarkInvoicePaid(id: $id) {
+      ${INVOICE_FIELDS}
+    }
+  }
+`;
+var LIST_CHANNELS = `
+  query SubscriberbotListChannels($ownerId: ID) {
+    subListChannels(ownerId: $ownerId) {
+      ${CHANNEL_FIELDS}
+    }
+  }
+`;
+var CREATE_CHANNEL = `
+  mutation SubscriberbotCreateChannel($input: SubCreateChannelInput!) {
+    subCreateChannel(input: $input) {
+      ${CHANNEL_FIELDS}
+    }
+  }
+`;
+var VERIFY_CHANNEL = `
+  mutation SubscriberbotVerifyChannel($id: ID!) {
+    subVerifyChannel(id: $id) {
+      ${CHANNEL_FIELDS}
+    }
+  }
+`;
+var LIST_INBOX_MESSAGES = `
+  query SubscriberbotListInboxMessages(
+    $category: SubMessageCategory
+    $channelId: ID
+    $relationshipId: ID
+    $unreadOnly: Boolean
+    $pagination: PaginationInput
+  ) {
+    subListInboxMessages(
+      category: $category
+      channelId: $channelId
+      relationshipId: $relationshipId
+      unreadOnly: $unreadOnly
+      pagination: $pagination
+    ) {
+      items { ${INBOX_MESSAGE_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var INGEST_MESSAGE = `
+  mutation SubscriberbotIngestMessage($input: SubIngestMessageInput!) {
+    subIngestMessage(input: $input) {
+      ${INBOX_MESSAGE_FIELDS}
+    }
+  }
+`;
+var MARK_MESSAGE_READ = `
+  mutation SubscriberbotMarkMessageRead($id: ID!) {
+    subMarkMessageRead(id: $id) {
+      ${INBOX_MESSAGE_FIELDS}
+    }
+  }
+`;
+var GET_AGENT = `
+  query SubscriberbotGetAgent($id: ID!) {
+    subAgent(id: $id) {
+      ${AGENT_FIELDS}
+      policies { ${POLICY_FIELDS} }
+    }
+  }
+`;
+var LIST_AGENTS = `
+  query SubscriberbotListAgents($kind: SubAgentKind, $ownerId: ID, $status: SubAgentStatus) {
+    subListAgents(kind: $kind, ownerId: $ownerId, status: $status) {
+      ${AGENT_FIELDS}
+    }
+  }
+`;
+var CREATE_AGENT = `
+  mutation SubscriberbotCreateAgent($input: SubCreateAgentInput!) {
+    subCreateAgent(input: $input) {
+      ${AGENT_FIELDS}
+    }
+  }
+`;
+var SET_AGENT_STATUS = `
+  mutation SubscriberbotSetAgentStatus($id: ID!, $status: SubAgentStatus!) {
+    subSetAgentStatus(id: $id, status: $status) {
+      ${AGENT_FIELDS}
+    }
+  }
+`;
+var LIST_POLICIES = `
+  query SubscriberbotListPolicies($agentId: ID) {
+    subListPolicies(agentId: $agentId) {
+      ${POLICY_FIELDS}
+    }
+  }
+`;
+var CREATE_POLICY = `
+  mutation SubscriberbotCreatePolicy($input: SubCreatePolicyInput!) {
+    subCreatePolicy(input: $input) {
+      ${POLICY_FIELDS}
+    }
+  }
+`;
+var LIST_WORKFLOWS = `
+  query SubscriberbotListWorkflows($status: SubWorkflowStatus) {
+    subListWorkflows(status: $status) {
+      ${WORKFLOW_FIELDS}
+    }
+  }
+`;
+var CREATE_WORKFLOW = `
+  mutation SubscriberbotCreateWorkflow($input: SubCreateWorkflowInput!) {
+    subCreateWorkflow(input: $input) {
+      ${WORKFLOW_FIELDS}
+    }
+  }
+`;
+var ACTIVATE_WORKFLOW = `
+  mutation SubscriberbotActivateWorkflow($id: ID!) {
+    subActivateWorkflow(id: $id) {
+      ${WORKFLOW_FIELDS}
+    }
+  }
+`;
+var HEALTH = `
+  query SubscriberbotHealth {
+    subHealth
+  }
+`;
+var SubAgentKindEnum = zod.z.enum([
+  "COMPLIANCE",
+  "CONCIERGE",
+  "COST",
+  "DISCOVERY",
+  "MIGRATION",
+  "NEGOTIATION",
+  "NEWSLETTER",
+  "RENEWAL",
+  "VENDOR"
+]).describe("The specialised role of an AI agent");
+var SubAgentStatusEnum = zod.z.enum(["AUTONOMOUS", "DISABLED", "SUGGEST_ONLY"]).describe("An agent's operating posture");
+var SubAssetTypeEnum = zod.z.enum([
+  "CERTIFICATE",
+  "CONTRACT",
+  "CREDENTIAL",
+  "DOMAIN",
+  "INVOICE",
+  "LICENSE_KEY",
+  "RECEIPT",
+  "WARRANTY"
+]).describe("The kind of asset attached to a relationship");
+var SubBillingIntervalEnum = zod.z.enum(["DAILY", "FREE", "LIFETIME", "MONTHLY", "QUARTERLY", "USAGE_BASED", "WEEKLY", "YEARLY"]).describe("Billing cadence of a plan or relationship");
+zod.z.enum(["DISABLED", "PENDING", "VERIFIED"]).describe("Verification status of a communication channel");
+var SubChannelTypeEnum = zod.z.enum(["DISCORD", "EMAIL", "PUSH", "SLACK", "SMS", "WEBHOOK", "WHATSAPP"]).describe("Transport type of a communication channel");
+var SubDiscoverySourceEnum = zod.z.enum(["AI_AGENT", "EMAIL_SCAN", "IMPORT", "MANUAL", "PAYMENT_SCAN", "PROVIDER_CONNECT"]).describe("How a relationship was discovered");
+var SubEntitlementTypeEnum = zod.z.enum(["CONTENT", "DISCOUNT", "FEATURE_ACCESS", "SEAT", "SUPPORT_TIER", "USAGE_QUOTA"]).describe("The kind of entitlement granted by a relationship");
+var SubInvoiceStatusEnum = zod.z.enum(["CANCELLED", "DRAFT", "FAILED", "ISSUED", "OVERDUE", "PAID", "REFUNDED"]).describe("Lifecycle status of an invoice");
+var SubMessageCategoryEnum = zod.z.enum([
+  "BILLING",
+  "MARKETING",
+  "OTHER",
+  "PRODUCT_UPDATE",
+  "RENEWAL",
+  "REQUIRED_ACTION",
+  "SECURITY_ALERT"
+]).describe("Classification of a universal-inbox message");
+zod.z.enum(["ACTIVE", "EXPIRED", "EXPIRING", "REMOVED"]).describe("Status of a payment instrument");
+var SubPaymentInstrumentTypeEnum = zod.z.enum(["BANK_ACCOUNT", "CARD", "OTHER", "PAYPAL", "UPI", "WALLET"]).describe("Type of a payment instrument");
+var SubPolicyActionEnum = zod.z.enum(["ALERT", "CANCEL", "CREATE_TASK", "DOWNGRADE", "PAUSE", "RENEW", "UPGRADE"]).describe("The action an autonomous policy takes when triggered");
+var SubProviderCategoryEnum = zod.z.enum([
+  "AI_SERVICE",
+  "ASSOCIATION",
+  "COMMUNITY",
+  "CONTRACT",
+  "EDUCATION",
+  "FINANCIAL",
+  "INSURANCE",
+  "LICENSE",
+  "MEMBERSHIP",
+  "NEWSLETTER",
+  "NEWS_DIGEST",
+  "OTHER",
+  "SAAS",
+  "STREAMING",
+  "TELECOM",
+  "UTILITY"
+]).describe("Category of a provider in the global registry");
+var SubProviderStatusEnum = zod.z.enum(["CLAIMED", "DEPRECATED", "UNVERIFIED", "VERIFIED"]).describe("Lifecycle/trust status of a provider");
+var SubRelationshipKindEnum = zod.z.enum([
+  "CONTRACT",
+  "ENROLLMENT",
+  "LICENSE",
+  "MEMBERSHIP",
+  "NEWSLETTER",
+  "RECURRING_PAYMENT",
+  "SUBSCRIPTION",
+  "TRIAL"
+]).describe("The kind of recurring relationship");
+var SubRelationshipStatusEnum = zod.z.enum(["ACTIVE", "CANCELLED", "EXPIRED", "LAPSED", "PAST_DUE", "PAUSED", "TRIAL"]).describe("Lifecycle status of a relationship");
+var SubWorkflowStatusEnum = zod.z.enum(["ACTIVE", "ARCHIVED", "DRAFT", "PAUSED"]).describe("Lifecycle status of an automation workflow");
+var JsonObject = zod.z.record(zod.z.string(), zod.z.unknown());
+var JsonValue = zod.z.union([JsonObject, zod.z.array(zod.z.unknown())]);
+function registerProviderTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "providers_get")),
+    {
+      title: "Get Provider",
+      description: "Fetch a single provider from the global registry by ID, including its plans.",
+      inputSchema: { id: zod.z.string().describe("Provider ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PROVIDER, { id });
+        if (!data.subProvider) return errorResult(`Provider ${id} not found`);
+        return jsonResult(data.subProvider);
+      } catch (error) {
+        ctx.logger.error("subscriberbot providers_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get provider: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "providers_list")),
+    {
+      title: "List Providers",
+      description: "Discovery: search/browse the global provider registry with optional category/status/text filters and pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        category: SubProviderCategoryEnum.optional().describe("Filter by category"),
+        status: SubProviderStatusEnum.optional().describe("Filter by trust/lifecycle status"),
+        search: zod.z.string().optional().describe("Free-text search across provider name/description"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ category, status, search, limit, offset, cursor }) => {
+      try {
+        const pagination = {};
+        if (limit !== void 0) pagination.limit = limit;
+        if (offset !== void 0) pagination.offset = offset;
+        if (cursor !== void 0) pagination.cursor = cursor;
+        const data = await ctx.gql.workspace.request(
+          LIST_PROVIDERS,
+          {
+            category,
+            status,
+            search,
+            pagination: Object.keys(pagination).length > 0 ? pagination : void 0
+          }
+        );
+        return jsonResult(data.subListProviders);
+      } catch (error) {
+        ctx.logger.error("subscriberbot providers_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list providers: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "providers_create")),
+    {
+      title: "Create Provider",
+      description: "Register a new provider in the global registry. Only `name` is required; `slug` should be unique within the workspace.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Provider display name"),
+        slug: zod.z.string().optional().describe("URL slug, unique within the workspace"),
+        category: SubProviderCategoryEnum.optional().describe("Provider category (default OTHER)"),
+        status: SubProviderStatusEnum.optional().describe(
+          "Trust/lifecycle status (default UNVERIFIED)"
+        ),
+        description: zod.z.string().optional().describe("Provider description"),
+        industry: zod.z.string().optional().describe("Industry"),
+        region: zod.z.string().optional().describe("Region"),
+        language: zod.z.string().optional().describe("Primary language"),
+        websiteUrl: zod.z.string().optional().describe("Provider website URL"),
+        logoFileId: zod.z.string().optional().describe("wspace-files-svc File ID for the logo"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({
+      name,
+      slug,
+      category,
+      status,
+      description,
+      industry,
+      region,
+      language,
+      websiteUrl,
+      logoFileId,
+      tags
+    }) => {
+      try {
+        const input = { name };
+        if (slug !== void 0) input.slug = slug;
+        if (category !== void 0) input.category = category;
+        if (status !== void 0) input.status = status;
+        if (description !== void 0) input.description = description;
+        if (industry !== void 0) input.industry = industry;
+        if (region !== void 0) input.region = region;
+        if (language !== void 0) input.language = language;
+        if (websiteUrl !== void 0) input.websiteUrl = websiteUrl;
+        if (logoFileId !== void 0) input.logoFileId = logoFileId;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_PROVIDER, { input });
+        return jsonResult(data.subCreateProvider);
+      } catch (error) {
+        ctx.logger.error("subscriberbot providers_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create provider: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "providers_update")),
+    {
+      title: "Update Provider",
+      description: "Update a provider. At least one mutable field must be provided. Use `status` to verify/claim/deprecate; set churn/vendor-health scores for vendor intelligence.",
+      inputSchema: {
+        id: zod.z.string().describe("Provider ID"),
+        name: zod.z.string().optional().describe("Updated display name"),
+        slug: zod.z.string().optional().describe("Updated slug"),
+        category: SubProviderCategoryEnum.optional().describe("Updated category"),
+        status: SubProviderStatusEnum.optional().describe("Updated trust/lifecycle status"),
+        description: zod.z.string().optional().describe("Updated description"),
+        industry: zod.z.string().optional().describe("Updated industry"),
+        region: zod.z.string().optional().describe("Updated region"),
+        language: zod.z.string().optional().describe("Updated language"),
+        websiteUrl: zod.z.string().optional().describe("Updated website URL"),
+        logoFileId: zod.z.string().optional().describe("Updated logo File ID"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags"),
+        churnRiskScore: zod.z.number().int().optional().describe("Churn-risk score (0-100)"),
+        vendorHealthScore: zod.z.number().int().optional().describe("Vendor-health score (0-100)")
+      }
+    },
+    async ({
+      id,
+      name,
+      slug,
+      category,
+      status,
+      description,
+      industry,
+      region,
+      language,
+      websiteUrl,
+      logoFileId,
+      tags,
+      churnRiskScore,
+      vendorHealthScore
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (slug !== void 0) input.slug = slug;
+        if (category !== void 0) input.category = category;
+        if (status !== void 0) input.status = status;
+        if (description !== void 0) input.description = description;
+        if (industry !== void 0) input.industry = industry;
+        if (region !== void 0) input.region = region;
+        if (language !== void 0) input.language = language;
+        if (websiteUrl !== void 0) input.websiteUrl = websiteUrl;
+        if (logoFileId !== void 0) input.logoFileId = logoFileId;
+        if (tags !== void 0) input.tags = tags;
+        if (churnRiskScore !== void 0) input.churnRiskScore = churnRiskScore;
+        if (vendorHealthScore !== void 0) input.vendorHealthScore = vendorHealthScore;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable provider field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_PROVIDER, { id, input });
+        return jsonResult(data.subUpdateProvider);
+      } catch (error) {
+        ctx.logger.error("subscriberbot providers_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update provider: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "providers_archive")),
+    {
+      title: "Archive Provider",
+      description: "Archive (soft-delete) a provider. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Provider ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_PROVIDER,
+          { id }
+        );
+        return jsonResult({ archived: data.subArchiveProvider, id });
+      } catch (error) {
+        ctx.logger.error("subscriberbot providers_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive provider: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerPlanTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "plans_list")),
+    {
+      title: "List Plans",
+      description: "List plans, optionally filtered by provider.",
+      inputSchema: {
+        providerId: zod.z.string().optional().describe("Filter by provider ID")
+      }
+    },
+    async ({ providerId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PLANS, { providerId });
+        return jsonResult(data.subListPlans);
+      } catch (error) {
+        ctx.logger.error("subscriberbot plans_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list plans: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "plans_create")),
+    {
+      title: "Create Plan",
+      description: "Create a plan for a provider.",
+      inputSchema: {
+        providerId: zod.z.string().min(1).describe("Provider ID this plan belongs to"),
+        name: zod.z.string().min(1).describe("Plan name"),
+        amount: zod.z.number().optional().describe("Plan amount"),
+        currency: zod.z.string().optional().describe("ISO currency code"),
+        interval: SubBillingIntervalEnum.optional().describe("Billing interval (default MONTHLY)"),
+        description: zod.z.string().optional().describe("Plan description"),
+        features: zod.z.array(zod.z.string()).optional().describe("Feature list")
+      }
+    },
+    async ({ providerId, name, amount, currency, interval, description, features }) => {
+      try {
+        const input = { providerId, name };
+        if (amount !== void 0) input.amount = amount;
+        if (currency !== void 0) input.currency = currency;
+        if (interval !== void 0) input.interval = interval;
+        if (description !== void 0) input.description = description;
+        if (features !== void 0) input.features = features;
+        const data = await ctx.gql.workspace.request(
+          CREATE_PLAN,
+          { input }
+        );
+        return jsonResult(data.subCreatePlan);
+      } catch (error) {
+        ctx.logger.error("subscriberbot plans_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create plan: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerRelationshipTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "relationships_get")),
+    {
+      title: "Get Relationship",
+      description: "Fetch a single relationship by ID, including its provider, plan, entitlements, assets, and renewal events.",
+      inputSchema: { id: zod.z.string().describe("Relationship ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_RELATIONSHIP, { id });
+        if (!data.subRelationship) return errorResult(`Relationship ${id} not found`);
+        return jsonResult(data.subRelationship);
+      } catch (error) {
+        ctx.logger.error("subscriberbot relationships_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get relationship: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "relationships_list")),
+    {
+      title: "List Relationships",
+      description: "List recurring relationships with optional kind/status/owner/provider filters and pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        kind: SubRelationshipKindEnum.optional().describe("Filter by relationship kind"),
+        status: SubRelationshipStatusEnum.optional().describe("Filter by lifecycle status"),
+        ownerId: zod.z.string().optional().describe("Filter by owner user ID"),
+        providerId: zod.z.string().optional().describe("Filter by provider ID"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ kind, status, ownerId, providerId, limit, offset, cursor }) => {
+      try {
+        const pagination = {};
+        if (limit !== void 0) pagination.limit = limit;
+        if (offset !== void 0) pagination.offset = offset;
+        if (cursor !== void 0) pagination.cursor = cursor;
+        const data = await ctx.gql.workspace.request(
+          LIST_RELATIONSHIPS,
+          {
+            kind,
+            status,
+            ownerId,
+            providerId,
+            pagination: Object.keys(pagination).length > 0 ? pagination : void 0
+          }
+        );
+        return jsonResult(data.subListRelationships);
+      } catch (error) {
+        ctx.logger.error("subscriberbot 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: "Create a recurring relationship (subscription / membership / license / contract). Only `label` is required.",
+      inputSchema: {
+        label: zod.z.string().min(1).describe("Human-readable label"),
+        kind: SubRelationshipKindEnum.optional().describe(
+          "Relationship kind (default SUBSCRIPTION)"
+        ),
+        status: SubRelationshipStatusEnum.optional().describe("Initial status (default ACTIVE)"),
+        providerId: zod.z.string().optional().describe("Provider ID"),
+        planId: zod.z.string().optional().describe("Plan ID"),
+        ownerId: zod.z.string().optional().describe("Owner user ID"),
+        amount: zod.z.number().optional().describe("Recurring amount"),
+        currency: zod.z.string().optional().describe("ISO currency code"),
+        interval: SubBillingIntervalEnum.optional().describe("Billing interval (default MONTHLY)"),
+        autoRenew: zod.z.boolean().optional().describe("Whether the relationship auto-renews (default true)"),
+        discoverySource: SubDiscoverySourceEnum.optional().describe(
+          "How it was discovered (default MANUAL)"
+        ),
+        notes: zod.z.string().optional().describe("Free-form notes"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Tags"),
+        startedAt: zod.z.string().optional().describe("Start datetime (ISO 8601)"),
+        renewsAt: zod.z.string().optional().describe("Next renewal datetime (ISO 8601)"),
+        trialEndsAt: zod.z.string().optional().describe("Trial-end datetime (ISO 8601)")
+      }
+    },
+    async (args) => {
+      try {
+        const input = { label: args.label };
+        const optional = [
+          "kind",
+          "status",
+          "providerId",
+          "planId",
+          "ownerId",
+          "amount",
+          "currency",
+          "interval",
+          "autoRenew",
+          "discoverySource",
+          "notes",
+          "tags",
+          "startedAt",
+          "renewsAt",
+          "trialEndsAt"
+        ];
+        for (const key of optional) {
+          if (args[key] !== void 0) input[key] = args[key];
+        }
+        const data = await ctx.gql.workspace.request(CREATE_RELATIONSHIP, { input });
+        return jsonResult(data.subCreateRelationship);
+      } catch (error) {
+        ctx.logger.error("subscriberbot relationships_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create relationship: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "relationships_update")),
+    {
+      title: "Update Relationship",
+      description: "Update a relationship. At least one mutable field must be provided.",
+      inputSchema: {
+        id: zod.z.string().describe("Relationship ID"),
+        label: zod.z.string().optional().describe("Updated label"),
+        kind: SubRelationshipKindEnum.optional().describe("Updated kind"),
+        providerId: zod.z.string().optional().describe("Updated provider ID"),
+        planId: zod.z.string().optional().describe("Updated plan ID"),
+        amount: zod.z.number().optional().describe("Updated amount"),
+        currency: zod.z.string().optional().describe("Updated currency"),
+        interval: SubBillingIntervalEnum.optional().describe("Updated billing interval"),
+        autoRenew: zod.z.boolean().optional().describe("Updated auto-renew flag"),
+        healthScore: zod.z.number().int().optional().describe("Relationship health score (0-100)"),
+        notes: zod.z.string().optional().describe("Updated notes"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags"),
+        startedAt: zod.z.string().optional().describe("Updated start datetime (ISO 8601)"),
+        renewsAt: zod.z.string().optional().describe("Updated renewal datetime (ISO 8601)"),
+        trialEndsAt: zod.z.string().optional().describe("Updated trial-end datetime (ISO 8601)")
+      }
+    },
+    async ({ id, ...rest }) => {
+      try {
+        const input = {};
+        for (const [key, value] of Object.entries(rest)) {
+          if (value !== void 0) input[key] = value;
+        }
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one mutable relationship field"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_RELATIONSHIP, { id, input });
+        return jsonResult(data.subUpdateRelationship);
+      } catch (error) {
+        ctx.logger.error("subscriberbot relationships_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update relationship: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "relationships_cancel")),
+    {
+      title: "Cancel Relationship",
+      description: "Cancel a relationship (sets status CANCELLED and stamps cancelledAt).",
+      inputSchema: { id: zod.z.string().describe("Relationship ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(CANCEL_RELATIONSHIP, { id });
+        return jsonResult(data.subCancelRelationship);
+      } catch (error) {
+        ctx.logger.error("subscriberbot relationships_cancel failed", { error: String(error) });
+        return errorResult(
+          `Failed to cancel relationship: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "relationships_transition")),
+    {
+      title: "Transition Relationship",
+      description: "Advance a relationship through its lifecycle with a validated status transition.",
+      inputSchema: {
+        id: zod.z.string().describe("Relationship ID"),
+        status: SubRelationshipStatusEnum.describe("Target lifecycle status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_RELATIONSHIP, { id, status });
+        return jsonResult(data.subTransitionRelationship);
+      } catch (error) {
+        ctx.logger.error("subscriberbot relationships_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition relationship: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerEntitlementTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "entitlements_list")),
+    {
+      title: "List Entitlements",
+      description: "List the entitlements granted by a relationship.",
+      inputSchema: { relationshipId: zod.z.string().describe("Relationship ID (required)") }
+    },
+    async ({ relationshipId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ENTITLEMENTS, { relationshipId });
+        return jsonResult(data.subListEntitlements);
+      } catch (error) {
+        ctx.logger.error("subscriberbot entitlements_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list entitlements: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "entitlements_create")),
+    {
+      title: "Create Entitlement",
+      description: "Add an entitlement to a relationship.",
+      inputSchema: {
+        relationshipId: zod.z.string().min(1).describe("Relationship ID"),
+        name: zod.z.string().min(1).describe("Entitlement name"),
+        type: SubEntitlementTypeEnum.optional().describe(
+          "Entitlement type (default FEATURE_ACCESS)"
+        ),
+        description: zod.z.string().optional().describe("Description"),
+        quota: zod.z.number().int().optional().describe("Quota count"),
+        unit: zod.z.string().optional().describe('Quota unit (e.g. "seats", "GB")')
+      }
+    },
+    async ({ relationshipId, name, type, description, quota, unit }) => {
+      try {
+        const input = { relationshipId, name };
+        if (type !== void 0) input.type = type;
+        if (description !== void 0) input.description = description;
+        if (quota !== void 0) input.quota = quota;
+        if (unit !== void 0) input.unit = unit;
+        const data = await ctx.gql.workspace.request(CREATE_ENTITLEMENT, { input });
+        return jsonResult(data.subCreateEntitlement);
+      } catch (error) {
+        ctx.logger.error("subscriberbot entitlements_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create entitlement: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerAssetTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "assets_list")),
+    {
+      title: "List Assets",
+      description: "List the assets attached to a relationship.",
+      inputSchema: { relationshipId: zod.z.string().describe("Relationship ID (required)") }
+    },
+    async ({ relationshipId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ASSETS, { relationshipId });
+        return jsonResult(data.subListAssets);
+      } catch (error) {
+        ctx.logger.error("subscriberbot 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: "Attach an asset to a relationship. `fileId` references a wspace-files-svc File; `secretRef` references a vault secret for credentials.",
+      inputSchema: {
+        relationshipId: zod.z.string().min(1).describe("Relationship ID"),
+        name: zod.z.string().min(1).describe("Asset name"),
+        type: SubAssetTypeEnum.optional().describe("Asset type (default RECEIPT)"),
+        fileId: zod.z.string().optional().describe("wspace-files-svc File ID"),
+        secretRef: zod.z.string().optional().describe("Vault secret reference for credentials"),
+        expiresAt: zod.z.string().optional().describe("Expiry datetime (ISO 8601)")
+      }
+    },
+    async ({ relationshipId, name, type, fileId, secretRef, expiresAt }) => {
+      try {
+        const input = { relationshipId, name };
+        if (type !== void 0) input.type = type;
+        if (fileId !== void 0) input.fileId = fileId;
+        if (secretRef !== void 0) input.secretRef = secretRef;
+        if (expiresAt !== void 0) input.expiresAt = expiresAt;
+        const data = await ctx.gql.workspace.request(CREATE_ASSET, { input });
+        return jsonResult(data.subCreateAsset);
+      } catch (error) {
+        ctx.logger.error("subscriberbot assets_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create asset: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerRenewalTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "renewal_events_list")),
+    {
+      title: "List Renewal Events",
+      description: "List renewal events, optionally scoped to a relationship and/or filtered to upcoming events only.",
+      inputSchema: {
+        relationshipId: zod.z.string().optional().describe("Filter by relationship ID"),
+        upcomingOnly: zod.z.boolean().optional().describe("Only return events that have not yet occurred")
+      }
+    },
+    async ({ relationshipId, upcomingOnly }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_RENEWAL_EVENTS, { relationshipId, upcomingOnly });
+        return jsonResult(data.subListRenewalEvents);
+      } catch (error) {
+        ctx.logger.error("subscriberbot renewals_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list renewal events: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerPaymentInstrumentTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "payment_instruments_list")),
+    {
+      title: "List Payment Instruments",
+      description: "List stored payment instruments, optionally filtered by owner.",
+      inputSchema: { ownerId: zod.z.string().optional().describe("Filter by owner user ID") }
+    },
+    async ({ ownerId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PAYMENT_INSTRUMENTS, { ownerId });
+        return jsonResult(data.subListPaymentInstruments);
+      } catch (error) {
+        ctx.logger.error("subscriberbot payment_instruments_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list payment instruments: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "payment_instruments_create")),
+    {
+      title: "Create Payment Instrument",
+      description: "Store a payment instrument. Never send raw card numbers \u2014 use `processorToken` from your PSP plus display-only fields (brand, last4, expiry).",
+      inputSchema: {
+        label: zod.z.string().min(1).describe('Display label (e.g. "Personal Visa")'),
+        type: SubPaymentInstrumentTypeEnum.optional().describe("Instrument type (default CARD)"),
+        ownerId: zod.z.string().optional().describe("Owner user ID"),
+        brand: zod.z.string().optional().describe('Card/wallet brand (e.g. "Visa")'),
+        last4: zod.z.string().optional().describe("Last 4 digits (display only)"),
+        expiryMonth: zod.z.number().int().optional().describe("Expiry month (1-12)"),
+        expiryYear: zod.z.number().int().optional().describe("Expiry year (4-digit)"),
+        isDefault: zod.z.boolean().optional().describe("Mark as the default instrument (default false)"),
+        processorToken: zod.z.string().optional().describe("Opaque PSP token (never a raw PAN)")
+      }
+    },
+    async ({
+      label,
+      type,
+      ownerId,
+      brand,
+      last4,
+      expiryMonth,
+      expiryYear,
+      isDefault,
+      processorToken
+    }) => {
+      try {
+        const input = { label };
+        if (type !== void 0) input.type = type;
+        if (ownerId !== void 0) input.ownerId = ownerId;
+        if (brand !== void 0) input.brand = brand;
+        if (last4 !== void 0) input.last4 = last4;
+        if (expiryMonth !== void 0) input.expiryMonth = expiryMonth;
+        if (expiryYear !== void 0) input.expiryYear = expiryYear;
+        if (isDefault !== void 0) input.isDefault = isDefault;
+        if (processorToken !== void 0) input.processorToken = processorToken;
+        const data = await ctx.gql.workspace.request(CREATE_PAYMENT_INSTRUMENT, { input });
+        return jsonResult(data.subCreatePaymentInstrument);
+      } catch (error) {
+        ctx.logger.error("subscriberbot payment_instruments_create failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to create payment instrument: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "payment_instruments_remove")),
+    {
+      title: "Remove Payment Instrument",
+      description: "Remove a stored payment instrument. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Payment instrument ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          REMOVE_PAYMENT_INSTRUMENT,
+          { id }
+        );
+        return jsonResult({ removed: data.subRemovePaymentInstrument, id });
+      } catch (error) {
+        ctx.logger.error("subscriberbot payment_instruments_remove failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to remove payment instrument: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerInvoiceTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "invoices_list")),
+    {
+      title: "List Invoices",
+      description: "List invoices with optional relationship/status filters and pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        relationshipId: zod.z.string().optional().describe("Filter by relationship ID"),
+        status: SubInvoiceStatusEnum.optional().describe("Filter by invoice status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ relationshipId, status, limit, offset, cursor }) => {
+      try {
+        const pagination = {};
+        if (limit !== void 0) pagination.limit = limit;
+        if (offset !== void 0) pagination.offset = offset;
+        if (cursor !== void 0) pagination.cursor = cursor;
+        const data = await ctx.gql.workspace.request(
+          LIST_INVOICES,
+          {
+            relationshipId,
+            status,
+            pagination: Object.keys(pagination).length > 0 ? pagination : void 0
+          }
+        );
+        return jsonResult(data.subListInvoices);
+      } catch (error) {
+        ctx.logger.error("subscriberbot invoices_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list invoices: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "invoices_create")),
+    {
+      title: "Create Invoice",
+      description: "Create an invoice against a relationship. `lineItems` is arbitrary JSON; `fileId` references a wspace-files-svc File holding the PDF.",
+      inputSchema: {
+        relationshipId: zod.z.string().min(1).describe("Relationship ID"),
+        number: zod.z.string().optional().describe("Invoice number"),
+        status: SubInvoiceStatusEnum.optional().describe("Invoice status (default ISSUED)"),
+        currency: zod.z.string().optional().describe("ISO currency code"),
+        subtotal: zod.z.number().optional().describe("Subtotal amount"),
+        taxAmount: zod.z.number().optional().describe("Tax amount"),
+        total: zod.z.number().optional().describe("Total amount"),
+        issueDate: zod.z.string().optional().describe("Issue datetime (ISO 8601)"),
+        dueDate: zod.z.string().optional().describe("Due datetime (ISO 8601)"),
+        lineItems: JsonValue.optional().describe("Line items as JSON (object or array)"),
+        paymentInstrumentId: zod.z.string().optional().describe("Payment instrument ID"),
+        fileId: zod.z.string().optional().describe("wspace-files-svc File ID for the invoice PDF")
+      }
+    },
+    async (args) => {
+      try {
+        const input = { relationshipId: args.relationshipId };
+        const optional = [
+          "number",
+          "status",
+          "currency",
+          "subtotal",
+          "taxAmount",
+          "total",
+          "issueDate",
+          "dueDate",
+          "lineItems",
+          "paymentInstrumentId",
+          "fileId"
+        ];
+        for (const key of optional) {
+          if (args[key] !== void 0) input[key] = args[key];
+        }
+        const data = await ctx.gql.workspace.request(CREATE_INVOICE, { input });
+        return jsonResult(data.subCreateInvoice);
+      } catch (error) {
+        ctx.logger.error("subscriberbot invoices_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create invoice: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "invoices_mark_paid")),
+    {
+      title: "Mark Invoice Paid",
+      description: "Mark an invoice as paid (sets status PAID and stamps paidAt).",
+      inputSchema: { id: zod.z.string().describe("Invoice ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(MARK_INVOICE_PAID, { id });
+        return jsonResult(data.subMarkInvoicePaid);
+      } catch (error) {
+        ctx.logger.error("subscriberbot invoices_mark_paid failed", { error: String(error) });
+        return errorResult(
+          `Failed to mark invoice paid: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerChannelTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "channels_list")),
+    {
+      title: "List Channels",
+      description: "List communication channels, optionally filtered by owner.",
+      inputSchema: { ownerId: zod.z.string().optional().describe("Filter by owner user ID") }
+    },
+    async ({ ownerId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_CHANNELS, { ownerId });
+        return jsonResult(data.subListChannels);
+      } catch (error) {
+        ctx.logger.error("subscriberbot channels_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list channels: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "channels_create")),
+    {
+      title: "Create Channel",
+      description: "Register a communication channel. `address` is the endpoint (email address, phone number, webhook URL, \u2026).",
+      inputSchema: {
+        address: zod.z.string().min(1).describe("Channel endpoint (email/phone/URL)"),
+        type: SubChannelTypeEnum.optional().describe("Channel type (default EMAIL)"),
+        label: zod.z.string().optional().describe("Display label"),
+        ownerId: zod.z.string().optional().describe("Owner user ID"),
+        ingestEnabled: zod.z.boolean().optional().describe("Whether inbound ingestion is enabled (default true)")
+      }
+    },
+    async ({ address, type, label, ownerId, ingestEnabled }) => {
+      try {
+        const input = { address };
+        if (type !== void 0) input.type = type;
+        if (label !== void 0) input.label = label;
+        if (ownerId !== void 0) input.ownerId = ownerId;
+        if (ingestEnabled !== void 0) input.ingestEnabled = ingestEnabled;
+        const data = await ctx.gql.workspace.request(CREATE_CHANNEL, { input });
+        return jsonResult(data.subCreateChannel);
+      } catch (error) {
+        ctx.logger.error("subscriberbot channels_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create channel: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "channels_verify")),
+    {
+      title: "Verify Channel",
+      description: "Mark a communication channel as verified (sets status VERIFIED, stamps verifiedAt).",
+      inputSchema: { id: zod.z.string().describe("Channel ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(VERIFY_CHANNEL, { id });
+        return jsonResult(data.subVerifyChannel);
+      } catch (error) {
+        ctx.logger.error("subscriberbot channels_verify failed", { error: String(error) });
+        return errorResult(
+          `Failed to verify channel: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerInboxTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "inbox_list")),
+    {
+      title: "List Inbox Messages",
+      description: "The Universal Inbox \u2014 list merged subscription communications with optional category/channel/relationship/unread filters and pagination. Returns a connection ({ items, pageInfo }).",
+      inputSchema: {
+        category: SubMessageCategoryEnum.optional().describe("Filter by message category"),
+        channelId: zod.z.string().optional().describe("Filter by source channel ID"),
+        relationshipId: zod.z.string().optional().describe("Filter by linked relationship ID"),
+        unreadOnly: zod.z.boolean().optional().describe("Only return unread messages"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ category, channelId, relationshipId, unreadOnly, limit, offset, cursor }) => {
+      try {
+        const pagination = {};
+        if (limit !== void 0) pagination.limit = limit;
+        if (offset !== void 0) pagination.offset = offset;
+        if (cursor !== void 0) pagination.cursor = cursor;
+        const data = await ctx.gql.workspace.request(
+          LIST_INBOX_MESSAGES,
+          {
+            category,
+            channelId,
+            relationshipId,
+            unreadOnly,
+            pagination: Object.keys(pagination).length > 0 ? pagination : void 0
+          }
+        );
+        return jsonResult(data.subListInboxMessages);
+      } catch (error) {
+        ctx.logger.error("subscriberbot inbox_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list inbox messages: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "inbox_ingest")),
+    {
+      title: "Ingest Inbox Message",
+      description: "Ingest a new communication into the universal inbox from a channel. `receivedAt` and `channelId` are required.",
+      inputSchema: {
+        channelId: zod.z.string().min(1).describe("Source channel ID"),
+        receivedAt: zod.z.string().describe("When the message was received (ISO 8601)"),
+        category: SubMessageCategoryEnum.optional().describe("Message category (default OTHER)"),
+        categoryConfidence: zod.z.number().int().optional().describe("Classifier confidence (0-100)"),
+        actionRequired: zod.z.boolean().optional().describe("Whether the message requires action (default false)"),
+        subject: zod.z.string().optional().describe("Message subject"),
+        preview: zod.z.string().optional().describe("Short preview/snippet"),
+        externalId: zod.z.string().optional().describe("External message ID (for de-dup)"),
+        relationshipId: zod.z.string().optional().describe("Linked relationship ID")
+      }
+    },
+    async (args) => {
+      try {
+        const input = {
+          channelId: args.channelId,
+          receivedAt: args.receivedAt
+        };
+        const optional = [
+          "category",
+          "categoryConfidence",
+          "actionRequired",
+          "subject",
+          "preview",
+          "externalId",
+          "relationshipId"
+        ];
+        for (const key of optional) {
+          if (args[key] !== void 0) input[key] = args[key];
+        }
+        const data = await ctx.gql.workspace.request(INGEST_MESSAGE, { input });
+        return jsonResult(data.subIngestMessage);
+      } catch (error) {
+        ctx.logger.error("subscriberbot inbox_ingest failed", { error: String(error) });
+        return errorResult(
+          `Failed to ingest message: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "inbox_mark_read")),
+    {
+      title: "Mark Message Read",
+      description: "Mark a universal-inbox message as read.",
+      inputSchema: { id: zod.z.string().describe("Inbox message ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(MARK_MESSAGE_READ, { id });
+        return jsonResult(data.subMarkMessageRead);
+      } catch (error) {
+        ctx.logger.error("subscriberbot inbox_mark_read failed", { error: String(error) });
+        return errorResult(
+          `Failed to mark message read: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerAgentTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "agents_get")),
+    {
+      title: "Get Agent",
+      description: "Fetch a single AI agent by ID, including its policies.",
+      inputSchema: { id: zod.z.string().describe("Agent ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_AGENT, { id });
+        if (!data.subAgent) return errorResult(`Agent ${id} not found`);
+        return jsonResult(data.subAgent);
+      } catch (error) {
+        ctx.logger.error("subscriberbot agents_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get agent: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "agents_list")),
+    {
+      title: "List Agents",
+      description: "List AI agents with optional kind/owner/status filters.",
+      inputSchema: {
+        kind: SubAgentKindEnum.optional().describe("Filter by agent kind"),
+        ownerId: zod.z.string().optional().describe("Filter by owner user ID"),
+        status: SubAgentStatusEnum.optional().describe("Filter by operating posture")
+      }
+    },
+    async ({ kind, ownerId, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_AGENTS, { kind, ownerId, status });
+        return jsonResult(data.subListAgents);
+      } catch (error) {
+        ctx.logger.error("subscriberbot agents_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list agents: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "agents_create")),
+    {
+      title: "Create Agent",
+      description: "Create an AI agent. Defaults to kind=DISCOVERY and status=SUGGEST_ONLY (no autonomous action until promoted).",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Agent name"),
+        kind: SubAgentKindEnum.optional().describe("Agent kind (default DISCOVERY)"),
+        status: SubAgentStatusEnum.optional().describe("Operating posture (default SUGGEST_ONLY)"),
+        description: zod.z.string().optional().describe("Agent description"),
+        ownerId: zod.z.string().optional().describe("Owner user ID"),
+        config: JsonObject.optional().describe("Agent configuration as JSON")
+      }
+    },
+    async ({ name, kind, status, description, ownerId, config }) => {
+      try {
+        const input = { name };
+        if (kind !== void 0) input.kind = kind;
+        if (status !== void 0) input.status = status;
+        if (description !== void 0) input.description = description;
+        if (ownerId !== void 0) input.ownerId = ownerId;
+        if (config !== void 0) input.config = config;
+        const data = await ctx.gql.workspace.request(CREATE_AGENT, { input });
+        return jsonResult(data.subCreateAgent);
+      } catch (error) {
+        ctx.logger.error("subscriberbot agents_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create agent: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "agents_set_status")),
+    {
+      title: "Set Agent Status",
+      description: "Change an agent's operating posture (DISABLED / SUGGEST_ONLY / AUTONOMOUS).",
+      inputSchema: {
+        id: zod.z.string().describe("Agent ID"),
+        status: SubAgentStatusEnum.describe("Target operating posture")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(SET_AGENT_STATUS, { id, status });
+        return jsonResult(data.subSetAgentStatus);
+      } catch (error) {
+        ctx.logger.error("subscriberbot agents_set_status failed", { error: String(error) });
+        return errorResult(
+          `Failed to set agent status: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerPolicyTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "policies_list")),
+    {
+      title: "List Policies",
+      description: "List autonomous policies, optionally filtered by agent.",
+      inputSchema: { agentId: zod.z.string().optional().describe("Filter by agent ID") }
+    },
+    async ({ agentId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_POLICIES, { agentId });
+        return jsonResult(data.subListPolicies);
+      } catch (error) {
+        ctx.logger.error("subscriberbot policies_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list policies: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "policies_create")),
+    {
+      title: "Create Policy",
+      description: "Create an autonomous policy for an agent. `condition` is arbitrary JSON evaluated to decide whether `action` fires.",
+      inputSchema: {
+        agentId: zod.z.string().min(1).describe("Agent ID this policy belongs to"),
+        name: zod.z.string().min(1).describe("Policy name"),
+        action: SubPolicyActionEnum.optional().describe("Action when triggered (default ALERT)"),
+        description: zod.z.string().optional().describe("Policy description"),
+        condition: JsonObject.optional().describe("Trigger condition as JSON"),
+        isEnabled: zod.z.boolean().optional().describe("Whether the policy is enabled (default true)")
+      }
+    },
+    async ({ agentId, name, action, description, condition, isEnabled }) => {
+      try {
+        const input = { agentId, name };
+        if (action !== void 0) input.action = action;
+        if (description !== void 0) input.description = description;
+        if (condition !== void 0) input.condition = condition;
+        if (isEnabled !== void 0) input.isEnabled = isEnabled;
+        const data = await ctx.gql.workspace.request(CREATE_POLICY, { input });
+        return jsonResult(data.subCreatePolicy);
+      } catch (error) {
+        ctx.logger.error("subscriberbot policies_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create policy: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerWorkflowTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workflows_list")),
+    {
+      title: "List Workflows",
+      description: "List automation workflows, optionally filtered by status.",
+      inputSchema: {
+        status: SubWorkflowStatusEnum.optional().describe("Filter by workflow status")
+      }
+    },
+    async ({ status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_WORKFLOWS, { status });
+        return jsonResult(data.subListWorkflows);
+      } catch (error) {
+        ctx.logger.error("subscriberbot workflows_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list workflows: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workflows_create")),
+    {
+      title: "Create Workflow",
+      description: "Create an event-triggered automation workflow. `triggerEvent` names the event; `steps` is arbitrary JSON describing the step graph.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Workflow name"),
+        triggerEvent: zod.z.string().min(1).describe("Event name that triggers the workflow"),
+        description: zod.z.string().optional().describe("Workflow description"),
+        steps: JsonValue.optional().describe("Step definition as JSON (object or array)")
+      }
+    },
+    async ({ name, triggerEvent, description, steps }) => {
+      try {
+        const input = { name, triggerEvent };
+        if (description !== void 0) input.description = description;
+        if (steps !== void 0) input.steps = steps;
+        const data = await ctx.gql.workspace.request(CREATE_WORKFLOW, { input });
+        return jsonResult(data.subCreateWorkflow);
+      } catch (error) {
+        ctx.logger.error("subscriberbot workflows_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create workflow: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workflows_activate")),
+    {
+      title: "Activate Workflow",
+      description: "Activate a workflow (sets status ACTIVE).",
+      inputSchema: { id: zod.z.string().describe("Workflow ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(ACTIVATE_WORKFLOW, { id });
+        return jsonResult(data.subActivateWorkflow);
+      } catch (error) {
+        ctx.logger.error("subscriberbot workflows_activate failed", { error: String(error) });
+        return errorResult(
+          `Failed to activate workflow: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/subscriberbot/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "Subscriber Bot Health Check",
+      description: "Public liveness/identity probe for the Subscriber Bot subgraph (subHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.subHealth });
+      } catch (error) {
+        ctx.logger.error("subscriberbot health failed", { error: String(error) });
+        return errorResult(
+          `Subscriber Bot health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/subscriberbot/resources.ts
+function registerSubscriberbotResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const providersUri = track(mcpResourceUri(ctx.productName, "providers"));
+  const relationshipsUri = track(mcpResourceUri(ctx.productName, "relationships"));
+  const inboxUri = track(mcpResourceUri(ctx.productName, "inbox"));
+  server.registerResource(
+    "subscriberbot-schema",
+    schemaUri,
+    {
+      title: "Subscriber Bot Domain Schema",
+      description: "Overview of the Subscriber Bot domain \u2014 the Universal Digital Relationship OS: entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# Subscriber Bot Domain (Overview)
+
+The Universal Digital Relationship Operating System \u2014 system of record for every
+recurring digital relationship.
+
+## Entities
+- SubProvider \u2014 a provider in the global discovery registry (has plans)
+- SubPlan \u2014 a provider's pricing plan
+- SubRelationship \u2014 the core object: a subscription / membership / license / contract
+- SubEntitlement \u2014 what a relationship grants (seats, quotas, feature access, \u2026)
+- SubAsset \u2014 documents/credentials attached to a relationship (refs wspace-files File)
+- SubRenewalEvent \u2014 renewal / trial-end / price-change / cancellation timeline events
+- SubPaymentInstrument \u2014 stored card / bank / wallet (universal billing layer)
+- SubInvoice \u2014 invoice ledger entry (refs wspace-files File for the PDF)
+- SubCommunicationChannel \u2014 inbound/outbound channel feeding the inbox
+- SubInboxMessage \u2014 a merged subscription communication (the Universal Inbox)
+- SubAiAgent \u2014 an automation-layer specialised agent (has policies)
+- SubPolicy \u2014 an autonomous rule (condition \u2192 action) evaluated by an agent
+- SubWorkflow \u2014 an event-triggered automation workflow
+
+## Key enums
+- SubRelationshipKind: SUBSCRIPTION, MEMBERSHIP, LICENSE, CONTRACT, TRIAL, NEWSLETTER, ENROLLMENT, RECURRING_PAYMENT
+- SubRelationshipStatus: ACTIVE, TRIAL, PAST_DUE, PAUSED, LAPSED, EXPIRED, CANCELLED
+- SubBillingInterval: DAILY, WEEKLY, MONTHLY, QUARTERLY, YEARLY, LIFETIME, USAGE_BASED, FREE
+- SubProviderCategory: SAAS, STREAMING, TELECOM, UTILITY, FINANCIAL, INSURANCE, NEWSLETTER, MEMBERSHIP, AI_SERVICE, \u2026 (16)
+- SubInvoiceStatus: DRAFT, ISSUED, PAID, OVERDUE, FAILED, REFUNDED, CANCELLED
+- SubMessageCategory: BILLING, RENEWAL, REQUIRED_ACTION, SECURITY_ALERT, PRODUCT_UPDATE, MARKETING, OTHER
+- SubAgentKind: DISCOVERY, RENEWAL, COST, NEGOTIATION, MIGRATION, COMPLIANCE, CONCIERGE, VENDOR, NEWSLETTER
+- SubAgentStatus: DISABLED, SUGGEST_ONLY, AUTONOMOUS
+
+## Tool groups
+providers, plans, relationships, entitlements, assets, renewal_events,
+payment_instruments, invoices, channels, inbox, agents, policies, workflows, 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(
+    "subscriberbot-providers",
+    providersUri,
+    {
+      title: "Subscriber Bot Provider Registry",
+      description: "The first 50 providers in the bound workspace registry.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${providersUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_PROVIDERS,
+          {
+            pagination: { limit: 50, offset: 0 }
+          }
+        );
+        return {
+          contents: [
+            {
+              uri: providersUri,
+              text: JSON.stringify(data.subListProviders, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: providersUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "subscriberbot-relationships",
+    relationshipsUri,
+    {
+      title: "Subscriber Bot Relationships",
+      description: "The first 50 recurring relationships in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${relationshipsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_RELATIONSHIPS,
+          { pagination: { limit: 50, offset: 0 } }
+        );
+        return {
+          contents: [
+            {
+              uri: relationshipsUri,
+              text: JSON.stringify(data.subListRelationships, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: relationshipsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "subscriberbot-inbox",
+    inboxUri,
+    {
+      title: "Subscriber Bot Universal Inbox",
+      description: "The first 50 merged subscription communications in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${inboxUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_INBOX_MESSAGES,
+          { pagination: { limit: 50, offset: 0 } }
+        );
+        return {
+          contents: [
+            {
+              uri: inboxUri,
+              text: JSON.stringify(data.subListInboxMessages, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: inboxUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerSubscriberbotPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const onboardingName = track(mcpPromptName(p, "relationship-onboarding"));
+  const triageName = track(mcpPromptName(p, "inbox-triage"));
+  server.registerPrompt(
+    onboardingName,
+    {
+      title: "Relationship Onboarding",
+      description: "Guide for onboarding a new recurring relationship end to end: find/create the provider and plan, create the relationship, and capture its entitlements, assets, and renewal cadence.",
+      argsSchema: {
+        providerName: zod.z.string().optional().describe("Provider/vendor name"),
+        label: zod.z.string().optional().describe("Label for the relationship")
+      }
+    },
+    ({ providerName, label }) => {
+      ctx.logger.debug(`Prompt ${onboardingName} called`, { providerName, label });
+      const providerNote = providerName ? `Search the registry for "${providerName}" with ${p}_providers_list; create it with ${p}_providers_create if missing.` : `Ask the user for the provider name, then search with ${p}_providers_list (create with ${p}_providers_create if missing).`;
+      const labelNote = label ? `Use the label "${label}".` : "Ask the user for a label for the relationship.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me onboard a new recurring relationship in Subscriber Bot.
+
+1. **Provider**: ${providerNote}
+2. **Plan**: Use ${p}_plans_list for the provider; create one with ${p}_plans_create (amount, currency, interval) if needed.
+3. **Create Relationship**: Use ${p}_relationships_create. ${labelNote} Set kind (SUBSCRIPTION / MEMBERSHIP / LICENSE / CONTRACT), providerId, planId, amount/currency/interval, autoRenew, and renewsAt.
+4. **Entitlements**: Use ${p}_entitlements_create for each seat/quota/feature the relationship grants.
+5. **Assets**: Use ${p}_assets_create to attach contracts/receipts/license keys (reference a wspace-files File via fileId).
+6. **Confirm**: Re-read with ${p}_relationships_get and summarise the renewal cadence.
+
+Show results at each step and confirm before finishing.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    triageName,
+    {
+      title: "Inbox & Renewal Triage",
+      description: "Daily triage workflow: work the universal inbox, mark actioned messages read, handle upcoming renewals, settle invoices, and tune automation agents/policies.",
+      argsSchema: {
+        relationshipId: zod.z.string().optional().describe("Relationship ID to focus on")
+      }
+    },
+    ({ relationshipId }) => {
+      ctx.logger.debug(`Prompt ${triageName} called`, { relationshipId });
+      const scopeNote = relationshipId ? `Focus on relationship "${relationshipId}".` : `Work across all relationships (use ${p}_relationships_list to pick).`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run daily Subscriber Bot triage. ${scopeNote}
+
+1. **Required actions**: Use ${p}_inbox_list with category=REQUIRED_ACTION (and unreadOnly=true) to find messages needing attention; mark handled ones with ${p}_inbox_mark_read.
+2. **Renewals**: Use ${p}_renewal_events_list with upcomingOnly=true to find imminent renewals/trial-ends; for each decide renew vs cancel (${p}_relationships_transition / ${p}_relationships_cancel).
+3. **Billing**: Use ${p}_invoices_list with status=ISSUED or OVERDUE; settle paid ones with ${p}_invoices_mark_paid.
+4. **Security**: Use ${p}_inbox_list with category=SECURITY_ALERT and escalate.
+5. **Automation**: Use ${p}_agents_list and ${p}_policies_list to review autonomous coverage; promote a trusted agent with ${p}_agents_set_status (SUGGEST_ONLY \u2192 AUTONOMOUS) where appropriate.
+
+Summarise what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/subscriberbot/index.ts
+var subscriberbotModule = {
+  id: "subscriberbot",
+  version: "0.0.1",
+  displayName: "Subscriber Bot",
+  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;
+    };
+    registerProviderTools(server, ctx, trackTool);
+    registerPlanTools(server, ctx, trackTool);
+    registerRelationshipTools(server, ctx, trackTool);
+    registerEntitlementTools(server, ctx, trackTool);
+    registerAssetTools(server, ctx, trackTool);
+    registerRenewalTools(server, ctx, trackTool);
+    registerPaymentInstrumentTools(server, ctx, trackTool);
+    registerInvoiceTools(server, ctx, trackTool);
+    registerChannelTools(server, ctx, trackTool);
+    registerInboxTools(server, ctx, trackTool);
+    registerAgentTools(server, ctx, trackTool);
+    registerPolicyTools(server, ctx, trackTool);
+    registerWorkflowTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerSubscriberbotResources(server, ctx, trackResource);
+    registerSubscriberbotPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var subscriberbot_default = subscriberbotModule;
+
+module.exports = subscriberbot_default;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map