@pikku/core 0.12.78 → 0.12.80

package/src/wirings/ai-agent/ai-agent-turn.ts

@@ -0,0 +1,121 @@
+import type { CoreSingletonServices } from '../../types/core.types.js'
+import type { PikkuAIMiddlewareHooks } from './ai-agent.types.js'
+
+/** Exactly what `modifyInput` accepts and returns, taken from the hook itself. */
+type TurnInput = Pick<
+  Parameters<NonNullable<PikkuAIMiddlewareHooks['modifyInput']>>[1],
+  'messages' | 'instructions'
+>
+
+/**
+ * Run every `modifyInput` hook in order, threading each result into the next.
+ *
+ * Shared by the four places a turn starts — first turn and resume, on both the
+ * streaming and non-streaming paths. `sharedNotes` is one bag per run that the
+ * caller keeps, because hooks use it to pass things forward (`voiceInput`
+ * leaves the transcript there for `voiceOutput`).
+ */
+export const applyInputMiddleware = async (
+  aiMiddlewares: PikkuAIMiddlewareHooks[],
+  singletonServices: CoreSingletonServices,
+  input: TurnInput,
+  sharedNotes: Record<string, unknown>
+): Promise<TurnInput> => {
+  let { messages, instructions } = input
+  for (const mw of aiMiddlewares) {
+    if (!mw.modifyInput) continue
+    const result = await mw.modifyInput(singletonServices, {
+      messages,
+      instructions,
+      shared: sharedNotes,
+    })
+    messages = result.messages
+    instructions = result.instructions
+  }
+  return { messages, instructions }
+}
+
+/** The step fields both agent paths hand to `afterStep`, taken from the hook. */
+type StepResult = Omit<
+  Parameters<NonNullable<PikkuAIMiddlewareHooks['afterStep']>>[1],
+  'stepNumber'
+>
+
+/**
+ * Notify every `afterStep` hook. The payload is the step verbatim plus its
+ * ordinal — a hook that wants the run's totals accumulates them itself.
+ */
+export const notifyAfterStep = async (
+  aiMiddlewares: PikkuAIMiddlewareHooks[],
+  singletonServices: CoreSingletonServices,
+  stepNumber: number,
+  stepResult: StepResult
+): Promise<void> => {
+  for (const mw of aiMiddlewares) {
+    if (!mw.afterStep) continue
+    await mw.afterStep(singletonServices, {
+      stepNumber,
+      text: stepResult.text,
+      toolCalls: stepResult.toolCalls,
+      toolResults: stepResult.toolResults,
+      usage: stepResult.usage,
+      finishReason: stepResult.finishReason,
+    })
+  }
+}
+
+/**
+ * The step shape kept on the run: each tool call paired with its result.
+ *
+ * A result is stringified unless it already is a string, because this is what
+ * gets persisted and read back as history — an object there is unreadable.
+ */
+export const toAccumulatedStep = (stepResult: StepResult) => ({
+  usage: stepResult.usage,
+  toolCalls: stepResult.toolCalls.map((tc) => {
+    const tr = stepResult.toolResults.find(
+      (r) => r.toolCallId === tc.toolCallId
+    )
+    return {
+      name: tc.toolName,
+      args: tc.args as Record<string, unknown>,
+      result:
+        typeof tr?.result === 'string'
+          ? tr.result
+          : JSON.stringify(tr?.result ?? ''),
+    }
+  }),
+})
+
+type PendingApproval = {
+  toolName: string
+  args: unknown
+  reason?: string
+}
+
+type ToolDef = {
+  name: string
+  approvalDescriptionFn?: (args: any) => Promise<string> | string
+}
+
+/**
+ * Fill in each approval's human-readable reason from the tool's own
+ * `approvalDescriptionFn`, where it did not supply one.
+ *
+ * A description that throws is swallowed: the approval still has to be raised,
+ * and a gate that disappears because its label failed to render is the worst
+ * available outcome.
+ */
+export const describeApprovals = async (
+  approvals: PendingApproval[],
+  tools: ToolDef[]
+): Promise<void> => {
+  for (const approval of approvals) {
+    if (approval.reason) continue
+    const toolDef = tools.find((t) => t.name === approval.toolName)
+    if (!toolDef?.approvalDescriptionFn) continue
+    try {
+      approval.reason = await toolDef.approvalDescriptionFn(approval.args)
+    } catch {}
+  }
+}

package/src/wirings/ai-agent/ai-agent.types.ts

@@ -413,7 +413,7 @@ export type AIStreamEvent =
       toolName: string
       args: unknown
       reason?: string
-      runId?: string
+      runId: string
       agent?: string
       session?: string
     }

package/src/wirings/ai-agent/voice-input.ts

@@ -164,12 +164,7 @@ export const voiceInput = (config?: {
       // to send, and a message with no content is not a question.
       if (updatedContent.length === 0) throw new NoSpeechDetectedError()
 
-      // Only when something was actually heard. A turn can carry audio that all
-      // reads as non-speech and still have content — an image with a silent
-      // caption clip — which leaves nothing above to throw. Recording `''` here
-      // would send a transcript event saying the user said nothing, and a client
-      // that tells "not transcribed yet" from "transcribed" by the key being
-      // absent would render the turn as an empty bubble rather than a pending one.
+      // knowledge: decisions/internals/an-empty-transcript-is-not-recorded.md
       if (heard.length > 0) {
         shared[SPOKEN_TRANSCRIPT] = heard.join(' ')
       }

package/src/wirings/ai-agent/voice-output.ts

@@ -206,11 +206,7 @@ export const voiceOutput = (config?: {
       }
       if (!aiAgentRunner?.generateSpeech) return event
 
-      // Only an explicit `false` silences the reply. `voiceInput` sets this on
-      // every turn it handles, so `false` means a real user really typed; the
-      // key being absent means nothing reported either way — no voice input is
-      // wired — and that caller's replies are spoken exactly as they were before
-      // this option existed.
+      // knowledge: decisions/internals/voice-output-speaks-unless-voice-input-explicitly-says-otherwise.md
       if (!config?.always && shared[SPOKEN_TURN] === false) return event
 
       /**
@@ -228,13 +224,7 @@ export const voiceOutput = (config?: {
           )
         }
 
-        // Checked per sentence but announced once per reply: a bilingual answer
-        // should still speak the half it can, and repeating the notice for
-        // every sentence of a long one would bury the reply itself.
-        //
-        // Per sentence is also what makes the voice right. A reply that answers
-        // in English and then quotes a Chinese title is two sentences in two
-        // scripts, and each is synthesized in the voice its own script needs.
+        // knowledge: decisions/internals/speech-synthesis-picks-a-voice-per-sentence-and-warns-once.md
         let voice = config.voice
         if (config.speakableScripts) {
           const unspeakable = unspeakableScripts(text, config.speakableScripts)

package/src/wirings/channel/channel-common.ts

@@ -1,3 +1,4 @@
+import type { CorePikkuChannelMiddleware } from './channel.types.js'
 import type {
   CoreSingletonServices,
   CorePikkuMiddleware,
@@ -61,7 +62,9 @@ export const runChannelLifecycleWithMiddleware = async ({
     `${channelConfig.name}:${lifecycleType}:cm`,
     {
       wireInheritedChannelMiddleware: channelMiddlewareMeta,
-      wireChannelMiddleware: channelConfig.channelMiddleware as any,
+      // knowledge: questions/channel-middleware-accepts-bare-factories-that-nothing-resolves.md
+      wireChannelMiddleware:
+        channelConfig.channelMiddleware as CorePikkuChannelMiddleware[],
     }
   )
 
@@ -76,7 +79,7 @@ export const runChannelLifecycleWithMiddleware = async ({
   const runLifecycle = async () => {
     return await runPikkuFunc('channel', channelConfig.name, meta.pikkuFuncId, {
       singletonServices: services,
-      data: () => data as any,
+      data: () => data,
       wire,
       sessionService: userSession,
       tags: meta.tags ?? [],

package/src/wirings/channel/channel-handler-shapes.test.ts

@@ -0,0 +1,72 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { pikkuState, resetPikkuState } from '../../pikku-state.js'
+import { wireChannel } from './channel-runner.js'
+
+const registeredFunc = (funcId: string) =>
+  pikkuState(null, 'function', 'functions').get(funcId)
+
+const wire = (channel: any) => {
+  resetPikkuState()
+  pikkuState(null, 'channel', 'meta', {
+    shapes: {
+      name: 'shapes',
+      route: '/shapes',
+      input: null,
+      connect: { pikkuFuncId: 'shapes__connect' },
+      disconnect: { pikkuFuncId: 'shapes__disconnect' },
+      message: { pikkuFuncId: 'shapes__message' },
+      messageWirings: {},
+    },
+  } as any)
+  wireChannel({ name: 'shapes', route: '/shapes', ...channel })
+}
+
+/**
+ * knowledge: decisions/internals/channel-message-handlers-accept-three-config-shapes.md
+ */
+describe('every channel handler shape registers a callable function config', () => {
+  const handler = async () => undefined
+
+  test('a direct function config registers as-is', () => {
+    wire({ onConnect: { func: handler } })
+
+    assert.equal(typeof registeredFunc('shapes__connect')?.func, 'function')
+  })
+
+  test('a wrapper around a function config registers the inner config', () => {
+    wire({ onConnect: { func: { func: handler }, middleware: [] } })
+
+    // Registering the wrapper itself leaves `.func` an object, and the function
+    // runner calls `.func(...)` — that is a TypeError at connect time.
+    assert.equal(
+      typeof registeredFunc('shapes__connect')?.func,
+      'function',
+      'the wrapper was registered instead of the config it wraps'
+    )
+  })
+
+  test('onDisconnect unwraps the same way', () => {
+    wire({ onDisconnect: { func: { func: handler }, middleware: [] } })
+
+    assert.equal(typeof registeredFunc('shapes__disconnect')?.func, 'function')
+  })
+
+  test('onMessage unwraps the same way', () => {
+    wire({ onMessage: { func: { func: handler } } })
+
+    assert.equal(typeof registeredFunc('shapes__message')?.func, 'function')
+  })
+
+  test('a simple wrapper — a function plus sibling middleware — stays whole', () => {
+    wire({ onConnect: { func: handler, middleware: [] } })
+
+    const registered = registeredFunc('shapes__connect')
+    assert.equal(typeof registered?.func, 'function')
+    assert.ok(
+      'middleware' in (registered as object),
+      'the sibling middleware must survive registration'
+    )
+  })
+})

package/src/wirings/channel/channel-handler.ts

@@ -4,6 +4,7 @@ import type {
   CoreUserSession,
 } from '../../types/core.types.js'
 import type {
+  CorePikkuChannelMiddleware,
   BinaryData,
   ChannelMessageMeta,
   CoreChannel,
@@ -94,7 +95,7 @@ export const processMessageHandlers = (
       logger.error(
         `Channel ${channelConfig.name} with id ${channelHandler.getChannel().channelId} requires a session for ${routeMessage}. No session is attached to this websocket connection. Ensure auth middleware establishes a session during websocket upgrade, and configure sessionStore when the runtime needs persisted sessions.`
       )
-      // TODO: Send error message back breaks typescript, but should be implemented somehow
+      // knowledge: questions/unauthorized-channel-replies-escape-the-declared-out-type.md
       channelHandler.getChannel().send(`Unauthorized for ${routeMessage}`)
       return
     }
@@ -111,10 +112,7 @@ export const processMessageHandlers = (
     // Get wire middleware: channel-level middleware + message-specific middleware
     const channelWireMiddleware = channelConfig.middleware || []
 
-    // Check if onMessage is a wrapper object vs direct function config:
-    // - Direct config: onMessage.func is a plain Function
-    // - Wrapper: onMessage.func is a CorePikkuFunctionConfig (has onMessage.func.func)
-    // - Simple wrapper: onMessage has both func (plain Function) and middleware properties
+    // knowledge: decisions/internals/channel-message-handlers-accept-three-config-shapes.md
     const isWrapper =
       onMessage &&
       typeof onMessage === 'object' &&
@@ -145,7 +143,9 @@ export const processMessageHandlers = (
       inheritedMiddleware,
       wireMiddleware,
       inheritedChannelMiddleware: channelMeta?.channelMiddleware,
-      wireChannelMiddleware: wireChannelMiddleware as any,
+      // knowledge: questions/channel-middleware-accepts-bare-factories-that-nothing-resolves.md
+      wireChannelMiddleware:
+        wireChannelMiddleware as CorePikkuChannelMiddleware[],
       coerceDataFromSchema: true,
       tags: channelConfig.tags,
       sessionService: userSession,
@@ -191,7 +191,7 @@ export const processMessageHandlers = (
 
             processed = true
             const routeResult = await processMessage(
-              data as any,
+              data,
               routes[routerValue],
               routingProperty,
               routerValue

package/src/wirings/channel/channel-rpc-service.ts

@@ -10,20 +10,6 @@ import {
   type ChannelRPCValidator,
 } from './channel-rpc.types.js'
 
-/**
- * `remote` for channels that only ever flow one way — a server-sent stream, an
- * agent's output, a local CLI. Nothing is listening for a request on them, so
- * the call is refused rather than waiting out a timeout.
- */
-export const unsupportedChannelRemote = async (
-  funcName: string
-): Promise<never> => {
-  throw new ChannelRPCError(
-    `Cannot call "${funcName}" remotely: this channel has no peer that answers`,
-    'unsupported'
-  )
-}
-
 /**
  * A `DeploymentService` whose transport is an open channel rather than an
  * address, so a server-side function can call back into a peer that has no

package/src/wirings/channel/channel-rpc.test.ts

@@ -109,21 +109,42 @@ describe('ChannelRPCRegistry', () => {
     })
   })
 
-  test('times out instead of hanging forever', async () => {
+  /**
+   * The registry unrefs its timeout timer so an in-flight call can never hold
+   * a process open. That makes the timeout unawaitable in a test: when the
+   * pending call is the only thing left, the loop drains before the timer
+   * fires, and node:test cancels the file — taking every later test with it.
+   *
+   * Driving the clock by hand removes the dependency on real time entirely.
+   * `t.mock.timers` is scoped to the test and resets itself, so the tests that
+   * do want a real clock are unaffected.
+   *
+   * knowledge: decisions/internals/an-unref-d-timer-cannot-be-awaited-under-node-test.md
+   */
+  test('times out instead of hanging forever', async (t) => {
+    t.mock.timers.enable({ apis: ['setTimeout'] })
+
     const registry = new ChannelRPCRegistry(10)
     const call = registry.register()
 
-    await assert.rejects(call.promise, (e: ChannelRPCError) => {
+    const rejected = assert.rejects(call.promise, (e: ChannelRPCError) => {
       assert.equal(e.reason, 'timeout')
       return true
     })
+    t.mock.timers.tick(10)
+    await rejected
+
     assert.equal(registry.inFlight, 0, 'a timed out call is not leaked')
   })
 
-  test('drops a late response for an already-timed-out call', async () => {
+  test('drops a late response for an already-timed-out call', async (t) => {
+    t.mock.timers.enable({ apis: ['setTimeout'] })
+
     const registry = new ChannelRPCRegistry(10)
     const call = registry.register()
-    await assert.rejects(call.promise)
+    const rejected = assert.rejects(call.promise)
+    t.mock.timers.tick(10)
+    await rejected
 
     const settled = registry.settle({
       action: CHANNEL_RPC_RESPONSE,

package/src/wirings/channel/channel-rpc.types.ts

@@ -148,3 +148,17 @@ export type ChannelRPCValidator = (
   funcName: string,
   value: unknown
 ) => Promise<void> | void
+
+/**
+ * `remote` for wires with no peer that answers — a server-sent stream, an
+ * agent's output, a local CLI. Nothing is listening for a request on them, so
+ * the call is refused rather than waiting out a timeout.
+ */
+export const unsupportedChannelRemote = async (
+  funcName: string
+): Promise<never> => {
+  throw new ChannelRPCError(
+    `Cannot call "${funcName}" remotely: this channel has no peer that answers`,
+    'unsupported'
+  )
+}

package/src/wirings/channel/channel-runner.ts

@@ -1,10 +1,9 @@
 import { NotFoundError } from '../../errors/errors.js'
 import { addFunction } from '../../function/function-runner.js'
-import type { CorePikkuPermission } from '../../function/functions.types.js'
+import type { CorePikkuFunctionConfig } from '../../function/functions.types.js'
 import { pikkuState, getSingletonServices } from '../../pikku-state.js'
 import { coerceTopLevelDataFromSchema, validateSchema } from '../../schema.js'
 import type { SessionService } from '../../services/user-session-service.js'
-import type { CorePikkuMiddleware } from '../../types/core.types.js'
 import { httpRouter } from '../http/routers/http-router.js'
 import type {
   ChannelMeta,
@@ -13,19 +12,34 @@ import type {
   RunChannelParams,
 } from './channel.types.js'
 
+type HandlerConfig = CorePikkuFunctionConfig<any, any>
+
+/**
+ * The config to register for a channel handler: the handler itself when it is a
+ * direct function config, or its inner `func` when it is a wrapper.
+ *
+ * knowledge: decisions/internals/channel-message-handlers-accept-three-config-shapes.md
+ */
+const registeredHandler = (handler: unknown): HandlerConfig => {
+  const candidate = handler as { func?: unknown }
+  return typeof candidate.func === 'function'
+    ? (handler as HandlerConfig)
+    : (candidate.func as HandlerConfig)
+}
+
 export const wireChannel = <
   In,
   Channel extends string,
-  PikkuPermission extends CorePikkuPermission<In>,
-  PikkuMiddleware extends CorePikkuMiddleware,
-  ChannelFunction,
+  ChannelConnect,
+  ChannelDisconnect,
+  ChannelFunctionMessage,
 >(
   channel: CoreChannel<
     In,
     Channel,
-    PikkuPermission,
-    PikkuMiddleware,
-    ChannelFunction
+    ChannelConnect,
+    ChannelDisconnect,
+    ChannelFunctionMessage
   >
 ) => {
   const channelsMeta = pikkuState(null, 'channel', 'meta')
@@ -38,19 +52,23 @@ export const wireChannel = <
   }
 
   if (channel.onConnect && channelMeta.connect) {
-    addFunction(channelMeta.connect.pikkuFuncId, channel.onConnect as any)
+    addFunction(
+      channelMeta.connect.pikkuFuncId,
+      registeredHandler(channel.onConnect)
+    )
   }
 
   if (channel.onDisconnect && channelMeta.disconnect) {
-    addFunction(channelMeta.disconnect.pikkuFuncId, channel.onDisconnect as any)
+    addFunction(
+      channelMeta.disconnect.pikkuFuncId,
+      registeredHandler(channel.onDisconnect)
+    )
   }
 
   if (channel.onMessage && channelMeta.message?.pikkuFuncId) {
     addFunction(
       channelMeta.message.pikkuFuncId,
-      (channel.onMessage as any).func instanceof Function
-        ? channel.onMessage
-        : (channel.onMessage as any).func
+      registeredHandler(channel.onMessage)
     )
   }
 
@@ -63,17 +81,12 @@ export const wireChannel = <
         const wiringMeta = channelWirings[wiringKey]
         if (!wiringMeta) return
 
-        addFunction(
-          wiringMeta.pikkuFuncId,
-          (handler as any).func instanceof Function
-            ? handler
-            : (handler as any).func
-        )
+        addFunction(wiringMeta.pikkuFuncId, registeredHandler(handler))
       })
     })
   }
 
-  pikkuState(null, 'channel', 'channels').set(channel.name, channel as any)
+  pikkuState(null, 'channel', 'channels').set(channel.name, channel)
 }
 
 const getMatchingChannelConfig = (path: string) => {

package/src/wirings/channel/channel.types.ts

@@ -64,6 +64,8 @@ export interface ChannelMeta {
   message: ChannelMessageMeta | null
   messageWirings: Record<string, Record<string, ChannelMessageMeta>>
   binary?: boolean | null
+  /** Set when the channel was wired by a gateway rather than declared directly. */
+  gateway?: boolean
   summary?: string
   description?: string
   errors?: string[]

package/src/wirings/channel/local/local-channel-runner.ts

@@ -206,7 +206,7 @@ export const runLocalChannel = async ({
 
       const { onMessage, onBinaryMessage } = processMessageHandlers(
         services,
-        channelConfig as any,
+        channelConfig,
         channelHandler,
         userSession
       )

package/src/wirings/channel/pikku-abstract-channel-handler.ts

@@ -34,7 +34,8 @@ export abstract class PikkuAbstractChannelHandler<
         setState: (s) => {
           channelState = s
         },
-        getState: () => channelState as any,
+        // knowledge: decisions/internals/channel-state-accessors-are-unsound-generics-that-every-implementation-asserts.md
+        getState: () => channelState as never,
         clearState: () => {
           channelState = undefined
         },

package/src/wirings/channel/serverless/serverless-channel-runner.ts

@@ -117,7 +117,8 @@ export const runChannelConnect = async ({
       channelName: channelConfig.name,
     })
     channel.setState = (state) => channelStore.setState(channelId, state)
-    channel.getState = () => channelStore.getState(channelId) as any
+    // knowledge: decisions/internals/channel-state-accessors-are-unsound-generics-that-every-implementation-asserts.md
+    channel.getState = () => channelStore.getState(channelId) as never
     channel.clearState = () => channelStore.clearState(channelId)
 
     const wire: PikkuRawWire = {
@@ -198,7 +199,8 @@ export const runChannelDisconnect = async ({
     channelName,
   })
   channel.setState = (state) => channelStore.setState(channelId, state)
-  channel.getState = () => channelStore.getState(channelId) as any
+  // knowledge: decisions/internals/channel-state-accessors-are-unsound-generics-that-every-implementation-asserts.md
+  channel.getState = () => channelStore.getState(channelId) as never
   channel.clearState = () => channelStore.clearState(channelId)
 
   const userSession = new PikkuSessionService<CoreUserSession>(
@@ -271,7 +273,8 @@ export const runChannelMessage = async (
     channelName,
   })
   channel.setState = (state) => channelStore.setState(channelId, state)
-  channel.getState = () => channelStore.getState(channelId) as any
+  // knowledge: decisions/internals/channel-state-accessors-are-unsound-generics-that-every-implementation-asserts.md
+  channel.getState = () => channelStore.getState(channelId) as never
   channel.clearState = () => channelStore.clearState(channelId)
 
   const userSession = new PikkuSessionService<CoreUserSession>(

package/src/wirings/cli/channel/cli-channel-runner.ts

@@ -90,7 +90,9 @@ export async function executeCLIViaChannel({
         return
       }
 
-      renderer(null as any, response, undefined)
+      // A CLI channel response is rendered off-process: there are no services
+      // to hand the renderer, and every CLI renderer ignores the argument.
+      renderer(null as never, response, undefined)
     }
 
     commandRoute.subscribe(commandId, responseHandler)

package/src/wirings/cli/channel/cli-raw-client-runner.ts

@@ -32,7 +32,10 @@ export type CorePikkuCLIClientRender<Data> = (
 ) => void | Promise<void>
 
 /** The normal case once the server owns the command tree. */
-const defaultJSONRenderer: CorePikkuCLIClientRender<any> = (_services, data) => {
+const defaultJSONRenderer: CorePikkuCLIClientRender<any> = (
+  _services,
+  data
+) => {
   console.log(JSON.stringify(data))
 }
 

package/src/wirings/cli/cli-runner.ts

@@ -16,6 +16,7 @@ import type {
   CLIMeta,
 } from './cli.types.js'
 import type {
+  CoreConfig,
   CoreSingletonServices,
   CoreServices,
   CreateWireServices,
@@ -24,7 +25,7 @@ import type {
   CreateSingletonServices,
 } from '../../types/core.types.js'
 import type { PikkuChannel } from '../channel/channel.types.js'
-import { unsupportedChannelRemote } from '../channel/channel-rpc.js'
+import { unsupportedChannelRemote } from '../channel/channel-rpc.types.js'
 import {
   PikkuSessionService,
   createMiddlewareSessionWireProps,
@@ -321,7 +322,8 @@ export async function runCLICommand({
     setState: (s) => {
       cliState = s
     },
-    getState: () => cliState as any,
+    // knowledge: decisions/internals/channel-state-accessors-are-unsound-generics-that-every-implementation-asserts.md
+    getState: () => cliState as never,
     clearState: () => {
       cliState = undefined
     },
@@ -372,7 +374,8 @@ export async function runCLICommand({
     if (result !== undefined && !onOutput) {
       const commandRenderer = programData?.renderers[commandId]
       const jsonMode =
-        (data as any).json === true || (data as any).output === 'json'
+        (data as { json?: unknown; output?: unknown }).json === true ||
+        (data as { json?: unknown; output?: unknown }).output === 'json'
       const finalRenderer: CorePikkuCLIRender<any> | undefined =
         jsonMode && commandRenderer !== undefined
           ? defaultJSONRenderer
@@ -491,7 +494,7 @@ export async function executeCLI({
 
     const config = createConfig
       ? await createConfig(new LocalVariablesService(), data)
-      : ({} as any)
+      : ({} as CoreConfig)
 
     const singletonServices = await createSingletonServices(config)
     pikkuState(null, 'package', 'singletonServices', singletonServices)