@pikku/cli 0.11.3 → 0.12.0

package/dist/src/functions/commands/versions-init.d.ts

@@ -0,0 +1,7 @@
+export declare const pikkuVersionsInit: import("#pikku").PikkuFunctionConfig<{
+    force?: boolean;
+}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+    force?: boolean;
+}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    force?: boolean;
+}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

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

@@ -0,0 +1,15 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { pikkuSessionlessFunc } from '#pikku';
+import { createEmptyManifest, saveManifest, } from '../../utils/contract-versions.js';
+export const pikkuVersionsInit = pikkuSessionlessFunc({
+    func: async ({ logger, config }, { force }) => {
+        const manifestPath = join(config.outDir, 'versions.json');
+        if (existsSync(manifestPath) && !force) {
+            logger.error(`Version manifest already exists at ${manifestPath}. Use --force to overwrite.`);
+            process.exit(1);
+        }
+        await saveManifest(manifestPath, createEmptyManifest());
+        logger.info(`Version manifest created at ${manifestPath}`);
+    },
+});

package/dist/src/functions/commands/versions-update.d.ts

@@ -0,0 +1 @@
+export declare const pikkuVersionsUpdate: 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/commands/versions-update.js

@@ -0,0 +1,20 @@
+import { join } from 'path';
+import { pikkuSessionlessFunc } from '#pikku';
+import { ErrorCode } from '@pikku/inspector';
+import { saveManifest } from '../../utils/contract-versions.js';
+export const pikkuVersionsUpdate = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        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.`);
+        }
+        const immutabilityErrors = visitState.manifest.errors.filter((e) => e.code === ErrorCode.FUNCTION_VERSION_MODIFIED);
+        if (immutabilityErrors.length > 0) {
+            const messages = immutabilityErrors.map((e) => `[${e.code}] ${e.message}`);
+            throw new Error(messages.join('\n'));
+        }
+        await saveManifest(manifestPath, visitState.manifest.current);
+        logger.debug(`Version manifest updated at ${manifestPath}`);
+    },
+});

package/dist/src/functions/commands/watch.d.ts

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

@@ -1,9 +1,8 @@
-import { pikkuVoidFunc } from '../../../.pikku/pikku-types.gen.js';
+import { pikkuVoidFunc } from '#pikku';
 import chokidar from 'chokidar';
-import { all } from './all.js';
 export const watch = pikkuVoidFunc({
-    func: async ({ logger, config, getInspectorState }) => {
-        const services = { logger, config, getInspectorState };
+    remote: true,
+    func: async ({ logger, config }, _data, { rpc }) => {
         const configWatcher = chokidar.watch(config.srcDirectories, {
             ignoreInitial: true,
             ignored: /.*\.gen\.tsx?/,
@@ -20,7 +19,7 @@ export const watch = pikkuVoidFunc({
                 const handle = async () => {
                     try {
                         const start = Date.now();
-                        await all.func(services, null, {});
+                        await rpc.invoke('all', null);
                         logger.info({
                             message: `✓ Generated in ${Date.now() - start}ms`,
                             type: 'timing',

package/dist/src/functions/runtimes/fetch/index.d.ts

@@ -0,0 +1 @@
+export declare const pikkuFetch: 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 → runtimes}/fetch/index.js

@@ -1,5 +1,5 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
-import { serializeFetchWrapper } from '../http/serialize-fetch-wrapper.js';
+import { pikkuSessionlessFunc } from '#pikku';
+import { serializeFetchWrapper } from '../../wirings/http/serialize-fetch-wrapper.js';
 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';
@@ -8,7 +8,7 @@ export const pikkuFetch = pikkuSessionlessFunc({
         const { fetchFile, httpMapDeclarationFile, packageMappings } = config;
         // If fetchFile is not set, clean up any existing file and return
         if (!fetchFile) {
-            logger.info({
+            logger.debug({
                 message: "Skipping generating fetch wrapper since fetchFile isn't set in the pikku config.",
                 type: 'skip',
             });

package/dist/src/functions/runtimes/nextjs/pikku-command-nextjs.d.ts

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { checkRequiredTypes } from '../../../utils/check-required-types.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
@@ -10,7 +10,7 @@ export const pikkuNext = pikkuSessionlessFunc({
         const { nextBackendFile, nextHTTPFile, httpMapDeclarationFile, rpcMapDeclarationFile, packageMappings, fetchFile, } = config;
         // If both files are undefined, clean up any existing files and return
         if (!nextBackendFile && !nextHTTPFile) {
-            logger.info({
+            logger.debug({
                 message: 'Skipping generating nextjs wrapper since nextjs outfile is not defined.',
                 type: 'skip',
             });
@@ -27,17 +27,16 @@ export const pikkuNext = pikkuSessionlessFunc({
             checkRequiredTypes(visitState.filesAndMethodsErrors, {
                 config: true,
                 singletonServicesFactory: true,
-                wireServicesFactory: true,
             });
             const { pikkuConfigFactory, singletonServicesFactory, wireServicesFactory, } = visitState.filesAndMethods;
-            if (!pikkuConfigFactory ||
-                !singletonServicesFactory ||
-                !wireServicesFactory) {
+            if (!pikkuConfigFactory || !singletonServicesFactory) {
                 throw new Error('Required types not found');
             }
             const pikkuConfigImport = `import { ${pikkuConfigFactory.variable} as createConfig } from '${getFileImportRelativePath(nextBackendFile, pikkuConfigFactory.file, packageMappings)}'`;
             const singletonServicesImport = `import { ${singletonServicesFactory.variable} as createSingletonServices } from '${getFileImportRelativePath(nextBackendFile, singletonServicesFactory.file, packageMappings)}'`;
-            const wireServicesImport = `import { ${wireServicesFactory.variable} as createWireServices } from '${getFileImportRelativePath(nextBackendFile, wireServicesFactory.file, packageMappings)}'`;
+            const wireServicesImport = wireServicesFactory
+                ? `import { ${wireServicesFactory.variable} as createWireServices } from '${getFileImportRelativePath(nextBackendFile, wireServicesFactory.file, packageMappings)}'`
+                : '';
             const bootstrapPath = getFileImportRelativePath(nextBackendFile, config.bootstrapFile, packageMappings);
             const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpMapDeclarationFile, packageMappings);
             const rpcMapDeclarationPath = getFileImportRelativePath(nextBackendFile, rpcMapDeclarationFile, packageMappings);

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

@@ -1 +1 @@
-export declare const serializeNextJsBackendWrapper: (bootstrapPath: string, routesMapPath: string, rpcMapPath: string, configImport: string, singleServicesFactoryImport: string, wireServicesImport: string) => string;
+export declare const serializeNextJsBackendWrapper: (bootstrapPath: string, routesMapPath: string, rpcMapPath: string, configImport: string, singleServicesFactoryImport: string, wireServicesImport: string | undefined) => string;

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

@@ -1,4 +1,5 @@
 export const serializeNextJsBackendWrapper = (bootstrapPath, routesMapPath, rpcMapPath, configImport, singleServicesFactoryImport, wireServicesImport) => {
+    const hasWireServices = !!wireServicesImport;
     return `'server-only'
 
 /**
@@ -14,7 +15,7 @@ type RouteContext = { params: Promise<Record<string, string | string[]>> }
 
 ${configImport}
 ${singleServicesFactoryImport}
-${wireServicesImport}
+${wireServicesImport ? wireServicesImport : ''}
 
 import '${bootstrapPath}'
 
@@ -25,17 +26,12 @@ export const removeAPIPrefix = (enable: boolean) => {
   _removeAPIPrefix = enable
 }
 
-/**
- * Initializes and returns an instance of PikkuNextJS with helper methods for handling route requests.
- *
- * @returns An object containing methods for making dynamic and static action requests, as well as session retrieval.
- */
 export const pikku = (_options?: any) => {
   if (!_pikku) {
     _pikku = new PikkuNextJS(
       createConfig as any,
       createSingletonServices as any,
-      createWireServices
+      ${hasWireServices ? 'createWireServices' : 'undefined'}
     )
   }
 
@@ -199,11 +195,9 @@ export const pikku = (_options?: any) => {
    */
   const rpc = async <Name extends keyof FlattenedRPCMap>(
     rpcName: Name,
-    ...args: FlattenedRPCMap[Name]['input'] extends null | undefined
-      ? [data?: FlattenedRPCMap[Name]['input']]
-      : [data: NonNullable<FlattenedRPCMap[Name]['input']>]
+    data: FlattenedRPCMap[Name]['input']
   ): Promise<FlattenedRPCMap[Name]['output']> => {
-    return dynamicActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: args[0] ?? null }) as unknown as FlattenedRPCMap[Name]['output']
+    return dynamicActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: data ?? null }) as unknown as FlattenedRPCMap[Name]['output']
   }
 
   /**
@@ -217,11 +211,9 @@ export const pikku = (_options?: any) => {
    */
   const staticRPC = async <Name extends keyof FlattenedRPCMap>(
     rpcName: Name,
-    ...args: FlattenedRPCMap[Name]['input'] extends null | undefined
-      ? [data?: FlattenedRPCMap[Name]['input']]
-      : [data: NonNullable<FlattenedRPCMap[Name]['input']>]
+    data: FlattenedRPCMap[Name]['input']
   ): Promise<FlattenedRPCMap[Name]['output']> => {
-    return staticActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: args[0] ?? null }) as unknown as FlattenedRPCMap[Name]['output']
+    return staticActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: data ?? null }) as unknown as FlattenedRPCMap[Name]['output']
   }
 
   return {
@@ -256,7 +248,7 @@ export const pikkuAPIRequest = (
     _pikku = new PikkuNextJS(
       createConfig as any,
       createSingletonServices as any,
-      createWireServices
+      ${hasWireServices ? 'createWireServices' : 'undefined'}
     )
   }
   if (_removeAPIPrefix) {

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

@@ -171,11 +171,9 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
    */
   const rpc = async <Name extends keyof FlattenedRPCMap>(
     rpcName: Name,
-    ...args: FlattenedRPCMap[Name]['input'] extends null | undefined
-      ? [data?: FlattenedRPCMap[Name]['input']]
-      : [data: NonNullable<FlattenedRPCMap[Name]['input']>]
+    data: FlattenedRPCMap[Name]['input']
   ): Promise<FlattenedRPCMap[Name]['output']> => {
-    return dynamicActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: args[0] ?? null }) as unknown as FlattenedRPCMap[Name]['output']
+    return dynamicActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: data ?? null }) as unknown as FlattenedRPCMap[Name]['output']
   }
 
   /**
@@ -189,11 +187,9 @@ export const pikku = (options?: CorePikkuFetchOptions) => {
    */
   const staticRPC = async <Name extends keyof FlattenedRPCMap>(
     rpcName: Name,
-    ...args: FlattenedRPCMap[Name]['input'] extends null | undefined
-      ? [data?: FlattenedRPCMap[Name]['input']]
-      : [data: NonNullable<FlattenedRPCMap[Name]['input']>]
+    data: FlattenedRPCMap[Name]['input']
   ): Promise<FlattenedRPCMap[Name]['output']> => {
-    return staticActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: args[0] ?? null }) as unknown as FlattenedRPCMap[Name]['output']
+    return staticActionRequest('/rpc/:rpcName' as '/rpc/:rpcName', 'POST', { rpcName, data: data ?? null }) as unknown as FlattenedRPCMap[Name]['output']
   }
 
   return {

package/dist/src/functions/runtimes/websocket/pikku-command-websocket-typed.d.ts

@@ -0,0 +1 @@
+export declare const pikkuWebSocketTyped: 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 → runtimes/websocket}/pikku-command-websocket-typed.js

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+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';
@@ -8,7 +8,7 @@ export const pikkuWebSocketTyped = pikkuSessionlessFunc({
         const { websocketFile, channelsMapDeclarationFile, packageMappings } = config;
         // If websocketFile is not set, clean up any existing file and return
         if (!websocketFile) {
-            logger.info({
+            logger.debug({
                 message: "Skipping generating websocket wrapper since websocketFile isn't set in the pikku config.",
                 type: 'skip',
             });

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

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

@@ -0,0 +1,19 @@
+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 { serializeAIAgentTypes } from './serialize-ai-agent-types.js';
+export const pikkuAIAgentTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config }) => {
+        const { agentTypesFile, functionTypesFile, packageMappings } = config;
+        const functionTypesImportPath = getFileImportRelativePath(agentTypesFile, functionTypesFile, packageMappings);
+        const content = serializeAIAgentTypes(functionTypesImportPath);
+        await writeFileInDir(logger, agentTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating AI agent types',
+            commandEnd: 'Created AI agent types',
+        }),
+    ],
+});

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

@@ -0,0 +1 @@
+export declare const pikkuAIAgent: 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/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';

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: [