@pikku/cli 0.11.2 → 0.12.0

package/dist/src/functions/wirings/http/serialize-http-types.js

@@ -6,9 +6,9 @@ export const serializeHTTPTypes = (functionTypesImportPath) => {
  * HTTP-specific type definitions for tree-shaking optimization
  */
 
-import { AssertHTTPWiringParams, wireHTTP as wireHTTPCore, addHTTPMiddleware as addHTTPMiddlewareCore, addHTTPPermission as addHTTPPermissionCore } from '@pikku/core/http'
-import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
-import type { CoreHTTPFunctionWiring } from '@pikku/core/http'
+import { AssertHTTPWiringParams, wireHTTP as wireHTTPCore, addHTTPMiddleware as addHTTPMiddlewareCore, addHTTPPermission as addHTTPPermissionCore, wireHTTPRoutes as wireHTTPRoutesCore, defineHTTPRoutes as defineHTTPRoutesCore } from '@pikku/core/http'
+import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware, PikkuFunctionConfig } from '${functionTypesImportPath}'
+import type { CoreHTTPFunctionWiring, HTTPMethod, HTTPRouteBaseConfig } from '@pikku/core/http'
 
 /**
  * Type definition for HTTP API wirings with type-safe path parameters.
@@ -85,5 +85,66 @@ export const addHTTPPermission = <In = unknown>(
 ) => {
   addHTTPPermissionCore(pattern, permissions as any)
 }
+
+/**
+ * Route configuration for wireHTTPRoutes with proper typing
+ */
+type HTTPRouteConfig = HTTPRouteBaseConfig & {
+  method: HTTPMethod
+  route: string
+  func: PikkuFunctionConfig<any, any, any, any, any, any>
+  auth?: boolean
+  permissions?: Record<string, PikkuPermission | PikkuPermission[]>
+  middleware?: PikkuMiddleware[]
+  sse?: boolean
+}
+
+/**
+ * Typed route map for wireHTTPRoutes
+ */
+type TypedHTTPRouteMap = {
+  [key: string]: HTTPRouteConfig | TypedHTTPRouteMap | TypedHTTPRouteContract
+}
+
+/**
+ * Typed route contract for defineHTTPRoutes
+ */
+type TypedHTTPRouteContract<T extends TypedHTTPRouteMap = TypedHTTPRouteMap> = TypedHTTPRoutesGroupConfig & {
+  routes: T
+}
+
+/**
+ * Group config with typed middleware/permissions
+ */
+type TypedHTTPRoutesGroupConfig = {
+  basePath?: string
+  tags?: string[]
+  auth?: boolean
+  middleware?: PikkuMiddleware[]
+  permissions?: Record<string, PikkuPermission | PikkuPermission[]>
+}
+
+/**
+ * Full config for wireHTTPRoutes
+ */
+type TypedWireHTTPRoutesConfig = TypedHTTPRoutesGroupConfig & {
+  routes: TypedHTTPRouteMap | HTTPRouteConfig[]
+}
+
+/**
+ * Type-safe helper for defining route contracts that can be composed.
+ */
+export function defineHTTPRoutes<T extends TypedHTTPRouteMap>(routes: T): TypedHTTPRouteContract<T>
+export function defineHTTPRoutes<T extends TypedHTTPRouteMap>(config: TypedHTTPRoutesGroupConfig & { routes: T }): TypedHTTPRouteContract<T>
+export function defineHTTPRoutes<T extends TypedHTTPRouteMap>(configOrRoutes: T | (TypedHTTPRoutesGroupConfig & { routes: T })): TypedHTTPRouteContract<T> {
+  return defineHTTPRoutesCore(configOrRoutes as any) as unknown as TypedHTTPRouteContract<T>
+}
+
+/**
+ * Wires multiple HTTP routes from a nested map or array configuration.
+ */
+export const wireHTTPRoutes = (config: TypedWireHTTPRoutesConfig): void => {
+  wireHTTPRoutesCore(config as any)
+}
 `;
 };

package/dist/src/functions/wirings/http/serialize-typed-http-map.d.ts

@@ -1,4 +1,7 @@
 import { HTTPWiringsMeta } from '@pikku/core/http';
 import { MetaInputTypes, TypesMap } from '@pikku/inspector';
-import { FunctionsMeta } from '@pikku/core';
-export declare const serializeTypedHTTPWiringsMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, wiringsMeta: HTTPWiringsMeta, metaTypes: MetaInputTypes) => string;
+import { Logger } from '@pikku/core/services';
+export declare const serializeTypedHTTPWiringsMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, wiringsMeta: HTTPWiringsMeta, metaTypes: MetaInputTypes, resolvedIOTypes: Record<string, {
+    inputType: string;
+    outputType: string;
+}>, rpcInternalMapDeclarationFile: string) => string;

package/dist/src/functions/wirings/http/serialize-typed-http-map.js

@@ -1,17 +1,34 @@
 import { serializeImportMap } from '../../../utils/serialize-import-map.js';
-import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
-export const serializeTypedHTTPWiringsMap = (relativeToPath, packageMappings, typesMap, functionsMeta, wiringsMeta, metaTypes) => {
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { generateCustomTypes } from '@pikku/inspector';
+export const serializeTypedHTTPWiringsMap = (logger, relativeToPath, packageMappings, typesMap, wiringsMeta, metaTypes, resolvedIOTypes, rpcInternalMapDeclarationFile) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap);
-    const serializedHTTPWirings = generateHTTPWirings(wiringsMeta, functionsMeta, typesMap, requiredTypes);
-    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap, requiredTypes);
+    const serializedHTTPWirings = generateHTTPWirings(wiringsMeta, resolvedIOTypes, requiredTypes);
+    const needsFlattenedRPCMap = Array.from(requiredTypes).some((t) => t.includes('FlattenedRPCMap'));
+    if (needsFlattenedRPCMap) {
+        for (const t of Array.from(requiredTypes)) {
+            if (t.includes('FlattenedRPCMap')) {
+                requiredTypes.delete(t);
+            }
+        }
+    }
+    const serializedImportMap = serializeImportMap(logger, relativeToPath, packageMappings, typesMap, requiredTypes);
+    const rpcMapImport = needsFlattenedRPCMap
+        ? `import type { FlattenedRPCMap } from '${getFileImportRelativePath(relativeToPath, rpcInternalMapDeclarationFile, packageMappings)}'`
+        : '';
+    const serializedCustomTypesDeclarationsOnly = serializedCustomTypes
+        .split('\n')
+        .filter((line) => !line.startsWith('import '))
+        .join('\n');
     return `/**
  * This provides the structure needed for typescript to be aware of routes and their return types
  */
-    
+
 ${serializedImportMap}
-${serializedCustomTypes}
+${rpcMapImport}
+${serializedCustomTypesDeclarationsOnly}
 ${serializedMetaTypes}
 
 interface HTTPWiringHandler<I, O> {
@@ -31,34 +48,21 @@ export type HTTPWiringsWithMethod<Method extends string> = {
 }[keyof HTTPWiringsMap];
   `;
 };
-function generateHTTPWirings(routesMeta, functionsMeta, typesMap, requiredTypes) {
-    // Initialize an object to collect routes
+function generateHTTPWirings(routesMeta, resolvedIOTypes, requiredTypes) {
     const routesObj = {};
     for (const methods of Object.values(routesMeta)) {
         for (const meta of Object.values(methods)) {
-            const { route, method, pikkuFuncName } = meta;
-            const functionMeta = functionsMeta[pikkuFuncName];
-            if (!functionMeta) {
-                throw new Error(`Function ${pikkuFuncName} not found in functionsMeta. Please check your configuration.`);
-            }
-            const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
-            const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
-            // Initialize the route entry if it doesn't exist
+            const { route, method, pikkuFuncId } = meta;
             if (!routesObj[route]) {
                 routesObj[route] = {};
             }
-            // Store the input and output types separately for RouteHandler
-            const inputType = input ? typesMap.getTypeMeta(input).uniqueName : 'null';
-            const outputType = output
-                ? typesMap.getTypeMeta(output).uniqueName
-                : 'null';
-            requiredTypes.add(inputType);
-            requiredTypes.add(outputType);
-            // Add method entry
-            routesObj[route][method] = {
-                inputType,
-                outputType,
-            };
+            const resolved = resolvedIOTypes[pikkuFuncId];
+            if (!resolved) {
+                throw new Error(`Function ${pikkuFuncId} not found in resolvedIOTypes. Please check your configuration.`);
+            }
+            requiredTypes.add(resolved.inputType);
+            requiredTypes.add(resolved.outputType);
+            routesObj[route][method] = resolved;
         }
     }
     // Build the routes object as a string
@@ -73,9 +77,17 @@ function generateHTTPWirings(routesMeta, functionsMeta, typesMap, requiredTypes)
     routesStr += '};';
     return routesStr;
 }
-const generateMetaTypes = (metaTypes, typesMap) => {
+const generateMetaTypes = (metaTypes, typesMap, requiredTypes) => {
     const nameToTypeMap = Array.from(metaTypes.entries()).reduce((result, [_name, { query, body, params }]) => {
-        const { uniqueName } = typesMap.getTypeMeta(_name);
+        let uniqueName;
+        try {
+            uniqueName = typesMap.getTypeMeta(_name).uniqueName;
+        }
+        catch {
+            // Zod-derived schema - use the name directly
+            uniqueName = _name;
+        }
+        requiredTypes.add(uniqueName);
         const queryType = query && query.length > 0
             ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`
             : undefined;

package/dist/src/functions/wirings/mcp/pikku-command-mcp-json.d.ts

@@ -1 +1 @@
-export declare const pikkuMCPJSON: any;
+export declare const pikkuMCPJSON: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/mcp/pikku-command-mcp-json.js

@@ -1,14 +1,13 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-import { serializeMCPJson } from './serialize-mcp-json.js';
+import { serializeMCPJson } from '@pikku/inspector';
 export const pikkuMCPJSON = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { mcpEndpoints, functions } = await getInspectorState();
-        const { mcpJsonFile, schemaDirectory } = config;
-        // Generate MCP JSON file
+        const state = await getInspectorState();
+        const { mcpJsonFile } = config;
         if (mcpJsonFile) {
-            const mcpJson = await serializeMCPJson(logger, schemaDirectory, functions.meta, functions.typesMap, mcpEndpoints.resourcesMeta, mcpEndpoints.toolsMeta, mcpEndpoints.promptsMeta);
+            const mcpJson = serializeMCPJson(logger, state);
             await writeFileInDir(logger, mcpJsonFile, mcpJson, {
                 ignoreModifyComment: true,
             });

package/dist/src/functions/wirings/mcp/pikku-command-mcp-types.d.ts

@@ -1 +1 @@
-export declare const pikkuMCPTypes: any;
+export declare const pikkuMCPTypes: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/mcp/pikku-command-mcp-types.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

package/dist/src/functions/wirings/mcp/pikku-command-mcp.d.ts

@@ -1 +1 @@
-export declare const pikkuMCP: any;
+export declare const pikkuMCP: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/mcp/pikku-command-mcp.js

@@ -1,22 +1,32 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { readFile } from 'fs/promises';
 import { join } from 'path';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 // Helper function to generate arguments from schema
 const generateArgumentsFromSchema = async (inputSchema, schemaDirectory, typesMap, logger) => {
     if (!inputSchema)
         return [];
-    if (['boolean', 'string', 'number', 'null', 'undefined', 'void'].includes(inputSchema)) {
+    if ([
+        'boolean',
+        'string',
+        'number',
+        'null',
+        'undefined',
+        'void',
+        'unknown',
+        'never',
+    ].includes(inputSchema)) {
         return [];
     }
     const uniqueName = typesMap.getUniqueName(inputSchema);
     if (!uniqueName)
         return [];
+    const schemaPath = join(schemaDirectory, 'schemas', `${uniqueName}.schema.json`);
     try {
-        const schemaPath = join(schemaDirectory, 'schemas', `${uniqueName}.schema.json`);
         const schemaContent = await readFile(schemaPath, 'utf-8');
         const schema = JSON.parse(schemaContent);
         const argumentsArray = [];
@@ -34,7 +44,8 @@ const generateArgumentsFromSchema = async (inputSchema, schemaDirectory, typesMa
         return argumentsArray;
     }
     catch (e) {
-        logger.warn(`Could not load schema for type: ${uniqueName}`);
+        logger.warn(`Command MCP: Could not load schema for type: ${uniqueName} from ${schemaPath}`);
+        console.error(e);
         return [];
     }
 };
@@ -42,11 +53,11 @@ export const pikkuMCP = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { mcpEndpoints, functions } = await getInspectorState();
         const { mcpWiringsFile, mcpWiringsMetaFile, packageMappings, schemaDirectory, schema, } = config;
-        await writeFileInDir(logger, mcpWiringsFile, serializeFileImports('wireMCPResource or wireMCPTool', mcpWiringsFile, mcpEndpoints.files, packageMappings));
+        await writeFileInDir(logger, mcpWiringsFile, serializeFileImports('wireMCPResource', mcpWiringsFile, mcpEndpoints.files, packageMappings));
         // Populate arguments for prompts meta before serializing
         const promptsMetaWithArguments = { ...mcpEndpoints.promptsMeta };
         for (const promptMeta of Object.values(promptsMetaWithArguments)) {
-            const functionMeta = functions.meta[promptMeta.pikkuFuncName];
+            const functionMeta = functions.meta[promptMeta.pikkuFuncId];
             if (functionMeta) {
                 const inputType = functionMeta.inputs?.[0];
                 promptMeta.arguments = await generateArgumentsFromSchema(inputType || null, schemaDirectory || '', functions.typesMap, logger);
@@ -57,7 +68,14 @@ export const pikkuMCP = pikkuSessionlessFunc({
             toolsMeta: mcpEndpoints.toolsMeta,
             promptsMeta: promptsMetaWithArguments,
         };
-        await writeFileInDir(logger, config.mcpWiringsMetaJsonFile, JSON.stringify(metaData, null, 2));
+        // Write minimal JSON (runtime-only fields)
+        const minimalMeta = stripVerboseFields(metaData);
+        await writeFileInDir(logger, config.mcpWiringsMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
+        // Write verbose JSON only if it has additional fields
+        if (hasVerboseFields(metaData)) {
+            const verbosePath = config.mcpWiringsMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+            await writeFileInDir(logger, verbosePath, JSON.stringify(metaData, null, 2));
+        }
         const jsonImportPath = getFileImportRelativePath(mcpWiringsMetaFile, config.mcpWiringsMetaJsonFile, packageMappings);
         const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
         const importStatement = supportsImportAttributes
@@ -66,9 +84,9 @@ export const pikkuMCP = pikkuSessionlessFunc({
         await writeFileInDir(logger, mcpWiringsMetaFile, `import { pikkuState } from '@pikku/core'
 import type { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp'
 ${importStatement}
-pikkuState('mcp', 'resourcesMeta', metaData.resourcesMeta as MCPResourceMeta)
-pikkuState('mcp', 'toolsMeta', metaData.toolsMeta as MCPToolMeta)
-pikkuState('mcp', 'promptsMeta', metaData.promptsMeta as MCPPromptMeta)`);
+pikkuState(null, 'mcp', 'resourcesMeta', metaData.resourcesMeta as MCPResourceMeta)
+pikkuState(null, 'mcp', 'toolsMeta', metaData.toolsMeta as MCPToolMeta)
+pikkuState(null, 'mcp', 'promptsMeta', metaData.promptsMeta as MCPPromptMeta)`);
         return true;
     },
     middleware: [

package/dist/src/functions/wirings/mcp/serialize-mcp-types.js

@@ -8,10 +8,8 @@ export const serializeMCPTypes = (functionTypesImportPath) => {
 
 import {
   CoreMCPResource,
-  CoreMCPTool,
   CoreMCPPrompt,
   wireMCPResource as wireMCPResourceCore,
-  wireMCPTool as wireMCPToolCore,
   wireMCPPrompt as wireMCPPromptCore,
   MCPResourceResponse,
   MCPToolResponse,
@@ -19,7 +17,9 @@ import {
   AssertMCPResourceURIParams
 } from '@pikku/core/mcp'
 
-import type { PikkuFunctionConfig, PikkuFunctionSessionless } from '${functionTypesImportPath}'
+import type { PikkuFunctionConfig, PikkuFunctionSessionless, PikkuMiddleware, PikkuPermission, InferSchemaOutput } from '${functionTypesImportPath}'
+import type { CorePermissionGroup } from '@pikku/core'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 
 /**
  * Type definition for MCP resources that provide data to AI models.
@@ -29,13 +29,6 @@ import type { PikkuFunctionConfig, PikkuFunctionSessionless } from '${functionTy
  */
 type MCPResourceWiring<In, URI extends string> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse, 'rpc' | 'session' | 'mcp'>> & { uri: URI }
 
-/**
- * Type definition for MCP tools that AI models can invoke.
- *
- * @template In - Input type for the tool invocation
- */
-type MCPToolWiring<In> = CoreMCPTool<PikkuFunctionConfig<In, MCPToolResponse, 'rpc' | 'session' | 'mcp'>>
-
 /**
  * Type definition for MCP prompts that provide templates to AI models.
  *
@@ -57,19 +50,6 @@ export const wireMCPResource = <In, URI extends string>(
   wireMCPResourceCore(mcpResource as any)
 }
 
-/**
- * Registers an MCP tool with the Pikku framework.
- * Tools are functions that AI models can invoke.
- *
- * @template In - Input type for the tool invocation
- * @param mcpTool - MCP tool definition with action function
- */
-export const wireMCPTool = <In>(
-  mcpTool: MCPToolWiring<In>
-) => {
-  wireMCPToolCore(mcpTool as any)
-}
-
 /**
  * Registers an MCP prompt with the Pikku framework.
  * Prompts provide templates that AI models can use.
@@ -83,60 +63,123 @@ export const wireMCPPrompt = <In>(
   wireMCPPromptCore(mcpPrompt as any)
 }
 
+/**
+ * Configuration for MCP prompt with Zod schema input validation.
+ */
+type MCPPromptFuncConfigWithSchema<InputSchema extends StandardSchemaV1> = {
+  func: PikkuFunctionSessionless<InferSchemaOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
+  name?: string
+  input: InputSchema
+}
+
 /**
  * Creates a function for handling MCP prompt requests.
  * These functions generate prompt templates for AI models.
  *
- * @template In - Input type for the prompt parameters
+ * Supports two patterns:
+ * 1. Generic types: \`pikkuMCPPromptFunc<Input>({ func: ... })\`
+ * 2. Zod schemas: \`pikkuMCPPromptFunc({ input: z.object(...), func: ... })\`
+ *
+ * @template In - Input type for the prompt parameters (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The unwrapped function for internal use
  */
-export const pikkuMCPPromptFunc = <In>(
+export function pikkuMCPPromptFunc<InputSchema extends StandardSchemaV1>(
+  config: MCPPromptFuncConfigWithSchema<InputSchema>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, MCPPromptResponse, 'mcp' | 'rpc'>
+export function pikkuMCPPromptFunc<In>(
   func:
-    | PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp'>
+    | PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp' | 'rpc'>
     | {
-        func: PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp'>
+        func: PikkuFunctionSessionless<In, MCPPromptResponse, 'mcp' | 'rpc'>
         name?: string
       }
-): PikkuFunctionConfig<In, MCPPromptResponse, 'mcp'> => {
+): PikkuFunctionConfig<In, MCPPromptResponse, 'mcp' | 'rpc'>
+export function pikkuMCPPromptFunc(func: any): any {
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Configuration for MCP tool with Zod schema input validation.
+ */
+type MCPToolFuncConfigWithSchema<InputSchema extends StandardSchemaV1> = {
+  func: PikkuFunctionSessionless<InferSchemaOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
+  description?: string
+  tags?: string[]
+  title?: string
+  summary?: string
+  name?: string
+  middleware?: PikkuMiddleware[]
+  permissions?: CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>>
+  input: InputSchema
+}
+
 /**
  * Creates a function for handling MCP tool invocations.
  * These functions perform actions that AI models can request.
  *
- * @template In - Input type for the tool invocation
+ * Supports two patterns:
+ * 1. Generic types: \`pikkuMCPToolFunc<Input>({ func: ... })\`
+ * 2. Zod schemas: \`pikkuMCPToolFunc({ input: z.object(...), func: ... })\`
+ *
+ * @template In - Input type for the tool invocation (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The unwrapped function for internal use
  */
-export const pikkuMCPToolFunc = <In>(
+export function pikkuMCPToolFunc<InputSchema extends StandardSchemaV1>(
+  config: MCPToolFuncConfigWithSchema<InputSchema>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
+export function pikkuMCPToolFunc<In>(
   func:
-    | PikkuFunctionSessionless<In, MCPToolResponse, 'mcp'>
+    | PikkuFunctionSessionless<In, MCPToolResponse, 'mcp' | 'rpc'>
     | {
-      func: PikkuFunctionSessionless<In, MCPToolResponse, 'mcp'>
+      func: PikkuFunctionSessionless<In, MCPToolResponse, 'mcp' | 'rpc'>
+      description?: string
+      tags?: string[]
+      title?: string
+      summary?: string
       name?: string
+      middleware?: PikkuMiddleware[]
+      permissions?: CorePermissionGroup<PikkuPermission<In>>
     }
-): PikkuFunctionConfig<In, MCPToolResponse, 'mcp'> => {
+): PikkuFunctionConfig<In, MCPToolResponse, 'mcp' | 'rpc'>
+export function pikkuMCPToolFunc(func: any): any {
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Configuration for MCP resource with Zod schema input validation.
+ */
+type MCPResourceFuncConfigWithSchema<InputSchema extends StandardSchemaV1> = {
+  func: PikkuFunctionSessionless<InferSchemaOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
+  name?: string
+  input: InputSchema
+}
+
 /**
  * Creates a function for handling MCP resource requests.
  * These functions provide data that AI models can access.
  *
- * @template In - Input type for the resource request
+ * Supports two patterns:
+ * 1. Generic types: \`pikkuMCPResourceFunc<Input>({ func: ... })\`
+ * 2. Zod schemas: \`pikkuMCPResourceFunc({ input: z.object(...), func: ... })\`
+ *
+ * @template In - Input type for the resource request (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The unwrapped function for internal use
  */
-export const pikkuMCPResourceFunc = <In>(
+export function pikkuMCPResourceFunc<InputSchema extends StandardSchemaV1>(
+  config: MCPResourceFuncConfigWithSchema<InputSchema>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, MCPResourceResponse, 'mcp' | 'rpc'>
+export function pikkuMCPResourceFunc<In>(
   func:
-    | PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp'>
+    | PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp' | 'rpc'>
     | {
-      func: PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp'>
+      func: PikkuFunctionSessionless<In, MCPResourceResponse, 'mcp' | 'rpc'>
       name?: string
     }
-): PikkuFunctionConfig<In, MCPResourceResponse, 'mcp'> => {
+): PikkuFunctionConfig<In, MCPResourceResponse, 'mcp' | 'rpc'>
+export function pikkuMCPResourceFunc(func: any): any {
   return typeof func === 'function' ? { func } : func
 }
 `;

package/dist/src/functions/wirings/middleware/pikku-command-middleware.d.ts

@@ -1 +1 @@
-export declare const pikkuMiddleware: any;
+export declare const pikkuMiddleware: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/middleware/pikku-command-middleware.js

@@ -1,45 +1,25 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeMiddlewareImports } from './serialize-middleware-imports.js';
-import { serializeMiddlewareGroupsMeta } from './serialize-middleware-groups-meta.js';
-import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const pikkuMiddleware = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const state = await getInspectorState();
         const { middleware } = state;
-        const { middlewareFile, packageMappings, schema } = config;
+        const { middlewareFile, packageMappings } = config;
         let filesGenerated = false;
-        // Check if there are any middleware groups
         const hasHTTPGroups = state.http.routeMiddleware.size > 0;
         const hasTagGroups = state.middleware.tagMiddleware.size > 0;
-        if (hasHTTPGroups || hasTagGroups) {
-            const metaData = serializeMiddlewareGroupsMeta(state);
-            // Write JSON file
+        const hasDefinitions = Object.keys(state.middleware.definitions).length > 0;
+        const hasChannelMiddleware = state.channelMiddleware.tagMiddleware.size > 0 ||
+            Object.keys(state.channelMiddleware.definitions).length > 0;
+        if (hasHTTPGroups ||
+            hasTagGroups ||
+            hasDefinitions ||
+            hasChannelMiddleware) {
+            const metaData = state.middlewareGroupsMeta;
             await writeFileInDir(logger, config.middlewareGroupsMetaJsonFile, JSON.stringify(metaData, null, 2));
-            // Calculate relative path from TS file to JSON file
-            const jsonImportPath = getFileImportRelativePath(config.middlewareGroupsMetaFile, config.middlewareGroupsMetaJsonFile, packageMappings);
-            // Write TypeScript file that imports JSON
-            const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
-            const importStatement = supportsImportAttributes
-                ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-                : `import metaData from '${jsonImportPath}'`;
-            const tsContent = `import { pikkuState } from '@pikku/core'
-${importStatement}
-
-// HTTP middleware groups metadata
-if (metaData.httpGroups && Object.keys(metaData.httpGroups).length > 0) {
-  pikkuState('middleware', 'httpGroupMeta', metaData.httpGroups)
-}
-
-// Tag middleware groups metadata
-if (metaData.tagGroups && Object.keys(metaData.tagGroups).length > 0) {
-  pikkuState('middleware', 'tagGroupMeta', metaData.tagGroups)
-}
-`;
-            await writeFileInDir(logger, config.middlewareGroupsMetaFile, tsContent);
-            // Always generate middleware imports file when groups exist (even if empty)
-            await writeFileInDir(logger, middlewareFile, serializeMiddlewareImports(middlewareFile, middleware, state.http, packageMappings));
+            await writeFileInDir(logger, middlewareFile, serializeMiddlewareImports(middlewareFile, middleware, state.http, packageMappings, state));
             filesGenerated = true;
         }
         return filesGenerated;

package/dist/src/functions/wirings/middleware/serialize-middleware-imports.js

@@ -1,43 +1,38 @@
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-export const serializeMiddlewareImports = (outputPath, middlewareState, httpState, packageMappings = {}, fullState) => {
-    const serializedImports = [];
-    const serializedFactoryCalls = [];
-    // Collect factory imports and calls for HTTP middleware groups
-    const httpFactories = new Map();
-    for (const [, groupMeta] of httpState.routeMiddleware.entries()) {
-        if (groupMeta.exportName && groupMeta.isFactory) {
-            const filePath = getFileImportRelativePath(outputPath, groupMeta.sourceFile, packageMappings);
-            httpFactories.set(groupMeta.exportName, {
-                exportName: groupMeta.exportName,
-                filePath,
-            });
-        }
-    }
-    // Collect factory imports and calls for tag middleware groups
-    const tagFactories = new Map();
-    for (const [, groupMeta] of middlewareState.tagMiddleware.entries()) {
+const collectFactories = (groupMap, outputPath, packageMappings) => {
+    const factories = new Map();
+    for (const [, groupMeta] of groupMap.entries()) {
         if (groupMeta.exportName && groupMeta.isFactory) {
             const filePath = getFileImportRelativePath(outputPath, groupMeta.sourceFile, packageMappings);
-            tagFactories.set(groupMeta.exportName, {
+            factories.set(groupMeta.exportName, {
                 exportName: groupMeta.exportName,
                 filePath,
             });
         }
     }
-    // Combine all factories and deduplicate by exportName (same factory might be used in multiple groups)
-    const allFactories = new Map([...httpFactories, ...tagFactories]);
-    // Add factory imports and calls
+    return factories;
+};
+export const serializeMiddlewareImports = (outputPath, middlewareState, httpState, packageMappings = {}, fullState) => {
+    const serializedImports = [];
+    const serializedFactoryCalls = [];
+    const httpFactories = collectFactories(httpState.routeMiddleware, outputPath, packageMappings);
+    const tagFactories = collectFactories(middlewareState.tagMiddleware, outputPath, packageMappings);
+    const channelMiddlewareFactories = fullState
+        ? collectFactories(fullState.channelMiddleware.tagMiddleware, outputPath, packageMappings)
+        : new Map();
+    const allFactories = new Map([
+        ...httpFactories,
+        ...tagFactories,
+        ...channelMiddlewareFactories,
+    ]);
     if (allFactories.size > 0) {
         serializedImports.push('/* Call middleware group factories to register at module evaluation */');
-        // Import factories
         for (const [exportName, { filePath }] of allFactories) {
             serializedImports.push(`import { ${exportName} } from '${filePath}'`);
         }
-        // Call factories
         for (const [exportName] of allFactories) {
             serializedFactoryCalls.push(`${exportName}()`);
         }
     }
-    // Return combined output
     return [...serializedImports, ...serializedFactoryCalls].join('\n');
 };