@pikku/cli 0.9.16-next.0 → 0.10.0

package/src/functions/wirings/functions/pikku-command-functions.ts

@@ -54,8 +54,6 @@ export const pikkuFunctions: any = pikkuSessionlessFunc<
     logCommandInfoAndTime({
       commandStart: 'Serializing Pikku functions',
       commandEnd: 'Serialized Pikku functions',
-      skipCondition: false,
-      skipMessage: '',
     }),
   ],
 })

package/src/functions/wirings/functions/pikku-command-services.ts

@@ -5,30 +5,24 @@ import { writeFileInDir } from '../../../utils/file-writer.js'
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
 
 export const serializeServicesMap = (
-  functionsMetaData: Record<string, any>,
-  middlewareServices: string[] = [],
+  requiredServices: Set<string>,
+  forceRequiredServices: string[] = [],
   servicesImport: string,
   sessionServicesImport: string
 ): string => {
-  // Extract all unique services from all functions
-  const usedServices = new Set<string>()
+  // Use pre-aggregated services from inspector state
+  // This includes services from:
+  // - Wired functions (HTTP, channels, queues, schedulers, MCP, CLI, RPC)
+  // - Middleware used by wired functions
+  // - Permissions used by wired functions
+  // - Session factories
+  const usedServices = new Set(requiredServices)
 
   // Internal services that are created internally and not via the create service script
   const internalServices = new Set(['rpc', 'mcp', 'channel', 'userSession'])
 
-  for (const funcMeta of Object.values(functionsMetaData)) {
-    if (funcMeta.services && Array.isArray(funcMeta.services.services)) {
-      funcMeta.services.services.forEach((service: string) => {
-        // Only include services that are not internal
-        if (!internalServices.has(service)) {
-          usedServices.add(service)
-        }
-      })
-    }
-  }
-
-  // Add middleware services that might not be detected from function inspection
-  middlewareServices.forEach((service) => {
+  // Add force-required services that might not be detected from function inspection
+  forceRequiredServices.forEach((service) => {
     if (!internalServices.has(service)) {
       usedServices.add(service)
     }
@@ -57,10 +51,6 @@ export const serializeServicesMap = (
   // We don't need to hardcode which services are singletons beyond the core framework ones
 
   const code = [
-    '/**',
-    ' * This file was generated by the @pikku/cli',
-    ' */',
-    '',
     servicesImport,
     sessionServicesImport,
     "import type { PikkuInteraction } from '@pikku/core'",
@@ -105,8 +95,8 @@ export const pikkuServices: any = pikkuSessionlessFunc<void, void>({
     const sessionServicesImport = `import type { ${sessionServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, sessionServicesType.typePath, config.packageMappings)}'`
 
     const servicesCode = serializeServicesMap(
-      visitState.functions.meta,
-      config.middlewareServices,
+      visitState.serviceAggregation.requiredServices,
+      config.forceRequiredServices,
       servicesImport,
       sessionServicesImport
     )
@@ -116,7 +106,6 @@ export const pikkuServices: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Generating Pikku services map',
       commandEnd: 'Generated Pikku services map',
-      skipMessage: '',
     }),
   ],
 })

package/src/functions/wirings/functions/pikku-function-types.ts

@@ -38,8 +38,6 @@ export const pikkuFunctionTypes: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Creating api types hub',
       commandEnd: 'Created api types hub',
-      skipCondition: false,
-      skipMessage: '',
     }),
   ],
 })

package/src/functions/wirings/functions/schemas.ts

@@ -40,8 +40,6 @@ export const pikkuSchemas: any = pikkuSessionlessFunc<
     logCommandInfoAndTime({
       commandStart: 'Generating schemas',
       commandEnd: 'Generated schemas',
-      skipCondition: false,
-      skipMessage: '',
     }),
   ],
 })

package/src/functions/wirings/functions/serialize-function-types.ts

@@ -8,25 +8,30 @@ export const serializeFunctionTypes = (
   singletonServicesTypeName: string,
   sessionServicesTypeImport: string,
   sessionServicesTypeName: string,
-  rpcMapTypeImport: string
+  rpcMapTypeImport: string,
+  requiredServicesTypeImport: string,
+  configTypeImport: string
 ) => {
   return `/**
- * This file was generated by the @pikku/cli
  * Core function, middleware, and permission types for all wirings
  */
 
-import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore } from '@pikku/core'
+import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore } from '@pikku/core'
 import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
-import { PikkuChannel, PikkuMCP } from '@pikku/core'
+import { PikkuChannel } from '@pikku/core/channel'
+import { PikkuMCP } from '@pikku/core/mcp'
 
 ${userSessionTypeImport}
 ${singletonServicesTypeImport}
 ${sessionServicesTypeImport}
+${configTypeImport}
 ${rpcMapTypeImport}
+${requiredServicesTypeImport}
 
 ${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
 ${sessionServicesTypeName !== 'Services' ? `type Services = ${sessionServicesTypeName}` : ''}
 ${userSessionTypeName !== 'Session' ? `type Session = ${userSessionTypeName}` : ''}
+${configTypeImport.includes('Config type not found') ? 'type Config = any' : ''}
 
 /**
  * Type-safe API permission definition that integrates with your application's session type.
@@ -45,35 +50,84 @@ export type PikkuPermission<In = unknown, RequiredServices extends Services = Se
  */
 export type PikkuMiddleware<RequiredServices extends SingletonServices = SingletonServices> = CorePikkuMiddleware<RequiredServices, Session>
 
+/**
+ * Configuration object for creating a permission with metadata
+ */
+export type PikkuPermissionConfig<In = unknown, RequiredServices extends Services = Services> = {
+  /** The permission function */
+  func: PikkuPermission<In, RequiredServices>
+  /** Optional human-readable name for the permission */
+  name?: string
+  /** Optional description of what the permission checks */
+  description?: string
+}
+
 /**
  * Factory function for creating permissions with tree-shaking support.
- * This enables the bundler to detect which services your permission actually uses.
+ * Supports both direct function and configuration object syntax.
  *
  * @example
  * \`\`\`typescript
+ * // Direct function syntax
  * const permission = pikkuPermission(({ logger }, data, session) => {
- *   return session?.isAdmin || false
+ *   return session?.role === 'admin'
+ * })
+ *
+ * // Configuration object syntax with metadata
+ * const adminPermission = pikkuPermission({
+ *   name: 'Admin Permission',
+ *   description: 'Checks if user has admin role',
+ *   func: async ({ logger }, data, session) => {
+ *     return session?.role === 'admin'
+ *   }
  * })
  * \`\`\`
  */
-export const pikkuPermission = <In>(func: PikkuPermission<In>) => {
-  return func
+export const pikkuPermission = <In>(
+  permission: PikkuPermission<In> | PikkuPermissionConfig<In>
+): PikkuPermission<In> => {
+  return typeof permission === 'function' ? permission : permission.func
+}
+
+/**
+ * Configuration object for creating middleware with metadata
+ */
+export type PikkuMiddlewareConfig<RequiredServices extends SingletonServices = SingletonServices> = {
+  /** The middleware function */
+  func: PikkuMiddleware<RequiredServices>
+  /** Optional human-readable name for the middleware */
+  name?: string
+  /** Optional description of what the middleware does */
+  description?: string
 }
 
 /**
  * Factory function for creating middleware with tree-shaking support.
- * This enables the bundler to detect which services your middleware actually uses.
+ * Supports both direct function and configuration object syntax.
  *
  * @example
  * \`\`\`typescript
+ * // Direct function syntax
  * const middleware = pikkuMiddleware(({ logger }, interactions, next) => {
  *   logger.info('Middleware executed')
  *   await next()
  * })
+ *
+ * // Configuration object syntax with metadata
+ * const logMiddleware = pikkuMiddleware({
+ *   name: 'Request Logger',
+ *   description: 'Logs all incoming requests',
+ *   func: async ({ logger }, interactions, next) => {
+ *     logger.info('Request started')
+ *     await next()
+ *   }
+ * })
  * \`\`\`
  */
-export const pikkuMiddleware = (func: PikkuMiddleware) => {
-  return func
+export const pikkuMiddleware = <RequiredServices extends SingletonServices = SingletonServices>(
+  middleware: PikkuMiddleware<RequiredServices> | PikkuMiddlewareConfig<RequiredServices>
+): PikkuMiddleware<RequiredServices> => {
+  return typeof middleware === 'function' ? middleware : middleware.func
 }
 
 /**
@@ -99,6 +153,31 @@ export const pikkuMiddlewareFactory = <In = any>(
   return factory
 }
 
+/**
+ * Factory function for creating permission factories
+ * Use this when your permission needs configuration/input parameters
+ *
+ * @example
+ * \`\`\`typescript
+ * export const requireRole = pikkuPermissionFactory<{ role: string }>(({
+ *   role
+ * }) => {
+ *   return pikkuPermission(async ({ logger }, data, session) => {
+ *     if (!session || session.role !== role) {
+ *       logger.warn(\`Permission denied: required role '\${role}'\`)
+ *       return false
+ *     }
+ *     return true
+ *   })
+ * })
+ * \`\`\`
+ */
+export const pikkuPermissionFactory = <In = any>(
+  factory: (input: In) => PikkuPermission<any>
+): ((input: In) => PikkuPermission<any>) => {
+  return factory
+}
+
 /**
  * A sessionless API function that doesn't require user authentication.
  * Use this for public endpoints, health checks, or operations that don't need user context.
@@ -114,7 +193,7 @@ export type PikkuFunctionSessionless<
   Out = never,
   ChannelData = null,  // null means optional channel
   MCPData = null, // null means optional MCP
-  RequiredServices extends Services = Services &
+  RequiredServices extends Services = Omit<Services, 'rpc' | 'channel' | 'mcp'> &
     { rpc: TypedPikkuRPC } & (
     [ChannelData] extends [null]
       ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
@@ -140,7 +219,7 @@ export type PikkuFunction<
   Out = never,
   ChannelData = null,  // null means optional channel
   MCPData = null, // null means optional MCP
-  RequiredServices extends Services = Omit<Services, 'rpc'> &
+  RequiredServices extends Services = Omit<Services, 'rpc' | 'channel' | 'mcp'> &
     { rpc: TypedPikkuRPC } & (
     [ChannelData] extends [null]
       ? { channel?: PikkuChannel<unknown, Out> }  // Optional channel
@@ -157,12 +236,16 @@ export type PikkuFunction<
  *
  * @template In - The input type
  * @template Out - The output type
+ * @template ChannelData - Channel data type
+ * @template MCPData - MCP data type
  * @template PikkuFunc - The function type (can be narrowed to PikkuFunction or PikkuFunctionSessionless)
  */
 export type PikkuFunctionConfig<
   In = unknown,
   Out = unknown,
-  PikkuFunc extends PikkuFunction<In, Out> | PikkuFunctionSessionless<In, Out> = PikkuFunction<In, Out> | PikkuFunctionSessionless<In, Out>
+  ChannelData = unknown,
+  MCPData = unknown,
+  PikkuFunc extends PikkuFunction<In, Out, ChannelData, MCPData> | PikkuFunctionSessionless<In, Out, ChannelData, MCPData> = PikkuFunction<In, Out, ChannelData, MCPData> | PikkuFunctionSessionless<In, Out, ChannelData, MCPData>
 > = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware>
 
 /**
@@ -189,7 +272,7 @@ export type PikkuFunctionConfig<
 export const pikkuFunc = <In, Out = unknown>(
   func:
     | PikkuFunction<In, Out>
-    | CorePikkuFunctionConfig<PikkuFunction<In, Out>, PikkuPermission<In>>
+    | CorePikkuFunctionConfig<PikkuFunction<In, Out>, PikkuPermission<In>, PikkuMiddleware>
 ) => {
   return typeof func === 'function' ? { func } : func
 }
@@ -246,6 +329,73 @@ export const pikkuVoidFunc = (
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Creates a Pikku config factory.
+ * Use this to define your application's configuration factory.
+ *
+ * @param func - Config factory function that returns your application's config
+ * @returns The config factory function
+ *
+ * @example
+ * \`\`\`typescript
+ * export const createConfig = pikkuConfig(async () => {
+ *   return {
+ *     apiUrl: process.env.API_URL || 'http://localhost:3000',
+ *     dbUrl: process.env.DATABASE_URL
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuConfig = (
+  func: (variables?: any, ...args: any[]) => Promise<Config>
+) => func
+
+/**
+ * Creates a Pikku singleton services factory.
+ * Use this to define services that are created once and shared across all requests.
+ *
+ * @param func - Singleton services factory function
+ * @returns The singleton services factory function
+ *
+ * @example
+ * \`\`\`typescript
+ * export const createSingletonServices = pikkuServices(async (config, existingServices) => {
+ *   return {
+ *     config,
+ *     logger: new CustomLogger(),
+ *     db: await createDatabaseConnection(config.dbUrl)
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuServices = (
+  func: (config: Config, existingServices?: Partial<SingletonServices>) => Promise<RequiredSingletonServices>
+) => func
+
+/**
+ * Creates a Pikku session services factory.
+ * Use this to define services that are created per-request/session.
+ *
+ * @param func - Session services factory function
+ * @returns The session services factory function
+ *
+ * @example
+ * \`\`\`typescript
+ * export const createSessionServices = pikkuSessionServices(async (services, interaction, session) => {
+ *   return {
+ *     userCache: new UserCache(session?.userId)
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuSessionServices = (
+  func: (
+    services: SingletonServices,
+    interaction: any,
+    session: Session | undefined
+  ) => Promise<RequiredSessionServices>
+) => func
+
 /**
  * Adds global middleware for a specific tag.
  *
@@ -280,7 +430,7 @@ export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
  * any wiring (HTTP, Channel, Queue, Scheduler, MCP) that includes the matching tag.
  *
  * @param tag - The tag that the permissions should apply to.
- * @param permissions - The permissions array to apply for the specified tag.
+ * @param permissions - The permissions array or object to apply for the specified tag.
  *
  * @throws Error if permissions for the tag already exist.
  *
@@ -292,11 +442,11 @@ export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
  * // Add authentication permissions for auth endpoints
  * addPermission('auth', [authPermission])
  *
- * // Add read permissions for all API endpoints
- * addPermission('api', [readPermission])
+ * // Add read permissions for all API endpoints (as object)
+ * addPermission('api', { read: readPermission })
  * \`\`\`
  */
-export const addPermission = <In = unknown>(tag: string, permissions: PikkuPermission<In>[]) => {
+export const addPermission = <In = unknown>(tag: string, permissions: CorePermissionGroup<PikkuPermission<In>> | PikkuPermission<In>[]) => {
   addPermissionCore(tag, permissions as any)
 }
 `

package/src/functions/wirings/functions/serialize-pikku-types-hub.ts

@@ -11,7 +11,6 @@ export const serializePikkuTypesHub = (
   cliTypesImportPath: string
 ) => {
   return `/**
- * This file was generated by the @pikku/cli
  * Main type export hub - re-exports all wiring-specific types
  */
 

package/src/functions/wirings/http/openapi-spec-generator.ts

@@ -1,4 +1,5 @@
-import { FunctionsMeta, HTTPWiringsMeta, pikkuState } from '@pikku/core'
+import { FunctionsMeta, pikkuState } from '@pikku/core'
+import { HTTPWiringsMeta } from '@pikku/core/http'
 import _convertSchema from '@openapi-contrib/json-schema-to-openapi-schema'
 import { CLILogger } from '../../../services/cli-logger.service.js'
 const convertSchema =

package/src/functions/wirings/http/pikku-command-http-map.ts

@@ -22,11 +22,6 @@ export const pikkuHTTPMap: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Creating HTTP map',
       commandEnd: 'Created HTTP map',
-      skipCondition: async ({ getInspectorState }) => {
-        const { http } = await getInspectorState()
-        return http.files.size === 0
-      },
-      skipMessage: 'none found',
     }),
   ],
 })

package/src/functions/wirings/http/pikku-command-http-routes.ts

@@ -31,11 +31,6 @@ export const pikkuHTTP: any = pikkuSessionlessFunc<void, boolean | undefined>({
     logCommandInfoAndTime({
       commandStart: 'Finding HTTP routes',
       commandEnd: 'Found HTTP routes',
-      skipCondition: async ({ getInspectorState }) => {
-        const visitState = await getInspectorState()
-        return visitState.http.files.size === 0
-      },
-      skipMessage: 'none found',
     }),
   ],
 })

package/src/functions/wirings/http/pikku-command-http-types.ts

@@ -20,8 +20,6 @@ export const pikkuHTTPTypes: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Creating HTTP types',
       commandEnd: 'Created HTTP types',
-      skipCondition: false,
-      skipMessage: '',
     }),
   ],
 })

package/src/functions/wirings/http/pikku-command-openapi.ts

@@ -7,13 +7,20 @@ import { stringify } from 'yaml'
 
 export const pikkuOpenAPI: any = pikkuSessionlessFunc<void, void>({
   func: async ({ logger, config, getInspectorState }) => {
-    const { http, functions } = await getInspectorState()
     const { tsconfig, openAPI, schemasFromTypes } = config
 
+    // If openAPI outputFile is not defined, clean up any existing file and return
     if (!openAPI?.outputFile) {
-      throw new Error('openAPI is required')
+      logger.info({
+        message:
+          'Skipping creating OpenAPI spec since openAPI outfile is not defined.',
+        type: 'skip',
+      })
+      return
     }
 
+    const { http, functions } = await getInspectorState()
+
     const schemas = await generateSchemas(
       logger,
       tsconfig,
@@ -50,8 +57,6 @@ export const pikkuOpenAPI: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Creating OpenAPI spec',
       commandEnd: 'Created OpenAPI spec',
-      skipCondition: ({ config }) => config.openAPI?.outputFile === undefined,
-      skipMessage: 'openAPI outfile is not defined',
     }),
   ],
 })

package/src/functions/wirings/http/pikku-http-routes.ts

@@ -30,11 +30,6 @@ export const pikkuHTTP: any = pikkuSessionlessFunc<void, boolean>({
     logCommandInfoAndTime({
       commandStart: 'Finding HTTP routes',
       commandEnd: 'Found HTTP routes',
-      skipCondition: async ({ getInspectorState }) => {
-        const visitState = await getInspectorState()
-        return visitState.http.files.size === 0
-      },
-      skipMessage: 'none found',
     }),
   ],
 })

package/src/functions/wirings/http/serialize-http-types.ts

@@ -3,11 +3,10 @@
  */
 export const serializeHTTPTypes = (functionTypesImportPath: string) => {
   return `/**
- * This file was generated by the @pikku/cli
  * HTTP-specific type definitions for tree-shaking optimization
  */
 
-import { AssertHTTPWiringParams, wireHTTP as wireHTTPCore, addHTTPMiddleware as addHTTPMiddlewareCore } from '@pikku/core/http'
+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'
 
@@ -60,5 +59,31 @@ export const addHTTPMiddleware = (
 ) => {
   addHTTPMiddlewareCore(routeOrMiddleware as any, middleware as any)
 }
+
+/**
+ * Registers HTTP permissions either globally or for a specific route pattern.
+ *
+ * When a string route pattern is provided along with permissions, the permissions
+ * are applied only to that route. Permissions can be passed as an array or as a
+ * permission group object.
+ *
+ * @param pattern - Route pattern string (e.g., '*' for all routes, '/api/*' for specific routes)
+ * @param permissions - The permissions to apply for the specified route pattern
+ *
+ * @example
+ * \`\`\`typescript
+ * // Add global HTTP permissions
+ * addHTTPPermission('*', { global: globalPermission })
+ *
+ * // Add route-specific permissions
+ * addHTTPPermission('/api/admin/*', { admin: adminPermission })
+ * \`\`\`
+ */
+export const addHTTPPermission = <In = unknown>(
+  pattern: string,
+  permissions: Record<string, PikkuPermission<In>> | PikkuPermission<In>[]
+) => {
+  addHTTPPermissionCore(pattern, permissions as any)
+}
 `
 }

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

@@ -28,11 +28,6 @@ export const pikkuMCPJSON: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Generating MCP JSON',
       commandEnd: 'Generated MCP JSON',
-      skipCondition: async ({ getInspectorState, config }) => {
-        const { mcpEndpoints } = await getInspectorState()
-        return mcpEndpoints.files.size === 0 || !config.mcpJsonFile
-      },
-      skipMessage: 'none found or mcpJsonFile not set',
     }),
   ],
 })

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

@@ -20,8 +20,6 @@ export const pikkuMCPTypes: any = pikkuSessionlessFunc<void, void>({
     logCommandInfoAndTime({
       commandStart: 'Creating MCP types',
       commandEnd: 'Created MCP types',
-      skipCondition: false,
-      skipMessage: '',
     }),
   ],
 })

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

@@ -109,11 +109,6 @@ pikkuState('mcp', 'promptsMeta', ${JSON.stringify(promptsMetaWithArguments, null
     logCommandInfoAndTime({
       commandStart: 'Finding MCP endpoints',
       commandEnd: 'Found MCP endpoints',
-      skipCondition: async ({ getInspectorState }) => {
-        const { mcpEndpoints } = await getInspectorState()
-        return mcpEndpoints.files.size === 0
-      },
-      skipMessage: 'none found',
     }),
   ],
 })

package/src/functions/wirings/mcp/serialize-mcp-json.ts

@@ -1,6 +1,6 @@
 import { readFile } from 'fs/promises'
 import { join } from 'path'
-import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core'
+import { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp'
 import { FunctionsMeta, JSONValue } from '@pikku/core'
 import { TypesMap } from '@pikku/inspector'
 import { CLILogger } from '../../../services/cli-logger.service.js'

package/src/functions/wirings/mcp/serialize-mcp-types.ts

@@ -3,7 +3,6 @@
  */
 export const serializeMCPTypes = (functionTypesImportPath: string) => {
   return `/**
- * This file was generated by the @pikku/cli
  * MCP-specific type definitions for tree-shaking optimization
  */
 
@@ -16,8 +15,9 @@ import {
   wireMCPPrompt as wireMCPPromptCore,
   MCPResourceResponse,
   MCPToolResponse,
-  MCPPromptResponse
-} from '@pikku/core'
+  MCPPromptResponse,
+  AssertMCPResourceURIParams
+} from '@pikku/core/mcp'
 
 import type { PikkuFunctionConfig, PikkuFunctionSessionless } from '${functionTypesImportPath}'
 
@@ -25,8 +25,9 @@ import type { PikkuFunctionConfig, PikkuFunctionSessionless } from '${functionTy
  * Type definition for MCP resources that provide data to AI models.
  *
  * @template In - Input type for the resource request
+ * @template URI - URI template string type for compile-time parameter validation
  */
-type MCPResourceWiring<In> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse>>
+type MCPResourceWiring<In, URI extends string> = CoreMCPResource<PikkuFunctionConfig<In, MCPResourceResponse>> & { uri: URI }
 
 /**
  * Type definition for MCP tools that AI models can invoke.
@@ -47,10 +48,11 @@ type MCPPromptWiring<In> = CoreMCPPrompt<PikkuFunctionConfig<In, MCPPromptRespon
  * Resources provide data that AI models can access.
  *
  * @template In - Input type for the resource request
+ * @template URI - URI template string for compile-time parameter validation
  * @param mcpResource - MCP resource definition with data provider function
  */
-export const wireMCPResource = <In>(
-  mcpResource: MCPResourceWiring<In>
+export const wireMCPResource = <In, URI extends string>(
+  mcpResource: MCPResourceWiring<In, URI> & AssertMCPResourceURIParams<In, URI>
 ) => {
   wireMCPResourceCore(mcpResource as any)
 }
@@ -96,8 +98,8 @@ export const pikkuMCPPromptFunc = <In>(
         func: PikkuFunctionSessionless<In, MCPPromptResponse>
         name?: string
       }
-) => {
-  return typeof func === 'function' ? func : func.func
+): PikkuFunctionConfig<In, MCPPromptResponse> => {
+  return typeof func === 'function' ? { func } : func
 }
 
 /**
@@ -115,8 +117,8 @@ export const pikkuMCPToolFunc = <In>(
       func: PikkuFunctionSessionless<In, MCPToolResponse, null, true>
       name?: string
     }
-) => {
-  return typeof func === 'function' ? func : func.func
+): PikkuFunctionConfig<In, MCPToolResponse> => {
+  return typeof func === 'function' ? { func } : func
 }
 
 /**
@@ -134,8 +136,8 @@ export const pikkuMCPResourceFunc = <In>(
       func: PikkuFunctionSessionless<In, MCPResourceResponse, null, true>
       name?: string
     }
-) => {
-  return typeof func === 'function' ? func : func.func
+): PikkuFunctionConfig<In, MCPResourceResponse> => {
+  return typeof func === 'function' ? { func } : func
 }
 `
 }