@pikku/cli 0.11.3 → 0.12.0

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

@@ -1,13 +1,21 @@
 /**
  * Generates core function, middleware, and permission type definitions
  */
-export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, wireServicesTypeImport, wireServicesTypeName, rpcMapTypeImport, requiredServicesTypeImport, configTypeImport, packageName) => {
+export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeName, singletonServicesTypeImport, singletonServicesTypeName, wireServicesTypeImport, wireServicesTypeName, rpcMapTypeImport, requiredServicesTypeImport, configTypeImport, packageName, workflowTypesImport, nodeCategories) => {
     const packageNameValue = packageName ? `'${packageName}'` : 'null';
+    const nodeCategoryType = nodeCategories?.length
+        ? nodeCategories.map((c) => `'${c}'`).join(' | ')
+        : 'string';
+    const workflowImport = workflowTypesImport ||
+        `import type { TypedWorkflow } from '../workflow/pikku-workflow-types.gen.js'`;
     return `/**
  * Core function, middleware, and permission types for all wirings
  */
 
-import { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired, ZodLike, CreateWireServices } from '@pikku/core'
+import { CorePikkuFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired, CreateWireServices } from '@pikku/core'
+import { pikkuAuth as pikkuAuthCore } from '@pikku/core'
+import type { NodeType } from '@pikku/core/node'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
 import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
 
 ${userSessionTypeImport}
@@ -16,11 +24,22 @@ ${wireServicesTypeImport}
 ${configTypeImport}
 ${rpcMapTypeImport}
 ${requiredServicesTypeImport}
+${workflowImport}
 
-${singletonServicesTypeName !== 'SingletonServices' ? `type SingletonServices = ${singletonServicesTypeName}` : ''}
-${wireServicesTypeName !== 'Services' ? `type Services = ${wireServicesTypeName}` : ''}
-${userSessionTypeName !== 'Session' ? `type Session = ${userSessionTypeName}` : ''}
-${configTypeImport.includes('Config type not found') ? 'type Config = any' : ''}
+${singletonServicesTypeName !== 'SingletonServices' ? `export type SingletonServices = ${singletonServicesTypeName}` : `export type { ${singletonServicesTypeName} as SingletonServices }`}
+${wireServicesTypeName !== 'Services' ? `export type Services = ${wireServicesTypeName}` : `export type { ${wireServicesTypeName} as Services }`}
+${userSessionTypeName !== 'Session' ? `export type Session = ${userSessionTypeName}` : `export type { ${userSessionTypeName} as Session }`}
+${configTypeImport.includes('Config type not found') ? 'export type Config = any' : ''}
+
+/**
+ * Inline node configuration for function definitions.
+ */
+export type NodeConfig = {
+  displayName: string
+  category: ${nodeCategoryType}
+  type: NodeType
+  errorOutput?: boolean
+}
 
 /**
  * Type-safe API permission definition that integrates with your application's session type.
@@ -80,6 +99,46 @@ export const pikkuPermission = <In>(
   return typeof permission === 'function' ? permission : permission.func
 }
 
+/**
+ * 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 const pikkuAuth = <RequiredServices extends SingletonServices = SingletonServices>(
+  auth: PikkuAuth<RequiredServices> | PikkuAuthConfig<RequiredServices>
+): PikkuPermission<any, any> => {
+  return pikkuAuthCore(auth as any) as any
+}
+
 /**
  * Configuration object for creating middleware with metadata
  */
@@ -153,8 +212,8 @@ export const pikkuMiddlewareFactory = <In = any>(
  * 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
  *     }
@@ -186,7 +245,8 @@ export type PikkuFunctionSessionless<
     In,
     Out,
     RequiredServices,
-    PickRequired<PikkuWire<In, Out, false, Session, TypedPikkuRPC, null, any>, RequiredWires>
+    Session,
+    PickRequired<PikkuWire<In, Out, false, Session, TypedPikkuRPC, null, any, TypedWorkflow>, RequiredWires>
   >
 
 /**
@@ -206,13 +266,14 @@ export type PikkuFunction<
     In,
     Out,
     RequiredServices,
-    PickRequired<PikkuWire<In, Out, true, Session, TypedPikkuRPC, null, any>, RequiredWires>
+    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.
@@ -227,8 +288,8 @@ export type PikkuFunctionConfig<
   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
+  InputSchema extends StandardSchemaV1 | undefined = undefined,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
 > = CorePikkuFunctionConfig<PikkuFunc, PikkuPermission<In>, PikkuMiddleware, InputSchema, OutputSchema>
 
 /**
@@ -237,28 +298,30 @@ export type PikkuFunctionConfig<
  * Types are automatically inferred from the schemas.
  */
 export type PikkuFunctionConfigWithSchema<
-  InputSchema extends ZodLike,
-  OutputSchema extends ZodLike | undefined = undefined,
+  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,
+    InferSchemaOutput<InputSchema>,
+    OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown,
     RequiredWires
   > | PikkuFunctionSessionless<
-    InferZodOutput<InputSchema>,
-    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    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
 }
 
 /**
@@ -300,11 +363,11 @@ export type PikkuFunctionConfigWithSchema<
  * \`\`\`
  */
 export function pikkuFunc<
-  InputSchema extends ZodLike,
-  OutputSchema extends ZodLike | undefined = undefined
+  InputSchema extends StandardSchemaV1,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
 >(
   config: PikkuFunctionConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>
-): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'session' | 'rpc'>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'session' | 'rpc'>
 export function pikkuFunc<In, Out = unknown>(
   func:
     | PikkuFunction<In, Out, 'session' | 'rpc'>
@@ -318,25 +381,28 @@ export function pikkuFunc(func: any) {
  * Configuration object for sessionless Pikku functions with Zod schema validation.
  */
 export type PikkuFunctionSessionlessConfigWithSchema<
-  InputSchema extends ZodLike,
-  OutputSchema extends ZodLike | undefined = undefined,
+  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<
-    InferZodOutput<InputSchema>,
-    OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown,
+    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
 }
 
 /**
@@ -375,11 +441,11 @@ export type PikkuFunctionSessionlessConfigWithSchema<
  * \`\`\`
  */
 export function pikkuSessionlessFunc<
-  InputSchema extends ZodLike,
-  OutputSchema extends ZodLike | undefined = undefined
+  InputSchema extends StandardSchemaV1,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
 >(
   config: PikkuFunctionSessionlessConfigWithSchema<InputSchema, OutputSchema, 'session' | 'rpc'>
-): PikkuFunctionConfig<InferZodOutput<InputSchema>, OutputSchema extends ZodLike ? InferZodOutput<OutputSchema> : unknown, 'session' | 'rpc'>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'session' | 'rpc'>
 export function pikkuSessionlessFunc<In, Out = unknown>(
   func:
     | PikkuFunctionSessionless<In, Out, 'session' | 'rpc'>
@@ -473,6 +539,7 @@ export const pikkuConfig = (
   func: (variables?: any, ...args: any[]) => Promise<Config>
 ) => func
 
+
 /**
  * Creates a Pikku singleton services factory.
  * Use this to define services that are created once and shared across all requests.

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

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

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

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

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

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

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

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

@@ -1 +1 @@
-export declare const pikkuHTTP: any;
+export declare const pikkuHTTP: 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/http/pikku-command-http-routes.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/http/pikku-command-http-types.d.ts

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

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

@@ -1,23 +1,25 @@
-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 { generateSchemas } from '../../../utils/schema-generator.js';
-import { generateOpenAPISpec } from './openapi-spec-generator.js';
 import { stringify } from 'yaml';
 export const pikkuOpenAPI = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { tsconfig, openAPI, schemasFromTypes } = config;
-        // If openAPI outputFile is not defined, clean up any existing file and return
+        const { openAPI } = config;
         if (!openAPI?.outputFile) {
-            logger.info({
+            logger.debug({
                 message: 'Skipping creating OpenAPI spec since openAPI outfile is not defined.',
                 type: 'skip',
             });
             return;
         }
-        const { http, functions, zodLookup } = await getInspectorState();
-        const schemas = await generateSchemas(logger, tsconfig, functions.typesMap, functions.meta, http.meta, schemasFromTypes, config.schema?.additionalProperties, zodLookup);
-        const openAPISpec = await generateOpenAPISpec(logger, functions.meta, http.meta, schemas, openAPI.additionalInfo);
+        const { openAPISpec } = await getInspectorState();
+        if (!openAPISpec) {
+            logger.debug({
+                message: 'Skipping creating OpenAPI spec since no spec was generated.',
+                type: 'skip',
+            });
+            return;
+        }
         if (openAPI.outputFile.endsWith('.json')) {
             await writeFileInDir(logger, openAPI.outputFile, JSON.stringify(openAPISpec, null, 2), { ignoreModifyComment: true });
         }

package/dist/src/functions/wirings/http/pikku-http-routes.d.ts

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

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

@@ -6,9 +6,9 @@ export const serializeHTTPTypes = (functionTypesImportPath) => {
  * HTTP-specific type definitions for tree-shaking optimization
  */
 
-import { AssertHTTPWiringParams, wireHTTP as wireHTTPCore, addHTTPMiddleware as addHTTPMiddlewareCore, addHTTPPermission as addHTTPPermissionCore } from '@pikku/core/http'
-import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
-import type { CoreHTTPFunctionWiring, HTTPMethod } from '@pikku/core/http'
+import { AssertHTTPWiringParams, wireHTTP as wireHTTPCore, addHTTPMiddleware as addHTTPMiddlewareCore, addHTTPPermission as addHTTPPermissionCore, wireHTTPRoutes as wireHTTPRoutesCore, defineHTTPRoutes as defineHTTPRoutesCore } from '@pikku/core/http'
+import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware, PikkuFunctionConfig } from '${functionTypesImportPath}'
+import type { CoreHTTPFunctionWiring, HTTPMethod, HTTPRouteBaseConfig } from '@pikku/core/http'
 
 /**
  * Type definition for HTTP API wirings with type-safe path parameters.
@@ -20,22 +20,6 @@ import type { CoreHTTPFunctionWiring, HTTPMethod } from '@pikku/core/http'
  */
 type HTTPWiring<In, Out, Route extends string> = CoreHTTPFunctionWiring<In, Out, Route, PikkuFunction<In, Out, 'rpc' | 'session'>, PikkuFunctionSessionless<In, Out, 'rpc' | 'session'>, PikkuPermission<In>, PikkuMiddleware>
 
-/**
- * HTTP wiring for workflow triggers (no function needed)
- */
-type HTTPWorkflowWiring<Route extends string> = {
-  route: Route
-  method: HTTPMethod
-  workflow: true
-  func?: undefined
-  permissions?: undefined
-  auth?: undefined
-  tags?: undefined
-  middleware?: undefined
-  returnsJSON?: undefined
-  sse?: boolean
-}
-
 /**
  * Registers an HTTP wiring with the Pikku framework.
  *
@@ -45,7 +29,7 @@ type HTTPWorkflowWiring<Route extends string> = {
  * @param httpWiring - HTTP wiring definition with handler, method, and optional middleware
  */
 export const wireHTTP = <In, Out, Route extends string>(
-  httpWiring: (HTTPWiring<In, Out, Route> & AssertHTTPWiringParams<In, Route>) | HTTPWorkflowWiring<Route>
+  httpWiring: HTTPWiring<In, Out, Route> & AssertHTTPWiringParams<In, Route>
 ) => {
   wireHTTPCore(httpWiring as any)
 }
@@ -101,5 +85,66 @@ export const addHTTPPermission = <In = unknown>(
 ) => {
   addHTTPPermissionCore(pattern, permissions as any)
 }
+
+/**
+ * Route configuration for wireHTTPRoutes with proper typing
+ */
+type HTTPRouteConfig = HTTPRouteBaseConfig & {
+  method: HTTPMethod
+  route: string
+  func: PikkuFunctionConfig<any, any, any, any, any, any>
+  auth?: boolean
+  permissions?: Record<string, PikkuPermission | PikkuPermission[]>
+  middleware?: PikkuMiddleware[]
+  sse?: boolean
+}
+
+/**
+ * Typed route map for wireHTTPRoutes
+ */
+type TypedHTTPRouteMap = {
+  [key: string]: HTTPRouteConfig | TypedHTTPRouteMap | TypedHTTPRouteContract
+}
+
+/**
+ * Typed route contract for defineHTTPRoutes
+ */
+type TypedHTTPRouteContract<T extends TypedHTTPRouteMap = TypedHTTPRouteMap> = TypedHTTPRoutesGroupConfig & {
+  routes: T
+}
+
+/**
+ * Group config with typed middleware/permissions
+ */
+type TypedHTTPRoutesGroupConfig = {
+  basePath?: string
+  tags?: string[]
+  auth?: boolean
+  middleware?: PikkuMiddleware[]
+  permissions?: Record<string, PikkuPermission | PikkuPermission[]>
+}
+
+/**
+ * Full config for wireHTTPRoutes
+ */
+type TypedWireHTTPRoutesConfig = TypedHTTPRoutesGroupConfig & {
+  routes: TypedHTTPRouteMap | HTTPRouteConfig[]
+}
+
+/**
+ * Type-safe helper for defining route contracts that can be composed.
+ */
+export function defineHTTPRoutes<T extends TypedHTTPRouteMap>(routes: T): TypedHTTPRouteContract<T>
+export function defineHTTPRoutes<T extends TypedHTTPRouteMap>(config: TypedHTTPRoutesGroupConfig & { routes: T }): TypedHTTPRouteContract<T>
+export function defineHTTPRoutes<T extends TypedHTTPRouteMap>(configOrRoutes: T | (TypedHTTPRoutesGroupConfig & { routes: T })): TypedHTTPRouteContract<T> {
+  return defineHTTPRoutesCore(configOrRoutes as any) as unknown as TypedHTTPRouteContract<T>
+}
+
+/**
+ * Wires multiple HTTP routes from a nested map or array configuration.
+ */
+export const wireHTTPRoutes = (config: TypedWireHTTPRoutesConfig): void => {
+  wireHTTPRoutesCore(config as any)
+}
 `;
 };

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

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

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

@@ -1,17 +1,34 @@
 import { serializeImportMap } from '../../../utils/serialize-import-map.js';
-import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
-export const serializeTypedHTTPWiringsMap = (relativeToPath, packageMappings, typesMap, functionsMeta, wiringsMeta, metaTypes) => {
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { generateCustomTypes } from '@pikku/inspector';
+export const serializeTypedHTTPWiringsMap = (logger, relativeToPath, packageMappings, typesMap, wiringsMeta, metaTypes, resolvedIOTypes, rpcInternalMapDeclarationFile) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
-    const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap);
-    const serializedHTTPWirings = generateHTTPWirings(wiringsMeta, functionsMeta, typesMap, requiredTypes);
-    const serializedImportMap = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    const serializedMetaTypes = generateMetaTypes(metaTypes, typesMap, requiredTypes);
+    const serializedHTTPWirings = generateHTTPWirings(wiringsMeta, resolvedIOTypes, requiredTypes);
+    const needsFlattenedRPCMap = Array.from(requiredTypes).some((t) => t.includes('FlattenedRPCMap'));
+    if (needsFlattenedRPCMap) {
+        for (const t of Array.from(requiredTypes)) {
+            if (t.includes('FlattenedRPCMap')) {
+                requiredTypes.delete(t);
+            }
+        }
+    }
+    const serializedImportMap = serializeImportMap(logger, relativeToPath, packageMappings, typesMap, requiredTypes);
+    const rpcMapImport = needsFlattenedRPCMap
+        ? `import type { FlattenedRPCMap } from '${getFileImportRelativePath(relativeToPath, rpcInternalMapDeclarationFile, packageMappings)}'`
+        : '';
+    const serializedCustomTypesDeclarationsOnly = serializedCustomTypes
+        .split('\n')
+        .filter((line) => !line.startsWith('import '))
+        .join('\n');
     return `/**
  * This provides the structure needed for typescript to be aware of routes and their return types
  */
 
 ${serializedImportMap}
-${serializedCustomTypes}
+${rpcMapImport}
+${serializedCustomTypesDeclarationsOnly}
 ${serializedMetaTypes}
 
 interface HTTPWiringHandler<I, O> {
@@ -31,52 +48,21 @@ export type HTTPWiringsWithMethod<Method extends string> = {
 }[keyof HTTPWiringsMap];
   `;
 };
-function generateHTTPWirings(routesMeta, functionsMeta, typesMap, requiredTypes) {
-    // Initialize an object to collect routes
+function generateHTTPWirings(routesMeta, resolvedIOTypes, requiredTypes) {
     const routesObj = {};
     for (const methods of Object.values(routesMeta)) {
         for (const meta of Object.values(methods)) {
-            const { route, method, pikkuFuncName } = meta;
-            // Skip workflow-triggered routes (they don't have a function)
-            if (meta.workflow) {
-                continue;
-            }
-            const functionMeta = functionsMeta[pikkuFuncName];
-            if (!functionMeta) {
-                throw new Error(`Function ${pikkuFuncName} not found in functionsMeta. Please check your configuration.`);
-            }
-            const input = functionMeta.inputs ? functionMeta.inputs[0] : undefined;
-            const output = functionMeta.outputs ? functionMeta.outputs[0] : undefined;
+            const { route, method, pikkuFuncId } = meta;
             if (!routesObj[route]) {
                 routesObj[route] = {};
             }
-            // 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 {
-                    // Zod-derived schema - use the schema name directly
-                    outputType = output;
-                }
+            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 method entry
-            routesObj[route][method] = {
-                inputType,
-                outputType,
-            };
+            requiredTypes.add(resolved.inputType);
+            requiredTypes.add(resolved.outputType);
+            routesObj[route][method] = resolved;
         }
     }
     // Build the routes object as a string
@@ -91,7 +77,7 @@ function generateHTTPWirings(routesMeta, functionsMeta, typesMap, requiredTypes)
     routesStr += '};';
     return routesStr;
 }
-const generateMetaTypes = (metaTypes, typesMap) => {
+const generateMetaTypes = (metaTypes, typesMap, requiredTypes) => {
     const nameToTypeMap = Array.from(metaTypes.entries()).reduce((result, [_name, { query, body, params }]) => {
         let uniqueName;
         try {
@@ -101,6 +87,7 @@ const generateMetaTypes = (metaTypes, typesMap) => {
             // Zod-derived schema - use the name directly
             uniqueName = _name;
         }
+        requiredTypes.add(uniqueName);
         const queryType = query && query.length > 0
             ? `Pick<${uniqueName}, '${query?.join("' | '")}'>`
             : undefined;

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

@@ -1 +1 @@
-export declare const pikkuMCPJSON: any;
+export declare const pikkuMCPJSON: 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>;