@pikku/cli 0.12.0 → 0.12.1

package/dist/src/functions/commands/new-function.js

@@ -0,0 +1,79 @@
+import { existsSync } from 'fs';
+import { dirname } from 'path';
+import { mkdir, writeFile } from 'fs/promises';
+import { pikkuSessionlessFunc } from '#pikku';
+import { scaffoldFilePath } from '../../utils/file-writer.js';
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+export const pikkuNewFunction = pikkuSessionlessFunc({
+    func: async ({ logger, config }, { name, type = 'sessionless' }) => {
+        const filePath = scaffoldFilePath(config, 'functions', name, '.functions.ts', config.scaffold?.functionDir);
+        if (existsSync(filePath)) {
+            logger.error(`File already exists: ${filePath}`);
+            process.exit(1);
+        }
+        const inputName = capitalize(name) + 'Input';
+        const outputName = capitalize(name) + 'Output';
+        let content;
+        switch (type) {
+            case 'func':
+                content = `import { pikkuFunc } from '#pikku'
+
+export type ${inputName} = {
+  // TODO: define input
+}
+
+export type ${outputName} = {
+  // TODO: define output
+}
+
+export const ${name} = pikkuFunc<${inputName}, ${outputName}>({
+  func: async ({ logger }, data, { session }) => {
+    // TODO: implement
+    return {} as ${outputName}
+  },
+})
+`;
+                break;
+            case 'void':
+                content = `import { pikkuVoidFunc } from '#pikku'
+
+export type ${inputName} = {
+  // TODO: define input
+}
+
+export const ${name} = pikkuVoidFunc<${inputName}>({
+  func: async ({ logger }, data) => {
+    // TODO: implement
+  },
+})
+`;
+                break;
+            case 'sessionless':
+            default:
+                content = `import { pikkuSessionlessFunc } from '#pikku'
+
+export type ${inputName} = {
+  // TODO: define input
+}
+
+export type ${outputName} = {
+  // TODO: define output
+}
+
+export const ${name} = pikkuSessionlessFunc<${inputName}, ${outputName}>({
+  func: async ({ logger }, data) => {
+    // TODO: implement
+    return {} as ${outputName}
+  },
+})
+`;
+                break;
+        }
+        await mkdir(dirname(filePath), { recursive: true });
+        await writeFile(filePath, content, 'utf-8');
+        logger.info(`Created function at ${filePath}`);
+        console.log(filePath);
+    },
+});

package/dist/src/functions/commands/new-middleware.d.ts

@@ -0,0 +1,10 @@
+export declare const pikkuNewMiddleware: import("#pikku").PikkuFunctionConfig<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/new-middleware.js

@@ -0,0 +1,48 @@
+import { existsSync } from 'fs';
+import { dirname } from 'path';
+import { mkdir, writeFile } from 'fs/promises';
+import { pikkuSessionlessFunc } from '#pikku';
+import { scaffoldFilePath } from '../../utils/file-writer.js';
+export const pikkuNewMiddleware = pikkuSessionlessFunc({
+    func: async ({ logger, config }, { name, type = 'simple' }) => {
+        const filePath = scaffoldFilePath(config, 'middleware', name, '.ts', config.scaffold?.middlewareDir);
+        if (existsSync(filePath)) {
+            logger.error(`File already exists: ${filePath}`);
+            process.exit(1);
+        }
+        let content;
+        switch (type) {
+            case 'factory':
+                content = `import { pikkuMiddlewareFactory } from '#pikku'
+
+export const ${name} = pikkuMiddlewareFactory(
+  (param: string) =>
+    async ({ logger }, _data, next) => {
+      logger.info(\`[\${param}] before\`)
+      const result = await next()
+      logger.info(\`[\${param}] after\`)
+      return result
+    }
+)
+`;
+                break;
+            case 'simple':
+            default:
+                content = `import { pikkuMiddleware } from '#pikku'
+
+export const ${name} = pikkuMiddleware(
+  async ({ logger }, _data, next) => {
+    // TODO: implement
+    const result = await next()
+    return result
+  }
+)
+`;
+                break;
+        }
+        await mkdir(dirname(filePath), { recursive: true });
+        await writeFile(filePath, content, 'utf-8');
+        logger.info(`Created middleware at ${filePath}`);
+        console.log(filePath);
+    },
+});

package/dist/src/functions/commands/new-permission.d.ts

@@ -0,0 +1,10 @@
+export declare const pikkuNewPermission: import("#pikku").PikkuFunctionConfig<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/new-permission.js

@@ -0,0 +1,45 @@
+import { existsSync } from 'fs';
+import { dirname } from 'path';
+import { mkdir, writeFile } from 'fs/promises';
+import { pikkuSessionlessFunc } from '#pikku';
+import { scaffoldFilePath } from '../../utils/file-writer.js';
+export const pikkuNewPermission = pikkuSessionlessFunc({
+    func: async ({ logger, config }, { name, type = 'simple' }) => {
+        const filePath = scaffoldFilePath(config, 'permissions', name, '.ts', config.scaffold?.permissionDir);
+        if (existsSync(filePath)) {
+            logger.error(`File already exists: ${filePath}`);
+            process.exit(1);
+        }
+        let content;
+        switch (type) {
+            case 'factory':
+                content = `import { pikkuPermissionFactory } from '#pikku'
+
+export const ${name} = pikkuPermissionFactory(
+  (param: string) =>
+    async ({ logger }, _data, { session }) => {
+      // TODO: implement permission check
+      return true
+    }
+)
+`;
+                break;
+            case 'simple':
+            default:
+                content = `import { pikkuPermission } from '#pikku'
+
+export const ${name} = pikkuPermission(
+  async ({ logger }, _data, { session }) => {
+    // TODO: implement permission check
+    return true
+  }
+)
+`;
+                break;
+        }
+        await mkdir(dirname(filePath), { recursive: true });
+        await writeFile(filePath, content, 'utf-8');
+        logger.info(`Created permission at ${filePath}`);
+        console.log(filePath);
+    },
+});

package/dist/src/functions/commands/new-wiring.d.ts

@@ -0,0 +1,10 @@
+export declare const pikkuNewWiring: import("#pikku").PikkuFunctionConfig<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    name: string;
+    type?: string;
+}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/new-wiring.js

@@ -0,0 +1,102 @@
+import { existsSync } from 'fs';
+import { dirname } from 'path';
+import { mkdir, writeFile } from 'fs/promises';
+import { pikkuSessionlessFunc } from '#pikku';
+import { scaffoldFilePath } from '../../utils/file-writer.js';
+function getWiringTemplate(type, name) {
+    switch (type) {
+        case 'http':
+            return `import { wireHTTP } from '#pikku'
+// import { myFunc } from '../functions/${name}.functions.js'
+
+wireHTTP({
+  method: 'get',
+  route: '/api/${name}',
+  func: myFunc,
+  auth: false,
+})
+`;
+        case 'channel':
+            return `import { wireChannel } from '#pikku'
+// import { onConnect, onMessage, onDisconnect } from '../functions/${name}.functions.js'
+
+wireChannel({
+  name: '${name}',
+  route: '/',
+  onConnect,
+  onDisconnect,
+  onMessage,
+  auth: true,
+})
+`;
+        case 'scheduler':
+            return `import { wireScheduler } from '#pikku'
+// import { myTask } from '../functions/${name}.functions.js'
+
+wireScheduler({
+  name: '${name}',
+  schedule: '0 * * * *',
+  func: myTask,
+})
+`;
+        case 'queue':
+            return `import { wireQueueWorker } from '#pikku'
+// import { processItem } from '../functions/${name}.functions.js'
+
+wireQueueWorker({
+  name: '${name}',
+  func: processItem,
+})
+`;
+        case 'mcp':
+            return `import { wireMCPResource } from '#pikku'
+// import { myResource } from '../functions/${name}.functions.js'
+
+wireMCPResource({
+  uri: '${name}',
+  title: '${name}',
+  description: 'TODO: describe this resource',
+  func: myResource,
+})
+`;
+        case 'cli':
+            return `import { wireCLI, pikkuCLICommand } from '#pikku'
+// import { myCommand } from '../functions/${name}.functions.js'
+
+wireCLI({
+  program: '${name}',
+  commands: {
+    example: pikkuCLICommand({
+      func: myCommand,
+      description: 'TODO: describe this command',
+    }),
+  },
+})
+`;
+        case 'trigger':
+            return `import { wireTrigger } from '#pikku'
+// import { handleEvent } from '../functions/${name}.functions.js'
+
+wireTrigger({
+  name: '${name}',
+  func: handleEvent,
+})
+`;
+        default:
+            return `// ${type} wiring for ${name}\n`;
+    }
+}
+export const pikkuNewWiring = pikkuSessionlessFunc({
+    func: async ({ logger, config }, { name, type = 'http' }) => {
+        const filePath = scaffoldFilePath(config, 'wirings', name, '.wiring.ts', config.scaffold?.wiringDir);
+        if (existsSync(filePath)) {
+            logger.error(`File already exists: ${filePath}`);
+            process.exit(1);
+        }
+        const content = getWiringTemplate(type, name);
+        await mkdir(dirname(filePath), { recursive: true });
+        await writeFile(filePath, content, 'utf-8');
+        logger.info(`Created wiring at ${filePath}`);
+        console.log(filePath);
+    },
+});

package/dist/src/functions/commands/pikku-command-bootstrap.js

@@ -4,45 +4,17 @@ import { writeFileInDir } from '../../utils/file-writer.js';
 export const pikkuBootstrap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }, { allImports }) => {
         const stateBeforeBootstrap = await getInspectorState();
-        const externalPackageBootstraps = [];
-        const usedExternalPackages = {};
-        if (config.externalPackages) {
-            for (const [namespace, externalPkg] of Object.entries(config.externalPackages)) {
-                const isUsed = stateBeforeBootstrap.rpc?.usedExternalPackages?.has(namespace);
-                if (isUsed || externalPkg.forceInclude) {
-                    const packageName = externalPkg.package;
-                    const packageBootstrap = `${packageName}/.pikku/pikku-bootstrap.gen.js`;
-                    externalPackageBootstraps.push(packageBootstrap);
-                    usedExternalPackages[namespace] = {
-                        package: packageName,
-                        rpcEndpoint: externalPkg.rpcEndpoint,
-                    };
-                    logger.debug(`• External package ${externalPkg.forceInclude && !isUsed ? 'force-included' : 'detected'}: ${namespace} (${packageName})`);
-                }
-            }
+        const addonBootstraps = [];
+        for (const [, decl] of stateBeforeBootstrap.rpc?.wireAddonDeclarations ??
+            []) {
+            addonBootstraps.push(`${decl.package}/.pikku/pikku-bootstrap.gen.js`);
+            logger.debug(`• Addon bootstrap: ${decl.package}`);
         }
+        const wireAddonFileImports = Array.from(stateBeforeBootstrap.rpc?.wireAddonFiles ?? []).map((to) => `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`);
         const localImports = allImports.map((to) => `import '${getFileImportRelativePath(config.bootstrapFile, to, config.packageMappings)}'`);
-        const externalImports = externalPackageBootstraps.map((packagePath) => `import '${packagePath}'`);
-        let externalPackagesRegistration = '';
-        if (Object.keys(usedExternalPackages).length > 0) {
-            externalPackagesRegistration = `
-// Register external package mappings
-import { pikkuState } from '@pikku/core'
-const externalPackages = pikkuState(null, 'rpc', 'externalPackages')
-${Object.entries(usedExternalPackages)
-                .map(([ns, cfg]) => {
-                const rpcEndpointPart = cfg.rpcEndpoint
-                    ? `, rpcEndpoint: '${cfg.rpcEndpoint}'`
-                    : '';
-                return `externalPackages.set('${ns}', { package: '${cfg.package}'${rpcEndpointPart} })`;
-            })
-                .join('\n')}
-`;
-        }
-        const packageNameArg = config.externalPackageName
-            ? `'${config.externalPackageName}'`
-            : 'null';
-        const metaDirRegistration = `import { pikkuState as __pikkuState } from '@pikku/core'
+        const addonImports = addonBootstraps.map((packagePath) => `import '${packagePath}'`);
+        const packageNameArg = config.addonName ? `'${config.addonName}'` : 'null';
+        const metaDirRegistration = `import { pikkuState as __pikkuState } from '@pikku/core/internal'
 try {
   const { fileURLToPath: __fileURLToPath } = await import('url')
   const { dirname: __dirname } = await import('path')
@@ -50,7 +22,7 @@ try {
 } catch {}
 `;
         const allBootstrapImports = metaDirRegistration +
-            [...localImports, ...externalImports]
+            [...localImports, ...wireAddonFileImports, ...addonImports]
                 .sort((a, b) => {
                 const aMeta = a.includes('meta');
                 const bMeta = b.includes('meta');
@@ -60,8 +32,7 @@ try {
                     return 1;
                 return 0;
             })
-                .join('\n') +
-            externalPackagesRegistration;
+                .join('\n');
         await writeFileInDir(logger, config.bootstrapFile, allBootstrapImports);
     },
 });

package/dist/src/functions/commands/versions-check.js

@@ -1,16 +1,98 @@
 import { join } from 'path';
 import { pikkuSessionlessFunc } from '#pikku';
 import { ErrorCode } from '@pikku/inspector';
+function hashArrow(prev, curr) {
+    const p = (prev ?? 'unknown').slice(0, 8);
+    const c = (curr ?? 'unknown').slice(0, 8);
+    if (p === c) {
+        return `${p} (unchanged)`;
+    }
+    return `${p} → ${c}`;
+}
 export const pikkuVersionsCheck = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
         if (!visitState.manifest.initial) {
             const manifestPath = join(config.outDir, 'versions.json');
-            throw new Error(`[${ErrorCode.MANIFEST_MISSING}] Version manifest not found at ${manifestPath}. Run 'pikku init' to create one.`);
+            throw new Error(`[${ErrorCode.MANIFEST_MISSING}] Version manifest not found at ${manifestPath}. Run 'pikku versions init' to create one.`);
         }
         if (visitState.manifest.errors.length > 0) {
-            const messages = visitState.manifest.errors.map((e) => `[${e.code}] ${e.message}`);
-            throw new Error(messages.join('\n'));
+            for (const error of visitState.manifest.errors) {
+                if (error.code === ErrorCode.CONTRACT_CHANGED_REQUIRES_BUMP &&
+                    error.functionKey) {
+                    logger.info(`✗ ${error.functionKey} — contract changed without version bump`);
+                    if (error.previousInputHash !== undefined ||
+                        error.currentInputHash !== undefined) {
+                        logger.info(`  Input schema hash:  ${hashArrow(error.previousInputHash, error.currentInputHash)}`);
+                        logger.info(`  Output schema hash: ${hashArrow(error.previousOutputHash, error.currentOutputHash)}`);
+                    }
+                    logger.info(``);
+                    if (error.nextVersion !== undefined) {
+                        logger.info(`  Set \`version: ${error.nextVersion}\` on the function, then run:`);
+                    }
+                    logger.info(`  npx pikku versions-update`);
+                }
+                else if (error.code === ErrorCode.FUNCTION_VERSION_MODIFIED &&
+                    error.functionKey) {
+                    logger.info(`✗ ${error.functionKey}@v${error.version} — published contract was modified`);
+                    if (error.previousInputHash !== undefined ||
+                        error.currentInputHash !== undefined) {
+                        logger.info(`  Recorded hash: ${(error.previousInputHash ?? 'unknown').slice(0, 8)}`);
+                        logger.info(`  Current hash:  ${(error.currentInputHash ?? 'unknown').slice(0, 8)}`);
+                    }
+                    logger.info(``);
+                    logger.info(`  Published versions are immutable. Either revert`);
+                    logger.info(`  the schema change or create version ${(error.version ?? 1) + 1} instead.`);
+                }
+                else if (error.code === ErrorCode.VERSION_REGRESSION_OR_CONFLICT &&
+                    error.functionKey) {
+                    logger.info(`✗ ${error.functionKey}@v${error.version} — version missing from manifest`);
+                    if (error.latestVersion !== undefined) {
+                        logger.info(`  Latest recorded version: ${error.latestVersion}`);
+                    }
+                    logger.info(`  Version ${error.version} exists in code but not in versions.json`);
+                    logger.info(``);
+                    logger.info(`  This usually means a merge conflict in versions.json.`);
+                    logger.info(`  Resolve the conflict, then run:`);
+                    logger.info(`  npx pikku versions-update`);
+                }
+                else if (error.code === ErrorCode.VERSION_GAP_NOT_ALLOWED &&
+                    error.functionKey) {
+                    logger.info(`✗ ${error.functionKey}@v${error.version} — version gap detected`);
+                    if (error.latestVersion !== undefined) {
+                        logger.info(`  Latest version: ${error.latestVersion}`);
+                    }
+                    if (error.expectedNextVersion !== undefined) {
+                        logger.info(`  Expected next:  ${error.expectedNextVersion}`);
+                    }
+                    if (error.version !== undefined) {
+                        logger.info(`  Found:          ${error.version}`);
+                    }
+                    logger.info(``);
+                    if (error.expectedNextVersion !== undefined) {
+                        logger.info(`  Versions must be sequential. Set \`version: ${error.expectedNextVersion}\``);
+                        logger.info(`  on the function.`);
+                    }
+                }
+                else if (error.code === ErrorCode.MANIFEST_INTEGRITY_ERROR &&
+                    error.functionKey) {
+                    logger.info(`✗ ${error.functionKey} — versions.json integrity error`);
+                    if (error.latestVersion !== undefined) {
+                        logger.info(`  "latest" field: ${error.latestVersion}`);
+                    }
+                    if (error.expectedNextVersion !== undefined) {
+                        logger.info(`  Highest version key: ${error.expectedNextVersion}`);
+                    }
+                    logger.info(``);
+                    logger.info(`  The manifest is corrupted. Run:`);
+                    logger.info(`  npx pikku versions-update`);
+                }
+                else {
+                    logger.info(`[${error.code}] ${error.message}`);
+                }
+                logger.info(``);
+            }
+            throw new Error('Version check failed.');
         }
         logger.info('Version manifest check passed.');
     },

package/dist/src/functions/commands/versions-update.js

@@ -7,7 +7,7 @@ export const pikkuVersionsUpdate = pikkuSessionlessFunc({
         const manifestPath = join(config.outDir, 'versions.json');
         const visitState = await getInspectorState();
         if (!visitState.manifest.initial) {
-            throw new Error(`Version manifest not found at ${manifestPath}. Run 'pikku init' to create one.`);
+            throw new Error(`Version manifest not found at ${manifestPath}. Run 'pikku versions init' to create one.`);
         }
         const immutabilityErrors = visitState.manifest.errors.filter((e) => e.code === ErrorCode.FUNCTION_VERSION_MODIFIED);
         if (immutabilityErrors.length > 0) {

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-backend-wrapper.js

@@ -1,5 +1,4 @@
 export const serializeNextJsBackendWrapper = (bootstrapPath, routesMapPath, rpcMapPath, configImport, singleServicesFactoryImport, wireServicesImport) => {
-    const hasWireServices = !!wireServicesImport;
     return `'server-only'
 
 /**
@@ -15,7 +14,6 @@ type RouteContext = { params: Promise<Record<string, string | string[]>> }
 
 ${configImport}
 ${singleServicesFactoryImport}
-${wireServicesImport ? wireServicesImport : ''}
 
 import '${bootstrapPath}'
 
@@ -31,7 +29,6 @@ export const pikku = (_options?: any) => {
     _pikku = new PikkuNextJS(
       createConfig as any,
       createSingletonServices as any,
-      ${hasWireServices ? 'createWireServices' : 'undefined'}
     )
   }
 
@@ -248,7 +245,6 @@ export const pikkuAPIRequest = (
     _pikku = new PikkuNextJS(
       createConfig as any,
       createSingletonServices as any,
-      ${hasWireServices ? 'createWireServices' : 'undefined'}
     )
   }
   if (_removeAPIPrefix) {

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

@@ -5,9 +5,10 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializeAIAgentTypes } from './serialize-ai-agent-types.js';
 export const pikkuAIAgentTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        const { agentTypesFile, functionTypesFile, packageMappings } = config;
+        const { agentTypesFile, functionTypesFile, agentMapDeclarationFile, packageMappings, } = config;
         const functionTypesImportPath = getFileImportRelativePath(agentTypesFile, functionTypesFile, packageMappings);
-        const content = serializeAIAgentTypes(functionTypesImportPath);
+        const agentMapImportPath = getFileImportRelativePath(agentTypesFile, agentMapDeclarationFile, packageMappings);
+        const content = serializeAIAgentTypes(functionTypesImportPath, agentMapImportPath);
         await writeFileInDir(logger, agentTypesFile, content);
     },
     middleware: [

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

@@ -7,7 +7,7 @@ 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 { agentWiringsFile, agentWiringMetaFile, agentWiringMetaJsonFile, agentMapDeclarationFile, packageMappings, schema, addonName, } = config;
         const lines = [];
         const hasAgents = agents.files.size > 0;
         if (hasAgents) {
@@ -24,7 +24,7 @@ export const pikkuAIAgent = pikkuSessionlessFunc({
             lines.push(`import { ${exportedName} } from '${importPath}'`);
         }
         lines.push('');
-        const packageArg = externalPackageName ? `, '${externalPackageName}'` : '';
+        const packageArg = addonName ? `, '${addonName}'` : '';
         for (const [agentName, { exportedName }] of sortedAgents) {
             lines.push(`addAIAgent('${agentName}', ${exportedName}${packageArg})`);
         }
@@ -44,7 +44,7 @@ export const pikkuAIAgent = pikkuSessionlessFunc({
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
         const modelConfigLines = [];
-        if (!externalPackageName &&
+        if (!addonName &&
             (config.models || config.agentDefaults || config.agentOverrides)) {
             modelConfigLines.push(`\npikkuState(null, 'models', 'config', ${JSON.stringify({
                 models: config.models,
@@ -52,10 +52,10 @@ export const pikkuAIAgent = pikkuSessionlessFunc({
                 agentOverrides: config.agentOverrides,
             })} as any)`);
         }
-        await writeFileInDir(logger, agentWiringMetaFile, `import { pikkuState } from '@pikku/core'
+        await writeFileInDir(logger, agentWiringMetaFile, `import { pikkuState } from '@pikku/core/internal'
 import type { AIAgentMeta } from '@pikku/core/ai-agent'
 ${importStatement}
-pikkuState(${externalPackageName ? `'${externalPackageName}'` : 'null'}, 'agent', 'agentsMeta', metaData.agentsMeta as AIAgentMeta)${modelConfigLines.join('')}`);
+pikkuState(${addonName ? `'${addonName}'` : 'null'}, 'agent', 'agentsMeta', metaData.agentsMeta as AIAgentMeta)${modelConfigLines.join('')}`);
         await writeFileInDir(logger, agentMapDeclarationFile, serializeAgentMap(logger, agentMapDeclarationFile, packageMappings, functions.typesMap, agents.agentsMeta));
         return true;
     },

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

@@ -1,4 +1,4 @@
 import type { AIAgentMeta } from '@pikku/core/ai-agent';
 import { type TypesMap } from '@pikku/inspector';
-import { Logger } from '@pikku/core/services';
+import type { 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-ai-agent-types.d.ts

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

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

@@ -1,11 +1,18 @@
-export const serializeAIAgentTypes = (functionTypesImportPath) => {
+export const serializeAIAgentTypes = (functionTypesImportPath, agentMapImportPath) => {
     return `import {
   CoreAIAgent,
   PikkuAIMiddlewareHooks,
 } from '@pikku/core/ai-agent'
-import type { PikkuPermission, PikkuMiddleware, Services } from '${functionTypesImportPath}'
+import {
+  agent as coreAgent,
+  agentStream as coreAgentStream,
+  agentResume as coreAgentResume,
+  agentApprove as coreAgentApprove,
+} from '@pikku/core/ai-agent'
+import type { PikkuPermission, PikkuMiddleware, Services, PikkuFunctionConfig } from '${functionTypesImportPath}'
 import type { StandardSchemaV1 } from '@standard-schema/spec'
-import type { AIAgentMemoryConfig } from '@pikku/core/ai-agent'
+import type { AIAgentMemoryConfig, AIAgentInput } from '@pikku/core/ai-agent'
+import type { AgentMap } from '${agentMapImportPath}'
 
 type AIAgentConfig = Omit<CoreAIAgent<PikkuPermission, PikkuMiddleware>, 'tools' | 'agents' | 'memory'> & {
   input?: StandardSchemaV1
@@ -27,5 +34,43 @@ export const pikkuAIMiddleware = <
 >(
   hooks: PikkuAIMiddlewareHooks<State, RequiredServices>
 ): PikkuAIMiddlewareHooks<State, RequiredServices> => hooks
+
+export const agent = <Name extends keyof AgentMap>(
+  agentName: Name
+) => {
+  return coreAgent<AgentMap>(agentName as string & keyof AgentMap) as PikkuFunctionConfig<
+    AIAgentInput,
+    { runId: string; result: AgentMap[Name]['output']; usage: { inputTokens: number; outputTokens: number } },
+    'session' | 'rpc'
+  >
+}
+
+export const agentStream = <Name extends keyof AgentMap>(
+  agentName?: Name
+) => {
+  return coreAgentStream<AgentMap>(agentName as string & keyof AgentMap) as PikkuFunctionConfig<
+    { agentName?: string; message: string; threadId: string; resourceId: string },
+    void,
+    'session' | 'rpc'
+  >
+}
+
+export const agentResume = () => {
+  return coreAgentResume() as PikkuFunctionConfig<
+    { runId: string; toolCallId: string; approved: boolean },
+    void,
+    'session' | 'rpc'
+  >
+}
+
+export const agentApprove = <Name extends keyof AgentMap>(
+  agentName: Name
+) => {
+  return coreAgentApprove<AgentMap>(agentName as string & keyof AgentMap) as PikkuFunctionConfig<
+    { runId: string; approvals: { toolCallId: string; approved: boolean }[] },
+    unknown,
+    'session' | 'rpc'
+  >
+}
 `;
 };