@pikku/core 0.11.2 → 0.12.1

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

@@ -1,6 +1,7 @@
 import type { SerializeOptions } from 'cookie';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
 import type { PikkuError } from '../../errors/error-handler.js';
-import type { CoreServices, CoreSingletonServices, CoreUserSession, CreateWireServices, CorePikkuMiddleware, CommonWireMeta } from '../../types/core.types.js';
+import type { 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;
 export type AssertHTTPWiringParams<In, HTTPWiring extends string> = ExtractHTTPWiringParams<HTTPWiring> extends keyof In ? unknown : [
@@ -17,30 +18,41 @@ export type RunHTTPWiringOptions = Partial<{
     bubbleErrors: boolean;
     generateRequestId: () => string;
 }>;
-export type RunHTTPWiringParams = {
-    singletonServices: CoreSingletonServices;
-    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 CoreHTTPFunction = {
+export type HTTPRouteDocsConfig = {
+    description?: string;
+    response?: string;
+    errors?: Array<typeof PikkuError>;
+    tags?: string[];
+};
+/**
+ * Common HTTP route configuration shared between wireHTTP and wireHTTPRoutes
+ */
+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 +79,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 +93,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 +101,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 +126,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 +147,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 +183,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/http/log-http-routes.d.ts

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

package/dist/wirings/http/pikku-fetch-http-request.d.ts

@@ -1,4 +1,4 @@
-import { HTTPMethod, PikkuHTTPRequest, PikkuQuery } from './http.types.js';
+import type { HTTPMethod, PikkuHTTPRequest, PikkuQuery } from './http.types.js';
 /**
  * Abstract class representing a pikku request.
  * @template In - The type of the request body.

package/dist/wirings/http/pikku-fetch-http-response.d.ts

@@ -1,5 +1,5 @@
-import { PikkuHTTPResponse } from './http.types.js';
-import { SerializeOptions as CookieSerializeOptions } from 'cookie';
+import type { PikkuHTTPResponse } from './http.types.js';
+import type { SerializeOptions as CookieSerializeOptions } from 'cookie';
 export declare class PikkuFetchHTTPResponse implements PikkuHTTPResponse {
     #private;
     setMode(mode: 'stream'): void;

package/dist/wirings/http/pikku-fetch-http-response.js

@@ -1,4 +1,4 @@
-import { serialize as serializeCookie, } from 'cookie';
+import { serialize as serializeCookie } from 'cookie';
 export class PikkuFetchHTTPResponse {
     #statusCode = 200;
     #headers = new Headers();
@@ -76,6 +76,11 @@ export class PikkuFetchHTTPResponse {
     //   return this
     // }
     redirect(location, status = 302) {
+        if (!location.startsWith('/') &&
+            !location.startsWith('https://') &&
+            !location.startsWith('http://')) {
+            throw new Error('Invalid redirect location: must be a relative path or absolute URL');
+        }
         this.#statusCode = status;
         this.header('Location', location);
         return this;

package/dist/wirings/http/routers/http-router.d.ts

@@ -1,4 +1,4 @@
-import { HTTPMethod } from '../http.types.js';
+import type { HTTPMethod } from '../http.types.js';
 import { PathToRegexRouter } from './path-to-regex.js';
 export type MatchResult = {
     route: string;

package/dist/wirings/http/routers/path-to-regex.d.ts

@@ -1,5 +1,5 @@
-import { MatchResult, Router } from './http-router.js';
-import { HTTPMethod } from '../http.types.js';
+import type { MatchResult, Router } from './http-router.js';
+import type { HTTPMethod } from '../http.types.js';
 export declare class PathToRegexRouter implements Router {
     private compiledRoutes;
     private staticRoutes;

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-endpoint-registry.d.ts

@@ -1,4 +1,4 @@
-import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp';
+import type { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp';
 export interface MCPToolEndpoint {
     name: string;
     title: string;

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

@@ -1,14 +1,11 @@
-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;
     constructor(error: JsonRpcErrorResponse);
 }
 export type RunMCPEndpointParams<Tools extends string = any> = {
-    singletonServices: CoreSingletonServices;
     mcp?: PikkuMCP<Tools>;
-    createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
 };
 export type JsonRpcError = {
     code: number;
@@ -16,12 +13,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

@@ -1,9 +1,9 @@
 import { getErrorResponse } from '../../errors/error-handler.js';
 import { closeWireServices } from '../../utils.js';
-import { pikkuState } from '../../pikku-state.js';
+import { pikkuState, getSingletonServices, getCreateWireServices, } 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,40 @@ 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, { mcp: mcpWire }) {
+    const singletonServices = getSingletonServices();
+    const createWireServices = getCreateWireServices();
     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 +115,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 +163,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

@@ -1,5 +1,5 @@
-import { CorePermissionGroup, CorePikkuFunctionConfig, CorePikkuFunctionSessionless, CorePikkuPermission } from '../../function/functions.types.js';
-import { CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
+import type { CorePermissionGroup, CorePikkuFunctionConfig, CorePikkuFunctionSessionless, CorePikkuPermission } from '../../function/functions.types.js';
+import type { CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.js';
 /**
  * Extract URI parameters from MCP resource URI template.
  * E.g., "user/{userId}/post/{postId}" => "userId" | "postId"
@@ -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';

package/dist/wirings/oauth2/oauth2-client.d.ts

@@ -0,0 +1,47 @@
+import type { OAuth2Token } from './oauth2.types.js';
+import type { OAuth2CredentialConfig } from '../secret/secret.types.js';
+import type { SecretService } from '../../services/secret-service.js';
+export declare class OAuth2Client {
+    private oauth2Config;
+    private appCredentialSecretId;
+    private secrets;
+    private cachedToken;
+    private cachedAppCredential;
+    private refreshPromise;
+    constructor(oauth2Config: OAuth2CredentialConfig, appCredentialSecretId: string, secrets: SecretService);
+    /**
+     * Make an authenticated request. Handles token caching and 401 refresh.
+     */
+    request(url: string, options?: RequestInit, timeoutMs?: number): Promise<Response>;
+    /**
+     * Get cached token or load from secrets.
+     */
+    getAccessToken(): Promise<string>;
+    /**
+     * Refresh token and update cache.
+     * Uses a promise lock to prevent concurrent refresh attempts.
+     */
+    private refreshAndGetToken;
+    /**
+     * Perform the actual token refresh.
+     */
+    private doRefreshToken;
+    /**
+     * Check if token is valid (not expired).
+     */
+    private isTokenValid;
+    /**
+     * Get app credentials (cached).
+     */
+    private getAppCredential;
+    /**
+     * Generate OAuth2 authorization URL.
+     * Used by CLI during `pikku oauth connect`.
+     */
+    getAuthorizationUrl(state: string, redirectUri: string): Promise<string>;
+    /**
+     * Exchange authorization code for tokens.
+     * Used by CLI during `pikku oauth connect`.
+     */
+    exchangeCode(code: string, redirectUri: string): Promise<OAuth2Token>;
+}