@pikku/cli 0.11.2 → 0.12.0

package/dist/.pikku/cli/pikku-cli.gen.d.ts

@@ -1,10 +1,6 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.12.0
  */
 import '../pikku-bootstrap.gen.js';
-/**
- * Pikku CLI function
- * Handles command line arguments and executes the appropriate function
- */
 export declare function PikkuCLI(args: string[]): Promise<void>;
 export default PikkuCLI;

package/dist/.pikku/cli/pikku-cli.gen.js

@@ -1,15 +1,11 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.12.0
  */
 import { executeCLI, CLIError } from '@pikku/core/cli';
 import { createConfig as createConfig } from '../../src/services.js';
 import { createSingletonServices as createSingletonServices } from '../../src/services.js';
 import { createWireServices as createWireServices } from '../../src/services.js';
 import '../pikku-bootstrap.gen.js';
-/**
- * Pikku CLI function
- * Handles command line arguments and executes the appropriate function
- */
 export async function PikkuCLI(args) {
     try {
         await executeCLI({

package/dist/.pikku/console/pikku-node-types.gen.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This file was generated by @pikku/cli@0.12.0
+ */
+import type { FlattenedRPCMap } from '../rpc/pikku-rpc-wirings-map.internal.gen.js';
+export type NodeCategory = never;
+export type NodeRPCName = keyof FlattenedRPCMap;

package/dist/.pikku/console/pikku-node-types.gen.js

@@ -0,0 +1 @@
+export {};

package/dist/.pikku/function/pikku-function-types.gen.d.ts

@@ -1,18 +1,32 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.12.0
  */
 /**
  * Core function, middleware, and permission types for all wirings
  */
-import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, PikkuWire, PickRequired } from '@pikku/core';
+import { CorePikkuFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, PikkuWire, PickRequired, CreateWireServices } from '@pikku/core';
+import type { NodeType } from '@pikku/core/node';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
 import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function';
 import type { UserSession } from '../../types/application-types.d.js';
 import type { SingletonServices } from '../../types/application-types.d.js';
 import type { Services } from '../../types/application-types.d.js';
 import type { Config } from '../../types/application-types.d.js';
-import type { TypedPikkuRPC } from '../rpc/pikku-rpc-wirings-map.internal.gen.d.js';
+import type { TypedPikkuRPC, FlattenedRPCMap } from '../rpc/pikku-rpc-wirings-map.internal.gen.d.js';
 import type { RequiredSingletonServices, RequiredWireServices } from '../pikku-services.gen.js';
-type Session = UserSession;
+import type { TypedWorkflow } from '../workflow/pikku-workflow-types.gen.js';
+export type { SingletonServices as SingletonServices };
+export type { Services as Services };
+export type Session = UserSession;
+/**
+ * Inline node configuration for function definitions.
+ */
+export type NodeConfig = {
+    displayName: string;
+    category: string;
+    type: NodeType;
+    errorOutput?: boolean;
+};
 /**
  * Type-safe API permission definition that integrates with your application's session type.
  * Use this to define authorization logic for your API endpoints.
@@ -63,6 +77,39 @@ export type PikkuPermissionConfig<In = unknown, RequiredServices extends Service
  * ```
  */
 export declare const pikkuPermission: <In>(permission: PikkuPermission<In> | PikkuPermissionConfig<In>) => PikkuPermission<In>;
+/**
+ * Type-safe auth-only permission that only needs services and session.
+ * Use this for upfront authorization gates (MCP tools, AI agents, workflows)
+ * where request data isn't available yet.
+ *
+ * @template RequiredServices - The services required for this auth check
+ */
+export type PikkuAuth<RequiredServices extends SingletonServices = SingletonServices> = CorePikkuAuth<RequiredServices, Session>;
+/**
+ * Configuration object for creating an auth permission with metadata
+ */
+export type PikkuAuthConfig<RequiredServices extends SingletonServices = SingletonServices> = CorePikkuAuthConfig<RequiredServices, Session>;
+/**
+ * Factory function for creating auth-only permissions with tree-shaking support.
+ * Auth permissions only receive services and session (no request data),
+ * making them evaluable before request data is available.
+ *
+ * @example
+ * \`\`\`typescript
+ * const isAuthenticated = pikkuAuth(async ({ logger }, session) => {
+ *   return !!session
+ * })
+ *
+ * const isAdmin = pikkuAuth({
+ *   name: 'Admin Auth',
+ *   description: 'Checks if user is an admin',
+ *   func: async ({ logger }, session) => {
+ *     return session?.role === 'admin'
+ *   }
+ * })
+ * \`\`\`
+ */
+export declare const pikkuAuth: <RequiredServices extends SingletonServices = SingletonServices>(auth: PikkuAuth<RequiredServices> | PikkuAuthConfig<RequiredServices>) => PikkuPermission<any, any>;
 /**
  * Configuration object for creating middleware with metadata
  */
@@ -125,8 +172,8 @@ export declare const pikkuMiddlewareFactory: <In = any>(factory: (input: In) =>
  * export const requireRole = pikkuPermissionFactory<{ role: string }>(({
  *   role
  * }) => {
- *   return pikkuPermission(async ({ logger }, data, { initialSession }) => {
- *     if (!initialSession || initialSession.role !== role) {
+ *   return pikkuPermission(async ({ logger }, data, { session }) => {
+ *     if (!session || session.role !== role) {
  *       logger.warn(`Permission denied: required role '${role}'`)
  *       return false
  *     }
@@ -144,7 +191,7 @@ export declare const pikkuPermissionFactory: <In = any>(factory: (input: In) =>
  * @template Out - The output type that the function returns
  * @template RequiredServices - Services required by this function
  */
-export type PikkuFunctionSessionless<In = unknown, Out = never, RequiredWires extends keyof PikkuWire = never, RequiredServices extends Services = Services> = CorePikkuFunctionSessionless<In, Out, RequiredServices, PickRequired<PikkuWire<In, Out, false, Session, TypedPikkuRPC, null, any>, RequiredWires>>;
+export type PikkuFunctionSessionless<In = unknown, Out = never, RequiredWires extends keyof PikkuWire = never, RequiredServices extends Services = Services> = CorePikkuFunctionSessionless<In, Out, RequiredServices, Session, PickRequired<PikkuWire<In, Out, false, Session, TypedPikkuRPC, null, any, TypedWorkflow>, RequiredWires>>;
 /**
  * A session-aware API function that requires user authentication.
  * Use this for protected endpoints that need access to user session data.
@@ -153,7 +200,11 @@ export type PikkuFunctionSessionless<In = unknown, Out = never, RequiredWires ex
  * @template Out - The output type that the function returns
  * @template RequiredServices - Services required by this function
  */
-export type PikkuFunction<In = unknown, Out = never, RequiredWires extends keyof PikkuWire = 'session', RequiredServices extends Services = Services> = CorePikkuFunction<In, Out, RequiredServices, PickRequired<PikkuWire<In, Out, true, Session, TypedPikkuRPC, null, any>, RequiredWires>>;
+export type PikkuFunction<In = unknown, Out = never, RequiredWires extends keyof PikkuWire = 'session', RequiredServices extends Services = Services> = CorePikkuFunction<In, Out, RequiredServices, Session, PickRequired<PikkuWire<In, Out, true, Session, TypedPikkuRPC, null, any, TypedWorkflow>, RequiredWires>>;
+/**
+ * Helper type to infer the output type from a Standard Schema
+ */
+export type InferSchemaOutput<T> = T extends StandardSchemaV1<any, infer Output> ? Output : never;
 /**
  * Configuration object for Pikku functions with optional middleware, permissions, tags, and documentation.
  * This type wraps CorePikkuFunctionConfig with the user's custom types.
@@ -162,51 +213,122 @@ export type PikkuFunction<In = unknown, Out = never, RequiredWires extends keyof
  * @template Out - The output type
  * @template PikkuFunc - The function type (can be narrowed to PikkuFunction or PikkuFunctionSessionless)
  */
-export type PikkuFunctionConfig<In = unknown, Out = unknown, RequiredWires extends keyof PikkuWire = never, PikkuFunc extends PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires> = PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires>> = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware>;
+export type PikkuFunctionConfig<In = unknown, Out = unknown, RequiredWires extends keyof PikkuWire = never, PikkuFunc extends PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires> = PikkuFunction<In, Out, RequiredWires> | PikkuFunctionSessionless<In, Out, RequiredWires>, InputSchema extends StandardSchemaV1 | undefined = undefined, OutputSchema extends StandardSchemaV1 | undefined = undefined> = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware, InputSchema, OutputSchema>;
+/**
+ * Configuration object for Pikku functions with Zod schema validation.
+ * Use this when you want to define input/output schemas using Zod.
+ * Types are automatically inferred from the schemas.
+ */
+export type PikkuFunctionConfigWithSchema<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1 | undefined = undefined, RequiredWires extends keyof PikkuWire = never> = {
+    name?: string;
+    tags?: string[];
+    expose?: boolean;
+    mcp?: boolean;
+    internal?: boolean;
+    func: PikkuFunction<InferSchemaOutput<InputSchema>, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, RequiredWires> | PikkuFunctionSessionless<InferSchemaOutput<InputSchema>, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, RequiredWires>;
+    auth?: boolean;
+    permissions?: CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>>;
+    middleware?: PikkuMiddleware[];
+    input: InputSchema;
+    output?: OutputSchema;
+    node?: NodeConfig;
+};
 /**
  * Creates a Pikku function that can be either session-aware or sessionless.
  * This is the main function wrapper for creating API endpoints.
  *
- * @template In - Input type for the function
- * @template Out - Output type for the function
+ * Supports two patterns:
+ * 1. Generic types: `pikkuFunc<Input, Output>({ func: ... })`
+ * 2. Zod schemas: `pikkuFunc({ input: z.object(...), output: z.object(...), func: ... })`
+ *
+ * @template In - Input type for the function (inferred from schema if provided)
+ * @template Out - Output type for the function (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The normalized configuration object
  *
  * @example
- * \`\`\`typescript
- * const createUser = pikkuFunc<{name: string, email: string}, {id: number, message: string}>({
- *   func: async ({db, logger}, input, wire) => {
- *     const session = await wire.session.get()
- *     logger.info('Creating user', input.name)
+ * ```typescript
+ * // Pattern 1: Using generic types
+ * const createUser = pikkuFunc<{name: string, email: string}, {id: number}>({
+ *   func: async ({db}, input) => {
  *     const user = await db.users.create(input)
- *     return {id: user.id, message: \`User \${input.name} created successfully\`}
- *   },
- *   auth: true
+ *     return { id: user.id }
+ *   }
  * })
- * \`\`\`
+ *
+ * // Pattern 2: Using Zod schemas (types inferred automatically)
+ * const createUserInput = z.object({ name: z.string(), email: z.string() })
+ * const createUserOutput = z.object({ id: z.number() })
+ *
+ * const createUser = pikkuFunc({
+ *   input: createUserInput,
+ *   output: createUserOutput,
+ *   func: async ({db}, input) => {
+ *     // input is typed as { name: string, email: string }
+ *     const user = await db.users.create(input)
+ *     return { id: user.id } // must match output schema
+ *   }
+ * })
+ * ```
  */
-export declare const pikkuFunc: <In, Out = unknown>(func: PikkuFunction<In, Out, "session" | "rpc"> | PikkuFunctionConfig<In, Out, "session" | "rpc">) => PikkuFunctionConfig<In, Out, "rpc" | "session", PikkuFunction<In, Out, "rpc" | "session", Services> | PikkuFunctionSessionless<In, Out, "rpc" | "session", Services>>;
+export declare function pikkuFunc<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1 | undefined = undefined>(config: PikkuFunctionConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'session' | 'rpc'>;
+export declare function pikkuFunc<In, Out = unknown>(func: PikkuFunction<In, Out, 'session' | 'rpc'> | PikkuFunctionConfig<In, Out, 'session' | 'rpc'>): PikkuFunctionConfig<In, Out, 'session' | 'rpc'>;
+/**
+ * Configuration object for sessionless Pikku functions with Zod schema validation.
+ */
+export type PikkuFunctionSessionlessConfigWithSchema<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1 | undefined = undefined, RequiredWires extends keyof PikkuWire = never> = {
+    name?: string;
+    description?: string;
+    tags?: string[];
+    expose?: boolean;
+    mcp?: boolean;
+    internal?: boolean;
+    remote?: boolean;
+    func: PikkuFunctionSessionless<InferSchemaOutput<InputSchema>, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, RequiredWires>;
+    auth?: boolean;
+    permissions?: CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>>;
+    middleware?: PikkuMiddleware[];
+    input: InputSchema;
+    output?: OutputSchema;
+    node?: NodeConfig;
+};
 /**
  * Creates a sessionless Pikku function that doesn't require user authentication.
  * Use this for public endpoints, webhooks, or background tasks.
  *
- * @template In - Input type for the function
- * @template Out - Output type for the function
+ * Supports two patterns:
+ * 1. Generic types: `pikkuSessionlessFunc<Input, Output>({ func: ... })`
+ * 2. Zod schemas: `pikkuSessionlessFunc({ input: z.object(...), func: ... })`
+ *
+ * @template In - Input type for the function (inferred from schema if provided)
+ * @template Out - Output type for the function (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The normalized configuration object
  *
  * @example
- * \`\`\`typescript
- * const healthCheck = pikkuSessionlessFunc<void, {status: string, timestamp: string}>({
- *   func: async ({logger}, input) => {
- *     logger.info('Health check requested')
- *     return {status: 'healthy', timestamp: new Date().toISOString()}
- *   },
- *   name: 'healthCheck'
+ * ```typescript
+ * // Pattern 1: Using generic types
+ * const healthCheck = pikkuSessionlessFunc<void, {status: string}>({
+ *   func: async ({logger}) => {
+ *     return { status: 'healthy' }
+ *   }
  * })
- * \`\`\`
+ *
+ * // Pattern 2: Using Zod schemas
+ * const greetInput = z.object({ name: z.string() })
+ * const greetOutput = z.object({ message: z.string() })
+ *
+ * const greet = pikkuSessionlessFunc({
+ *   input: greetInput,
+ *   output: greetOutput,
+ *   func: async (_services, { name }) => {
+ *     return { message: `Hello, ${name}!` }
+ *   }
+ * })
+ * ```
  */
-export declare const pikkuSessionlessFunc: <In, Out = unknown>(func: PikkuFunctionSessionless<In, Out, "session" | "rpc"> | PikkuFunctionConfig<In, Out, "session" | "rpc">) => PikkuFunctionConfig<In, Out, "rpc" | "session", PikkuFunctionSessionless<In, Out, "rpc" | "session", Services> | PikkuFunction<In, Out, "rpc" | "session", Services>>;
+export declare function pikkuSessionlessFunc<InputSchema extends StandardSchemaV1, OutputSchema extends StandardSchemaV1 | undefined = undefined>(config: PikkuFunctionSessionlessConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'session' | 'rpc'>;
+export declare function pikkuSessionlessFunc<In, Out = unknown>(func: PikkuFunctionSessionless<In, Out, 'session' | 'rpc'> | PikkuFunctionConfig<In, Out, 'session' | 'rpc'>): PikkuFunctionConfig<In, Out, 'session' | 'rpc'>;
 /**
  * Creates a function that takes no input and returns no output.
  * Useful for health checks, triggers, or cleanup operations.
@@ -215,15 +337,37 @@ export declare const pikkuSessionlessFunc: <In, Out = unknown>(func: PikkuFuncti
  * @returns The normalized configuration object
  *
  * @example
- * \`\`\`typescript
+ * ```typescript
  * const cleanupTempFiles = pikkuVoidFunc(async ({fileSystem, logger}) => {
  *     logger.info('Starting cleanup of temporary files')
  *     await fileSystem.deleteDirectory('/tmp/uploads')
  *     logger.info('Cleanup completed')
  * })
- * \`\`\`
+ * ```
+ */
+export declare const pikkuVoidFunc: (func: PikkuFunctionSessionless<void, void, "session" | "rpc"> | PikkuFunctionConfig<void, void, "session" | "rpc">) => PikkuFunctionConfig<void, void, "session" | "rpc", PikkuFunctionSessionless<void, void, "session" | "rpc", Services> | PikkuFunction<void, void, "session" | "rpc", Services>, undefined, undefined>;
+/**
+ * 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.)
+ * 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
+ *
+ * @example
+ * ```typescript
+ * // Wire an external function via HTTP
+ * wireHTTP({
+ *   auth: false,
+ *   method: 'get',
+ *   route: '/external/hello',
+ *   func: external('ext:hello'),
+ *   tags: ['external'],
+ * })
+ * ```
  */
-export declare const pikkuVoidFunc: (func: PikkuFunctionSessionless<void, void, "session" | "rpc"> | PikkuFunctionConfig<void, void, "session" | "rpc">) => PikkuFunctionConfig<void, void, "rpc" | "session", PikkuFunctionSessionless<void, void, "rpc" | "session", Services> | PikkuFunction<void, void, "rpc" | "session", Services>>;
+export declare const external: <Name extends keyof FlattenedRPCMap>(rpcName: Name) => PikkuFunctionConfig<FlattenedRPCMap[Name]["input"], FlattenedRPCMap[Name]["output"], "session" | "rpc">;
 /**
  * Creates a Pikku config factory.
  * Use this to define your application's configuration factory.
@@ -278,7 +422,7 @@ export declare const pikkuServices: (func: (config: Config, existingServices?: P
  * })
  * ```
  */
-export declare const pikkuWireServices: (func: (services: SingletonServices, wire: any) => Promise<RequiredWireServices>) => (services: SingletonServices, wire: any) => Promise<RequiredWireServices>;
+export declare const pikkuWireServices: (func: (services: SingletonServices, wire: any) => Promise<RequiredWireServices>) => CreateWireServices;
 /**
  * Adds global middleware for a specific tag.
  *
@@ -327,4 +471,3 @@ export declare const addMiddleware: (tag: string, middleware: PikkuMiddleware[])
  * ```
  */
 export declare const addPermission: <In = unknown>(tag: string, permissions: CorePermissionGroup<PikkuPermission<In>> | PikkuPermission<In>[]) => void;
-export {};

package/dist/.pikku/function/pikku-function-types.gen.js

@@ -1,10 +1,11 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.12.0
  */
 /**
  * Core function, middleware, and permission types for all wirings
  */
 import { addMiddleware as addMiddlewareCore, addPermission as addPermissionCore } from '@pikku/core';
+import { pikkuAuth as pikkuAuthCore } from '@pikku/core';
 /**
  * Factory function for creating permissions with tree-shaking support.
  * Supports both direct function and configuration object syntax.
@@ -31,6 +32,29 @@ import { addMiddleware as addMiddlewareCore, addPermission as addPermissionCore
 export const pikkuPermission = (permission) => {
     return typeof permission === 'function' ? permission : permission.func;
 };
+/**
+ * Factory function for creating auth-only permissions with tree-shaking support.
+ * Auth permissions only receive services and session (no request data),
+ * making them evaluable before request data is available.
+ *
+ * @example
+ * \`\`\`typescript
+ * const isAuthenticated = pikkuAuth(async ({ logger }, session) => {
+ *   return !!session
+ * })
+ *
+ * const isAdmin = pikkuAuth({
+ *   name: 'Admin Auth',
+ *   description: 'Checks if user is an admin',
+ *   func: async ({ logger }, session) => {
+ *     return session?.role === 'admin'
+ *   }
+ * })
+ * \`\`\`
+ */
+export const pikkuAuth = (auth) => {
+    return pikkuAuthCore(auth);
+};
 /**
  * Factory function for creating middleware with tree-shaking support.
  * Supports both direct function and configuration object syntax.
@@ -86,8 +110,8 @@ export const pikkuMiddlewareFactory = (factory) => {
  * export const requireRole = pikkuPermissionFactory<{ role: string }>(({
  *   role
  * }) => {
- *   return pikkuPermission(async ({ logger }, data, { initialSession }) => {
- *     if (!initialSession || initialSession.role !== role) {
+ *   return pikkuPermission(async ({ logger }, data, { session }) => {
+ *     if (!session || session.role !== role) {
  *       logger.warn(`Permission denied: required role '${role}'`)
  *       return false
  *     }
@@ -99,54 +123,12 @@ export const pikkuMiddlewareFactory = (factory) => {
 export const pikkuPermissionFactory = (factory) => {
     return factory;
 };
-/**
- * Creates a Pikku function that can be either session-aware or sessionless.
- * This is the main function wrapper for creating API endpoints.
- *
- * @template In - Input type for the function
- * @template Out - Output type for the function
- * @param func - Function definition, either direct function or configuration object
- * @returns The normalized configuration object
- *
- * @example
- * \`\`\`typescript
- * const createUser = pikkuFunc<{name: string, email: string}, {id: number, message: string}>({
- *   func: async ({db, logger}, input, wire) => {
- *     const session = await wire.session.get()
- *     logger.info('Creating user', input.name)
- *     const user = await db.users.create(input)
- *     return {id: user.id, message: \`User \${input.name} created successfully\`}
- *   },
- *   auth: true
- * })
- * \`\`\`
- */
-export const pikkuFunc = (func) => {
+export function pikkuFunc(func) {
     return typeof func === 'function' ? { func } : func;
-};
-/**
- * Creates a sessionless Pikku function that doesn't require user authentication.
- * Use this for public endpoints, webhooks, or background tasks.
- *
- * @template In - Input type for the function
- * @template Out - Output type for the function
- * @param func - Function definition, either direct function or configuration object
- * @returns The normalized configuration object
- *
- * @example
- * \`\`\`typescript
- * const healthCheck = pikkuSessionlessFunc<void, {status: string, timestamp: string}>({
- *   func: async ({logger}, input) => {
- *     logger.info('Health check requested')
- *     return {status: 'healthy', timestamp: new Date().toISOString()}
- *   },
- *   name: 'healthCheck'
- * })
- * \`\`\`
- */
-export const pikkuSessionlessFunc = (func) => {
+}
+export function pikkuSessionlessFunc(func) {
     return typeof func === 'function' ? { func } : func;
-};
+}
 /**
  * Creates a function that takes no input and returns no output.
  * Useful for health checks, triggers, or cleanup operations.
@@ -155,17 +137,45 @@ export const pikkuSessionlessFunc = (func) => {
  * @returns The normalized configuration object
  *
  * @example
- * \`\`\`typescript
+ * ```typescript
  * const cleanupTempFiles = pikkuVoidFunc(async ({fileSystem, logger}) => {
  *     logger.info('Starting cleanup of temporary files')
  *     await fileSystem.deleteDirectory('/tmp/uploads')
  *     logger.info('Cleanup completed')
  * })
- * \`\`\`
+ * ```
  */
 export const pikkuVoidFunc = (func) => {
     return typeof func === 'function' ? { func } : func;
 };
+/**
+ * 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.)
+ * 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
+ *
+ * @example
+ * ```typescript
+ * // Wire an external function via HTTP
+ * wireHTTP({
+ *   auth: false,
+ *   method: 'get',
+ *   route: '/external/hello',
+ *   func: external('ext:hello'),
+ *   tags: ['external'],
+ * })
+ * ```
+ */
+export const external = (rpcName) => {
+    return {
+        func: (async (_services, data, { rpc }) => {
+            return rpc.invoke(rpcName, data);
+        })
+    };
+};
 /**
  * Creates a Pikku config factory.
  * Use this to define your application's configuration factory.
@@ -245,7 +255,7 @@ export const pikkuWireServices = (func) => func;
  * ```
  */
 export const addMiddleware = (tag, middleware) => {
-    addMiddlewareCore(tag, middleware);
+    addMiddlewareCore(tag, middleware, null);
 };
 /**
  * Adds global permissions for a specific tag.
@@ -271,5 +281,5 @@ export const addMiddleware = (tag, middleware) => {
  * ```
  */
 export const addPermission = (tag, permissions) => {
-    addPermissionCore(tag, permissions);
+    addPermissionCore(tag, permissions, null);
 };

package/dist/.pikku/function/pikku-functions-meta.gen.js

@@ -1,6 +1,6 @@
 /**
- * This file was generated by @pikku/cli@0.11.2
+ * This file was generated by @pikku/cli@0.12.0
  */
 import { pikkuState } from '@pikku/core';
 import metaData from './pikku-functions-meta.gen.json' with { type: 'json' };
-pikkuState('function', 'meta', metaData);
+pikkuState(null, 'function', 'meta', metaData);