@pikku/cli 0.12.0 → 0.12.2

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

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

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

@@ -1,8 +1,6 @@
 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'
+    return `import { pikkuSessionlessFunc, defineHTTPRoutes, wireHTTPRoutes } from '${pathToPikkuTypes}'
 
 export const agentCaller = pikkuSessionlessFunc<
   { agentName: string; message: string; threadId: string; resourceId: string },
@@ -10,7 +8,7 @@ export const agentCaller = pikkuSessionlessFunc<
 >({
   auth: ${authFlag},
   func: async (_services, data, { rpc }) => {
-    return await (rpc.agent as any)(data.agentName, {
+    return await rpc.agent.run(data.agentName as any, {
       message: data.message,
       threadId: data.threadId,
       resourceId: data.resourceId,
@@ -23,13 +21,12 @@ export const agentStreamCaller = pikkuSessionlessFunc<
   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 }
-    )
+  func: async (_services, data, { rpc }) => {
+    await rpc.agent.stream(data.agentName as any, {
+      message: data.message,
+      threadId: data.threadId,
+      resourceId: data.resourceId,
+    })
   },
 })
 
@@ -38,53 +35,34 @@ export const agentApproveCaller = pikkuSessionlessFunc<
   unknown
 >({
   auth: ${authFlag},
-  func: async ({ aiRunState }, { runId, approvals, agentName }) => {
-    if (!aiRunState) {
-      throw new Error('AIRunStateService not available')
-    }
-    return await approveAIAgent(aiRunState, runId, approvals, agentName)
+  func: async (_services, { runId, approvals, agentName }, { rpc }) => {
+    return await rpc.agent.approve(runId, approvals, agentName)
   },
 })
 
-wireHTTP({
-  route: '/rpc/agent/:agentName',
-  method: 'options',
-  tags: ['pikku:public'],
+export const agentRoutes = defineHTTPRoutes({
   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,
+  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,
+    },
+  },
 })
 
-wireHTTP({
-  route: '/rpc/agent/:agentName/approve',
-  method: 'post',
-  tags: ['pikku:public'],
-  auth: ${authFlag},
-  func: agentApproveCaller,
-})
+wireHTTPRoutes({ routes: { agent: agentRoutes } })
 `;
 };

package/dist/src/functions/wirings/channels/pikku-channels.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.js

@@ -5,9 +5,9 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializeChannelTypes } from './serialize-channel-types.js';
 export const pikkuChannelTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        const { channelsTypesFile, functionTypesFile, packageMappings, externalPackageName, } = config;
+        const { channelsTypesFile, functionTypesFile, packageMappings, addonName } = config;
         const functionTypesImportPath = getFileImportRelativePath(channelsTypesFile, functionTypesFile, packageMappings);
-        const content = serializeChannelTypes(functionTypesImportPath, externalPackageName);
+        const content = serializeChannelTypes(functionTypesImportPath, addonName);
         await writeFileInDir(logger, channelsTypesFile, content);
     },
     middleware: [

package/dist/src/functions/wirings/channels/pikku-command-channels.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-typed-channel-map.d.ts

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

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

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

package/dist/src/functions/wirings/cli/serialize-channel-cli-client.d.ts

@@ -1,5 +1,5 @@
-import { CLIProgramMeta } from '@pikku/core/cli';
-import { Config } from '../../../../types/application-types.js';
+import type { CLIProgramMeta } from '@pikku/core/cli';
+import type { Config } from '../../../../types/application-types.js';
 /**
  * Collect all unique renderer names from CLI metadata (populated by inspector)
  */

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

@@ -1,4 +1,4 @@
-import { CLIProgramMeta } from '@pikku/core/cli';
+import type { CLIProgramMeta } from '@pikku/core/cli';
 /**
  * Serializes a wireChannel call from CLI metadata
  * This creates a WebSocket backend for all CLI commands

package/dist/src/functions/wirings/cli/serialize-local-cli-bootstrap.d.ts

@@ -1,4 +1,4 @@
-import { Config } from '../../../../types/application-types.js';
+import type { Config } from '../../../../types/application-types.js';
 /**
  * Serializes the local (in-program) CLI bootstrap code
  */

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

@@ -3,13 +3,12 @@ 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 { serializeConsoleFunctions } from './serialize-console-functions.js';
-import { join } from 'path';
 export const pikkuConsoleFunctions = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        if (config.console?.functionsPath) {
-            const consoleFunctionsPath = join(config.rootDir, config.console.functionsPath);
-            const pathToPikkuTypes = getFileImportRelativePath(consoleFunctionsPath, config.typesDeclarationFile, config.packageMappings);
-            await writeFileInDir(logger, consoleFunctionsPath, serializeConsoleFunctions(pathToPikkuTypes));
+        if (config.scaffold?.console) {
+            const pathToPikkuTypes = getFileImportRelativePath(config.consoleFunctionsFile, config.typesDeclarationFile, config.packageMappings);
+            const pathToAgentTypes = getFileImportRelativePath(config.consoleFunctionsFile, config.agentTypesFile, config.packageMappings);
+            await writeFileInDir(logger, config.consoleFunctionsFile, serializeConsoleFunctions(pathToPikkuTypes, pathToAgentTypes));
             return true;
         }
         return false;

package/dist/src/functions/wirings/console/pikku-command-nodes-meta.js

@@ -19,7 +19,7 @@ const loadIcon = async (iconPath, rootDir, logger) => {
         }
         return trimmed.replace(/<\?xml[^?]*\?>\s*/g, '').trim();
     }
-    catch (e) {
+    catch {
         logger.warn(`Could not load icon: ${fullPath}`);
         return undefined;
     }
@@ -60,7 +60,7 @@ export const pikkuNodesMeta = pikkuSessionlessFunc({
                 categories: node?.categories,
             },
         };
-        if (nodesMetaJsonFile) {
+        if (nodesMetaJsonFile && config.scaffold?.console) {
             const minimalMeta = stripVerboseFields(metaData);
             await writeFileInDir(logger, nodesMetaJsonFile, JSON.stringify(minimalMeta, null, 2), { ignoreModifyComment: true });
             if (hasVerboseFields(metaData)) {

package/dist/src/functions/wirings/console/serialize-console-functions.d.ts

@@ -1 +1 @@
-export declare const serializeConsoleFunctions: (pathToPikkuTypes: string) => string;
+export declare const serializeConsoleFunctions: (pathToPikkuTypes: string, _pathToAgentTypes: string) => string;

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

@@ -1,66 +1,12 @@
-export const serializeConsoleFunctions = (pathToPikkuTypes) => {
-    return `import { pikkuSessionlessFunc, defineHTTPRoutes, wireHTTPRoutes, external } from '${pathToPikkuTypes}'
-import { streamAIAgent, resumeAIAgent } from '@pikku/core/ai-agent'
-import type { AIStreamChannel } from '@pikku/core/ai-agent'
+export const serializeConsoleFunctions = (pathToPikkuTypes, _pathToAgentTypes) => {
+    return `import { pikkuSessionlessFunc, defineHTTPRoutes, wireHTTPRoutes, addon, wireAddon } from '${pathToPikkuTypes}'
 
-export const streamAgentRun = pikkuSessionlessFunc<
-  { agentName: string; message: string; threadId: string; resourceId?: string },
-  any
->({
-  title: 'Stream Agent Run',
-  description: 'SSE stream of agent conversation responses.',
-  expose: false,
-  auth: false,
-  func: async (services, data, { channel }) => {
-    if (!channel) return
-    await streamAIAgent(
-      data.agentName,
-      {
-        message: data.message,
-        threadId: data.threadId,
-        resourceId: data.resourceId || 'console-playground',
-      },
-      channel as unknown as AIStreamChannel,
-      { singletonServices: services }
-    )
-  },
-})
-
-export const resumeAgentRun = pikkuSessionlessFunc<
-  {
-    agentName: string
-    toolCallId: string
-    approved: boolean
-  },
-  any
->({
-  title: 'Resume Agent Run',
-  description: 'Resume an agent run after tool approval/denial.',
-  expose: false,
-  auth: false,
-  func: async (services, data, { channel }) => {
-    if (!channel) return
-    await resumeAIAgent(
-      {
-        toolCallId: data.toolCallId,
-        approved: data.approved,
-      },
-      channel as unknown as AIStreamChannel,
-      { singletonServices: services }
-    )
-  },
-})
-
-export interface SetSecretInput {
+export const pikkuConsoleSetSecret = pikkuSessionlessFunc<{
   secretId: string
   value: unknown
-}
-
-export interface SetSecretOutput {
+}, {
   success: boolean
-}
-
-export const setSecret = pikkuSessionlessFunc<SetSecretInput, SetSecretOutput>({
+}>({
   description: 'Set the value of a secret',
   expose: true,
   auth: false,
@@ -70,18 +16,9 @@ export const setSecret = pikkuSessionlessFunc<SetSecretInput, SetSecretOutput>({
   },
 })
 
-export interface GetVariableInput {
-  variableId: string
-}
-
-export interface GetVariableOutput {
-  exists: boolean
-  value: unknown | null
-}
-
-export const getVariable = pikkuSessionlessFunc<
-  GetVariableInput,
-  GetVariableOutput
+export const pikkuConsoleGetVariable = pikkuSessionlessFunc<
+  { variableId: string },
+  { exists: boolean; value: unknown | null }
 >({
   description: 'Get the current value of a variable',
   expose: true,
@@ -101,18 +38,9 @@ export const getVariable = pikkuSessionlessFunc<
   },
 })
 
-export interface SetVariableInput {
-  variableId: string
-  value: unknown
-}
-
-export interface SetVariableOutput {
-  success: boolean
-}
-
-export const setVariable = pikkuSessionlessFunc<
-  SetVariableInput,
-  SetVariableOutput
+export const pikkuConsoleSetVariable = pikkuSessionlessFunc<
+  { variableId: string; value: unknown },
+  { success: boolean }
 >({
   description: 'Set the value of a variable',
   expose: true,
@@ -127,18 +55,9 @@ export const setVariable = pikkuSessionlessFunc<
   },
 })
 
-export interface GetSecretInput {
-  secretId: string
-}
-
-export interface GetSecretOutput {
-  exists: boolean
-  value: unknown | null
-}
-
-export const getSecret = pikkuSessionlessFunc<
-  GetSecretInput,
-  GetSecretOutput
+export const pikkuConsoleGetSecret = pikkuSessionlessFunc<
+  { secretId: string },
+  { exists: boolean; value: unknown | null }
 >({
   description: 'Get the current value of a secret',
   expose: true,
@@ -153,77 +72,19 @@ export const getSecret = pikkuSessionlessFunc<
   },
 })
 
-export interface StartWorkflowRunInput {
-  workflowName: string
-  input?: any
-}
-
-export interface StartWorkflowRunOutput {
-  runId: string
-}
-
-export const startWorkflowRun = pikkuSessionlessFunc<
-  StartWorkflowRunInput,
-  StartWorkflowRunOutput
->({
-  title: 'Start Workflow Run',
-  description: 'Starts a new workflow run by name with optional input.',
-  expose: true,
-  auth: false,
-  func: async (_services, { workflowName, input }, { rpc }) => {
-    return await (rpc as any).startWorkflow(workflowName, input || {})
-  },
-})
-
 export const consoleRoutes = defineHTTPRoutes({
   auth: false,
   routes: {
-    externalIconOptions: {
-      route: '/external/icon/:alias',
-      method: 'options',
-      func: pikkuSessionlessFunc<{ alias: string }>(async () => void 0),
-    },
-    externalIcon: {
-      route: '/external/icon/:alias',
-      method: 'get',
-      func: external('console:getExternalIcon'),
-    },
-    agentStreamOptions: {
-      route: '/api/agents/:agentName/stream',
-      method: 'options',
-      func: pikkuSessionlessFunc<{ agentName: string }>(async () => void 0),
-    },
-    agentStream: {
-      route: '/api/agents/:agentName/stream',
-      method: 'post',
-      sse: true,
-      func: streamAgentRun,
-    },
-    agentResumeOptions: {
-      route: '/api/agents/:agentName/resume',
-      method: 'options',
-      func: pikkuSessionlessFunc<{ agentName: string }>(async () => void 0),
-    },
-    agentResume: {
-      route: '/api/agents/:agentName/resume',
-      method: 'post',
-      sse: true,
-      func: resumeAgentRun,
-    },
-    workflowRunStreamOptions: {
-      route: '/api/workflow-run/:runId/stream',
-      method: 'options',
-      func: pikkuSessionlessFunc<{ runId: string }>(async () => void 0),
-    },
     workflowRunStream: {
-      route: '/api/workflow-run/:runId/stream',
+      route: '/workflow-run/:runId/stream',
       method: 'get',
       sse: true,
-      func: external('console:streamWorkflowRun'),
+      func: addon('console:streamWorkflowRun'),
     },
   },
 })
 
-wireHTTPRoutes({ routes: { console: consoleRoutes } })
+wireAddon({ name: 'console', package: '@pikku/addon-console' })
+wireHTTPRoutes({ baseRoute: '/api', routes: { console: consoleRoutes } })
 `;
 };

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

@@ -0,0 +1 @@
+export declare const pikkuAddonTypes: 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/functions/pikku-command-addon-types.js

@@ -0,0 +1,33 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
+import { checkRequiredTypes } from '../../../utils/check-required-types.js';
+import { writeFileInDir } from '../../../utils/file-writer.js';
+import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
+import { serializeAddonTypes } from './serialize-addon-types.js';
+export const pikkuAddonTypes = pikkuSessionlessFunc({
+    func: async ({ logger, config, getInspectorState }) => {
+        if (!config.addon) {
+            return;
+        }
+        const visitState = await getInspectorState();
+        const { addonTypesFile, packageMappings, servicesFile, secretsFile, variablesFile, } = config;
+        checkRequiredTypes(visitState.filesAndMethodsErrors, {
+            singletonServicesType: true,
+        });
+        const { singletonServicesType, pikkuConfigType } = visitState.filesAndMethods;
+        if (!singletonServicesType) {
+            throw new Error('Required types not found');
+        }
+        const configTypeImport = pikkuConfigType
+            ? `import type { ${pikkuConfigType.type} } from '${getFileImportRelativePath(addonTypesFile, pikkuConfigType.typePath, packageMappings)}'`
+            : '// Config type not found, will use fallback';
+        const content = serializeAddonTypes(`import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(addonTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, configTypeImport, `import type { RequiredSingletonServices } from '${getFileImportRelativePath(addonTypesFile, servicesFile, packageMappings)}'`, `import { TypedSecretService } from '${getFileImportRelativePath(addonTypesFile, secretsFile, packageMappings)}'`, `import { TypedVariablesService } from '${getFileImportRelativePath(addonTypesFile, variablesFile, packageMappings)}'`);
+        await writeFileInDir(logger, addonTypesFile, content);
+    },
+    middleware: [
+        logCommandInfoAndTime({
+            commandStart: 'Creating addon types',
+            commandEnd: 'Created addon types',
+        }),
+    ],
+});

package/dist/src/functions/wirings/functions/pikku-command-function-types-split.js

@@ -21,7 +21,7 @@ export const pikkuFunctionTypesSplit = pikkuSessionlessFunc({
         const configTypeImport = pikkuConfigType
             ? `import type { ${pikkuConfigType.type} } from '${getFileImportRelativePath(functionTypesFile, pikkuConfigType.typePath, packageMappings)}'`
             : '// Config type not found, will use fallback';
-        const content = serializeFunctionTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, wireServicesType.typePath, packageMappings)}'`, wireServicesType.type, `import type { TypedPikkuRPC, FlattenedRPCMap } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`, `import type { RequiredSingletonServices, RequiredWireServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`, configTypeImport, config.externalPackageName, undefined, config.node?.categories);
+        const content = serializeFunctionTypes(`import type { ${userSessionType.type} } from '${getFileImportRelativePath(functionTypesFile, userSessionType.typePath, packageMappings)}'`, userSessionType.type, `import type { ${singletonServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, singletonServicesType.typePath, packageMappings)}'`, singletonServicesType.type, `import type { ${wireServicesType.type} } from '${getFileImportRelativePath(functionTypesFile, wireServicesType.typePath, packageMappings)}'`, wireServicesType.type, `import type { TypedPikkuRPC, FlattenedRPCMap } from '${getFileImportRelativePath(functionTypesFile, rpcInternalMapDeclarationFile, packageMappings)}'`, `import type { RequiredSingletonServices, RequiredWireServices } from '${getFileImportRelativePath(functionTypesFile, servicesFile, packageMappings)}'`, configTypeImport, config.addonName, undefined, config.node?.categories);
         await writeFileInDir(logger, functionTypesFile, content);
     },
     middleware: [

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

@@ -5,13 +5,13 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializePikkuTypesHub } from './serialize-pikku-types-hub.js';
 export const pikkuFunctionTypes = pikkuSessionlessFunc({
     func: async ({ logger, config }) => {
-        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, triggersTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, nodeTypesFile, secretTypesFile, externalTypesFile, } = config;
-        const getImportPath = (file) => config.externalPackage
+        const { typesDeclarationFile: typesFile, packageMappings, functionTypesFile, httpTypesFile, channelsTypesFile, triggersTypesFile, schedulersTypesFile, queueTypesFile, mcpTypesFile, cliTypesFile, nodeTypesFile, secretTypesFile, addonTypesFile, } = config;
+        const getImportPath = (file) => config.addon
             ? null
             : getFileImportRelativePath(typesFile, file, packageMappings);
-        // Node and trigger types are included for external packages
+        // Node and trigger types are included for addon packages
         const getAlwaysImportPath = (file) => getFileImportRelativePath(typesFile, file, packageMappings);
-        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getImportPath(httpTypesFile), getImportPath(channelsTypesFile), getAlwaysImportPath(triggersTypesFile), getImportPath(schedulersTypesFile), getImportPath(queueTypesFile), getImportPath(mcpTypesFile), getImportPath(cliTypesFile), getAlwaysImportPath(nodeTypesFile), getAlwaysImportPath(secretTypesFile), config.externalPackage ? getAlwaysImportPath(externalTypesFile) : null);
+        const content = serializePikkuTypesHub(getFileImportRelativePath(typesFile, functionTypesFile, packageMappings), getImportPath(httpTypesFile), getImportPath(channelsTypesFile), getAlwaysImportPath(triggersTypesFile), getImportPath(schedulersTypesFile), getImportPath(queueTypesFile), getImportPath(mcpTypesFile), getImportPath(cliTypesFile), getAlwaysImportPath(nodeTypesFile), getAlwaysImportPath(secretTypesFile), config.addon ? getAlwaysImportPath(addonTypesFile) : null);
         await writeFileInDir(logger, typesFile, content);
     },
     middleware: [

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

@@ -21,24 +21,18 @@ export const pikkuFunctions = pikkuSessionlessFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        const packageName = config.externalPackageName
-            ? `'${config.externalPackageName}'`
-            : 'null';
-        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState, FunctionsMeta } from '@pikku/core'\n${importStatement}\npikkuState(${packageName}, 'function', 'meta', metaData as FunctionsMeta)`);
-        // For external packages, register ALL functions (they'll be invoked by consumers)
+        const packageName = config.addonName ? `'${config.addonName}'` : 'null';
+        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState } from '@pikku/core/internal'\nimport type { FunctionsMeta } from '@pikku/core'\n${importStatement}\npikkuState(${packageName}, 'function', 'meta', metaData as FunctionsMeta)`);
+        // For addon packages, register ALL functions (they'll be invoked by consumers)
         // For main packages, only register functions that are invoked via internal RPCs
-        const isExternalPackage = !!config.externalPackageName;
+        const isAddon = !!config.addonName;
         const hasRPCs = rpc.exposedFiles.size > 0 || rpc.internalFiles.size > 0;
         const hasFunctions = functions.files.size > 0;
-        const shouldGenerateFunctionsFile = isExternalPackage
-            ? hasFunctions
-            : hasRPCs;
+        const shouldGenerateFunctionsFile = isAddon ? hasFunctions : hasRPCs;
         if (shouldGenerateFunctionsFile) {
-            // For external packages, use all function files; for main packages, use internal RPC files
-            const filesToRegister = isExternalPackage
-                ? functions.files
-                : rpc.internalFiles;
-            await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, filesToRegister, functions.meta, packageMappings, config.externalPackageName));
+            // For addon packages, use all function files; for main packages, use internal RPC files
+            const filesToRegister = isAddon ? functions.files : rpc.internalFiles;
+            await writeFileInDir(logger, functionsFile, serializeFunctionImports(functionsFile, filesToRegister, functions.meta, packageMappings, config.addonName));
         }
         return shouldGenerateFunctionsFile;
     },

package/dist/src/functions/wirings/functions/schemas.js

@@ -7,7 +7,7 @@ export const pikkuSchemas = pikkuSessionlessFunc({
         if (Object.keys(visitState.schemas).length === 0) {
             return undefined;
         }
-        await saveSchemas(logger, config.schemaDirectory, visitState.schemas, visitState.requiredSchemas, config.schema?.supportsImportAttributes ?? true, config.externalPackageName || null);
+        await saveSchemas(logger, config.schemaDirectory, visitState.schemas, visitState.requiredSchemas, config.schema?.supportsImportAttributes ?? true, config.addonName || null);
         return true;
     },
     middleware: [

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

@@ -0,0 +1 @@
+export declare const serializeAddonTypes: (singletonServicesTypeImport: string, singletonServicesTypeName: string, configTypeImport: string, requiredServicesTypeImport: string, typedSecretServiceImport: string, typedVariablesServiceImport: string) => string;