@pikku/cli 0.11.3 → 0.12.1

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

@@ -14,7 +14,6 @@ type RouteContext = { params: Promise<Record<string, string | string[]>> }
 
 ${configImport}
 ${singleServicesFactoryImport}
-${wireServicesImport}
 
 import '${bootstrapPath}'
 
@@ -25,17 +24,11 @@ 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
     )
   }
 
@@ -199,11 +192,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 +208,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 +245,6 @@ export const pikkuAPIRequest = (
     _pikku = new PikkuNextJS(
       createConfig as any,
       createSingletonServices as any,
-      createWireServices
     )
   }
   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,20 @@
+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, agentMapDeclarationFile, packageMappings, } = config;
+        const functionTypesImportPath = getFileImportRelativePath(agentTypesFile, functionTypesFile, packageMappings);
+        const agentMapImportPath = getFileImportRelativePath(agentTypesFile, agentMapDeclarationFile, packageMappings);
+        const content = serializeAIAgentTypes(functionTypesImportPath, agentMapImportPath);
+        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, addonName, } = 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 = addonName ? `, '${addonName}'` : '';
+        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 (!addonName &&
+            (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/internal'
+import type { AIAgentMeta } from '@pikku/core/ai-agent'
+${importStatement}
+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;
+    },
+    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 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-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, agentMapImportPath: string) => string;

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

@@ -0,0 +1,76 @@
+export const serializeAIAgentTypes = (functionTypesImportPath, agentMapImportPath) => {
+    return `import {
+  CoreAIAgent,
+  PikkuAIMiddlewareHooks,
+} from '@pikku/core/ai-agent'
+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, AIAgentInput } from '@pikku/core/ai-agent'
+import type { AgentMap } from '${agentMapImportPath}'
+
+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
+
+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'
+  >
+}
+`;
+};

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,68 @@
+export const serializePublicAgent = (pathToPikkuTypes, requireAuth = true) => {
+    const authFlag = requireAuth ? 'true' : 'false';
+    return `import { pikkuSessionlessFunc, defineHTTPRoutes, wireHTTPRoutes } from '${pathToPikkuTypes}'
+
+export const agentCaller = pikkuSessionlessFunc<
+  { agentName: string; message: string; threadId: string; resourceId: string },
+  unknown
+>({
+  auth: ${authFlag},
+  func: async (_services, data, { rpc }) => {
+    return await rpc.agent.run(data.agentName as any, {
+      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, { rpc }) => {
+    await rpc.agent.stream(data.agentName as any, {
+      message: data.message,
+      threadId: data.threadId,
+      resourceId: data.resourceId,
+    })
+  },
+})
+
+export const agentApproveCaller = pikkuSessionlessFunc<
+  { agentName: string; runId: string; approvals: { toolCallId: string; approved: boolean }[] },
+  unknown
+>({
+  auth: ${authFlag},
+  func: async (_services, { runId, approvals, agentName }, { rpc }) => {
+    return await rpc.agent.approve(runId, approvals, agentName)
+  },
+})
+
+export const agentRoutes = defineHTTPRoutes({
+  auth: ${authFlag},
+  tags: ['pikku:public'],
+  routes: {
+    agentRun: {
+      route: '/rpc/agent/:agentName',
+      method: 'post',
+      func: agentCaller,
+    },
+    agentStream: {
+      route: '/rpc/agent/:agentName/stream',
+      method: 'post',
+      sse: true,
+      func: agentStreamCaller,
+    },
+    agentApprove: {
+      route: '/rpc/agent/:agentName/approve',
+      method: 'post',
+      func: agentApproveCaller,
+    },
+  },
+})
+
+wireHTTPRoutes({ routes: { agent: agentRoutes } })
+`;
+};

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(null, 'channel', 'meta', metaData as ChannelsMeta)`);
+        await writeFileInDir(logger, channelsWiringMetaFile, `import { pikkuState } from '@pikku/core/internal'\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, addonName } = config;
         const functionTypesImportPath = getFileImportRelativePath(channelsTypesFile, functionTypesFile, packageMappings);
-        const content = serializeChannelTypes(functionTypesImportPath);
+        const content = serializeChannelTypes(functionTypesImportPath, addonName);
         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,4 +1,4 @@
-import { pikkuSessionlessFunc } from '../../../../.pikku/pikku-types.gen.js';
+import { pikkuSessionlessFunc } from '#pikku';
 import { serializeFileImports } from '../../../utils/file-imports-serializer.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
@@ -24,7 +24,7 @@ export const pikkuChannels = pikkuSessionlessFunc({
         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)`);
+        await writeFileInDir(logger, channelsWiringMetaFile, `import { pikkuState } from '@pikku/core/internal'\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;