@unifiedcommerce/core 0.4.2 → 0.4.4

package/dist/interfaces/mcp/tools/catalog.js

@@ -1,284 +0,0 @@
-import { z } from "zod";
-import { defineTool } from "./registry.js";
-import { enrichEntityForAgent, } from "../context-enrichment.js";
-export const catalogSearch = defineTool({
-    name: "catalog_search",
-    description: "Find products in the catalog. Use when the user asks about available items, " +
-        "wants to browse products, or needs to look up an entity by name. Supports " +
-        "filtering by entity type, publication status, category slug, brand slug, " +
-        "and free-text query. Returns paginated results enriched with stock status " +
-        "and variant counts.",
-    inputSchema: z.object({
-        query: z.string().optional().describe("Free-text search query"),
-        type: z.string().optional().describe("Entity type filter"),
-        status: z.string().optional().describe("Status filter (draft, active, archived, discontinued)"),
-        categorySlug: z.string().optional().describe("Category slug to filter by"),
-        brandSlug: z.string().optional().describe("Brand slug to filter by"),
-        page: z.number().int().positive().default(1).describe("Page number"),
-        limit: z.number().int().positive().max(100).default(20).describe("Results per page"),
-    }),
-    async handler({ query, type, status, categorySlug, brandSlug, page, limit }, kernel) {
-        const trimmed = (query ?? "").trim().toLowerCase();
-        if (trimmed.length > 0) {
-            const searchResult = await kernel.services.search.query({
-                query: trimmed,
-                page,
-                limit,
-                filters: {
-                    ...(type != null ? { type } : {}),
-                    ...(status != null ? { status } : {}),
-                    ...(categorySlug != null ? { category: categorySlug } : {}),
-                    ...(brandSlug != null ? { brand: brandSlug } : {}),
-                },
-            });
-            if (!searchResult.ok)
-                return { _error: searchResult.error };
-            const enrichedItems = await Promise.all(searchResult.value.hits.map(async (hit) => {
-                const entityResult = await kernel.services.catalog.getById(hit.id);
-                if (entityResult.ok) {
-                    return enrichEntityForAgent(entityResult.value, kernel);
-                }
-                return hit.document;
-            }));
-            return {
-                items: await Promise.all(enrichedItems),
-                pagination: {
-                    page: searchResult.value.page,
-                    limit: searchResult.value.limit,
-                    total: searchResult.value.total,
-                    totalPages: Math.max(1, Math.ceil(searchResult.value.total / searchResult.value.limit)),
-                },
-                facets: searchResult.value.facets,
-            };
-        }
-        // No query: list with filters
-        const result = await kernel.services.catalog.list({
-            filter: {
-                ...(type != null ? { type } : {}),
-                ...(status != null ? { status } : {}),
-                ...(categorySlug != null ? { category: categorySlug } : {}),
-                ...(brandSlug != null ? { brand: brandSlug } : {}),
-            },
-            pagination: { page, limit },
-        });
-        if (!result.ok)
-            return { _error: result.error };
-        return {
-            ...result.value,
-            items: await Promise.all(result.value.items.map((item) => enrichEntityForAgent(item, kernel))),
-        };
-    },
-});
-export const catalogCreate = defineTool({
-    name: "catalog_create",
-    description: "Create a new catalog entity (product, service, etc.) in draft status. " +
-        "Use when the user wants to add a new product to the catalog. " +
-        "Requires type, slug, and title. Returns the created entity with enriched context.",
-    inputSchema: z.object({
-        type: z.string().describe("Entity type (must match a configured entity type)"),
-        slug: z.string().describe("URL-friendly unique identifier"),
-        title: z.string().describe("Display title"),
-        description: z.string().optional().describe("Entity description"),
-        metadata: z.record(z.string(), z.unknown()).optional().describe("Arbitrary metadata"),
-    }),
-    async handler({ type, slug, title, description, metadata }, kernel) {
-        const result = await kernel.services.catalog.create({
-            type,
-            slug,
-            attributes: {
-                locale: "en",
-                title,
-                ...(description !== undefined ? { description } : {}),
-            },
-            ...(metadata != null ? { metadata } : {}),
-        }, kernel.getMCPActor());
-        if (!result.ok)
-            return { _error: result.error };
-        return enrichEntityForAgent(result.value, kernel);
-    },
-});
-export const catalogGet = defineTool({
-    name: "catalog_get",
-    description: "Get a single catalog entity by ID or slug with full details including " +
-        "attributes, variants, and pricing. Use when the user asks about a specific " +
-        "product or needs detailed information about one item.",
-    inputSchema: z.object({
-        entityId: z.string().optional().describe("UUID of the entity"),
-        slug: z.string().optional().describe("URL-friendly slug of the entity"),
-        locale: z.string().default("en").describe("Locale code for attributes (e.g., en, fr, de)"),
-    }),
-    async handler({ entityId, slug, locale }, kernel) {
-        let resolvedId = entityId;
-        if (!resolvedId && slug) {
-            const listResult = await kernel.services.catalog.list({
-                filter: {},
-                pagination: { page: 1, limit: 1 },
-            });
-            if (!listResult.ok)
-                return { _error: listResult.error };
-            const found = listResult.value.items.find((item) => item.slug === slug);
-            if (!found)
-                return { _error: { message: `Entity with slug '${slug}' not found` } };
-            resolvedId = found.id;
-        }
-        if (!resolvedId)
-            return { _error: { message: "Either entityId or slug is required" } };
-        const entityResult = await kernel.services.catalog.getById(resolvedId, {
-            includeVariants: true,
-        });
-        if (!entityResult.ok)
-            return { _error: entityResult.error };
-        const attrsResult = await kernel.services.catalog.getAttributes(resolvedId, locale);
-        const attributes = attrsResult.ok ? attrsResult.value : null;
-        const pricesResult = await kernel.services.pricing.listPrices({ entityId: resolvedId });
-        const prices = pricesResult.ok ? pricesResult.value : [];
-        const enriched = await enrichEntityForAgent(entityResult.value, kernel);
-        return {
-            ...enriched,
-            attributes,
-            prices,
-        };
-    },
-});
-export const catalogManage = defineTool({
-    name: "catalog_manage",
-    description: "Perform management operations on catalog entities, categories, and brands. " +
-        "Use when the user wants to update, delete, publish, archive, discontinue " +
-        "an entity, set its attributes, manage category/brand assignments, or create " +
-        "variants. The 'action' field determines which operation to run.",
-    inputSchema: z.object({
-        action: z.enum([
-            "update", "delete", "publish", "archive", "discontinue",
-            "set_attributes", "assign_category", "unassign_category",
-            "assign_brand", "unassign_brand", "create_variant",
-        ]).describe("The management operation to perform"),
-        entityId: z.string().describe("UUID of the catalog entity"),
-        // update fields
-        metadata: z.record(z.string(), z.unknown()).optional().describe("Metadata to merge (for update)"),
-        isVisible: z.boolean().optional().describe("Whether entity is visible in storefront (for update)"),
-        // set_attributes fields
-        locale: z.string().optional().describe("Locale code for attributes (for set_attributes)"),
-        title: z.string().optional().describe("Display title (for set_attributes)"),
-        subtitle: z.string().optional().describe("Subtitle (for set_attributes)"),
-        description: z.string().optional().describe("Plain text description (for set_attributes)"),
-        richDescription: z.string().optional().describe("HTML rich description (for set_attributes)"),
-        seoTitle: z.string().optional().describe("SEO page title (for set_attributes)"),
-        seoDescription: z.string().optional().describe("SEO meta description (for set_attributes)"),
-        // category/brand fields
-        categoryId: z.string().optional().describe("Category UUID (for assign_category/unassign_category)"),
-        brandId: z.string().optional().describe("Brand UUID (for assign_brand/unassign_brand)"),
-        // variant fields
-        sku: z.string().optional().describe("SKU for the variant (for create_variant)"),
-    }),
-    async handler(args, kernel) {
-        const actor = kernel.getMCPActor();
-        switch (args.action) {
-            case "update": {
-                const updates = {};
-                if (args.metadata !== undefined)
-                    updates["metadata"] = args.metadata;
-                if (args.isVisible !== undefined)
-                    updates["isVisible"] = args.isVisible;
-                const result = await kernel.services.catalog.update(args.entityId, updates, actor);
-                if (!result.ok)
-                    return { _error: result.error };
-                return enrichEntityForAgent(result.value, kernel);
-            }
-            case "delete": {
-                const result = await kernel.services.catalog.delete(args.entityId, actor);
-                if (!result.ok)
-                    return { _error: result.error };
-                return { deleted: true, entityId: args.entityId };
-            }
-            case "publish": {
-                const result = await kernel.services.catalog.publish(args.entityId, actor);
-                if (!result.ok)
-                    return { _error: result.error };
-                return enrichEntityForAgent(result.value, kernel);
-            }
-            case "archive": {
-                const result = await kernel.services.catalog.archive(args.entityId, actor);
-                if (!result.ok)
-                    return { _error: result.error };
-                return enrichEntityForAgent(result.value, kernel);
-            }
-            case "discontinue": {
-                const result = await kernel.services.catalog.discontinue(args.entityId, actor);
-                if (!result.ok)
-                    return { _error: result.error };
-                return enrichEntityForAgent(result.value, kernel);
-            }
-            case "set_attributes": {
-                const locale = args.locale ?? "en";
-                const attrs = {};
-                if (args.title !== undefined)
-                    attrs["title"] = args.title;
-                if (args.subtitle !== undefined)
-                    attrs["subtitle"] = args.subtitle;
-                if (args.description !== undefined)
-                    attrs["description"] = args.description;
-                if (args.richDescription !== undefined)
-                    attrs["richDescription"] = args.richDescription;
-                if (args.seoTitle !== undefined)
-                    attrs["seoTitle"] = args.seoTitle;
-                if (args.seoDescription !== undefined)
-                    attrs["seoDescription"] = args.seoDescription;
-                if (!("title" in attrs) || typeof attrs["title"] !== "string") {
-                    return { _error: { message: "title is required for set_attributes" } };
-                }
-                const result = await kernel.services.catalog.setAttributes(args.entityId, locale, attrs);
-                if (!result.ok)
-                    return { _error: result.error };
-                return result.value;
-            }
-            case "assign_category": {
-                if (!args.categoryId)
-                    return { _error: { message: "categoryId required for assign_category" } };
-                const result = await kernel.services.catalog.addToCategory(args.entityId, args.categoryId);
-                if (!result.ok)
-                    return { _error: result.error };
-                return { assigned: true, entityId: args.entityId, categoryId: args.categoryId };
-            }
-            case "unassign_category": {
-                if (!args.categoryId)
-                    return { _error: { message: "categoryId required for unassign_category" } };
-                const result = await kernel.services.catalog.removeFromCategory(args.entityId, args.categoryId);
-                if (!result.ok)
-                    return { _error: result.error };
-                return { unassigned: true, entityId: args.entityId, categoryId: args.categoryId };
-            }
-            case "assign_brand": {
-                if (!args.brandId)
-                    return { _error: { message: "brandId required for assign_brand" } };
-                const result = await kernel.services.catalog.addToBrand(args.entityId, args.brandId);
-                if (!result.ok)
-                    return { _error: result.error };
-                return { assigned: true, entityId: args.entityId, brandId: args.brandId };
-            }
-            case "unassign_brand": {
-                if (!args.brandId)
-                    return { _error: { message: "brandId required for unassign_brand" } };
-                const result = await kernel.services.catalog.removeFromBrand(args.entityId, args.brandId);
-                if (!result.ok)
-                    return { _error: result.error };
-                return { unassigned: true, entityId: args.entityId, brandId: args.brandId };
-            }
-            case "create_variant": {
-                const result = await kernel.services.catalog.createVariant({
-                    entityId: args.entityId,
-                    options: {},
-                    ...(args.sku != null ? { sku: args.sku } : {}),
-                }, actor);
-                if (!result.ok)
-                    return { _error: result.error };
-                return result.value;
-            }
-        }
-    },
-});
-export const catalogTools = [
-    catalogSearch,
-    catalogCreate,
-    catalogGet,
-    catalogManage,
-];

package/dist/interfaces/mcp/tools/index.d.ts

@@ -1,3 +0,0 @@
-import type { ToolDefinition } from "./registry.js";
-export declare const coreTools: ToolDefinition[];
-//# sourceMappingURL=index.d.ts.map

package/dist/interfaces/mcp/tools/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/mcp/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAWpD,eAAO,MAAM,SAAS,EAAE,cAAc,EAUrC,CAAC"}

package/dist/interfaces/mcp/tools/index.js

@@ -1,20 +0,0 @@
-import { catalogTools } from "./catalog.js";
-import { inventoryTools } from "./inventory.js";
-import { orderTools } from "./orders.js";
-import { cartTools } from "./cart.js";
-import { analyticsTools } from "./analytics.js";
-import { pricingTools } from "./pricing.js";
-import { promotionsTools } from "./promotions.js";
-import { searchTools } from "./search.js";
-import { webhooksTools } from "./webhooks.js";
-export const coreTools = [
-    ...catalogTools,
-    ...inventoryTools,
-    ...orderTools,
-    ...cartTools,
-    ...analyticsTools,
-    ...pricingTools,
-    ...promotionsTools,
-    ...searchTools,
-    ...webhooksTools,
-];

package/dist/interfaces/mcp/tools/inventory.d.ts

@@ -1,27 +0,0 @@
-import { z } from "zod";
-import type { ToolDefinition } from "./registry.js";
-export declare const inventoryCheck: ToolDefinition<z.ZodObject<{
-    entityIds: z.ZodArray<z.ZodString>;
-}, z.core.$strip>>;
-export declare const inventoryManage: ToolDefinition<z.ZodObject<{
-    action: z.ZodEnum<{
-        release: "release";
-        adjust: "adjust";
-        reserve: "reserve";
-        list_warehouses: "list_warehouses";
-        create_warehouse: "create_warehouse";
-    }>;
-    entityId: z.ZodOptional<z.ZodString>;
-    adjustment: z.ZodOptional<z.ZodNumber>;
-    reason: z.ZodOptional<z.ZodString>;
-    variantId: z.ZodOptional<z.ZodString>;
-    quantity: z.ZodOptional<z.ZodNumber>;
-    orderId: z.ZodOptional<z.ZodString>;
-    performedBy: z.ZodOptional<z.ZodString>;
-    name: z.ZodOptional<z.ZodString>;
-    code: z.ZodOptional<z.ZodString>;
-    isActive: z.ZodOptional<z.ZodBoolean>;
-    priority: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>>;
-export declare const inventoryTools: ToolDefinition[];
-//# sourceMappingURL=inventory.d.ts.map

package/dist/interfaces/mcp/tools/inventory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"inventory.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/mcp/tools/inventory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,eAAO,MAAM,cAAc;;kBAgCzB,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;kBAoH1B,CAAC;AAEH,eAAO,MAAM,cAAc,EAAE,cAAc,EAG1C,CAAC"}

package/dist/interfaces/mcp/tools/inventory.js

@@ -1,143 +0,0 @@
-import { z } from "zod";
-import { defineTool } from "./registry.js";
-import { enrichInventoryForAgent } from "../context-enrichment.js";
-export const inventoryCheck = defineTool({
-    name: "inventory_check",
-    description: "Check available inventory for one or more entities. Use when the user " +
-        "asks about stock levels, availability, or whether something is in stock. " +
-        "Returns quantity on hand, available, and reorder thresholds.",
-    inputSchema: z.object({
-        entityIds: z.array(z.string()).min(1).describe("Array of entity UUIDs to check"),
-    }),
-    async handler({ entityIds }, kernel) {
-        const result = await kernel.services.inventory.checkMultiple(entityIds);
-        if (!result.ok)
-            return { _error: result.error };
-        const enriched = await Promise.all(Object.entries(result.value).map(async ([entityId, available]) => {
-            const levelsResult = await kernel.services.inventory.getLevelsByEntityId(entityId);
-            const levels = levelsResult.ok ? levelsResult.value : [];
-            const reorderThreshold = levels[0]?.reorderThreshold;
-            const reorderQuantity = levels[0]?.reorderQuantity;
-            return enrichInventoryForAgent({
-                entityId,
-                available,
-                ...(reorderThreshold !== undefined ? { reorderThreshold } : {}),
-                ...(reorderQuantity !== undefined ? { reorderQuantity } : {}),
-            });
-        }));
-        return enriched;
-    },
-});
-export const inventoryManage = defineTool({
-    name: "inventory_manage",
-    description: "Perform inventory management operations. Use when the user wants to adjust " +
-        "stock levels, reserve or release inventory for orders, or manage warehouses. " +
-        "The 'action' field determines which operation to run.",
-    inputSchema: z.object({
-        action: z.enum(["adjust", "reserve", "release", "list_warehouses", "create_warehouse"])
-            .describe("The inventory operation to perform"),
-        entityId: z.string().optional().describe("UUID of the entity (for adjust/reserve/release)"),
-        // adjust fields
-        adjustment: z.number().int().optional().describe("Quantity to adjust: positive adds, negative removes (for adjust)"),
-        reason: z.string().optional().describe("Human-readable reason for the adjustment (for adjust)"),
-        variantId: z.string().optional().describe("Variant UUID for variant-level inventory (for adjust/reserve/release)"),
-        // reserve/release fields
-        quantity: z.number().int().positive().optional().describe("Quantity to reserve or release (for reserve/release)"),
-        orderId: z.string().optional().describe("Order UUID for the reservation/release (for reserve/release)"),
-        performedBy: z.string().optional().describe("Who performed the operation (for reserve/release)"),
-        // warehouse fields
-        name: z.string().optional().describe("Warehouse name (for create_warehouse)"),
-        code: z.string().optional().describe("Warehouse code (for create_warehouse)"),
-        isActive: z.boolean().optional().describe("Whether warehouse is active (for create_warehouse)"),
-        priority: z.number().int().optional().describe("Priority for warehouse selection (for create_warehouse)"),
-    }),
-    async handler(args, kernel) {
-        const actor = kernel.getMCPActor();
-        switch (args.action) {
-            case "adjust": {
-                if (!args.entityId)
-                    return { _error: { message: "entityId required for adjust" } };
-                if (args.adjustment == null)
-                    return { _error: { message: "adjustment required for adjust" } };
-                if (!args.reason)
-                    return { _error: { message: "reason required for adjust" } };
-                const result = await kernel.services.inventory.adjust({
-                    entityId: args.entityId,
-                    adjustment: args.adjustment,
-                    reason: args.reason,
-                    ...(args.variantId !== undefined ? { variantId: args.variantId } : {}),
-                }, actor);
-                if (!result.ok)
-                    return { _error: result.error };
-                const availableResult = await kernel.services.inventory.getAvailable(args.entityId, args.variantId);
-                return enrichInventoryForAgent({
-                    entityId: args.entityId,
-                    available: availableResult.ok ? availableResult.value : 0,
-                    ...(result.value.reorderThreshold !== undefined
-                        ? { reorderThreshold: result.value.reorderThreshold }
-                        : {}),
-                    ...(result.value.reorderQuantity !== undefined
-                        ? { reorderQuantity: result.value.reorderQuantity }
-                        : {}),
-                });
-            }
-            case "reserve": {
-                if (!args.entityId)
-                    return { _error: { message: "entityId required for reserve" } };
-                if (args.quantity == null)
-                    return { _error: { message: "quantity required for reserve" } };
-                if (!args.orderId)
-                    return { _error: { message: "orderId required for reserve" } };
-                const result = await kernel.services.inventory.reserve({
-                    entityId: args.entityId,
-                    quantity: args.quantity,
-                    orderId: args.orderId,
-                    ...(args.variantId != null ? { variantId: args.variantId } : {}),
-                    ...(args.performedBy != null ? { performedBy: args.performedBy } : {}),
-                }, actor);
-                if (!result.ok)
-                    return { _error: result.error };
-                return { reserved: true, entityId: args.entityId, quantity: args.quantity };
-            }
-            case "release": {
-                if (!args.entityId)
-                    return { _error: { message: "entityId required for release" } };
-                if (args.quantity == null)
-                    return { _error: { message: "quantity required for release" } };
-                if (!args.orderId)
-                    return { _error: { message: "orderId required for release" } };
-                const result = await kernel.services.inventory.release({
-                    entityId: args.entityId,
-                    quantity: args.quantity,
-                    orderId: args.orderId,
-                    ...(args.variantId != null ? { variantId: args.variantId } : {}),
-                    ...(args.performedBy != null ? { performedBy: args.performedBy } : {}),
-                }, actor);
-                if (!result.ok)
-                    return { _error: result.error };
-                return { released: true, entityId: args.entityId, quantity: args.quantity };
-            }
-            case "list_warehouses": {
-                const result = await kernel.services.inventory.listWarehouses(actor);
-                if (!result.ok)
-                    return { _error: result.error };
-                return result.value;
-            }
-            case "create_warehouse": {
-                const result = await kernel.services.inventory.createWarehouse({
-                    ...(args.name != null ? { name: args.name } : {}),
-                    ...(args.code != null ? { code: args.code } : {}),
-                    ...(args.isActive != null ? { isActive: args.isActive } : {}),
-                    ...(args.priority != null ? { priority: args.priority } : {}),
-                }, actor);
-                if (!result.ok)
-                    return { _error: result.error };
-                return result.value;
-            }
-        }
-    },
-});
-export const inventoryTools = [
-    inventoryCheck,
-    inventoryManage,
-];

package/dist/interfaces/mcp/tools/orders.d.ts

@@ -1,18 +0,0 @@
-import { z } from "zod";
-import type { ToolDefinition } from "./registry.js";
-export declare const orderGet: ToolDefinition<z.ZodObject<{
-    orderId: z.ZodOptional<z.ZodString>;
-    orderNumber: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>;
-export declare const orderList: ToolDefinition<z.ZodObject<{
-    page: z.ZodDefault<z.ZodNumber>;
-    limit: z.ZodDefault<z.ZodNumber>;
-    status: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>;
-export declare const orderChangeStatus: ToolDefinition<z.ZodObject<{
-    orderId: z.ZodString;
-    status: z.ZodString;
-    reason: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>>;
-export declare const orderTools: ToolDefinition[];
-//# sourceMappingURL=orders.d.ts.map

package/dist/interfaces/mcp/tools/orders.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"orders.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/mcp/tools/orders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,eAAO,MAAM,QAAQ;;;kBAmCnB,CAAC;AAEH,eAAO,MAAM,SAAS;;;;kBA4BpB,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;kBAyB5B,CAAC;AAEH,eAAO,MAAM,UAAU,EAAE,cAAc,EAItC,CAAC"}

package/dist/interfaces/mcp/tools/orders.js

@@ -1,82 +0,0 @@
-import { z } from "zod";
-import { defineTool } from "./registry.js";
-import { enrichOrderForAgent } from "../context-enrichment.js";
-export const orderGet = defineTool({
-    name: "order_get",
-    description: "Get order details by UUID or order number. Use when the user asks about " +
-        "a specific order, its status, or tracking information. Returns full order " +
-        "with line items, fulfillments, payment, and AI context.",
-    inputSchema: z.object({
-        orderId: z.string().optional().describe("Order UUID"),
-        orderNumber: z.string().optional().describe("Human-readable order number"),
-    }),
-    async handler({ orderId, orderNumber }, kernel) {
-        if (!orderId && !orderNumber) {
-            return { _error: { message: "Either orderId or orderNumber is required." } };
-        }
-        const result = orderId
-            ? await kernel.services.orders.getById(orderId, kernel.getMCPActor())
-            : await kernel.services.orders.getByNumber(orderNumber ?? "", kernel.getMCPActor());
-        if (!result.ok)
-            return { _error: result.error };
-        const enriched = enrichOrderForAgent(result.value, kernel.getMCPActor().permissions);
-        // Merge fulfillments into the response
-        const fulfillmentResult = await kernel.services.fulfillment.getByOrderId(result.value.id);
-        const fulfillments = fulfillmentResult.ok ? fulfillmentResult.value : [];
-        return {
-            ...enriched,
-            fulfillments,
-        };
-    },
-});
-export const orderList = defineTool({
-    name: "order_list",
-    description: "List orders with pagination and optional status filter. Use when the user " +
-        "wants to see recent orders or filter orders by status.",
-    inputSchema: z.object({
-        page: z.number().int().positive().default(1).describe("Page number"),
-        limit: z.number().int().positive().max(100).default(20).describe("Results per page"),
-        status: z.string().optional().describe("Filter by order status"),
-    }),
-    async handler({ page, limit, status }, kernel) {
-        const result = await kernel.services.orders.list({
-            ...(page !== undefined ? { page } : {}),
-            ...(limit !== undefined ? { limit } : {}),
-            ...(status !== undefined ? { status } : {}),
-        }, kernel.getMCPActor());
-        if (!result.ok)
-            return { _error: result.error };
-        return {
-            ...result.value,
-            items: result.value.items.map((order) => enrichOrderForAgent(order, kernel.getMCPActor().permissions)),
-        };
-    },
-});
-export const orderChangeStatus = defineTool({
-    name: "order_change_status",
-    description: "Change an order's status. Use when the user wants to confirm, process, " +
-        "fulfill, or refund an order. Valid transitions: pending -> confirmed -> " +
-        "processing -> partially_fulfilled/fulfilled -> refunded. This is a " +
-        "dangerous operation that cannot be undone.",
-    inputSchema: z.object({
-        orderId: z.string().describe("UUID of the order"),
-        status: z.string().describe("Target status"),
-        reason: z.string().optional().describe("Reason for the status change"),
-    }),
-    dangerous: true,
-    async handler({ orderId, status, reason }, kernel) {
-        const result = await kernel.services.orders.changeStatus({
-            orderId,
-            newStatus: status,
-            ...(reason != null ? { reason } : {}),
-        }, kernel.getMCPActor());
-        if (!result.ok)
-            return { _error: result.error };
-        return enrichOrderForAgent(result.value, kernel.getMCPActor().permissions);
-    },
-});
-export const orderTools = [
-    orderGet,
-    orderList,
-    orderChangeStatus,
-];

package/dist/interfaces/mcp/tools/pricing.d.ts

@@ -1,29 +0,0 @@
-import { z } from "zod";
-import type { ToolDefinition } from "./registry.js";
-export declare const pricingManage: ToolDefinition<z.ZodObject<{
-    action: z.ZodEnum<{
-        list: "list";
-        set_price: "set_price";
-        create_modifier: "create_modifier";
-    }>;
-    entityId: z.ZodOptional<z.ZodString>;
-    currency: z.ZodOptional<z.ZodString>;
-    amount: z.ZodOptional<z.ZodNumber>;
-    variantId: z.ZodOptional<z.ZodString>;
-    customerGroupId: z.ZodOptional<z.ZodString>;
-    minQuantity: z.ZodOptional<z.ZodNumber>;
-    maxQuantity: z.ZodOptional<z.ZodNumber>;
-    validFrom: z.ZodOptional<z.ZodString>;
-    validUntil: z.ZodOptional<z.ZodString>;
-    name: z.ZodOptional<z.ZodString>;
-    type: z.ZodOptional<z.ZodEnum<{
-        override: "override";
-        percentage_discount: "percentage_discount";
-        fixed_discount: "fixed_discount";
-        markup: "markup";
-    }>>;
-    value: z.ZodOptional<z.ZodNumber>;
-    priority: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>>;
-export declare const pricingTools: ToolDefinition[];
-//# sourceMappingURL=pricing.d.ts.map

package/dist/interfaces/mcp/tools/pricing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pricing.d.ts","sourceRoot":"","sources":["../../../../src/interfaces/mcp/tools/pricing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;kBAqFxB,CAAC;AAEH,eAAO,MAAM,YAAY,EAAE,cAAc,EAExC,CAAC"}