@pikku/core 0.7.7 → 0.8.0

package/CHANGELOG.md

@@ -1,4 +1,21 @@
-## 0.7.0
+## 0.8.0
+
+### Major Features
+
+- **Model Context Protocol (MCP) Support**: Added MCP implementation with resources, tools, and prompts
+- **Queue System**: Added queue support with runners and workers
+- **RPC (Remote Procedure Calls)**: Added typed RPC calls inside functions with local and remote support
+- **Middleware Runner**: Added middleware runner to functions for enhanced request processing
+- **Multiple Bootstrap Files**: Added support for different transport bootstrap files
+- **Middleware Runner**: Run middleware on any function
+
+## 0.7.8
+
+### Patch Changes
+
+- 8b4f52e: fix: nextjs compatability with 0.7
+- 8b4f52e: refactor: moving schemas in channels to functions
+- 1d70184: feat: adding multiple bootstrap files for different transports
 
 ## 0.7.7
 

package/dist/errors/error-handler.d.ts

@@ -15,6 +15,7 @@ export declare class PikkuError extends Error {
 export interface ErrorDetails {
     status: number;
     message: string;
+    mcpCode?: number;
 }
 /**
  * Adds an error to the API errors map.
@@ -35,4 +36,5 @@ export declare const addErrors: (errors: Array<[error: any, details: ErrorDetail
 export declare const getErrorResponse: (error: Error) => {
     status: number;
     message: string;
+    mcpCode?: number;
 } | undefined;

package/dist/errors/errors.js

@@ -10,6 +10,7 @@ export class BadRequestError extends PikkuError {
 }
 addError(BadRequestError, {
     status: 400,
+    mcpCode: -32600,
     message: 'The server cannot or will not process the request due to client error (e.g., malformed request syntax).',
 });
 /**
@@ -81,6 +82,7 @@ export class NotFoundError extends PikkuError {
  */
 addError(NotFoundError, {
     status: 404,
+    mcpCode: -32601,
     message: 'The server cannot find the requested resource.',
 });
 /**

package/dist/{channel → events/channel}/channel-handler.d.ts

@@ -1,3 +1,3 @@
-import { CoreServices, CoreUserSession } from '../types/core.types.js';
+import { CoreServices, CoreUserSession } from '../../types/core.types.js';
 import { CoreAPIChannel, PikkuChannelHandler } from './channel.types.js';
 export declare const processMessageHandlers: (services: CoreServices, session: CoreUserSession | undefined, channelConfig: CoreAPIChannel<any, any>, channelHandler: PikkuChannelHandler) => (rawData: any) => Promise<unknown>;

package/dist/{channel → events/channel}/channel-handler.js

@@ -1,5 +1,5 @@
-import { pikkuState } from '../pikku-state.js';
-import { runPikkuFunc } from '../function/function-runner.js';
+import { pikkuState } from '../../pikku-state.js';
+import { runPikkuFunc } from '../../function/function-runner.js';
 const getRouteMeta = (channelName, routingProperty, routerValue) => {
     const channelMeta = pikkuState('channel', 'meta')[channelName];
     if (!channelMeta) {

package/dist/{channel → events/channel}/channel-runner.d.ts

@@ -1,4 +1,4 @@
-import { UserSessionService } from '../services/user-session-service.js';
+import { UserSessionService } from '../../services/user-session-service.js';
 import { ChannelMeta, CoreAPIChannel, RunChannelOptions, RunChannelParams } from './channel.types.js';
 /**
  * Adds a channel and registers all functions referenced in it using the

package/dist/{channel → events/channel}/channel-runner.js

@@ -1,7 +1,7 @@
-import { NotFoundError } from '../errors/errors.js';
-import { addFunction } from '../function/function-runner.js';
-import { pikkuState } from '../pikku-state.js';
-import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
+import { NotFoundError } from '../../errors/errors.js';
+import { addFunction } from '../../function/function-runner.js';
+import { pikkuState } from '../../pikku-state.js';
+import { coerceTopLevelDataFromSchema, validateSchema } from '../../schema.js';
 import { match } from 'path-to-regexp';
 /**
  * Adds a channel and registers all functions referenced in it using the
@@ -16,14 +16,14 @@ export const addChannel = (channel) => {
     }
     pikkuState('channel', 'channels').set(channel.name, channel);
     // Register onConnect function if provided
-    if (channel.onConnect && channelMeta.connectPikkuFuncName) {
-        addFunction(channelMeta.connectPikkuFuncName, {
+    if (channel.onConnect && channelMeta.connect) {
+        addFunction(channelMeta.connect.pikkuFuncName, {
             func: channel.onConnect,
         });
     }
     // Register onDisconnect function if provided
-    if (channel.onDisconnect && channelMeta.disconnectPikkuFuncName) {
-        addFunction(channelMeta.disconnectPikkuFuncName, {
+    if (channel.onDisconnect && channelMeta.disconnect) {
+        addFunction(channelMeta.disconnect.pikkuFuncName, {
             func: channel.onDisconnect,
         });
     }

package/dist/{channel → events/channel}/channel-store.d.ts

@@ -1,4 +1,4 @@
-import { CoreUserSession } from '../types/core.types.js';
+import { CoreUserSession } from '../../types/core.types.js';
 export type Channel<ChannelType = unknown, OpeningData = unknown> = {
     channelId: string;
     channelName: string;

package/dist/{channel → events/channel}/channel.types.d.ts

@@ -1,7 +1,7 @@
-import { PikkuError } from '../errors/error-handler.js';
+import { PikkuError } from '../../errors/error-handler.js';
 import { HTTPFunctionMetaInputTypes, PikkuHTTPRequest, PikkuHTTPResponse } from '../http/http.types.js';
-import { APIDocs, CoreSingletonServices, CreateSessionServices, PikkuMiddleware } from '../types/core.types.js';
-import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission } from '../function/functions.types.js';
+import { APIDocs, CoreSingletonServices, CreateSessionServices, PikkuMiddleware } from '../../types/core.types.js';
+import { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission } from '../../function/functions.types.js';
 export type RunChannelOptions = Partial<{
     skipUserSession: boolean;
     respondWith404: boolean;
@@ -18,8 +18,6 @@ export type RunChannelParams<ChannelData> = {
 };
 export interface ChannelMessageMeta {
     pikkuFuncName: string;
-    inputs: string[] | null;
-    outputs: string[] | null;
     docs?: APIDocs;
 }
 export interface ChannelMeta {
@@ -29,10 +27,8 @@ export interface ChannelMeta {
     query?: string[];
     input: string | null;
     inputTypes?: HTTPFunctionMetaInputTypes;
-    connect: boolean;
-    connectPikkuFuncName: string | null;
-    disconnect: boolean;
-    disconnectPikkuFuncName: string | null;
+    connect: ChannelMessageMeta | null;
+    disconnect: ChannelMessageMeta | null;
     message: ChannelMessageMeta | null;
     messageRoutes: Record<string, Record<string, ChannelMessageMeta>>;
     docs?: APIDocs;

package/dist/{channel → events/channel}/local/local-channel-runner.js

@@ -1,12 +1,12 @@
 import { openChannel } from '../channel-runner.js';
 import { createHTTPInteraction } from '../../http/http-runner.js';
-import { closeSessionServices } from '../../utils.js';
+import { closeSessionServices } from '../../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { PikkuLocalChannelHandler } from './local-channel-handler.js';
-import { handleError } from '../../handle-error.js';
-import { runMiddleware } from '../../middleware-runner.js';
-import { PikkuUserSessionService } from '../../services/user-session-service.js';
-import { runPikkuFuncDirectly } from '../../function/function-runner.js';
+import { handleHTTPError } from '../../../handle-error.js';
+import { runMiddleware } from '../../../middleware-runner.js';
+import { PikkuUserSessionService } from '../../../services/user-session-service.js';
+import { runPikkuFuncDirectly } from '../../../function/function-runner.js';
 import { rpcService } from '../../rpc/rpc-runner.js';
 export const runLocalChannel = async ({ singletonServices, channelId, request, response, route, createSessionServices, skipUserSession = false, respondWith404 = true, coerceDataFromSchema = true, logWarningsForStatusCodes = [], bubbleErrors = false, }) => {
     let sessionServices;
@@ -43,13 +43,13 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
                 userSession: userSession,
             });
             channelHandler.registerOnOpen(() => {
-                if (channelConfig.onConnect && meta.connectPikkuFuncName) {
-                    runPikkuFuncDirectly(meta.connectPikkuFuncName, { ...allServices, channel }, openingData);
+                if (channelConfig.onConnect && meta.connect) {
+                    runPikkuFuncDirectly(meta.connect.pikkuFuncName, { ...allServices, channel }, openingData);
                 }
             });
             channelHandler.registerOnClose(async () => {
-                if (channelConfig.onDisconnect && meta.disconnectPikkuFuncName) {
-                    runPikkuFuncDirectly(meta.disconnectPikkuFuncName, { ...allServices, channel }, openingData);
+                if (channelConfig.onDisconnect && meta.disconnect) {
+                    runPikkuFuncDirectly(meta.disconnect.pikkuFuncName, { ...allServices, channel }, openingData);
                 }
                 if (sessionServices) {
                     await closeSessionServices(singletonServices.logger, sessionServices);
@@ -58,7 +58,7 @@ export const runLocalChannel = async ({ singletonServices, channelId, request, r
             channelHandler.registerOnMessage(processMessageHandlers(allServices, session, channelConfig, channelHandler));
         }
         catch (e) {
-            handleError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
+            handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
         }
         finally {
             if (sessionServices) {

package/dist/{channel → events/channel}/log-channels.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from '../services/index.js';
+import { Logger } from '../../services/index.js';
 /**
  * Logs all the loaded channels.
  * @param logger - A logger for logging information.

package/dist/{channel → events/channel}/log-channels.js

@@ -1,4 +1,4 @@
-import { pikkuState } from '../pikku-state.js';
+import { pikkuState } from '../../pikku-state.js';
 /**
  * Logs all the loaded channels.
  * @param logger - A logger for logging information.

package/dist/{channel → events/channel}/serverless/serverless-channel-runner.js

@@ -1,13 +1,13 @@
-import { closeSessionServices } from '../../utils.js';
+import { closeSessionServices } from '../../../utils.js';
 import { processMessageHandlers } from '../channel-handler.js';
 import { openChannel } from '../channel-runner.js';
 import { createHTTPInteraction } from '../../http/http-runner.js';
-import { handleError } from '../../handle-error.js';
-import { PikkuUserSessionService } from '../../services/user-session-service.js';
-import { runMiddleware } from '../../middleware-runner.js';
-import { pikkuState } from '../../pikku-state.js';
+import { handleHTTPError } from '../../../handle-error.js';
+import { PikkuUserSessionService } from '../../../services/user-session-service.js';
+import { runMiddleware } from '../../../middleware-runner.js';
+import { pikkuState } from '../../../pikku-state.js';
 import { PikkuFetchHTTPRequest } from '../../http/pikku-fetch-http-request.js';
-import { runPikkuFuncDirectly } from '../../function/function-runner.js';
+import { runPikkuFuncDirectly } from '../../../function/function-runner.js';
 const getVariablesForChannel = ({ channelId, channelName, channelHandlerFactory, openingData, }) => {
     const channels = pikkuState('channel', 'channels');
     const channelConfig = channels[channelName];
@@ -59,13 +59,13 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
             if (createSessionServices) {
                 sessionServices = await createSessionServices(singletonServices, { http }, await userSession.get());
             }
-            if (channelConfig.onConnect && meta.connectPikkuFuncName) {
-                await runPikkuFuncDirectly(meta.connectPikkuFuncName, { ...singletonServices, ...sessionServices, channel }, openingData);
+            if (channelConfig.onConnect && meta.connect) {
+                await runPikkuFuncDirectly(meta.connect.pikkuFuncName, { ...singletonServices, ...sessionServices, channel }, openingData);
             }
             http?.response?.status(101);
         }
         catch (e) {
-            handleError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
+            handleHTTPError(e, http, channelId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
         }
         finally {
             if (sessionServices) {
@@ -89,8 +89,8 @@ export const runChannelDisconnect = async ({ singletonServices, ...params }) =>
     if (!sessionServices && params.createSessionServices) {
         sessionServices = await params.createSessionServices(singletonServices, {}, session);
     }
-    if (channelConfig.onDisconnect && meta.disconnectPikkuFuncName) {
-        await runPikkuFuncDirectly(meta.disconnectPikkuFuncName, { ...singletonServices, ...sessionServices, channel }, undefined);
+    if (channelConfig.onDisconnect && meta.disconnect) {
+        await runPikkuFuncDirectly(meta.disconnect.pikkuFuncName, { ...singletonServices, ...sessionServices, channel }, undefined);
     }
     await params.channelStore.removeChannels([channel.channelId]);
     if (sessionServices) {

package/dist/{http → events/http}/http-runner.d.ts

@@ -1,5 +1,5 @@
 import { CoreHTTPFunctionRoute, RunRouteOptions, RunRouteParams, PikkuHTTP, PikkuHTTPRequest, PikkuHTTPResponse } from './http.types.js';
-import { PikkuMiddleware } from '../types/core.types.js';
+import { PikkuMiddleware } from '../../types/core.types.js';
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
 /**
  * Registers middleware either globally or for a specific route.
@@ -87,4 +87,4 @@ export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest,
  * @param {RunRouteOptions & RunRouteParams} options - Options such as singleton services, session handling, and error configuration.
  * @returns {Promise<Out | void>} The output from the route handler or void if an error occurred.
  */
-export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { singletonServices, createSessionServices, skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, generateRequestId, }: RunRouteOptions & RunRouteParams) => Promise<Out | void>;
+export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { singletonServices, createSessionServices, skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, generateRequestId, ignoreMiddleware, }: RunRouteOptions & RunRouteParams) => Promise<Out | void>;

package/dist/{http → events/http}/http-runner.js

@@ -1,13 +1,13 @@
 import { match } from 'path-to-regexp';
-import { MissingSessionError, NotFoundError } from '../errors/errors.js';
-import { closeSessionServices, createWeakUID, isSerializable, } from '../utils.js';
-import { PikkuUserSessionService, } from '../services/user-session-service.js';
-import { runMiddleware } from '../middleware-runner.js';
-import { handleError } from '../handle-error.js';
-import { pikkuState } from '../pikku-state.js';
+import { MissingSessionError, NotFoundError } from '../../errors/errors.js';
+import { closeSessionServices, createWeakUID, isSerializable, } from '../../utils.js';
+import { PikkuUserSessionService, } from '../../services/user-session-service.js';
+import { runMiddleware } from '../../middleware-runner.js';
+import { handleHTTPError } from '../../handle-error.js';
+import { pikkuState } from '../../pikku-state.js';
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
 import { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js';
-import { addFunction, runPikkuFunc } from '../function/function-runner.js';
+import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
 import { rpcService } from '../rpc/rpc-runner.js';
 /**
  * Registers middleware either globally or for a specific route.
@@ -21,14 +21,23 @@ import { rpcService } from '../rpc/rpc-runner.js';
  * @param {APIMiddleware[]} [middleware] - The middleware array to apply when a route pattern is specified.
  */
 export const addMiddleware = (routeOrMiddleware, middleware) => {
+    const middlewareStore = pikkuState('http', 'middleware');
     if (typeof routeOrMiddleware === 'string' && middleware) {
-        pikkuState('http', 'middleware').push({
-            route: routeOrMiddleware,
-            middleware,
-        });
+        const route = routeOrMiddleware;
+        // Remove existing entry for this route if it exists
+        const existingIndex = middlewareStore.findIndex((item) => item.route === route);
+        if (existingIndex !== -1) {
+            middlewareStore.splice(existingIndex, 1);
+        }
+        middlewareStore.push({ route, middleware });
     }
     else {
-        pikkuState('http', 'middleware').push({
+        // Handle global middleware
+        const existingIndex = middlewareStore.findIndex((item) => item.route === '*');
+        if (existingIndex !== -1) {
+            middlewareStore.splice(existingIndex, 1);
+        }
+        middlewareStore.push({
             route: '*',
             middleware: routeOrMiddleware,
         });
@@ -57,8 +66,6 @@ export const addHTTPRoute = (httpRoute) => {
     }
     addFunction(routeMeta.pikkuFuncName, {
         func: httpRoute.func,
-        auth: httpRoute.auth,
-        permissions: httpRoute.permissions,
     });
     const routes = pikkuState('http', 'routes');
     if (!routes.has(httpRoute.method)) {
@@ -217,7 +224,7 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
                 channel,
             });
         };
-        const result = await runPikkuFunc(meta.pikkuFuncName, {
+        result = await runPikkuFunc(meta.pikkuFuncName, {
             getAllServices,
             session,
             data,
@@ -234,7 +241,6 @@ const executeRouteWithMiddleware = async (services, matchedRoute, http, options)
         http?.response?.status(200);
         // TODO: Evaluate if the response stream should be explicitly ended.
         // http?.response?.end()
-        return result;
     };
     // Execute middleware, then run the main logic
     await runMiddleware({ ...singletonServices, userSession }, { http }, middleware, runMain);
@@ -295,7 +301,7 @@ export const pikkuFetch = async (request, params) => {
  * @param {RunRouteOptions & RunRouteParams} options - Options such as singleton services, session handling, and error configuration.
  * @returns {Promise<Out | void>} The output from the route handler or void if an error occurred.
  */
-export const fetchData = async (request, response, { singletonServices, createSessionServices, skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, generateRequestId, }) => {
+export const fetchData = async (request, response, { singletonServices, createSessionServices, skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, generateRequestId, ignoreMiddleware = false, }) => {
     const requestId = request.getHeader?.('x-request-id') ||
         generateRequestId?.() ||
         createWeakUID();
@@ -326,12 +332,17 @@ export const fetchData = async (request, response, { singletonServices, createSe
             createSessionServices,
             skipUserSession,
             requestId,
-        }, matchedRoute, http, { coerceDataFromSchema }));
+        }, ignoreMiddleware
+            ? {
+                ...matchedRoute,
+                middleware: [],
+            }
+            : matchedRoute, http, { coerceDataFromSchema }));
         return result;
     }
     catch (e) {
         // Handle errors and, depending on configuration, bubble them up or respond with an error
-        handleError(e, http, requestId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
+        handleHTTPError(e, http, requestId, singletonServices.logger, logWarningsForStatusCodes, respondWith404, bubbleErrors);
     }
     finally {
         // Clean up any session-specific services created during processing

package/dist/{http → events/http}/http.types.d.ts

@@ -1,7 +1,7 @@
 import type { SerializeOptions } from 'cookie';
-import type { PikkuError } from '../errors/error-handler.js';
-import type { APIDocs, CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices, PikkuMiddleware } from '../types/core.types.js';
-import type { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission, CorePermissionGroup } from '../function/functions.types.js';
+import type { PikkuError } from '../../errors/error-handler.js';
+import type { APIDocs, CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices, PikkuMiddleware } from '../../types/core.types.js';
+import type { CoreAPIFunction, CoreAPIFunctionSessionless, CoreAPIPermission, CorePermissionGroup } from '../../function/functions.types.js';
 type ExtractRouteParams<S extends string> = S extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractRouteParams<`/${Rest}`> : S extends `${string}:${infer Param}` ? Param : never;
 export type AssertRouteParams<In, Route extends string> = ExtractRouteParams<Route> extends keyof In ? unknown : ['Error: Route parameters', ExtractRouteParams<Route>, 'not in', keyof In];
 export type RunRouteOptions = Partial<{
@@ -11,6 +11,7 @@ export type RunRouteOptions = Partial<{
     coerceDataFromSchema: boolean;
     bubbleErrors: boolean;
     generateRequestId: () => string;
+    ignoreMiddleware: boolean;
 }>;
 export type RunRouteParams = {
     singletonServices: CoreSingletonServices;

package/dist/{http → events/http}/index.d.ts

@@ -1,6 +1,5 @@
 export * from './pikku-fetch-http-request.js';
 export * from './pikku-fetch-http-response.js';
-export * from './incomingmessage-to-request-convertor.js';
 export * from './log-http-routes.js';
 export { fetch, fetchData, addHTTPRoute } from './http-runner.js';
 export type * from './http.types.js';

package/dist/{http → events/http}/index.js

@@ -1,5 +1,4 @@
 export * from './pikku-fetch-http-request.js';
 export * from './pikku-fetch-http-response.js';
-export * from './incomingmessage-to-request-convertor.js';
 export * from './log-http-routes.js';
 export { fetch, fetchData, addHTTPRoute } from './http-runner.js';

package/dist/{http → events/http}/log-http-routes.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from '../services/index.js';
+import { Logger } from '../../services/index.js';
 /**
  * Logs all the loaded routes.
  * @param logger - A logger for logging information.

package/dist/{http → events/http}/log-http-routes.js

@@ -1,4 +1,4 @@
-import { pikkuState } from '../pikku-state.js';
+import { pikkuState } from '../../pikku-state.js';
 /**
  * Logs all the loaded routes.
  * @param logger - A logger for logging information.

package/dist/{http → events/http}/pikku-fetch-http-request.js

@@ -1,6 +1,6 @@
 import { parse as parseQuery } from 'picoquery';
 import { parse as parseCookie } from 'cookie';
-import { UnprocessableContentError } from '../errors/errors.js';
+import { UnprocessableContentError } from '../../errors/errors.js';
 /**
  * Abstract class representing a pikku request.
  * @template In - The type of the request body.

package/dist/events/mcp/index.d.ts

@@ -0,0 +1,2 @@
+export * from './mcp.types.js';
+export * from './mcp-runner.js';

package/dist/events/mcp/index.js

@@ -0,0 +1,2 @@
+export * from './mcp.types.js';
+export * from './mcp-runner.js';

package/dist/events/mcp/mcp-runner.d.ts

@@ -0,0 +1,30 @@
+import type { CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices } from '../../types/core.types.js';
+import type { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, JsonRpcRequest, JsonRpcResponse, JsonRpcErrorResponse, PikkuMCP } from './mcp.types.js';
+import type { CoreAPIFunctionSessionless } from '../../function/functions.types.js';
+export declare class MCPError extends Error {
+    readonly error: JsonRpcErrorResponse;
+    constructor(error: JsonRpcErrorResponse);
+}
+export type RunMCPEndpointParams<Tools extends string = any> = {
+    session?: CoreUserSession;
+    singletonServices: CoreSingletonServices;
+    mcp?: PikkuMCP<Tools>;
+    createSessionServices?: CreateSessionServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
+};
+export type JsonRpcError = {
+    code: number;
+    message: string;
+    data?: any;
+};
+export declare const addMCPResource: <APIFunction extends CoreAPIFunctionSessionless<any, any>>(mcpResource: CoreMCPResource<APIFunction>) => void;
+export declare const addMCPTool: <APIFunction extends CoreAPIFunctionSessionless<any, any>>(mcpTool: CoreMCPTool<APIFunction>) => void;
+export declare const addMCPPrompt: <APIFunction extends CoreAPIFunctionSessionless<any, any>>(mcpPrompt: CoreMCPPrompt<APIFunction>) => void;
+export declare function runMCPResource(request: JsonRpcRequest, params: RunMCPEndpointParams, uri: string): Promise<JsonRpcResponse>;
+export declare function runMCPTool(request: JsonRpcRequest, params: RunMCPEndpointParams, name: string): Promise<JsonRpcResponse>;
+export declare function runMCPPrompt(request: JsonRpcRequest, params: RunMCPEndpointParams, name: string): Promise<JsonRpcResponse>;
+export declare const getMCPTools: () => Map<string, CoreMCPTool>;
+export declare const getMCPResources: () => Map<string, CoreMCPResource>;
+export declare const getMCPResourcesMeta: () => import("./mcp.types.js").MCPResourceMeta;
+export declare const getMCPToolsMeta: () => import("./mcp.types.js").MCPToolMeta;
+export declare const getMCPPrompts: () => Map<string, CoreMCPPrompt>;
+export declare const getMCPPromptsMeta: () => import("./mcp.types.js").MCPPromptMeta;