@pikku/cli 0.11.3 → 0.12.1

package/dist/.pikku/cli/pikku-cli-wirings-meta.gen.json

@@ -4,7 +4,7 @@
             "program": "pikku",
             "commands": {
                 "all": {
-                    "pikkuFuncName": "all",
+                    "pikkuFuncId": "all",
                     "positionals": [],
                     "options": {
                         "tags": {
@@ -33,58 +33,303 @@
                     "isDefault": true
                 },
                 "bootstrap": {
-                    "pikkuFuncName": "bootstrap",
+                    "pikkuFuncId": "bootstrap",
                     "positionals": [],
                     "options": {},
                     "description": "Generate only type files (setup phase only)"
                 },
                 "watch": {
-                    "pikkuFuncName": "watch",
+                    "pikkuFuncId": "watch",
                     "positionals": [],
                     "options": {},
                     "description": "Watch for file changes and regenerate automatically"
                 },
+                "console": {
+                    "pikkuFuncId": "consoleCommand",
+                    "positionals": [],
+                    "options": {
+                        "port": {
+                            "description": "Port for the console server",
+                            "default": "51442",
+                            "short": "p"
+                        }
+                    },
+                    "description": "Start the Pikku Console UI with live file watching"
+                },
                 "schemas": {
-                    "pikkuFuncName": "pikkuSchemas",
+                    "pikkuFuncId": "pikkuSchemas",
                     "positionals": [],
                     "options": {},
                     "description": "Generate JSON schemas for function input/output types"
                 },
                 "fetch": {
-                    "pikkuFuncName": "pikkuFetch",
+                    "pikkuFuncId": "pikkuFetch",
                     "positionals": [],
                     "options": {},
                     "description": "Generate type-safe HTTP fetch client"
                 },
                 "websocket": {
-                    "pikkuFuncName": "pikkuWebSocketTyped",
+                    "pikkuFuncId": "pikkuWebSocketTyped",
                     "positionals": [],
                     "options": {},
                     "description": "Generate type-safe WebSocket client"
                 },
                 "rpc": {
-                    "pikkuFuncName": "pikkuRPCClient",
+                    "pikkuFuncId": "pikkuRPCClient",
                     "positionals": [],
                     "options": {},
                     "description": "Generate RPC client wrappers"
                 },
                 "queue-service": {
-                    "pikkuFuncName": "pikkuQueueService",
+                    "pikkuFuncId": "pikkuQueueService",
                     "positionals": [],
                     "options": {},
                     "description": "Generate queue service wrapper"
                 },
                 "openapi": {
-                    "pikkuFuncName": "pikkuOpenAPI",
+                    "pikkuFuncId": "pikkuOpenAPI",
                     "positionals": [],
                     "options": {},
                     "description": "Generate OpenAPI specification from HTTP routes"
                 },
                 "nextjs": {
-                    "pikkuFuncName": "pikkuNext",
+                    "pikkuFuncId": "pikkuNext",
                     "positionals": [],
                     "options": {},
                     "description": "Generate Next.js backend and HTTP wrappers"
+                },
+                "new": {
+                    "pikkuFuncId": "",
+                    "positionals": [],
+                    "options": {},
+                    "description": "Scaffold new functions and wirings",
+                    "subcommands": {
+                        "function": {
+                            "pikkuFuncId": "pikkuNewFunction",
+                            "positionals": [
+                                {
+                                    "name": "name",
+                                    "required": true
+                                }
+                            ],
+                            "options": {
+                                "type": {
+                                    "description": "Function type: func, sessionless (default), or void",
+                                    "short": "t",
+                                    "default": "sessionless"
+                                }
+                            },
+                            "description": "Create a new Pikku function file",
+                            "parameters": "<name>"
+                        },
+                        "wiring": {
+                            "pikkuFuncId": "pikkuNewWiring",
+                            "positionals": [
+                                {
+                                    "name": "name",
+                                    "required": true
+                                }
+                            ],
+                            "options": {
+                                "type": {
+                                    "description": "Wiring type: http (default), channel, scheduler, queue, mcp, cli, or trigger",
+                                    "short": "t",
+                                    "default": "http"
+                                }
+                            },
+                            "description": "Create a new wiring file",
+                            "parameters": "<name>"
+                        },
+                        "middleware": {
+                            "pikkuFuncId": "pikkuNewMiddleware",
+                            "positionals": [
+                                {
+                                    "name": "name",
+                                    "required": true
+                                }
+                            ],
+                            "options": {
+                                "type": {
+                                    "description": "Middleware type: simple (default) or factory",
+                                    "short": "t",
+                                    "default": "simple"
+                                }
+                            },
+                            "description": "Create a new middleware file",
+                            "parameters": "<name>"
+                        },
+                        "permission": {
+                            "pikkuFuncId": "pikkuNewPermission",
+                            "positionals": [
+                                {
+                                    "name": "name",
+                                    "required": true
+                                }
+                            ],
+                            "options": {
+                                "type": {
+                                    "description": "Permission type: simple (default) or factory",
+                                    "short": "t",
+                                    "default": "simple"
+                                }
+                            },
+                            "description": "Create a new permission file",
+                            "parameters": "<name>"
+                        },
+                        "addon": {
+                            "pikkuFuncId": "pikkuNewAddon",
+                            "positionals": [
+                                {
+                                    "name": "name",
+                                    "required": true
+                                }
+                            ],
+                            "options": {
+                                "displayName": {
+                                    "description": "Human-readable display name (defaults to PascalCase of name)"
+                                },
+                                "description": {
+                                    "description": "Package description (defaults to \"{displayName} integration for Pikku\")"
+                                },
+                                "category": {
+                                    "description": "Forge category (defaults to \"General\")",
+                                    "default": "General"
+                                },
+                                "dir": {
+                                    "description": "Override output directory (defaults to scaffold.addonDir or cwd)",
+                                    "short": "d"
+                                },
+                                "secret": {
+                                    "description": "Include secret schema file",
+                                    "default": false
+                                },
+                                "variable": {
+                                    "description": "Include variable definition file",
+                                    "default": false
+                                },
+                                "oauth": {
+                                    "description": "Include OAuth2 credential wiring and OAuth2Client-based API service",
+                                    "default": false
+                                },
+                                "test": {
+                                    "description": "Include test harness (default: true)",
+                                    "default": true
+                                },
+                                "openapi": {
+                                    "description": "Path to OpenAPI YAML/JSON spec to generate functions from"
+                                }
+                            },
+                            "description": "Scaffold a new addon package",
+                            "parameters": "<name>"
+                        }
+                    }
+                },
+                "versions": {
+                    "pikkuFuncId": "",
+                    "positionals": [],
+                    "options": {},
+                    "description": "Manage function contract versions",
+                    "subcommands": {
+                        "init": {
+                            "pikkuFuncId": "pikkuVersionsInit",
+                            "positionals": [],
+                            "options": {
+                                "force": {
+                                    "description": "Overwrite existing manifest"
+                                }
+                            },
+                            "description": "Initialize the version manifest (versions.json)"
+                        },
+                        "check": {
+                            "pikkuFuncId": "pikkuVersionsCheck",
+                            "positionals": [],
+                            "options": {},
+                            "description": "Validate function contracts against the version manifest"
+                        },
+                        "update": {
+                            "pikkuFuncId": "pikkuVersionsUpdate",
+                            "positionals": [],
+                            "options": {},
+                            "description": "Update the version manifest with current contract hashes"
+                        }
+                    }
+                },
+                "info": {
+                    "pikkuFuncId": "pikkuInfoFunctions",
+                    "positionals": [],
+                    "options": {
+                        "limit": {
+                            "description": "Maximum number of rows to display",
+                            "default": "50"
+                        },
+                        "verbose": {
+                            "description": "Show additional details (file paths, services, etc.)",
+                            "default": false
+                        }
+                    },
+                    "description": "Show information about Pikku project resources",
+                    "subcommands": {
+                        "functions": {
+                            "pikkuFuncId": "pikkuInfoFunctions",
+                            "positionals": [],
+                            "options": {
+                                "limit": {
+                                    "description": "Maximum number of rows to display",
+                                    "default": "50"
+                                },
+                                "verbose": {
+                                    "description": "Show additional details (type, middleware, file)",
+                                    "default": false
+                                }
+                            },
+                            "description": "List all registered functions"
+                        },
+                        "tags": {
+                            "pikkuFuncId": "pikkuInfoTags",
+                            "positionals": [],
+                            "options": {
+                                "limit": {
+                                    "description": "Maximum number of rows to display",
+                                    "default": "50"
+                                },
+                                "verbose": {
+                                    "description": "Show names instead of counts",
+                                    "default": false
+                                }
+                            },
+                            "description": "List all tags with associated functions, middleware, and permissions"
+                        },
+                        "middleware": {
+                            "pikkuFuncId": "pikkuInfoMiddleware",
+                            "positionals": [],
+                            "options": {
+                                "limit": {
+                                    "description": "Maximum number of rows to display",
+                                    "default": "50"
+                                },
+                                "verbose": {
+                                    "description": "Show additional details (sourceFile, services)",
+                                    "default": false
+                                }
+                            },
+                            "description": "List all middleware definitions"
+                        },
+                        "permissions": {
+                            "pikkuFuncId": "pikkuInfoPermissions",
+                            "positionals": [],
+                            "options": {
+                                "limit": {
+                                    "description": "Maximum number of rows to display",
+                                    "default": "50"
+                                },
+                                "verbose": {
+                                    "description": "Show additional details (sourceFile, services)",
+                                    "default": false
+                                }
+                            },
+                            "description": "List all permission definitions"
+                        }
+                    }
                 }
             },
             "options": {
@@ -138,7 +383,12 @@
                     "secrets",
                     "workflowService",
                     "queueService",
-                    "schedulerService"
+                    "schedulerService",
+                    "deploymentService",
+                    "aiStorage",
+                    "content",
+                    "aiAgentRunner",
+                    "aiRunState"
                 ]
             },
             "filePath": "/home/runner/work/pikku/pikku/packages/cli/src/services.ts"

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

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.11.3
+ * This file was generated by @pikku/cli@0.12.1
  */
 import '../../src/cli.wiring.js';
 import '../../src/services.js';

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

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.11.3
+ * This file was generated by @pikku/cli@0.12.1
  */
 /* The files with an wireCLI function call */
 import '../../src/cli.wiring.js';

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

@@ -1,10 +1,6 @@
 /**
- * This file was generated by @pikku/cli@0.11.3
+ * This file was generated by @pikku/cli@0.12.1
  */
 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.3
+ * This file was generated by @pikku/cli@0.12.1
  */
 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.1
+ */
+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,10 +1,13 @@
 /**
- * This file was generated by @pikku/cli@0.11.3
+ * This file was generated by @pikku/cli@0.12.1
  */
 /**
  * Core function, middleware, and permission types for all wirings
  */
-import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, PikkuWire, PickRequired, ZodLike, CreateWireServices } from '@pikku/core';
+import { CorePikkuFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, PikkuWire, PickRequired } from '@pikku/core';
+import { CreateWireServices } from '@pikku/core/internal';
+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';
@@ -12,7 +15,19 @@ import type { Services } from '../../types/application-types.d.js';
 import type { Config } from '../../types/application-types.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 +78,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 +173,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 +192,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,11 +201,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 Zod schema
+ * Helper type to infer the output type from a Standard Schema
  */
-export type InferZodOutput<T> = T extends ZodLike<infer U> ? U : never;
+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.
@@ -166,23 +214,25 @@ export type InferZodOutput<T> = T extends ZodLike<infer U> ? U : never;
  * @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>, InputSchema extends ZodLike | undefined = undefined, OutputSchema extends ZodLike | undefined = undefined> = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware, InputSchema, OutputSchema>;
+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 ZodLike, OutputSchema extends ZodLike | undefined = undefined, RequiredWires extends keyof PikkuWire = never> = {
+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<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, RequiredWires> | PikkuFunctionSessionless<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, RequiredWires>;
+    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<InferZodOutput<InputSchema>>>;
+    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.
@@ -222,23 +272,26 @@ export type PikkuFunctionConfigWithSchema<InputSchema extends ZodLike, OutputSch
  * })
  * ```
  */
-export declare function pikkuFunc<InputSchema extends ZodLike, OutputSchema extends ZodLike | undefined = undefined>(config: PikkuFunctionConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'session' | 'rpc'>;
+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 ZodLike, OutputSchema extends ZodLike | undefined = undefined, RequiredWires extends keyof PikkuWire = never> = {
+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;
-    func: PikkuFunctionSessionless<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, RequiredWires>;
+    remote?: boolean;
+    func: PikkuFunctionSessionless<InferSchemaOutput<InputSchema>, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, RequiredWires>;
     auth?: boolean;
-    permissions?: CorePermissionGroup<PikkuPermission<InferZodOutput<InputSchema>>>;
+    permissions?: CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>>;
     middleware?: PikkuMiddleware[];
     input: InputSchema;
     output?: OutputSchema;
+    node?: NodeConfig;
 };
 /**
  * Creates a sessionless Pikku function that doesn't require user authentication.
@@ -275,7 +328,7 @@ export type PikkuFunctionSessionlessConfigWithSchema<InputSchema extends ZodLike
  * })
  * ```
  */
-export declare function pikkuSessionlessFunc<InputSchema extends ZodLike, OutputSchema extends ZodLike | undefined = undefined>(config: PikkuFunctionSessionlessConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'session' | 'rpc'>;
+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.
@@ -293,29 +346,29 @@ export declare function pikkuSessionlessFunc<In, Out = unknown>(func: PikkuFunct
  * })
  * ```
  */
-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>, undefined, undefined>;
+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.)
+ * 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 declare const external: <Name extends keyof FlattenedRPCMap>(rpcName: Name) => PikkuFunctionConfig<FlattenedRPCMap[Name]["input"], FlattenedRPCMap[Name]["output"], "session" | "rpc">;
+export declare const addon: <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.
@@ -352,7 +405,7 @@ export declare const pikkuConfig: (func: (variables?: any, ...args: any[]) => Pr
  * })
  * ```
  */
-export declare const pikkuServices: (func: (config: Config, existingServices?: Partial<SingletonServices>) => Promise<RequiredSingletonServices>) => (config: Config, existingServices?: Partial<SingletonServices>) => Promise<RequiredSingletonServices>;
+export declare const pikkuServices: (func: (config: Config, existingServices: Partial<SingletonServices>) => Promise<RequiredSingletonServices>) => (config: Config, existingServices?: Partial<SingletonServices>) => Promise<RequiredSingletonServices>;
 /**
  * Creates a Pikku wire services factory.
  * Use this to define services that are created per-request/session.
@@ -419,4 +472,5 @@ export declare const addMiddleware: (tag: string, middleware: PikkuMiddleware[])
  * ```
  */
 export declare const addPermission: <In = unknown>(tag: string, permissions: CorePermissionGroup<PikkuPermission<In>> | PikkuPermission<In>[]) => void;
-export {};
+export { wireAddon } from '@pikku/core';
+export type { WireAddonConfig } from '@pikku/core';