@unchainedshop/api 4.0.0-rc.15 → 4.0.0-rc.16

package/src/express/chatHandler.ts

@@ -0,0 +1,147 @@
+import express from 'express';
+import type { Express, Request, RequestHandler, Response } from 'express';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import {
+  convertToModelMessages,
+  experimental_createMCPClient as createMCPClient,
+  MCPTransport,
+  stepCountIs,
+  streamText,
+  ToolSet,
+} from 'ai';
+import { ChatConfiguration, errorHandler } from '../chat/utils.js';
+import generateImageHandler from '../chat/generateImageHandler.js';
+import defaultSystemPrompt from '../chat/defaultSystemPrompt.js';
+import normalizeToolsIndex from '../chat/normalizeToolsIndex.js';
+
+export const expressRouter = () => {
+  const router = express.Router();
+
+  const staticURL = import.meta.resolve('@unchainedshop/admin-ui');
+  const staticPath = new URL(staticURL).pathname.split('/').slice(0, -1).join('/');
+
+  router.use(express.static(staticPath));
+
+  router.get(/(.*)/, (_, res) => {
+    res.sendFile(`${staticPath}/index.html`);
+  });
+
+  return router;
+};
+
+const setupMCPChatHandler = (chatConfiguration: ChatConfiguration & any): RequestHandler => {
+  if (!chatConfiguration || !chatConfiguration.model) {
+    throw new Error('Model is required');
+  }
+
+  const {
+    tools: additionalTools = {},
+    unchainedMCPUrl = `${process.env.ROOT_URL}/mcp`,
+    model,
+    imageGenerationTool,
+    ...restChatConfig
+  }: any = chatConfiguration;
+
+  const system = chatConfiguration.system ?? defaultSystemPrompt;
+
+  const mcpChatHandler: RequestHandler = async (req: Request, res: Response): Promise<void> => {
+    if (req.method === 'OPTIONS') {
+      res.setHeader('access-control-allow-credentials', 'true');
+      res.setHeader('access-control-allow-private-network', 'true');
+      res.status(200).end();
+      return;
+    }
+    if (req.method !== 'POST' && req.method !== 'GET') {
+      res.status(405).json({ error: 'Method Not Allowed. Use POST.' });
+      return;
+    }
+
+    const client = await createMCPClient({
+      transport: new StreamableHTTPClientTransport(new URL(unchainedMCPUrl), {
+        requestInit: {
+          headers: {
+            Cookie: req.headers.cookie || '',
+          },
+        },
+      }) as MCPTransport,
+    });
+
+    try {
+      const defaultUnchainedTools = await client.tools();
+      const tools: ToolSet = {
+        ...defaultUnchainedTools,
+        ...additionalTools,
+      };
+      if (imageGenerationTool) {
+        tools.generateImage = generateImageHandler(req)(imageGenerationTool) as any;
+      }
+
+      if (req.method === 'GET') {
+        res.status(200).json({
+          tools: normalizeToolsIndex(tools),
+          cached: false,
+        });
+        return;
+      }
+      const { messages } = req.body;
+
+      const cacheControlledTools = { ...tools };
+      const keys = Object.keys(cacheControlledTools);
+      const lastKey = keys[keys.length - 1];
+
+      cacheControlledTools[lastKey] = {
+        ...cacheControlledTools[lastKey],
+        providerOptions: {
+          anthropic: { cacheControl: { type: 'ephemeral' } },
+        },
+      };
+
+      const normalizedMessages = convertToModelMessages(messages, { tools: cacheControlledTools });
+
+      if (normalizedMessages.length > 0) {
+        const lastIndex = normalizedMessages.length - 1;
+        normalizedMessages[lastIndex] = {
+          ...normalizedMessages[lastIndex],
+          providerOptions: { anthropic: { cacheControl: { type: 'ephemeral' } } },
+        };
+      }
+      const result = streamText({
+        stopWhen: stepCountIs(10),
+        ...restChatConfig,
+        system,
+        model,
+        tools: cacheControlledTools,
+        onFinish: async () => {
+          await client?.close();
+        },
+        messages: normalizedMessages.slice(-20),
+        providerOptions: {
+          anthropic: {
+            cacheControl: {
+              type: 'ephemeral',
+            },
+          },
+        },
+      });
+
+      result.pipeUIMessageStreamToResponse(res, {
+        onError: errorHandler,
+      });
+    } catch (err) {
+      await client?.close();
+      res.status(500).json({ error: errorHandler(err) });
+    }
+  };
+
+  return mcpChatHandler;
+};
+
+export const connectChat = (app: Express, chatConfiguration: ChatConfiguration) => {
+  const handler = setupMCPChatHandler(chatConfiguration);
+  if (!handler) {
+    throw new Error('Invalid chat configuration: model is required.');
+  }
+  app.post('/chat', express.json({ limit: '10mb' }), handler);
+  app.options('/chat', handler);
+  app.get('/chat/tools', handler);
+};

package/src/express/createBulkImportMiddleware.ts

@@ -7,8 +7,7 @@ const logger = createLogger('unchained:bulk-import');
 
 const methodWrongHandler = (res) => {
   logger.error('Method not supported, return 404');
-  res.writeHead(404);
-  res.end();
+  res.status(404).end();
   return;
 };
 
@@ -41,6 +40,9 @@ export default async function bulkImportMiddleware(
       meta: {},
     });
 
+    const validationStream = await context.services.files.createDownloadStream({ fileId: file._id });
+    await context.bulkImporter.validateEventStream(validationStream);
+
     input.payloadId = file._id;
     input.payloadSize = file.size;
 
@@ -53,12 +55,10 @@ export default async function bulkImportMiddleware(
       priority: 10,
     });
 
-    res.writeHead(200);
-    res.end(JSON.stringify(work));
+    res.status(200).send(work);
   } catch (e) {
-    logger.error(e.message);
-    res.writeHead(503);
-    res.end(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+    logger.error(e);
+    res.status(503).send({ name: e.name, code: e.code, message: e.message });
     return;
   }
 }

package/src/express/createERCMetadataMiddleware.ts

@@ -8,8 +8,7 @@ const { ROOT_URL = 'http://localhost:4010' } = process.env;
 
 const methodWrongHandler = (res) => {
   logger.error('Method not supported, return 404');
-  res.writeHead(404);
-  res.end();
+  res.status(404).end();
   return;
 };
 
@@ -51,15 +50,12 @@ const ercMetadataMiddleware: RequestHandler = async (
       return methodWrongHandler(res);
     }
 
-    const body = JSON.stringify(ercMetadata);
     res.status(200);
-    res.setHeader('Content-Type', 'application/json');
-    res.setHeader('Content-Length', new TextEncoder().encode(body).length);
-    return res.send(body);
+    return res.send(ercMetadata);
   } catch (e) {
-    logger.error(e.message);
-    res.writeHead(503);
-    res.end(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+    logger.error(e);
+    res.status(503);
+    res.send({ name: e.name, code: e.code, message: e.message });
     return;
   }
 };

package/src/express/createTempUploadMiddleware.ts

@@ -8,8 +8,7 @@ const logger = createLogger('unchained:temp-upload');
 
 const methodWrongHandler = (res) => {
   logger.error('Method not supported, return 404');
-  res.writeHead(404);
-  res.end();
+  res.status(404).end();
   return;
 };
 
@@ -47,14 +46,10 @@ export default async function tempUploadMiddleware(
     const fileUploadAdapter = getFileAdapter();
     const rawUrl = await fileUploadAdapter.createDownloadURL(file);
     const url = context.modules.files.normalizeUrl(rawUrl, {});
-    const body = JSON.stringify({ fileId: file._id, url, expires: expires.toISOString() });
-
-    res.writeHead(200);
-    res.end(body);
+    res.status(200).send({ fileId: file._id, url, expires: expires.toISOString() });
   } catch (e) {
-    logger.error(e.message);
-    res.writeHead(503);
-    res.end(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+    logger.error(e);
+    res.status(503).send({ name: e.name, code: e.code, message: e.message });
     return;
   }
 }

package/src/express/index.ts

@@ -16,6 +16,8 @@ import createTempUploadMiddleware from './createTempUploadMiddleware.js';
 import createMCPMiddleware from './createMCPMiddleware.js';
 import { API_EVENTS } from '../events.js';
 
+export * from './chatHandler.js';
+
 const resolveUserRemoteAddress = (req: e.Request) => {
   const remoteAddress =
     (req.headers['x-real-ip'] as string) ||

package/src/fastify/bulkImportHandler.ts

@@ -32,6 +32,9 @@ const bulkImportHandler: RouteHandlerMethod = async (
       chunkSizeBytes: 1024 * 1024 * 5, // 5MB chunks
     });
 
+    const validationStream = await context.services.files.createDownloadStream({ fileId: file._id });
+    await context.bulkImporter.validateEventStream(validationStream);
+
     input.payloadId = file._id;
     input.payloadSize = file.size;
 
@@ -44,15 +47,12 @@ const bulkImportHandler: RouteHandlerMethod = async (
       priority: 10,
     });
 
-    const body = JSON.stringify(work);
     res.status(200);
-    res.header('Content-Length', new TextEncoder().encode(body).length);
-    res.header('Content-Type', 'application/json');
-    return res.send(body);
+    return res.send(work);
   } catch (e) {
-    logger.error(e.message);
+    logger.error(e);
     res.status(503);
-    return res.send(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+    return res.send({ name: e.name, code: e.code, message: e.message });
   }
 };
 

package/src/fastify/chatHandler.ts

@@ -0,0 +1,140 @@
+import { FastifyInstance, RouteHandlerMethod, FastifyRequest } from 'fastify';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import {
+  convertToModelMessages,
+  experimental_createMCPClient as createMCPClient,
+  MCPTransport,
+  stepCountIs,
+  streamText,
+  ToolSet,
+} from 'ai';
+import generateImageHandler from '../chat/generateImageHandler.js';
+import defaultSystemPrompt from '../chat/defaultSystemPrompt.js';
+import normalizeToolsIndex from '../chat/normalizeToolsIndex.js';
+import { ChatConfiguration, errorHandler } from '../chat/utils.js';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:api:chat');
+
+const setupMCPChatHandler = (chatConfiguration: ChatConfiguration & any) => {
+  if (!chatConfiguration?.model) {
+    throw new Error('Model is required');
+  }
+
+  const {
+    tools: additionalTools = {},
+    unchainedMCPUrl = `${process.env.ROOT_URL}/mcp`,
+    imageGenerationTool,
+    ...restChatConfig
+  } = chatConfiguration;
+
+  const system = chatConfiguration.system ?? defaultSystemPrompt;
+
+  const mcpChatHandler: RouteHandlerMethod = async (req: FastifyRequest, res) => {
+    let client;
+    try {
+      if (req.method === 'OPTIONS') {
+        res.headers({
+          'access-control-allow-credentials': 'true',
+          'access-control-allow-private-network': 'true',
+        });
+        return res.status(200).send();
+      }
+
+      client = await createMCPClient({
+        transport: new StreamableHTTPClientTransport(new URL(unchainedMCPUrl), {
+          authProvider: null,
+          requestInit: {
+            headers: {
+              Cookie: req.headers.cookie || '',
+            },
+          },
+        }) as MCPTransport,
+      });
+
+      const defaultUnchainedTools = await client.tools();
+      const tools: ToolSet = {
+        ...defaultUnchainedTools,
+        ...additionalTools,
+      };
+      if (imageGenerationTool) {
+        tools.generateImage = generateImageHandler(req)(imageGenerationTool) as any;
+      }
+
+      if (req.method === 'GET') {
+        return res.status(200).send({
+          tools: normalizeToolsIndex(tools),
+          cached: false,
+        });
+      }
+
+      const { messages } = req.body as any;
+
+      const cacheControlledTools = { ...tools };
+      const keys = Object.keys(cacheControlledTools);
+      const lastKey = keys[keys.length - 1];
+
+      cacheControlledTools[lastKey] = {
+        ...cacheControlledTools[lastKey],
+        providerOptions: {
+          anthropic: { cacheControl: { type: 'ephemeral' } },
+        },
+      };
+
+      const normalizedMessages = convertToModelMessages(messages, { tools: cacheControlledTools });
+
+      if (normalizedMessages.length > 0) {
+        const lastIndex = normalizedMessages.length - 1;
+        normalizedMessages[lastIndex] = {
+          ...normalizedMessages[lastIndex],
+          providerOptions: { anthropic: { cacheControl: { type: 'ephemeral' } } },
+        };
+      }
+      const result = streamText({
+        stopWhen: stepCountIs(500),
+        ...restChatConfig,
+        messages: normalizedMessages.slice(-20),
+        system,
+        tools: cacheControlledTools,
+        onFinish: async () => {
+          await client?.close();
+        },
+        providerOptions: {
+          anthropic: {
+            cacheControl: {
+              type: 'ephemeral',
+            },
+          },
+        },
+      });
+
+      return res.send(
+        result.toUIMessageStreamResponse({
+          onError: errorHandler,
+        }),
+      );
+    } catch (err: any) {
+      logger.error(err);
+      await client?.close();
+      res.status(500);
+      return res.send({ error: errorHandler(err) });
+    }
+  };
+  return mcpChatHandler;
+};
+
+export const connectChat = (app: FastifyInstance, chatConfiguration: ChatConfiguration) => {
+  const handler = setupMCPChatHandler(chatConfiguration);
+
+  app.route({
+    url: '/chat',
+    method: ['POST', 'OPTIONS'],
+    handler,
+  });
+
+  app.route({
+    url: '/chat/tools',
+    method: ['GET', 'OPTIONS'],
+    handler,
+  });
+};

package/src/fastify/ercMetadataHandler.ts

@@ -39,15 +39,12 @@ const ercMetadataHandler: RouteHandlerMethod = async (
 
     if (!ercMetadata) return notFoundHandler(res);
 
-    const body = JSON.stringify(ercMetadata);
     res.status(200);
-    res.header('Content-Length', new TextEncoder().encode(body).length);
-    res.header('Content-Type', 'application/json');
-    return res.send(body);
+    return res.send(ercMetadata);
   } catch (e) {
-    logger.error(e.message);
+    logger.error(e);
     res.status(503);
-    return res.send(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+    return res.send({ name: e.name, code: e.code, message: e.message });
   }
 };
 

package/src/fastify/index.ts

@@ -11,10 +11,12 @@ import { User } from '@unchainedshop/core-users';
 import fastifySession from '@fastify/session';
 import fastifyCookie from '@fastify/cookie';
 import fastifyMultipart from '@fastify/multipart';
-import { FastifyBaseLogger, FastifyInstance, FastifyRequest } from 'fastify';
+import { FastifyBaseLogger, FastifyInstance, FastifyPluginAsync, FastifyRequest } from 'fastify';
 import { createLogger } from '@unchainedshop/logger';
 import mcpHandler from './mcpHandler.js';
 import tempUploadHandler from './tempUploadHandler.js';
+import fastifyStatic from '@fastify/static';
+export * from './chatHandler.js';
 
 const resolveUserRemoteAddress = (req: FastifyRequest) => {
   const remoteAddress =
@@ -234,3 +236,37 @@ export const connect = (
     registered();
   });
 };
+
+interface FastifyRouterOptions {
+  prefix?: string;
+}
+
+export const fastifyRouter: FastifyPluginAsync<FastifyRouterOptions> = async (
+  fastify: FastifyInstance,
+  opts,
+) => {
+  try {
+    const staticURL = import.meta.resolve('@unchainedshop/admin-ui');
+    const staticPath = new URL(staticURL).pathname.split('/').slice(0, -1).join('/');
+
+    await fastify.register(fastifyStatic, {
+      root: staticPath,
+      prefix: opts.prefix || '/',
+    });
+
+    fastify.setNotFoundHandler((request, reply) => {
+      if (request.raw.method === 'GET') {
+        return reply.type('text/html').sendFile('index.html');
+      } else {
+        return reply.status(404).send();
+      }
+    });
+  } catch {
+    if (process.env.NODE_ENV !== 'production') {
+      // Trying the default admin ui dev port
+      fastify.get('/', async (request, reply) => {
+        return reply.redirect('http://localhost:3000');
+      });
+    }
+  }
+};

package/src/fastify/mcpHandler.ts

@@ -85,8 +85,8 @@ const mcpHandler: RouteHandlerMethod = async (
 
     return res.status(405).send('Method Not Allowed');
   } catch (e) {
-    logger.error(e.message);
-    return res.status(503).send(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+    logger.error(e);
+    return res.status(503).send({ name: e.name, code: e.code, message: e.message });
   }
 };
 

package/src/fastify/tempUploadHandler.ts

@@ -37,15 +37,12 @@ const tempUploadHandler: RouteHandlerMethod = async (
     const fileUploadAdapter = getFileAdapter();
     const rawUrl = await fileUploadAdapter.createDownloadURL(file);
     const url = context.modules.files.normalizeUrl(rawUrl, {});
-    const body = JSON.stringify({ fileId: file._id, url, expires: expires.toISOString() });
     res.status(200);
-    res.header('Content-Length', new TextEncoder().encode(body).length);
-    res.header('Content-Type', 'application/json');
-    return res.send(body);
+    return res.send({ fileId: file._id, url, expires: expires.toISOString() });
   } catch (e) {
-    logger.error(e.message);
+    logger.error(e);
     res.status(503);
-    return res.send(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+    return res.send({ name: e.name, code: e.code, message: e.message });
   }
 };
 

package/src/mcp/tools/product/handlers/addProductMedia.ts

@@ -1,6 +1,6 @@
 import { Context } from '../../../../context.js';
 import { ProductNotFoundError } from '../../../../errors.js';
-import normalizeMediaUrl from '../../../utils/normalizeMediaUrl.js';
+import { getNormalizedProductDetails } from '../../../utils/getNormalizedProductDetails.js';
 import { Params } from '../schemas.js';
 
 export default async function addProductMedia(context: Context, params: Params<'ADD_MEDIA'>) {
@@ -39,8 +39,7 @@ export default async function addProductMedia(context: Context, params: Params<'
   if (file.expires && new Date(file.expires).getTime() < Date.now()) {
     throw new Error(`File upload expired: ${fileId}`);
   }
-
-  const linked = await services.files.linkFile({ fileId, size, type });
-  const media = await normalizeMediaUrl([{ ...linked, mediaId: linked._id }], context);
-  return { media };
+  await services.files.linkFile({ fileId, size, type });
+  const updatedProduct = await getNormalizedProductDetails(productId, context);
+  return { product: updatedProduct };
 }

package/src/mcp/tools/product/handlers/updateProduct.ts

@@ -1,6 +1,8 @@
 import { Context } from '../../../../context.js';
 import { ProductTypes } from '@unchainedshop/core-products';
 import {
+  CountryNotFoundError,
+  CurrencyNotFoundError,
   ProductNotFoundError,
   ProductWrongStatusError,
   ProductWrongTypeError,
@@ -9,7 +11,7 @@ import { getNormalizedProductDetails } from '../../../utils/getNormalizedProduct
 import { Params } from '../schemas.js';
 
 export default async function updateProduct(context: Context, params: Params<'UPDATE'>) {
-  const { modules } = context;
+  const { modules, loaders } = context;
   const { productId, product } = params;
 
   const existingProduct = await modules.products.findProduct({ productId });
@@ -64,6 +66,15 @@ export default async function updateProduct(context: Context, params: Params<'UP
   }
 
   if (product.commerce !== undefined) {
+    await Promise.all(
+      product.commerce.pricing.map(async ({ countryCode, currencyCode }) => {
+        const currency = await loaders.currencyLoader.load({ isoCode: currencyCode });
+        if (!currency) throw new CurrencyNotFoundError({ currencyCode });
+
+        const country = await loaders.countryLoader.load({ isoCode: countryCode });
+        if (!country) throw new CountryNotFoundError({ countryCode });
+      }),
+    );
     updateData.commerce = product.commerce;
   }
 

package/src/mcp/tools/product/schemas.ts

@@ -111,15 +111,19 @@ export const ProductSchema = z.object({
               .min(2)
               .max(2)
               .describe(
-                'ISO country code (e.g., US, DE) make sure the country exists in the system before using it. if it does not exists prompt the user to add the country. NEVER add it automatically',
+                'ISO country code (e.g., US, DE) make sure the country/countryCode exists in the system before using it. if it does not exists prompt the user to add the country. NEVER add it automatically',
               ),
           }),
         )
         .nonempty()
-        .describe('List of price configurations'),
+        .describe(
+          "List of price configurations always use countryCode and currencyCodes that are already registered in the system, don't use non existing iso codes.",
+        ),
     })
     .optional()
-    .describe('Commerce info - Available for ALL except CONFIGURABLE_PRODUCT & BUNDLE_PRODUCT'),
+    .describe(
+      "Commerce info - Available for ALL except CONFIGURABLE_PRODUCT. always use countryCode and currencyCodes that are already registered in the system, don't use non existing iso codes.",
+    ),
 });
 
 export const actionValidators = {

package/src/mcp/utils/getNormalizedProductDetails.ts

@@ -1,6 +1,9 @@
 import { ProductTypes } from '@unchainedshop/core-products';
 import { Context } from '../../context.js';
 import normalizeMediaUrl from './normalizeMediaUrl.js';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:api:mcp');
 
 export async function getNormalizedProductDetails(productId: string, context: Context) {
   const { modules, locale, loaders } = context;
@@ -84,7 +87,7 @@ export async function getNormalizedProductDetails(productId: string, context: Co
     });
   } catch {
     // Pricing might not be available for all products
-    console.warn('Pricing not available for product:', product._id);
+    logger.warn('Pricing not available for product:', product._id);
   }
 
   const productMedias = await modules.products.media.findProductMedias({ productId });

package/src/resolvers/mutations/orders/checkoutCart.ts

@@ -30,7 +30,7 @@ export default async function checkoutCart(
     const checkedOutOrder = await services.orders.checkoutOrder(order._id, transactionContext);
     return checkedOutOrder;
   } catch (error) {
-    logger.error(error.message, { userId, orderId: order._id });
+    logger.error(error, { userId, orderId: order._id });
     throw new OrderCheckoutError({
       userId,
       orderId: order._id,