MCP

bun add @absolutejs/mcp

import { Elysia } from "elysia";
import { mcpServer, verifyBearer } from "@absolutejs/mcp";
import { verifyJwt } from "@absolutejs/auth"; // or any JWT verifier

type Caller = { userId: string };

const server = new Elysia().use(
  mcpServer<Caller>({
    path: "/mcp",
    issuer: "https://your.app",
    serverInfo: { name: "your-app", title: "Your App", version: "1.0.0" },
    instructions: "What the model should know about this server.",
    scopesSupported: ["openid", "mcp"],
    serveRootMetadata: true,

    // You decide who is allowed in. verifyBearer does the standard OAuth
    // access-token checks; add your own (billing, role, MFA) on top.
    authorize: async (request) => {
      const token = await verifyBearer({
        audience: "https://your.app/mcp",
        request,
        issuer: "https://your.app",
        requiredScope: "mcp",
        verify: (jwt) => verifyJwt(jwt, publicJwk),
      });
      if ("error" in token) return { ok: false, reason: token.error };
      return { ok: true, caller: { userId: token.subject } };
    },

    // Called once per request; build the tools for this caller.
    tools: ({ caller }) => buildToolsFor(caller.userId),
  }),
);

import { createAgency, createMemoryAgencyStore } from "@absolutejs/agency";

const agency = createAgency({ policy, store: createMemoryAgencyStore() });

mcpServer<Caller>({
  agency: {
    enforcement: agency,
    resolveActor: ({ caller, scopes }) => ({
      agentId: caller.agentId,
      delegationId: caller.delegationId,
      scopes,
      userId: caller.userId,
    }),
  },
  // normal MCP config…
});

tasks: {
  authorizationKey: (caller) => caller.userId,
  shouldCreate: ({ name }) => name === "long_running_report",
  store: createMemoryMcpTaskStore(), // use a durable shared store in production
  ttlMs: 60 * 60 * 1000,
}

tools: () => ({
  long_running_report: {
    taskSupport: "optional", // "required" and "forbidden" are also supported
    // normal tool definition…
  },
})

import { Elysia } from 'elysia';
import { mcpServer, verifyBearer } from '@absolutejs/mcp';

type Caller = { userId: string };

const server = new Elysia().use(
	mcpServer<Caller>({
		path: '/mcp',
		issuer: 'https://your.app',
		serverInfo: { name: 'your-app', title: 'Your App', version: '1.0.0' },
		instructions: 'What the model should know about this server.',
		scopesSupported: ['openid', 'mcp'],
		serveRootMetadata: true,

		// You decide who is allowed in. verifyBearer does the standard
		// OAuth access-token checks; add your own on top.
		authorize: async (request) => {
			const token = await verifyBearer({
				request,
				issuer: 'https://your.app',
				requiredScope: 'mcp',
				verify: (jwt) => verifyJwt(jwt, publicJwk)
			});
			if ('error' in token) return { ok: false, reason: token.error };
			return { ok: true, caller: { userId: token.subject } };
		},

		// Called once per request; build the tools for this caller.
		tools: ({ caller }) => buildToolsFor(caller.userId)
	})
);

import {
	FEEDBACK_INSTRUCTIONS,
	feedbackTools,
	mcpServer
} from '@absolutejs/mcp';

mcpServer<Caller>({
	// ...as above
	instructions: `${myInstructions} ${FEEDBACK_INSTRUCTIONS}`,

	// Refuse a single call before it runs; the message comes back as
	// an isError tool result the model can relay, not a crash.
	beforeCall: async ({ caller }) =>
		(await outOfCredits(caller))
			? { block: 'Out of credits this cycle.' }
			: undefined,

	// Audit every call. meta carries whatever the tool handler wrote.
	onCall: ({ caller, name, ok, meta }) =>
		recordCall({ caller, name, ok, touched: meta.touched }),

	tools: ({ caller }) => ({
		...myTools(caller),
		...feedbackTools({
			caller,
			store: {
				reportProblem: ({ caller, report }) => file(caller, report),
				submitFeedback: ({ caller, feedback }) => record(caller, feedback)
			}
		})
	})
});

import { createAgency, createMemoryAgencyStore } from '@absolutejs/agency';
import { createPostgresMcpTaskStore, mcpServer } from '@absolutejs/mcp';

const agency = createAgency({ policy, store: createMemoryAgencyStore() });

mcpServer<Caller>({
	agency: {
		enforcement: agency,
		resolveActor: ({ caller, scopes }) => ({
			agentId: caller.agentId,
			delegationId: caller.delegationId,
			scopes,
			userId: caller.userId
		})
	},
	tasks: {
		authorizationKey: (caller) => caller.userId,
		shouldCreate: ({ name }) => name === 'long_running_report',
		store: createPostgresMcpTaskStore({ sql }),
		ttlMs: 60 * 60 * 1000
	},
	tools: () => ({
		long_running_report: { taskSupport: 'optional', ...reportTool }
	})
});