@pikku/cli 0.12.6 → 0.12.8

package/dist/src/functions/commands/new-addon.js

@@ -1,9 +1,9 @@
 import { existsSync } from 'fs';
 import { join } from 'path';
 import { mkdir, writeFile } from 'fs/promises';
+import { createEmptyManifest, saveManifest, } from '../../utils/contract-versions.js';
 import { pikkuSessionlessFunc } from '#pikku';
-import { parseOpenAPISpec } from '../../utils/openapi/parse-openapi.js';
-import { generateAddonFromOpenAPI } from '../../utils/openapi/codegen.js';
+import { parseOpenAPISpec, computeContractHash, generateAddonFromOpenAPI, } from '@pikku/openapi-parser';
 function toCamelCase(str) {
     return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 }
@@ -31,14 +31,15 @@ function getAddonFiles(vars, flags) {
                 types: './dist/src/index.d.ts',
                 import: './dist/src/index.js',
             },
-            './.pikku/*': './.pikku/*',
-            './.pikku/pikku-metadata.gen.json': './.pikku/pikku-metadata.gen.json',
+            './.pikku/*': './dist/.pikku/*',
+            './.pikku/pikku-metadata.gen.json': './dist/.pikku/pikku-metadata.gen.json',
             './.pikku/rpc/pikku-rpc-wirings-map.internal.gen.js': {
-                types: './.pikku/rpc/pikku-rpc-wirings-map.internal.gen.d.ts',
+                types: './dist/.pikku/rpc/pikku-rpc-wirings-map.internal.gen.d.ts',
             },
         },
-        files: ['dist', '.pikku'],
+        files: ['dist'],
         scripts: {
+            prepublishOnly: 'yarn build',
             prebuild: 'pikku all',
             build: 'tsc && cp -r .pikku dist/',
             pikku: 'pikku all',
@@ -613,6 +614,16 @@ export const pikkuNewAddon = pikkuSessionlessFunc({
                 mcp,
             });
             Object.assign(addonFiles, openapiFiles);
+            // Inject openapi metadata into pikku.config.json
+            const config = JSON.parse(addonFiles['pikku.config.json']);
+            if (typeof config.addon === 'boolean' || !config.addon) {
+                config.addon = {};
+            }
+            config.addon.openapi = {
+                version: spec.info.version,
+                hash: computeContractHash(spec),
+            };
+            addonFiles['pikku.config.json'] = JSON.stringify(config, null, 2);
         }
         const written = await writeFiles(addonDir, addonFiles);
         // Test harness
@@ -621,6 +632,9 @@ export const pikkuNewAddon = pikkuSessionlessFunc({
             const testWritten = await writeFiles(join(addonDir, 'test'), testFiles);
             written.push(...testWritten);
         }
+        // Initialize version manifest
+        const manifestPath = join(addonDir, 'versions.pikku.json');
+        await saveManifest(manifestPath, createEmptyManifest());
         logger.info(`Created addon at ${addonDir}`);
         for (const f of written) {
             logger.debug({ message: `  ${f}`, type: 'success' });

package/dist/src/functions/commands/versions-check.js

@@ -13,7 +13,7 @@ export const pikkuVersionsCheck = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
         if (!visitState.manifest.initial) {
-            const manifestPath = join(config.outDir, 'versions.json');
+            const manifestPath = join(config.rootDir, 'versions.pikku.json');
             throw new Error(`[${ErrorCode.MANIFEST_MISSING}] Version manifest not found at ${manifestPath}. Run 'pikku versions init' to create one.`);
         }
         if (visitState.manifest.errors.length > 0) {
@@ -50,9 +50,9 @@ export const pikkuVersionsCheck = pikkuSessionlessFunc({
                     if (error.latestVersion !== undefined) {
                         logger.info(`  Latest recorded version: ${error.latestVersion}`);
                     }
-                    logger.info(`  Version ${error.version} exists in code but not in versions.json`);
+                    logger.info(`  Version ${error.version} exists in code but not in versions.pikku.json`);
                     logger.info(``);
-                    logger.info(`  This usually means a merge conflict in versions.json.`);
+                    logger.info(`  This usually means a merge conflict in versions.pikku.json.`);
                     logger.info(`  Resolve the conflict, then run:`);
                     logger.info(`  npx pikku versions-update`);
                 }
@@ -76,7 +76,7 @@ export const pikkuVersionsCheck = pikkuSessionlessFunc({
                 }
                 else if (error.code === ErrorCode.MANIFEST_INTEGRITY_ERROR &&
                     error.functionKey) {
-                    logger.info(`✗ ${error.functionKey} — versions.json integrity error`);
+                    logger.info(`✗ ${error.functionKey} — versions.pikku.json integrity error`);
                     if (error.latestVersion !== undefined) {
                         logger.info(`  "latest" field: ${error.latestVersion}`);
                     }

package/dist/src/functions/commands/versions-init.js

@@ -4,7 +4,7 @@ import { pikkuSessionlessFunc } from '#pikku';
 import { createEmptyManifest, saveManifest, } from '../../utils/contract-versions.js';
 export const pikkuVersionsInit = pikkuSessionlessFunc({
     func: async ({ logger, config }, { force }) => {
-        const manifestPath = join(config.outDir, 'versions.json');
+        const manifestPath = join(config.rootDir, 'versions.pikku.json');
         if (existsSync(manifestPath) && !force) {
             logger.error(`Version manifest already exists at ${manifestPath}. Use --force to overwrite.`);
             process.exit(1);

package/dist/src/functions/commands/versions-update.js

@@ -4,7 +4,7 @@ import { ErrorCode } from '@pikku/inspector';
 import { saveManifest } from '../../utils/contract-versions.js';
 export const pikkuVersionsUpdate = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const manifestPath = join(config.outDir, 'versions.json');
+        const manifestPath = join(config.rootDir, 'versions.pikku.json');
         const visitState = await getInspectorState();
         if (!visitState.manifest.initial) {
             throw new Error(`Version manifest not found at ${manifestPath}. Run 'pikku versions init' to create one.`);

package/dist/src/functions/runtimes/nextjs/pikku-command-nextjs.js

@@ -43,14 +43,14 @@ export const pikkuNext = pikkuSessionlessFunc({
             const bootstrapPath = getFileImportRelativePath(nextBackendFile, config.bootstrapFile, packageMappings);
             const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpMapDeclarationFile, packageMappings);
             const rpcMapDeclarationPath = getFileImportRelativePath(nextBackendFile, rpcMapDeclarationFile, packageMappings);
-            const content = serializeNextBackendWrapper(bootstrapPath, routesMapDeclarationPath, rpcMapDeclarationPath, pikkuConfigImport, singletonServicesImport, wireServicesImport);
+            const content = serializeNextBackendWrapper(bootstrapPath, routesMapDeclarationPath, rpcMapDeclarationPath, pikkuConfigImport, singletonServicesImport, wireServicesImport, config.globalHTTPPrefix || '');
             await writeFileInDir(logger, nextBackendFile, content);
         }
         if (nextHTTPFile && fetchFile) {
             const routesMapDeclarationPath = getFileImportRelativePath(nextHTTPFile, httpMapDeclarationFile, packageMappings);
             const rpcMapDeclarationPath = getFileImportRelativePath(nextHTTPFile, rpcMapDeclarationFile, packageMappings);
             const fetchPath = getFileImportRelativePath(nextHTTPFile, fetchFile, packageMappings);
-            const content = serializeNextHTTPWrapper(routesMapDeclarationPath, rpcMapDeclarationPath, fetchPath);
+            const content = serializeNextHTTPWrapper(routesMapDeclarationPath, rpcMapDeclarationPath, fetchPath, config.globalHTTPPrefix || '');
             await writeFileInDir(logger, nextHTTPFile, content);
         }
     },

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-backend-wrapper.d.ts

@@ -1 +1 @@
-export declare const serializeNextJsBackendWrapper: (bootstrapPath: string, routesMapPath: string, rpcMapPath: string, configImport: string, singleServicesFactoryImport: string, wireServicesImport: string | undefined) => string;
+export declare const serializeNextJsBackendWrapper: (bootstrapPath: string, routesMapPath: string, rpcMapPath: string, configImport: string, singleServicesFactoryImport: string, wireServicesImport: string | undefined, globalHTTPPrefix?: string) => string;

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-backend-wrapper.js

@@ -1,4 +1,4 @@
-export const serializeNextJsBackendWrapper = (bootstrapPath, routesMapPath, rpcMapPath, configImport, singleServicesFactoryImport, wireServicesImport) => {
+export const serializeNextJsBackendWrapper = (bootstrapPath, routesMapPath, rpcMapPath, configImport, singleServicesFactoryImport, wireServicesImport, globalHTTPPrefix = '') => {
     return `'server-only'
 
 /**
@@ -194,7 +194,7 @@ export const pikku = (_options?: any) => {
     rpcName: Name,
     data: FlattenedRPCMap[Name]['input']
   ): Promise<FlattenedRPCMap[Name]['output']> => {
-    return dynamicActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: data ?? null }) as unknown as FlattenedRPCMap[Name]['output']
+    return dynamicActionRequest('${globalHTTPPrefix}/rpc/:rpcName' as '${globalHTTPPrefix}/rpc/:rpcName', 'POST', { rpcName, data: data ?? null }) as unknown as FlattenedRPCMap[Name]['output']
   }
 
   /**

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-http-wrapper.d.ts

@@ -1 +1 @@
-export declare const serializeNextJsHTTPWrapper: (routesMapPath: string, rpcMapPath: string, pikkuFetchImport: string) => string;
+export declare const serializeNextJsHTTPWrapper: (routesMapPath: string, rpcMapPath: string, pikkuFetchImport: string, globalHTTPPrefix?: string) => string;

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-http-wrapper.js

@@ -1,4 +1,4 @@
-export const serializeNextJsHTTPWrapper = (routesMapPath, rpcMapPath, pikkuFetchImport) => {
+export const serializeNextJsHTTPWrapper = (routesMapPath, rpcMapPath, pikkuFetchImport, globalHTTPPrefix = '') => {
     return `'server-only'
   
 /**
@@ -173,7 +173,7 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
     rpcName: Name,
     data: FlattenedRPCMap[Name]['input']
   ): Promise<FlattenedRPCMap[Name]['output']> => {
-    return dynamicActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: data ?? null }) as unknown as FlattenedRPCMap[Name]['output']
+    return dynamicActionRequest('${globalHTTPPrefix}/rpc/:rpcName' as '${globalHTTPPrefix}/rpc/:rpcName', 'POST', { rpcName, data: data ?? null }) as unknown as FlattenedRPCMap[Name]['output']
   }
 
   /**

package/dist/src/functions/wirings/ai-agent/pikku-command-public-agent.js

@@ -7,7 +7,7 @@ export const pikkuPublicAgent = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
         if (config.scaffold?.agent) {
             const pathToPikkuTypes = getFileImportRelativePath(config.publicAgentFile, config.typesDeclarationFile, config.packageMappings);
-            await writeFileInDir(logger, config.publicAgentFile, serializePublicAgent(pathToPikkuTypes, config.scaffold.agent === 'auth'));
+            await writeFileInDir(logger, config.publicAgentFile, serializePublicAgent(pathToPikkuTypes, config.scaffold.agent === 'auth', config.globalHTTPPrefix || ''));
             return true;
         }
         return false;

package/dist/src/functions/wirings/ai-agent/serialize-ai-agent-types.js

@@ -14,16 +14,22 @@ import type { StandardSchemaV1 } from '@standard-schema/spec'
 import type { AIAgentMemoryConfig, AIAgentInput } from '@pikku/core/ai-agent'
 import type { AgentMap } from '${agentMapImportPath}'
 
-type AIAgentConfig = Omit<CoreAIAgent<PikkuPermission, PikkuMiddleware>, 'tools' | 'agents' | 'memory'> & {
-  input?: StandardSchemaV1
-  output?: StandardSchemaV1
+type AIAgentConfig<
+  InputSchema extends StandardSchemaV1 | undefined = undefined,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
+> = Omit<CoreAIAgent<PikkuPermission, PikkuMiddleware>, 'tools' | 'agents' | 'memory' | 'input' | 'output'> & {
+  input?: InputSchema
+  output?: OutputSchema
   memory?: Omit<AIAgentMemoryConfig, 'workingMemory'> & { workingMemory?: StandardSchemaV1 }
   tools?: object[]
-  agents?: AIAgentConfig[]
+  agents?: AIAgentConfig<StandardSchemaV1 | undefined, StandardSchemaV1 | undefined>[]
 }
 
-export const pikkuAIAgent = (
-  agent: AIAgentConfig
+export const pikkuAIAgent = <
+  InputSchema extends StandardSchemaV1 | undefined = undefined,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
+>(
+  agent: AIAgentConfig<InputSchema, OutputSchema>
 ) => {
   return agent
 }

package/dist/src/functions/wirings/ai-agent/serialize-public-agent.d.ts

@@ -1 +1 @@
-export declare const serializePublicAgent: (pathToPikkuTypes: string, requireAuth?: boolean) => string;
+export declare const serializePublicAgent: (pathToPikkuTypes: string, requireAuth?: boolean, globalHTTPPrefix?: string) => string;

package/dist/src/functions/wirings/ai-agent/serialize-public-agent.js

@@ -1,4 +1,4 @@
-export const serializePublicAgent = (pathToPikkuTypes, requireAuth = true) => {
+export const serializePublicAgent = (pathToPikkuTypes, requireAuth = true, globalHTTPPrefix = '') => {
     const authFlag = requireAuth ? 'true' : 'false';
     return `import { pikkuSessionlessFunc, defineHTTPRoutes, wireHTTPRoutes } from '${pathToPikkuTypes}'
 
@@ -58,23 +58,23 @@ export const agentRoutes = defineHTTPRoutes({
   tags: ['pikku:public'],
   routes: {
     agentRun: {
-      route: '/rpc/agent/:agentName',
+      route: '${globalHTTPPrefix}/rpc/agent/:agentName',
       method: 'post',
       func: agentCaller,
     },
     agentStream: {
-      route: '/rpc/agent/:agentName/stream',
+      route: '${globalHTTPPrefix}/rpc/agent/:agentName/stream',
       method: 'post',
       sse: true,
       func: agentStreamCaller,
     },
     agentApprove: {
-      route: '/rpc/agent/:agentName/approve',
+      route: '${globalHTTPPrefix}/rpc/agent/:agentName/approve',
       method: 'post',
       func: agentApproveCaller,
     },
     agentResume: {
-      route: '/rpc/agent/:agentName/resume',
+      route: '${globalHTTPPrefix}/rpc/agent/:agentName/resume',
       method: 'post',
       sse: true,
       func: agentResumeCaller,

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

@@ -56,7 +56,7 @@ export const pikkuCLIEntry = pikkuSessionlessFunc({
                             `Move it to a source directory like "src/wirings/cli-channel.gen.ts".`);
                     }
                     const channelWireFile = resolvedWirePath;
-                    const channelCode = serializeChannelCLI(programName, programMeta, channelWireFile, visitState.functions.files, config.packageMappings, config.channelsTypesFile, config.functionTypesFile, channelName, channelRoute);
+                    const channelCode = serializeChannelCLI(programName, programMeta, channelWireFile, visitState.functions.files, config.packageMappings, config.channelsTypesFile, config.functionTypesFile, channelName, channelRoute, config.globalHTTPPrefix || '');
                     await writeFileInDir(logger, channelWireFile, channelCode);
                     logger.debug(`Serialized CLI channel for ${programName}: ${channelWireFile}`);
                     // Generate client code if clientPath is provided

package/dist/src/functions/wirings/cli/serialize-channel-cli.d.ts

@@ -6,4 +6,4 @@ import type { CLIProgramMeta } from '@pikku/core/cli';
 export declare function serializeChannelCLI(programName: string, programMeta: CLIProgramMeta, channelFile: string, functionFiles: Map<string, {
     path: string;
     exportedName: string;
-}>, packageMappings: Record<string, string>, channelTypesFile: string, functionTypesFile: string, channelName?: string, channelRoute?: string): string;
+}>, packageMappings: Record<string, string>, channelTypesFile: string, functionTypesFile: string, channelName?: string, channelRoute?: string, globalHTTPPrefix?: string): string;

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

@@ -3,9 +3,9 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
  * Serializes a wireChannel call from CLI metadata
  * This creates a WebSocket backend for all CLI commands
  */
-export function serializeChannelCLI(programName, programMeta, channelFile, functionFiles, packageMappings, channelTypesFile, functionTypesFile, channelName, channelRoute) {
+export function serializeChannelCLI(programName, programMeta, channelFile, functionFiles, packageMappings, channelTypesFile, functionTypesFile, channelName, channelRoute, globalHTTPPrefix = '') {
     const finalChannelName = channelName || `${programName}-cli`;
-    const finalChannelRoute = channelRoute || `/cli/${programName}`;
+    const finalChannelRoute = channelRoute || `${globalHTTPPrefix}/cli/${programName}`;
     // Flatten all commands into a single routing map
     const commandMap = {};
     const collectCommands = (commands, path = []) => {

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

@@ -8,7 +8,7 @@ export const pikkuConsoleFunctions = pikkuSessionlessFunc({
         if (config.scaffold?.console) {
             const pathToPikkuTypes = getFileImportRelativePath(config.consoleFunctionsFile, config.typesDeclarationFile, config.packageMappings);
             const pathToAgentTypes = getFileImportRelativePath(config.consoleFunctionsFile, config.agentTypesFile, config.packageMappings);
-            await writeFileInDir(logger, config.consoleFunctionsFile, serializeConsoleFunctions(pathToPikkuTypes, pathToAgentTypes));
+            await writeFileInDir(logger, config.consoleFunctionsFile, serializeConsoleFunctions(pathToPikkuTypes, pathToAgentTypes, config.globalHTTPPrefix || ''));
             return true;
         }
         return false;

package/dist/src/functions/wirings/console/serialize-console-functions.d.ts

@@ -1 +1 @@
-export declare const serializeConsoleFunctions: (pathToPikkuTypes: string, _pathToAgentTypes: string) => string;
+export declare const serializeConsoleFunctions: (pathToPikkuTypes: string, _pathToAgentTypes: string, globalHTTPPrefix?: string) => string;

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

@@ -1,4 +1,4 @@
-export const serializeConsoleFunctions = (pathToPikkuTypes, _pathToAgentTypes) => {
+export const serializeConsoleFunctions = (pathToPikkuTypes, _pathToAgentTypes, globalHTTPPrefix = '') => {
     return `import { pikkuSessionlessFunc, defineHTTPRoutes, wireHTTPRoutes, addon, wireAddon } from '${pathToPikkuTypes}'
 
 export const pikkuConsoleSetSecret = pikkuSessionlessFunc<{
@@ -98,6 +98,6 @@ export const consoleRoutes = defineHTTPRoutes({
 })
 
 wireAddon({ name: 'console', package: '@pikku/addon-console' })
-wireHTTPRoutes({ basePath: '/api', routes: { console: consoleRoutes } })
+wireHTTPRoutes({ basePath: '${globalHTTPPrefix}', routes: { console: consoleRoutes } })
 `;
 };

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

@@ -20,11 +20,33 @@ export const serializeMiddlewareImports = (outputPath, middlewareState, httpStat
     const channelMiddlewareFactories = fullState
         ? collectFactories(fullState.channelMiddleware.tagMiddleware, outputPath, packageMappings)
         : new Map();
+    // Collect direct (non-factory) side-effect imports
+    const directImports = new Set();
+    const collectDirectImports = (groupMap) => {
+        for (const [, groupMeta] of groupMap.entries()) {
+            if (!groupMeta.isFactory) {
+                const filePath = getFileImportRelativePath(outputPath, groupMeta.sourceFile, packageMappings);
+                directImports.add(filePath);
+            }
+        }
+    };
+    collectDirectImports(httpState.routeMiddleware);
+    collectDirectImports(middlewareState.tagMiddleware);
+    if (fullState) {
+        collectDirectImports(fullState.channelMiddleware.tagMiddleware);
+    }
     const allFactories = new Map([
         ...httpFactories,
         ...tagFactories,
         ...channelMiddlewareFactories,
     ]);
+    // Add direct side-effect imports (non-factory addHTTPMiddleware / addMiddleware calls)
+    if (directImports.size > 0) {
+        serializedImports.push('/* Side-effect imports for direct middleware registration calls */');
+        for (const filePath of directImports) {
+            serializedImports.push(`import '${filePath}'`);
+        }
+    }
     if (allFactories.size > 0) {
         serializedImports.push('/* Call middleware group factories to register at module evaluation */');
         for (const [exportName, { filePath }] of allFactories) {

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

@@ -24,8 +24,30 @@ export const serializePermissionsImports = (outputPath, permissionsState, httpSt
             });
         }
     }
+    // Collect direct (non-factory) side-effect imports for HTTP permission groups
+    const directImports = new Set();
+    for (const [, groupMeta] of httpState.routePermissions.entries()) {
+        if (!groupMeta.isFactory) {
+            const filePath = getFileImportRelativePath(outputPath, groupMeta.sourceFile, packageMappings);
+            directImports.add(filePath);
+        }
+    }
+    // Collect direct (non-factory) side-effect imports for tag permission groups
+    for (const [, groupMeta] of permissionsState.tagPermissions.entries()) {
+        if (!groupMeta.isFactory) {
+            const filePath = getFileImportRelativePath(outputPath, groupMeta.sourceFile, packageMappings);
+            directImports.add(filePath);
+        }
+    }
     // Combine all factories and deduplicate by exportName (same factory might be used in multiple groups)
     const allFactories = new Map([...httpFactories, ...tagFactories]);
+    // Add direct side-effect imports (non-factory addPermission calls)
+    if (directImports.size > 0) {
+        serializedImports.push('/* Side-effect imports for direct addPermission calls */');
+        for (const filePath of directImports) {
+            serializedImports.push(`import '${filePath}'`);
+        }
+    }
     // Add factory imports and calls
     if (allFactories.size > 0) {
         serializedImports.push('/* Call permission group factories to register at module evaluation */');

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

@@ -7,7 +7,7 @@ export const pikkuPublicRPC = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
         if (config.scaffold?.rpc) {
             const pathToPikkuTypes = getFileImportRelativePath(config.publicRpcFile, config.typesDeclarationFile, config.packageMappings);
-            await writeFileInDir(logger, config.publicRpcFile, serializePublicRPC(pathToPikkuTypes, config.scaffold.rpc === 'auth'));
+            await writeFileInDir(logger, config.publicRpcFile, serializePublicRPC(pathToPikkuTypes, config.scaffold.rpc === 'auth', config.globalHTTPPrefix || ''));
             return true;
         }
         return false;

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

@@ -16,7 +16,7 @@ export const pikkuRPCClient = pikkuSessionlessFunc({
             return;
         }
         const rpcMapDeclarationPath = getFileImportRelativePath(rpcWiringsFile, rpcMapDeclarationFile, packageMappings);
-        const content = [serializeRPCWrapper(rpcMapDeclarationPath)];
+        const content = [serializeRPCWrapper(rpcMapDeclarationPath, config.globalHTTPPrefix || '')];
         await writeFileInDir(logger, rpcWiringsFile, content.join('\n'));
     },
     middleware: [

package/dist/src/functions/wirings/rpc/serialize-public-rpc.d.ts

@@ -1,4 +1,4 @@
 /**
  * Generate public RPC HTTP endpoint
  */
-export declare const serializePublicRPC: (pathToPikkuTypes: string, requireAuth?: boolean) => string;
+export declare const serializePublicRPC: (pathToPikkuTypes: string, requireAuth?: boolean, globalHTTPPrefix?: string) => string;

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

@@ -1,7 +1,7 @@
 /**
  * Generate public RPC HTTP endpoint
  */
-export const serializePublicRPC = (pathToPikkuTypes, requireAuth = true) => {
+export const serializePublicRPC = (pathToPikkuTypes, requireAuth = true, globalHTTPPrefix = '') => {
     const authFlag = requireAuth ? 'true' : 'false';
     return `/**
  * Auto-generated public RPC HTTP endpoint
@@ -25,7 +25,7 @@ export const workflowCaller = pikkuSessionlessFunc<
 >({
   auth: ${authFlag},
   func: async (_services, { workflowName, input }, { rpc }) => {
-    return await rpc.startWorkflow(workflowName, input || {})
+    return await (rpc.startWorkflow as Function)(workflowName, input || {})
   },
 })
 
@@ -34,12 +34,12 @@ export const rpcRoutes = defineHTTPRoutes({
   tags: ['pikku:public'],
   routes: {
     rpc: {
-      route: '/rpc/:rpcName',
+      route: '${globalHTTPPrefix}/rpc/:rpcName',
       method: 'post',
       func: rpcCaller,
     },
     workflow: {
-      route: '/rpc/workflow/:workflowName',
+      route: '${globalHTTPPrefix}/rpc/workflow/:workflowName',
       method: 'post',
       func: workflowCaller,
     },

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

@@ -1 +1 @@
-export declare const serializeRPCWrapper: (rpcMapPath: string) => string;
+export declare const serializeRPCWrapper: (rpcMapPath: string, globalHTTPPrefix?: string) => string;

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

@@ -1,4 +1,4 @@
-export const serializeRPCWrapper = (rpcMapPath) => {
+export const serializeRPCWrapper = (rpcMapPath, globalHTTPPrefix = '') => {
     return `
 import { PikkuFetch } from "./pikku-fetch.gen.js"
 import type { RPCInvoke, TypedAgentRun, TypedStartWorkflow } from '${rpcMapPath}'
@@ -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/\${String(rpcName)}\` as never, { rpcName: String(rpcName), data }) as any
+       return await this.pikkuFetch.post(\`${globalHTTPPrefix}/rpc/\${String(rpcName)}\` as never, { rpcName: String(rpcName), data }) as any
     }
 
     /**
@@ -71,7 +71,7 @@ export class PikkuRPC {
      * @returns A promise that resolves with the new run ID
      */
     startWorkflow: TypedStartWorkflow = async (workflowName, input) => {
-        return await this.pikkuFetch.post(\`/rpc/workflow/\${String(workflowName)}\` as never, { workflowName: String(workflowName), input }) as any
+        return await this.pikkuFetch.post(\`${globalHTTPPrefix}/rpc/workflow/\${String(workflowName)}\` as never, { workflowName: String(workflowName), input }) as any
     }
 
     /**
@@ -87,7 +87,7 @@ export class PikkuRPC {
          * @returns A promise with runId, result, and token usage
          */
         run: (async (agentName, input) => {
-            return await this.pikkuFetch.post(\`/rpc/agent/\${String(agentName)}\` as never, input) as any
+            return await this.pikkuFetch.post(\`${globalHTTPPrefix}/rpc/agent/\${String(agentName)}\` as never, input) as any
         }) as TypedAgentRun,
         /**
          * Streams agent responses via SSE. Used for real-time chat interfaces.
@@ -96,7 +96,7 @@ export class PikkuRPC {
          * @param input - The agent input (message, threadId, resourceId)
          */
         stream: async (agentName: string, input: Record<string, unknown>) => {
-            return await this.pikkuFetch.post(\`/rpc/agent/\${String(agentName)}/stream\` as never, input) as any
+            return await this.pikkuFetch.post(\`${globalHTTPPrefix}/rpc/agent/\${String(agentName)}/stream\` as never, input) as any
         },
         /**
          * Approves or denies pending tool calls for an agent run.
@@ -105,7 +105,7 @@ export class PikkuRPC {
          * @param input - The approval payload (runId, approvals array)
          */
         approve: async (agentName: string, input: Record<string, unknown>) => {
-            return await this.pikkuFetch.post(\`/rpc/agent/\${String(agentName)}/approve\` as never, input) as any
+            return await this.pikkuFetch.post(\`${globalHTTPPrefix}/rpc/agent/\${String(agentName)}/approve\` as never, input) as any
         },
     }
 }

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

@@ -16,18 +16,25 @@ import type { PikkuWorkflowWire, WorkflowStepOptions } from '@pikku/core/workflo
 
 export { WorkflowCancelledException }
 import type { PikkuFunctionSessionless, PikkuFunctionConfig } from '${functionTypesImportPath}'
-import type { RPCMap, FlattenedRPCMap } from '${rpcMapImportPath}'
+import type { FlattenedRPCMap } from '${rpcMapImportPath}'
 import type { WorkflowMap, GraphsMap } from '${workflowMapImportPath}'
 
 export { template }
 
 export interface TypedWorkflow extends PikkuWorkflowWire {
-  do<K extends keyof RPCMap>(
+  do<K extends keyof FlattenedRPCMap>(
     stepName: string,
     rpcName: K,
-    data: RPCMap[K]['input'],
+    data: FlattenedRPCMap[K]['input'],
     options?: WorkflowStepOptions
-  ): Promise<RPCMap[K]['output']>
+  ): Promise<FlattenedRPCMap[K]['output']>
+
+  do<K extends keyof WorkflowMap>(
+    stepName: string,
+    workflowName: K,
+    data: WorkflowMap[K]['input'],
+    options?: WorkflowStepOptions
+  ): Promise<WorkflowMap[K]['output']>
 
   do<T>(
     stepName: string,
@@ -36,24 +43,73 @@ export interface TypedWorkflow extends PikkuWorkflowWire {
   ): Promise<T>
 }
 
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+import type { InferSchemaOutput, PikkuPermission, PikkuMiddleware, NodeConfig, PikkuApprovalDescription } from '${functionTypesImportPath}'
+import { PikkuError } from '@pikku/core/errors'
+import type { CorePermissionGroup } from '@pikku/core'
+
 export type PikkuFunctionWorkflow<
   In = unknown,
   Out = never
 > = PikkuFunctionSessionless<In, Out, 'workflow'>
 
-export const pikkuWorkflowFunc = <In, Out = unknown>(
+export type PikkuWorkflowConfigWithSchema<
+  InputSchema extends StandardSchemaV1 | undefined = undefined,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
+> = {
+  title?: string
+  description?: string
+  tags?: string[]
+  expose?: boolean
+  internal?: boolean
+  override?: string
+  version?: number
+  remote?: boolean
+  mcp?: boolean
+  readonly?: boolean
+  approvalRequired?: boolean
+  approvalDescription?: InputSchema extends StandardSchemaV1 ? PikkuApprovalDescription<InferSchemaOutput<InputSchema>> : never
+  func: PikkuFunctionWorkflow<
+    InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown,
+    OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown
+  >
+  auth?: boolean
+  permissions?: InputSchema extends StandardSchemaV1 ? CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>> : undefined
+  middleware?: PikkuMiddleware[]
+  input?: InputSchema
+  output?: OutputSchema
+  node?: NodeConfig
+  errors?: Array<typeof PikkuError>
+  inline?: boolean
+}
+
+export function pikkuWorkflowFunc<
+  InputSchema extends StandardSchemaV1 | undefined = undefined,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
+>(
+  config: PikkuWorkflowConfigWithSchema<InputSchema, OutputSchema>
+): PikkuFunctionConfig<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'workflow', PikkuFunctionWorkflow<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown>, InputSchema, OutputSchema>
+export function pikkuWorkflowFunc<In, Out = unknown>(
   func:
     | PikkuFunctionWorkflow<In, Out>
     | PikkuFunctionConfig<In, Out, 'workflow', PikkuFunctionWorkflow<In, Out>>
-) => {
+): PikkuFunctionConfig<In, Out, 'workflow'>
+export function pikkuWorkflowFunc(func: any) {
   return typeof func === 'function' ? { func } : func
 }
 
-export const pikkuWorkflowComplexFunc = <In, Out = unknown>(
+export function pikkuWorkflowComplexFunc<
+  InputSchema extends StandardSchemaV1 | undefined = undefined,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
+>(
+  config: PikkuWorkflowConfigWithSchema<InputSchema, OutputSchema>
+): PikkuFunctionConfig<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'workflow', PikkuFunctionWorkflow<InputSchema extends StandardSchemaV1 ? InferSchemaOutput<InputSchema> : unknown, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown>, InputSchema, OutputSchema>
+export function pikkuWorkflowComplexFunc<In, Out = unknown>(
   func:
     | PikkuFunctionWorkflow<In, Out>
     | PikkuFunctionConfig<In, Out, 'workflow', PikkuFunctionWorkflow<In, Out>>
-) => {
+): PikkuFunctionConfig<In, Out, 'workflow'>
+export function pikkuWorkflowComplexFunc(func: any) {
   return typeof func === 'function' ? { func } : func
 }
 

package/dist/src/services.js

@@ -215,13 +215,16 @@ export const createSingletonServices = async (config) => {
                 }
             }
             const manifest = !setupOnly
-                ? ((await loadManifest(join(config.outDir, 'versions.json'))) ??
+                ? ((await loadManifest(join(config.rootDir, 'versions.pikku.json'))) ??
                     undefined)
                 : undefined;
+            const oldProgram = unfilteredState?.program ?? undefined;
+            const inspectStart = Date.now();
             unfilteredState = await inspect(logger, wiringFiles, {
                 setupOnly,
                 rootDir,
                 isAddon: !!config.addon,
+                oldProgram,
                 types: {
                     configFileType: config.configFile,
                     userSessionType: config.userSessionType,
@@ -248,6 +251,7 @@ export const createSingletonServices = async (config) => {
                     }
                     : undefined,
             });
+            logger.debug(`Inspector took ${Date.now() - inspectStart}ms`);
             if ('diagnostics' in unfilteredState &&
                 unfilteredState.diagnostics.length > 0) {
                 processDiagnostics(unfilteredState.diagnostics, config.lint);