@pikku/cli 0.11.3 → 0.12.0

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.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, externalPackages, 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);
         await writeFileInDir(logger, rpcInternalMapDeclarationFile, content);
     },
     middleware: [
@@ -18,9 +21,11 @@ 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, externalPackages, 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);
         await writeFileInDir(logger, rpcMapDeclarationFile, content);
     },
     middleware: [

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,10 @@ 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.externalPackageName
+                ? `'${config.externalPackageName}'`
+                : 'null';
+            await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core'\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,7 +1,8 @@
 /**
  * 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'
@@ -13,24 +14,28 @@ import { pikkuSessionlessFunc, wireHTTP } from '${pathToPikkuTypes}'
  * 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,
+  tags: ['pikku:public'],
+  auth: ${authFlag},
   func: pikkuSessionlessFunc<{ rpcName: string }>(async () => void 0),
 });
 
 wireHTTP({
   route: '/rpc/:rpcName',
   method: 'post',
+  tags: ['pikku:public'],
+  auth: ${authFlag},
   func: rpcCaller,
 })
 `;

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, TypedAgent } 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,18 @@ 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
+    }
+
+    /**
+     * Invokes an AI agent on the server.
+     *
+     * @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
+     */
+    agent: TypedAgent = async (agentName, input) => {
+       return await this.pikkuFetch.post(\`/rpc/agent/\${String(agentName)}\` as never, input) as any
     }
 }
 

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

@@ -1,3 +1,6 @@
-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 { TypesMap, ExternalPackageConfig } from '@pikku/inspector';
+import { Logger } from '@pikku/core/services';
+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;
+}>, externalPackages?: Record<string, ExternalPackageConfig>, workflowMapPath?: string, agentMapPath?: string) => string;

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

@@ -1,18 +1,35 @@
 import { serializeImportMap } from '../../../utils/serialize-import-map.js';
-import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
-export const serializeTypedRPCMap = (relativeToPath, packageMappings, typesMap, functionsMeta, rpcMeta, externalPackages) => {
+import { generateCustomTypes, } from '@pikku/inspector';
+export const serializeTypedRPCMap = (logger, relativeToPath, packageMappings, typesMap, rpcMeta, resolvedIOTypes, externalPackages, workflowMapPath, agentMapPath) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    const serializedRPCs = generateRPCs(rpcMeta, functionsMeta, typesMap, requiredTypes);
-    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    const serializedRPCs = generateRPCs(rpcMeta, resolvedIOTypes, requiredTypes);
+    const mcpTypes = [
+        'MCPResourceResponse',
+        'MCPToolResponse',
+        'MCPPromptResponse',
+    ];
+    const usedMcpTypes = mcpTypes.filter((t) => requiredTypes.has(t));
+    const mcpImport = usedMcpTypes.length > 0
+        ? `import type { ${usedMcpTypes.join(', ')} } from '@pikku/core/mcp'`
+        : '';
+    for (const t of usedMcpTypes) {
+        requiredTypes.delete(t);
+    }
+    const serializedImportMap = serializeImportMap(logger, relativeToPath, packageMappings, typesMap, requiredTypes);
+    const serializedCustomTypesDeclarationsOnly = serializedCustomTypes
+        .split('\n')
+        .filter((line) => !line.startsWith('import '))
+        .join('\n');
     const externalPackageImports = generateExternalPackageImports(externalPackages, relativeToPath);
     const mergedRPCMap = generateMergedRPCMap(externalPackages);
     return `/**
  * This provides the structure needed for typescript to be aware of RPCs and their return types
  */
 
+${mcpImport}
 ${serializedImportMap}
-${serializedCustomTypes}
+${serializedCustomTypesDeclarationsOnly}
 
 interface RPCHandler<I, O> {
     input: I;
@@ -25,25 +42,40 @@ ${mergedRPCMap}
 
 export type RPCInvoke = <Name extends keyof FlattenedRPCMap>(
   name: Name,
-  data: FlattenedRPCMap[Name]['input'],
-  options?: {
-    location?: 'local' | 'remote' | 'auto'
-  }
+  data: FlattenedRPCMap[Name]['input']
+) => Promise<FlattenedRPCMap[Name]['output']>
+
+export type RPCRemote = <Name extends keyof FlattenedRPCMap>(
+  name: Name,
+  data: FlattenedRPCMap[Name]['input']
 ) => Promise<FlattenedRPCMap[Name]['output']>
 
-// Import WorkflowMap for workflow typing
-import type { WorkflowMap } from '../workflow/pikku-workflow-map.gen.js'
+${workflowMapPath ? `import type { WorkflowMap } from '${workflowMapPath}'` : `type WorkflowMap = {}`}
 
-export type TypedPikkuRPC = {
-  depth: number;
-  global: boolean;
-  invoke: RPCInvoke;
-  invokeExposed: (name: string, data: any) => Promise<any>;
-  startWorkflow: <Name extends keyof WorkflowMap>(
-    name: Name,
-    input: WorkflowMap[Name]['input']
-  ) => Promise<{ runId: string }>;
+${agentMapPath ? `import type { AgentMap } from '${agentMapPath}'` : `type AgentMap = {}`}
+${generateExternalAgentImports(externalPackages)}
+${generateMergedAgentMap(externalPackages)}
+
+import type { PikkuRPC } from '@pikku/core/rpc'
+
+interface AIAgentInput {
+  message: string
+  threadId: string
+  resourceId: string
 }
+
+type TypedStartWorkflow = <Name extends keyof WorkflowMap>(
+  name: Name,
+  input: WorkflowMap[Name]['input'],
+  options?: { startNode?: string }
+) => Promise<{ runId: string }>
+
+type TypedAgent = <Name extends keyof FlattenedAgentMap>(
+  name: Name,
+  input: AIAgentInput
+) => Promise<{ runId: string; result: FlattenedAgentMap[Name]['output']; usage: { inputTokens: number; outputTokens: number } }>
+
+export type TypedPikkuRPC = PikkuRPC<RPCInvoke, RPCRemote, TypedStartWorkflow, TypedAgent>
   `;
 };
 function generateExternalPackageImports(externalPackages, relativeToPath) {
@@ -51,10 +83,10 @@ function generateExternalPackageImports(externalPackages, relativeToPath) {
         return '';
     }
     let imports = '\n// External package RPC maps\n';
-    for (const [namespace, packageName] of Object.entries(externalPackages)) {
+    for (const [namespace, config] of Object.entries(externalPackages)) {
         // Import the RPCMap from each external package's internal RPC map
         // Use .js extension - package.json exports will resolve to .d.ts for types
-        imports += `import type { RPCMap as ${toPascalCase(namespace)}RPCMap } from '${packageName}/.pikku/rpc/pikku-rpc-wirings-map.internal.gen.js'\n`;
+        imports += `import type { RPCMap as ${toPascalCase(namespace)}RPCMap } from '${config.package}/.pikku/rpc/pikku-rpc-wirings-map.internal.gen.js'\n`;
     }
     return imports;
 }
@@ -86,46 +118,39 @@ function toPascalCase(str) {
         .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
         .join('');
 }
-function generateRPCs(rpcMeta, functionsMeta, typesMap, requiredTypes) {
-    // Initialize an object to collect RPCs
+function generateExternalAgentImports(externalPackages) {
+    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+        return '';
+    }
+    let imports = '\n// External package Agent maps\n';
+    for (const [namespace, config] of Object.entries(externalPackages)) {
+        imports += `import type { AgentMap as ${toPascalCase(namespace)}AgentMap } from '${config.package}/.pikku/agent/pikku-agent-map.gen.d.js'\n`;
+    }
+    return imports;
+}
+function generateMergedAgentMap(externalPackages) {
+    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+        return `
+type FlattenedAgentMap = AgentMap
+`;
+    }
+    return `
+type FlattenedAgentMap =
+  AgentMap${Object.keys(externalPackages)
+        .map((namespace) => ` & PrefixKeys<${toPascalCase(namespace)}AgentMap, '${namespace}'>`)
+        .join('')}
+`;
+}
+function generateRPCs(rpcMeta, resolvedIOTypes, requiredTypes) {
     const rpcsObj = {};
-    // Iterate through RPC metadata
-    for (const [funcName, pikkuFuncName] of Object.entries(rpcMeta)) {
-        const functionMeta = functionsMeta[pikkuFuncName];
-        if (!functionMeta) {
-            throw new Error(`Function ${funcName} not found in functionsMeta. 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 RPCHandler
-        // 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 {
-                // Type not in typesMap - use the name directly (e.g., zod-derived types)
-                inputType = input;
-            }
-        }
-        let outputType = 'null';
-        if (output) {
-            try {
-                outputType = typesMap.getTypeMeta(output).uniqueName;
-            }
-            catch {
-                // Type not in typesMap - use the name directly (e.g., zod-derived types)
-                outputType = output;
-            }
+    for (const [funcName, pikkuFuncId] of Object.entries(rpcMeta)) {
+        const resolved = resolvedIOTypes[pikkuFuncId];
+        if (!resolved) {
+            throw new Error(`Function ${pikkuFuncId} not found in resolvedIOTypes. Please check your configuration.`);
         }
-        requiredTypes.add(inputType);
-        requiredTypes.add(outputType);
-        // Add RPC entry
-        rpcsObj[funcName] = {
-            inputType,
-            outputType,
-        };
+        requiredTypes.add(resolved.inputType);
+        requiredTypes.add(resolved.outputType);
+        rpcsObj[funcName] = resolved;
     }
     // Build the RPCs object as a string
     let rpcsStr = 'export type RPCMap = {\n';

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

@@ -1 +1 @@
-export declare const pikkuSchedulerTypes: any;
+export declare const pikkuSchedulerTypes: 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/scheduler/pikku-command-scheduler-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/scheduler/pikku-command-scheduler.d.ts

@@ -1 +1 @@
-export declare const pikkuScheduler: any;
+export declare const pikkuScheduler: 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/scheduler/pikku-command-scheduler.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/scheduler/serialize-scheduler-meta.d.ts

@@ -1,3 +1,3 @@
 import { ScheduledTasksMeta } from '@pikku/core/scheduler';
 export declare const serializeSchedulerMeta: (scheduledTasksMeta: ScheduledTasksMeta) => ScheduledTasksMeta;
-export declare const serializeSchedulerMetaTS: (scheduledTasksMeta: ScheduledTasksMeta, jsonImportPath: string, supportsImportAttributes: any) => string;
+export declare const serializeSchedulerMetaTS: (scheduledTasksMeta: ScheduledTasksMeta, jsonImportPath: string, supportsImportAttributes: boolean) => string;

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

@@ -1,20 +1,21 @@
+import { serializeMetaTS } from '../../../utils/serialize-meta-ts.js';
 export const serializeSchedulerMeta = (scheduledTasksMeta) => {
     return scheduledTasksMeta;
 };
 export const serializeSchedulerMetaTS = (scheduledTasksMeta, 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 { ScheduledTasksMeta } from '@pikku/core/scheduler'");
-    serializedOutput.push(importStatement);
-    serializedOutput.push('');
-    serializedOutput.push("pikkuState(null, 'scheduler', 'meta', metaData as ScheduledTasksMeta)");
-    serializedOutput.push('');
+    const base = serializeMetaTS({
+        jsonImportPath,
+        supportsImportAttributes,
+        pikkuStateNamespace: 'scheduler',
+        pikkuStateKey: 'meta',
+        metaTypeImport: '@pikku/core/scheduler',
+        metaTypeName: 'ScheduledTasksMeta',
+    });
     const scheduledTasksMetaValues = Object.values(scheduledTasksMeta);
     if (scheduledTasksMetaValues.length > 0) {
-        serializedOutput.push(`export type ScheduledTaskNames = '${scheduledTasksMetaValues.map((s) => s.name).join("' | '")}'`);
+        return (base +
+            '\n\n' +
+            `export type ScheduledTaskNames = '${scheduledTasksMetaValues.map((s) => s.name).join("' | '")}'`);
     }
-    return serializedOutput.join('\n');
+    return base;
 };