Multi-tool functions

Preview — Jelou Functions is in preview. The API and behavior may change without prior notice.

When to use `app()` vs `define()`?

Pattern	When to use it
`define()`	A single operation with one HTTP endpoint
`app()`	Multiple related tools you want to deploy together

If your project has a single handler, use define(). If you need to group multiple operations — for example, sending and reading emails from the same service — use app().

Basic example

index.ts

import { app, define, z } from "@jelou/functions";

export default app({
  config: { cors: { origin: "*" }, timeout: 30_000 },
  tools: {
    sendEmail: define({
      description: "Sends an email",
      input: z.object({ to: z.string(), subject: z.string(), body: z.string() }),
      config: { timeout: 5_000 },
      handler: async (input) => ({ sent: true }),
    }),
    readInbox: define({
      description: "Reads inbox messages",
      input: z.object({ limit: z.coerce.number().default(10) }),
      handler: async (input) => ({ messages: [] }),
    }),
  },
});

Local testing

Start the server with jelou functions dev and test each tool at its route:

curl -X POST http://localhost:3000/send-email \
  -H "Content-Type: application/json" \
  -d '{"to": "[email protected]", "subject": "Hello", "body": "Welcome"}'

{
  "sent": true
}

curl http://localhost:3000/read-inbox?limit=5

{
  "messages": []
}

If you send an invalid field, you receive a 400 with details:

curl -X POST http://localhost:3000/send-email \
  -H "Content-Type: application/json" \
  -d '{"to": ""}'

{
  "error": "Validation failed",
  "details": [
    { "path": ["subject"], "message": "Required", "code": "invalid_type" },
    { "path": ["body"], "message": "Required", "code": "invalid_type" }
  ]
}

API

import { app } from "@jelou/functions";

const edgeApp = app({
  config: { cors: { origin: "*" }, timeout: 30_000 },
  tools: {
    /* ... your define() here ... */
  },
});

export default edgeApp;

Type signature:

function app(options: {
  config?: AppConfig;
  tools: Record<string, AnyEdgeFunction>;
}): EdgeApp;

`AppConfig`

interface AppConfig {
  cors?: {
    origin?: string | string[];
    methods?: string[];
    headers?: string[];
    credentials?: boolean;
    maxAge?: number;
  };
  timeout?: number;
  methods?: string[];
  mcp?: boolean;
}

Field	Type	Default	Description
`cors`	`object`	`{ origin: "*" }`	Global CORS configuration
`timeout`	`number`	`30000`	Timeout in ms for all tools
`methods`	`string[]`	`["GET","POST","PUT","PATCH","DELETE"]`	Allowed HTTP methods
`mcp`	`boolean`	`true`	Register tools in the MCP server

Auto-generated routes

Your tools object keys are automatically converted to kebab-case to generate HTTP routes:

Key	Route
`sendEmail`	`/send-email`
`readInbox`	`/read-inbox`
`MyTool`	`/my-tool`

To customize a route, use config.path in the individual define():

tools: {
  sendEmail: define({
    config: { path: "/emails/send" },
    handler: async (input) => ({ sent: true }),
  }),
}

Config combination

The global config of app() applies to all tools. Each define() can override specific values:

Field	Behavior
`timeout`	Tool overrides the global
`methods`	Tool overrides the global
`cors`	Tool overrides the global
`mcp`	Tool overrides the global
`path`	Always per tool
`cron`	Always per tool

export default app({
  config: { timeout: 30_000, cors: { origin: "*" } },
  tools: {
    fast: define({
      config: { timeout: 5_000 },
      handler: async () => ({ ok: true }),
    }),
    slow: define({
      handler: async () => ({ ok: true }),
    }),
  },
});

In this example, fast has a 5-second timeout and slow inherits the global 30 seconds. Both share the CORS configuration.

Health endpoint

In app mode, /__health returns information about all tools:

{
  "mode": "app",
  "tools": [
    {
      "key": "sendEmail",
      "name": "Send Email",
      "description": "Sends an email",
      "path": "/send-email",
      "cron": []
    },
    {
      "key": "readInbox",
      "name": "Read Inbox",
      "description": "Reads inbox messages",
      "path": "/read-inbox",
      "cron": []
    }
  ]
}

Type guards

Use isEdgeApp() and isEdgeFunction() to identify the export type at runtime:

import { isEdgeApp, isEdgeFunction } from "@jelou/functions";

isEdgeApp(module);      // true if created with app()
isEdgeFunction(module);  // true if created with define()

Multi-tool cron

Each tool inside app() can have its own independent cron schedules. Cron requests are sent to the specific route of each tool.

export default app({
  tools: {
    dailyCleanup: define({
      description: "Cleans up stale records",
      input: z.object({}),
      config: { cron: [{ expression: "0 3 * * *", timezone: "UTC" }] },
      handler: async (_input, ctx) => {
        if (!ctx.isCron) return { skipped: true };
        return { cleaned: true };
      },
    }),
    hourlySync: define({
      description: "Syncs external data",
      input: z.object({}),
      config: { cron: [{ expression: "0 * * * *" }] },
      handler: async (_input, ctx) => {
        if (!ctx.isCron) return { skipped: true };
        return { synced: true };
      },
    }),
  },
});

The 10 cron schedule limit is aggregated across all tools in an app(). If dailyCleanup has 3 and hourlySync has 4, only 3 remain available.

Multi-tool MCP

A single MCP server at /mcp automatically registers all tools from the app(). To exclude a tool from the MCP registry, use mcp: false in its config:

export default app({
  tools: {
    publicTool: define({
      description: "Visible to MCP",
      input: z.object({}),
      handler: async () => ({}),
    }),
    internalTool: define({
      description: "HTTP only",
      input: z.object({}),
      config: { mcp: false },
      handler: async () => ({}),
    }),
  },
});

In this example, AI agents only discover publicTool via MCP. internalTool is only accessible via direct HTTP at its /internal-tool route.

Exposed routes (app mode)

Route	Description
`/__health`	Health check with tool list
`/mcp`	Unified MCP server (unless `config.mcp: false` globally)
`/<tool-key>`	Each tool’s route (kebab-case or custom `config.path`)

Common issues

404 on tool route
Validation fails with 400
Tool does not appear in MCP

tools keys are converted to kebab-case. If your key is sendEmail, the route is /send-email, not /sendEmail.Verify the actual routes with the health check:

curl http://localhost:3000/__health

{
  "mode": "app",
  "tools": [
    { "key": "sendEmail", "path": "/send-email" },
    { "key": "readInbox", "path": "/read-inbox" }
  ]
}

Schema validation runs before the handler. If you receive a 400, check the details array:

curl -X POST http://localhost:3000/send-email \
  -H "Content-Type: application/json" \
  -d '{"to": 12345}'

{
  "error": "Validation failed",
  "details": [
    { "path": ["to"], "message": "Expected string, received number", "code": "invalid_type" },
    { "path": ["subject"], "message": "Required", "code": "invalid_type" },
    { "path": ["body"], "message": "Required", "code": "invalid_type" }
  ]
}

Each entry in details indicates the field (path), what was expected (message), and the Zod code (code).

If a tool has config: { mcp: false }, it is not registered in the MCP server. Verify which tools are exposed:

curl http://localhost:3000/mcp

{
  "tools": [
    { "name": "send-email", "description": "Sends an email", "inputSchema": { "..." } }
  ]
}

If a tool is missing, check that it does not have mcp: false in its config.

Next steps

Testing

Learn to test multi-tool functions with createMockApp().

MCP

Configure the unified MCP server for your AI agents.

Cron

Independent schedules per tool inside app().

Getting Started

Developer

Jelou CLI

Outbound Messaging

Management

Marketplace

Channels

Configuration

Billing

When to use `app()` vs `define()`?

Basic example

Local testing

API

`AppConfig`

Auto-generated routes

Config combination

Health endpoint

Type guards

Multi-tool cron

Multi-tool MCP

Exposed routes (app mode)

Common issues

Next steps

Testing

MCP

Cron

​When to use app() vs define()?

​Basic example

​Local testing

​API

​AppConfig

​Auto-generated routes

​Config combination

​Health endpoint

​Type guards

​Multi-tool cron

​Multi-tool MCP

​Exposed routes (app mode)

​Common issues

​Next steps

Testing

MCP

Cron

When to use `app()` vs `define()`?

Basic example

Local testing

API

`AppConfig`

Auto-generated routes

Config combination

Health endpoint

Type guards

Multi-tool cron

Multi-tool MCP

Exposed routes (app mode)

Common issues

Next steps