@pikku/cli 0.12.0 → 0.12.2

package/dist/src/functions/wirings/functions/{serialize-external-types.js → serialize-addon-types.js}

@@ -1,8 +1,9 @@
-export const serializeExternalTypes = (singletonServicesTypeImport, singletonServicesTypeName, configTypeImport, requiredServicesTypeImport, typedSecretServiceImport, typedVariablesServiceImport) => {
+export const serializeAddonTypes = (singletonServicesTypeImport, singletonServicesTypeName, configTypeImport, requiredServicesTypeImport, typedSecretServiceImport, typedVariablesServiceImport) => {
     return `/**
- * External package types for pikkuExternalConfig and pikkuExternalServices
+ * Addon package types for pikkuAddonConfig and pikkuAddonServices
  */
 
+import type { CreateConfig } from '@pikku/core'
 ${singletonServicesTypeImport}
 ${configTypeImport}
 ${requiredServicesTypeImport}
@@ -13,40 +14,40 @@ ${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices =
 ${configTypeImport.includes('Config type not found') ? 'type Config = any' : ''}
 
 /**
- * Base services provided to external package service factories.
+ * Base services provided to addon package service factories.
  * These are always available from the parent application.
  */
-export type ExternalBaseServices = {
+export type AddonBaseServices = {
   logger: SingletonServices['logger']
   variables: TypedVariablesService
   secrets: TypedSecretService
 }
 
 /**
- * Creates a Pikku config factory for external packages.
- * Unlike pikkuConfig, this receives ExternalBaseServices (logger, variables, secrets)
- * from the parent application, so external packages can read variables/secrets during config creation.
+ * Creates a Pikku config factory for addon packages.
+ * Unlike pikkuConfig, this receives AddonBaseServices (logger, variables, secrets)
+ * from the parent application, so addon packages can read variables/secrets during config creation.
  */
-export const pikkuExternalConfig = <ExistingServices extends Omit<Partial<SingletonServices>, 'variables' | 'secrets'> & ExternalBaseServices>(
+export const pikkuAddonConfig = <ExistingServices extends Omit<Partial<SingletonServices>, 'variables' | 'secrets'> & AddonBaseServices>(
   func: (services: ExistingServices) => Promise<Config>
-) => {
-  return async (_variables: any, existingServices?: Partial<SingletonServices>): Promise<Config> => {
+): CreateConfig<Config> => {
+  return (async (_variables: any, existingServices?: Partial<SingletonServices>): Promise<Config> => {
     const { secrets, variables, ...rest } = (existingServices ?? {}) as unknown as SingletonServices
     return func({ ...rest, secrets: new TypedSecretService(secrets), variables: new TypedVariablesService(variables) } as ExistingServices)
-  }
+  }) as unknown as CreateConfig<Config>
 }
 
 /**
- * Creates a Pikku singleton services factory for external packages.
+ * Creates a Pikku singleton services factory for addon packages.
  * Unlike pikkuServices, this expects the parent application to provide
  * logger, variables, and secrets - no fallbacks needed.
  *
- * @param func - External services factory function that receives config and base services
+ * @param func - Addon services factory function that receives config and base services
  * @returns The singleton services factory function
  *
  * @example
  * \`\`\`typescript
- * export const createSingletonServices = pikkuExternalServices(async (
+ * export const createSingletonServices = pikkuAddonServices(async (
  *   config,
  *   { secrets }
  * ) => {
@@ -56,7 +57,7 @@ export const pikkuExternalConfig = <ExistingServices extends Omit<Partial<Single
  * })
  * \`\`\`
  */
-export const pikkuExternalServices = <T extends Record<string, any>, ExistingServices extends Omit<Partial<SingletonServices>, 'variables' | 'secrets'> & ExternalBaseServices>(
+export const pikkuAddonServices = <T extends Record<string, any>, ExistingServices extends Omit<Partial<SingletonServices>, 'variables' | 'secrets'> & AddonBaseServices>(
   func: (config: Config, services: ExistingServices) => Promise<T>
 ) => {
   return async (config: Config, existingServices?: Partial<SingletonServices>): Promise<RequiredSingletonServices> => {

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

@@ -1,7 +1,7 @@
-import { FunctionsMeta } from '@pikku/core';
+import type { FunctionsMeta } from '@pikku/core';
 export declare const serializeFunctionImports: (outputPath: string, functionsMap: Map<string, {
     path: string;
     exportedName: string;
 }>, functionsMeta: FunctionsMeta, packageMappings?: Record<string, string>, 
-/** Package name for external packages (e.g., '@pikku/templates-function-external') */
-externalPackageName?: string) => string;
+/** Package name for addon packages (e.g., '@pikku/templates-function-addon') */
+addonName?: string) => string;

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

@@ -1,7 +1,7 @@
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const serializeFunctionImports = (outputPath, functionsMap, functionsMeta, packageMappings = {}, 
-/** Package name for external packages (e.g., '@pikku/templates-function-external') */
-externalPackageName) => {
+/** Package name for addon packages (e.g., '@pikku/templates-function-addon') */
+addonName) => {
     const serializedImports = [
         `/* Import and register functions used by RPCs */`,
         `import { addFunction } from '@pikku/core'`,
@@ -10,7 +10,7 @@ externalPackageName) => {
     // Sort by function name for consistent output
     const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) => a[0].localeCompare(b[0]));
     // Third argument to addFunction is the package name (null for main package)
-    const packageArg = externalPackageName ? `, '${externalPackageName}'` : '';
+    const packageArg = addonName ? `, '${addonName}'` : '';
     const usedAliases = new Set();
     for (const [name, { path, exportedName }] of sortedEntries) {
         const filePath = getFileImportRelativePath(outputPath, path, packageMappings);

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

@@ -12,7 +12,8 @@ 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, CreateWireServices } from '@pikku/core'
+import { CorePikkuFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired } from '@pikku/core'
+import { pikkuState as __pikkuState, CreateWireServices } from '@pikku/core/internal'
 import { pikkuAuth as pikkuAuthCore } from '@pikku/core'
 import type { NodeType } from '@pikku/core/node'
 import type { StandardSchemaV1 } from '@standard-schema/spec'
@@ -480,27 +481,27 @@ export const pikkuVoidFunc = (
 }
 
 /**
- * Creates a wrapper function for external package functions that are exposed via RPC.
- * This allows you to wire external functions to any wiring type (HTTP, queue, etc.)
+ * 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.
  *
  * @template Name - The RPC method name (must be a key in FlattenedRPCMap)
  * @param rpcName - The name of the RPC method to invoke
- * @returns A Pikku function that proxies calls to the external RPC method
+ * @returns A Pikku function that proxies calls to the addon RPC method
  *
  * @example
  * \`\`\`typescript
- * // Wire an external function via HTTP
+ * // Wire an addon function via HTTP
  * wireHTTP({
  *   auth: false,
  *   method: 'get',
- *   route: '/external/hello',
- *   func: external('ext:hello'),
- *   tags: ['external'],
+ *   route: '/addon/hello',
+ *   func: addon('ext:hello'),
+ *   tags: ['addon'],
  * })
  * \`\`\`
  */
-export const external = <Name extends keyof FlattenedRPCMap>(
+export const addon = <Name extends keyof FlattenedRPCMap>(
   rpcName: Name
 ): PikkuFunctionConfig<
   FlattenedRPCMap[Name]['input'],
@@ -508,9 +509,9 @@ export const external = <Name extends keyof FlattenedRPCMap>(
   'session' | 'rpc'
 > => {
   return {
-    func: (async (_services: any, data: any, { rpc }: any) => {
+    func: async (_services: any, data: FlattenedRPCMap[Name]['input'], { rpc }: any) => {
       return rpc.invoke(rpcName, data)
-    }) as any
+    }
   } as PikkuFunctionConfig<
     FlattenedRPCMap[Name]['input'],
     FlattenedRPCMap[Name]['output'],
@@ -559,8 +560,14 @@ export const pikkuConfig = (
  * \`\`\`
  */
 export const pikkuServices = (
-  func: (config: Config, existingServices?: Partial<SingletonServices>) => Promise<RequiredSingletonServices>
-) => func
+  func: (config: Config, existingServices: Partial<SingletonServices>) => Promise<RequiredSingletonServices>
+) => {
+  return async (config: Config, existingServices: Partial<SingletonServices> = {}) => {
+    const services = await func(config, existingServices)
+    __pikkuState(null, 'package', 'singletonServices', services as any)
+    return services
+  }
+}
 
 /**
  * Creates a Pikku wire services factory.
@@ -584,7 +591,11 @@ export const pikkuWireServices = (
     services: SingletonServices,
     wire: any
   ) => Promise<RequiredWireServices>
-): CreateWireServices => func as unknown as CreateWireServices
+): CreateWireServices => {
+  const factories = __pikkuState(null, 'package', 'factories')
+  __pikkuState(null, 'package', 'factories', { ...factories, createWireServices: func as any })
+  return func as unknown as CreateWireServices
+}
 
 /**
  * Adds global middleware for a specific tag.
@@ -639,5 +650,8 @@ export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
 export const addPermission = <In = unknown>(tag: string, permissions: CorePermissionGroup<PikkuPermission<In>> | PikkuPermission<In>[]) => {
   addPermissionCore(tag, permissions as any, ${packageNameValue})
 }
+
+export { wireAddon } from '@pikku/core'
+export type { WireAddonConfig } from '@pikku/core'
 `;
 };

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

@@ -1,4 +1,4 @@
 /**
  * Generates the main pikku-types.gen.ts file as a re-export hub
  */
-export declare const serializePikkuTypesHub: (functionTypesImportPath: string, httpTypesImportPath: string | null, channelTypesImportPath: string | null, triggerTypesImportPath: string | null, schedulerTypesImportPath: string | null, queueTypesImportPath: string | null, mcpTypesImportPath: string | null, cliTypesImportPath: string | null, nodeTypesImportPath: string | null, secretTypesImportPath: string | null, externalTypesImportPath: string | null) => string;
+export declare const serializePikkuTypesHub: (functionTypesImportPath: string, httpTypesImportPath: string | null, channelTypesImportPath: string | null, triggerTypesImportPath: string | null, schedulerTypesImportPath: string | null, queueTypesImportPath: string | null, mcpTypesImportPath: string | null, cliTypesImportPath: string | null, nodeTypesImportPath: string | null, secretTypesImportPath: string | null, addonTypesImportPath: string | null) => string;

package/dist/src/functions/wirings/functions/serialize-pikku-types-hub.js

@@ -1,7 +1,7 @@
 /**
  * Generates the main pikku-types.gen.ts file as a re-export hub
  */
-export const serializePikkuTypesHub = (functionTypesImportPath, httpTypesImportPath, channelTypesImportPath, triggerTypesImportPath, schedulerTypesImportPath, queueTypesImportPath, mcpTypesImportPath, cliTypesImportPath, nodeTypesImportPath, secretTypesImportPath, externalTypesImportPath) => {
+export const serializePikkuTypesHub = (functionTypesImportPath, httpTypesImportPath, channelTypesImportPath, triggerTypesImportPath, schedulerTypesImportPath, queueTypesImportPath, mcpTypesImportPath, cliTypesImportPath, nodeTypesImportPath, secretTypesImportPath, addonTypesImportPath) => {
     const exports = [
         {
             comment: 'Core function, middleware, and permission types',
@@ -16,7 +16,7 @@ export const serializePikkuTypesHub = (functionTypesImportPath, httpTypesImportP
         { comment: 'CLI wiring types', path: cliTypesImportPath },
         { comment: 'Node wiring types', path: nodeTypesImportPath },
         { comment: 'Secret definition types', path: secretTypesImportPath },
-        { comment: 'External package types', path: externalTypesImportPath },
+        { comment: 'Addon types', path: addonTypesImportPath },
     ];
     const exportStatements = exports
         .filter((e) => e.path)

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

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

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

@@ -0,0 +1,22 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+export const pikkuGateway = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const visitState = await getInspectorState();
+        const { gatewaysWiringFile, packageMappings } = config;
+        const { gateways } = visitState;
+        if (Object.keys(gateways.meta).length === 0) {
+            return undefined;
+        }
+        await writeFileInDir(logger, gatewaysWiringFile, serializeFileImports('wireGateway', gatewaysWiringFile, gateways.files, packageMappings));
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Finding gateways',
+            commandEnd: 'Found gateways',
+        }),
+    ],
+});

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

@@ -24,7 +24,7 @@ export const pikkuHTTP = pikkuSessionlessFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core'\nimport type { HTTPWiringsMeta } from '@pikku/core/http'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`);
+        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core/internal'\nimport type { HTTPWiringsMeta } from '@pikku/core/http'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`);
         return true;
     },
     middleware: [

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

@@ -15,7 +15,7 @@ export const pikkuHTTP = pikkuSessionlessFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core'\nimport type { HTTPWiringsMeta } from '@pikku/core/http'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`);
+        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core/internal'\nimport type { HTTPWiringsMeta } from '@pikku/core/http'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`);
         return true;
     },
     middleware: [

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

@@ -1,6 +1,6 @@
-import { HTTPWiringsMeta } from '@pikku/core/http';
-import { MetaInputTypes, TypesMap } from '@pikku/inspector';
-import { Logger } from '@pikku/core/services';
+import type { HTTPWiringsMeta } from '@pikku/core/http';
+import type { MetaInputTypes, TypesMap } from '@pikku/inspector';
+import type { Logger } from '@pikku/core/services';
 export declare const serializeTypedHTTPWiringsMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, wiringsMeta: HTTPWiringsMeta, metaTypes: MetaInputTypes, resolvedIOTypes: Record<string, {
     inputType: string;
     outputType: string;

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

@@ -5,7 +5,7 @@ import { serializeMCPJson } from '@pikku/inspector';
 export const pikkuMCPJSON = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const state = await getInspectorState();
-        const { mcpJsonFile } = config;
+        const mcpJsonFile = config.clientFiles?.mcpJsonFile;
         if (mcpJsonFile) {
             const mcpJson = serializeMCPJson(logger, state);
             await writeFileInDir(logger, mcpJsonFile, mcpJson, {

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

@@ -81,7 +81,7 @@ export const pikkuMCP = pikkuSessionlessFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, mcpWiringsMetaFile, `import { pikkuState } from '@pikku/core'
+        await writeFileInDir(logger, mcpWiringsMetaFile, `import { pikkuState } from '@pikku/core/internal'
 import type { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp'
 ${importStatement}
 pikkuState(null, 'mcp', 'resourcesMeta', metaData.resourcesMeta as MCPResourceMeta)

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

@@ -4,11 +4,11 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 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) {
+        const { addonName, packageMappings, packageFile } = config;
+        // Only generate for addon packages
+        if (!addonName) {
             logger.debug({
-                message: 'Skipping package factories - not an external package (externalPackageName not set)',
+                message: 'Skipping package factories - not an addon package (addonName not set)',
                 type: 'skip',
             });
             return false;
@@ -23,7 +23,7 @@ export const pikkuPackage = pikkuSessionlessFunc({
         const state = await getInspectorState();
         const { filesAndMethods } = state;
         const { pikkuConfigFactory, singletonServicesFactory, wireServicesFactory, } = filesAndMethods;
-        const content = serializePackageFactories(packageFile, externalPackageName, pikkuConfigFactory
+        const content = serializePackageFactories(packageFile, addonName, pikkuConfigFactory
             ? {
                 file: pikkuConfigFactory.file,
                 variable: pikkuConfigFactory.variable,

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

@@ -1,7 +1,7 @@
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const serializePackageFactories = (outputPath, packageName, configFactory, singletonServicesFactory, wireServicesFactory, packageMappings = {}) => {
     const imports = [
-        `import { addPackageServiceFactories } from '@pikku/core'`,
+        `import { pikkuState } from '@pikku/core/internal'`,
     ];
     const factoryEntries = [];
     if (configFactory) {
@@ -25,7 +25,7 @@ export const serializePackageFactories = (outputPath, packageName, configFactory
     }
     return `${imports.join('\n')}
 
-addPackageServiceFactories('${packageName}', {
+pikkuState('${packageName}', 'package', 'factories', {
 ${factoryEntries.join('\n')}
 })
 `;

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

@@ -14,11 +14,6 @@ export const pikkuPermissions = pikkuSessionlessFunc({
         if (hasHTTPGroups || hasTagGroups || hasIndividual) {
             const metaData = state.permissionsGroupsMeta;
             await writeFileInDir(logger, config.permissionsGroupsMetaJsonFile, JSON.stringify(metaData, null, 2));
-            filesGenerated = true;
-        }
-        const hasHTTPFactories = Array.from(state.http.routePermissions.values()).some((meta) => meta.exportName && meta.isFactory);
-        const hasTagFactories = Array.from(state.permissions.tagPermissions.values()).some((meta) => meta.exportName && meta.isFactory);
-        if (hasHTTPFactories || hasTagFactories) {
             await writeFileInDir(logger, permissionsFile, serializePermissionsImports(permissionsFile, permissions, state.http, packageMappings));
             filesGenerated = true;
         }

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

@@ -5,7 +5,8 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializeQueueWrapper } from './serialize-queue-wrapper.js';
 export const pikkuQueueService = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        const { queueWiringsFile, queueMapDeclarationFile, packageMappings } = config;
+        const queueWiringsFile = config.clientFiles?.queueWiringsFile;
+        const { queueMapDeclarationFile, packageMappings } = config;
         // If queueWiringsFile is not set, clean up any existing file and return
         if (!queueWiringsFile) {
             logger.debug({

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

@@ -1,6 +1,6 @@
 import type { QueueWorkersMeta } from '@pikku/core/queue';
-import { TypesMap } from '@pikku/inspector';
-import { Logger } from '@pikku/core/services';
+import type { TypesMap } from '@pikku/inspector';
+import type { Logger } from '@pikku/core/services';
 export declare const serializeQueueMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, queueWorkersMeta: QueueWorkersMeta, resolvedIOTypes: Record<string, {
     inputType: string;
     outputType: string;

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

@@ -1,3 +1,3 @@
-import { QueueWorkersMeta } from '@pikku/core/queue';
+import type { QueueWorkersMeta } from '@pikku/core/queue';
 export declare const serializeQueueMeta: (queueWorkersMeta: QueueWorkersMeta) => QueueWorkersMeta;
 export declare const serializeQueueMetaTS: (jsonImportPath: string, supportsImportAttributes: boolean) => string;

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

@@ -3,13 +3,11 @@ 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 { serializePublicRPC } from './serialize-public-rpc.js';
-import { join } from 'path';
 export const pikkuPublicRPC = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        if (config.rpc?.publicRpcPath) {
-            const publicRpcPath = join(config.rootDir, config.rpc.publicRpcPath);
-            const pathToPikkuTypes = getFileImportRelativePath(publicRpcPath, config.typesDeclarationFile, config.packageMappings);
-            await writeFileInDir(logger, publicRpcPath, serializePublicRPC(pathToPikkuTypes, config.rpc.publicRpcRequireAuth ?? true));
+        if (config.scaffold?.rpc) {
+            const pathToPikkuTypes = getFileImportRelativePath(config.publicRpcFile, config.typesDeclarationFile, config.packageMappings);
+            await writeFileInDir(logger, config.publicRpcFile, serializePublicRPC(pathToPikkuTypes, config.scaffold.rpc === 'auth'));
             return true;
         }
         return false;

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

@@ -3,13 +3,11 @@ 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 { serializeRemoteRPC } from './serialize-remote-rpc.js';
-import { join } from 'path';
 export const pikkuRemoteRPC = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        if (config.rpc?.remoteRpcWorkersPath) {
-            const remoteRpcPath = join(config.rootDir, config.rpc.remoteRpcWorkersPath);
-            const pathToPikkuTypes = getFileImportRelativePath(remoteRpcPath, config.typesDeclarationFile, config.packageMappings);
-            await writeFileInDir(logger, remoteRpcPath, serializeRemoteRPC(pathToPikkuTypes));
+        if (config.remoteRpcWorkersFile) {
+            const pathToPikkuTypes = getFileImportRelativePath(config.remoteRpcWorkersFile, config.typesDeclarationFile, config.packageMappings);
+            await writeFileInDir(logger, config.remoteRpcWorkersFile, serializeRemoteRPC(pathToPikkuTypes));
             return true;
         }
         return false;

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

@@ -5,7 +5,8 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializeRPCWrapper } from './serialize-rpc-wrapper.js';
 export const pikkuRPCClient = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        const { rpcWiringsFile, rpcMapDeclarationFile, packageMappings } = config;
+        const rpcWiringsFile = config.clientFiles?.rpcWiringsFile;
+        const { rpcMapDeclarationFile, packageMappings } = config;
         // If rpcWiringsFile is not set, clean up any existing file and return
         if (!rpcWiringsFile) {
             logger.debug({

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

@@ -6,10 +6,10 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const pikkuRPCInternalMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { functions, rpc, resolvedIOTypes } = await getInspectorState();
-        const { rpcInternalMapDeclarationFile, packageMappings, externalPackages, workflowMapDeclarationFile, agentMapDeclarationFile, } = config;
+        const { rpcInternalMapDeclarationFile, packageMappings, workflowMapDeclarationFile, agentMapDeclarationFile, } = config;
         const workflowMapPath = getFileImportRelativePath(rpcInternalMapDeclarationFile, workflowMapDeclarationFile, packageMappings);
         const agentMapPath = getFileImportRelativePath(rpcInternalMapDeclarationFile, agentMapDeclarationFile, packageMappings);
-        const content = serializeTypedRPCMap(logger, rpcInternalMapDeclarationFile, packageMappings, functions.typesMap, rpc.internalMeta, resolvedIOTypes, externalPackages, workflowMapPath, agentMapPath);
+        const content = serializeTypedRPCMap(logger, rpcInternalMapDeclarationFile, packageMappings, functions.typesMap, rpc.internalMeta, resolvedIOTypes, rpc.wireAddonDeclarations, workflowMapPath, agentMapPath);
         await writeFileInDir(logger, rpcInternalMapDeclarationFile, content);
     },
     middleware: [
@@ -22,16 +22,16 @@ export const pikkuRPCInternalMap = pikkuSessionlessFunc({
 export const pikkuRPCExposedMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { functions, rpc, resolvedIOTypes } = await getInspectorState();
-        const { rpcMapDeclarationFile, packageMappings, externalPackages, workflowMapDeclarationFile, agentMapDeclarationFile, } = config;
+        const { rpcMapDeclarationFile, packageMappings, workflowMapDeclarationFile, agentMapDeclarationFile, } = config;
         const workflowMapPath = getFileImportRelativePath(rpcMapDeclarationFile, workflowMapDeclarationFile, packageMappings);
         const agentMapPath = getFileImportRelativePath(rpcMapDeclarationFile, agentMapDeclarationFile, packageMappings);
-        const content = serializeTypedRPCMap(logger, rpcMapDeclarationFile, packageMappings, functions.typesMap, rpc.exposedMeta, resolvedIOTypes, externalPackages, workflowMapPath, agentMapPath);
+        const content = serializeTypedRPCMap(logger, rpcMapDeclarationFile, packageMappings, functions.typesMap, rpc.exposedMeta, resolvedIOTypes, rpc.wireAddonDeclarations, workflowMapPath, agentMapPath);
         await writeFileInDir(logger, rpcMapDeclarationFile, content);
     },
     middleware: [
         logCommandInfoAndTime({
-            commandStart: 'Creating RPC external map',
-            commandEnd: 'Created RPC external map',
+            commandStart: 'Creating RPC addon map',
+            commandEnd: 'Created RPC addon map',
         }),
     ],
 });

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

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

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

@@ -7,12 +7,8 @@ export const serializePublicRPC = (pathToPikkuTypes, requireAuth = true) => {
  * Auto-generated public RPC HTTP endpoint
  * Do not edit manually - regenerate with 'npx pikku'
  */
-import { pikkuSessionlessFunc, wireHTTP } from '${pathToPikkuTypes}'
+import { pikkuSessionlessFunc, defineHTTPRoutes, wireHTTPRoutes } from '${pathToPikkuTypes}'
 
-/**
- * Public RPC endpoint that invokes any exposed RPC by name
- * This is used for public HTTP access to exposed server functions
- */
 export const rpcCaller = pikkuSessionlessFunc<
   { rpcName: string; data?: unknown },
   unknown
@@ -23,20 +19,33 @@ export const rpcCaller = pikkuSessionlessFunc<
   },
 })
 
-wireHTTP({
-  route: "/rpc/:rpcName",
-  method: "options",
-  tags: ['pikku:public'],
+export const workflowCaller = pikkuSessionlessFunc<
+  { workflowName: string; input?: unknown },
+  { runId: string }
+>({
   auth: ${authFlag},
-  func: pikkuSessionlessFunc<{ rpcName: string }>(async () => void 0),
-});
+  func: async (_services, { workflowName, input }, { rpc }) => {
+    return await rpc.startWorkflow(workflowName, input || {})
+  },
+})
 
-wireHTTP({
-  route: '/rpc/:rpcName',
-  method: 'post',
-  tags: ['pikku:public'],
+export const rpcRoutes = defineHTTPRoutes({
   auth: ${authFlag},
-  func: rpcCaller,
+  tags: ['pikku:public'],
+  routes: {
+    rpc: {
+      route: '/rpc/:rpcName',
+      method: 'post',
+      func: rpcCaller,
+    },
+    workflow: {
+      route: '/rpc/workflow/:workflowName',
+      method: 'post',
+      func: workflowCaller,
+    },
+  },
 })
+
+wireHTTPRoutes({ routes: { rpc: rpcRoutes } })
 `;
 };

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

@@ -1,7 +1,7 @@
 export const serializeRPCWrapper = (rpcMapPath) => {
     return `
 import { PikkuFetch } from "./pikku-fetch.gen.js"
-import type { RPCInvoke, TypedAgent } from '${rpcMapPath}'
+import type { RPCInvoke, TypedAgentRun, TypedStartWorkflow } from '${rpcMapPath}'
 
 /**
  * PikkuRPC provides a type-safe client for making Remote Procedure Calls (RPC)
@@ -63,14 +63,50 @@ export class PikkuRPC {
     }
 
     /**
-     * Invokes an AI agent on the server.
+     * Starts a workflow by name with the given input.
+     * Posts to \\\`/rpc/workflow/:workflowName\\\`.
      *
-     * @param agentName - The name of the agent to invoke
-     * @param input - The agent input (message, threadId, resourceId)
-     * @returns A promise that resolves with the agent's output
+     * @param workflowName - The registered workflow name
+     * @param input - The workflow input data
+     * @returns A promise that resolves with the new run ID
      */
-    agent: TypedAgent = async (agentName, input) => {
-       return await this.pikkuFetch.post(\`/rpc/agent/\${String(agentName)}\` as never, input) as any
+    startWorkflow: TypedStartWorkflow = async (workflowName, input) => {
+        return await this.pikkuFetch.post(\`/rpc/workflow/\${String(workflowName)}\` as never, { workflowName: String(workflowName), input }) as any
+    }
+
+    /**
+     * Agent namespace — methods for running, streaming, and approving AI agents.
+     * All methods post to \\\`/rpc/agent/:agentName/*\\\`.
+     */
+    agent = {
+        /**
+         * Runs an agent to completion and returns the result.
+         *
+         * @param agentName - The registered agent name
+         * @param input - The agent input (message, threadId, resourceId)
+         * @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
+        }) as TypedAgentRun,
+        /**
+         * Streams agent responses via SSE. Used for real-time chat interfaces.
+         *
+         * @param agentName - The registered agent name
+         * @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
+        },
+        /**
+         * Approves or denies pending tool calls for an agent run.
+         *
+         * @param agentName - The registered agent name
+         * @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
+        },
     }
 }