feat(core): Support split by app with multiple auth options

.coderabbit.yaml

@@ -2,6 +2,11 @@
 reviews:
   profile: chill
   high_level_summary: true
+  path_instructions:
+    - path: "apps/demo/**"
+      instructions: "apps/demo directory contains demo application to testing purposes, can be used for sdk usages examples"
+    - path: "docs/**"
+      instructions: "Contains documentation for sdk, using mdx format and hosted by mintlify"
   path_filters:
     - "!**/dist/**"
     - "!**/build/**"

apps/demo/src/apps/calculator/index.ts

@@ -0,0 +1,50 @@
+import {App} from '@frontmcp/sdk';
+
+import AddTool from "./tools/add.tool";
+import SubtractTool from "./tools/subtract.tool";
+import MultiplyTool from "./tools/multiply.tool";
+import DivideTool from "./tools/divide.tool";
+import PowTool from "./tools/pow.tool";
+import ModuloTool from "./tools/modulo.tool";
+import SqrtTool from "./tools/sqrt.tool";
+import AbsTool from "./tools/abs.tool";
+import FloorTool from "./tools/floor.tool";
+import CeilTool from "./tools/ceil.tool";
+import RoundTool from "./tools/round.tool";
+import MinTool from "./tools/min.tool";
+import MaxTool from "./tools/max.tool";
+import ExpTool from "./tools/exp.tool";
+import {CachePlugin} from "@frontmcp/plugins";
+
+@App({
+  id: 'calculator',
+  name: 'Calculator MCP app',
+  providers: [],
+  plugins: [
+    CachePlugin.init({
+      type: 'redis',
+      config: {
+        host: 'localhost',
+        port: 6379,
+      }
+    })
+  ],
+  tools: [
+    AddTool,
+    SubtractTool,
+    MultiplyTool,
+    DivideTool,
+    PowTool,
+    ModuloTool,
+    SqrtTool,
+    AbsTool,
+    FloorTool,
+    CeilTool,
+    RoundTool,
+    MinTool,
+    MaxTool,
+    ExpTool,
+  ],
+})
+export default class CalculatorMcpApp {
+}

apps/demo/src/apps/calculator/tools/abs.tool.ts

@@ -0,0 +1,16 @@
+import {Tool, ToolContext} from "@frontmcp/sdk";
+import {z} from "zod";
+
+@Tool({
+  name: 'abs',
+  description: 'Absolute value of x',
+  inputSchema: {x: z.number()},
+  outputSchema: {result: z.number()}
+})
+export default class AbsTool extends ToolContext {
+  async execute(input: { x: number }) {
+    return {
+      result: Math.abs(input.x),
+    };
+  }
+}

apps/demo/src/apps/calculator/tools/add.tool.ts

@@ -0,0 +1,16 @@
+import {Tool, ToolContext} from "@frontmcp/sdk";
+import {z} from "zod";
+
+@Tool({
+  name: 'add',
+  description: 'Add two numbers',
+  inputSchema: {a: z.number(), b: z.number()},
+  outputSchema: {result: z.number()}
+})
+export default class AddTool extends ToolContext {
+  async execute(input: { a: number, b: number }) {
+    return {
+      result: input.a + input.b,
+    };
+  }
+}

apps/demo/src/apps/calculator/tools/ceil.tool.ts

@@ -0,0 +1,16 @@
+import {Tool, ToolContext} from "@frontmcp/sdk";
+import {z} from "zod";
+
+@Tool({
+  name: 'ceil',
+  description: 'Ceil of x (smallest integer ≥ x)',
+  inputSchema: {x: z.number()},
+  outputSchema: {result: z.number()}
+})
+export default class CeilTool extends ToolContext {
+  async execute(input: { x: number }) {
+    return {
+      result: Math.ceil(input.x),
+    };
+  }
+}

apps/demo/src/apps/calculator/tools/divide.tool.ts

@@ -0,0 +1,16 @@
+import {Tool, ToolContext} from "@frontmcp/sdk";
+import {z} from "zod";
+
+@Tool({
+  name: 'divide',
+  description: 'Divide a by b',
+  inputSchema: {a: z.number(), b: z.number().refine((n) => n !== 0, 'Division by zero is not allowed')},
+  outputSchema: {result: z.number()}
+})
+export default class DivideTool extends ToolContext {
+  async execute(input: { a: number, b: number }) {
+    return {
+      result: input.a / input.b,
+    };
+  }
+}

apps/demo/src/apps/calculator/tools/exp.tool.ts

@@ -0,0 +1,16 @@
+import {Tool, ToolContext} from "@frontmcp/sdk";
+import {z} from "zod";
+
+@Tool({
+  name: 'exp',
+  description: 'e raised to the power of x',
+  inputSchema: {x: z.number()},
+  outputSchema: {result: z.number()}
+})
+export default class ExpTool extends ToolContext {
+  async execute(input: { x: number }) {
+    return {
+      result: Math.exp(input.x),
+    };
+  }
+}

apps/demo/src/apps/calculator/tools/floor.tool.ts

@@ -0,0 +1,16 @@
+import {Tool, ToolContext} from "@frontmcp/sdk";
+import {z} from "zod";
+
+@Tool({
+  name: 'floor',
+  description: 'Floor of x (largest integer ≤ x)',
+  inputSchema: {x: z.number()},
+  outputSchema: {result: z.number()}
+})
+export default class FloorTool extends ToolContext {
+  async execute(input: { x: number }) {
+    return {
+      result: Math.floor(input.x),
+    };
+  }
+}

apps/demo/src/apps/calculator/tools/max.tool.ts

@@ -0,0 +1,16 @@
+import {Tool, ToolContext} from "@frontmcp/sdk";
+import {z} from "zod";
+
+@Tool({
+  name: 'max',
+  description: 'Maximum value in an array of numbers',
+  inputSchema: {values: z.array(z.number()).min(1)},
+  outputSchema: {result: z.number()}
+})
+export default class MaxTool extends ToolContext {
+  async execute(input: { values: number[] }) {
+    return {
+      result: Math.max(...input.values),
+    };
+  }
+}

apps/demo/src/apps/calculator/tools/min.tool.ts

@@ -0,0 +1,16 @@
+import {Tool, ToolContext} from "@frontmcp/sdk";
+import {z} from "zod";
+
+@Tool({
+  name: 'min',
+  description: 'Minimum value in an array of numbers',
+  inputSchema: {values: z.array(z.number()).min(1)},
+  outputSchema: {result: z.number()}
+})
+export default class MinTool extends ToolContext {
+  async execute(input: { values: number[] }) {
+    return {
+      result: Math.min(...input.values),
+    };
+  }
+}

apps/demo/src/apps/calculator/tools/modulo.tool.ts

@@ -0,0 +1,16 @@
+import {Tool, ToolContext} from "@frontmcp/sdk";
+import {z} from "zod";
+
+@Tool({
+  name: 'modulo',
+  description: 'Remainder of a divided by b (JavaScript % semantics)',
+  inputSchema: {a: z.number(), b: z.number().refine((n) => n !== 0, 'Modulo by zero is not allowed')},
+  outputSchema: {result: z.number()}
+})
+export default class ModuloTool extends ToolContext {
+  async execute(input: { a: number, b: number }) {
+    return {
+      result: input.a % input.b,
+    };
+  }
+}

apps/demo/src/apps/calculator/tools/multiply.tool.ts

@@ -0,0 +1,16 @@
+import {Tool, ToolContext} from "@frontmcp/sdk";
+import {z} from "zod";
+
+@Tool({
+  name: 'multiply',
+  description: 'Multiply two numbers',
+  inputSchema: {a: z.number(), b: z.number()},
+  outputSchema: {result: z.number()}
+})
+export default class MultiplyTool extends ToolContext {
+  async execute(input: { a: number, b: number }) {
+    return {
+      result: input.a * input.b,
+    };
+  }
+}

apps/demo/src/apps/calculator/tools/pow.tool.ts

@@ -0,0 +1,17 @@
+import {Tool, ToolContext} from "@frontmcp/sdk";
+import {z} from "zod";
+
+@Tool({
+  name: 'pow',
+  description: 'Raise a to the power of b (a^b)',
+  inputSchema: {a: z.number(), b: z.number()},
+  outputSchema: {result: z.number()}
+})
+export default class PowTool extends ToolContext {
+  async execute(input: { a: number, b: number }) {
+    const result = Math.pow(input.a, input.b);
+    return {
+      result,
+    };
+  }
+}

apps/demo/src/apps/calculator/tools/round.tool.ts

@@ -0,0 +1,23 @@
+import {Tool, ToolContext} from "@frontmcp/sdk";
+import {z} from "zod";
+
+@Tool({
+  name: 'round',
+  description: 'Round x to nearest integer or to a given number of decimal places',
+  inputSchema: {
+    x: z.number(),
+    digits: z.number().int().min(0).max(15).optional(),
+  },
+  outputSchema: {result: z.number()}
+})
+export default class RoundTool extends ToolContext {
+  async execute(input: { x: number, digits?: number }) {
+    const { x, digits } = input;
+    if (digits === undefined) {
+      return { result: Math.round(x) };
+    }
+    const factor = Math.pow(10, digits);
+    const result = Math.round((x + Number.EPSILON) * factor) / factor;
+    return { result };
+  }
+}

apps/demo/src/apps/calculator/tools/sqrt.tool.ts

@@ -0,0 +1,16 @@
+import {Tool, ToolContext} from "@frontmcp/sdk";
+import {z} from "zod";
+
+@Tool({
+  name: 'sqrt',
+  description: 'Square root of x',
+  inputSchema: {x: z.number().nonnegative('x must be >= 0')},
+  outputSchema: {result: z.number()}
+})
+export default class SqrtTool extends ToolContext {
+  async execute(input: { x: number }) {
+    return {
+      result: Math.sqrt(input.x),
+    };
+  }
+}

apps/demo/src/apps/calculator/tools/subtract.tool.ts

@@ -0,0 +1,16 @@
+import {Tool, ToolContext} from "@frontmcp/sdk";
+import {z} from "zod";
+
+@Tool({
+  name: 'subtract',
+  description: 'Subtract b from a',
+  inputSchema: {a: z.number(), b: z.number()},
+  outputSchema: {result: z.number()}
+})
+export default class SubtractTool extends ToolContext {
+  async execute(input: { a: number, b: number }) {
+    return {
+      result: input.a - input.b,
+    };
+  }
+}

apps/demo/src/apps/employee-time/index.ts

@@ -0,0 +1,39 @@
+import {App} from '@frontmcp/sdk';
+import {CachePlugin} from '@frontmcp/plugins';
+import {createEmployeeRedisProvider} from './providers/redis.provider';
+import {createEmployeeDirectoryProvider} from './providers/employee-directory.provider';
+import SiteAuthorizationPlugin from './plugins/site-authorization.plugin';
+
+import RegisterEntryTool from './tools/register-entry.tool';
+import RegisterExitTool from './tools/register-exit.tool';
+import AdminAddEntryTool from './tools/admin-add-entry.tool';
+import AdminAddExitTool from './tools/admin-add-exit.tool';
+import GetEmployeeDetailsTool from './tools/get-employee-details.tool';
+import ReportHoursTool from './tools/report-hours.tool';
+import ListEmployeesTool from './tools/list-employees.tool';
+
+@App({
+  id: 'employee-time',
+  name: 'Employee Time MCP app',
+  providers: [
+    createEmployeeRedisProvider,
+    createEmployeeDirectoryProvider,
+  ],
+  plugins: [
+    SiteAuthorizationPlugin,
+    CachePlugin.init({
+      type: 'redis',
+      config: { host: 'localhost', port: 6379 },
+    })
+  ],
+  tools: [
+    RegisterEntryTool,
+    RegisterExitTool,
+    AdminAddEntryTool,
+    AdminAddExitTool,
+    GetEmployeeDetailsTool,
+    ReportHoursTool,
+    ListEmployeesTool,
+  ],
+})
+export default class EmployeeTimeMcpApp {}