@pikku/cli 0.11.2 → 0.11.3

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

@@ -44,16 +44,18 @@ export const serializeMCPJson = async (
       return undefined
     }
 
+    const schemaPath = join(
+      schemaDirectory,
+      'schemas',
+      `${uniqueName}.schema.json`
+    )
+
     try {
-      const schemaPath = join(
-        schemaDirectory,
-        'schemas',
-        `${uniqueName}.schema.json`
-      )
       const schemaContent = await readFile(schemaPath, 'utf-8')
       return JSON.parse(schemaContent)
     } catch (e) {
-      logger.warn(`Could not load schema for type: ${uniqueName}`)
+      logger.warn(`Serialize MCP: Could not load schema for type: ${uniqueName} from ${schemaPath}`)
+      console.error(e)
       return undefined
     }
   }

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

@@ -19,7 +19,8 @@ import {
   AssertMCPResourceURIParams
 } from '@pikku/core/mcp'
 
-import type { PikkuFunctionConfig, PikkuFunctionSessionless } from '${functionTypesImportPath}'
+import type { PikkuFunctionConfig, PikkuFunctionSessionless, InferZodOutput } from '${functionTypesImportPath}'
+import type { ZodLike } from '@pikku/core'
 
 /**
  * Type definition for MCP resources that provide data to AI models.
@@ -83,60 +84,111 @@ export const wireMCPPrompt = <In>(
   wireMCPPromptCore(mcpPrompt as any)
 }
 
+/**
+ * Configuration for MCP prompt with Zod schema input validation.
+ */
+type MCPPromptFuncConfigWithSchema<InputSchema extends ZodLike> = {
+  func: PikkuFunctionSessionless<InferZodOutput<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 ZodLike>(
+  config: MCPPromptFuncConfigWithSchema<InputSchema>
+): PikkuFunctionConfig<InferZodOutput<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 ZodLike> = {
+  func: PikkuFunctionSessionless<InferZodOutput<InputSchema>, MCPToolResponse, 'mcp' | 'rpc'>
+  name?: string
+  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 ZodLike>(
+  config: MCPToolFuncConfigWithSchema<InputSchema>
+): PikkuFunctionConfig<InferZodOutput<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'>
       name?: string
     }
-): 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 ZodLike> = {
+  func: PikkuFunctionSessionless<InferZodOutput<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 ZodLike>(
+  config: MCPResourceFuncConfigWithSchema<InputSchema>
+): PikkuFunctionConfig<InferZodOutput<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/src/functions/wirings/middleware/pikku-command-middleware.ts

@@ -43,17 +43,21 @@ export const pikkuMiddleware: any = pikkuSessionlessFunc<
         ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
         : `import metaData from '${jsonImportPath}'`
 
+      const packageNameValue = config.externalPackageName
+        ? `'${config.externalPackageName}'`
+        : 'null'
+
       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)
+  pikkuState(${packageNameValue}, 'middleware', 'httpGroupMeta', metaData.httpGroups)
 }
 
 // Tag middleware groups metadata
 if (metaData.tagGroups && Object.keys(metaData.tagGroups).length > 0) {
-  pikkuState('middleware', 'tagGroupMeta', metaData.tagGroups)
+  pikkuState(${packageNameValue}, 'middleware', 'tagGroupMeta', metaData.tagGroups)
 }
 `
 

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

@@ -0,0 +1,81 @@
+import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js'
+import { writeFileInDir } from '../../../utils/file-writer.js'
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js'
+import { serializePackageFactories } from './serialize-package.js'
+
+export const pikkuPackage: any = pikkuSessionlessFunc<
+  void,
+  boolean | undefined
+>({
+  func: async ({ logger, config, getInspectorState }) => {
+    const { externalPackageName, packageMappings, packageFile } = config
+
+    // Only generate for external packages
+    if (!externalPackageName) {
+      logger.info({
+        message:
+          'Skipping package factories - not an external package (externalPackageName not set)',
+        type: 'skip',
+      })
+      return false
+    }
+
+    if (!packageFile) {
+      logger.info({
+        message: 'Skipping package factories - packageFile not configured',
+        type: 'skip',
+      })
+      return false
+    }
+
+    const state = await getInspectorState()
+    const { filesAndMethods } = state
+
+    const {
+      pikkuConfigFactory,
+      singletonServicesFactory,
+      wireServicesFactory,
+    } = filesAndMethods
+
+    const content = serializePackageFactories(
+      packageFile,
+      externalPackageName,
+      pikkuConfigFactory
+        ? {
+            file: pikkuConfigFactory.file,
+            variable: pikkuConfigFactory.variable,
+          }
+        : undefined,
+      singletonServicesFactory
+        ? {
+            file: singletonServicesFactory.file,
+            variable: singletonServicesFactory.variable,
+          }
+        : undefined,
+      wireServicesFactory
+        ? {
+            file: wireServicesFactory.file,
+            variable: wireServicesFactory.variable,
+          }
+        : undefined,
+      packageMappings
+    )
+
+    if (!content) {
+      logger.info({
+        message: 'Skipping package factories - no service factories found',
+        type: 'skip',
+      })
+      return false
+    }
+
+    await writeFileInDir(logger, packageFile, content)
+    return true
+  },
+  middleware: [
+    logCommandInfoAndTime({
+      commandStart: 'Generating package service factories',
+      commandEnd: 'Generated package service factories',
+    }),
+  ],
+})

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

@@ -0,0 +1,69 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+
+export interface PackageFactoryInfo {
+  file: string
+  variable: string
+}
+
+export const serializePackageFactories = (
+  outputPath: string,
+  packageName: string,
+  configFactory: PackageFactoryInfo | undefined,
+  singletonServicesFactory: PackageFactoryInfo | undefined,
+  wireServicesFactory: PackageFactoryInfo | undefined,
+  packageMappings: Record<string, string> = {}
+) => {
+  const imports: string[] = [
+    `import { addPackageServiceFactories } from '@pikku/core'`,
+  ]
+
+  const factoryEntries: string[] = []
+
+  if (configFactory) {
+    const filePath = getFileImportRelativePath(
+      outputPath,
+      configFactory.file,
+      packageMappings
+    )
+    imports.push(
+      `import { ${configFactory.variable} as createConfig } from '${filePath}'`
+    )
+    factoryEntries.push(`  createConfig,`)
+  }
+
+  if (singletonServicesFactory) {
+    const filePath = getFileImportRelativePath(
+      outputPath,
+      singletonServicesFactory.file,
+      packageMappings
+    )
+    imports.push(
+      `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${filePath}'`
+    )
+    factoryEntries.push(`  createSingletonServices,`)
+  }
+
+  if (wireServicesFactory) {
+    const filePath = getFileImportRelativePath(
+      outputPath,
+      wireServicesFactory.file,
+      packageMappings
+    )
+    imports.push(
+      `import { ${wireServicesFactory.variable} as createWireServices } from '${filePath}'`
+    )
+    factoryEntries.push(`  createWireServices,`)
+  }
+
+  // Only generate if at least one factory is defined
+  if (factoryEntries.length === 0) {
+    return null
+  }
+
+  return `${imports.join('\n')}
+
+addPackageServiceFactories('${packageName}', {
+${factoryEntries.join('\n')}
+})
+`
+}

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

@@ -7,6 +7,10 @@ import {
   serializeQueueMetaTS,
 } from './serialize-queue-meta.js'
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js'
+import {
+  stripVerboseFields,
+  hasVerboseFields,
+} from '../../../utils/strip-verbose-meta.js'
 
 export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean | undefined>({
   func: async ({ logger, config, getInspectorState }) => {
@@ -20,13 +24,29 @@ export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean | undefined>({
     } = config
     const { queueWorkers } = visitState
 
-    // Write JSON file
+    const fullMeta = serializeQueueMeta(queueWorkers.meta)
+
+    // Write minimal JSON file (runtime-only fields)
+    const minimalMeta = stripVerboseFields(fullMeta)
     await writeFileInDir(
       logger,
       queueWorkersWiringMetaJsonFile,
-      JSON.stringify(serializeQueueMeta(queueWorkers.meta), null, 2)
+      JSON.stringify(minimalMeta, null, 2)
     )
 
+    // Write verbose JSON only if it has additional fields
+    if (hasVerboseFields(fullMeta)) {
+      const verbosePath = queueWorkersWiringMetaJsonFile.replace(
+        /\.gen\.json$/,
+        '-verbose.gen.json'
+      )
+      await writeFileInDir(
+        logger,
+        verbosePath,
+        JSON.stringify(fullMeta, null, 2)
+      )
+    }
+
     // Calculate relative path from TS file to JSON file
     const jsonImportPath = getFileImportRelativePath(
       queueWorkersWiringMetaFile,

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

@@ -20,20 +20,11 @@ export const pikkuQueue: any = pikkuSessionlessFunc<void, boolean>({
     } = config
     const { queueWorkers } = visitState
 
-    // Add remote RPC worker to queue metadata if it exists
-    const queueMeta = { ...queueWorkers.meta }
-    if (config.rpc?.remoteRpcWorkersPath) {
-      queueMeta['pikku-remote-internal-rpc'] = {
-        pikkuFuncName: 'pikkuRemoteInternalRPC',
-        queueName: 'pikku-remote-internal-rpc',
-      }
-    }
-
     // Write JSON file
     await writeFileInDir(
       logger,
       queueWorkersWiringMetaJsonFile,
-      JSON.stringify(serializeQueueMeta(queueMeta), null, 2)
+      JSON.stringify(serializeQueueMeta(queueWorkers.meta), null, 2)
     )
 
     // Calculate relative path from TS file to JSON file

package/src/functions/wirings/queue/serialize-queue-map.ts

@@ -30,7 +30,7 @@ export const serializeQueueMap = (
   return `/**
  * This provides the structure needed for typescript to be aware of Queue workers and their input/output types
  */
-    
+
 ${serializedImportMap}
 ${serializedCustomTypes}
 
@@ -93,8 +93,23 @@ function generateQueues(
     const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
 
     // Store the input and output types for QueueHandler
-    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 {
+        outputType = output
+      }
+    }
 
     requiredTypes.add(inputType)
     requiredTypes.add(outputType)

package/src/functions/wirings/queue/serialize-queue-meta.ts

@@ -18,7 +18,7 @@ export const serializeQueueMetaTS = (
   serializedOutput.push(importStatement)
   serializedOutput.push('')
   serializedOutput.push(
-    "pikkuState('queue', 'meta', metaData as QueueWorkersMeta)"
+    "pikkuState(null, 'queue', 'meta', metaData as QueueWorkersMeta)"
   )
   return serializedOutput.join('\n')
 }

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

@@ -6,14 +6,16 @@ import { serializeTypedRPCMap } from './serialize-typed-rpc-map.js'
 export const pikkuRPCInternalMap: any = pikkuSessionlessFunc<void, void>({
   func: async ({ logger, config, getInspectorState }) => {
     const { functions, rpc } = await getInspectorState()
-    const { rpcInternalMapDeclarationFile, packageMappings } = config
+    const { rpcInternalMapDeclarationFile, packageMappings, externalPackages } =
+      config
 
     const content = serializeTypedRPCMap(
       rpcInternalMapDeclarationFile,
       packageMappings,
       functions.typesMap,
       functions.meta,
-      rpc.internalMeta
+      rpc.internalMeta,
+      externalPackages
     )
     await writeFileInDir(logger, rpcInternalMapDeclarationFile, content)
   },
@@ -28,14 +30,15 @@ export const pikkuRPCInternalMap: any = pikkuSessionlessFunc<void, void>({
 export const pikkuRPCExposedMap: any = pikkuSessionlessFunc<void, void>({
   func: async ({ logger, config, getInspectorState }) => {
     const { functions, rpc } = await getInspectorState()
-    const { rpcMapDeclarationFile, packageMappings } = config
+    const { rpcMapDeclarationFile, packageMappings, externalPackages } = config
 
     const content = serializeTypedRPCMap(
       rpcMapDeclarationFile,
       packageMappings,
       functions.typesMap,
       functions.meta,
-      rpc.exposedMeta
+      rpc.exposedMeta,
+      externalPackages
     )
     await writeFileInDir(logger, rpcMapDeclarationFile, content)
   },

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

@@ -34,7 +34,7 @@ export const pikkuRPC: any = pikkuSessionlessFunc<void, boolean>({
       await writeFileInDir(
         logger,
         rpcInternalWiringMetaFile,
-        `import { pikkuState } from '@pikku/core'\n${importStatement}\npikkuState('rpc', 'meta', metaData as Record<string, string>)`
+        `import { pikkuState } from '@pikku/core'\n${importStatement}\npikkuState(null, 'rpc', 'meta', metaData as Record<string, string>)`
       )
       return true
     }

package/src/functions/wirings/rpc/serialize-remote-rpc.ts

@@ -11,6 +11,9 @@ import { pikkuSessionlessFunc, wireQueueWorker } from '${pathToPikkuTypes}'
 /**
  * Generic remote RPC worker that invokes any internal RPC by name
  * This is used for executing internal RPCs via a queue or HTTP (e.g., scheduled tasks, background jobs, internal services)
+ *
+ * TODO: Security risk - this allows any RPC to be invoked by name. Should validate
+ * that rpcName is in an allowlist of permitted internal RPCs to prevent unauthorized access.
  */
 export const pikkuRemoteInternalRPC = pikkuSessionlessFunc<
   { rpcName: string, data?: any },

package/src/functions/wirings/rpc/serialize-rpc-wrapper.ts

@@ -59,7 +59,7 @@ export class PikkuRPC {
      * @returns A promise that resolves with the function's return value
      */
     invoke: RPCInvoke = async (rpcName, data) => {
-       return await this.pikkuFetch.post(\`/rpc/\${rpcName}\` as any, { rpcName, data }) as any
+       return await this.pikkuFetch.post(\`/rpc/\${rpcName}\` as any, { rpcName: String(rpcName), data }) as any
     }
 }
 

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

@@ -8,7 +8,8 @@ export const serializeTypedRPCMap = (
   packageMappings: Record<string, string>,
   typesMap: TypesMap,
   functionsMeta: FunctionsMeta,
-  rpcMeta: Record<string, string>
+  rpcMeta: Record<string, string>,
+  externalPackages?: Record<string, string>
 ) => {
   const requiredTypes = new Set<string>()
   const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes)
@@ -26,10 +27,17 @@ export const serializeTypedRPCMap = (
     requiredTypes
   )
 
+  const externalPackageImports = generateExternalPackageImports(
+    externalPackages,
+    relativeToPath
+  )
+
+  const mergedRPCMap = generateMergedRPCMap(externalPackages)
+
   return `/**
  * This provides the structure needed for typescript to be aware of RPCs and their return types
  */
-    
+
 ${serializedImportMap}
 ${serializedCustomTypes}
 
@@ -39,14 +47,16 @@ interface RPCHandler<I, O> {
 }
 
 ${serializedRPCs}
+${externalPackageImports}
+${mergedRPCMap}
 
-export type RPCInvoke = <Name extends keyof RPCMap>(
+export type RPCInvoke = <Name extends keyof FlattenedRPCMap>(
   name: Name,
-  data: RPCMap[Name]['input'],
+  data: FlattenedRPCMap[Name]['input'],
   options?: {
     location?: 'local' | 'remote' | 'auto'
   }
-) => Promise<RPCMap[Name]['output']>
+) => Promise<FlattenedRPCMap[Name]['output']>
 
 // Import WorkflowMap for workflow typing
 import type { WorkflowMap } from '../workflow/pikku-workflow-map.gen.js'
@@ -64,6 +74,60 @@ export type TypedPikkuRPC = {
   `
 }
 
+function generateExternalPackageImports(
+  externalPackages: Record<string, string> | undefined,
+  relativeToPath: string
+): string {
+  if (!externalPackages || Object.keys(externalPackages).length === 0) {
+    return ''
+  }
+
+  let imports = '\n// External package RPC maps\n'
+  for (const [namespace, packageName] of Object.entries(externalPackages)) {
+    // Import the RPCMap from each external package's internal RPC map
+    // Use .js extension - package.json exports will resolve to .d.ts for types
+    imports += `import type { RPCMap as ${toPascalCase(namespace)}RPCMap } from '${packageName}/.pikku/rpc/pikku-rpc-wirings-map.internal.gen.js'\n`
+  }
+  return imports
+}
+
+function generateMergedRPCMap(
+  externalPackages: Record<string, string> | undefined
+): string {
+  if (!externalPackages || Object.keys(externalPackages).length === 0) {
+    return `
+// No external packages, use RPCMap directly
+export type FlattenedRPCMap = RPCMap
+`
+  }
+
+  // TypeScript utility to flatten namespaced RPC maps
+  const utilityTypes = `
+// Utility type to prefix keys with namespace
+type PrefixKeys<T, Prefix extends string> = {
+  [K in keyof T as \`\${Prefix}:\${string & K}\`]: T[K]
+}
+
+// Merge all RPC maps with namespace prefixes
+export type FlattenedRPCMap =
+  RPCMap${Object.keys(externalPackages)
+    .map(
+      (namespace) =>
+        ` & PrefixKeys<${toPascalCase(namespace)}RPCMap, '${namespace}'>`
+    )
+    .join('')}
+`
+
+  return utilityTypes
+}
+
+function toPascalCase(str: string): string {
+  return str
+    .split(/[-_]/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('')
+}
+
 function generateRPCs(
   rpcMeta: Record<string, string>,
   functionsMeta: FunctionsMeta,
@@ -86,13 +150,14 @@ function generateRPCs(
     const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined
 
     // Store the input and output types for RPCHandler
-    // Use 'any' for types not in typesMap (e.g., inline types in generated workflow workers)
+    // 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 = 'any'
+        // Type not in typesMap - use the name directly (e.g., zod-derived types)
+        inputType = input
       }
     }
 
@@ -101,7 +166,8 @@ function generateRPCs(
       try {
         outputType = typesMap.getTypeMeta(output).uniqueName
       } catch {
-        outputType = 'any'
+        // Type not in typesMap - use the name directly (e.g., zod-derived types)
+        outputType = output
       }
     }