@pikku/cli 0.11.2 → 0.12.0

package/dist/src/functions/wirings/ai-agent/pikku-command-ai-agent.js

@@ -0,0 +1,68 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
+import { serializeAgentMap } from './serialize-agent-map.js';
+export const pikkuAIAgent = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        const { agents, functions } = await getInspectorState();
+        const { agentWiringsFile, agentWiringMetaFile, agentWiringMetaJsonFile, agentMapDeclarationFile, packageMappings, schema, externalPackageName, } = config;
+        const lines = [];
+        const hasAgents = agents.files.size > 0;
+        if (hasAgents) {
+            lines.push(`import { addAIAgent } from '@pikku/core/ai-agent'`);
+        }
+        const metaImportPath = getFileImportRelativePath(agentWiringsFile, agentWiringMetaFile, packageMappings);
+        if (Object.keys(agents.agentsMeta).length > 0) {
+            lines.push(`import '${metaImportPath}'`);
+        }
+        const agentFiles = agents.files;
+        const sortedAgents = Array.from(agentFiles.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+        for (const [, { path, exportedName }] of sortedAgents) {
+            const importPath = getFileImportRelativePath(agentWiringsFile, path, packageMappings);
+            lines.push(`import { ${exportedName} } from '${importPath}'`);
+        }
+        lines.push('');
+        const packageArg = externalPackageName ? `, '${externalPackageName}'` : '';
+        for (const [agentName, { exportedName }] of sortedAgents) {
+            lines.push(`addAIAgent('${agentName}', ${exportedName}${packageArg})`);
+        }
+        await writeFileInDir(logger, agentWiringsFile, lines.join('\n'));
+        const metaData = {
+            agentsMeta: agents.agentsMeta,
+        };
+        const minimalMeta = stripVerboseFields(metaData);
+        await writeFileInDir(logger, agentWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
+        if (hasVerboseFields(metaData)) {
+            const verbosePath = agentWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+            await writeFileInDir(logger, verbosePath, JSON.stringify(metaData, null, 2));
+        }
+        const jsonImportPath = getFileImportRelativePath(agentWiringMetaFile, agentWiringMetaJsonFile, packageMappings);
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        const importStatement = supportsImportAttributes
+            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+            : `import metaData from '${jsonImportPath}'`;
+        const modelConfigLines = [];
+        if (!externalPackageName &&
+            (config.models || config.agentDefaults || config.agentOverrides)) {
+            modelConfigLines.push(`\npikkuState(null, 'models', 'config', ${JSON.stringify({
+                models: config.models,
+                agentDefaults: config.agentDefaults,
+                agentOverrides: config.agentOverrides,
+            })} as any)`);
+        }
+        await writeFileInDir(logger, agentWiringMetaFile, `import { pikkuState } from '@pikku/core'
+import type { AIAgentMeta } from '@pikku/core/ai-agent'
+${importStatement}
+pikkuState(${externalPackageName ? `'${externalPackageName}'` : 'null'}, 'agent', 'agentsMeta', metaData.agentsMeta as AIAgentMeta)${modelConfigLines.join('')}`);
+        await writeFileInDir(logger, agentMapDeclarationFile, serializeAgentMap(logger, agentMapDeclarationFile, packageMappings, functions.typesMap, agents.agentsMeta));
+        return true;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Finding AI agents',
+            commandEnd: 'Found AI agents',
+        }),
+    ],
+});

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

@@ -0,0 +1 @@
+export declare const pikkuPublicAgent: 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/ai-agent/pikku-command-public-agent.js

@@ -0,0 +1,23 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializePublicAgent } from './serialize-public-agent.js';
+import { join } from 'path';
+export const pikkuPublicAgent = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        if (config.agent?.publicAgentPath) {
+            const publicAgentPath = join(config.rootDir, config.agent.publicAgentPath);
+            const pathToPikkuTypes = getFileImportRelativePath(publicAgentPath, config.typesDeclarationFile, config.packageMappings);
+            await writeFileInDir(logger, publicAgentPath, serializePublicAgent(pathToPikkuTypes, config.agent.publicAgentRequireAuth ?? true));
+            return true;
+        }
+        return false;
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Generating Public Agent Endpoint',
+            commandEnd: 'Generated Public Agent Endpoint',
+        }),
+    ],
+});

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

@@ -0,0 +1,4 @@
+import type { AIAgentMeta } from '@pikku/core/ai-agent';
+import { type TypesMap } from '@pikku/inspector';
+import { Logger } from '@pikku/core/services';
+export declare const serializeAgentMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, agentsMeta: AIAgentMeta) => string;

package/dist/src/functions/wirings/ai-agent/serialize-agent-map.js

@@ -0,0 +1,48 @@
+import { serializeImportMap } from '../../../utils/serialize-import-map.js';
+import { generateCustomTypes } from '@pikku/inspector';
+export const serializeAgentMap = (logger, relativeToPath, packageMappings, typesMap, agentsMeta) => {
+    const requiredTypes = new Set();
+    const serializedAgents = generateAgents(agentsMeta, typesMap, requiredTypes);
+    const hasAny = Object.keys(agentsMeta).length > 0;
+    const serializedCustomTypes = hasAny
+        ? generateCustomTypes(typesMap, requiredTypes)
+        : '';
+    const serializedImportMap = hasAny
+        ? serializeImportMap(logger, relativeToPath, packageMappings, typesMap, requiredTypes)
+        : '';
+    return `/**
+ * Agent type map with output types for each agent
+ */
+
+${serializedImportMap}
+${serializedCustomTypes}
+
+interface AgentHandler<O> {
+    output: O;
+}
+
+${serializedAgents}
+`;
+};
+function generateAgents(agentsMeta, typesMap, requiredTypes) {
+    const agentsObj = {};
+    for (const [agentName, meta] of Object.entries(agentsMeta)) {
+        let outputType = 'string';
+        if (meta.outputSchema) {
+            try {
+                outputType = typesMap.getTypeMeta(meta.outputSchema).uniqueName;
+            }
+            catch {
+                outputType = meta.outputSchema;
+            }
+            requiredTypes.add(outputType);
+        }
+        agentsObj[agentName] = { outputType };
+    }
+    let agentsStr = 'export type AgentMap = {\n';
+    for (const [agentName, handler] of Object.entries(agentsObj)) {
+        agentsStr += `  readonly '${agentName}': AgentHandler<${handler.outputType}>,\n`;
+    }
+    agentsStr += '};';
+    return agentsStr;
+}

package/dist/src/functions/wirings/ai-agent/serialize-ai-agent-types.d.ts

@@ -0,0 +1 @@
+export declare const serializeAIAgentTypes: (functionTypesImportPath: string) => string;

package/dist/src/functions/wirings/ai-agent/serialize-ai-agent-types.js

@@ -0,0 +1,31 @@
+export const serializeAIAgentTypes = (functionTypesImportPath) => {
+    return `import {
+  CoreAIAgent,
+  PikkuAIMiddlewareHooks,
+} from '@pikku/core/ai-agent'
+import type { PikkuPermission, PikkuMiddleware, Services } from '${functionTypesImportPath}'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+import type { AIAgentMemoryConfig } from '@pikku/core/ai-agent'
+
+type AIAgentConfig = Omit<CoreAIAgent<PikkuPermission, PikkuMiddleware>, 'tools' | 'agents' | 'memory'> & {
+  input?: StandardSchemaV1
+  output?: StandardSchemaV1
+  memory?: Omit<AIAgentMemoryConfig, 'workingMemory'> & { workingMemory?: StandardSchemaV1 }
+  tools?: object[]
+  agents?: AIAgentConfig[]
+}
+
+export const pikkuAIAgent = (
+  agent: AIAgentConfig
+) => {
+  return agent
+}
+
+export const pikkuAIMiddleware = <
+  State extends Record<string, unknown> = Record<string, unknown>,
+  RequiredServices extends Services = Services,
+>(
+  hooks: PikkuAIMiddlewareHooks<State, RequiredServices>
+): PikkuAIMiddlewareHooks<State, RequiredServices> => hooks
+`;
+};

package/dist/src/functions/wirings/ai-agent/serialize-public-agent.d.ts

@@ -0,0 +1 @@
+export declare const serializePublicAgent: (pathToPikkuTypes: string, requireAuth?: boolean) => string;

package/dist/src/functions/wirings/ai-agent/serialize-public-agent.js

@@ -0,0 +1,90 @@
+export const serializePublicAgent = (pathToPikkuTypes, requireAuth = true) => {
+    const authFlag = requireAuth ? 'true' : 'false';
+    return `import { pikkuSessionlessFunc, wireHTTP } from '${pathToPikkuTypes}'
+import { streamAIAgent, approveAIAgent } from '@pikku/core/ai-agent'
+import type { AIStreamChannel } from '@pikku/core/ai-agent'
+
+export const agentCaller = pikkuSessionlessFunc<
+  { agentName: string; message: string; threadId: string; resourceId: string },
+  unknown
+>({
+  auth: ${authFlag},
+  func: async (_services, data, { rpc }) => {
+    return await (rpc.agent as any)(data.agentName, {
+      message: data.message,
+      threadId: data.threadId,
+      resourceId: data.resourceId,
+    })
+  },
+})
+
+export const agentStreamCaller = pikkuSessionlessFunc<
+  { agentName: string; message: string; threadId: string; resourceId: string },
+  void
+>({
+  auth: ${authFlag},
+  func: async (services, data, { channel }) => {
+    await streamAIAgent(
+      data.agentName,
+      { message: data.message, threadId: data.threadId, resourceId: data.resourceId },
+      channel as unknown as AIStreamChannel,
+      { singletonServices: services }
+    )
+  },
+})
+
+export const agentApproveCaller = pikkuSessionlessFunc<
+  { agentName: string; runId: string; approvals: { toolCallId: string; approved: boolean }[] },
+  unknown
+>({
+  auth: ${authFlag},
+  func: async ({ aiRunState }, { runId, approvals, agentName }) => {
+    if (!aiRunState) {
+      throw new Error('AIRunStateService not available')
+    }
+    return await approveAIAgent(aiRunState, runId, approvals, agentName)
+  },
+})
+
+wireHTTP({
+  route: '/rpc/agent/:agentName',
+  method: 'options',
+  tags: ['pikku:public'],
+  auth: ${authFlag},
+  func: pikkuSessionlessFunc<{ agentName: string }>(async () => void 0),
+})
+
+wireHTTP({
+  route: '/rpc/agent/:agentName',
+  method: 'post',
+  tags: ['pikku:public'],
+  auth: ${authFlag},
+  func: agentCaller,
+})
+
+wireHTTP({
+  route: '/rpc/agent/:agentName/stream',
+  method: 'options',
+  tags: ['pikku:public'],
+  auth: ${authFlag},
+  func: pikkuSessionlessFunc<{ agentName: string }>(async () => void 0),
+})
+
+wireHTTP({
+  route: '/rpc/agent/:agentName/stream',
+  method: 'get',
+  tags: ['pikku:public'],
+  auth: ${authFlag},
+  sse: true,
+  func: agentStreamCaller,
+})
+
+wireHTTP({
+  route: '/rpc/agent/:agentName/approve',
+  method: 'post',
+  tags: ['pikku:public'],
+  auth: ${authFlag},
+  func: agentApproveCaller,
+})
+`;
+};

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

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

@@ -1,4 +1,4 @@
-import { pikkuVoidFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuVoidFunc } 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 pikkuChannels = pikkuVoidFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, channelsWiringMetaFile, `import { pikkuState } from '@pikku/core'\nimport { ChannelsMeta } from '@pikku/core/channel'\n${importStatement}\npikkuState('channel', 'meta', metaData as ChannelsMeta)`);
+        await writeFileInDir(logger, channelsWiringMetaFile, `import { pikkuState } from '@pikku/core'\nimport { ChannelsMeta } from '@pikku/core/channel'\n${importStatement}\npikkuState(null, 'channel', 'meta', metaData as ChannelsMeta)`);
     },
     middleware: [
         logCommandInfoAndTime({

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

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

@@ -1,13 +1,13 @@
-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';
 import { serializeChannelTypes } from './serialize-channel-types.js';
 export const pikkuChannelTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        const { channelsTypesFile, functionTypesFile, packageMappings } = config;
+        const { channelsTypesFile, functionTypesFile, packageMappings, externalPackageName, } = config;
         const functionTypesImportPath = getFileImportRelativePath(channelsTypesFile, functionTypesFile, packageMappings);
-        const content = serializeChannelTypes(functionTypesImportPath);
+        const content = serializeChannelTypes(functionTypesImportPath, externalPackageName);
         await writeFileInDir(logger, channelsTypesFile, content);
     },
     middleware: [

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

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeTypedChannelsMap } from './serialize-typed-channel-map.js';
@@ -6,7 +6,7 @@ export const pikkuChannelsMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const state = await getInspectorState();
         const { channelsMapDeclarationFile, packageMappings } = config;
-        const content = serializeTypedChannelsMap(channelsMapDeclarationFile, packageMappings, state.functions.typesMap, state.functions.meta, state.channels.meta);
+        const content = serializeTypedChannelsMap(logger, channelsMapDeclarationFile, packageMappings, state.functions.typesMap, state.functions.meta, state.channels.meta);
         await writeFileInDir(logger, channelsMapDeclarationFile, content);
     },
     middleware: [

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

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

@@ -1,14 +1,30 @@
-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';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 export const pikkuChannels = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
-        const { channelsWiringFile, channelsWiringMetaFile, packageMappings } = config;
+        const { channelsWiringFile, channelsWiringMetaFile, channelsWiringMetaJsonFile, packageMappings, schema, } = config;
         const { channels } = visitState;
         await writeFileInDir(logger, channelsWiringFile, serializeFileImports('addChannel', channelsWiringFile, channels.files, packageMappings));
-        await writeFileInDir(logger, channelsWiringMetaFile, `import { pikkuState } from '@pikku/core'\npikkuState('channel', 'meta', ${JSON.stringify(channels.meta, null, 2)})`);
+        // Write minimal JSON (runtime-only fields)
+        const minimalMeta = stripVerboseFields(channels.meta);
+        await writeFileInDir(logger, channelsWiringMetaJsonFile, JSON.stringify(minimalMeta, null, 2));
+        // Write verbose JSON only if it has additional fields
+        if (hasVerboseFields(channels.meta)) {
+            const verbosePath = channelsWiringMetaJsonFile.replace(/\.gen\.json$/, '-verbose.gen.json');
+            await writeFileInDir(logger, verbosePath, JSON.stringify(channels.meta, null, 2));
+        }
+        // Generate TypeScript file that imports the minimal JSON
+        const jsonImportPath = getFileImportRelativePath(channelsWiringMetaFile, channelsWiringMetaJsonFile, packageMappings);
+        const supportsImportAttributes = schema?.supportsImportAttributes ?? false;
+        const importStatement = supportsImportAttributes
+            ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
+            : `import metaData from '${jsonImportPath}'`;
+        await writeFileInDir(logger, channelsWiringMetaFile, `import { pikkuState } from '@pikku/core'\nimport type { ChannelsMeta } from '@pikku/core/channel'\n${importStatement}\npikkuState(null, 'channel', 'meta', metaData as ChannelsMeta)`);
         return true;
     },
     middleware: [

package/dist/src/functions/wirings/channels/serialize-channel-types.d.ts

@@ -1,4 +1,4 @@
 /**
  * Generates type definitions for WebSocket channel wirings
  */
-export declare const serializeChannelTypes: (functionTypesImportPath: string) => string;
+export declare const serializeChannelTypes: (functionTypesImportPath: string, packageName?: string) => string;

package/dist/src/functions/wirings/channels/serialize-channel-types.js

@@ -1,15 +1,22 @@
 /**
  * Generates type definitions for WebSocket channel wirings
  */
-export const serializeChannelTypes = (functionTypesImportPath) => {
+export const serializeChannelTypes = (functionTypesImportPath, packageName) => {
+    const packageNameValue = packageName ? `'${packageName}'` : 'null';
     return `/**
-
  * Channel-specific type definitions for tree-shaking optimization
  */
 
-import { CoreChannel, wireChannel as wireChannelCore } from '@pikku/core/channel'
+import { CoreChannel, CorePikkuChannelMiddleware, CorePikkuChannelMiddlewareFactory, wireChannel as wireChannelCore, defineChannelRoutes as defineChannelRoutesCore, addChannelMiddleware as addChannelMiddlewareCore } from '@pikku/core/channel'
 import { AssertHTTPWiringParams } from '@pikku/core/http'
-import type { PikkuFunctionConfig, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware } from '${functionTypesImportPath}'
+import type { PikkuFunctionConfig, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware, Services } from '${functionTypesImportPath}'
+import type { CorePermissionGroup } from '@pikku/core'
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+
+/**
+ * Helper type to infer the output type from a Standard Schema
+ */
+type InferSchemaOutput<T> = T extends StandardSchemaV1<any, infer Output> ? Output : never
 
 /**
  * Type definition for WebSocket channels with typed data exchange.
@@ -60,21 +67,72 @@ export const pikkuChannelDisconnectionFunc = (
   return typeof func === 'function' ? { func } : func
 }
 
+/**
+ * Configuration object for channel functions with Zod schema validation.
+ */
+type PikkuChannelFuncConfigWithSchema<
+  InputSchema extends StandardSchemaV1,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
+> = {
+  name?: string
+  tags?: string[]
+  expose?: boolean
+  remote?: boolean
+  func: PikkuFunctionSessionless<
+    InferSchemaOutput<InputSchema>,
+    OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown,
+    'channel' | 'session' | 'rpc'
+  >
+  auth?: boolean
+  permissions?: CorePermissionGroup<PikkuPermission<InferSchemaOutput<InputSchema>>>
+  middleware?: PikkuMiddleware[]
+  input: InputSchema
+  output?: OutputSchema
+}
+
 /**
  * Creates a function that handles WebSocket channel messages.
  * Called when a message is received on a channel.
- * This is the same as pikkuSessionlessFunc but with ChannelData = unknown by default.
  *
- * @template In - Input type for channel messages
- * @template Out - Output type for channel responses
+ * Supports two patterns:
+ * 1. Generic types: \`pikkuChannelFunc<Input, Output>({ func: ... })\`
+ * 2. Zod schemas: \`pikkuChannelFunc({ input: z.object(...), func: ... })\`
+ *
+ * @template In - Input type for channel messages (inferred from schema if provided)
+ * @template Out - Output type for channel responses (inferred from schema if provided)
  * @param func - Function definition, either direct function or configuration object
  * @returns The normalized configuration object
+ *
+ * @example
+ * \`\`\`typescript
+ * // Pattern 1: Using generic types
+ * const handleMessage = pikkuChannelFunc<{text: string}, {received: boolean}>({
+ *   func: async (_services, { text }) => ({ received: true })
+ * })
+ *
+ * // Pattern 2: Using Zod schemas
+ * const messageInput = z.object({ text: z.string() })
+ * const messageOutput = z.object({ received: z.boolean() })
+ *
+ * const handleMessage = pikkuChannelFunc({
+ *   input: messageInput,
+ *   output: messageOutput,
+ *   func: async (_services, { text }) => ({ received: true })
+ * })
+ * \`\`\`
  */
-export const pikkuChannelFunc = <In, Out = unknown>(
+export function pikkuChannelFunc<
+  InputSchema extends StandardSchemaV1,
+  OutputSchema extends StandardSchemaV1 | undefined = undefined
+>(
+  config: PikkuChannelFuncConfigWithSchema<InputSchema, OutputSchema>
+): PikkuFunctionConfig<InferSchemaOutput<InputSchema>, OutputSchema extends StandardSchemaV1 ? InferSchemaOutput<OutputSchema> : unknown, 'channel' | 'session' | 'rpc'>
+export function pikkuChannelFunc<In, Out = unknown>(
   func:
     | PikkuFunctionSessionless<In, Out, 'channel' | 'session' | 'rpc'>
     | PikkuFunctionConfig<In, Out, 'channel' | 'session' | 'rpc'>
-) => {
+): PikkuFunctionConfig<In, Out, 'channel' | 'session' | 'rpc'>
+export function pikkuChannelFunc(func: any) {
   return typeof func === 'function' ? { func } : func
 }
 
@@ -88,7 +146,36 @@ export const pikkuChannelFunc = <In, Out = unknown>(
 export const wireChannel = <ChannelData, Channel extends string>(
   channel: ChannelWiring<ChannelData, Channel> & AssertHTTPWiringParams<ChannelData, Channel>
 ) => {
-  wireChannelCore(channel as any) // TODO
+  wireChannelCore(channel as any)
+}
+
+/**
+ * Type-safe helper for defining channel message routes that can be composed.
+ * Returns the routes record as-is for use with wireChannel's onMessageWiring.
+ *
+ * @template T - Record of channel route handlers
+ * @param routes - The channel routes record
+ * @returns The same routes record (identity function for type safety)
+ */
+export function defineChannelRoutes<T extends Record<string, any>>(routes: T): T {
+  return defineChannelRoutesCore(routes)
 }
+
+export type PikkuChannelMiddleware<RequiredServices extends Services = Services, Event = unknown> = CorePikkuChannelMiddleware<RequiredServices, Event>
+
+export const pikkuChannelMiddleware = <RequiredServices extends Services = Services, Event = unknown>(
+  middleware: PikkuChannelMiddleware<RequiredServices, Event>
+): PikkuChannelMiddleware<RequiredServices, Event> => {
+  return middleware
+}
+
+export const pikkuChannelMiddlewareFactory = <In = any>(
+  factory: CorePikkuChannelMiddlewareFactory<In>
+): CorePikkuChannelMiddlewareFactory<In> => {
+  return factory
+}
+
+export const addChannelMiddleware = (tag: string, middleware: PikkuChannelMiddleware[]) =>
+  addChannelMiddlewareCore(tag, middleware, ${packageNameValue})
 `;
 };

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

@@ -1,4 +1,5 @@
 import { ChannelsMeta } from '@pikku/core/channel';
 import { TypesMap } from '@pikku/inspector';
 import { FunctionsMeta } from '@pikku/core';
-export declare const serializeTypedChannelsMap: (relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, channelsMeta: ChannelsMeta) => string;
+import { Logger } from '@pikku/core/services';
+export declare const serializeTypedChannelsMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, functionsMeta: FunctionsMeta, channelsMeta: ChannelsMeta) => string;

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

@@ -1,21 +1,20 @@
 import { serializeImportMap } from '../../../utils/serialize-import-map.js';
-import { generateCustomTypes } from '../../../utils/custom-types-generator.js';
-export const serializeTypedChannelsMap = (relativeToPath, packageMappings, typesMap, functionsMeta, channelsMeta) => {
+import { generateCustomTypes } from '@pikku/inspector';
+export const serializeTypedChannelsMap = (logger, relativeToPath, packageMappings, typesMap, functionsMeta, channelsMeta) => {
     const { channels, requiredTypes } = generateChannels(functionsMeta, channelsMeta);
     typesMap.customTypes.forEach(({ references }) => {
         for (const reference of references) {
-            // Skip __object types (placeholder types for invalid/broken functions)
             if (reference !== '__object' && !reference.startsWith('__object_')) {
                 requiredTypes.add(reference);
             }
         }
     });
-    const imports = serializeImportMap(relativeToPath, packageMappings, typesMap, requiredTypes);
+    const imports = serializeImportMap(logger, relativeToPath, packageMappings, typesMap, requiredTypes);
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
     return `/**
  * This provides the structure needed for TypeScript to be aware of channels
  */
-    
+
 ${imports}
 ${serializedCustomTypes}
 
@@ -50,9 +49,9 @@ function generateChannels(functionsMeta, channelsMeta) {
             channelsObject[name] = { message: null, routes: {} };
         }
         if (message) {
-            const func = functionsMeta[message.pikkuFuncName];
+            const func = functionsMeta[message.pikkuFuncId];
             if (!func) {
-                throw new Error(`Function ${message.pikkuFuncName} not found in functionsMeta for channel ${name}`);
+                throw new Error(`Function ${message.pikkuFuncId} not found in functionsMeta for channel ${name}`);
             }
             const inputTypes = func.inputs || null;
             const outputTypes = func.outputs || null;
@@ -67,10 +66,10 @@ function generateChannels(functionsMeta, channelsMeta) {
             if (!channelsObject[name].routes[key]) {
                 channelsObject[name].routes[key] = {};
             }
-            for (const [method, { pikkuFuncName }] of Object.entries(route)) {
-                const func = functionsMeta[pikkuFuncName];
+            for (const [method, { pikkuFuncId }] of Object.entries(route)) {
+                const func = functionsMeta[pikkuFuncId];
                 if (!func) {
-                    throw new Error(`Function ${pikkuFuncName} not found in functionsMeta for channel ${name}, route ${key}, method ${method}`);
+                    throw new Error(`Function ${pikkuFuncId} not found in functionsMeta for channel ${name}, route ${key}, method ${method}`);
                 }
                 const inputTypes = func.inputs || null;
                 const outputTypes = func.outputs || null;

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

@@ -1 +1 @@
-export declare const pikkuCLIEntry: any;
+export declare const pikkuCLIEntry: 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/cli/pikku-command-cli-entry.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 { checkRequiredTypes } from '../../../utils/check-required-types.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
@@ -15,7 +15,7 @@ export const pikkuCLIEntry = pikkuSessionlessFunc({
         // Check if CLI entrypoints are configured
         if (!config.cli?.entrypoints ||
             Object.keys(config.cli.entrypoints).length === 0) {
-            logger.info({
+            logger.debug({
                 message: 'No CLI entrypoints configured in config.cli.entrypoints, skipping CLI bootstrap generation',
                 type: 'skip',
             });
@@ -98,14 +98,10 @@ export const pikkuCLIEntry = pikkuSessionlessFunc({
                 // Get service factories for local mode
                 // Check for required types
                 checkRequiredTypes(visitState.filesAndMethodsErrors, {
-                    config: true,
                     singletonServicesFactory: true,
-                    wireServicesFactory: true,
                 });
                 const { pikkuConfigFactory, singletonServicesFactory, wireServicesFactory, } = visitState.filesAndMethods;
-                if (!pikkuConfigFactory ||
-                    !singletonServicesFactory ||
-                    !wireServicesFactory) {
+                if (!singletonServicesFactory) {
                     throw new Error('Required types not found');
                 }
                 const bootstrapCode = serializeLocalCLIBootstrap(programName, programMeta, bootstrapFile, config, pikkuConfigFactory, singletonServicesFactory, wireServicesFactory);

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

@@ -1 +1 @@
-export declare const pikkuCLITypes: any;
+export declare const pikkuCLITypes: 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/cli/pikku-command-cli-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';