@pikku/core 0.7.8 → 0.8.0

package/CHANGELOG.md

@@ -1,4 +1,13 @@
-## 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
 

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

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;

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;
@@ -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];
@@ -65,7 +65,7 @@ export const runChannelConnect = async ({ singletonServices, channelId, channelO
             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) {

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.

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.
@@ -342,7 +342,7 @@ export const fetchData = async (request, response, { singletonServices, createSe
     }
     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<{

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;

package/dist/events/mcp/mcp-runner.js

@@ -0,0 +1,192 @@
+import { getErrorResponse } from '../../errors/error-handler.js';
+import { closeSessionServices } from '../../utils.js';
+import { pikkuState } from '../../pikku-state.js';
+import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
+import { rpcService } from '../rpc/rpc-runner.js';
+import { BadRequestError, NotFoundError } from '../../errors/errors.js';
+export class MCPError extends Error {
+    error;
+    constructor(error) {
+        super(error?.message || 'MCP Error');
+        this.error = error;
+        this.name = 'MCPError';
+        this.stack = new Error().stack;
+    }
+}
+export const addMCPResource = (mcpResource) => {
+    const resourcesMeta = pikkuState('mcp', 'resourcesMeta');
+    const mcpResourceMeta = resourcesMeta[mcpResource.uri];
+    if (!mcpResourceMeta) {
+        throw new Error(`MCP resource metadata not found for '${mcpResource.uri}'`);
+    }
+    addFunction(mcpResourceMeta.pikkuFuncName, {
+        func: mcpResource.func,
+    });
+    const resources = pikkuState('mcp', 'resources');
+    if (resources.has(mcpResource.uri)) {
+        throw new Error(`MCP resource already exists: ${mcpResource.uri}`);
+    }
+    resources.set(mcpResource.uri, mcpResource);
+};
+export const addMCPTool = (mcpTool) => {
+    const toolsMeta = pikkuState('mcp', 'toolsMeta');
+    const mcpToolMeta = toolsMeta[mcpTool.name];
+    if (!mcpToolMeta) {
+        throw new Error(`MCP tool metadata not found for '${mcpTool.name}'`);
+    }
+    addFunction(mcpToolMeta.pikkuFuncName, {
+        func: mcpTool.func,
+    });
+    const tools = pikkuState('mcp', 'tools');
+    if (tools.has(mcpTool.name)) {
+        throw new Error(`MCP tool already exists: ${mcpTool.name}`);
+    }
+    tools.set(mcpTool.name, mcpTool);
+};
+export const addMCPPrompt = (mcpPrompt) => {
+    const promptsMeta = pikkuState('mcp', 'promptsMeta');
+    const mcpPromptMeta = promptsMeta[mcpPrompt.name];
+    if (!mcpPromptMeta) {
+        throw new Error(`MCP prompt metadata not found for '${mcpPrompt.name}'`);
+    }
+    addFunction(mcpPromptMeta.pikkuFuncName, {
+        func: mcpPrompt.func,
+    });
+    const prompts = pikkuState('mcp', 'prompts');
+    if (prompts.has(mcpPrompt.name)) {
+        throw new Error(`MCP prompt already exists: ${mcpPrompt.name}`);
+    }
+    prompts.set(mcpPrompt.name, mcpPrompt);
+};
+export async function runMCPResource(request, params, uri) {
+    let endpoint;
+    let pikkuFuncName;
+    let extractedParams = {};
+    const metas = pikkuState('mcp', 'resourcesMeta');
+    const endpoints = pikkuState('mcp', 'resources');
+    if (endpoints.has(uri)) {
+        endpoint = endpoints.get(uri);
+        pikkuFuncName = metas[uri]?.pikkuFuncName;
+    }
+    else {
+        for (const [uriTemplate, value] of endpoints.entries()) {
+            // Extract parameter names from the template
+            const paramNames = Array.from(uriTemplate.matchAll(/\{([^}]+)\}/g), (m) => m[1]);
+            // Create regex pattern to match and capture parameter values
+            const regexPattern = uriTemplate.replace(/\{[^}]+\}/g, '([^/]+)');
+            const regex = new RegExp(`^${regexPattern}$`);
+            const match = uri.match(regex);
+            if (match) {
+                endpoint = value;
+                pikkuFuncName = metas[uriTemplate]?.pikkuFuncName;
+                // Extract parameter values and create params object
+                for (let i = 0; i < paramNames.length; i++) {
+                    extractedParams[paramNames[i]] = match[i + 1]; // match[0] is the full match
+                }
+                break;
+            }
+        }
+    }
+    return await runMCPPikkuFunc({
+        ...request,
+        params: { ...request.params, ...extractedParams },
+    }, 'resource', uri, endpoint, pikkuFuncName, { ...params, mcp: { uri } });
+}
+export async function runMCPTool(request, params, name) {
+    const endpoint = pikkuState('mcp', 'tools').get(name);
+    const meta = pikkuState('mcp', 'toolsMeta')[name];
+    return await runMCPPikkuFunc(request, 'tool', name, endpoint, meta?.pikkuFuncName, params);
+}
+export async function runMCPPrompt(request, params, name) {
+    const endpoint = pikkuState('mcp', 'prompts').get(name);
+    const meta = pikkuState('mcp', 'promptsMeta')[name];
+    return await runMCPPikkuFunc(request, 'prompt', name, endpoint, meta?.pikkuFuncName, params);
+}
+/**
+ * JSON-RPC 2.0 compatible MCP endpoint runner
+ */
+async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { session, singletonServices, createSessionServices, mcp: interaction, }) {
+    let sessionServices;
+    try {
+        // Validate JSON-RPC request structure
+        if (request.jsonrpc !== '2.0') {
+            throw new BadRequestError('Invalid JSON-RPC version, only supoorted version is 2.0');
+        }
+        if (!mcp) {
+            throw new NotFoundError(`MCP '${type}' registration not found for '${name}'`);
+        }
+        if (!pikkuFuncName) {
+            throw new NotFoundError(`MCP '${type}' PikkuFunction Mapping not found for '${name}'`);
+        }
+        singletonServices.logger.debug(`Running MCP ${type}: ${name}`);
+        const getAllServices = async () => {
+            if (createSessionServices) {
+                const services = await createSessionServices(singletonServices, { mcp: interaction }, session);
+                sessionServices = services;
+                return rpcService.injectRPCService({
+                    ...singletonServices,
+                    ...services,
+                    mcp: interaction,
+                });
+            }
+            return rpcService.injectRPCService({
+                ...singletonServices,
+                mcp: interaction,
+            });
+        };
+        const result = await runPikkuFunc(pikkuFuncName, {
+            getAllServices,
+            session,
+            data: request.params,
+        });
+        return {
+            id: request.id,
+            result,
+        };
+    }
+    catch (e) {
+        singletonServices.logger.error(`Error running MCP ${type} '${name}':`, e.constructor);
+        const errorResponse = getErrorResponse(e);
+        if (errorResponse?.mcpCode) {
+            throw new MCPError({
+                id: request.id,
+                code: errorResponse.mcpCode,
+                message: errorResponse.message,
+            });
+        }
+        else {
+            if (errorResponse) {
+                singletonServices.logger.warn(`Got error without a mapping: ${errorResponse.message}`);
+            }
+            throw new MCPError({
+                id: request.id,
+                code: -32603,
+                message: 'Internal error',
+                data: { message: e.message, stack: e.stack },
+            });
+        }
+    }
+    finally {
+        if (sessionServices) {
+            await closeSessionServices(singletonServices.logger, sessionServices);
+        }
+    }
+}
+export const getMCPTools = () => {
+    return pikkuState('mcp', 'tools');
+};
+export const getMCPResources = () => {
+    return pikkuState('mcp', 'resources');
+};
+export const getMCPResourcesMeta = () => {
+    return pikkuState('mcp', 'resourcesMeta');
+};
+export const getMCPToolsMeta = () => {
+    return pikkuState('mcp', 'toolsMeta');
+};
+export const getMCPPrompts = () => {
+    return pikkuState('mcp', 'prompts');
+};
+export const getMCPPromptsMeta = () => {
+    return pikkuState('mcp', 'promptsMeta');
+};

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

@@ -0,0 +1,117 @@
+import { CoreAPIFunctionSessionless } from '../../function/functions.types.js';
+export type PikkuMCP<Tools extends string = any> = {
+    uri?: string;
+    sendResourceUpdated: (uri: string) => void;
+    enableResources: (resources: Record<string, boolean>) => Promise<boolean>;
+    enablePrompts: (prompts: Record<string, boolean>) => Promise<boolean>;
+    enableTools: (tools: Record<Tools, boolean>) => Promise<boolean>;
+};
+/**
+ * Represents metadata for MCP resources, including name, description, and documentation.
+ */
+export type MCPResourceMeta = Record<string, Omit<CoreMCPResource, 'func'> & {
+    pikkuFuncName: string;
+    inputSchema: string | null;
+    outputSchema: string | null;
+}>;
+/**
+ * Represents metadata for MCP tools, including name, description, and documentation.
+ */
+export type MCPToolMeta = Record<string, Omit<CoreMCPTool, 'func'> & {
+    pikkuFuncName: string;
+    inputSchema: string | null;
+    outputSchema: string | null;
+}>;
+/**
+ * Represents metadata for MCP prompts, including name, description, and arguments.
+ */
+export type MCPPromptMeta = Record<string, Omit<CoreMCPPrompt, 'func'> & {
+    pikkuFuncName: string;
+    inputSchema: string | null;
+    outputSchema: string | null;
+    arguments: Array<{
+        name: string;
+        description: string;
+        required: boolean;
+    }>;
+}>;
+/**
+ * Represents an MCP resource with specific properties.
+ */
+export type CoreMCPResource<APIFunction = CoreAPIFunctionSessionless<any, any>> = {
+    uri: string;
+    title: string;
+    description?: string;
+    mimeType?: string;
+    size?: number;
+    streaming?: boolean;
+    func: APIFunction;
+    tags?: string[];
+};
+/**
+ * Represents an MCP tool with specific properties.
+ */
+export type CoreMCPTool<APIFunction = CoreAPIFunctionSessionless<any, any>> = {
+    name: string;
+    title?: string;
+    description: string;
+    annotations?: Record<string, any>;
+    func: APIFunction;
+    tags?: string[];
+    streaming?: boolean;
+};
+/**
+ * Represents an MCP prompt with specific properties.
+ */
+export type CoreMCPPrompt<APIFunction = CoreAPIFunctionSessionless<any, MCPPromptResponse>> = {
+    name: string;
+    description?: string;
+    func: APIFunction;
+    tags?: string[];
+};
+export type JsonRpcRequest = {
+    jsonrpc: string;
+    id?: string | number | null;
+    params?: any;
+};
+export type JsonRpcResponse = {
+    id?: string | number | null;
+    result?: any;
+};
+export type JsonRpcErrorResponse = {
+    id?: string | number | null;
+    code: number;
+    message: string;
+    data?: any;
+};
+/**
+ * Represents a message in an MCP prompt response
+ */
+export type MCPPromptMessage = {
+    role: 'user' | 'assistant' | 'system';
+    content: {
+        type: 'text' | 'image';
+        text: string;
+        data?: string;
+    };
+};
+/**
+ * Standard response type for MCP prompts - array of messages
+ */
+export type MCPPromptResponse = MCPPromptMessage[];
+export type MCPResourceMessage = {
+    uri: string;
+    text: string;
+};
+export type MCPResourceResponse = MCPResourceMessage[];
+/**
+ * Standard response type for MCP prompts - array of messages
+ */
+export type MCPToolMessage = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    data: string;
+};
+export type MCPToolResponse = MCPToolMessage[];

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

@@ -0,0 +1,6 @@
+export type * from './queue.types.js';
+export { addQueueWorker, runQueueJob, getQueueWorkers, removeQueueWorker, } from './queue-runner.js';
+export { validateWorkerConfig } from './validate-worker-config.js';
+export type { QueueConfigMapping } from './validate-worker-config.js';
+export { registerqueueWorkers } from './register-queue-helper.js';
+export type { QueueRegistrationCallback } from './register-queue-helper.js';

package/dist/events/queue/index.js

@@ -0,0 +1,6 @@
+// Queue processor management
+export { addQueueWorker, runQueueJob, getQueueWorkers, removeQueueWorker, } from './queue-runner.js';
+// Configuration validation
+export { validateWorkerConfig } from './validate-worker-config.js';
+// Queue registration helper
+export { registerqueueWorkers } from './register-queue-helper.js';