@pikku/cli 0.11.2 → 0.11.3

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

@@ -10,13 +10,15 @@ export const serializeFunctionTypes = (
   wireServicesTypeName: string,
   rpcMapTypeImport: string,
   requiredServicesTypeImport: string,
-  configTypeImport: string
+  configTypeImport: string,
+  packageName?: string
 ) => {
+  const packageNameValue = packageName ? `'${packageName}'` : 'null'
   return `/**
  * Core function, middleware, and permission types for all wirings
  */
 
-import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired } from '@pikku/core'
+import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired, ZodLike, CreateWireServices } from '@pikku/core'
 import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
 
 ${userSessionTypeImport}
@@ -218,6 +220,11 @@ export type PikkuFunction<
     PickRequired<PikkuWire<In, Out, true, Session, TypedPikkuRPC, null, any>, RequiredWires>
   >
 
+/**
+ * Helper type to infer the output type from a Zod schema
+ */
+export type InferZodOutput<T> = T extends ZodLike<infer U> ? U : never
+
 /**
  * Configuration object for Pikku functions with optional middleware, permissions, tags, and documentation.
  * This type wraps CorePikkuFunctionConfig with the user's custom types.
@@ -230,64 +237,166 @@ export type PikkuFunctionConfig<
   In = unknown,
   Out = unknown,
   RequiredWires extends keyof PikkuWire = never,
-  PikkuFunc extends PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires> = PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires>
-> = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware>
+  PikkuFunc extends PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires> = PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires>,
+  InputSchema extends ZodLike | undefined = undefined,
+  OutputSchema extends ZodLike | undefined = undefined
+> = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware, InputSchema, OutputSchema>
+
+/**
+ * Configuration object for Pikku functions with Zod schema validation.
+ * Use this when you want to define input/output schemas using Zod.
+ * Types are automatically inferred from the schemas.
+ */
+export type PikkuFunctionConfigWithSchema<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined,
+  RequiredWires extends keyof PikkuWire = never
+> = {
+  name?: string
+  tags?: string[]
+  expose?: boolean
+  internal?: boolean
+  func: PikkuFunction<
+    InferZodOutput<InputSchema>,
+    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    RequiredWires
+  > | PikkuFunctionSessionless<
+    InferZodOutput<InputSchema>,
+    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    RequiredWires
+  >
+  auth?: boolean
+  permissions?: CorePermissionGroup<PikkuPermission<InferZodOutput<InputSchema>>>
+  middleware?: PikkuMiddleware[]
+  input: InputSchema
+  output?: OutputSchema
+}
 
 /**
  * Creates a Pikku function that can be either session-aware or sessionless.
  * This is the main function wrapper for creating API endpoints.
  *
- * @template In - Input type for the function
- * @template Out - Output type for the function
+ * Supports two patterns:
+ * 1. Generic types: \`pikkuFunc<Input, Output>({ func: ... })\`
+ * 2. Zod schemas: \`pikkuFunc({ input: z.object(...), output: z.object(...), func: ... })\`
+ *
+ * @template In - Input type for the function (inferred from schema if provided)
+ * @template Out - Output type for the function (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The normalized configuration object
  *
  * @example
- * \\\`\\\`\\\`typescript
- * const createUser = pikkuFunc<{name: string, email: string}, {id: number, message: string}>({
- *   func: async ({db, logger}, input, wire) => {
- *     const session = await wire.session.get()
- *     logger.info('Creating user', input.name)
+ * \`\`\`typescript
+ * // Pattern 1: Using generic types
+ * const createUser = pikkuFunc<{name: string, email: string}, {id: number}>({
+ *   func: async ({db}, input) => {
  *     const user = await db.users.create(input)
- *     return {id: user.id, message: \\\`User \\\${input.name} created successfully\\\`}
- *   },
- *   auth: true
+ *     return { id: user.id }
+ *   }
  * })
- * \\\`\\\`\\\`
+ *
+ * // Pattern 2: Using Zod schemas (types inferred automatically)
+ * const createUserInput = z.object({ name: z.string(), email: z.string() })
+ * const createUserOutput = z.object({ id: z.number() })
+ *
+ * const createUser = pikkuFunc({
+ *   input: createUserInput,
+ *   output: createUserOutput,
+ *   func: async ({db}, input) => {
+ *     // input is typed as { name: string, email: string }
+ *     const user = await db.users.create(input)
+ *     return { id: user.id } // must match output schema
+ *   }
+ * })
+ * \`\`\`
  */
-export const pikkuFunc = <In, Out = unknown>(
+export function pikkuFunc<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined
+>(
+  config: PikkuFunctionConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>
+): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'session' | 'rpc'>
+export function pikkuFunc<In, Out = unknown>(
   func:
     | PikkuFunction<In, Out, 'session' | 'rpc'>
     | PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
-) => {
+): PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
+export function pikkuFunc(func: any) {
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Configuration object for sessionless Pikku functions with Zod schema validation.
+ */
+export type PikkuFunctionSessionlessConfigWithSchema<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined,
+  RequiredWires extends keyof PikkuWire = never
+> = {
+  name?: string
+  description?: string
+  tags?: string[]
+  expose?: boolean
+  internal?: boolean
+  func: PikkuFunctionSessionless<
+    InferZodOutput<InputSchema>,
+    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    RequiredWires
+  >
+  auth?: boolean
+  permissions?: CorePermissionGroup<PikkuPermission<InferZodOutput<InputSchema>>>
+  middleware?: PikkuMiddleware[]
+  input: InputSchema
+  output?: OutputSchema
+}
+
 /**
  * Creates a sessionless Pikku function that doesn't require user authentication.
  * Use this for public endpoints, webhooks, or background tasks.
  *
- * @template In - Input type for the function
- * @template Out - Output type for the function
+ * Supports two patterns:
+ * 1. Generic types: \`pikkuSessionlessFunc<Input, Output>({ func: ... })\`
+ * 2. Zod schemas: \`pikkuSessionlessFunc({ input: z.object(...), func: ... })\`
+ *
+ * @template In - Input type for the function (inferred from schema if provided)
+ * @template Out - Output type for the function (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The normalized configuration object
  *
  * @example
- * \\\`\\\`\\\`typescript
- * const healthCheck = pikkuSessionlessFunc<void, {status: string, timestamp: string}>({
- *   func: async ({logger}, input) => {
- *     logger.info('Health check requested')
- *     return {status: 'healthy', timestamp: new Date().toISOString()}
- *   },
- *   name: 'healthCheck'
+ * \`\`\`typescript
+ * // Pattern 1: Using generic types
+ * const healthCheck = pikkuSessionlessFunc<void, {status: string}>({
+ *   func: async ({logger}) => {
+ *     return { status: 'healthy' }
+ *   }
+ * })
+ *
+ * // Pattern 2: Using Zod schemas
+ * const greetInput = z.object({ name: z.string() })
+ * const greetOutput = z.object({ message: z.string() })
+ *
+ * const greet = pikkuSessionlessFunc({
+ *   input: greetInput,
+ *   output: greetOutput,
+ *   func: async (_services, { name }) => {
+ *     return { message: \`Hello, \${name}!\` }
+ *   }
  * })
- * \\\`\\\`\\\`
+ * \`\`\`
  */
-export const pikkuSessionlessFunc = <In, Out = unknown>(
+export function pikkuSessionlessFunc<
+  InputSchema extends ZodLike,
+  OutputSchema extends ZodLike | undefined = undefined
+>(
+  config: PikkuFunctionSessionlessConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>
+): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'session' | 'rpc'>
+export function pikkuSessionlessFunc<In, Out = unknown>(
   func:
     | PikkuFunctionSessionless<In, Out, 'session' | 'rpc'>
     | PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
-) => {
+): PikkuFunctionConfig<In, Out, 'session' | 'rpc'>
+export function pikkuSessionlessFunc(func: any) {
   return typeof func === 'function' ? { func } : func
 }
 
@@ -299,13 +408,13 @@ export const pikkuSessionlessFunc = <In, Out = unknown>(
  * @returns The normalized configuration object
  *
  * @example
- * \\\`\\\`\\\`typescript
+ * \`\`\`typescript
  * const cleanupTempFiles = pikkuVoidFunc(async ({fileSystem, logger}) => {
  *     logger.info('Starting cleanup of temporary files')
  *     await fileSystem.deleteDirectory('/tmp/uploads')
  *     logger.info('Cleanup completed')
  * })
- * \\\`\\\`\\\`
+ * \`\`\`
  */
 export const pikkuVoidFunc = (
   func:
@@ -315,6 +424,45 @@ export const pikkuVoidFunc = (
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Creates a wrapper function for external package functions that are exposed via RPC.
+ * This allows you to wire external functions to any wiring type (HTTP, queue, etc.)
+ * without type compatibility issues.
+ *
+ * @template Name - The RPC method name (must be a key in FlattenedRPCMap)
+ * @param rpcName - The name of the RPC method to invoke
+ * @returns A Pikku function that proxies calls to the external RPC method
+ *
+ * @example
+ * \`\`\`typescript
+ * // Wire an external function via HTTP
+ * wireHTTP({
+ *   auth: false,
+ *   method: 'get',
+ *   route: '/external/hello',
+ *   func: external('ext:hello'),
+ *   tags: ['external'],
+ * })
+ * \`\`\`
+ */
+export const external = <Name extends keyof FlattenedRPCMap>(
+  rpcName: Name
+): PikkuFunctionConfig<
+  FlattenedRPCMap[Name]['input'],
+  FlattenedRPCMap[Name]['output'],
+  'session' | 'rpc'
+> => {
+  return {
+    func: (async (_services: any, data: any, { rpc }: any) => {
+      return rpc.invoke(rpcName, data)
+    }) as any
+  } as PikkuFunctionConfig<
+    FlattenedRPCMap[Name]['input'],
+    FlattenedRPCMap[Name]['output'],
+    'session' | 'rpc'
+  >
+}
+
 /**
  * Creates a Pikku config factory.
  * Use this to define your application's configuration factory.
@@ -380,7 +528,7 @@ export const pikkuWireServices = (
     services: SingletonServices,
     wire: any
   ) => Promise<RequiredWireServices>
-) => func
+): CreateWireServices => func as unknown as CreateWireServices
 
 /**
  * Adds global middleware for a specific tag.
@@ -406,7 +554,7 @@ export const pikkuWireServices = (
  * \`\`\`
  */
 export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
-  addMiddlewareCore(tag, middleware as any)
+  addMiddlewareCore(tag, middleware as any, ${packageNameValue})
 }
 
 /**
@@ -433,7 +581,7 @@ export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
  * \`\`\`
  */
 export const addPermission = <In = unknown>(tag: string, permissions: CorePermissionGroup<PikkuPermission<In>> | PikkuPermission<In>[]) => {
-  addPermissionCore(tag, permissions as any)
+  addPermissionCore(tag, permissions as any, ${packageNameValue})
 }
 `
 }

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

@@ -3,36 +3,37 @@
  */
 export const serializePikkuTypesHub = (
   functionTypesImportPath: string,
-  httpTypesImportPath: string,
-  channelTypesImportPath: string,
-  schedulerTypesImportPath: string,
-  queueTypesImportPath: string,
-  mcpTypesImportPath: string,
-  cliTypesImportPath: string
+  httpTypesImportPath: string | null,
+  channelTypesImportPath: string | null,
+  schedulerTypesImportPath: string | null,
+  queueTypesImportPath: string | null,
+  mcpTypesImportPath: string | null,
+  cliTypesImportPath: string | null,
+  forgeTypesImportPath: string | null
 ) => {
+  const exports = [
+    {
+      comment: 'Core function, middleware, and permission types',
+      path: functionTypesImportPath,
+    },
+    { comment: 'HTTP wiring types', path: httpTypesImportPath },
+    { comment: 'Channel wiring types', path: channelTypesImportPath },
+    { comment: 'Scheduler wiring types', path: schedulerTypesImportPath },
+    { comment: 'Queue wiring types', path: queueTypesImportPath },
+    { comment: 'MCP wiring types', path: mcpTypesImportPath },
+    { comment: 'CLI wiring types', path: cliTypesImportPath },
+    { comment: 'Forge wiring types', path: forgeTypesImportPath },
+  ]
+
+  const exportStatements = exports
+    .filter((e) => e.path)
+    .map((e) => `// ${e.comment}\nexport * from '${e.path}'`)
+    .join('\n\n')
+
   return `/**
  * Main type export hub - re-exports all wiring-specific types
  */
 
-// Core function, middleware, and permission types
-export * from '${functionTypesImportPath}'
-
-// HTTP wiring types
-export * from '${httpTypesImportPath}'
-
-// Channel wiring types
-export * from '${channelTypesImportPath}'
-
-// Scheduler wiring types
-export * from '${schedulerTypesImportPath}'
-
-// Queue wiring types
-export * from '${queueTypesImportPath}'
-
-// MCP wiring types
-export * from '${mcpTypesImportPath}'
-
-// CLI wiring types
-export * from '${cliTypesImportPath}'
+${exportStatements}
 `
 }

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

@@ -68,7 +68,7 @@ export interface OpenAPISpecInfo {
 }
 
 const getErrorResponseForConstructorName = (constructorName: string) => {
-  const errors = Array.from(pikkuState('misc', 'errors').entries())
+  const errors = Array.from(pikkuState(null, 'misc', 'errors').entries())
   const foundError = errors.find(([e]) => e.name === constructorName)
   if (foundError) {
     return foundError[1]

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

@@ -2,11 +2,22 @@ import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
 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 { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import {
+  stripVerboseFields,
+  hasVerboseFields,
+} from '../../../utils/strip-verbose-meta.js'
 
 export const pikkuHTTP: any = pikkuSessionlessFunc<void, boolean | undefined>({
   func: async ({ logger, config, getInspectorState }) => {
     const visitState = await getInspectorState()
-    const { httpWiringsFile, httpWiringMetaFile, packageMappings } = config
+    const {
+      httpWiringsFile,
+      httpWiringMetaFile,
+      httpWiringMetaJsonFile,
+      packageMappings,
+      schema,
+    } = config
     const { http } = visitState
 
     await writeFileInDir(
@@ -19,10 +30,43 @@ export const pikkuHTTP: any = pikkuSessionlessFunc<void, boolean | undefined>({
         packageMappings
       )
     )
+
+    // Write minimal JSON (runtime-only fields)
+    const minimalMeta = stripVerboseFields(http.meta)
+    await writeFileInDir(
+      logger,
+      httpWiringMetaJsonFile,
+      JSON.stringify(minimalMeta, null, 2)
+    )
+
+    // Write verbose JSON only if it has additional fields
+    if (hasVerboseFields(http.meta)) {
+      const verbosePath = httpWiringMetaJsonFile.replace(
+        /\.gen\.json$/,
+        '-verbose.gen.json'
+      )
+      await writeFileInDir(
+        logger,
+        verbosePath,
+        JSON.stringify(http.meta, null, 2)
+      )
+    }
+
+    // Generate TypeScript file that imports the minimal JSON
+    const jsonImportPath = getFileImportRelativePath(
+      httpWiringMetaFile,
+      httpWiringMetaJsonFile,
+      packageMappings
+    )
+    const supportsImportAttributes = schema?.supportsImportAttributes ?? false
+    const importStatement = supportsImportAttributes
+      ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+      : `import metaData from '${jsonImportPath}'`
+
     await writeFileInDir(
       logger,
       httpWiringMetaFile,
-      `import { pikkuState } from '@pikku/core'\npikkuState('http', 'meta', ${JSON.stringify(http.meta, null, 2)})`
+      `import { pikkuState } from '@pikku/core'\nimport type { HTTPWiringsMeta } from '@pikku/core/http'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`
     )
 
     return true

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

@@ -19,7 +19,7 @@ export const pikkuOpenAPI: any = pikkuSessionlessFunc<void, void>({
       return
     }
 
-    const { http, functions } = await getInspectorState()
+    const { http, functions, zodLookup } = await getInspectorState()
 
     const schemas = await generateSchemas(
       logger,
@@ -28,7 +28,8 @@ export const pikkuOpenAPI: any = pikkuSessionlessFunc<void, void>({
       functions.meta,
       http.meta,
       schemasFromTypes,
-      config.schema?.additionalProperties
+      config.schema?.additionalProperties,
+      zodLookup
     )
     const openAPISpec = await generateOpenAPISpec(
       logger,

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

@@ -47,7 +47,7 @@ export const pikkuHTTP: any = pikkuSessionlessFunc<void, boolean>({
     await writeFileInDir(
       logger,
       httpWiringMetaFile,
-      `import { pikkuState, HTTPWiringsMeta } from '@pikku/core'\n${importStatement}\npikkuState('http', 'meta', metaData as HTTPWiringsMeta)`
+      `import { pikkuState, HTTPWiringsMeta } from '@pikku/core'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`
     )
 
     return true

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

@@ -8,7 +8,7 @@ export const serializeHTTPTypes = (functionTypesImportPath: string) => {
 
 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 type { CoreHTTPFunctionWiring, HTTPMethod } from '@pikku/core/http'
 
 /**
  * Type definition for HTTP API wirings with type-safe path parameters.
@@ -20,6 +20,22 @@ import type { CoreHTTPFunctionWiring } from '@pikku/core/http'
  */
 type HTTPWiring<In, Out, Route extends string> = CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction<In, Out, 'rpc' | 'session'>, PikkuFunctionSessionless<In, Out, 'rpc' | 'session'>, PikkuPermission<In>, PikkuMiddleware>
 
+/**
+ * HTTP wiring for workflow triggers (no function needed)
+ */
+type HTTPWorkflowWiring<Route extends string> = {
+  route: Route
+  method: HTTPMethod
+  workflow: true
+  func?: undefined
+  permissions?: undefined
+  auth?: undefined
+  tags?: undefined
+  middleware?: undefined
+  returnsJSON?: undefined
+  sse?: boolean
+}
+
 /**
  * Registers an HTTP wiring with the Pikku framework.
  *
@@ -29,7 +45,7 @@ type HTTPWiring<In, Out, Route extends string> = CoreHTTPFunctionWiring<In, Out,
  * @param httpWiring - HTTP wiring definition with handler, method, and optional middleware
  */
 export const wireHTTP = <In, Out, Route extends string>(
-  httpWiring: HTTPWiring<In, Out, Route> & AssertHTTPWiringParams<In, Route>
+  httpWiring: (HTTPWiring<In, Out, Route> & AssertHTTPWiringParams<In, Route>) | HTTPWorkflowWiring<Route>
 ) => {
   wireHTTPCore(httpWiring as any)
 }

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

@@ -32,7 +32,7 @@ export const serializeTypedHTTPWiringsMap = (
   return `/**
  * This provides the structure needed for typescript to be aware of routes and their return types
  */
-    
+
 ${serializedImportMap}
 ${serializedCustomTypes}
 ${serializedMetaTypes}
@@ -70,6 +70,12 @@ function generateHTTPWirings(
   for (const methods of Object.values(routesMeta)) {
     for (const meta of Object.values(methods)) {
       const { route, method, pikkuFuncName } = meta
+
+      // Skip workflow-triggered routes (they don't have a function)
+      if (meta.workflow) {
+        continue
+      }
+
       const functionMeta = functionsMeta[pikkuFuncName]
       if (!functionMeta) {
         throw new Error(
@@ -79,16 +85,28 @@ function generateHTTPWirings(
       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
       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'
+      // For zod-derived schemas, the type might not be in typesMap, so use the schema name directly
+      let inputType = 'null'
+      if (input) {
+        try {
+          inputType = typesMap.getTypeMeta(input).uniqueName
+        } catch {
+          inputType = input
+        }
+      }
+      let outputType = 'null'
+      if (output) {
+        try {
+          outputType = typesMap.getTypeMeta(output).uniqueName
+        } catch {
+          // Zod-derived schema - use the schema name directly
+          outputType = output
+        }
+      }
 
       requiredTypes.add(inputType)
       requiredTypes.add(outputType)
@@ -121,7 +139,13 @@ const generateMetaTypes = (metaTypes: MetaInputTypes, typesMap: TypesMap) => {
   const nameToTypeMap = Array.from(metaTypes.entries()).reduce<
     Map<string, string>
   >((result, [_name, { query, body, params }]) => {
-    const { uniqueName } = typesMap.getTypeMeta(_name)
+    let uniqueName: string
+    try {
+      uniqueName = typesMap.getTypeMeta(_name).uniqueName
+    } catch {
+      // Zod-derived schema - use the name directly
+      uniqueName = _name
+    }
     const queryType =
       query && query.length > 0
         ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`

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

@@ -5,6 +5,10 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 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 (
@@ -26,12 +30,13 @@ const generateArgumentsFromSchema = async (
   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)
 
@@ -54,7 +59,8 @@ const generateArgumentsFromSchema = async (
     }
     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 []
   }
 }
@@ -101,12 +107,28 @@ export const pikkuMCP: any = pikkuSessionlessFunc<void, boolean | undefined>({
       toolsMeta: mcpEndpoints.toolsMeta,
       promptsMeta: promptsMetaWithArguments,
     }
+
+    // Write minimal JSON (runtime-only fields)
+    const minimalMeta = stripVerboseFields(metaData)
     await writeFileInDir(
       logger,
       config.mcpWiringsMetaJsonFile,
-      JSON.stringify(metaData, null, 2)
+      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,
@@ -124,9 +146,9 @@ export const pikkuMCP: any = pikkuSessionlessFunc<void, boolean | undefined>({
       `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