@pikku/cli 0.12.104 → 0.12.105

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

@@ -5,7 +5,7 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
 import { serializeAgentMap } from './serialize-agent-map.js';
 import { serializeModelAliases } from './serialize-model-aliases.js';
-export const pikkuAIAgent = pikkuSessionlessFunc({
+export const pikkuAgent = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { agents, functions } = await getInspectorState();
         const { agentWiringsFile, agentWiringMetaFile, agentWiringMetaJsonFile, agentMapDeclarationFile, modelAliasesFile, packageMappings, schema, addonName, models, } = config;
@@ -19,7 +19,7 @@ export const pikkuAIAgent = pikkuSessionlessFunc({
             return undefined;
         }
         const lines = [];
-        lines.push(`import { addAIAgent } from '@pikku/core/ai-agent'`);
+        lines.push(`import { addAgent } from '@pikku/core/ecosystem/agent'`);
         const metaImportPath = getFileImportRelativePath(agentWiringsFile, agentWiringMetaFile, packageMappings);
         if (Object.keys(agents.agentsMeta).length > 0) {
             lines.push(`import '${metaImportPath}'`);
@@ -32,7 +32,7 @@ export const pikkuAIAgent = pikkuSessionlessFunc({
         lines.push('');
         const packageArg = addonName ? `, '${addonName}'` : '';
         for (const [agentName, { exportedName }] of sortedAgents) {
-            lines.push(`addAIAgent('${agentName}', ${exportedName}${packageArg})`);
+            lines.push(`addAgent('${agentName}', ${exportedName}${packageArg})`);
         }
         await writeFileInDir(logger, agentWiringsFile, lines.join('\n'));
         const metaData = {
@@ -50,9 +50,9 @@ export const pikkuAIAgent = pikkuSessionlessFunc({
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
         await writeFileInDir(logger, agentWiringMetaFile, `import { pikkuState } from '@pikku/core/ecosystem'
-import type { AIAgentMeta } from '@pikku/core/ai-agent'
+import type { AgentsMeta } from '@pikku/core/ecosystem/agent'
 ${importStatement}
-pikkuState(${addonName ? `'${addonName}'` : 'null'}, 'agent', 'agentsMeta', metaData.agentsMeta as AIAgentMeta)`);
+pikkuState(${addonName ? `'${addonName}'` : 'null'}, 'agent', 'agentsMeta', metaData.agentsMeta as AgentsMeta)`);
         await writeFileInDir(logger, agentMapDeclarationFile, serializeAgentMap(logger, agentMapDeclarationFile, packageMappings, functions.typesMap, agents.agentsMeta));
         return true;
     },

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

@@ -1,4 +1,4 @@
-import type { AIAgentMeta } from '@pikku/core/ai-agent';
+import type { AgentsMeta } from '@pikku/core/ecosystem/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;
+export declare const serializeAgentMap: (logger: Logger, relativeToPath: string, packageMappings: Record<string, string>, typesMap: TypesMap, agentsMeta: AgentsMeta) => string;

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

@@ -0,0 +1 @@
+export declare const serializeAgentTypes: (functionTypesImportPath: string, agentMapImportPath: string, scopesImportPath: string, scorerNamesImportPath: string) => string;

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

@@ -1,66 +1,55 @@
-export const serializeAIAgentTypes = (functionTypesImportPath, agentMapImportPath, scopesImportPath, scorerNamesImportPath) => {
-    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 {
-  pikkuAIScorer as corePikkuAIScorer,
-  pikkuAIJudge as corePikkuAIJudge,
-} from '@pikku/core/ai-scorer'
+export const serializeAgentTypes = (functionTypesImportPath, agentMapImportPath, scopesImportPath, scorerNamesImportPath) => {
+    return `import { CoreAgent, PikkuAgentMiddlewareHooks } from '@pikku/core/ecosystem/agent'
+import { agent as coreAgent, agentStream as coreAgentStream, agentResume as coreAgentResume, agentApprove as coreAgentApprove } from '@pikku/core/ecosystem/agent'
+import { pikkuAgentScorer as corePikkuAgentScorer, pikkuAgentJudge as corePikkuAgentJudge } from '@pikku/core/ecosystem/agent-scorer'
 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 { AgentMemoryConfig, AgentInput } from '@pikku/core/ecosystem/agent'
 import type { AgentMap } from '${agentMapImportPath}'
 import type { ScopeId } from '${scopesImportPath}'
 import type { ScorerName } from '${scorerNamesImportPath}'
 
-type AIAgentConfig<
+type AgentConfig<
   InputSchema extends StandardSchemaV1 | undefined = undefined,
   OutputSchema extends StandardSchemaV1 | undefined = undefined
-> = Omit<CoreAIAgent<PikkuPermission, PikkuMiddleware, ScopeId, ScorerName>, 'tools' | 'agents' | 'workflows' | 'memory' | 'input' | 'output'> & {
+> = Omit<CoreAgent<PikkuPermission, PikkuMiddleware, ScopeId, ScorerName>, 'tools' | 'agents' | 'workflows' | 'memory' | 'input' | 'output'> & {
   input?: InputSchema
   output?: OutputSchema
-  memory?: Omit<AIAgentMemoryConfig, 'workingMemory'> & { workingMemory?: StandardSchemaV1 }
+  memory?: Omit<AgentMemoryConfig, 'workingMemory'> & { workingMemory?: StandardSchemaV1 }
   tools?: object[]
-  agents?: AIAgentConfig<StandardSchemaV1 | undefined, StandardSchemaV1 | undefined>[]
+  agents?: AgentConfig<StandardSchemaV1 | undefined, StandardSchemaV1 | undefined>[]
   workflows?: object[]
 }
 
-export const pikkuAIAgent = <
+export const pikkuAgent = <
   InputSchema extends StandardSchemaV1 | undefined = undefined,
   OutputSchema extends StandardSchemaV1 | undefined = undefined
 >(
-  agent: AIAgentConfig<InputSchema, OutputSchema>
+  agent: AgentConfig<InputSchema, OutputSchema>
 ) => {
   return agent
 }
 
-export const pikkuAIScorer = (
-  config: Parameters<typeof corePikkuAIScorer<Services>>[0]
-) => corePikkuAIScorer<Services>(config)
+export const pikkuAgentScorer = (
+  config: Parameters<typeof corePikkuAgentScorer<Services>>[0]
+) => corePikkuAgentScorer<Services>(config)
 
-export const pikkuAIJudge = (
-  config: Parameters<typeof corePikkuAIJudge<Services>>[0]
-) => corePikkuAIJudge<Services>(config)
+export const pikkuAgentJudge = (
+  config: Parameters<typeof corePikkuAgentJudge<Services>>[0]
+) => corePikkuAgentJudge<Services>(config)
 
-export const pikkuAIMiddleware = <
+export const pikkuAgentMiddleware = <
   State extends Record<string, unknown> = Record<string, unknown>,
   RequiredServices extends Services = Services,
 >(
-  hooks: PikkuAIMiddlewareHooks<State, RequiredServices>
-): PikkuAIMiddlewareHooks<State, RequiredServices> => hooks
+  hooks: PikkuAgentMiddlewareHooks<State, RequiredServices>
+): PikkuAgentMiddlewareHooks<State, RequiredServices> => hooks
 
 export const agent = <Name extends keyof AgentMap>(
   agentName: Name
 ) => {
   return coreAgent<AgentMap>(agentName as string & keyof AgentMap) as PikkuFunctionConfig<
-    AIAgentInput,
+    AgentInput,
     { runId: string; result: AgentMap[Name]['output']; usage: { inputTokens: number; outputTokens: number } },
     'session' | 'rpc'
   >

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

@@ -54,7 +54,7 @@ export const ThreadRef = z.object({
 
 export const ThreadDeleted = z.object({ deleted: z.boolean() })
 `;
-    const functions = `import { canAccessThread, threadOwnerConstraint } from '@pikku/core/ai-agent'
+    const functions = `import { canAccessThread, threadOwnerConstraint } from '@pikku/core/ecosystem/agent'
 import { pikkuSessionlessFunc, pikkuPermission, defineHTTPRoutes, wireHTTPRoutes } from '${pathToPikkuTypes}'
 import {
   AgentCall,

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

@@ -0,0 +1 @@
+export declare const pikkuAgentScorer: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, boolean | undefined, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/wirings/{ai-scorer/pikku-command-ai-scorer.js → agent-scorer/pikku-command-agent-scorer.js}

@@ -3,7 +3,7 @@ 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 { serializeScorerNames } from './serialize-scorer-names.js';
-export const pikkuAIScorer = pikkuSessionlessFunc({
+export const pikkuAgentScorer = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { scorers } = await getInspectorState();
         const { scorerWiringsFile, scorerWiringMetaFile, scorerWiringMetaJsonFile, scorerNamesDeclarationFile, packageMappings, schema, addonName, } = config;
@@ -16,8 +16,8 @@ export const pikkuAIScorer = pikkuSessionlessFunc({
             return undefined;
         }
         const lines = [];
-        lines.push(`import { addAIScorer } from '@pikku/core/ai-scorer'`);
-        // Ahead of the registrations: addAIScorer refuses a scorer whose metadata
+        lines.push(`import { addAgentScorer } from '@pikku/core/ecosystem/agent-scorer'`);
+        // Ahead of the registrations: addAgentScorer refuses a scorer whose metadata
         // has not landed yet.
         lines.push(`import '${getFileImportRelativePath(scorerWiringsFile, scorerWiringMetaFile, packageMappings)}'`);
         const sortedScorers = Array.from(scorerFiles.entries()).sort((a, b) => a[0].localeCompare(b[0]));
@@ -28,7 +28,7 @@ export const pikkuAIScorer = pikkuSessionlessFunc({
         lines.push('');
         const packageArg = addonName ? `, '${addonName}'` : '';
         for (const [scorerName, { exportedName }] of sortedScorers) {
-            lines.push(`addAIScorer('${scorerName}', ${exportedName}${packageArg})`);
+            lines.push(`addAgentScorer('${scorerName}', ${exportedName}${packageArg})`);
         }
         await writeFileInDir(logger, scorerWiringsFile, lines.join('\n'));
         await writeFileInDir(logger, scorerWiringMetaJsonFile, JSON.stringify({ scorersMeta: scorers.scorersMeta }, null, 2));
@@ -37,7 +37,7 @@ export const pikkuAIScorer = pikkuSessionlessFunc({
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
         await writeFileInDir(logger, scorerWiringMetaFile, `import { pikkuState } from '@pikku/core/ecosystem'
-import type { ScorerMeta } from '@pikku/core/ai-scorer'
+import type { ScorerMeta } from '@pikku/core/ecosystem/agent-scorer'
 ${importStatement}
 pikkuState(${addonName ? `'${addonName}'` : 'null'}, 'agent', 'scorersMeta', metaData.scorersMeta as ScorerMeta)`);
         return true;

package/dist/src/functions/wirings/{ai-scorer → agent-scorer}/serialize-scorer-names.d.ts

@@ -1,4 +1,4 @@
-import type { ScorerMeta } from '@pikku/core/ai-scorer';
+import type { ScorerMeta } from '@pikku/core/ecosystem/agent-scorer';
 /**
  * The names an agent may ask to be graded by.
  *

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

@@ -26,7 +26,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/ecosystem'\nimport { ChannelsMeta } from '@pikku/core/channel'\n${importStatement}\npikkuState(null, 'channel', 'meta', metaData as ChannelsMeta)`);
+            await writeFileInDir(logger, channelsWiringMetaFile, `import { pikkuState } from '@pikku/core/ecosystem'\nimport { ChannelsMeta } from '@pikku/core/ecosystem/channel'\n${importStatement}\npikkuState(null, 'channel', 'meta', metaData as ChannelsMeta)`);
         }
     },
     middleware: [

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

@@ -41,7 +41,7 @@ export const pikkuCommandChannels = pikkuSessionlessFunc({
         const importStatement = supportsImportAttributes
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
-        await writeFileInDir(logger, channelsWiringMetaFile, `import { pikkuState } from '@pikku/core/ecosystem'\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/ecosystem'\nimport type { ChannelsMeta } from '@pikku/core/ecosystem/channel'\n${importStatement}\npikkuState(null, 'channel', 'meta', metaData as ChannelsMeta)`);
         return true;
     },
     middleware: [

package/dist/src/functions/wirings/channels/serialize-channel-types.js

@@ -7,10 +7,11 @@ export const serializeChannelTypes = (functionTypesImportPath, packageName) => {
  * Channel-specific type definitions for tree-shaking optimization
  */
 
-import { CoreChannel, CorePikkuChannelMiddleware, CorePikkuChannelMiddlewareFactory, wireChannel as wireChannelCore, defineChannelRoutes as defineChannelRoutesCore, addChannelMiddleware as addChannelMiddlewareCore } from '@pikku/core/channel'
-import { AssertHTTPWiringParams } from '@pikku/core/http'
+import { wireChannel as wireChannelCore, defineChannelRoutes as defineChannelRoutesCore } from '@pikku/core/channel'
+import { CoreChannel, CorePikkuChannelMiddleware, CorePikkuChannelMiddlewareFactory, addChannelMiddleware as addChannelMiddlewareCore } from '@pikku/core/ecosystem/channel'
+import { AssertHTTPWiringParams } from '@pikku/core/ecosystem/http'
 import type { PikkuFunctionConfig, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware, Services } from '${functionTypesImportPath}'
-import type { CorePermissionGroup } from '@pikku/core'
+import type { CorePermissionGroup } from '@pikku/core/ecosystem/types'
 import type { StandardSchemaV1 } from '@standard-schema/spec'
 
 /**

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

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

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

@@ -41,7 +41,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/ecosystem'\nimport { CLIMeta } from '@pikku/core/cli'\n${importStatement}\npikkuState(null, 'cli', 'meta', metaData as CLIMeta)`);
+        await writeFileInDir(logger, cliWiringMetaFile, `import { pikkuState } from '@pikku/core/ecosystem'\nimport { CLIMeta } from '@pikku/core/ecosystem/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,4 +1,4 @@
-import type { CLIProgramMeta } from '@pikku/core/cli';
+import type { CLIProgramMeta } from '@pikku/core/ecosystem/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-client.js

@@ -111,9 +111,9 @@ export function serializeChannelCLIClient(programName, programMeta, clientFile,
         ? `,\n    defaultRenderer: ${defaultRendererBinding} as CorePikkuCLIClientRender<any>`
         : '';
     return `
-import { executeRawCLIViaChannel } from '@pikku/core/cli/channel'
-import type { CorePikkuCLIClientRender } from '@pikku/core/cli/channel'
-import type { Capabilities } from '@pikku/core/channel'
+import { executeRawCLIViaChannel } from '@pikku/core/ecosystem/cli/channel'
+import type { CorePikkuCLIClientRender } from '@pikku/core/ecosystem/cli/channel'
+import type { Capabilities } from '@pikku/core/ecosystem/channel'
 import { CorePikkuWebsocket } from '@pikku/websocket'
 ${rendererImports}
 /**

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

@@ -1,4 +1,4 @@
-import type { CLIProgramMeta } from '@pikku/core/cli';
+import type { CLIProgramMeta } from '@pikku/core/ecosystem/cli';
 type WireAddonDeclarations = Map<string, {
     package: string;
 }>;

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

@@ -59,8 +59,8 @@ export function serializeChannelCLI(programName, programMeta, channelFile, funct
  */
 import { wireChannel } from '${channelTypesPath}'
 import { pikkuMiddleware${hasAddonFuncs ? ', ref' : ''}, pikkuSessionlessFunc } from '${functionTypesPath}'
-import { generateCommandHelp } from '@pikku/core/cli'
-import { handleRawCLI, type RawCLIFrame } from '@pikku/core/cli/channel'
+import { generateCommandHelp } from '@pikku/core/ecosystem/cli'
+import { handleRawCLI, type RawCLIFrame } from '@pikku/core/ecosystem/cli/channel'
 import { pikkuState, getSingletonServices, getCreateWireServices } from '@pikku/core/ecosystem'
 ${imports}
 

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

@@ -7,7 +7,8 @@ export const serializeCLITypes = (functionTypesImportPath, userSessionTypeImport
  * CLI-specific type definitions for tree-shaking optimization
  */
 
-import { CoreCLI, wireCLI as wireCLICore, CorePikkuCLIRender, CoreCLICommandConfig, defineCLICommands as defineCLICommandsCore } from '@pikku/core/cli'
+import { wireCLI as wireCLICore, defineCLICommands as defineCLICommandsCore } from '@pikku/core/cli'
+import { CoreCLI, CorePikkuCLIRender, CoreCLICommandConfig } from '@pikku/core/ecosystem/cli'
 import type { PikkuFunctionConfig, PikkuMiddleware } from '${functionTypesImportPath}'
 ${userSessionTypeImport}
 ${singletonServicesTypeImport}

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

@@ -14,7 +14,7 @@ export function serializeLocalCLIBootstrap(programName, _programMeta, bootstrapF
         : null;
     const cliBootstrapPath = getFileImportRelativePath(bootstrapFile, config.bootstrapFile, config.packageMappings);
     return `
-import { executeCLI, CLIError } from '@pikku/core/cli'
+import { executeCLI, CLIError } from '@pikku/core/ecosystem/cli'
 ${pikkuConfigFactory ? `import { ${pikkuConfigFactory.variable} as createConfig } from '${pikkuConfigPath}'` : ''}
 import { ${singletonServicesFactory.variable} as createSingletonServices } from '${singletonServicesPath}'
 ${wireServicesFactory ? `import { ${wireServicesFactory.variable} as createWireServices } from '${wireServicesPath}'` : ''}

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

@@ -5,7 +5,7 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { readFile } from 'fs/promises';
 import { join, isAbsolute } from 'path';
 import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
-import { validateAndBuildSecretDefinitionsMeta } from '@pikku/core/secret';
+import { validateAndBuildSecretDefinitionsMeta } from '@pikku/core/ecosystem/secret';
 const loadIcon = async (iconPath, rootDir, logger) => {
     if (!iconPath)
         return undefined;

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

@@ -2,7 +2,7 @@ import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeCredentialsTypes } from './serialize-credentials-types.js';
-import { validateAndBuildCredentialDefinitionsMeta } from '@pikku/core/credential';
+import { validateAndBuildCredentialDefinitionsMeta } from '@pikku/core/ecosystem/credential';
 export const pikkuCredentials = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { credentialsFile, credentialsMetaJsonFile, packageMappings } = config;

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

@@ -1,4 +1,4 @@
-import type { CredentialDefinitions } from '@pikku/core/credential';
+import type { CredentialDefinitions } from '@pikku/core/ecosystem/credential';
 import type { SchemaRef } from '@pikku/inspector';
 export interface SerializeCredentialsOptions {
     definitions: CredentialDefinitions;

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

@@ -1,4 +1,4 @@
-import { validateAndBuildCredentialDefinitionsMeta } from '@pikku/core/credential';
+import { validateAndBuildCredentialDefinitionsMeta } from '@pikku/core/ecosystem/credential';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 /**
  * A display name is the human-facing label a developer wrote, so an apostrophe
@@ -42,10 +42,11 @@ export const serializeCredentialsTypes = ({ definitions, schemaLookup, credentia
         metaEntries.push(`  '${name}': { ${metaParts.join(', ')} }`);
     }
     const imports = [];
-    imports.push(`import { TypedCredentialService as CoreTypedCredentialService, type CredentialMetaInfo } from '@pikku/core/services'`);
+    imports.push(`import { TypedCredentialService as CoreTypedCredentialService } from '@pikku/core/services'
+import type { CredentialMetaInfo } from '@pikku/core/ecosystem/services'`);
     imports.push(`import type { CredentialService } from '@pikku/core/services'`);
     if (oauth2Entries.length > 0) {
-        imports.push(`import type { OAuth2CredentialConfig } from '@pikku/core/secret'`);
+        imports.push(`import type { OAuth2CredentialConfig } from '@pikku/core/ecosystem/secret'`);
     }
     if (needsZod) {
         imports.push(`import type { z } from 'zod'`);

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

@@ -27,7 +27,7 @@ export const pikkuFunctions = pikkuSessionlessFunc({
             ? `import metaData from '${jsonImportPath}' with { type: 'json' }`
             : `import metaData from '${jsonImportPath}'`;
         const packageName = config.addonName ? `'${config.addonName}'` : 'null';
-        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState } from '@pikku/core/ecosystem'\nimport type { FunctionsMeta } from '@pikku/core'\n${importStatement}\npikkuState(${packageName}, 'function', 'meta', metaData as FunctionsMeta)`);
+        await writeFileInDir(logger, functionsMetaFile, `import { pikkuState } from '@pikku/core/ecosystem'\nimport type { FunctionsMeta } from '@pikku/core/ecosystem/services'\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 isAddon = !!config.addonName;

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

@@ -3,7 +3,8 @@ export const serializeAddonTypes = (singletonServicesTypeImport, singletonServic
  * Addon package types for pikkuAddonConfig and pikkuAddonServices
  */
 
-import type { CreateConfig, PikkuWire } from '@pikku/core'
+import type { CreateConfig } from '@pikku/core'
+import type { PikkuWire } from '@pikku/core/ecosystem/types'
 ${singletonServicesTypeImport}
 ${configTypeImport}
 ${requiredServicesTypeImport}

package/dist/src/functions/wirings/functions/serialize-function-imports.d.ts

@@ -1,4 +1,4 @@
-import type { FunctionsMeta } from '@pikku/core';
+import type { FunctionsMeta } from '@pikku/core/ecosystem/services';
 export declare const serializeFunctionImports: (outputPath: string, functionsMap: Map<string, {
     path: string;
     exportedName: string;

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

@@ -15,19 +15,18 @@ export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeNam
  * Core function, middleware, and permission types for all wirings
  */
 
-import type { CorePikkuMiddleware, CorePermissionGroup, ListInput, ListOutput, PikkuWire, PickRequired, SecretlessServices } from '@pikku/core'
-import type { CorePikkuFunctionConfig, CorePikkuSessionlessFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission } from '@pikku/core/function'
-import { pikkuAuth as pikkuAuthCore } from '@pikku/core/function'
-import {
-  addTagMiddleware as addTagMiddlewareCore,
-  addGlobalMiddleware as addGlobalMiddlewareCore,
-  addGlobalPermission as addGlobalPermissionCore,
-} from '@pikku/core/middleware'
+import type { CorePikkuMiddleware, PickRequired } from '@pikku/core'
+import type { ListInput, ListOutput } from '@pikku/core/ecosystem/function'
+import type { CorePermissionGroup, PikkuWire, SecretlessServices } from '@pikku/core/ecosystem/types'
+import type { CorePikkuFunctionConfig, CorePikkuSessionlessFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission } from '@pikku/core/ecosystem/function'
+import { pikkuAuth as pikkuAuthCore } from '@pikku/core/ecosystem/function'
+import { addTagMiddleware as addTagMiddlewareCore, addGlobalMiddleware as addGlobalMiddlewareCore } from '@pikku/core/middleware'
+import { addGlobalPermission as addGlobalPermissionCore } from '@pikku/core/ecosystem/middleware'
 import { pikkuState as __pikkuState, CreateWireServices } from '@pikku/core/ecosystem'
-import type { NodeType } from '@pikku/core/node'
+import type { NodeType } from '@pikku/core/ecosystem/node'
 ${scopesImport}
 import type { StandardSchemaV1 } from '@standard-schema/spec'
-import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/function'
+import { CorePikkuFunction, CorePikkuFunctionSessionless } from '@pikku/core/ecosystem/function'
 
 ${userSessionTypeImport}
 ${singletonServicesTypeImport}
@@ -778,7 +777,7 @@ export const addGlobalPermission = <In = unknown>(permissions: CorePermissionGro
   addGlobalPermissionCore(permissions as any, ${packageNameValue})
 }
 
-export { wireAddon, wireRemoteAddon } from '@pikku/core/rpc'
-export type { WireAddonConfig, WireRemoteAddonConfig, RemoteAddonAuth } from '@pikku/core/rpc'
+export { wireAddon, wireRemoteAddon } from '@pikku/core/ecosystem/rpc'
+export type { WireAddonConfig, WireRemoteAddonConfig, RemoteAddonAuth } from '@pikku/core/ecosystem/rpc'
 `;
 };

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

@@ -1,3 +1,3 @@
-import type { GatewaysMeta } from '@pikku/core/gateway';
+import type { GatewaysMeta } from '@pikku/core/ecosystem/gateway';
 export declare const serializeGatewayMeta: (gatewayMeta: GatewaysMeta) => GatewaysMeta;
 export declare const serializeGatewayMetaTS: (jsonImportPath: string, supportsImportAttributes: boolean) => string;

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

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

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

@@ -18,7 +18,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/ecosystem'\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/ecosystem'\nimport type { HTTPWiringsMeta } from '@pikku/core/ecosystem/http'\n${importStatement}\npikkuState(null, 'http', 'meta', metaData as HTTPWiringsMeta)`);
         return true;
     },
     middleware: [

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

@@ -6,9 +6,10 @@ export const serializeHTTPTypes = (functionTypesImportPath) => {
  * HTTP-specific type definitions for tree-shaking optimization
  */
 
-import { AssertHTTPWiringParams, wireHTTP as wireHTTPCore, addHTTPMiddleware as addHTTPMiddlewareCore, wireHTTPRoutes as wireHTTPRoutesCore, defineHTTPRoutes as defineHTTPRoutesCore } from '@pikku/core/http'
+import { wireHTTP as wireHTTPCore, addHTTPMiddleware as addHTTPMiddlewareCore, wireHTTPRoutes as wireHTTPRoutesCore, defineHTTPRoutes as defineHTTPRoutesCore } from '@pikku/core/http'
+import { AssertHTTPWiringParams } from '@pikku/core/ecosystem/http'
 import type { PikkuFunction, PikkuFunctionSessionless, PikkuPermission, PikkuMiddleware, PikkuFunctionConfig } from '${functionTypesImportPath}'
-import type { CoreHTTPFunctionWiring, HTTPMethod, HTTPRouteBaseConfig } from '@pikku/core/http'
+import type { CoreHTTPFunctionWiring, HTTPMethod, HTTPRouteBaseConfig } from '@pikku/core/ecosystem/http'
 
 /**
  * Type definition for HTTP API wirings with type-safe path parameters.

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

@@ -1,4 +1,4 @@
-import type { HTTPWiringsMeta } from '@pikku/core/http';
+import type { HTTPWiringsMeta } from '@pikku/core/ecosystem/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, {

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

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

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

@@ -6,19 +6,11 @@ export const serializeMCPTypes = (functionTypesImportPath) => {
  * MCP-specific type definitions for tree-shaking optimization
  */
 
-import {
-  CoreMCPResource,
-  CoreMCPPrompt,
-  wireMCPResource as wireMCPResourceCore,
-  wireMCPPrompt as wireMCPPromptCore,
-  MCPResourceResponse,
-  MCPToolResponse,
-  MCPPromptResponse,
-  AssertMCPResourceURIParams
-} from '@pikku/core/mcp'
+import { wireMCPResource as wireMCPResourceCore, wireMCPPrompt as wireMCPPromptCore, MCPResourceResponse, MCPPromptResponse } from '@pikku/core/mcp'
+import { CoreMCPResource, CoreMCPPrompt, MCPToolResponse, AssertMCPResourceURIParams } from '@pikku/core/ecosystem/mcp'
 
 import type { PikkuFunctionConfig, PikkuFunctionSessionless, PikkuMiddleware, PikkuPermission, InferSchemaOutput } from '${functionTypesImportPath}'
-import type { CorePermissionGroup } from '@pikku/core'
+import type { CorePermissionGroup } from '@pikku/core/ecosystem/types'
 import type { StandardSchemaV1 } from '@standard-schema/spec'
 
 /**

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

@@ -1,17 +1,18 @@
 export const serializeSecretDefinitionTypes = () => {
     return `export { defineSecret } from '@pikku/core/secret'
-export type { CoreSecret, SecretDefinitionMeta, SecretDefinitionsMeta } from '@pikku/core/secret'
+export type { SecretDefinitionsMeta } from '@pikku/core/secret'
+export type { CoreSecret, SecretDefinitionMeta } from '@pikku/core/ecosystem/secret'
 `;
 };
 export const serializeScopeDefinitionTypes = () => {
-    return `export { defineScope } from '@pikku/core/scope'
-export type { CoreScopes, CoreScopeNode, FlatScope, ScopeDefinitionMeta, ScopeDefinitionsMeta } from '@pikku/core/scope'
-export { defineSystemRole } from '@pikku/core/role'
-export type { CoreSystemRole, CoreSystemRoles, SystemRole, SystemRoleDefinitionMeta, SystemRoleDefinitionsMeta } from '@pikku/core/role'
+    return `export { defineScope } from '@pikku/core/ecosystem/scope'
+export type { CoreScopes, CoreScopeNode, FlatScope, ScopeDefinitionMeta, ScopeDefinitionsMeta } from '@pikku/core/ecosystem/scope'
+export { defineSystemRole } from '@pikku/core/ecosystem/role'
+export type { CoreSystemRole, CoreSystemRoles, SystemRole, SystemRoleDefinitionMeta, SystemRoleDefinitionsMeta } from '@pikku/core/ecosystem/role'
 `;
 };
 export const serializeVariableDefinitionTypes = () => {
     return `export { defineVariable } from '@pikku/core/variable'
-export type { CoreVariable, VariableDefinitionMeta, VariableDefinitionsMeta } from '@pikku/core/variable'
+export type { CoreVariable, VariableDefinitionMeta, VariableDefinitionsMeta } from '@pikku/core/ecosystem/variable'
 `;
 };

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

@@ -7,7 +7,7 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializePersonasTypes } from './serialize-personas-types.js';
 import { serializePersonasSecrets } from './serialize-personas-secrets.js';
 import { personasSecretsFilePath } from './personas-secrets-file.js';
-import { personaEnvironmentErrors, validateAndBuildPersonasMeta, } from '@pikku/core/persona';
+import { personaEnvironmentErrors, validateAndBuildPersonasMeta, } from '@pikku/core/ecosystem/persona';
 export const pikkuPersonas = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }, data) => {
         const { personasFile, personasMetaJsonFile, rolesFile, packageMappings } = config;

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

@@ -1,4 +1,4 @@
-import type { PersonaDefinitions } from '@pikku/core/persona';
+import type { PersonaDefinitions } from '@pikku/core/ecosystem/persona';
 export interface SerializePersonasOptions {
     definitions: PersonaDefinitions;
     /** Relative import path to the generated roles file. */

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

@@ -11,7 +11,10 @@ const quote = (value) => `'${value.replace(/'/g, "\\'")}'`;
 export const serializePersonasTypes = ({ definitions, rolesImportPath, environmentNames, }) => {
     const ids = [...new Set(definitions.map((d) => d.id))].sort();
     const environmentUnion = environmentNames.length > 0
-        ? `\n${[...environmentNames].sort().map((name) => `  | ${quote(name)}`).join('\n')}`
+        ? `\n${[...environmentNames]
+            .sort()
+            .map((name) => `  | ${quote(name)}`)
+            .join('\n')}`
         : ' never';
     const union = ids.length > 0
         ? `\n${ids.map((id) => `  | ${quote(id)}`).join('\n')}`
@@ -27,7 +30,8 @@ export const serializePersonasTypes = ({ definitions, rolesImportPath, environme
  * This file was generated by the @pikku/cli
  */
 import { definePersonas as definePersonasCore } from '@pikku/core/persona'
-import type { CorePersona, PersonaMeta, PersonasMeta } from '@pikku/core/persona'
+import type { PersonaMeta, PersonasMeta } from '@pikku/core/persona'
+import type { CorePersona } from '@pikku/core/ecosystem/persona'
 import type { SystemRoleName } from '${rolesImportPath}'
 import definitions from './pikku-personas-meta.gen.json' with { type: 'json' }
 

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

@@ -1,4 +1,4 @@
-import type { QueueWorkersMeta } from '@pikku/core/queue';
+import type { QueueWorkersMeta } from '@pikku/core/ecosystem/queue';
 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, {