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

package/src/express/chatHandler.ts

@@ -0,0 +1,204 @@
+import express from 'express';
+import type { Express, Request, RequestHandler, Response } from 'express';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.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 resourceTransport = new StreamableHTTPClientTransport(new URL(unchainedMCPUrl), {
+      requestInit: {
+        headers: {
+          Cookie: req.headers.cookie || '',
+        },
+      },
+    });
+
+    const sdkClient = new Client(
+      { name: 'unchained-chat-client', version: '1.0.0' },
+      {
+        capabilities: { resources: {} },
+      },
+    );
+    await sdkClient.connect(resourceTransport as any);
+    const transport = new StreamableHTTPClientTransport(new URL(unchainedMCPUrl), {
+      requestInit: {
+        headers: {
+          Cookie: req.headers.cookie || '',
+        },
+      },
+    });
+
+    const client = await createMCPClient({
+      transport: transport as MCPTransport,
+    });
+
+    try {
+      const defaultUnchainedTools = await client.tools();
+      let resourceContext = '';
+      try {
+        const resources = await sdkClient.listResources();
+        if (resources?.resources) {
+          const resourceTexts = await Promise.all(
+            resources.resources.map(async (resource) => {
+              try {
+                const content = await sdkClient.readResource({ uri: resource.uri });
+                if (content?.contents?.[0]?.text) {
+                  return `${resource.name}:\n${content.contents[0].text}`;
+                }
+              } catch (e) {
+                console.error(`Failed to read resource ${resource.uri}:`, e);
+              }
+              return null;
+            }),
+          );
+          resourceContext =
+            '\n\nAVAILABLE SHOP CONFIGURATION:\n' + resourceTexts.filter(Boolean).join('\n\n');
+        }
+      } catch (e) {
+        console.error('Failed to fetch MCP resources:', e);
+      }
+
+      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 MAX_MESSAGES = 10;
+      let startIndex = Math.max(0, normalizedMessages.length - MAX_MESSAGES);
+      while (startIndex < normalizedMessages.length) {
+        const msg = normalizedMessages[startIndex];
+        const hasOrphanedToolResult =
+          Array.isArray(msg.content) && msg.content.some((c: any) => c.type === 'tool-result');
+
+        if (!hasOrphanedToolResult) break;
+        startIndex++;
+      }
+      const messagesToInclude = normalizedMessages.slice(startIndex);
+
+      const result = streamText({
+        stopWhen: stepCountIs(10),
+        temperature: 0.2,
+        maxRetries: 3,
+        ...restChatConfig,
+        system: system + resourceContext,
+        model,
+        tools: cacheControlledTools,
+        onFinish: async () => {
+          await client?.close();
+        },
+        messages: messagesToInclude,
+        providerOptions: {
+          anthropic: {
+            cacheControl: {
+              type: 'ephemeral',
+            },
+          },
+        },
+      });
+
+      result.pipeUIMessageStreamToResponse(res, {
+        onError: errorHandler,
+      });
+    } catch (err) {
+      await client?.close();
+      await sdkClient?.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,10 @@ export default async function bulkImportMiddleware(
       meta: {},
     });
 
+    const validationStream = await context.services.files.createDownloadStream({ fileId: file._id });
+    if (!validationStream) throw new Error('Could not create download stream from uploaded file');
+    await context.bulkImporter.validateEventStream(validationStream);
+
     input.payloadId = file._id;
     input.payloadSize = file.size;
 
@@ -53,12 +56,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;
 };
 
@@ -30,14 +29,16 @@ const ercMetadataMiddleware: RequestHandler = async (
     if (!pathname.toLowerCase().endsWith('.json')) throw new Error('Invalid ERC Metadata URI');
 
     const fileName = pathname.split('/').pop();
-    const chainTokenId = fileName.slice(0, fileName.lastIndexOf('.'));
+
+    if (!fileName) throw new Error('Invalid ERC Metadata URI');
+    const tokenSerialNumber = 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,
+      tokenSerialNumber,
       contractAddress: product?.tokenization?.contractAddress,
     });
 
@@ -51,15 +52,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/createMCPMiddleware.ts

@@ -34,7 +34,7 @@ const handlePostRequest: RequestHandler = async (req: Request & { unchainedConte
       }
     };
 
-    const roles = req.unchainedContext.user.roles || [];
+    const roles = req.unchainedContext.user?.roles || [];
     const server = createMcpServer(req.unchainedContext, roles);
     await server.connect(transport);
   } else {

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;
 };
 
@@ -46,15 +45,12 @@ export default async function tempUploadMiddleware(
 
     const fileUploadAdapter = getFileAdapter();
     const rawUrl = await fileUploadAdapter.createDownloadURL(file);
+    if (!rawUrl) throw new Error('Could not create download URL for 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) ||
@@ -39,7 +41,7 @@ const {
   UNCHAINED_COOKIE_NAME = 'unchained_token',
   UNCHAINED_COOKIE_PATH = '/',
   UNCHAINED_COOKIE_DOMAIN,
-  UNCHAINED_COOKIE_SAMESITE,
+  UNCHAINED_COOKIE_SAMESITE = 'none',
   UNCHAINED_COOKIE_INSECURE,
 } = process.env;
 

package/src/fastify/bulkImportHandler.ts

@@ -32,6 +32,11 @@ const bulkImportHandler: RouteHandlerMethod = async (
       chunkSizeBytes: 1024 * 1024 * 5, // 5MB chunks
     });
 
+    const validationStream = await context.services.files.createDownloadStream({ fileId: file._id });
+    if (!validationStream) throw new Error('Could not create download stream from uploaded file');
+
+    await context.bulkImporter.validateEventStream(validationStream);
+
     input.payloadId = file._id;
     input.payloadSize = file.size;
 
@@ -44,15 +49,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,198 @@
+import { FastifyInstance, RouteHandlerMethod, FastifyRequest } from 'fastify';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.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();
+      }
+
+      const resourceTransport = new StreamableHTTPClientTransport(new URL(unchainedMCPUrl), {
+        requestInit: {
+          headers: {
+            Cookie: req.headers.cookie || '',
+          },
+        },
+      });
+
+      const sdkClient = new Client(
+        { name: 'unchained-chat-client', version: '1.0.0' },
+        {
+          capabilities: { resources: {} },
+        },
+      );
+      await sdkClient.connect(resourceTransport as any);
+
+      const transport = new StreamableHTTPClientTransport(new URL(unchainedMCPUrl), {
+        requestInit: {
+          headers: {
+            Cookie: req.headers.cookie || '',
+          },
+        },
+      });
+
+      client = await createMCPClient({
+        transport: transport as MCPTransport,
+      });
+
+      const defaultUnchainedTools = await client.tools();
+
+      let resourceContext = '';
+      try {
+        const resources = await sdkClient.listResources();
+        if (resources?.resources) {
+          const resourceTexts = await Promise.all(
+            resources.resources.map(async (resource) => {
+              try {
+                const content = await sdkClient.readResource({ uri: resource.uri });
+                if (content?.contents?.[0]?.text) {
+                  return `${resource.name}:\n${content.contents[0].text}`;
+                }
+              } catch (e) {
+                logger.error(`Failed to read resource ${resource.uri}:`, e);
+              }
+              return null;
+            }),
+          );
+          resourceContext =
+            '\n\nAVAILABLE SHOP CONFIGURATION:\n' + resourceTexts.filter(Boolean).join('\n\n');
+        }
+      } catch (e) {
+        logger.error('Failed to fetch MCP resources:', e);
+      }
+
+      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 MAX_MESSAGES = 10;
+      let startIndex = Math.max(0, normalizedMessages.length - MAX_MESSAGES);
+      while (startIndex < normalizedMessages.length) {
+        const msg = normalizedMessages[startIndex];
+        const hasOrphanedToolResult =
+          Array.isArray(msg.content) && msg.content.some((c: any) => c.type === 'tool-result');
+
+        if (!hasOrphanedToolResult) break;
+        startIndex++;
+      }
+      const messagesToInclude = normalizedMessages.slice(startIndex);
+
+      const result = streamText({
+        stopWhen: stepCountIs(500),
+        temperature: 0.2,
+        maxRetries: 3,
+        ...restChatConfig,
+        messages: messagesToInclude,
+        system: system + resourceContext,
+        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

@@ -27,7 +27,7 @@ const ercMetadataHandler: RouteHandlerMethod = async (
     const product = await loaders.productLoader.load({ productId });
 
     const [token] = await modules.warehousing.findTokens({
-      chainTokenId: (tokenFileName || localeOrTokenFilename).toLowerCase().replace('.json', ''),
+      tokenSerialNumber: (tokenFileName || localeOrTokenFilename).toLowerCase().replace('.json', ''),
       contractAddress: product?.tokenization?.contractAddress,
     });
 
@@ -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 =
@@ -36,7 +38,7 @@ const {
   UNCHAINED_COOKIE_NAME = 'unchained_token',
   UNCHAINED_COOKIE_PATH = '/',
   UNCHAINED_COOKIE_DOMAIN,
-  UNCHAINED_COOKIE_SAMESITE,
+  UNCHAINED_COOKIE_SAMESITE = 'none',
   UNCHAINED_COOKIE_INSECURE,
 } = process.env;
 
@@ -158,7 +160,7 @@ export const connect = (
   if (!fastify.hasPlugin('@fastify/cookie')) {
     fastify.register(fastifyCookie);
   }
-  fastify.register(fastifySession, {
+  fastify.register(fastifySession as any, {
     secret: process.env.UNCHAINED_TOKEN_SECRET,
     cookieName,
     store: MongoStore.create({
@@ -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 });
   }
 };