@pikku/cli 0.11.3 → 0.12.1

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

@@ -1,12 +1,12 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeQueueMap } from './serialize-queue-map.js';
 export const pikkuQueueMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { queueWorkers, functions } = await getInspectorState();
+        const { queueWorkers, functions, resolvedIOTypes } = await getInspectorState();
         const { queueMapDeclarationFile, packageMappings } = config;
-        const content = serializeQueueMap(queueMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, queueWorkers.meta);
+        const content = serializeQueueMap(logger, queueMapDeclarationFile, packageMappings, functions.typesMap, queueWorkers.meta, resolvedIOTypes);
         await writeFileInDir(logger, queueMapDeclarationFile, content);
     },
     middleware: [

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

@@ -1 +1 @@
-export declare const pikkuQueueService: any;
+export declare const pikkuQueueService: 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/queue/pikku-command-queue-service.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+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';
@@ -8,7 +8,7 @@ export const pikkuQueueService = pikkuSessionlessFunc({
         const { queueWiringsFile, queueMapDeclarationFile, packageMappings } = config;
         // If queueWiringsFile is not set, clean up any existing file and return
         if (!queueWiringsFile) {
-            logger.info({
+            logger.debug({
                 message: "Skipping generating queue service wrapper since queueWiringsFile isn't set in the pikku config.",
                 type: 'skip',
             });

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

@@ -1 +1 @@
-export declare const pikkuQueueTypes: any;
+export declare const pikkuQueueTypes: 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/queue/pikku-command-queue-types.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';

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

@@ -1 +1 @@
-export declare const pikkuQueue: any;
+export declare const pikkuQueue: 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/queue/pikku-command-queue.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+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';

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

@@ -1 +1 @@
-export declare const pikkuQueueMap: any;
+export declare const pikkuQueueMap: 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/queue/pikku-queue-map.js

@@ -1,12 +1,12 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeQueueMap } from './serialize-queue-map.js';
 export const pikkuQueueMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { queueWorkers, functions } = await getInspectorState();
+        const { queueWorkers, functions, resolvedIOTypes } = await getInspectorState();
         const { queueMapDeclarationFile, packageMappings } = config;
-        const content = serializeQueueMap(queueMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, queueWorkers.meta);
+        const content = serializeQueueMap(logger, queueMapDeclarationFile, packageMappings, functions.typesMap, queueWorkers.meta, resolvedIOTypes);
         await writeFileInDir(logger, queueMapDeclarationFile, content);
     },
     middleware: [

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

@@ -1 +1 @@
-export declare const pikkuQueue: any;
+export declare const pikkuQueue: 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/queue/pikku-queue.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+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';

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

@@ -1,4 +1,7 @@
 import type { QueueWorkersMeta } from '@pikku/core/queue';
-import { TypesMap } from '@pikku/inspector';
-import { FunctionsMeta } from '@pikku/core';
-export declare const serializeQueueMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, queueWorkersMeta: QueueWorkersMeta) => string;
+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;
+}>) => string;

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

@@ -1,10 +1,10 @@
 import { serializeImportMap } from '../../../utils/serialize-import-map.js';
-import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
-export const serializeQueueMap = (relativeToPath, packageMappings, typesMap, functionsMeta, queueWorkersMeta) => {
+import { generateCustomTypes } from '@pikku/inspector';
+export const serializeQueueMap = (logger, relativeToPath, packageMappings, typesMap, queueWorkersMeta, resolvedIOTypes) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    const serializedQueues = generateQueues(queueWorkersMeta, functionsMeta, typesMap, requiredTypes);
-    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    const serializedQueues = generateQueues(queueWorkersMeta, resolvedIOTypes, requiredTypes);
+    const serializedImportMap = serializeImportMap(logger, relativeToPath, packageMappings, typesMap, requiredTypes);
     return `/**
  * This provides the structure needed for typescript to be aware of Queue workers and their input/output types
  */
@@ -45,44 +45,16 @@ export type TypedPikkuQueue = {
 }
   `;
 };
-function generateQueues(queueWorkersMeta, functionsMeta, typesMap, requiredTypes) {
-    // Initialize an object to collect queues
+function generateQueues(queueWorkersMeta, resolvedIOTypes, requiredTypes) {
     const queuesObj = {};
-    // Iterate through Queue metadata
-    for (const [queueName, { pikkuFuncName }] of Object.entries(queueWorkersMeta)) {
-        const functionMeta = functionsMeta[pikkuFuncName];
-        if (!functionMeta) {
-            throw new Error(`Function ${queueName} not found in functionsMeta. Please check your configuration.`);
+    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.`);
         }
-        const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
-        const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
-        // Store the input and output types for QueueHandler
-        // For zod-derived schemas, the type might not be in typesMap, so use the schema name directly
-        let inputType = 'null';
-        if (input) {
-            try {
-                inputType = typesMap.getTypeMeta(input).uniqueName;
-            }
-            catch {
-                inputType = input;
-            }
-        }
-        let outputType = 'null';
-        if (output) {
-            try {
-                outputType = typesMap.getTypeMeta(output).uniqueName;
-            }
-            catch {
-                outputType = output;
-            }
-        }
-        requiredTypes.add(inputType);
-        requiredTypes.add(outputType);
-        // Add Queue entry
-        queuesObj[queueName] = {
-            inputType,
-            outputType,
-        };
+        requiredTypes.add(resolved.inputType);
+        requiredTypes.add(resolved.outputType);
+        queuesObj[queueName] = resolved;
     }
     // Build the Queues object as a string
     let queuesStr = 'export type QueueMap = {\n';

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/queue/serialize-queue-meta.js

@@ -1,15 +1,14 @@
+import { serializeMetaTS } from '../../../utils/serialize-meta-ts.js';
 export const serializeQueueMeta = (queueWorkersMeta) => {
     return queueWorkersMeta;
 };
 export const serializeQueueMetaTS = (jsonImportPath, supportsImportAttributes) => {
-    const importStatement = supportsImportAttributes
-        ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
-        : `import metaData from '${jsonImportPath}'`;
-    const serializedOutput = [];
-    serializedOutput.push("import { pikkuState } from '@pikku/core'");
-    serializedOutput.push("import { QueueWorkersMeta } from '@pikku/core/queue'");
-    serializedOutput.push(importStatement);
-    serializedOutput.push('');
-    serializedOutput.push("pikkuState(null, 'queue', 'meta', metaData as QueueWorkersMeta)");
-    return serializedOutput.join('\n');
+    return serializeMetaTS({
+        jsonImportPath,
+        supportsImportAttributes,
+        pikkuStateNamespace: 'queue',
+        pikkuStateKey: 'meta',
+        metaTypeImport: '@pikku/core/queue',
+        metaTypeName: 'QueueWorkersMeta',
+    });
 };

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

@@ -24,7 +24,7 @@ type QueueWiring<In, Out> = CoreQueueWorker<PikkuFunctionConfig<In, Out, 'sessio
  * @param queueWorker - Queue worker definition with job handler
  */
 export const wireQueueWorker = (queueWorker: QueueWiring<any, any>) => {
-  wireQueueWorkerCore(queueWorker as any) // TODO
+  wireQueueWorkerCore(queueWorker as any)
 }
 `;
 };

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

@@ -1 +1 @@
-export declare const pikkuPublicRPC: any;
+export declare const pikkuPublicRPC: 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/rpc/pikku-command-public-rpc.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+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';
@@ -9,7 +9,7 @@ export const pikkuPublicRPC = pikkuSessionlessFunc({
         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));
+            await writeFileInDir(logger, publicRpcPath, serializePublicRPC(pathToPikkuTypes, config.rpc.publicRpcRequireAuth ?? true));
             return true;
         }
         return false;

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

@@ -1 +1 @@
-export declare const pikkuRemoteRPC: any;
+export declare const pikkuRemoteRPC: 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/rpc/pikku-command-remote-rpc.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+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';

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

@@ -1 +1 @@
-export declare const pikkuRPCClient: any;
+export declare const pikkuRPCClient: 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/rpc/pikku-command-rpc-client.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+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';
@@ -8,7 +8,7 @@ export const pikkuRPCClient = pikkuSessionlessFunc({
         const { rpcWiringsFile, rpcMapDeclarationFile, packageMappings } = config;
         // If rpcWiringsFile is not set, clean up any existing file and return
         if (!rpcWiringsFile) {
-            logger.info({
+            logger.debug({
                 message: "Skipping generating RPC wrappers since rpcWiringsFile isn't set in the pikku config.",
                 type: 'skip',
             });

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

@@ -1,2 +1,2 @@
-export declare const pikkuRPCInternalMap: any;
-export declare const pikkuRPCExposedMap: any;
+export declare const pikkuRPCInternalMap: 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>;
+export declare const pikkuRPCExposedMap: 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/rpc/pikku-command-rpc-map.js

@@ -1,12 +1,15 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeTypedRPCMap } from './serialize-typed-rpc-map.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const pikkuRPCInternalMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { functions, rpc } = await getInspectorState();
-        const { rpcInternalMapDeclarationFile, packageMappings, externalPackages } = config;
-        const content = serializeTypedRPCMap(rpcInternalMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.internalMeta, externalPackages);
+        const { functions, rpc, resolvedIOTypes } = await getInspectorState();
+        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, rpc.wireAddonDeclarations, workflowMapPath, agentMapPath);
         await writeFileInDir(logger, rpcInternalMapDeclarationFile, content);
     },
     middleware: [
@@ -18,15 +21,17 @@ export const pikkuRPCInternalMap = pikkuSessionlessFunc({
 });
 export const pikkuRPCExposedMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { functions, rpc } = await getInspectorState();
-        const { rpcMapDeclarationFile, packageMappings, externalPackages } = config;
-        const content = serializeTypedRPCMap(rpcMapDeclarationFile, packageMappings, functions.typesMap, functions.meta, rpc.exposedMeta, externalPackages);
+        const { functions, rpc, resolvedIOTypes } = await getInspectorState();
+        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, 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.d.ts

@@ -1 +1 @@
-export declare const pikkuRPC: any;
+export declare const pikkuRPC: 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/rpc/pikku-command-rpc.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
@@ -13,7 +13,8 @@ export const pikkuRPC = pikkuSessionlessFunc({
             const importStatement = supportsImportAttributes
                 ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
                 : `import metaData from '${jsonImportPath}'`;
-            await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core'\n${importStatement}\npikkuState(null, '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.d.ts

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

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

@@ -1,37 +1,51 @@
 /**
  * Generate public RPC HTTP endpoint
  */
-export const serializePublicRPC = (pathToPikkuTypes) => {
+export const serializePublicRPC = (pathToPikkuTypes, requireAuth = true) => {
+    const authFlag = requireAuth ? 'true' : 'false';
     return `/**
  * 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?: any },
-  any
+  { rpcName: string; data?: unknown },
+  unknown
 >({
-  func: async (services, { rpcName, data }, { rpc }) => {
-    return await (rpc.invokeExposed as any)(rpcName, data)
+  auth: ${authFlag},
+  func: async (_services, { rpcName, data }, { rpc }) => {
+    return await rpc.exposed(rpcName, data)
   },
 })
 
-wireHTTP({
-  route: "/rpc/:rpcName",
-  method: "options",
-  auth: false,
-  func: pikkuSessionlessFunc<{ rpcName: string }>(async () => void 0),
-});
+export const workflowCaller = pikkuSessionlessFunc<
+  { workflowName: string; input?: unknown },
+  { runId: string }
+>({
+  auth: ${authFlag},
+  func: async (_services, { workflowName, input }, { rpc }) => {
+    return await rpc.startWorkflow(workflowName, input || {})
+  },
+})
 
-wireHTTP({
-  route: '/rpc/:rpcName',
-  method: 'post',
-  func: rpcCaller,
+export const rpcRoutes = defineHTTPRoutes({
+  auth: ${authFlag},
+  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-remote-rpc.js

@@ -22,11 +22,11 @@ export const pikkuRemoteInternalRPC = pikkuSessionlessFunc<
   func: async (_services, { rpcName, data }, { rpc }) => {
     return await (rpc.invoke as any)(rpcName, data)
   },
-  internal: true,
+  remote: true,
 })
 
 wireQueueWorker({
-  queueName: 'pikku-remote-internal-rpc',
+  name: 'pikku-remote-internal-rpc',
   func: pikkuRemoteInternalRPC,
 })
 `;

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

@@ -1,11 +1,11 @@
 export const serializeRPCWrapper = (rpcMapPath) => {
     return `
 import { PikkuFetch } from "./pikku-fetch.gen.js"
-import type { RPCInvoke } from '${rpcMapPath}'
+import type { RPCInvoke, TypedAgentRun, TypedStartWorkflow } from '${rpcMapPath}'
 
 /**
- * PikkuRPC provides a type-safe client for making Remote Procedure Calls (RPC) 
- * to your Pikku server. It wraps the underlying HTTP client and provides a 
+ * PikkuRPC provides a type-safe client for making Remote Procedure Calls (RPC)
+ * to your Pikku server. It wraps the underlying HTTP client and provides a
  * simple interface for invoking server-side functions.
  */
 export class PikkuRPC {
@@ -15,7 +15,7 @@ export class PikkuRPC {
     /**
      * Sets a custom PikkuFetch instance to use for RPC calls.
      * This allows you to configure custom settings or use a shared client instance.
-     * 
+     *
      * @param pikkuFetch - The PikkuFetch instance to use
      */
     setPikkuFetch(pikkuFetch: PikkuFetch): void {
@@ -24,7 +24,7 @@ export class PikkuRPC {
 
     /**
      * Sets the base server URL for all RPC calls.
-     * 
+     *
      * @param serverUrl - The base URL of your Pikku server (e.g., 'https://api.example.com')
      */
     setServerUrl(serverUrl: string): void {
@@ -33,7 +33,7 @@ export class PikkuRPC {
 
     /**
      * Sets the JWT token for authorization on all RPC calls.
-     * 
+     *
      * @param jwt - The JWT token to use for authorization, or null to remove authorization
      */
     setAuthorizationJWT(jwt: string | null): void {
@@ -42,7 +42,7 @@ export class PikkuRPC {
 
     /**
      * Sets the API key for authorization on all RPC calls.
-     * 
+     *
      * @param apiKey - The API key to use for authorization, or null to remove the API key
      */
     setAPIKey(apiKey: string | null): void {
@@ -59,7 +59,54 @@ export class PikkuRPC {
      * @returns A promise that resolves with the function's return value
      */
     invoke: RPCInvoke = async (rpcName, data) => {
-       return await this.pikkuFetch.post(\`/rpc/\${rpcName}\` as any, { rpcName: String(rpcName), data }) as any
+       return await this.pikkuFetch.post(\`/rpc/\${String(rpcName)}\` as never, { rpcName: String(rpcName), data }) as any
+    }
+
+    /**
+     * Starts a workflow by name with the given input.
+     * Posts to \\\`/rpc/workflow/:workflowName\\\`.
+     *
+     * @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(\`/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
+        },
     }
 }
 

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

@@ -1,3 +1,11 @@
-import { TypesMap } from '@pikku/inspector';
-import { FunctionsMeta } from '@pikku/core';
-export declare const serializeTypedRPCMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, rpcMeta: Record<string, string>, externalPackages?: Record<string, string>) => string;
+import type { TypesMap } from '@pikku/inspector';
+import type { Logger } from '@pikku/core/services';
+type WireAddonDeclarations = Map<string, {
+    package: string;
+    rpcEndpoint?: string;
+}>;
+export declare const serializeTypedRPCMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, rpcMeta: Record<string, string>, resolvedIOTypes: Record<string, {
+    inputType: string;
+    outputType: string;
+}>, wireAddonDeclarations?: WireAddonDeclarations, workflowMapPath?: string, agentMapPath?: string) => string;
+export {};