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

package/src/chat/defaultSystemPrompt.ts

@@ -0,0 +1,7 @@
+const defaultSystemPrompt = `Use tools when requested but do not provide summaries or explanations after tool calls. Only return the direct tool results. Do not include the data in your summary, just write a summary about it in one short paragraph and never list all the fields of a result, just summarize paragraph about your findings, if necessary.
+    Rules for using the Unchained MCP tools:
+    - All prices are integer type and to correctly determine the currency decimal points you need to check currencies.
+    - Determine the currently used language / locale for creating and updating products, filters and assortments by checking Shop Info.
+`;
+
+export default defaultSystemPrompt;

package/src/chat/generateImageHandler.ts

@@ -0,0 +1,78 @@
+import { experimental_generateImage, ImageModel, tool } from 'ai';
+import { fileTypeFromBuffer } from 'file-type';
+import { z } from 'zod';
+
+const inputSchema = z.object({
+  prompt: z.string().describe('The prompt to generate the image from'),
+  size: z
+    .enum([
+      '512x512',
+      '768x768',
+      '1024x1024',
+      '512x896',
+      '640x1120',
+      '768x1344',
+      '1024x1792',
+      '896x512',
+      '1120x640',
+      '1344x768',
+      '1792x1024',
+    ])
+    .optional()
+    .describe('The size of the image (default is 1024x1024).'),
+});
+
+const generateImageHandler =
+  (req: any) =>
+  ({
+    model,
+    uploadUrl = `${process.env.ROOT_URL}/temp-upload`,
+  }: {
+    model: ImageModel;
+    uploadUrl?: string;
+  }) => {
+    return tool<any>({
+      description: 'Generate an image based on the prompt',
+      inputSchema: inputSchema as any,
+      name: 'generate_image',
+      execute: async ({ prompt, size = '1024x1024' }) => {
+        try {
+          const { image } = await experimental_generateImage({
+            model,
+            prompt,
+            size: size as any,
+          });
+
+          const buffer = Buffer.from(image.base64, 'base64');
+          const fileType = await fileTypeFromBuffer(buffer);
+          const extension = fileType?.ext || 'png';
+          const mime = fileType?.mime || 'image/png';
+
+          const filename = `image-${Date.now()}.${extension}`;
+          const file = new File([buffer], filename, { type: mime });
+          const formData = new FormData();
+          formData.append('image', file);
+
+          const uploadRes = await fetch(uploadUrl, {
+            method: 'POST',
+            body: formData,
+            credentials: 'include',
+            headers: {
+              Cookie: req?.headers?.cookie || req?.headers?.get('cookie') || '',
+            },
+          });
+
+          if (!uploadRes.ok) {
+            throw new Error(`Image upload failed: ${uploadRes.statusText}`);
+          }
+
+          const { url } = await uploadRes.json();
+          return { imageUrl: url, prompt };
+        } catch (error) {
+          return `Error Generating image: ${(error as Error).message}`;
+        }
+      },
+    });
+  };
+
+export default generateImageHandler;

package/src/chat/normalizeToolsIndex.ts

@@ -0,0 +1,11 @@
+import { categorizeTools } from './utils.js';
+
+export default function normalizeToolsIndex(mcpTools: any) {
+  const tools = Object.entries(mcpTools).map(([name, tool]: any) => ({
+    name,
+    description: tool.description || '',
+    parameters: tool.parameters || {},
+    category: categorizeTools(name),
+  }));
+  return tools;
+}

package/src/chat/utils.ts

@@ -0,0 +1,31 @@
+import { ImageModel, NoSuchToolError, InvalidArgumentError, streamText } from 'ai';
+
+type StreamTextParams = Parameters<typeof streamText>[0];
+
+export type ChatConfiguration = Omit<StreamTextParams, 'messages'> & {
+  unchainedMCPUrl?: string;
+  imageGenerationTool?: { model: ImageModel; uploadUrl?: string };
+};
+
+export const errorHandler = (error: any): string => {
+  if (NoSuchToolError.isInstance(error)) return 'NoSuchToolError';
+  if (InvalidArgumentError.isInstance(error)) return 'InvalidToolArgumentsError';
+  /* if (ToolExecutionError.isInstance(error)) return 'ToolExecutionError'; */
+  if (error?.message?.toLowerCase()?.includes('forbidden')) return 'NetworkError';
+  if (error?.message?.toLowerCase()?.includes('limit')) return 'LimitExceeded';
+  return `Failed to stream response: ${error?.message || 'Unknown error'}`;
+};
+
+export const categorizeTools = (toolName: string): string => {
+  const name = toolName.toLowerCase();
+
+  if (name.includes('product')) return 'Product Management';
+  if (name.includes('order')) return 'Order Management';
+  if (name.includes('customer') || name.includes('user')) return 'Customer Management';
+  if (name.includes('shop') || name.includes('settings')) return 'Shop Configuration';
+  if (name.includes('assortment')) return 'Assortments';
+  if (name.includes('filter')) return 'Filters';
+  if (name.includes('image') || name.includes('generate')) return 'Media & Content';
+
+  return 'Other Tools';
+};

package/src/context.ts

@@ -29,6 +29,9 @@ export interface CustomAdminUiProperties {
 export interface AdminUiConfig {
   customProperties?: CustomAdminUiProperties[];
   singleSignOnURL?: string;
+  defaultProductTags?: string[];
+  defaultAssortmentTags?: string[];
+  defaultUserTags?: string[];
 }
 
 export interface UnchainedHTTPServerContext {

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

@@ -1,4 +1,3 @@
-import path from 'node:path';
 import { createLogger } from '@unchainedshop/logger';
 import { Context } from '../context.js';
 import { Request, RequestHandler } from 'express';
@@ -9,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;
 };
 
@@ -25,16 +23,20 @@ const ercMetadataMiddleware: RequestHandler = async (
 
     const { services, modules, loaders, locale } = req.unchainedContext;
     const url = new URL(req.url, ROOT_URL);
-    const parsedPath = path.parse(url.pathname);
 
-    if (parsedPath.ext !== '.json') throw new Error('Invalid ERC Metadata URI');
+    // Replace path.parse with URL/string methods
+    const pathname = url.pathname;
+    if (!pathname.toLowerCase().endsWith('.json')) throw new Error('Invalid ERC Metadata URI');
+
+    const fileName = pathname.split('/').pop();
+    const chainTokenId = fileName.slice(0, fileName.lastIndexOf('.'));
 
     const [, productId, localeOrTokenFilename, tokenFileName] = url.pathname.split('/');
 
     const product = await loaders.productLoader.load({ productId });
 
     const [token] = await modules.warehousing.findTokens({
-      chainTokenId: parsedPath.name,
+      chainTokenId,
       contractAddress: product?.tokenization?.contractAddress,
     });
 
@@ -48,16 +50,12 @@ const ercMetadataMiddleware: RequestHandler = async (
       return methodWrongHandler(res);
     }
 
-    const body = JSON.stringify(ercMetadata);
-    res.writeHead(200, {
-      'Content-Length': Buffer.byteLength(body),
-      'Content-Type': 'text/plain',
-    });
-    res.end(body);
+    res.status(200);
+    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', Buffer.byteLength(body));
-    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', Buffer.byteLength(body));
-    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 });
   }
 };