@pikku/cli 0.12.0 → 0.12.1

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

@@ -1,7 +1,7 @@
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const serializeFunctionImports = (outputPath, functionsMap, functionsMeta, packageMappings = {}, 
-/** Package name for external packages (e.g., '@pikku/templates-function-external') */
-externalPackageName) => {
+/** Package name for addon packages (e.g., '@pikku/templates-function-addon') */
+addonName) => {
     const serializedImports = [
         `/* Import and register functions used by RPCs */`,
         `import { addFunction } from '@pikku/core'`,
@@ -10,7 +10,7 @@ externalPackageName) => {
     // Sort by function name for consistent output
     const sortedEntries = Array.from(functionsMap.entries()).sort((a, b) => a[0].localeCompare(b[0]));
     // Third argument to addFunction is the package name (null for main package)
-    const packageArg = externalPackageName ? `, '${externalPackageName}'` : '';
+    const packageArg = addonName ? `, '${addonName}'` : '';
     const usedAliases = new Set();
     for (const [name, { path, exportedName }] of sortedEntries) {
         const filePath = getFileImportRelativePath(outputPath, path, packageMappings);

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

@@ -12,7 +12,8 @@ export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeNam
  * Core function, middleware, and permission types for all wirings
  */
 
-import { CorePikkuFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired, CreateWireServices } from '@pikku/core'
+import { CorePikkuFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission, CorePikkuMiddleware, CorePermissionGroup, addMiddleware as addMiddlewareCore, addPermission as addPermissionCore, PikkuWire, PickRequired } from '@pikku/core'
+import { pikkuState as __pikkuState, CreateWireServices } from '@pikku/core/internal'
 import { pikkuAuth as pikkuAuthCore } from '@pikku/core'
 import type { NodeType } from '@pikku/core/node'
 import type { StandardSchemaV1 } from '@standard-schema/spec'
@@ -480,27 +481,27 @@ export const pikkuVoidFunc = (
 }
 
 /**
- * Creates a wrapper function for external package functions that are exposed via RPC.
- * This allows you to wire external functions to any wiring type (HTTP, queue, etc.)
+ * Creates a wrapper function for addon package functions that are exposed via RPC.
+ * This allows you to wire addon functions to any wiring type (HTTP, queue, etc.)
  * without type compatibility issues.
  *
  * @template Name - The RPC method name (must be a key in FlattenedRPCMap)
  * @param rpcName - The name of the RPC method to invoke
- * @returns A Pikku function that proxies calls to the external RPC method
+ * @returns A Pikku function that proxies calls to the addon RPC method
  *
  * @example
  * \`\`\`typescript
- * // Wire an external function via HTTP
+ * // Wire an addon function via HTTP
  * wireHTTP({
  *   auth: false,
  *   method: 'get',
- *   route: '/external/hello',
- *   func: external('ext:hello'),
- *   tags: ['external'],
+ *   route: '/addon/hello',
+ *   func: addon('ext:hello'),
+ *   tags: ['addon'],
  * })
  * \`\`\`
  */
-export const external = <Name extends keyof FlattenedRPCMap>(
+export const addon = <Name extends keyof FlattenedRPCMap>(
   rpcName: Name
 ): PikkuFunctionConfig<
   FlattenedRPCMap[Name]['input'],
@@ -508,9 +509,9 @@ export const external = <Name extends keyof FlattenedRPCMap>(
   'session' | 'rpc'
 > => {
   return {
-    func: (async (_services: any, data: any, { rpc }: any) => {
+    func: async (_services: any, data: FlattenedRPCMap[Name]['input'], { rpc }: any) => {
       return rpc.invoke(rpcName, data)
-    }) as any
+    }
   } as PikkuFunctionConfig<
     FlattenedRPCMap[Name]['input'],
     FlattenedRPCMap[Name]['output'],
@@ -559,8 +560,14 @@ export const pikkuConfig = (
  * \`\`\`
  */
 export const pikkuServices = (
-  func: (config: Config, existingServices?: Partial<SingletonServices>) => Promise<RequiredSingletonServices>
-) => func
+  func: (config: Config, existingServices: Partial<SingletonServices>) => Promise<RequiredSingletonServices>
+) => {
+  return async (config: Config, existingServices: Partial<SingletonServices> = {}) => {
+    const services = await func(config, existingServices)
+    __pikkuState(null, 'package', 'singletonServices', services as any)
+    return services
+  }
+}
 
 /**
  * Creates a Pikku wire services factory.
@@ -584,7 +591,11 @@ export const pikkuWireServices = (
     services: SingletonServices,
     wire: any
   ) => Promise<RequiredWireServices>
-): CreateWireServices => func as unknown as CreateWireServices
+): CreateWireServices => {
+  const factories = __pikkuState(null, 'package', 'factories')
+  __pikkuState(null, 'package', 'factories', { ...factories, createWireServices: func as any })
+  return func as unknown as CreateWireServices
+}
 
 /**
  * Adds global middleware for a specific tag.
@@ -639,5 +650,8 @@ export const addMiddleware = (tag: string, middleware: PikkuMiddleware[]) => {
 export const addPermission = <In = unknown>(tag: string, permissions: CorePermissionGroup<PikkuPermission<In>> | PikkuPermission<In>[]) => {
   addPermissionCore(tag, permissions as any, ${packageNameValue})
 }
+
+export { wireAddon } from '@pikku/core'
+export type { WireAddonConfig } from '@pikku/core'
 `;
 };

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

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

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

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

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

@@ -24,7 +24,7 @@ export const pikkuHTTP = pikkuSessionlessFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core'\nimport type { HTTPWiringsMeta } from '@pikku/core/http'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`);
+        await writeFileInDir(logger, httpWiringMetaFile, `import { pikkuState } from '@pikku/core/internal'\nimport type { HTTPWiringsMeta } from '@pikku/core/http'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`);
         return true;
     },
     middleware: [

package/dist/src/functions/wirings/http/pikku-http-routes.js

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

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

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

package/dist/src/functions/wirings/mcp/pikku-command-mcp.js

@@ -81,7 +81,7 @@ export const pikkuMCP = pikkuSessionlessFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, mcpWiringsMetaFile, `import { pikkuState } from '@pikku/core'
+        await writeFileInDir(logger, mcpWiringsMetaFile, `import { pikkuState } from '@pikku/core/internal'
 import type { MCPResourceMeta, MCPToolMeta, MCPPromptMeta } from '@pikku/core/mcp'
 ${importStatement}
 pikkuState(null, 'mcp', 'resourcesMeta', metaData.resourcesMeta as MCPResourceMeta)

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

@@ -4,11 +4,11 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializePackageFactories } from './serialize-package.js';
 export const pikkuPackage = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
-        const { externalPackageName, packageMappings, packageFile } = config;
-        // Only generate for external packages
-        if (!externalPackageName) {
+        const { addonName, packageMappings, packageFile } = config;
+        // Only generate for addon packages
+        if (!addonName) {
             logger.debug({
-                message: 'Skipping package factories - not an external package (externalPackageName not set)',
+                message: 'Skipping package factories - not an addon package (addonName not set)',
                 type: 'skip',
             });
             return false;
@@ -23,7 +23,7 @@ export const pikkuPackage = pikkuSessionlessFunc({
         const state = await getInspectorState();
         const { filesAndMethods } = state;
         const { pikkuConfigFactory, singletonServicesFactory, wireServicesFactory, } = filesAndMethods;
-        const content = serializePackageFactories(packageFile, externalPackageName, pikkuConfigFactory
+        const content = serializePackageFactories(packageFile, addonName, pikkuConfigFactory
             ? {
                 file: pikkuConfigFactory.file,
                 variable: pikkuConfigFactory.variable,

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

@@ -1,7 +1,7 @@
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const serializePackageFactories = (outputPath, packageName, configFactory, singletonServicesFactory, wireServicesFactory, packageMappings = {}) => {
     const imports = [
-        `import { addPackageServiceFactories } from '@pikku/core'`,
+        `import { pikkuState } from '@pikku/core/internal'`,
     ];
     const factoryEntries = [];
     if (configFactory) {
@@ -25,7 +25,7 @@ export const serializePackageFactories = (outputPath, packageName, configFactory
     }
     return `${imports.join('\n')}
 
-addPackageServiceFactories('${packageName}', {
+pikkuState('${packageName}', 'package', 'factories', {
 ${factoryEntries.join('\n')}
 })
 `;

package/dist/src/functions/wirings/permissions/pikku-command-permissions.js

@@ -14,11 +14,6 @@ export const pikkuPermissions = pikkuSessionlessFunc({
         if (hasHTTPGroups || hasTagGroups || hasIndividual) {
             const metaData = state.permissionsGroupsMeta;
             await writeFileInDir(logger, config.permissionsGroupsMetaJsonFile, JSON.stringify(metaData, null, 2));
-            filesGenerated = true;
-        }
-        const hasHTTPFactories = Array.from(state.http.routePermissions.values()).some((meta) => meta.exportName && meta.isFactory);
-        const hasTagFactories = Array.from(state.permissions.tagPermissions.values()).some((meta) => meta.exportName && meta.isFactory);
-        if (hasHTTPFactories || hasTagFactories) {
             await writeFileInDir(logger, permissionsFile, serializePermissionsImports(permissionsFile, permissions, state.http, packageMappings));
             filesGenerated = true;
         }

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

@@ -1,6 +1,6 @@
 import type { QueueWorkersMeta } from '@pikku/core/queue';
-import { TypesMap } from '@pikku/inspector';
-import { Logger } from '@pikku/core/services';
+import type { TypesMap } from '@pikku/inspector';
+import type { Logger } from '@pikku/core/services';
 export declare const serializeQueueMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, queueWorkersMeta: QueueWorkersMeta, resolvedIOTypes: Record<string, {
     inputType: string;
     outputType: string;

package/dist/src/functions/wirings/queue/serialize-queue-meta.d.ts

@@ -1,3 +1,3 @@
-import { QueueWorkersMeta } from '@pikku/core/queue';
+import type { QueueWorkersMeta } from '@pikku/core/queue';
 export declare const serializeQueueMeta: (queueWorkersMeta: QueueWorkersMeta) => QueueWorkersMeta;
 export declare const serializeQueueMetaTS: (jsonImportPath: string, supportsImportAttributes: boolean) => string;

package/dist/src/functions/wirings/rpc/pikku-command-rpc-map.js

@@ -6,10 +6,10 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 export const pikkuRPCInternalMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { functions, rpc, resolvedIOTypes } = await getInspectorState();
-        const { rpcInternalMapDeclarationFile, packageMappings, externalPackages, workflowMapDeclarationFile, agentMapDeclarationFile, } = config;
+        const { rpcInternalMapDeclarationFile, packageMappings, workflowMapDeclarationFile, agentMapDeclarationFile, } = config;
         const workflowMapPath = getFileImportRelativePath(rpcInternalMapDeclarationFile, workflowMapDeclarationFile, packageMappings);
         const agentMapPath = getFileImportRelativePath(rpcInternalMapDeclarationFile, agentMapDeclarationFile, packageMappings);
-        const content = serializeTypedRPCMap(logger, rpcInternalMapDeclarationFile, packageMappings, functions.typesMap, rpc.internalMeta, resolvedIOTypes, externalPackages, workflowMapPath, agentMapPath);
+        const content = serializeTypedRPCMap(logger, rpcInternalMapDeclarationFile, packageMappings, functions.typesMap, rpc.internalMeta, resolvedIOTypes, rpc.wireAddonDeclarations, workflowMapPath, agentMapPath);
         await writeFileInDir(logger, rpcInternalMapDeclarationFile, content);
     },
     middleware: [
@@ -22,16 +22,16 @@ export const pikkuRPCInternalMap = pikkuSessionlessFunc({
 export const pikkuRPCExposedMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { functions, rpc, resolvedIOTypes } = await getInspectorState();
-        const { rpcMapDeclarationFile, packageMappings, externalPackages, workflowMapDeclarationFile, agentMapDeclarationFile, } = config;
+        const { rpcMapDeclarationFile, packageMappings, workflowMapDeclarationFile, agentMapDeclarationFile, } = config;
         const workflowMapPath = getFileImportRelativePath(rpcMapDeclarationFile, workflowMapDeclarationFile, packageMappings);
         const agentMapPath = getFileImportRelativePath(rpcMapDeclarationFile, agentMapDeclarationFile, packageMappings);
-        const content = serializeTypedRPCMap(logger, rpcMapDeclarationFile, packageMappings, functions.typesMap, rpc.exposedMeta, resolvedIOTypes, externalPackages, workflowMapPath, agentMapPath);
+        const content = serializeTypedRPCMap(logger, rpcMapDeclarationFile, packageMappings, functions.typesMap, rpc.exposedMeta, resolvedIOTypes, rpc.wireAddonDeclarations, workflowMapPath, agentMapPath);
         await writeFileInDir(logger, rpcMapDeclarationFile, content);
     },
     middleware: [
         logCommandInfoAndTime({
-            commandStart: 'Creating RPC external map',
-            commandEnd: 'Created RPC external map',
+            commandStart: 'Creating RPC addon map',
+            commandEnd: 'Created RPC addon map',
         }),
     ],
 });

package/dist/src/functions/wirings/rpc/pikku-command-rpc.js

@@ -13,10 +13,8 @@ export const pikkuRPC = pikkuSessionlessFunc({
             const importStatement = supportsImportAttributes
                 ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
                 : `import metaData from '${jsonImportPath}'`;
-            const packageNameArg = config.externalPackageName
-                ? `'${config.externalPackageName}'`
-                : 'null';
-            await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core'\n${importStatement}\npikkuState(${packageNameArg}, 'rpc', 'meta', metaData as Record<string, string>)`);
+            const packageNameArg = config.addonName ? `'${config.addonName}'` : 'null';
+            await writeFileInDir(logger, rpcInternalWiringMetaFile, `import { pikkuState } from '@pikku/core/internal'\n${importStatement}\npikkuState(${packageNameArg}, 'rpc', 'meta', metaData as Record<string, string>)`);
             return true;
         }
         return false;

package/dist/src/functions/wirings/rpc/serialize-public-rpc.js

@@ -7,12 +7,8 @@ export const serializePublicRPC = (pathToPikkuTypes, requireAuth = true) => {
  * Auto-generated public RPC HTTP endpoint
  * Do not edit manually - regenerate with 'npx pikku'
  */
-import { pikkuSessionlessFunc, wireHTTP } from '${pathToPikkuTypes}'
+import { pikkuSessionlessFunc, defineHTTPRoutes, wireHTTPRoutes } from '${pathToPikkuTypes}'
 
-/**
- * Public RPC endpoint that invokes any exposed RPC by name
- * This is used for public HTTP access to exposed server functions
- */
 export const rpcCaller = pikkuSessionlessFunc<
   { rpcName: string; data?: unknown },
   unknown
@@ -23,20 +19,33 @@ export const rpcCaller = pikkuSessionlessFunc<
   },
 })
 
-wireHTTP({
-  route: "/rpc/:rpcName",
-  method: "options",
-  tags: ['pikku:public'],
+export const workflowCaller = pikkuSessionlessFunc<
+  { workflowName: string; input?: unknown },
+  { runId: string }
+>({
   auth: ${authFlag},
-  func: pikkuSessionlessFunc<{ rpcName: string }>(async () => void 0),
-});
+  func: async (_services, { workflowName, input }, { rpc }) => {
+    return await rpc.startWorkflow(workflowName, input || {})
+  },
+})
 
-wireHTTP({
-  route: '/rpc/:rpcName',
-  method: 'post',
-  tags: ['pikku:public'],
+export const rpcRoutes = defineHTTPRoutes({
   auth: ${authFlag},
-  func: rpcCaller,
+  tags: ['pikku:public'],
+  routes: {
+    rpc: {
+      route: '/rpc/:rpcName',
+      method: 'post',
+      func: rpcCaller,
+    },
+    workflow: {
+      route: '/rpc/workflow/:workflowName',
+      method: 'post',
+      func: workflowCaller,
+    },
+  },
 })
+
+wireHTTPRoutes({ routes: { rpc: rpcRoutes } })
 `;
 };

package/dist/src/functions/wirings/rpc/serialize-rpc-wrapper.js

@@ -1,7 +1,7 @@
 export const serializeRPCWrapper = (rpcMapPath) => {
     return `
 import { PikkuFetch } from "./pikku-fetch.gen.js"
-import type { RPCInvoke, TypedAgent } from '${rpcMapPath}'
+import type { RPCInvoke, TypedAgentRun, TypedStartWorkflow } from '${rpcMapPath}'
 
 /**
  * PikkuRPC provides a type-safe client for making Remote Procedure Calls (RPC)
@@ -63,14 +63,50 @@ export class PikkuRPC {
     }
 
     /**
-     * Invokes an AI agent on the server.
+     * Starts a workflow by name with the given input.
+     * Posts to \\\`/rpc/workflow/:workflowName\\\`.
      *
-     * @param agentName - The name of the agent to invoke
-     * @param input - The agent input (message, threadId, resourceId)
-     * @returns A promise that resolves with the agent's output
+     * @param workflowName - The registered workflow name
+     * @param input - The workflow input data
+     * @returns A promise that resolves with the new run ID
      */
-    agent: TypedAgent = async (agentName, input) => {
-       return await this.pikkuFetch.post(\`/rpc/agent/\${String(agentName)}\` as never, input) as any
+    startWorkflow: TypedStartWorkflow = async (workflowName, input) => {
+        return await this.pikkuFetch.post(\`/rpc/workflow/\${String(workflowName)}\` as never, { workflowName: String(workflowName), input }) as any
+    }
+
+    /**
+     * Agent namespace — methods for running, streaming, and approving AI agents.
+     * All methods post to \\\`/rpc/agent/:agentName/*\\\`.
+     */
+    agent = {
+        /**
+         * Runs an agent to completion and returns the result.
+         *
+         * @param agentName - The registered agent name
+         * @param input - The agent input (message, threadId, resourceId)
+         * @returns A promise with runId, result, and token usage
+         */
+        run: (async (agentName, input) => {
+            return await this.pikkuFetch.post(\`/rpc/agent/\${String(agentName)}\` as never, input) as any
+        }) as TypedAgentRun,
+        /**
+         * Streams agent responses via SSE. Used for real-time chat interfaces.
+         *
+         * @param agentName - The registered agent name
+         * @param input - The agent input (message, threadId, resourceId)
+         */
+        stream: async (agentName: string, input: Record<string, unknown>) => {
+            return await this.pikkuFetch.post(\`/rpc/agent/\${String(agentName)}/stream\` as never, input) as any
+        },
+        /**
+         * Approves or denies pending tool calls for an agent run.
+         *
+         * @param agentName - The registered agent name
+         * @param input - The approval payload (runId, approvals array)
+         */
+        approve: async (agentName: string, input: Record<string, unknown>) => {
+            return await this.pikkuFetch.post(\`/rpc/agent/\${String(agentName)}/approve\` as never, input) as any
+        },
     }
 }
 

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

@@ -1,6 +1,11 @@
-import { TypesMap, ExternalPackageConfig } from '@pikku/inspector';
-import { Logger } from '@pikku/core/services';
+import type { TypesMap } from '@pikku/inspector';
+import type { Logger } from '@pikku/core/services';
+type WireAddonDeclarations = Map<string, {
+    package: string;
+    rpcEndpoint?: string;
+}>;
 export declare const serializeTypedRPCMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, rpcMeta: Record<string, string>, resolvedIOTypes: Record<string, {
     inputType: string;
     outputType: string;
-}>, externalPackages?: Record<string, ExternalPackageConfig>, workflowMapPath?: string, agentMapPath?: string) => string;
+}>, wireAddonDeclarations?: WireAddonDeclarations, workflowMapPath?: string, agentMapPath?: string) => string;
+export {};

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

@@ -1,6 +1,6 @@
 import { serializeImportMap } from '../../../utils/serialize-import-map.js';
-import { generateCustomTypes, } from '@pikku/inspector';
-export const serializeTypedRPCMap = (logger, relativeToPath, packageMappings, typesMap, rpcMeta, resolvedIOTypes, externalPackages, workflowMapPath, agentMapPath) => {
+import { generateCustomTypes } from '@pikku/inspector';
+export const serializeTypedRPCMap = (logger, relativeToPath, packageMappings, typesMap, rpcMeta, resolvedIOTypes, wireAddonDeclarations, workflowMapPath, agentMapPath) => {
     const requiredTypes = new Set();
     const serializedCustomTypes = generateCustomTypes(typesMap, requiredTypes);
     const serializedRPCs = generateRPCs(rpcMeta, resolvedIOTypes, requiredTypes);
@@ -21,8 +21,8 @@ export const serializeTypedRPCMap = (logger, relativeToPath, packageMappings, ty
         .split('\n')
         .filter((line) => !line.startsWith('import '))
         .join('\n');
-    const externalPackageImports = generateExternalPackageImports(externalPackages, relativeToPath);
-    const mergedRPCMap = generateMergedRPCMap(externalPackages);
+    const addonImports = generateAddonImports(wireAddonDeclarations, relativeToPath);
+    const mergedRPCMap = generateMergedRPCMap(wireAddonDeclarations);
     return `/**
  * This provides the structure needed for typescript to be aware of RPCs and their return types
  */
@@ -37,7 +37,7 @@ interface RPCHandler<I, O> {
 }
 
 ${serializedRPCs}
-${externalPackageImports}
+${addonImports}
 ${mergedRPCMap}
 
 export type RPCInvoke = <Name extends keyof FlattenedRPCMap>(
@@ -53,8 +53,8 @@ export type RPCRemote = <Name extends keyof FlattenedRPCMap>(
 ${workflowMapPath ? `import type { WorkflowMap } from '${workflowMapPath}'` : `type WorkflowMap = {}`}
 
 ${agentMapPath ? `import type { AgentMap } from '${agentMapPath}'` : `type AgentMap = {}`}
-${generateExternalAgentImports(externalPackages)}
-${generateMergedAgentMap(externalPackages)}
+${generateAddonAgentImports(wireAddonDeclarations)}
+${generateMergedAgentMap(wireAddonDeclarations)}
 
 import type { PikkuRPC } from '@pikku/core/rpc'
 
@@ -64,36 +64,46 @@ interface AIAgentInput {
   resourceId: string
 }
 
-type TypedStartWorkflow = <Name extends keyof WorkflowMap>(
+export type TypedStartWorkflow = <Name extends keyof WorkflowMap>(
   name: Name,
   input: WorkflowMap[Name]['input'],
   options?: { startNode?: string }
 ) => Promise<{ runId: string }>
 
-type TypedAgent = <Name extends keyof FlattenedAgentMap>(
-  name: Name,
-  input: AIAgentInput
-) => Promise<{ runId: string; result: FlattenedAgentMap[Name]['output']; usage: { inputTokens: number; outputTokens: number } }>
+type TypedAgentRun = [keyof FlattenedAgentMap] extends [never]
+  ? (name: string, input: AIAgentInput) => Promise<any>
+  : <Name extends keyof FlattenedAgentMap>(
+      name: Name,
+      input: AIAgentInput
+    ) => Promise<{ runId: string; result: FlattenedAgentMap[Name]['output']; usage: { inputTokens: number; outputTokens: number } }>
+
+type TypedAgentStream = [keyof FlattenedAgentMap] extends [never]
+  ? (name: string, input: AIAgentInput, options?: { requiresToolApproval?: 'all' | 'explicit' | false }) => Promise<void>
+  : <Name extends keyof FlattenedAgentMap>(
+      name: Name,
+      input: AIAgentInput,
+      options?: { requiresToolApproval?: 'all' | 'explicit' | false }
+    ) => Promise<void>
 
-export type TypedPikkuRPC = PikkuRPC<RPCInvoke, RPCRemote, TypedStartWorkflow, TypedAgent>
+export type TypedPikkuRPC = PikkuRPC<RPCInvoke, RPCRemote, TypedStartWorkflow, TypedAgentRun, TypedAgentStream>
   `;
 };
-function generateExternalPackageImports(externalPackages, relativeToPath) {
-    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+function generateAddonImports(wireAddonDeclarations, relativeToPath) {
+    if (!wireAddonDeclarations || wireAddonDeclarations.size === 0) {
         return '';
     }
-    let imports = '\n// External package RPC maps\n';
-    for (const [namespace, config] of Object.entries(externalPackages)) {
-        // Import the RPCMap from each external package's internal RPC map
+    let imports = '\n// Addon package RPC maps\n';
+    for (const [namespace, decl] of wireAddonDeclarations.entries()) {
+        // Import the RPCMap from each addon package's internal RPC map
         // Use .js extension - package.json exports will resolve to .d.ts for types
-        imports += `import type { RPCMap as ${toPascalCase(namespace)}RPCMap } from '${config.package}/.pikku/rpc/pikku-rpc-wirings-map.internal.gen.js'\n`;
+        imports += `import type { RPCMap as ${toPascalCase(namespace)}RPCMap } from '${decl.package}/.pikku/rpc/pikku-rpc-wirings-map.internal.gen.js'\n`;
     }
     return imports;
 }
-function generateMergedRPCMap(externalPackages) {
-    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+function generateMergedRPCMap(wireAddonDeclarations) {
+    if (!wireAddonDeclarations || wireAddonDeclarations.size === 0) {
         return `
-// No external packages, use RPCMap directly
+// No addon packages, use RPCMap directly
 export type FlattenedRPCMap = RPCMap
 `;
     }
@@ -106,7 +116,7 @@ type PrefixKeys<T, Prefix extends string> = {
 
 // Merge all RPC maps with namespace prefixes
 export type FlattenedRPCMap =
-  RPCMap${Object.keys(externalPackages)
+  RPCMap${Array.from(wireAddonDeclarations.keys())
         .map((namespace) => ` & PrefixKeys<${toPascalCase(namespace)}RPCMap, '${namespace}'>`)
         .join('')}
 `;
@@ -118,25 +128,25 @@ function toPascalCase(str) {
         .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
         .join('');
 }
-function generateExternalAgentImports(externalPackages) {
-    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+function generateAddonAgentImports(wireAddonDeclarations) {
+    if (!wireAddonDeclarations || wireAddonDeclarations.size === 0) {
         return '';
     }
-    let imports = '\n// External package Agent maps\n';
-    for (const [namespace, config] of Object.entries(externalPackages)) {
-        imports += `import type { AgentMap as ${toPascalCase(namespace)}AgentMap } from '${config.package}/.pikku/agent/pikku-agent-map.gen.d.js'\n`;
+    let imports = '\n// Addon package Agent maps\n';
+    for (const [namespace, decl] of wireAddonDeclarations.entries()) {
+        imports += `import type { AgentMap as ${toPascalCase(namespace)}AgentMap } from '${decl.package}/.pikku/agent/pikku-agent-map.gen.d.js'\n`;
     }
     return imports;
 }
-function generateMergedAgentMap(externalPackages) {
-    if (!externalPackages || Object.keys(externalPackages).length === 0) {
+function generateMergedAgentMap(wireAddonDeclarations) {
+    if (!wireAddonDeclarations || wireAddonDeclarations.size === 0) {
         return `
 type FlattenedAgentMap = AgentMap
 `;
     }
     return `
 type FlattenedAgentMap =
-  AgentMap${Object.keys(externalPackages)
+  AgentMap${Array.from(wireAddonDeclarations.keys())
         .map((namespace) => ` & PrefixKeys<${toPascalCase(namespace)}AgentMap, '${namespace}'>`)
         .join('')}
 `;

package/dist/src/functions/wirings/scheduler/serialize-scheduler-meta.d.ts

@@ -1,3 +1,3 @@
-import { ScheduledTasksMeta } from '@pikku/core/scheduler';
+import type { ScheduledTasksMeta } from '@pikku/core/scheduler';
 export declare const serializeSchedulerMeta: (scheduledTasksMeta: ScheduledTasksMeta) => ScheduledTasksMeta;
 export declare const serializeSchedulerMetaTS: (scheduledTasksMeta: ScheduledTasksMeta, jsonImportPath: string, supportsImportAttributes: boolean) => string;

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

@@ -1,5 +1,5 @@
-import { SecretDefinitions } from '@pikku/core/secret';
-import { SchemaRef } from '@pikku/inspector';
+import type { SecretDefinitions } from '@pikku/core/secret';
+import type { SchemaRef } from '@pikku/inspector';
 export interface SerializeSecretsOptions {
     definitions: SecretDefinitions;
     schemaLookup: Map<string, SchemaRef>;

package/dist/src/functions/wirings/triggers/serialize-trigger-meta.d.ts

@@ -1,4 +1,4 @@
-import { TriggerMeta, TriggerSourceMeta } from '@pikku/core/trigger';
+import type { TriggerMeta, TriggerSourceMeta } from '@pikku/core/trigger';
 export declare const serializeTriggerMeta: (triggerMeta: TriggerMeta) => TriggerMeta;
 export declare const serializeTriggerMetaTS: (triggerMeta: TriggerMeta, jsonImportPath: string, supportsImportAttributes: boolean) => string;
 export declare const serializeTriggerSourceMeta: (sourceMeta: TriggerSourceMeta) => TriggerSourceMeta;