@pikku/core 0.11.2 → 0.12.0

package/dist/wirings/http/http-runner.js

@@ -1,13 +1,26 @@
-import { NotFoundError } from '../../errors/errors.js';
+import { NotFoundError, PikkuMissingMetaError } from '../../errors/errors.js';
 import { closeWireServices, createWeakUID, isSerializable, } from '../../utils.js';
-import { PikkuSessionService } from '../../services/user-session-service.js';
+import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../services/user-session-service.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 { httpRouter } from './routers/http-router.js';
-import { startWorkflowByHttpWire } from '../workflow/workflow-utils.js';
+import { validateSchema } from '../../schema.js';
+/**
+ * Extract headers from a PikkuHTTPRequest based on the schema keys
+ */
+function extractHeadersFromRequest(request, headerKeys) {
+    const headers = {};
+    for (const headerName of headerKeys) {
+        const value = request.header(headerName);
+        if (value !== null) {
+            headers[headerName] = value;
+        }
+    }
+    return headers;
+}
 /**
  * Registers HTTP middleware for a specific route pattern.
  *
@@ -95,10 +108,10 @@ export const wireHTTP = (httpWiring) => {
     const httpMeta = pikkuState(null, 'http', 'meta');
     const routeMeta = httpMeta[httpWiring.method][httpWiring.route];
     if (!routeMeta) {
-        throw new Error('Route metadata not found');
+        throw new PikkuMissingMetaError(`Missing generated metadata for HTTP route '${httpWiring.method.toUpperCase()} ${httpWiring.route}'`);
     }
     if (httpWiring.func) {
-        addFunction(routeMeta.pikkuFuncName, httpWiring.func);
+        addFunction(routeMeta.pikkuFuncId, httpWiring.func);
     }
     const routes = pikkuState(null, 'http', 'routes');
     if (!routes.has(httpWiring.method)) {
@@ -184,6 +197,12 @@ const executeRoute = async (services, matchedRoute, http, options) => {
     const { singletonServices, createWireServices, skipUserSession, requestId } = services;
     // Attach URL parameters to the request object
     http?.request?.setParams(params);
+    // Validate request headers if schema is defined
+    if (meta.headersSchemaName && http.request && singletonServices.schema) {
+        const headerKeys = singletonServices.schema.getSchemaKeys(meta.headersSchemaName);
+        const rawHeaders = extractHeadersFromRequest(http.request, headerKeys);
+        await validateSchema(singletonServices.logger, singletonServices.schema, meta.headersSchemaName, rawHeaders);
+    }
     const requiresSession = route.auth !== false;
     let wireServices;
     let result;
@@ -192,7 +211,13 @@ const executeRoute = async (services, matchedRoute, http, options) => {
     if (skipUserSession && requiresSession) {
         throw new Error("Can't skip trying to get user session if auth is required");
     }
-    const data = () => http.request.data();
+    let cachedData;
+    const data = async () => {
+        if (cachedData === undefined) {
+            cachedData = await http.request.data();
+        }
+        return cachedData;
+    };
     let channel;
     if (matchedRoute.route.sse) {
         const response = http?.response;
@@ -220,14 +245,12 @@ const executeRoute = async (services, matchedRoute, http, options) => {
             state: 'open',
         };
     }
-    const wire = { http, channel, session: userSession };
-    if (matchedRoute.meta.workflow === true) {
-        await startWorkflowByHttpWire(singletonServices, createWireServices, matchedRoute, wire);
-        return wireServices
-            ? { wireServices, result: http.response }
-            : { result: http.response };
-    }
-    result = await runPikkuFunc('http', `${meta.method}:${meta.route}`, meta.pikkuFuncName, {
+    const wire = {
+        http,
+        channel,
+        ...createMiddlewareSessionWireProps(userSession),
+    };
+    result = await runPikkuFunc('http', `${meta.method}:${meta.route}`, meta.pikkuFuncId, {
         singletonServices,
         createWireServices,
         auth: route.auth !== false,
@@ -239,17 +262,20 @@ const executeRoute = async (services, matchedRoute, http, options) => {
         coerceDataFromSchema: options.coerceDataFromSchema,
         tags: route.tags,
         wire,
+        sessionService: userSession,
     });
-    // Respond with either a binary or JSON response based on configuration
-    if (route.returnsJSON === false) {
-        http?.response?.arrayBuffer(result);
-    }
-    else {
-        http?.response?.json(result);
+    if (!matchedRoute.route.sse) {
+        if (result === undefined || result === null) {
+            http?.response?.status(204);
+        }
+        else if (route.returnsJSON === false) {
+            http?.response?.arrayBuffer(result);
+        }
+        else {
+            http?.response?.status(200);
+            http?.response?.json(result);
+        }
     }
-    http?.response?.status(200);
-    // TODO: Evaluate if the response stream should be explicitly ended.
-    // http?.response?.end()
     return wireServices ? { result, wireServices } : { result };
 };
 /**

package/dist/wirings/http/http.types.d.ts

@@ -1,5 +1,6 @@
 import type { SerializeOptions } from 'cookie';
-import type { PikkuError } from '../../errors/error-handler.js';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { PikkuError } from '../../errors/error-handler.js';
 import type { CoreServices, CoreSingletonServices, CoreUserSession, CreateWireServices, CorePikkuMiddleware, CommonWireMeta } from '../../types/core.types.js';
 import type { CorePikkuFunction, CorePikkuFunctionSessionless, CorePikkuPermission, CorePermissionGroup, CorePikkuFunctionConfig } from '../../function/functions.types.js';
 type ExtractHTTPWiringParams<S extends string> = S extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractHTTPWiringParams<`/${Rest}`> : S extends `${string}:${infer Param}` ? Param : never;
@@ -19,28 +20,43 @@ export type RunHTTPWiringOptions = Partial<{
 }>;
 export type RunHTTPWiringParams = {
     singletonServices: CoreSingletonServices;
-    createWireServices: CreateWireServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
+    createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
 };
 /**
  * Represents the HTTP methods supported for API HTTP wirings.
-t */
+ */
 export type HTTPMethod = 'post' | 'get' | 'delete' | 'patch' | 'head' | 'put' | 'options';
 /**
- * Represents an API HTTP wiring without a function, including metadata such as content type, route, and timeout settings.
+ * Header schema type for request header validation.
+ * Uses Standard Schema interface - works with Zod, Valibot, ArkType, Effect Schema, etc.
+ */
+export type HTTPHeadersSchema = StandardSchemaV1<Record<string, string | string[] | undefined>>;
+/**
+ * Documentation config for OpenAPI generation
+ */
+export type HTTPRouteDocsConfig = {
+    description?: string;
+    response?: string;
+    errors?: Array<typeof PikkuError>;
+    tags?: string[];
+};
+/**
+ * Common HTTP route configuration shared between wireHTTP and wireHTTPRoutes
  */
-export type CoreHTTPFunction = {
+export type HTTPRouteBaseConfig = {
     contentType?: 'xml' | 'json';
+    timeout?: number;
+    tags?: string[];
+    headers?: HTTPHeadersSchema;
+    docs?: HTTPRouteDocsConfig;
+};
+/**
+ * Represents an API HTTP wiring without a function, including metadata such as content type, route, and timeout settings.
+ */
+export type CoreHTTPFunction = HTTPRouteBaseConfig & {
     route: string;
     eventChannel?: false;
     returnsJSON?: false;
-    timeout?: number;
-    tags?: string[];
-    docs?: Partial<{
-        description: string;
-        response: string;
-        errors: Array<typeof PikkuError>;
-        tags: string[];
-    }>;
 };
 /**
  * Represents a http wire within Pikku, including a request and response.
@@ -67,13 +83,12 @@ export type PikkuQuery<T = Record<string, string | undefined>> = Record<string,
  * @template PikkuFunctionSessionless - The sessionless API function type, defaults to `CorePikkuFunctionSessionless`.
  * @template PikkuPermission - The permission function type, defaults to `CorePikkuPermission`.
  */
-export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction extends CorePikkuFunction<In, Out, any, any> = CorePikkuFunction<In, Out>, PikkuFunctionSessionless extends CorePikkuFunctionSessionless<In, Out, any, any> = CorePikkuFunctionSessionless<In, Out>, PikkuPermission extends CorePikkuPermission<In, any, any> = CorePikkuPermission<In, any, any>, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any>> = (CoreHTTPFunction & {
+export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction extends CorePikkuFunction<In, Out, any, any, any> = CorePikkuFunction<In, Out>, PikkuFunctionSessionless extends CorePikkuFunctionSessionless<In, Out, any, any, any> = CorePikkuFunctionSessionless<In, Out>, PikkuPermission extends CorePikkuPermission<In, any, any> = CorePikkuPermission<In, any, any>, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any>> = (CoreHTTPFunction & {
     route: R;
     method: HTTPMethod;
     func: CorePikkuFunctionConfig<PikkuFunction, PikkuPermission, PikkuMiddleware>;
     permissions?: CorePermissionGroup<PikkuPermission>;
     auth?: true;
-    tags?: string[];
     middleware?: PikkuMiddleware[];
     sse?: undefined;
 }) | (CoreHTTPFunction & {
@@ -82,7 +97,6 @@ export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction exte
     func: CorePikkuFunctionConfig<PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware>;
     permissions?: undefined;
     auth?: false;
-    tags?: string[];
     middleware?: PikkuMiddleware[];
     sse?: undefined;
 }) | (CoreHTTPFunction & {
@@ -91,27 +105,24 @@ export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction exte
     func: CorePikkuFunctionConfig<PikkuFunction, PikkuPermission, PikkuMiddleware>;
     permissions?: CorePermissionGroup<PikkuPermission>;
     auth?: true;
-    sse?: boolean;
-    tags?: string[];
     middleware?: PikkuMiddleware[];
+    sse?: boolean;
 }) | (CoreHTTPFunction & {
     route: R;
     method: 'get';
     func: CorePikkuFunctionConfig<PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware>;
     permissions?: undefined;
     auth?: false;
-    sse?: boolean;
-    tags?: string[];
     middleware?: PikkuMiddleware[];
+    sse?: boolean;
 }) | (CoreHTTPFunction & {
     route: R;
     method: 'post';
     func: CorePikkuFunctionConfig<PikkuFunction, PikkuPermission, PikkuMiddleware>;
     permissions?: CorePermissionGroup<PikkuPermission>;
     auth?: true;
-    query?: Array<keyof In>;
-    tags?: string[];
     middleware?: PikkuMiddleware[];
+    query?: Array<keyof In>;
     sse?: undefined;
 }) | (CoreHTTPFunction & {
     route: R;
@@ -119,23 +130,10 @@ export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction exte
     func: CorePikkuFunctionConfig<PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware>;
     permissions?: undefined;
     auth?: false;
-    query?: Array<keyof In>;
-    tags?: string[];
     middleware?: PikkuMiddleware[];
+    query?: Array<keyof In>;
     sse?: undefined;
-}) | {
-    /** Route triggers a workflow matched by route/method from workflow wires.http */
-    route: R;
-    method: HTTPMethod;
-    workflow: true;
-    func?: undefined;
-    permissions?: undefined;
-    auth?: undefined;
-    tags?: undefined;
-    middleware?: undefined;
-    returnsJSON?: undefined;
-    sse?: boolean;
-};
+});
 /**
  * Represents the input types for HTTP wiring metadata, including parameters, query, and body types.
  */
@@ -153,8 +151,9 @@ export type HTTPWiringMeta = CommonWireMeta & {
     params?: string[];
     query?: string[];
     inputTypes?: HTTPFunctionMetaInputTypes;
+    headersSchemaName?: string;
     sse?: true;
-    workflow?: true;
+    groupBasePath?: string;
 };
 export type HTTPWiringsMeta = Record<HTTPMethod, Record<string, HTTPWiringMeta>>;
 export type HTTPFunctionsMeta = Array<{
@@ -188,4 +187,45 @@ export interface PikkuHTTPResponse<Out = unknown> {
     close?: () => void;
     setMode?: (mode: 'stream') => void;
 }
+/**
+ * Single route configuration - supports all wireHTTP options
+ */
+export type HTTPRouteConfig<PikkuFunction extends CorePikkuFunction<any, any, any, any, any> | CorePikkuFunctionSessionless<any, any, any, any, any> = CorePikkuFunction<any, any, any, any, any> | CorePikkuFunctionSessionless<any, any, any, any, any>, PikkuPermission extends CorePikkuPermission<any, any, any> = CorePikkuPermission<any>, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any, any>> = HTTPRouteBaseConfig & {
+    method: HTTPMethod;
+    route: string;
+    func: CorePikkuFunctionConfig<PikkuFunction, PikkuPermission, PikkuMiddleware>;
+    auth?: boolean;
+    permissions?: CorePermissionGroup<PikkuPermission>;
+    middleware?: PikkuMiddleware[];
+    sse?: boolean;
+};
+/**
+ * Group-level configuration applied to all routes
+ */
+export type HTTPRoutesGroupConfig<PikkuPermission extends CorePikkuPermission<any, any, any> = CorePikkuPermission<any>, PikkuMiddleware extends CorePikkuMiddleware<any, any> = CorePikkuMiddleware<any, any>> = {
+    basePath?: string;
+    tags?: string[];
+    auth?: boolean;
+    middleware?: PikkuMiddleware[];
+    permissions?: CorePermissionGroup<PikkuPermission>;
+};
+/**
+ * Nested route map - allows hierarchical organization
+ * Can contain individual routes, nested maps, or contracts with config
+ */
+export type HTTPRouteMap = {
+    [key: string]: HTTPRouteConfig | HTTPRouteMap | HTTPRouteContract;
+};
+/**
+ * A route contract with optional group config (returned by defineRoutes)
+ */
+export type HTTPRouteContract<T extends HTTPRouteMap = HTTPRouteMap> = HTTPRoutesGroupConfig & {
+    routes: T;
+};
+/**
+ * Full configuration for wireHTTPRoutes
+ */
+export type WireHTTPRoutesConfig = HTTPRoutesGroupConfig & {
+    routes: HTTPRouteMap | HTTPRouteConfig[];
+};
 export {};

package/dist/wirings/http/index.d.ts

@@ -1,5 +1,6 @@
-export * from './pikku-fetch-http-request.js';
-export * from './pikku-fetch-http-response.js';
-export * from './log-http-routes.js';
+export { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js';
+export { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
+export { logRoutes } from './log-http-routes.js';
 export { fetch, fetchData, wireHTTP, addHTTPMiddleware, addHTTPPermission, } from './http-runner.js';
-export type * from './http.types.js';
+export { wireHTTPRoutes, defineHTTPRoutes } from './http-routes.js';
+export type { AssertHTTPWiringParams, CoreHTTPFunctionWiring, HTTPMethod, HTTPRouteBaseConfig, HTTPWiringsMeta, PikkuHTTPRequest, PikkuHTTPResponse, PikkuQuery, RunHTTPWiringOptions, } from './http.types.js';

package/dist/wirings/http/index.js

@@ -1,4 +1,5 @@
-export * from './pikku-fetch-http-request.js';
-export * from './pikku-fetch-http-response.js';
-export * from './log-http-routes.js';
+export { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js';
+export { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
+export { logRoutes } from './log-http-routes.js';
 export { fetch, fetchData, wireHTTP, addHTTPMiddleware, addHTTPPermission, } from './http-runner.js';
+export { wireHTTPRoutes, defineHTTPRoutes } from './http-routes.js';

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

@@ -1,3 +1,4 @@
-export * from './mcp.types.js';
-export * from './mcp-runner.js';
-export * from './mcp-endpoint-registry.js';
+export { MCPEndpointRegistry } from './mcp-endpoint-registry.js';
+export { MCPError, wireMCPResource, wireMCPPrompt, runMCPResource, runMCPTool, runMCPPrompt, } from './mcp-runner.js';
+export { getMCPResourcesMeta, getMCPToolsMeta, getMCPPromptsMeta, } from './mcp-runner.js';
+export type { AssertMCPResourceURIParams, CoreMCPPrompt, CoreMCPResource, CoreMCPTool, MCPPromptResponse, MCPResourceMeta, MCPResourceResponse, MCPToolMeta, MCPToolResponse, MCPPromptMeta, PikkuMCP, } from './mcp.types.js';

package/dist/wirings/mcp/index.js

@@ -1,3 +1,3 @@
-export * from './mcp.types.js';
-export * from './mcp-runner.js';
-export * from './mcp-endpoint-registry.js';
+export { MCPEndpointRegistry } from './mcp-endpoint-registry.js';
+export { MCPError, wireMCPResource, wireMCPPrompt, runMCPResource, runMCPTool, runMCPPrompt, } from './mcp-runner.js';
+export { getMCPResourcesMeta, getMCPToolsMeta, getMCPPromptsMeta, } from './mcp-runner.js';

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

@@ -1,5 +1,5 @@
 import { type CoreServices, type CoreSingletonServices, type CoreUserSession, type CreateWireServices } from '../../types/core.types.js';
-import type { CoreMCPResource, CoreMCPTool, CoreMCPPrompt, JsonRpcRequest, JsonRpcResponse, JsonRpcErrorResponse, PikkuMCP } from './mcp.types.js';
+import type { CoreMCPResource, CoreMCPPrompt, JsonRpcRequest, JsonRpcResponse, JsonRpcErrorResponse, PikkuMCP } from './mcp.types.js';
 import type { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 export declare class MCPError extends Error {
     readonly error: JsonRpcErrorResponse;
@@ -16,12 +16,10 @@ export type JsonRpcError = {
     data?: any;
 };
 export declare const wireMCPResource: <PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>> = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>>>(mcpResource: CoreMCPResource<PikkuFunctionConfig>) => void;
-export declare const wireMCPTool: <PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>> = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>>>(mcpTool: CoreMCPTool<PikkuFunctionConfig>) => void;
 export declare const wireMCPPrompt: <PikkuFunctionConfig extends CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>> = CorePikkuFunctionConfig<CorePikkuFunctionSessionless<any, any>>>(mcpPrompt: CoreMCPPrompt<PikkuFunctionConfig>) => 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;

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

@@ -2,8 +2,8 @@ import { getErrorResponse } from '../../errors/error-handler.js';
 import { closeWireServices } from '../../utils.js';
 import { pikkuState } from '../../pikku-state.js';
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js';
-import { BadRequestError, NotFoundError } from '../../errors/errors.js';
-import { PikkuSessionService } from '../../services/user-session-service.js';
+import { BadRequestError, NotFoundError, PikkuMissingMetaError, } from '../../errors/errors.js';
+import { PikkuSessionService, createMiddlewareSessionWireProps, } from '../../services/user-session-service.js';
 export class MCPError extends Error {
     error;
     constructor(error) {
@@ -17,35 +17,22 @@ export const wireMCPResource = (mcpResource) => {
     const resourcesMeta = pikkuState(null, 'mcp', 'resourcesMeta');
     const mcpResourceMeta = resourcesMeta[mcpResource.uri];
     if (!mcpResourceMeta) {
-        throw new Error(`MCP resource metadata not found for '${mcpResource.uri}'`);
+        throw new PikkuMissingMetaError(`Missing generated metadata for MCP resource '${mcpResource.uri}'`);
     }
-    addFunction(mcpResourceMeta.pikkuFuncName, mcpResource.func);
+    addFunction(mcpResourceMeta.pikkuFuncId, mcpResource.func);
     const resources = pikkuState(null, 'mcp', 'resources');
     if (resources.has(mcpResource.uri)) {
         throw new Error(`MCP resource already exists: ${mcpResource.uri}`);
     }
     resources.set(mcpResource.uri, mcpResource);
 };
-export const wireMCPTool = (mcpTool) => {
-    const toolsMeta = pikkuState(null, 'mcp', 'toolsMeta');
-    const mcpToolMeta = toolsMeta[mcpTool.name];
-    if (!mcpToolMeta) {
-        throw new Error(`MCP tool metadata not found for '${mcpTool.name}'`);
-    }
-    addFunction(mcpToolMeta.pikkuFuncName, mcpTool.func);
-    const tools = pikkuState(null, 'mcp', 'tools');
-    if (tools.has(mcpTool.name)) {
-        throw new Error(`MCP tool already exists: ${mcpTool.name}`);
-    }
-    tools.set(mcpTool.name, mcpTool);
-};
 export const wireMCPPrompt = (mcpPrompt) => {
     const promptsMeta = pikkuState(null, 'mcp', 'promptsMeta');
     const mcpPromptMeta = promptsMeta[mcpPrompt.name];
     if (!mcpPromptMeta) {
-        throw new Error(`MCP prompt metadata not found for '${mcpPrompt.name}'`);
+        throw new PikkuMissingMetaError(`Missing generated metadata for MCP prompt '${mcpPrompt.name}'`);
     }
-    addFunction(mcpPromptMeta.pikkuFuncName, mcpPrompt.func);
+    addFunction(mcpPromptMeta.pikkuFuncId, mcpPrompt.func);
     const prompts = pikkuState(null, 'mcp', 'prompts');
     if (prompts.has(mcpPrompt.name)) {
         throw new Error(`MCP prompt already exists: ${mcpPrompt.name}`);
@@ -54,13 +41,13 @@ export const wireMCPPrompt = (mcpPrompt) => {
 };
 export async function runMCPResource(request, params, uri) {
     let endpoint;
-    let pikkuFuncName;
+    let pikkuFuncId;
     let extractedParams = {};
     const metas = pikkuState(null, 'mcp', 'resourcesMeta');
     const endpoints = pikkuState(null, 'mcp', 'resources');
     if (endpoints.has(uri)) {
         endpoint = endpoints.get(uri);
-        pikkuFuncName = metas[uri]?.pikkuFuncName;
+        pikkuFuncId = metas[uri]?.pikkuFuncId;
     }
     else {
         for (const [uriTemplate, value] of endpoints.entries()) {
@@ -72,7 +59,7 @@ export async function runMCPResource(request, params, uri) {
             const match = uri.match(regex);
             if (match) {
                 endpoint = value;
-                pikkuFuncName = metas[uriTemplate]?.pikkuFuncName;
+                pikkuFuncId = metas[uriTemplate]?.pikkuFuncId;
                 // 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
@@ -84,40 +71,38 @@ export async function runMCPResource(request, params, uri) {
     return await runMCPPikkuFunc({
         ...request,
         params: { ...request.params, ...extractedParams },
-    }, 'resource', uri, endpoint, pikkuFuncName, { ...params, mcp: { ...params.mcp, uri } });
+    }, 'resource', uri, endpoint, pikkuFuncId, { ...params, mcp: { ...params.mcp, uri } });
 }
 export async function runMCPTool(request, params, name) {
-    const endpoint = pikkuState(null, 'mcp', 'tools').get(name);
     const meta = pikkuState(null, 'mcp', 'toolsMeta')[name];
-    return await runMCPPikkuFunc(request, 'tool', name, endpoint, meta?.pikkuFuncName, params);
+    return await runMCPPikkuFunc(request, 'tool', name, undefined, meta?.pikkuFuncId, params);
 }
 export async function runMCPPrompt(request, params, name) {
     const endpoint = pikkuState(null, 'mcp', 'prompts').get(name);
     const meta = pikkuState(null, 'mcp', 'promptsMeta')[name];
-    return await runMCPPikkuFunc(request, 'prompt', name, endpoint, meta?.pikkuFuncName, params);
+    return await runMCPPikkuFunc(request, 'prompt', name, endpoint, meta?.pikkuFuncId, params);
 }
 /**
  * JSON-RPC 2.0 compatible MCP endpoint runner
  */
-async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { singletonServices, createWireServices, mcp: mcpWire }) {
+async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncId, { singletonServices, createWireServices, mcp: mcpWire }) {
     let wireServices;
     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) {
+        if (mcp === undefined && type !== 'tool') {
             throw new NotFoundError(`MCP '${type}' registration not found for '${name}'`);
         }
-        if (!pikkuFuncName) {
+        if (!pikkuFuncId) {
             throw new NotFoundError(`MCP '${type}' PikkuFunction Mapping not found for '${name}'`);
         }
         singletonServices.logger.debug(`Running MCP ${type}: ${name}`);
+        const mcpSessionService = new PikkuSessionService();
         const wire = {
             mcp: mcpWire,
-            session: new PikkuSessionService(),
+            ...createMiddlewareSessionWireProps(mcpSessionService),
         };
-        // Get metadata for the MCP endpoint to access pre-resolved middleware
         let meta;
         if (type === 'resource') {
             meta = pikkuState(null, 'mcp', 'resourcesMeta')[name];
@@ -128,17 +113,21 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { single
         else if (type === 'prompt') {
             meta = pikkuState(null, 'mcp', 'promptsMeta')[name];
         }
-        const result = await runPikkuFunc('mcp', `${type}:${name}`, pikkuFuncName, {
+        let result = await runPikkuFunc('mcp', `${type}:${name}`, pikkuFuncId, {
             singletonServices,
             createWireServices,
             data: () => request.params,
             inheritedMiddleware: meta?.middleware,
-            wireMiddleware: mcp.middleware,
+            wireMiddleware: mcp?.middleware,
             inheritedPermissions: meta?.permissions,
-            wirePermissions: mcp.permissions,
-            tags: mcp.tags,
+            wirePermissions: mcp?.permissions,
+            tags: mcp?.tags,
             wire,
+            sessionService: mcpSessionService,
         });
+        if (type === 'tool' && meta?.outputSchema !== 'MCPToolResponse') {
+            result = [{ type: 'text', text: JSON.stringify(result) }];
+        }
         return {
             id: request.id,
             result,
@@ -172,9 +161,6 @@ async function runMCPPikkuFunc(request, type, name, mcp, pikkuFuncName, { single
         }
     }
 }
-export const getMCPTools = () => {
-    return pikkuState(null, 'mcp', 'tools');
-};
 export const getMCPResources = () => {
     return pikkuState(null, 'mcp', 'resources');
 };

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

@@ -26,7 +26,7 @@ export type PikkuMCP<Tools extends string = any> = {
  * Represents metadata for MCP resources, including name, description, and documentation.
  */
 export type MCPResourceMeta = Record<string, Omit<CoreMCPResource, 'func' | 'middleware' | 'permissions'> & {
-    pikkuFuncName: string;
+    pikkuFuncId: string;
     inputSchema: string | null;
     outputSchema: string | null;
     middleware?: MiddlewareMetadata[];
@@ -36,7 +36,7 @@ export type MCPResourceMeta = Record<string, Omit<CoreMCPResource, 'func' | 'mid
  * Represents metadata for MCP tools, including name, description, and documentation.
  */
 export type MCPToolMeta = Record<string, Omit<CoreMCPTool, 'func' | 'middleware' | 'permissions'> & {
-    pikkuFuncName: string;
+    pikkuFuncId: string;
     inputSchema: string | null;
     outputSchema: string | null;
     middleware?: MiddlewareMetadata[];
@@ -46,7 +46,7 @@ export type MCPToolMeta = Record<string, Omit<CoreMCPTool, 'func' | 'middleware'
  * Represents metadata for MCP prompts, including name, description, and arguments.
  */
 export type MCPPromptMeta = Record<string, Omit<CoreMCPPrompt, 'func' | 'middleware' | 'permissions'> & {
-    pikkuFuncName: string;
+    pikkuFuncId: string;
     inputSchema: string | null;
     outputSchema: string | null;
     arguments: Array<{

package/dist/wirings/node/index.d.ts

@@ -0,0 +1,2 @@
+export type { CoreNodeConfig, NodeType } from './node.types.js';
+export type { NodesMeta } from './node.types.js';

package/dist/wirings/node/index.js

@@ -0,0 +1 @@
+export {};

package/dist/wirings/node/node.types.d.ts

@@ -0,0 +1,20 @@
+export type NodeType = 'trigger' | 'action' | 'end';
+export type CoreNodeConfig = {
+    displayName: string;
+    category: string;
+    type: NodeType;
+    errorOutput?: boolean;
+};
+export type NodeMeta = {
+    name: string;
+    displayName: string;
+    category: string;
+    type: NodeType;
+    rpc: string;
+    description?: string;
+    errorOutput: boolean;
+    inputSchemaName: string | null;
+    outputSchemaName: string | null;
+    tags?: string[];
+};
+export type NodesMeta = Record<string, NodeMeta>;

package/dist/wirings/node/node.types.js

@@ -0,0 +1 @@
+export {};

package/dist/wirings/oauth2/index.d.ts

@@ -0,0 +1,3 @@
+export { OAuth2Client } from './oauth2-client.js';
+export { wireOAuth2Credential } from './wire-oauth2-credential.js';
+export type { OAuth2AppCredential, OAuth2Token } from './oauth2.types.js';

package/dist/wirings/oauth2/index.js

@@ -0,0 +1,2 @@
+export { OAuth2Client } from './oauth2-client.js';
+export { wireOAuth2Credential } from './wire-oauth2-credential.js';