@pikku/cli 0.12.15 → 0.12.16

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

@@ -8,16 +8,18 @@ export const pikkuAIAgent = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { agents, functions } = await getInspectorState();
         const { agentWiringsFile, agentWiringMetaFile, agentWiringMetaJsonFile, agentMapDeclarationFile, packageMappings, schema, addonName, } = config;
-        const lines = [];
-        const hasAgents = agents.files.size > 0;
-        if (hasAgents) {
-            lines.push(`import { addAIAgent } from '@pikku/core/ai-agent'`);
+        const agentFiles = agents.files;
+        if (agentFiles.size === 0 || Object.keys(agents.agentsMeta).length === 0) {
+            // Still need to generate an empty agent map for the types import
+            await writeFileInDir(logger, agentMapDeclarationFile, `export type AgentMap = {}\n`);
+            return undefined;
         }
+        const lines = [];
+        lines.push(`import { addAIAgent } from '@pikku/core/ai-agent'`);
         const metaImportPath = getFileImportRelativePath(agentWiringsFile, agentWiringMetaFile, packageMappings);
         if (Object.keys(agents.agentsMeta).length > 0) {
             lines.push(`import '${metaImportPath}'`);
         }
-        const agentFiles = agents.files;
         const sortedAgents = Array.from(agentFiles.entries()).sort((a, b) => a[0].localeCompare(b[0]));
         for (const [, { path, exportedName }] of sortedAgents) {
             const importPath = getFileImportRelativePath(agentWiringsFile, path, packageMappings);

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

@@ -8,6 +8,9 @@ export const pikkuChannels = pikkuVoidFunc({
         const visitState = await getInspectorState();
         const { channelsWiringFile, channelsWiringMetaFile, channelsWiringMetaJsonFile, packageMappings, schema, } = config;
         const { channels } = visitState;
+        if (channels.files.size === 0 || Object.keys(channels.meta).length === 0) {
+            return;
+        }
         await writeFileInDir(logger, channelsWiringFile, serializeFileImports('addChannel', channelsWiringFile, channels.files, packageMappings));
         await writeFileInDir(logger, channelsWiringMetaJsonFile, JSON.stringify(channels.meta, null, 2));
         const jsonImportPath = getFileImportRelativePath(channelsWiringMetaFile, channelsWiringMetaJsonFile, packageMappings);

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

@@ -9,6 +9,9 @@ export const pikkuChannels = pikkuSessionlessFunc({
         const visitState = await getInspectorState();
         const { channelsWiringFile, channelsWiringMetaFile, channelsWiringMetaJsonFile, packageMappings, schema, } = config;
         const { channels } = visitState;
+        if (channels.files.size === 0 || Object.keys(channels.meta).length === 0) {
+            return undefined;
+        }
         await writeFileInDir(logger, channelsWiringFile, serializeFileImports('addChannel', channelsWiringFile, channels.files, packageMappings));
         // Write minimal JSON (runtime-only fields)
         const minimalMeta = stripVerboseFields(channels.meta);

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

@@ -9,6 +9,9 @@ export const pikkuCLI = pikkuSessionlessFunc({
         const visitState = await getInspectorState();
         const { cliWiringsFile, cliWiringMetaFile, cliWiringMetaJsonFile, packageMappings, schema, } = config;
         const { cli } = visitState;
+        if (cli.files.size === 0 || Object.keys(cli.meta).length === 0) {
+            return undefined;
+        }
         // Generate CLI wirings file
         await writeFileInDir(logger, cliWiringsFile, serializeFileImports('wireCLI', cliWiringsFile, cli.files, packageMappings));
         // Write minimal JSON (runtime-only fields)

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

@@ -48,7 +48,7 @@ export function serializeChannelCLI(programName, programMeta, channelFile, funct
  * WebSocket channel backend for '${programName}' CLI commands
  */
 import { wireChannel } from '${channelTypesPath}'
-import { pikkuMiddleware${hasAddonFuncs ? ', addon' : ''}, pikkuSessionlessFunc } from '${functionTypesPath}'
+import { pikkuMiddleware${hasAddonFuncs ? ', ref' : ''}, pikkuSessionlessFunc } from '${functionTypesPath}'
 import { generateCommandHelp } from '@pikku/core/cli'
 import { handleRawCLI } from '@pikku/core/cli/channel'
 import { pikkuState } from '@pikku/core/internal'
@@ -115,7 +115,7 @@ wireChannel({
 ${Object.entries(commandMap)
         .map(([commandKey, { pikkuFuncId, isAddon }]) => {
         const funcRef = isAddon
-            ? `addon('${pikkuFuncId}')`
+            ? `ref('${pikkuFuncId}')`
             : (functionFiles.get(pikkuFuncId)?.exportedName ?? pikkuFuncId);
         return `      '${commandKey}': {
         func: ${funcRef},

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

@@ -1,5 +1,5 @@
 export const serializeConsoleFunctions = (pathToPikkuTypes, _pathToAgentTypes, globalHTTPPrefix = '') => {
-    return `import { pikkuSessionlessFunc, defineHTTPRoutes, wireHTTPRoutes, addon, wireAddon } from '${pathToPikkuTypes}'
+    return `import { pikkuSessionlessFunc, defineHTTPRoutes, wireHTTPRoutes, ref, wireAddon } from '${pathToPikkuTypes}'
 
 export const pikkuConsoleSetSecret = pikkuSessionlessFunc<{
   secretId: string
@@ -92,7 +92,7 @@ export const consoleRoutes = defineHTTPRoutes({
       route: '/workflow-run/:runId/stream',
       method: 'get',
       sse: true,
-      func: addon('console:streamWorkflowRun'),
+      func: ref('console:streamWorkflowRun'),
     },
   },
 })

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

@@ -1,2 +1,2 @@
-export declare const serializeServicesMap: (allSingletonServices: string[], allWireServices: string[], requiredServices: Set<string>, forceRequiredServices: string[] | undefined, servicesImport: string, wireServicesImport: string) => string;
+export declare const serializeServicesMap: (allSingletonServices: string[], allWireServices: string[], requiredServices: Set<string>, forceRequiredServices: string[] | undefined, servicesImport: string, wireServicesImport: string, addonRequiredParentServices?: string[]) => string;
 export declare const pikkuServices: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

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

@@ -3,7 +3,7 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { checkRequiredTypes } from '../../../utils/check-required-types.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
-export const serializeServicesMap = (allSingletonServices, allWireServices, requiredServices, forceRequiredServices = [], servicesImport, wireServicesImport) => {
+export const serializeServicesMap = (allSingletonServices, allWireServices, requiredServices, forceRequiredServices = [], servicesImport, wireServicesImport, addonRequiredParentServices = []) => {
     // Use pre-aggregated services from inspector state
     // This includes services from:
     // - Wired functions (HTTP, channels, queues, schedulers, MCP, CLI, RPC)
@@ -79,6 +79,13 @@ export const serializeServicesMap = (allSingletonServices, allWireServices, requ
             ? `export type RequiredWireServices = Pick<Services, ${requiredWireServiceNames.map((key) => `'${key}'`).join(' | ')}> & Partial<Omit<Services, ${requiredWireServiceNames.map((key) => `'${key}'`).join(' | ')}>>`
             : 'export type RequiredWireServices = Partial<Services>',
         '',
+        ...(addonRequiredParentServices.length > 0
+            ? [
+                '// Services this addon needs from the parent project',
+                `export const requiredParentServices = ${JSON.stringify(addonRequiredParentServices)} as const`,
+                '',
+            ]
+            : []),
     ].join('\n');
     return code;
 };
@@ -96,7 +103,7 @@ export const pikkuServices = pikkuSessionlessFunc({
         }
         const servicesImport = `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, singletonServicesType.typePath, config.packageMappings)}'`;
         const wireServicesImport = `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(config.typesDeclarationFile, wireServicesType.typePath, config.packageMappings)}'`;
-        const servicesCode = serializeServicesMap(visitState.serviceAggregation.allSingletonServices, visitState.serviceAggregation.allWireServices, visitState.serviceAggregation.requiredServices, config.forceRequiredServices, servicesImport, wireServicesImport);
+        const servicesCode = serializeServicesMap(visitState.serviceAggregation.allSingletonServices, visitState.serviceAggregation.allWireServices, visitState.serviceAggregation.requiredServices, config.forceRequiredServices, servicesImport, wireServicesImport, config.addonName ? visitState.addonRequiredParentServices : []);
         await writeFileInDir(logger, config.servicesFile, servicesCode);
     },
     middleware: [

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

@@ -4,11 +4,13 @@ export const serializeFunctionImports = (outputPath, functionsMap, functionsMeta
 addonName) => {
     const serializedImports = [
         `/* Import and register functions used by RPCs */`,
-        `import { addFunction } from '@pikku/core'`,
+        `import { addFunction } from '@pikku/core/function'`,
     ];
     const serializedRegistrations = [];
-    // Sort by function name for consistent output
-    const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+    // Sort by function name for consistent output, only include functions in meta
+    const sortedEntries = Array.from(functionsMap.entries())
+        .filter(([name]) => name in functionsMeta)
+        .sort((a, b) => a[0].localeCompare(b[0]));
     // Third argument to addFunction is the package name (null for main package)
     const packageArg = addonName ? `, '${addonName}'` : '';
     const usedAliases = new Set();

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

@@ -12,9 +12,11 @@ export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeNam
  * Core function, middleware, and permission types for all wirings
  */
 
-import { CorePikkuFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired } from '@pikku/core'
+import type { CorePikkuMiddleware, CorePermissionGroup, PikkuWire, PickRequired } from '@pikku/core'
+import type { CorePikkuFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission } from '@pikku/core/function'
+import { pikkuAuth as pikkuAuthCore } from '@pikku/core/function'
+import { addMiddleware as addMiddlewareCore, addPermission as addPermissionCore } from '@pikku/core/middleware'
 import { pikkuState as __pikkuState, CreateWireServices } from '@pikku/core/internal'
-import { pikkuAuth as pikkuAuthCore } from '@pikku/core'
 import { PikkuError } from '@pikku/core/errors'
 import type { NodeType } from '@pikku/core/node'
 import type { StandardSchemaV1 } from '@standard-schema/spec'
@@ -519,27 +521,23 @@ export const pikkuVoidFunc = (
 }
 
 /**
- * Creates a wrapper function for addon package functions that are exposed via RPC.
- * This allows you to wire addon functions to any wiring type (HTTP, queue, etc.)
- * without type compatibility issues.
+ * References a registered function by name for use in any wiring.
+ * Works for both local and addon functions — resolves via RPC at runtime.
  *
- * @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 addon RPC method
+ * @template Name - The function name (must be a key in FlattenedRPCMap)
+ * @param rpcName - The name of the function to reference
+ * @returns A Pikku function config that proxies calls via RPC
  *
  * @example
  * \`\`\`typescript
- * // Wire an addon function via HTTP
- * wireHTTP({
- *   auth: false,
- *   method: 'get',
- *   route: '/addon/hello',
- *   func: addon('ext:hello'),
- *   tags: ['addon'],
- * })
+ * // Use in agent tools
+ * tools: [ref('todos:listTodos'), ref('myLocalFunc')]
+ *
+ * // Use in HTTP wiring
+ * wireHTTP({ route: '/greet', method: 'post', func: ref('greet') })
  * \`\`\`
  */
-export const addon = <Name extends keyof FlattenedRPCMap>(
+export const ref = <Name extends keyof FlattenedRPCMap>(
   rpcName: Name
 ): PikkuFunctionConfig<
   FlattenedRPCMap[Name]['input'],
@@ -689,7 +687,7 @@ export const addPermission = <In = unknown>(tag: string, permissions: CorePermis
   addPermissionCore(tag, permissions as any, ${packageNameValue})
 }
 
-export { wireAddon } from '@pikku/core'
-export type { WireAddonConfig } from '@pikku/core'
+export { wireAddon } from '@pikku/core/rpc'
+export type { WireAddonConfig } from '@pikku/core/rpc'
 `;
 };

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

@@ -9,6 +9,9 @@ export const pikkuHTTP = pikkuSessionlessFunc({
         const visitState = await getInspectorState();
         const { httpWiringsFile, httpWiringMetaFile, httpWiringMetaJsonFile, packageMappings, schema, } = config;
         const { http } = visitState;
+        if (http.files.size === 0 || Object.keys(http.meta).length === 0) {
+            return undefined;
+        }
         await writeFileInDir(logger, httpWiringsFile, serializeFileImports('wireHTTP', httpWiringsFile, http.files, packageMappings));
         // Write minimal JSON (runtime-only fields)
         const minimalMeta = stripVerboseFields(http.meta);

package/dist/src/functions/wirings/http/pikku-http-routes.js

@@ -8,6 +8,9 @@ export const pikkuHTTP = pikkuSessionlessFunc({
         const visitState = await getInspectorState();
         const { httpWiringsFile, httpWiringMetaFile, httpWiringMetaJsonFile, packageMappings, schema, } = config;
         const { http } = visitState;
+        if (http.files.size === 0 || Object.keys(http.meta).length === 0) {
+            return false;
+        }
         await writeFileInDir(logger, httpWiringsFile, serializeFileImports('wireHTTP', httpWiringsFile, http.files, packageMappings));
         await writeFileInDir(logger, httpWiringMetaJsonFile, JSON.stringify(http.meta, null, 2));
         const jsonImportPath = getFileImportRelativePath(httpWiringMetaFile, httpWiringMetaJsonFile, packageMappings);

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

@@ -53,6 +53,12 @@ export const pikkuMCP = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { mcpEndpoints, functions } = await getInspectorState();
         const { mcpWiringsFile, mcpWiringsMetaFile, packageMappings, schemaDirectory, schema, } = config;
+        const hasMcpContent = Object.keys(mcpEndpoints.toolsMeta).length > 0 ||
+            Object.keys(mcpEndpoints.resourcesMeta).length > 0 ||
+            Object.keys(mcpEndpoints.promptsMeta).length > 0;
+        if (mcpEndpoints.files.size === 0 || !hasMcpContent) {
+            return undefined;
+        }
         await writeFileInDir(logger, mcpWiringsFile, serializeFileImports('wireMCPResource', mcpWiringsFile, mcpEndpoints.files, packageMappings));
         // Populate arguments for prompts meta before serializing
         const promptsMetaWithArguments = { ...mcpEndpoints.promptsMeta };

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

@@ -50,7 +50,7 @@ export const pikkuPackage = pikkuSessionlessFunc({
                 file: wireServicesFactory.file,
                 variable: wireServicesFactory.variable,
             }
-            : undefined, packageMappings, Object.keys(credentialsMeta).length > 0 ? credentialsMeta : undefined);
+            : undefined, packageMappings, Object.keys(credentialsMeta).length > 0 ? credentialsMeta : undefined, state.addonRequiredParentServices);
         if (!content) {
             logger.info({
                 message: 'Skipping package factories - no service factories found',

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

@@ -8,4 +8,4 @@ export interface CredentialMetaForPackage {
     type: 'singleton' | 'wire';
     oauth2?: boolean;
 }
-export declare const serializePackageFactories: (outputPath: string, packageName: string, configFactory: PackageFactoryInfo | undefined, singletonServicesFactory: PackageFactoryInfo | undefined, wireServicesFactory: PackageFactoryInfo | undefined, packageMappings?: Record<string, string>, credentialsMeta?: Record<string, CredentialMetaForPackage>) => string | null;
+export declare const serializePackageFactories: (outputPath: string, packageName: string, configFactory: PackageFactoryInfo | undefined, singletonServicesFactory: PackageFactoryInfo | undefined, wireServicesFactory: PackageFactoryInfo | undefined, packageMappings?: Record<string, string>, credentialsMeta?: Record<string, CredentialMetaForPackage>, requiredParentServices?: string[]) => string | null;

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

@@ -1,5 +1,5 @@
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
-export const serializePackageFactories = (outputPath, packageName, configFactory, singletonServicesFactory, wireServicesFactory, packageMappings = {}, credentialsMeta) => {
+export const serializePackageFactories = (outputPath, packageName, configFactory, singletonServicesFactory, wireServicesFactory, packageMappings = {}, credentialsMeta, requiredParentServices) => {
     const imports = [
         `import { pikkuState } from '@pikku/core/internal'`,
     ];
@@ -26,10 +26,13 @@ export const serializePackageFactories = (outputPath, packageName, configFactory
     const credentialsLine = credentialsMeta && Object.keys(credentialsMeta).length > 0
         ? `\npikkuState('${packageName}', 'package', 'credentialsMeta', ${JSON.stringify(credentialsMeta)})\n`
         : '';
+    const requiredParentServicesLine = requiredParentServices && requiredParentServices.length > 0
+        ? `\npikkuState('${packageName}', 'package', 'requiredParentServices', ${JSON.stringify(requiredParentServices)})\n`
+        : '';
     return `${imports.join('\n')}
 
 pikkuState('${packageName}', 'package', 'factories', {
 ${factoryEntries.join('\n')}
 })
-${credentialsLine}`;
+${credentialsLine}${requiredParentServicesLine}`;
 };

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

@@ -10,6 +10,10 @@ export const pikkuQueue = pikkuSessionlessFunc({
         const visitState = await getInspectorState();
         const { queueWorkersWiringFile, queueWorkersWiringMetaFile, queueWorkersWiringMetaJsonFile, packageMappings, schema, } = config;
         const { queueWorkers } = visitState;
+        if (queueWorkers.files.size === 0 ||
+            Object.keys(queueWorkers.meta).length === 0) {
+            return undefined;
+        }
         const fullMeta = serializeQueueMeta(queueWorkers.meta);
         // Write minimal JSON file (runtime-only fields)
         const minimalMeta = stripVerboseFields(fullMeta);

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

@@ -9,6 +9,10 @@ export const pikkuQueue = pikkuSessionlessFunc({
         const visitState = await getInspectorState();
         const { queueWorkersWiringFile, queueWorkersWiringMetaFile, queueWorkersWiringMetaJsonFile, packageMappings, schema, } = config;
         const { queueWorkers } = visitState;
+        if (queueWorkers.files.size === 0 ||
+            Object.keys(queueWorkers.meta).length === 0) {
+            return false;
+        }
         // Write JSON file
         await writeFileInDir(logger, queueWorkersWiringMetaJsonFile, JSON.stringify(serializeQueueMeta(queueWorkers.meta), null, 2));
         // Calculate relative path from TS file to JSON file

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

@@ -50,7 +50,10 @@ function generateQueues(queueWorkersMeta, resolvedIOTypes, requiredTypes) {
     for (const [queueName, { pikkuFuncId }] of Object.entries(queueWorkersMeta)) {
         const resolved = resolvedIOTypes[pikkuFuncId];
         if (!resolved) {
-            throw new Error(`Function ${pikkuFuncId} not found in resolvedIOTypes. Please check your configuration.`);
+            // Synthetic workflow queue workers (pikkuWorkflowWorker:*, pikkuWorkflowOrchestrator:*)
+            // don't have resolved types — use null for their queue map entries
+            queuesObj[queueName] = { inputType: 'null', outputType: 'null' };
+            continue;
         }
         requiredTypes.add(resolved.inputType);
         requiredTypes.add(resolved.outputType);

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

@@ -4,10 +4,17 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const pikkuRPC = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { rpc } = await getInspectorState();
+        const { rpc, functions } = await getInspectorState();
         const { rpcInternalWiringMetaFile, rpcInternalWiringMetaJsonFile, packageMappings, schema, } = config;
-        if (rpc.internalFiles.size > 0) {
-            await writeFileInDir(logger, rpcInternalWiringMetaJsonFile, JSON.stringify(rpc.internalMeta, null, 2));
+        // Filter internal RPC meta to only include functions in the filtered meta
+        const filteredInternalMeta = {};
+        for (const [key, value] of Object.entries(rpc.internalMeta)) {
+            if (key in functions.meta) {
+                filteredInternalMeta[key] = value;
+            }
+        }
+        if (Object.keys(filteredInternalMeta).length > 0) {
+            await writeFileInDir(logger, rpcInternalWiringMetaJsonFile, JSON.stringify(filteredInternalMeta, null, 2));
             const jsonImportPath = getFileImportRelativePath(rpcInternalWiringMetaFile, rpcInternalWiringMetaJsonFile, packageMappings);
             const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
             const importStatement = supportsImportAttributes

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

@@ -7,7 +7,7 @@ export const serializePublicRPC = (pathToPikkuTypes, requireAuth = true, globalH
  * Auto-generated public RPC HTTP endpoint
  * Do not edit manually - regenerate with 'npx pikku'
  */
-import { pikkuSessionlessFunc, defineHTTPRoutes, wireHTTPRoutes } from '${pathToPikkuTypes}'
+import { pikkuSessionlessFunc, wireHTTP } from '${pathToPikkuTypes}'
 
 export const rpcCaller = pikkuSessionlessFunc<
   { rpcName: string; data?: unknown },
@@ -19,33 +19,11 @@ export const rpcCaller = pikkuSessionlessFunc<
   },
 })
 
-export const workflowCaller = pikkuSessionlessFunc<
-  { workflowName: string; input?: unknown },
-  { runId: string }
->({
+wireHTTP({
+  route: '${globalHTTPPrefix}/rpc/:rpcName',
+  method: 'post',
   auth: ${authFlag},
-  func: async (_services, { workflowName, input }, { rpc }) => {
-    return await (rpc.startWorkflow as Function)(workflowName, input || {})
-  },
+  func: rpcCaller,
 })
-
-export const rpcRoutes = defineHTTPRoutes({
-  auth: ${authFlag},
-  tags: ['pikku:public'],
-  routes: {
-    rpc: {
-      route: '${globalHTTPPrefix}/rpc/:rpcName',
-      method: 'post',
-      func: rpcCaller,
-    },
-    workflow: {
-      route: '${globalHTTPPrefix}/rpc/workflow/:workflowName',
-      method: 'post',
-      func: workflowCaller,
-    },
-  },
-})
-
-wireHTTPRoutes({ routes: { rpc: rpcRoutes } })
 `;
 };

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

@@ -6,18 +6,12 @@ export const serializeRemoteRPC = (pathToPikkuTypes) => {
  * Auto-generated remote internal RPC queue worker and HTTP endpoint
  * Do not edit manually - regenerate with 'npx pikku'
  */
-import { pikkuSessionlessFunc, wireQueueWorker } from '${pathToPikkuTypes}'
+import { pikkuSessionlessFunc, wireHTTP } from '${pathToPikkuTypes}'
+import { pikkuRemoteAuthMiddleware } from '@pikku/core/middleware'
 
-/**
- * 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 },
-  any
+export const remoteRPCHandler = pikkuSessionlessFunc<
+  { rpcName: string, data?: unknown },
+  unknown
 >({
   func: async (_services, { rpcName, data }, { rpc }) => {
     return await (rpc.invoke as any)(rpcName, data)
@@ -25,9 +19,12 @@ export const pikkuRemoteInternalRPC = pikkuSessionlessFunc<
   remote: true,
 })
 
-wireQueueWorker({
-  name: 'pikku-remote-internal-rpc',
-  func: pikkuRemoteInternalRPC,
+wireHTTP({
+  route: '/remote/rpc/:rpcName',
+  method: 'post',
+  auth: false,
+  middleware: [pikkuRemoteAuthMiddleware],
+  func: remoteRPCHandler,
 })
 `;
 };

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

@@ -1,7 +1,8 @@
 export const serializeRPCWrapper = (rpcMapPath, globalHTTPPrefix = '') => {
     return `
 import { PikkuFetch } from "./pikku-fetch.gen.js"
-import type { RPCInvoke, TypedAgentRun, TypedStartWorkflow } from '${rpcMapPath}'
+import type { RPCInvoke, TypedAgentRun, TypedStartWorkflow, TypedRunWorkflow, TypedWorkflowStatus } from '${rpcMapPath}'
+import type { WorkflowRunStatus } from '@pikku/core/workflow'
 
 /**
  * PikkuRPC provides a type-safe client for making Remote Procedure Calls (RPC)
@@ -64,14 +65,38 @@ export class PikkuRPC {
 
     /**
      * Starts a workflow by name with the given input.
-     * Posts to \\\`/rpc/workflow/:workflowName\\\`.
+     * Posts to \\\`/workflow/:workflowName/start\\\`.
      *
      * @param workflowName - The registered workflow name
      * @param input - The workflow input data
      * @returns A promise that resolves with the new run ID
      */
     startWorkflow: TypedStartWorkflow = async (workflowName, input) => {
-        return await this.pikkuFetch.post(\`${globalHTTPPrefix}/rpc/workflow/\${String(workflowName)}\` as never, { workflowName: String(workflowName), input }) as any
+        return await this.pikkuFetch.post(\`${globalHTTPPrefix}/workflow/\${String(workflowName)}/start\` as never, { data: input }) as any
+    }
+
+    /**
+     * Runs a workflow to completion and returns the output.
+     * Posts to \\\`/workflow/:workflowName/run\\\`.
+     *
+     * @param workflowName - The registered workflow name
+     * @param input - The workflow input data
+     * @returns A promise that resolves with the workflow output
+     */
+    runWorkflow: TypedRunWorkflow = async (workflowName, input) => {
+        return await this.pikkuFetch.post(\`${globalHTTPPrefix}/workflow/\${String(workflowName)}/run\` as never, { data: input }) as any
+    }
+
+    /**
+     * Gets the current status of a workflow run.
+     * GET \\\`/workflow/:workflowName/status/:runId\\\`.
+     *
+     * @param workflowName - The registered workflow name
+     * @param runId - The workflow run ID
+     * @returns A promise with the minimal run status
+     */
+    workflowStatus: TypedWorkflowStatus = async (workflowName, runId) => {
+        return await this.pikkuFetch.get(\`${globalHTTPPrefix}/workflow/\${String(workflowName)}/status/\${runId}\` as never) as unknown as WorkflowRunStatus
     }
 
     /**

package/dist/src/functions/wirings/rpc/serialize-typed-rpc-map.js

@@ -50,7 +50,7 @@ export type RPCRemote = <Name extends keyof FlattenedRPCMap>(
   data: FlattenedRPCMap[Name]['input']
 ) => Promise<FlattenedRPCMap[Name]['output']>
 
-${workflowMapPath ? `import type { WorkflowMap } from '${workflowMapPath}'` : `type WorkflowMap = {}`}
+${workflowMapPath ? `import type { FlattenedWorkflowMap } from '${workflowMapPath}'` : `type FlattenedWorkflowMap = {}`}
 
 ${agentMapPath ? `import type { AgentMap } from '${agentMapPath}'` : `type AgentMap = {}`}
 ${generateAddonAgentImports(wireAddonDeclarations)}
@@ -64,12 +64,22 @@ interface AIAgentInput {
   resourceId: string
 }
 
-export type TypedStartWorkflow = <Name extends keyof WorkflowMap>(
+export type TypedStartWorkflow = <Name extends keyof FlattenedWorkflowMap>(
   name: Name,
-  input: WorkflowMap[Name]['input'],
+  input: FlattenedWorkflowMap[Name]['input'],
   options?: { startNode?: string }
 ) => Promise<{ runId: string }>
 
+export type TypedRunWorkflow = <Name extends keyof FlattenedWorkflowMap>(
+  name: Name,
+  input: FlattenedWorkflowMap[Name]['input']
+) => Promise<FlattenedWorkflowMap[Name]['output']>
+
+export type TypedWorkflowStatus = (
+  workflowName: string,
+  runId: string
+) => Promise<{ id: string; status: 'running' | 'suspended' | 'completed' | 'failed' | 'cancelled'; output?: unknown; error?: { message?: string } }>
+
 type TypedAgentRun = [keyof FlattenedAgentMap] extends [never]
   ? (name: string, input: AIAgentInput) => Promise<any>
   : <Name extends keyof FlattenedAgentMap>(
@@ -109,8 +119,8 @@ 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> = {
+// Utility type to prefix keys with namespace (skips 'any' to prevent type poisoning)
+type PrefixKeys<T, Prefix extends string> = unknown extends T ? {} : {
   [K in keyof T as \`\${Prefix}:\${string & K}\`]: T[K]
 }
 

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

@@ -10,6 +10,10 @@ export const pikkuScheduler = pikkuSessionlessFunc({
         const visitState = await getInspectorState();
         const { schedulersWiringFile, schedulersWiringMetaFile, schedulersWiringMetaJsonFile, packageMappings, schema, } = config;
         const { scheduledTasks } = visitState;
+        if (scheduledTasks.files.size === 0 ||
+            Object.keys(scheduledTasks.meta).length === 0) {
+            return undefined;
+        }
         const fullMeta = serializeSchedulerMeta(scheduledTasks.meta);
         // Write minimal JSON (runtime-only fields)
         const minimalMeta = stripVerboseFields(fullMeta);

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

@@ -0,0 +1 @@
+export declare const pikkuWorkflowRoutes: import("#pikku").PikkuFunctionConfig<void, boolean, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

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

@@ -0,0 +1,21 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeWorkflowRoutes } from './serialize-workflow-routes.js';
+export const pikkuWorkflowRoutes = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        if (config.workflowRoutesFile) {
+            const pathToPikkuTypes = getFileImportRelativePath(config.workflowRoutesFile, config.typesDeclarationFile, config.packageMappings);
+            await writeFileInDir(logger, config.workflowRoutesFile, serializeWorkflowRoutes(pathToPikkuTypes, config.scaffold?.workflow === 'auth'));
+            return true;
+        }
+        return false;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating Workflow Routes',
+            commandEnd: 'Generated Workflow Routes',
+        }),
+    ],
+});

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

@@ -6,18 +6,23 @@ import { serializeWorkflowTypes } from './serialize-workflow-types.js';
 import { serializeWorkflowRegistration } from './serialize-workflow-registration.js';
 import { serializeWorkflowMap } from './serialize-workflow-map.js';
 import { serializeWorkflowMeta } from './serialize-workflow-meta.js';
-import { serializeWorkflowWorkers } from './serialize-workflow-workers.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 import { join } from 'path';
 export const pikkuWorkflow = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const { workflowsWiringFile, workflowsWiringMetaFile, workflowMetaDir, workflowMapDeclarationFile, workflowTypesFile, functionTypesFile, typesDeclarationFile, packageMappings, schema, } = config;
+        const { workflowsWiringFile, workflowsWiringMetaFile, workflowMetaDir, workflowMapDeclarationFile, workflowTypesFile, functionTypesFile, packageMappings, schema, } = config;
         const { workflows, functions: functionState } = visitState;
         const { typesMap } = functionState;
-        const allWorkflowNames = Object.keys(workflows.graphMeta);
-        const hasWorkflows = allWorkflowNames.length > 0;
+        const allWorkflowNames = [
+            ...new Set([
+                ...Object.keys(workflows.graphMeta),
+                ...Object.keys(workflows.meta),
+            ]),
+        ];
+        const hasRelevantWorkflows = allWorkflowNames.length > 0;
+        const hasWorkflows = hasRelevantWorkflows;
         if (hasWorkflows) {
             const hasWorkflowState = visitState.serviceAggregation.allSingletonServices.includes('workflowService');
             if (!hasWorkflowState) {
@@ -45,11 +50,7 @@ export const pikkuWorkflow = pikkuSessionlessFunc({
         const rpcMapImportPath = getFileImportRelativePath(workflowTypesFile, config.rpcInternalMapDeclarationFile, packageMappings);
         const workflowMapImportPath = getFileImportRelativePath(workflowTypesFile, workflowMapDeclarationFile, packageMappings);
         await writeFileInDir(logger, workflowTypesFile, serializeWorkflowTypes(functionTypesImportPath, rpcMapImportPath, workflowMapImportPath));
-        await writeFileInDir(logger, workflowMapDeclarationFile, serializeWorkflowMap(logger, workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta, workflows.graphMeta));
-        if (config.scaffold?.workflow) {
-            const pathToPikkuTypes = getFileImportRelativePath(config.workflowWorkersFile, typesDeclarationFile, packageMappings);
-            await writeFileInDir(logger, config.workflowWorkersFile, serializeWorkflowWorkers(pathToPikkuTypes));
-        }
+        await writeFileInDir(logger, workflowMapDeclarationFile, serializeWorkflowMap(logger, workflowMapDeclarationFile, packageMappings, typesMap, functionState.meta, workflows.meta, workflows.graphMeta, visitState.rpc?.wireAddonDeclarations));
         return hasWorkflows;
     },
     middleware: [