@burdenoff/mcp-libs 2026.529.1 → 2026.626.1

package/dist/modules/kadaikodi/index.js

@@ -0,0 +1,1406 @@
+import { mcpToolName, errorResult, jsonResult, mcpResourceUri, mcpPromptName } from '../../chunk-H2OYWLOA.js';
+import { z } from 'zod';
+
+// src/modules/kadaikodi/operations.ts
+var PROVIDER_FIELDS = `
+  id name slug description category status offeringType serviceTypes
+  location businessHours rating totalRatings averageOrderValue
+  analyticsSnapshot ownerId workspaceId createdAt updatedAt
+`;
+var OFFERING_FIELDS = `
+  id name slug description category kind price originalPrice durationMinutes
+  stock isAvailable serviceType media metadata tags providerId workspaceId
+  createdAt updatedAt
+`;
+var ORDER_ITEM_FIELDS = `
+  id orderId offeringId name quantity unitPrice totalPrice customizations workspaceId
+`;
+var ORDER_FIELDS = `
+  id orderNumber customerId providerId assignedWorkerId status paymentStatus
+  paymentMethod fulfillmentType subtotal tax discount deliveryFee total
+  deliveryAddress notes timeline workspaceId createdAt updatedAt
+  items { ${ORDER_ITEM_FIELDS} }
+`;
+var REVIEW_FIELDS = `
+  id providerId customerId orderId rating review response workspaceId
+  createdAt updatedAt
+`;
+var WORKER_FIELDS = `
+  id providerId workerId name role status metadata workspaceId
+  tasks { id title type status priority orderId dueAt completedAt }
+`;
+var TASK_FIELDS = `
+  id workerRefId title description type status priority orderId location
+  dueAt completedAt workspaceId
+`;
+var OPPORTUNITY_FIELDS = `
+  id providerId title description targetAmount raisedAmount minimumInvestment
+  expectedReturnsPct lockInMonths riskLevel status businessMetrics terms
+  expiresAt workspaceId createdAt updatedAt
+`;
+var INVESTMENT_TXN_FIELDS = `
+  id investmentId type amount notes createdAt workspaceId
+`;
+var INVESTMENT_FIELDS = `
+  id opportunityId investorId amount currentValue realizedReturns
+  expectedReturnsPct status investedAt maturedAt workspaceId
+  transactions { ${INVESTMENT_TXN_FIELDS} }
+`;
+var GET_SERVICE_PROVIDER = `
+  query KadaikodiGetServiceProvider($id: ID!) {
+    getServiceProvider(id: $id) {
+      ${PROVIDER_FIELDS}
+      offerings { id name slug kind price isAvailable }
+      workers { id name role status }
+      investmentOpportunities { id title status targetAmount raisedAmount }
+    }
+  }
+`;
+var LIST_SERVICE_PROVIDERS = `
+  query KadaikodiListServiceProviders(
+    $filter: KadaikodiProviderFilterInput
+    $limit: Int
+    $offset: Int
+  ) {
+    listServiceProviders(filter: $filter, limit: $limit, offset: $offset) {
+      ${PROVIDER_FIELDS}
+    }
+  }
+`;
+var CREATE_SERVICE_PROVIDER = `
+  mutation KadaikodiCreateServiceProvider($input: KadaikodiCreateServiceProviderInput!) {
+    kadaikodiCreateServiceProvider(input: $input) {
+      ${PROVIDER_FIELDS}
+    }
+  }
+`;
+var UPDATE_SERVICE_PROVIDER = `
+  mutation KadaikodiUpdateServiceProvider(
+    $id: ID!
+    $input: KadaikodiUpdateServiceProviderInput!
+  ) {
+    kadaikodiUpdateServiceProvider(id: $id, input: $input) {
+      ${PROVIDER_FIELDS}
+    }
+  }
+`;
+var LIST_PROVIDER_WORKERS = `
+  query KadaikodiListProviderWorkers($providerId: String!, $limit: Int, $offset: Int) {
+    listProviderWorkers(providerId: $providerId, limit: $limit, offset: $offset) {
+      ${WORKER_FIELDS}
+    }
+  }
+`;
+var LIST_WORKER_TASKS = `
+  query KadaikodiListWorkerTasks(
+    $workerRefId: String!
+    $status: String
+    $limit: Int
+    $offset: Int
+  ) {
+    listWorkerTasks(workerRefId: $workerRefId, status: $status, limit: $limit, offset: $offset) {
+      ${TASK_FIELDS}
+    }
+  }
+`;
+var GET_OFFERING = `
+  query KadaikodiGetOffering($id: ID!) {
+    getOffering(id: $id) {
+      ${OFFERING_FIELDS}
+    }
+  }
+`;
+var LIST_OFFERINGS = `
+  query KadaikodiListOfferings(
+    $kind: KadaikodiOfferingKind
+    $providerId: String
+    $limit: Int
+    $offset: Int
+  ) {
+    listOfferings(kind: $kind, providerId: $providerId, limit: $limit, offset: $offset) {
+      ${OFFERING_FIELDS}
+    }
+  }
+`;
+var CREATE_OFFERING = `
+  mutation KadaikodiCreateOffering($input: KadaikodiCreateOfferingInput!) {
+    createOffering(input: $input) {
+      ${OFFERING_FIELDS}
+    }
+  }
+`;
+var UPDATE_OFFERING = `
+  mutation KadaikodiUpdateOffering($id: ID!, $input: KadaikodiUpdateOfferingInput!) {
+    updateOffering(id: $id, input: $input) {
+      ${OFFERING_FIELDS}
+    }
+  }
+`;
+var GET_ORDER = `
+  query KadaikodiGetOrder($id: ID!) {
+    getOrder(id: $id) {
+      ${ORDER_FIELDS}
+    }
+  }
+`;
+var LIST_ORDERS = `
+  query KadaikodiListOrders(
+    $customerId: String
+    $providerId: String
+    $status: KadaikodiOrderStatus
+    $limit: Int
+    $offset: Int
+  ) {
+    listOrders(
+      customerId: $customerId
+      providerId: $providerId
+      status: $status
+      limit: $limit
+      offset: $offset
+    ) {
+      ${ORDER_FIELDS}
+    }
+  }
+`;
+var PLACE_ORDER = `
+  mutation KadaikodiPlaceOrder($input: KadaikodiPlaceOrderInput!) {
+    placeOrder(input: $input) {
+      ${ORDER_FIELDS}
+    }
+  }
+`;
+var UPDATE_ORDER_STATUS = `
+  mutation KadaikodiUpdateOrderStatus($id: ID!, $status: KadaikodiOrderStatus!) {
+    updateOrderStatus(id: $id, status: $status) {
+      ${ORDER_FIELDS}
+    }
+  }
+`;
+var LIST_REVIEWS = `
+  query KadaikodiListReviews($providerId: String!, $limit: Int, $offset: Int) {
+    listReviews(providerId: $providerId, limit: $limit, offset: $offset) {
+      ${REVIEW_FIELDS}
+    }
+  }
+`;
+var CREATE_REVIEW = `
+  mutation KadaikodiCreateReview($input: KadaikodiCreateReviewInput!) {
+    createReview(input: $input) {
+      ${REVIEW_FIELDS}
+    }
+  }
+`;
+var RESPOND_TO_REVIEW = `
+  mutation KadaikodiRespondToReview($id: ID!, $response: String!) {
+    respondToReview(id: $id, response: $response) {
+      ${REVIEW_FIELDS}
+    }
+  }
+`;
+var GET_INVESTMENT_OPPORTUNITY = `
+  query KadaikodiGetInvestmentOpportunity($id: ID!) {
+    getInvestmentOpportunity(id: $id) {
+      ${OPPORTUNITY_FIELDS}
+      provider { id name slug category }
+      investments { id investorId amount status investedAt }
+    }
+  }
+`;
+var LIST_INVESTMENT_OPPORTUNITIES = `
+  query KadaikodiListInvestmentOpportunities(
+    $riskLevel: KadaikodiRiskLevel
+    $status: KadaikodiInvestmentStatus
+    $limit: Int
+    $offset: Int
+  ) {
+    listInvestmentOpportunities(
+      riskLevel: $riskLevel
+      status: $status
+      limit: $limit
+      offset: $offset
+    ) {
+      ${OPPORTUNITY_FIELDS}
+    }
+  }
+`;
+var LIST_INVESTMENTS = `
+  query KadaikodiListInvestments($investorId: String!, $limit: Int, $offset: Int) {
+    listInvestments(investorId: $investorId, limit: $limit, offset: $offset) {
+      ${INVESTMENT_FIELDS}
+    }
+  }
+`;
+var CREATE_INVESTMENT_OPPORTUNITY = `
+  mutation KadaikodiCreateInvestmentOpportunity(
+    $input: KadaikodiCreateInvestmentOpportunityInput!
+  ) {
+    createInvestmentOpportunity(input: $input) {
+      ${OPPORTUNITY_FIELDS}
+    }
+  }
+`;
+var INVEST = `
+  mutation KadaikodiInvest($input: KadaikodiInvestInput!) {
+    invest(input: $input) {
+      ${INVESTMENT_FIELDS}
+      opportunity { id title status raisedAmount targetAmount }
+    }
+  }
+`;
+var ADMIN_ANALYTICS = `
+  query KadaikodiAdminAnalytics {
+    kadaikodiAdminAnalytics {
+      categoryDistribution
+      customerGrowth
+      orderTrends
+      revenueByCategory
+      topProviders
+    }
+  }
+`;
+var DASHBOARD_STATS = `
+  query KadaikodiDashboardStats {
+    kadaikodiDashboardStats {
+      activeCustomers
+      activeProviders
+      avgRating
+      pendingOrders
+      totalOrders
+      totalRevenue
+    }
+  }
+`;
+var HEALTH = `
+  query KadaikodiHealth {
+    kadaikodiHealth
+  }
+`;
+var ServiceCategoryEnum = z.enum([
+  "CLOTHING_FASHION",
+  "EDUCATION_SKILLS",
+  "FOOD_BEVERAGE",
+  "GROCERY_ESSENTIALS",
+  "HEALTH_WELLNESS",
+  "HOME_SERVICES",
+  "PERSONAL_CARE_BEAUTY",
+  "REPAIR_MAINTENANCE",
+  "RETAIL_MERCHANDISE"
+]).describe("Top-level service/commerce category for a provider or offering");
+var ProviderStatusEnum = z.enum(["ACTIVE", "ARCHIVED", "DRAFT", "PAUSED", "SUSPENDED", "VERIFIED"]).describe("Lifecycle/moderation status of a service provider");
+var OfferingKindEnum = z.enum(["PRODUCT", "SERVICE"]).describe("Whether the offering is a physical PRODUCT (stocked) or a bookable SERVICE");
+var OrderStatusEnum = z.enum([
+  "PENDING",
+  "PLACED",
+  "CONFIRMED",
+  "PREPARING",
+  "READY",
+  "OUT_FOR_DELIVERY",
+  "DELIVERED",
+  "COMPLETED",
+  "CANCELLED"
+]).describe("Fulfilment status of an order");
+z.enum(["PENDING", "PROCESSING", "PAID", "FAILED", "REFUNDED"]).describe("Payment status of an order");
+var InvestmentStatusEnum = z.enum(["DRAFT", "ACTIVE", "FUNDED", "CLOSED"]).describe("Lifecycle status of an investment opportunity");
+var RiskLevelEnum = z.enum(["LOW", "MEDIUM", "HIGH"]).describe("Risk classification of an investment opportunity");
+var JsonObject = z.record(z.string(), z.unknown());
+
+// src/modules/kadaikodi/tools/providers.ts
+function registerProviderTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "providers_get")),
+    {
+      title: "Get Service Provider",
+      description: "Fetch a single Kadaikodi service provider by ID, including its offerings, workers, and investment opportunities.",
+      inputSchema: { id: z.string().describe("Service provider ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_SERVICE_PROVIDER, { id });
+        if (!data.getServiceProvider) return errorResult(`Service provider ${id} not found`);
+        return jsonResult(data.getServiceProvider);
+      } catch (error) {
+        ctx.logger.error("kadaikodi providers_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get service provider: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "providers_list")),
+    {
+      title: "List Service Providers",
+      description: "List service providers in the bound workspace with optional category/status/open-now/text filters and pagination.",
+      inputSchema: {
+        category: ServiceCategoryEnum.optional().describe("Filter by category"),
+        status: ProviderStatusEnum.optional().describe("Filter by lifecycle status"),
+        openOnly: z.boolean().optional().describe("Only providers currently open per businessHours"),
+        query: z.string().optional().describe("Free-text search across name/description"),
+        limit: z.number().int().optional().describe("Page size (default 50)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ category, status, openOnly, query, limit, offset }) => {
+      try {
+        const filter = {};
+        if (category !== void 0) filter.category = category;
+        if (status !== void 0) filter.status = status;
+        if (openOnly !== void 0) filter.openOnly = openOnly;
+        if (query !== void 0) filter.query = query;
+        const data = await ctx.gql.workspace.request(LIST_SERVICE_PROVIDERS, {
+          filter: Object.keys(filter).length > 0 ? filter : void 0,
+          limit: limit ?? 50,
+          offset: offset ?? 0
+        });
+        return jsonResult(data.listServiceProviders);
+      } catch (error) {
+        ctx.logger.error("kadaikodi providers_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list service providers: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "providers_create")),
+    {
+      title: "Create Service Provider",
+      description: "Onboard a new service provider (storefront/business). `slug` must be unique within the workspace; `location` is required JSON ({ address, latitude, longitude }).",
+      inputSchema: {
+        name: z.string().min(1).describe("Business / provider display name"),
+        slug: z.string().min(1).describe("URL slug, unique within the workspace"),
+        category: ServiceCategoryEnum.describe("Primary category"),
+        ownerId: z.string().min(1).describe("User ID of the provider owner"),
+        location: JsonObject.describe("Location JSON: { address, latitude, longitude }"),
+        description: z.string().optional().describe("Business description"),
+        offeringType: z.string().optional().describe('What the provider offers: "products", "services", or "both" (default "both")'),
+        serviceTypes: z.array(z.string()).optional().describe("Free-form service-type tags (default [])"),
+        businessHours: z.union([JsonObject, z.array(z.unknown())]).optional().describe("Business-hours JSON (per-day open/close windows)")
+      }
+    },
+    async ({
+      name,
+      slug,
+      category,
+      ownerId,
+      location,
+      description,
+      offeringType,
+      serviceTypes,
+      businessHours
+    }) => {
+      try {
+        const input = { name, slug, category, ownerId, location };
+        if (description !== void 0) input.description = description;
+        if (offeringType !== void 0) input.offeringType = offeringType;
+        if (serviceTypes !== void 0) input.serviceTypes = serviceTypes;
+        if (businessHours !== void 0) input.businessHours = businessHours;
+        const data = await ctx.gql.workspace.request(CREATE_SERVICE_PROVIDER, { input });
+        return jsonResult(data.kadaikodiCreateServiceProvider);
+      } catch (error) {
+        ctx.logger.error("kadaikodi providers_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create service provider: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "providers_update")),
+    {
+      title: "Update Service Provider",
+      description: "Update a service provider. At least one mutable field must be provided. Use `status` to verify/pause/suspend/archive a provider.",
+      inputSchema: {
+        id: z.string().describe("Service provider ID"),
+        name: z.string().optional().describe("Updated display name"),
+        description: z.string().optional().describe("Updated description"),
+        status: ProviderStatusEnum.optional().describe("Updated lifecycle/moderation status"),
+        location: JsonObject.optional().describe("Updated location JSON"),
+        businessHours: z.union([JsonObject, z.array(z.unknown())]).optional().describe("Updated business-hours JSON"),
+        serviceTypes: z.array(z.string()).optional().describe("Updated service-type tags"),
+        analyticsSnapshot: JsonObject.optional().describe("Updated analytics snapshot JSON")
+      }
+    },
+    async ({
+      id,
+      name,
+      description,
+      status,
+      location,
+      businessHours,
+      serviceTypes,
+      analyticsSnapshot
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (description !== void 0) input.description = description;
+        if (status !== void 0) input.status = status;
+        if (location !== void 0) input.location = location;
+        if (businessHours !== void 0) input.businessHours = businessHours;
+        if (serviceTypes !== void 0) input.serviceTypes = serviceTypes;
+        if (analyticsSnapshot !== void 0) input.analyticsSnapshot = analyticsSnapshot;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/description/status/location/businessHours/serviceTypes/analyticsSnapshot"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_SERVICE_PROVIDER, { id, input });
+        return jsonResult(data.kadaikodiUpdateServiceProvider);
+      } catch (error) {
+        ctx.logger.error("kadaikodi providers_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update service provider: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerWorkerTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workers_list")),
+    {
+      title: "List Provider Workers",
+      description: "List the workers (staff/agents) attached to a service provider, including each worker\u2019s assigned tasks.",
+      inputSchema: {
+        providerId: z.string().describe("Service provider ID"),
+        limit: z.number().int().optional().describe("Page size (default 50)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ providerId, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PROVIDER_WORKERS, {
+          providerId,
+          limit: limit ?? 50,
+          offset: offset ?? 0
+        });
+        return jsonResult(data.listProviderWorkers);
+      } catch (error) {
+        ctx.logger.error("kadaikodi workers_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list provider workers: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerTaskTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "tasks_list")),
+    {
+      title: "List Worker Tasks",
+      description: "List the tasks assigned to a provider worker (referenced by workerRefId), optionally filtered by free-form task status.",
+      inputSchema: {
+        workerRefId: z.string().describe("Worker reference ID (KadaikodiProviderWorker.workerId)"),
+        status: z.string().optional().describe('Filter by task status (free-form, e.g. "pending", "in_progress", "done")'),
+        limit: z.number().int().optional().describe("Page size (default 50)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ workerRefId, status, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_WORKER_TASKS, {
+          workerRefId,
+          status,
+          limit: limit ?? 50,
+          offset: offset ?? 0
+        });
+        return jsonResult(data.listWorkerTasks);
+      } catch (error) {
+        ctx.logger.error("kadaikodi tasks_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list worker tasks: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+var MediaSchema = z.union([JsonObject, z.array(z.unknown())]).describe("Media JSON (image/video URLs or { images: [...] })");
+function registerOfferingTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "offerings_get")),
+    {
+      title: "Get Offering",
+      description: "Fetch a single catalog offering (product or service) by ID.",
+      inputSchema: { id: z.string().describe("Offering ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_OFFERING, { id });
+        if (!data.getOffering) return errorResult(`Offering ${id} not found`);
+        return jsonResult(data.getOffering);
+      } catch (error) {
+        ctx.logger.error("kadaikodi offerings_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get offering: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "offerings_list")),
+    {
+      title: "List Offerings",
+      description: "List catalog offerings, optionally filtered by kind (PRODUCT/SERVICE) and/or provider.",
+      inputSchema: {
+        kind: OfferingKindEnum.optional().describe("Filter by offering kind"),
+        providerId: z.string().optional().describe("Filter by provider ID"),
+        limit: z.number().int().optional().describe("Page size (default 100)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ kind, providerId, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_OFFERINGS, {
+          kind,
+          providerId,
+          limit: limit ?? 100,
+          offset: offset ?? 0
+        });
+        return jsonResult(data.listOfferings);
+      } catch (error) {
+        ctx.logger.error("kadaikodi offerings_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list offerings: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "offerings_create")),
+    {
+      title: "Create Offering",
+      description: "Create a catalog offering. For PRODUCT kind set `stock`; for SERVICE kind set `durationMinutes`. `slug` is unique per provider.",
+      inputSchema: {
+        providerId: z.string().min(1).describe("Owning provider ID"),
+        name: z.string().min(1).describe("Offering display name"),
+        slug: z.string().min(1).describe("URL slug, unique within the provider"),
+        category: ServiceCategoryEnum.describe("Offering category"),
+        kind: OfferingKindEnum.describe("PRODUCT or SERVICE"),
+        price: z.number().describe("Current selling price"),
+        originalPrice: z.number().optional().describe("Pre-discount/list price"),
+        description: z.string().optional().describe("Offering description"),
+        durationMinutes: z.number().int().optional().describe("Service duration in minutes (SERVICE kind)"),
+        stock: z.number().int().optional().describe("Available stock (PRODUCT kind)"),
+        serviceType: z.string().optional().describe("Free-form service-type tag"),
+        media: MediaSchema.optional(),
+        metadata: JsonObject.optional().describe("Arbitrary metadata JSON"),
+        tags: z.array(z.string()).optional().describe("Search/discovery tags (default [])")
+      }
+    },
+    async ({
+      providerId,
+      name,
+      slug,
+      category,
+      kind,
+      price,
+      originalPrice,
+      description,
+      durationMinutes,
+      stock,
+      serviceType,
+      media,
+      metadata,
+      tags
+    }) => {
+      try {
+        const input = { providerId, name, slug, category, kind, price };
+        if (originalPrice !== void 0) input.originalPrice = originalPrice;
+        if (description !== void 0) input.description = description;
+        if (durationMinutes !== void 0) input.durationMinutes = durationMinutes;
+        if (stock !== void 0) input.stock = stock;
+        if (serviceType !== void 0) input.serviceType = serviceType;
+        if (media !== void 0) input.media = media;
+        if (metadata !== void 0) input.metadata = metadata;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_OFFERING, { input });
+        return jsonResult(data.createOffering);
+      } catch (error) {
+        ctx.logger.error("kadaikodi offerings_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create offering: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "offerings_update")),
+    {
+      title: "Update Offering",
+      description: "Update a catalog offering. At least one mutable field must be provided. Use `isAvailable` to toggle visibility.",
+      inputSchema: {
+        id: z.string().describe("Offering ID"),
+        name: z.string().optional().describe("Updated name"),
+        description: z.string().optional().describe("Updated description"),
+        price: z.number().optional().describe("Updated price"),
+        originalPrice: z.number().optional().describe("Updated list price"),
+        durationMinutes: z.number().int().optional().describe("Updated service duration (minutes)"),
+        stock: z.number().int().optional().describe("Updated stock"),
+        isAvailable: z.boolean().optional().describe("Toggle availability"),
+        serviceType: z.string().optional().describe("Updated service-type tag"),
+        media: MediaSchema.optional(),
+        metadata: JsonObject.optional().describe("Updated metadata JSON"),
+        tags: z.array(z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      name,
+      description,
+      price,
+      originalPrice,
+      durationMinutes,
+      stock,
+      isAvailable,
+      serviceType,
+      media,
+      metadata,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (description !== void 0) input.description = description;
+        if (price !== void 0) input.price = price;
+        if (originalPrice !== void 0) input.originalPrice = originalPrice;
+        if (durationMinutes !== void 0) input.durationMinutes = durationMinutes;
+        if (stock !== void 0) input.stock = stock;
+        if (isAvailable !== void 0) input.isAvailable = isAvailable;
+        if (serviceType !== void 0) input.serviceType = serviceType;
+        if (media !== void 0) input.media = media;
+        if (metadata !== void 0) input.metadata = metadata;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable offering field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_OFFERING, { id, input });
+        return jsonResult(data.updateOffering);
+      } catch (error) {
+        ctx.logger.error("kadaikodi offerings_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update offering: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+var OrderItemSchema = z.object({
+  name: z.string().describe("Line-item display name (snapshot)"),
+  quantity: z.number().int().describe("Quantity ordered"),
+  unitPrice: z.number().describe("Unit price at time of order"),
+  offeringId: z.string().optional().describe("Source offering ID (optional for ad-hoc items)"),
+  customizations: JsonObject.optional().describe("Per-item customization JSON")
+}).describe("A single order line item");
+function registerOrderTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "orders_get")),
+    {
+      title: "Get Order",
+      description: "Fetch a single order by ID, including its line items.",
+      inputSchema: { id: z.string().describe("Order ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_ORDER, { id });
+        if (!data.getOrder) return errorResult(`Order ${id} not found`);
+        return jsonResult(data.getOrder);
+      } catch (error) {
+        ctx.logger.error("kadaikodi orders_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get order: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "orders_list")),
+    {
+      title: "List Orders",
+      description: "List orders, optionally filtered by customer, provider, and/or status. Useful for both buyer order-history and provider order-queue views.",
+      inputSchema: {
+        customerId: z.string().optional().describe("Filter by customer ID"),
+        providerId: z.string().optional().describe("Filter by provider ID"),
+        status: OrderStatusEnum.optional().describe("Filter by order status"),
+        limit: z.number().int().optional().describe("Page size (default 100)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ customerId, providerId, status, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ORDERS, {
+          customerId,
+          providerId,
+          status,
+          limit: limit ?? 100,
+          offset: offset ?? 0
+        });
+        return jsonResult(data.listOrders);
+      } catch (error) {
+        ctx.logger.error("kadaikodi orders_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list orders: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "orders_place")),
+    {
+      title: "Place Order",
+      description: 'Place an order on behalf of a customer. Provide one or more line items; subtotal/total are computed server-side. `fulfillmentType` is e.g. "delivery" or "pickup".',
+      inputSchema: {
+        customerId: z.string().min(1).describe("Ordering customer ID"),
+        providerId: z.string().min(1).describe("Provider the order is placed with"),
+        fulfillmentType: z.string().min(1).describe('Fulfilment type, e.g. "delivery" or "pickup"'),
+        items: z.array(OrderItemSchema).min(1).describe("Order line items (at least one)"),
+        deliveryAddress: JsonObject.optional().describe("Delivery address JSON (delivery orders)"),
+        deliveryFee: z.number().optional().describe("Delivery fee (default 0)"),
+        discount: z.number().optional().describe("Order-level discount (default 0)"),
+        tax: z.number().optional().describe("Tax amount (default 0)"),
+        paymentMethod: z.string().optional().describe('Payment method, e.g. "cod", "card", "upi"'),
+        notes: z.string().optional().describe("Customer notes for the order")
+      }
+    },
+    async ({
+      customerId,
+      providerId,
+      fulfillmentType,
+      items,
+      deliveryAddress,
+      deliveryFee,
+      discount,
+      tax,
+      paymentMethod,
+      notes
+    }) => {
+      try {
+        const input = { customerId, providerId, fulfillmentType, items };
+        if (deliveryAddress !== void 0) input.deliveryAddress = deliveryAddress;
+        if (deliveryFee !== void 0) input.deliveryFee = deliveryFee;
+        if (discount !== void 0) input.discount = discount;
+        if (tax !== void 0) input.tax = tax;
+        if (paymentMethod !== void 0) input.paymentMethod = paymentMethod;
+        if (notes !== void 0) input.notes = notes;
+        const data = await ctx.gql.workspace.request(PLACE_ORDER, { input });
+        return jsonResult(data.placeOrder);
+      } catch (error) {
+        ctx.logger.error("kadaikodi orders_place failed", { error: String(error) });
+        return errorResult(
+          `Failed to place order: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "orders_update_status")),
+    {
+      title: "Update Order Status",
+      description: "Advance an order through its fulfilment lifecycle (e.g. PLACED \u2192 CONFIRMED \u2192 PREPARING \u2192 READY \u2192 OUT_FOR_DELIVERY \u2192 DELIVERED \u2192 COMPLETED, or CANCELLED).",
+      inputSchema: {
+        id: z.string().describe("Order ID"),
+        status: OrderStatusEnum.describe("New order status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(UPDATE_ORDER_STATUS, { id, status });
+        return jsonResult(data.updateOrderStatus);
+      } catch (error) {
+        ctx.logger.error("kadaikodi orders_update_status failed", { error: String(error) });
+        return errorResult(
+          `Failed to update order status: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerReviewTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reviews_list")),
+    {
+      title: "List Reviews",
+      description: "List customer reviews for a service provider.",
+      inputSchema: {
+        providerId: z.string().describe("Service provider ID"),
+        limit: z.number().int().optional().describe("Page size (default 100)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ providerId, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_REVIEWS, {
+          providerId,
+          limit: limit ?? 100,
+          offset: offset ?? 0
+        });
+        return jsonResult(data.listReviews);
+      } catch (error) {
+        ctx.logger.error("kadaikodi reviews_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list reviews: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reviews_create")),
+    {
+      title: "Create Review",
+      description: "Create a customer review (rating 1\u20135, optional text) for a provider, optionally tied to a fulfilled order.",
+      inputSchema: {
+        providerId: z.string().min(1).describe("Provider being reviewed"),
+        customerId: z.string().min(1).describe("Reviewing customer ID"),
+        rating: z.number().int().min(1).max(5).describe("Star rating, 1\u20135"),
+        review: z.string().optional().describe("Free-text review body"),
+        orderId: z.string().optional().describe("Related order ID (for verified-purchase reviews)")
+      }
+    },
+    async ({ providerId, customerId, rating, review, orderId }) => {
+      try {
+        const input = { providerId, customerId, rating };
+        if (review !== void 0) input.review = review;
+        if (orderId !== void 0) input.orderId = orderId;
+        const data = await ctx.gql.workspace.request(CREATE_REVIEW, { input });
+        return jsonResult(data.createReview);
+      } catch (error) {
+        ctx.logger.error("kadaikodi reviews_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create review: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "reviews_respond")),
+    {
+      title: "Respond to Review",
+      description: "Post a provider response to an existing review.",
+      inputSchema: {
+        id: z.string().describe("Review ID"),
+        response: z.string().min(1).describe("Provider response text")
+      }
+    },
+    async ({ id, response }) => {
+      try {
+        const data = await ctx.gql.workspace.request(RESPOND_TO_REVIEW, { id, response });
+        return jsonResult(data.respondToReview);
+      } catch (error) {
+        ctx.logger.error("kadaikodi reviews_respond failed", { error: String(error) });
+        return errorResult(
+          `Failed to respond to review: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerInvestmentTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "investments_opportunities_get")),
+    {
+      title: "Get Investment Opportunity",
+      description: "Fetch a single investment opportunity by ID, including its provider and current investments.",
+      inputSchema: { id: z.string().describe("Investment opportunity ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_INVESTMENT_OPPORTUNITY, { id });
+        if (!data.getInvestmentOpportunity)
+          return errorResult(`Investment opportunity ${id} not found`);
+        return jsonResult(data.getInvestmentOpportunity);
+      } catch (error) {
+        ctx.logger.error("kadaikodi investments_opportunities_get failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to get investment opportunity: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "investments_opportunities_list")),
+    {
+      title: "List Investment Opportunities",
+      description: "List community-investment opportunities, optionally filtered by risk level and/or status.",
+      inputSchema: {
+        riskLevel: RiskLevelEnum.optional().describe("Filter by risk level"),
+        status: InvestmentStatusEnum.optional().describe("Filter by opportunity status"),
+        limit: z.number().int().optional().describe("Page size (default 100)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ riskLevel, status, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_INVESTMENT_OPPORTUNITIES, {
+          riskLevel,
+          status,
+          limit: limit ?? 100,
+          offset: offset ?? 0
+        });
+        return jsonResult(data.listInvestmentOpportunities);
+      } catch (error) {
+        ctx.logger.error("kadaikodi investments_opportunities_list failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to list investment opportunities: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "investments_opportunities_create")),
+    {
+      title: "Create Investment Opportunity",
+      description: "Create a community-investment opportunity for a provider (fundraise target, minimum ticket, expected returns, lock-in, risk).",
+      inputSchema: {
+        providerId: z.string().min(1).describe("Provider raising the investment"),
+        title: z.string().min(1).describe("Opportunity title"),
+        targetAmount: z.number().describe("Fundraise target amount"),
+        minimumInvestment: z.number().describe("Minimum investment ticket size"),
+        expectedReturnsPct: z.number().describe("Expected returns as a percentage"),
+        lockInMonths: z.number().int().describe("Lock-in period in months"),
+        riskLevel: RiskLevelEnum.optional().describe("Risk level (default MEDIUM)"),
+        description: z.string().optional().describe("Opportunity description"),
+        businessMetrics: JsonObject.optional().describe("Supporting business-metrics JSON"),
+        terms: JsonObject.optional().describe("Investment terms JSON"),
+        expiresAt: z.string().optional().describe("Expiry timestamp (ISO-8601 DateTime)")
+      }
+    },
+    async ({
+      providerId,
+      title,
+      targetAmount,
+      minimumInvestment,
+      expectedReturnsPct,
+      lockInMonths,
+      riskLevel,
+      description,
+      businessMetrics,
+      terms,
+      expiresAt
+    }) => {
+      try {
+        const input = {
+          providerId,
+          title,
+          targetAmount,
+          minimumInvestment,
+          expectedReturnsPct,
+          lockInMonths
+        };
+        if (riskLevel !== void 0) input.riskLevel = riskLevel;
+        if (description !== void 0) input.description = description;
+        if (businessMetrics !== void 0) input.businessMetrics = businessMetrics;
+        if (terms !== void 0) input.terms = terms;
+        if (expiresAt !== void 0) input.expiresAt = expiresAt;
+        const data = await ctx.gql.workspace.request(CREATE_INVESTMENT_OPPORTUNITY, { input });
+        return jsonResult(data.createInvestmentOpportunity);
+      } catch (error) {
+        ctx.logger.error("kadaikodi investments_opportunities_create failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to create investment opportunity: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "investments_list")),
+    {
+      title: "List Investments",
+      description: "List the investments made by a given investor, including each investment\u2019s transactions.",
+      inputSchema: {
+        investorId: z.string().describe("Investor user ID"),
+        limit: z.number().int().optional().describe("Page size (default 100)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ investorId, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_INVESTMENTS, {
+          investorId,
+          limit: limit ?? 100,
+          offset: offset ?? 0
+        });
+        return jsonResult(data.listInvestments);
+      } catch (error) {
+        ctx.logger.error("kadaikodi investments_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list investments: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "investments_invest")),
+    {
+      title: "Invest in Opportunity",
+      description: "Commit an investment amount to an opportunity on behalf of an investor. Returns the created investment plus the updated opportunity funding state.",
+      inputSchema: {
+        opportunityId: z.string().min(1).describe("Target investment opportunity ID"),
+        investorId: z.string().min(1).describe("Investor user ID"),
+        amount: z.number().describe("Investment amount (must meet the opportunity minimum)")
+      }
+    },
+    async ({ opportunityId, investorId, amount }) => {
+      try {
+        const input = { opportunityId, investorId, amount };
+        const data = await ctx.gql.workspace.request(INVEST, { input });
+        return jsonResult(data.invest);
+      } catch (error) {
+        ctx.logger.error("kadaikodi investments_invest failed", { error: String(error) });
+        return errorResult(
+          `Failed to invest: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/kadaikodi/tools/analytics.ts
+function registerAnalyticsTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "analytics_admin")),
+    {
+      title: "Kadaikodi Admin Analytics",
+      description: "Marketplace-wide admin analytics: category distribution, customer growth, order trends, revenue by category, and top providers.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(ADMIN_ANALYTICS, {});
+        return jsonResult(data.kadaikodiAdminAnalytics);
+      } catch (error) {
+        ctx.logger.error("kadaikodi analytics_admin failed", { error: String(error) });
+        return errorResult(
+          `Failed to get admin analytics: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "analytics_dashboard")),
+    {
+      title: "Kadaikodi Dashboard Stats",
+      description: "Headline marketplace KPIs: active providers, active customers, total + pending orders, total revenue, and average rating.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(DASHBOARD_STATS, {});
+        return jsonResult(data.kadaikodiDashboardStats);
+      } catch (error) {
+        ctx.logger.error("kadaikodi analytics_dashboard failed", { error: String(error) });
+        return errorResult(
+          `Failed to get dashboard stats: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "Kadaikodi Health Check",
+      description: "Public health probe for the Kadaikodi subgraph (kadaikodiHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.kadaikodiHealth });
+      } catch (error) {
+        ctx.logger.error("kadaikodi health failed", { error: String(error) });
+        return errorResult(
+          `Kadaikodi health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/kadaikodi/resources.ts
+function registerKadaikodiResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const dashboardUri = track(mcpResourceUri(ctx.productName, "dashboard"));
+  const analyticsUri = track(mcpResourceUri(ctx.productName, "analytics"));
+  const providersUri = track(mcpResourceUri(ctx.productName, "providers"));
+  server.registerResource(
+    "kadaikodi-schema",
+    schemaUri,
+    {
+      title: "Kadaikodi Domain Schema",
+      description: "Overview of the Kadaikodi marketplace domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# Kadaikodi Domain (Overview)
+
+Hyperlocal services + commerce + community-investment marketplace.
+
+## Entities
+- KadaikodiServiceProvider \u2014 a business/storefront (offerings, workers, investment opportunities)
+- KadaikodiProviderWorker \u2014 staff attached to a provider (has tasks)
+- KadaikodiWorkerTask \u2014 task assigned to a worker
+- KadaikodiOffering \u2014 catalog item (PRODUCT or SERVICE)
+- KadaikodiOrder (+KadaikodiOrderItem) \u2014 customer order + line items
+- KadaikodiReview \u2014 customer rating + provider response
+- KadaikodiInvestmentOpportunity \u2014 community fundraise for a provider
+- KadaikodiInvestment (+KadaikodiInvestmentTransaction) \u2014 an investor's stake + ledger
+
+## Enums
+- ServiceCategory: CLOTHING_FASHION, EDUCATION_SKILLS, FOOD_BEVERAGE, GROCERY_ESSENTIALS, HEALTH_WELLNESS, HOME_SERVICES, PERSONAL_CARE_BEAUTY, REPAIR_MAINTENANCE, RETAIL_MERCHANDISE
+- ProviderStatus: DRAFT, ACTIVE, VERIFIED, PAUSED, SUSPENDED, ARCHIVED
+- OfferingKind: PRODUCT, SERVICE
+- OrderStatus: PENDING, PLACED, CONFIRMED, PREPARING, READY, OUT_FOR_DELIVERY, DELIVERED, COMPLETED, CANCELLED
+- PaymentStatus: PENDING, PROCESSING, PAID, FAILED, REFUNDED
+- InvestmentStatus: DRAFT, ACTIVE, FUNDED, CLOSED
+- RiskLevel: LOW, MEDIUM, HIGH
+
+## Tool groups
+providers, workers, tasks, offerings, orders, reviews, investments, analytics.
+All run against the WORKSPACE gateway (workspace-scoped) except the public health probe.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "kadaikodi-dashboard",
+    dashboardUri,
+    {
+      title: "Kadaikodi Dashboard Stats",
+      description: "Live headline marketplace KPIs (providers, customers, orders, revenue, rating).",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${dashboardUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          DASHBOARD_STATS,
+          {}
+        );
+        return {
+          contents: [
+            {
+              uri: dashboardUri,
+              text: JSON.stringify(data.kadaikodiDashboardStats, 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(
+    "kadaikodi-analytics",
+    analyticsUri,
+    {
+      title: "Kadaikodi Admin Analytics",
+      description: "Marketplace-wide analytics: category distribution, customer growth, order trends, revenue by category, top providers.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${analyticsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          ADMIN_ANALYTICS,
+          {}
+        );
+        return {
+          contents: [
+            {
+              uri: analyticsUri,
+              text: JSON.stringify(data.kadaikodiAdminAnalytics, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: analyticsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "kadaikodi-providers",
+    providersUri,
+    {
+      title: "Kadaikodi Provider Directory",
+      description: "The first 50 service providers in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${providersUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_SERVICE_PROVIDERS,
+          { limit: 50, offset: 0 }
+        );
+        return {
+          contents: [
+            {
+              uri: providersUri,
+              text: JSON.stringify(data.listServiceProviders, 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"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerKadaikodiPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const onboardingName = track(mcpPromptName(p, "provider-onboarding"));
+  const opsName = track(mcpPromptName(p, "marketplace-ops"));
+  server.registerPrompt(
+    onboardingName,
+    {
+      title: "Provider Onboarding",
+      description: "Guide for onboarding a new Kadaikodi service provider end to end: create the provider, add catalog offerings, and optionally open an investment opportunity.",
+      argsSchema: {
+        name: z.string().optional().describe("Provider/business name"),
+        category: z.string().optional().describe("Service category")
+      }
+    },
+    ({ name, category }) => {
+      ctx.logger.debug(`Prompt ${onboardingName} called`, { name, category });
+      const nameNote = name ? `Use the business name "${name}".` : "Ask the user for the business name.";
+      const categoryNote = category ? `Use category ${category}.` : "Help the user pick a ServiceCategory.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me onboard a new Kadaikodi service provider.
+
+1. **Create Provider**: Use ${p}_providers_create. ${nameNote} ${categoryNote} Provide a unique slug, ownerId, and a location JSON ({ address, latitude, longitude }).
+2. **Add Offerings**: Use ${p}_offerings_create for each catalog item \u2014 set kind=PRODUCT (with stock) or kind=SERVICE (with durationMinutes), a price, and a unique slug per provider.
+3. **Verify Catalog**: Use ${p}_offerings_list filtered by the new providerId.
+4. **(Optional) Open Investment**: Use ${p}_investments_opportunities_create to raise community capital (targetAmount, minimumInvestment, expectedReturnsPct, lockInMonths, riskLevel).
+5. **Activate**: Use ${p}_providers_update with status=VERIFIED (or ACTIVE) when ready.
+
+Show results at each step and confirm before activation.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    opsName,
+    {
+      title: "Marketplace Operations",
+      description: "Daily operations workflow for a provider: triage the order queue, advance fulfilment, respond to reviews, and review KPIs.",
+      argsSchema: {
+        providerId: z.string().optional().describe("Provider ID to operate")
+      }
+    },
+    ({ providerId }) => {
+      ctx.logger.debug(`Prompt ${opsName} called`, { providerId });
+      const providerNote = providerId ? `Operate provider "${providerId}".` : `First list providers with ${p}_providers_list and pick one.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run daily Kadaikodi marketplace operations. ${providerNote}
+
+1. **KPIs**: Use ${p}_analytics_dashboard for headline numbers and ${p}_analytics_admin for trends.
+2. **Order Queue**: Use ${p}_orders_list filtered by providerId and status=PLACED (and PENDING) to find new orders.
+3. **Advance Fulfilment**: For each order use ${p}_orders_update_status to move it through CONFIRMED \u2192 PREPARING \u2192 READY \u2192 OUT_FOR_DELIVERY \u2192 DELIVERED \u2192 COMPLETED.
+4. **Reviews**: Use ${p}_reviews_list for the provider; reply to unanswered ones with ${p}_reviews_respond.
+5. **Workforce**: Use ${p}_workers_list and ${p}_tasks_list to check worker task load.
+6. **Investments**: If fundraising, use ${p}_investments_opportunities_list to track raised vs target.
+
+Summarize what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/kadaikodi/index.ts
+var kadaikodiModule = {
+  id: "kadaikodi",
+  version: "0.0.1",
+  displayName: "Kadaikodi",
+  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);
+    registerWorkerTools(server, ctx, trackTool);
+    registerTaskTools(server, ctx, trackTool);
+    registerOfferingTools(server, ctx, trackTool);
+    registerOrderTools(server, ctx, trackTool);
+    registerReviewTools(server, ctx, trackTool);
+    registerInvestmentTools(server, ctx, trackTool);
+    registerAnalyticsTools(server, ctx, trackTool);
+    registerKadaikodiResources(server, ctx, trackResource);
+    registerKadaikodiPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var kadaikodi_default = kadaikodiModule;
+
+export { kadaikodi_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map