@pikku/cli 0.11.2 → 0.11.3

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

@@ -8,7 +8,7 @@ export const serializeHTTPTypes = (functionTypesImportPath) => {
 
 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/dist/src/functions/wirings/http/serialize-typed-http-map.js

@@ -9,7 +9,7 @@ export const serializeTypedHTTPWiringsMap = (relativeToPath, packageMappings, ty
     return `/**
  * This provides the structure needed for typescript to be aware of routes and their return types
  */
-    
+
 ${serializedImportMap}
 ${serializedCustomTypes}
 ${serializedMetaTypes}
@@ -37,21 +37,39 @@ function generateHTTPWirings(routesMeta, functionsMeta, typesMap, requiredTypes)
     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(`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
             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);
             // Add method entry
@@ -75,7 +93,14 @@ function generateHTTPWirings(routesMeta, functionsMeta, typesMap, requiredTypes)
 }
 const generateMetaTypes = (metaTypes, typesMap) => {
     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;
+        }
         const queryType = query && query.length > 0
             ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`
             : undefined;

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

@@ -5,6 +5,7 @@ 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 (inputSchema, schemaDirectory, typesMap, logger) => {
     if (!inputSchema)
@@ -15,8 +16,8 @@ const generateArgumentsFromSchema = async (inputSchema, schemaDirectory, typesMa
     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 +35,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 [];
     }
 };
@@ -57,7 +59,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 +75,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-json.js

@@ -14,13 +14,14 @@ export const serializeMCPJson = async (logger, schemaDirectory, functionsMeta, t
         if (!uniqueName) {
             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/dist/src/functions/wirings/mcp/serialize-mcp-types.js

@@ -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/dist/src/functions/wirings/middleware/pikku-command-middleware.js

@@ -24,17 +24,20 @@ export const pikkuMiddleware = pikkuSessionlessFunc({
             const importStatement = supportsImportAttributes
                 ? `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)
 }
 `;
             await writeFileInDir(logger, config.middlewareGroupsMetaFile, tsContent);

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

@@ -0,0 +1 @@
+export declare const pikkuPackage: any;

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

@@ -0,0 +1,58 @@
+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 = pikkuSessionlessFunc({
+    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/dist/src/functions/wirings/package/serialize-package.d.ts

@@ -0,0 +1,5 @@
+export interface PackageFactoryInfo {
+    file: string;
+    variable: string;
+}
+export declare const serializePackageFactories: (outputPath: string, packageName: string, configFactory: PackageFactoryInfo | undefined, singletonServicesFactory: PackageFactoryInfo | undefined, wireServicesFactory: PackageFactoryInfo | undefined, packageMappings?: Record<string, string>) => string | null;

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

@@ -0,0 +1,32 @@
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+export const serializePackageFactories = (outputPath, packageName, configFactory, singletonServicesFactory, wireServicesFactory, packageMappings = {}) => {
+    const imports = [
+        `import { addPackageServiceFactories } from '@pikku/core'`,
+    ];
+    const factoryEntries = [];
+    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/dist/src/functions/wirings/queue/pikku-command-queue.js

@@ -4,13 +4,21 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeQueueMeta, 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 = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
         const { queueWorkersWiringFile, queueWorkersWiringMetaFile, queueWorkersWiringMetaJsonFile, packageMappings, schema, } = config;
         const { queueWorkers } = visitState;
-        // Write JSON file
-        await writeFileInDir(logger, queueWorkersWiringMetaJsonFile, JSON.stringify(serializeQueueMeta(queueWorkers.meta), null, 2));
+        const fullMeta = serializeQueueMeta(queueWorkers.meta);
+        // Write minimal JSON file (runtime-only fields)
+        const minimalMeta = stripVerboseFields(fullMeta);
+        await writeFileInDir(logger, queueWorkersWiringMetaJsonFile, 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, queueWorkersWiringMetaJsonFile, packageMappings);
         // Write TypeScript file that imports JSON

package/dist/src/functions/wirings/queue/pikku-queue.js

@@ -9,16 +9,8 @@ export const pikkuQueue = pikkuSessionlessFunc({
         const visitState = await getInspectorState();
         const { queueWorkersWiringFile, queueWorkersWiringMetaFile, queueWorkersWiringMetaJsonFile, packageMappings, schema, } = 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));
+        await writeFileInDir(logger, queueWorkersWiringMetaJsonFile, JSON.stringify(serializeQueueMeta(queueWorkers.meta), null, 2));
         // Calculate relative path from TS file to JSON file
         const jsonImportPath = getFileImportRelativePath(queueWorkersWiringMetaFile, queueWorkersWiringMetaJsonFile, packageMappings);
         // Write TypeScript file that imports JSON

package/dist/src/functions/wirings/queue/serialize-queue-map.js

@@ -8,7 +8,7 @@ export const serializeQueueMap = (relativeToPath, packageMappings, typesMap, fun
     return `/**
  * This provides the structure needed for typescript to be aware of Queue workers and their input/output types
  */
-    
+
 ${serializedImportMap}
 ${serializedCustomTypes}
 
@@ -57,8 +57,25 @@ function generateQueues(queueWorkersMeta, functionsMeta, typesMap, requiredTypes
         const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
         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);
         // Add Queue entry

package/dist/src/functions/wirings/queue/serialize-queue-meta.js

@@ -10,6 +10,6 @@ export const serializeQueueMetaTS = (jsonImportPath, supportsImportAttributes) =
     serializedOutput.push("import { QueueWorkersMeta } from '@pikku/core/queue'");
     serializedOutput.push(importStatement);
     serializedOutput.push('');
-    serializedOutput.push("pikkuState('queue', 'meta', metaData as QueueWorkersMeta)");
+    serializedOutput.push("pikkuState(null, 'queue', 'meta', metaData as QueueWorkersMeta)");
     return serializedOutput.join('\n');
 };

package/dist/src/functions/wirings/rpc/pikku-command-rpc-map.js

@@ -5,8 +5,8 @@ import { serializeTypedRPCMap } from './serialize-typed-rpc-map.js';
 export const pikkuRPCInternalMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { functions, rpc } = await getInspectorState();
-        const { rpcInternalMapDeclarationFile, packageMappings } = config;
-        const content = serializeTypedRPCMap(rpcInternalMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.internalMeta);
+        const { rpcInternalMapDeclarationFile, packageMappings, externalPackages } = config;
+        const content = serializeTypedRPCMap(rpcInternalMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.internalMeta, externalPackages);
         await writeFileInDir(logger, rpcInternalMapDeclarationFile, content);
     },
     middleware: [
@@ -19,8 +19,8 @@ export const pikkuRPCInternalMap = pikkuSessionlessFunc({
 export const pikkuRPCExposedMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { functions, rpc } = await getInspectorState();
-        const { rpcMapDeclarationFile, packageMappings } = config;
-        const content = serializeTypedRPCMap(rpcMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.exposedMeta);
+        const { rpcMapDeclarationFile, packageMappings, externalPackages } = config;
+        const content = serializeTypedRPCMap(rpcMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.exposedMeta, externalPackages);
         await writeFileInDir(logger, rpcMapDeclarationFile, content);
     },
     middleware: [

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

@@ -13,7 +13,7 @@ export const pikkuRPC = pikkuSessionlessFunc({
             const importStatement = supportsImportAttributes
                 ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
                 : `import metaData from '${jsonImportPath}'`;
-            await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core'\n${importStatement}\npikkuState('rpc', 'meta', metaData as Record<string, string>)`);
+            await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core'\n${importStatement}\npikkuState(null, 'rpc', 'meta', metaData as Record<string, string>)`);
             return true;
         }
         return false;

package/dist/src/functions/wirings/rpc/serialize-remote-rpc.js

@@ -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/dist/src/functions/wirings/rpc/serialize-rpc-wrapper.js

@@ -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/dist/src/functions/wirings/rpc/serialize-typed-rpc-map.d.ts

@@ -1,3 +1,3 @@
 import { TypesMap } from '@pikku/inspector';
 import { FunctionsMeta } from '@pikku/core';
-export declare const serializeTypedRPCMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, rpcMeta: Record<string, string>) => string;
+export declare const serializeTypedRPCMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, rpcMeta: Record<string, string>, externalPackages?: Record<string, string>) => string;