@pikku/core 0.11.0 → 0.11.2

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

@@ -0,0 +1,120 @@
+/**
+ * Forge node types for workflow builder visualization.
+ * wireForgeNode is metadata-only - no runtime behavior.
+ * The CLI extracts this via AST and generates JSON metadata.
+ */
+/**
+ * The type of forge node.
+ * - trigger: Starts workflows (webhooks, schedules, events)
+ * - action: Operations that do something (API calls, send email, database ops)
+ * - end: Terminal nodes with no outputs (logging, notifications)
+ */
+export type ForgeNodeType = 'trigger' | 'action' | 'end';
+/**
+ * Configuration for wireForgeNode.
+ * This is the input type that developers use when defining nodes.
+ */
+export type CoreForgeNode = {
+    /** Unique identifier for this node */
+    name: string;
+    /** Human-readable name for UI display */
+    displayName: string;
+    /** Grouping category (validated against forge.node.categories in config) */
+    category: string;
+    /** Node type determining behavior and outputs */
+    type: ForgeNodeType;
+    /** RPC name to call when node executes (local name, Forge handles package aliasing) */
+    rpc: string;
+    /** Optional description for UI */
+    description?: string;
+    /** Whether to add an error output port alongside the default output */
+    errorOutput?: boolean;
+    /** Optional tags for filtering/categorization */
+    tags?: string[];
+};
+/**
+ * Metadata generated for each forge node.
+ * This is the output type that the CLI generates.
+ */
+export type ForgeNodeMeta = {
+    name: string;
+    displayName: string;
+    category: string;
+    type: ForgeNodeType;
+    /** RPC name (local, remapped by Forge for external packages) */
+    rpc: string;
+    description?: string;
+    /** Whether node has error output port */
+    errorOutput: boolean;
+    /** Input schema name extracted from RPC */
+    inputSchemaName: string | null;
+    /** Output schema name extracted from RPC */
+    outputSchemaName: string | null;
+    tags?: string[];
+};
+/**
+ * Record of all forge node metadata, keyed by node name.
+ */
+export type ForgeNodesMeta = Record<string, ForgeNodeMeta>;
+/**
+ * No-op function for wireForgeNode.
+ * This exists purely for TypeScript type checking and will be tree-shaken.
+ * The CLI extracts metadata via AST parsing.
+ */
+export declare const wireForgeNode: (_config: CoreForgeNode) => void;
+/**
+ * Configuration for wireForgeCredential.
+ * Declares credentials/secrets required by a Forge package.
+ * Uses Zod for schema definition - converted to JSON Schema at build time.
+ */
+export type CoreForgeCredential<T = unknown> = {
+    /** Unique identifier for this credential */
+    name: string;
+    /** Human-readable name for UI display */
+    displayName: string;
+    /** Optional description for UI */
+    description?: string;
+    /** Key used with SecretService.getSecret() to retrieve the credential */
+    secretId: string;
+    /** Zod schema defining the structure of the credential */
+    schema: T;
+};
+/**
+ * Metadata generated for each forge credential.
+ * Schema is converted from Zod to JSON Schema at build time.
+ */
+export type ForgeCredentialMeta = {
+    name: string;
+    displayName: string;
+    description?: string;
+    secretId: string;
+    /** JSON Schema (converted from Zod at build time) or zodLookup reference name */
+    schema: Record<string, unknown> | string;
+};
+/**
+ * Record of all forge credential metadata, keyed by credential name.
+ */
+export type ForgeCredentialsMeta = Record<string, ForgeCredentialMeta>;
+/**
+ * No-op function for wireForgeCredential.
+ * This exists purely for TypeScript type checking and will be tree-shaken.
+ * The CLI extracts metadata via AST parsing.
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod'
+ *
+ * const slackCredentials = z.object({
+ *   botToken: z.string().describe('Bot OAuth token'),
+ *   signingSecret: z.string().describe('Request signing secret')
+ * })
+ *
+ * wireForgeCredential({
+ *   name: 'slack',
+ *   displayName: 'Slack Credentials',
+ *   secretId: 'SLACK_CREDENTIALS',
+ *   schema: slackCredentials
+ * })
+ * ```
+ */
+export declare const wireForgeCredential: <T>(_config: CoreForgeCredential<T>) => void;

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

@@ -0,0 +1,38 @@
+/**
+ * Forge node types for workflow builder visualization.
+ * wireForgeNode is metadata-only - no runtime behavior.
+ * The CLI extracts this via AST and generates JSON metadata.
+ */
+/**
+ * No-op function for wireForgeNode.
+ * This exists purely for TypeScript type checking and will be tree-shaken.
+ * The CLI extracts metadata via AST parsing.
+ */
+export const wireForgeNode = (_config) => {
+    // No-op - metadata only, extracted by CLI via AST
+};
+/**
+ * No-op function for wireForgeCredential.
+ * This exists purely for TypeScript type checking and will be tree-shaken.
+ * The CLI extracts metadata via AST parsing.
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod'
+ *
+ * const slackCredentials = z.object({
+ *   botToken: z.string().describe('Bot OAuth token'),
+ *   signingSecret: z.string().describe('Request signing secret')
+ * })
+ *
+ * wireForgeCredential({
+ *   name: 'slack',
+ *   displayName: 'Slack Credentials',
+ *   secretId: 'SLACK_CREDENTIALS',
+ *   schema: slackCredentials
+ * })
+ * ```
+ */
+export const wireForgeCredential = (_config) => {
+    // No-op - metadata only, extracted by CLI via AST
+};

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

@@ -0,0 +1 @@
+export * from './forge-node.types.js';

package/dist/wirings/forge-node/index.js

@@ -0,0 +1 @@
+export * from './forge-node.types.js';

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

@@ -31,7 +31,7 @@ import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
  * ])
  * ```
  */
-export declare const addHTTPMiddleware: <PikkuMiddleware extends CorePikkuMiddleware>(pattern: string, middleware: CorePikkuMiddlewareGroup) => CorePikkuMiddlewareGroup;
+export declare const addHTTPMiddleware: <PikkuMiddleware extends CorePikkuMiddleware>(pattern: string, middleware: CorePikkuMiddlewareGroup, packageName?: string | null) => CorePikkuMiddlewareGroup;
 /**
  * Registers HTTP permissions for a specific route pattern.
  *
@@ -61,7 +61,7 @@ export declare const addHTTPMiddleware: <PikkuMiddleware extends CorePikkuMiddle
  * ])
  * ```
  */
-export declare const addHTTPPermission: <PikkuPermission extends CorePikkuPermission>(pattern: string, permissions: CorePermissionGroup | CorePikkuPermission[]) => CorePermissionGroup | CorePikkuPermission[];
+export declare const addHTTPPermission: <PikkuPermission extends CorePikkuPermission>(pattern: string, permissions: CorePermissionGroup | CorePikkuPermission[], packageName?: string | null) => CorePermissionGroup | CorePikkuPermission[];
 /**
  * Adds a new route to the global HTTP route registry.
  *
@@ -79,16 +79,16 @@ export declare const addHTTPPermission: <PikkuPermission extends CorePikkuPermis
  */
 export declare const wireHTTP: <In, Out, Route extends string, PikkuFunction extends CorePikkuFunction<In, Out> = CorePikkuFunction<In, Out>, PikkuFunctionSessionless extends CorePikkuFunctionSessionless<In, Out> = CorePikkuFunctionSessionless<In, Out>, PikkuPermissionGroup extends CorePikkuPermission<In> = CorePikkuPermission<In>, PikkuMiddleware extends CorePikkuMiddleware = CorePikkuMiddleware>(httpWiring: CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction, PikkuFunctionSessionless, PikkuPermissionGroup, PikkuMiddleware>) => void;
 /**
- * Combines the request and response objects into a single HTTP interaction object.
+ * Combines the request and response objects into a single HTTP wire object.
  *
  * This utility function creates an object that holds both the HTTP request and response,
  * which simplifies passing these around through middleware and route execution.
  *
  * @param {PikkuHTTPRequest | undefined} request - The HTTP request object.
  * @param {PikkuHTTPResponse | undefined} response - The HTTP response object.
- * @returns {PikkuHTTP | undefined} The combined HTTP interaction object or undefined if none provided.
+ * @returns {PikkuHTTP | undefined} The combined HTTP wire object or undefined if none provided.
  */
-export declare const createHTTPInteraction: (request: PikkuHTTPRequest | undefined, response: PikkuHTTPResponse | undefined) => PikkuHTTP | undefined;
+export declare const createHTTPWire: (request: PikkuHTTPRequest | undefined, response: PikkuHTTPResponse | undefined) => PikkuHTTP | undefined;
 /**
  * Executes an HTTP route for a given Fetch API request.
  *
@@ -123,11 +123,11 @@ export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest,
  * middleware execution, error handling, and session service cleanup.
  *
  * This function does the following:
- *  - Wraps the incoming request and response into an HTTP interaction object.
+ *  - Wraps the incoming request and response into an HTTP wire object.
  *  - Determines the correct route based on HTTP method and path.
  *  - Executes middleware and the route handler.
  *  - Catches and handles errors, optionally bubbling them if configured.
- *  - Cleans up any session services created during processing.
+ *  - Cleans up any wire services created during processing.
  *
  * @template In Expected input data type.
  * @template Out Expected output data type.
@@ -136,4 +136,4 @@ export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest,
  * @param {RunHTTPWiringOptions & RunHTTPWiringParams} 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, }: RunHTTPWiringOptions & RunHTTPWiringParams) => Promise<Out | void>;
+export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { singletonServices, createWireServices, skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, generateRequestId, }: RunHTTPWiringOptions & RunHTTPWiringParams) => Promise<Out | void>;

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

@@ -1,14 +1,13 @@
-import { PikkuWiringTypes, } from '../../types/core.types.js';
 import { NotFoundError } from '../../errors/errors.js';
-import { closeSessionServices, createWeakUID, isSerializable, } from '../../utils.js';
-import { PikkuUserSessionService } from '../../services/user-session-service.js';
+import { closeWireServices, createWeakUID, isSerializable, } from '../../utils.js';
+import { PikkuSessionService } 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 { rpcService } from '../rpc/rpc-runner.js';
 import { httpRouter } from './routers/http-router.js';
+import { startWorkflowByHttpWire } from '../workflow/workflow-utils.js';
 /**
  * Registers HTTP middleware for a specific route pattern.
  *
@@ -38,8 +37,8 @@ import { httpRouter } from './routers/http-router.js';
  * ])
  * ```
  */
-export const addHTTPMiddleware = (pattern, middleware) => {
-    const httpGroups = pikkuState('middleware', 'httpGroup');
+export const addHTTPMiddleware = (pattern, middleware, packageName = null) => {
+    const httpGroups = pikkuState(packageName, 'middleware', 'httpGroup');
     httpGroups[pattern] = middleware;
     return middleware;
 };
@@ -72,8 +71,8 @@ export const addHTTPMiddleware = (pattern, middleware) => {
  * ])
  * ```
  */
-export const addHTTPPermission = (pattern, permissions) => {
-    const httpGroups = pikkuState('permissions', 'httpGroup');
+export const addHTTPPermission = (pattern, permissions, packageName = null) => {
+    const httpGroups = pikkuState(packageName, 'permissions', 'httpGroup');
     httpGroups[pattern] = permissions;
     return permissions;
 };
@@ -93,17 +92,19 @@ export const addHTTPPermission = (pattern, permissions) => {
  * @param {CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware>} httpWiring - The HTTP wiring configuration object.
  */
 export const wireHTTP = (httpWiring) => {
-    const httpMeta = pikkuState('http', 'meta');
+    const httpMeta = pikkuState(null, 'http', 'meta');
     const routeMeta = httpMeta[httpWiring.method][httpWiring.route];
     if (!routeMeta) {
         throw new Error('Route metadata not found');
     }
-    addFunction(routeMeta.pikkuFuncName, httpWiring.func);
-    const routes = pikkuState('http', 'routes');
+    if (httpWiring.func) {
+        addFunction(routeMeta.pikkuFuncName, httpWiring.func);
+    }
+    const routes = pikkuState(null, 'http', 'routes');
     if (!routes.has(httpWiring.method)) {
         routes.set(httpWiring.method, new Map());
     }
-    pikkuState('http', 'routes')
+    pikkuState(null, 'http', 'routes')
         .get(httpWiring.method)
         ?.set(httpWiring.route, httpWiring);
 };
@@ -121,10 +122,10 @@ export const wireHTTP = (httpWiring) => {
 const getMatchingRoute = (requestType, requestPath) => {
     const matchedPath = httpRouter.match(requestType.toLowerCase(), requestPath);
     if (matchedPath) {
-        const route = pikkuState('http', 'routes')
+        const route = pikkuState(null, 'http', 'routes')
             .get(requestType.toLowerCase())
             .get(matchedPath.route);
-        const meta = pikkuState('http', 'meta')[requestType.toLowerCase()][route.route];
+        const meta = pikkuState(null, 'http', 'meta')[requestType.toLowerCase()][route.route];
         return {
             matchedPath,
             params: matchedPath.params,
@@ -135,16 +136,16 @@ const getMatchingRoute = (requestType, requestPath) => {
     }
 };
 /**
- * Combines the request and response objects into a single HTTP interaction object.
+ * Combines the request and response objects into a single HTTP wire object.
  *
  * This utility function creates an object that holds both the HTTP request and response,
  * which simplifies passing these around through middleware and route execution.
  *
  * @param {PikkuHTTPRequest | undefined} request - The HTTP request object.
  * @param {PikkuHTTPResponse | undefined} response - The HTTP response object.
- * @returns {PikkuHTTP | undefined} The combined HTTP interaction object or undefined if none provided.
+ * @returns {PikkuHTTP | undefined} The combined HTTP wire object or undefined if none provided.
  */
-export const createHTTPInteraction = (request, response) => {
+export const createHTTPWire = (request, response) => {
     let http = undefined;
     if (request || response) {
         http = {};
@@ -172,20 +173,20 @@ export const createHTTPInteraction = (request, response) => {
  *
  * @param {Object} services - A collection of shared services and utilities.
  * @param {Object} matchedRoute - Contains route details, URL parameters, and optional schema.
- * @param {PikkuHTTP | undefined} http - The HTTP interaction object.
+ * @param {PikkuHTTP | undefined} http - The HTTP wire object.
  * @param {Object} options - Options for route execution (e.g., whether to coerce query strings to arrays).
- * @returns {Promise<any>} An object containing the route handler result and session services (if any).
+ * @returns {Promise<any>} An object containing the route handler result and wire services (if any).
  * @throws Throws errors like MissingSessionError or ForbiddenError on validation failures.
  */
 const executeRoute = async (services, matchedRoute, http, options) => {
-    const userSession = new PikkuUserSessionService();
+    const userSession = new PikkuSessionService();
     const { params, route, meta } = matchedRoute;
-    const { singletonServices, createSessionServices, skipUserSession, requestId, } = services;
-    const requiresSession = route.auth !== false;
-    let sessionServices;
-    let result;
+    const { singletonServices, createWireServices, skipUserSession, requestId } = services;
     // Attach URL parameters to the request object
     http?.request?.setParams(params);
+    const requiresSession = route.auth !== false;
+    let wireServices;
+    let result;
     singletonServices.logger.info(`Matched route: ${route.route} | method: ${route.method.toUpperCase()} | auth: ${requiresSession.toString()}`);
     // Ensure session is available when required
     if (skipUserSession && requiresSession) {
@@ -219,23 +220,17 @@ const executeRoute = async (services, matchedRoute, http, options) => {
             state: 'open',
         };
     }
-    const interaction = { http, channel };
-    const getAllServices = async (session) => {
-        // Create session-specific services for handling the request
-        sessionServices = await createSessionServices({ ...singletonServices, userSession, channel }, { http }, session);
-        return rpcService.injectRPCService({
-            ...singletonServices,
-            ...sessionServices,
-            http,
-            userSession,
-            channel,
-        }, interaction, route.auth);
-    };
-    result = await runPikkuFunc(PikkuWiringTypes.http, `${meta.method}:${meta.route}`, meta.pikkuFuncName, {
+    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, {
         singletonServices,
-        getAllServices,
+        createWireServices,
         auth: route.auth !== false,
-        userSession,
         data,
         inheritedMiddleware: meta.middleware,
         wireMiddleware: route.middleware,
@@ -243,7 +238,7 @@ const executeRoute = async (services, matchedRoute, http, options) => {
         wirePermissions: route.permissions,
         coerceDataFromSchema: options.coerceDataFromSchema,
         tags: route.tags,
-        interaction,
+        wire,
     });
     // Respond with either a binary or JSON response based on configuration
     if (route.returnsJSON === false) {
@@ -255,7 +250,7 @@ const executeRoute = async (services, matchedRoute, http, options) => {
     http?.response?.status(200);
     // TODO: Evaluate if the response stream should be explicitly ended.
     // http?.response?.end()
-    return sessionServices ? { result, sessionServices } : { result };
+    return wireServices ? { result, wireServices } : { result };
 };
 /**
  * Executes an HTTP route for a given Fetch API request.
@@ -299,11 +294,11 @@ export const pikkuFetch = async (request, params) => {
  * middleware execution, error handling, and session service cleanup.
  *
  * This function does the following:
- *  - Wraps the incoming request and response into an HTTP interaction object.
+ *  - Wraps the incoming request and response into an HTTP wire object.
  *  - Determines the correct route based on HTTP method and path.
  *  - Executes middleware and the route handler.
  *  - Catches and handles errors, optionally bubbling them if configured.
- *  - Cleans up any session services created during processing.
+ *  - Cleans up any wire services created during processing.
  *
  * @template In Expected input data type.
  * @template Out Expected output data type.
@@ -312,14 +307,14 @@ export const pikkuFetch = async (request, params) => {
  * @param {RunHTTPWiringOptions & RunHTTPWiringParams} 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, createWireServices, skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, generateRequestId, }) => {
     const requestId = request.getHeader?.('x-request-id') ||
         generateRequestId?.() ||
         createWeakUID();
-    let sessionServices;
+    let wireServices;
     let result;
-    // Combine the request and response into one interaction object
-    const http = createHTTPInteraction(request instanceof Request ? new PikkuFetchHTTPRequest(request) : request, response);
+    // Combine the request and response into one wire object
+    const http = createHTTPWire(request instanceof Request ? new PikkuFetchHTTPRequest(request) : request, response);
     const apiType = http.request.method();
     const apiRoute = http.request.path();
     // Locate the matching route based on the HTTP method and path
@@ -336,9 +331,9 @@ export const fetchData = async (request, response, { singletonServices, createSe
         }
         // Execute the matched route along with its middleware and session management
         ;
-        ({ result, sessionServices } = await executeRoute({
+        ({ result, wireServices } = await executeRoute({
             singletonServices,
-            createSessionServices,
+            createWireServices,
             skipUserSession,
             requestId,
         }, matchedRoute, http, { coerceDataFromSchema }));
@@ -350,8 +345,8 @@ export const fetchData = async (request, response, { singletonServices, createSe
     }
     finally {
         // Clean up any session-specific services created during processing
-        if (sessionServices) {
-            await closeSessionServices(singletonServices.logger, sessionServices);
+        if (wireServices) {
+            await closeWireServices(singletonServices.logger, wireServices);
         }
     }
 };

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

@@ -1,6 +1,6 @@
 import type { SerializeOptions } from 'cookie';
 import type { PikkuError } from '../../errors/error-handler.js';
-import type { PikkuDocs, CoreServices, CoreSingletonServices, CoreUserSession, CreateSessionServices, CorePikkuMiddleware, MiddlewareMetadata, PermissionMetadata } from '../../types/core.types.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;
 export type AssertHTTPWiringParams<In, HTTPWiring extends string> = ExtractHTTPWiringParams<HTTPWiring> extends keyof In ? unknown : [
@@ -19,7 +19,7 @@ export type RunHTTPWiringOptions = Partial<{
 }>;
 export type RunHTTPWiringParams = {
     singletonServices: CoreSingletonServices;
-    createSessionServices: CreateSessionServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
+    createWireServices: CreateWireServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
 };
 /**
  * Represents the HTTP methods supported for API HTTP wirings.
@@ -43,7 +43,7 @@ export type CoreHTTPFunction = {
     }>;
 };
 /**
- * Represents a http interaction within Pikku, including a request and response.
+ * Represents a http wire within Pikku, including a request and response.
  */
 export interface PikkuHTTP<In = unknown> {
     request?: PikkuHTTPRequest<In>;
@@ -67,7 +67,7 @@ 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, 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 & {
+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 & {
     route: R;
     method: HTTPMethod;
     func: CorePikkuFunctionConfig<PikkuFunction, PikkuPermission, PikkuMiddleware>;
@@ -123,7 +123,19 @@ export type CoreHTTPFunctionWiring<In, Out, R extends string, PikkuFunction exte
     tags?: string[];
     middleware?: PikkuMiddleware[];
     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.
  */
@@ -135,18 +147,14 @@ export type HTTPFunctionMetaInputTypes = {
 /**
  * Represents metadata for a set of HTTP wirings, including HTTP wiring details, methods, input/output types, and documentation.
  */
-export type HTTPWiringMeta = {
-    pikkuFuncName: string;
+export type HTTPWiringMeta = CommonWireMeta & {
     route: string;
     method: HTTPMethod;
     params?: string[];
     query?: string[];
     inputTypes?: HTTPFunctionMetaInputTypes;
-    docs?: PikkuDocs;
-    tags?: string[];
     sse?: true;
-    middleware?: MiddlewareMetadata[];
-    permissions?: PermissionMetadata[];
+    workflow?: true;
 };
 export type HTTPWiringsMeta = Record<HTTPMethod, Record<string, HTTPWiringMeta>>;
 export type HTTPFunctionsMeta = Array<{

package/dist/wirings/http/log-http-routes.js

@@ -4,7 +4,7 @@ import { pikkuState } from '../../pikku-state.js';
  * @param logger - A logger for logging information.
  */
 export const logRoutes = (logger) => {
-    const routesByType = pikkuState('http', 'routes');
+    const routesByType = pikkuState(null, 'http', 'routes');
     if (routesByType.size === 0) {
         logger.info('No routes added');
         return;

package/dist/wirings/http/routers/path-to-regex.js

@@ -10,8 +10,8 @@ export class PathToRegexRouter {
         this.isInitialized = false;
     }
     initialize() {
-        const routes = pikkuState('http', 'routes');
-        const channelRoutes = pikkuState('channel', 'channels');
+        const routes = pikkuState(null, 'http', 'routes');
+        const channelRoutes = pikkuState(null, 'channel', 'channels');
         // Helper function to compile routes for a given method
         const compileRoutesForMethod = (method, routeEntries) => {
             const methodCompiledRoutes = this.compiledRoutes.get(method) || new Map();

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

@@ -1,4 +1,4 @@
-import { type CoreServices, type CoreSingletonServices, type CoreUserSession, type CreateSessionServices } from '../../types/core.types.js';
+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 { CorePikkuFunctionConfig, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
 export declare class MCPError extends Error {
@@ -8,7 +8,7 @@ export declare class MCPError extends Error {
 export type RunMCPEndpointParams<Tools extends string = any> = {
     singletonServices: CoreSingletonServices;
     mcp?: PikkuMCP<Tools>;
-    createSessionServices?: CreateSessionServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
+    createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices<CoreSingletonServices>, CoreUserSession>;
 };
 export type JsonRpcError = {
     code: number;