@pikku/inspector 0.12.73 → 0.12.75

package/CHANGELOG.md

@@ -1,3 +1,31 @@
+## 0.12.75
+
+### Patch Changes
+
+- b28a8c0: An addon's exposed functions get their own deployment unit
+
+  `collectFilterNames` adds the `/rpc/:rpcName` scaffold name to every unit holding an exposed function, so that unit can serve its own `/rpc/<funcName>`. `filterInspectorState` read that same string back as "this unit is the generic dispatcher" and kept every wired addon's declaration for it, so almost every function unit imported each addon's whole package bootstrap — and the node-only modules it reaches.
+
+  No unit retains a wired addon on the strength of a catch-all route any more. Instead the analyzer emits a unit per addon carrying that addon's exposed functions, and the unit serving `/rpc/:rpcName` dispatches to it over a service binding rather than bundling it. Granularity is per addon rather than per function because an addon publishes a single prebuilt bootstrap that registers all of its functions at once.
+
+  `node:child_process` joins `node:fs` as a stubbed builtin: Workers have no implementation of it under any compatibility flag, and it is reached from the console addon's audit tooling.
+
+  `DeploymentUnit` gains `dispatch`, an RPC-name → unit-name map for calls whose target unit isn't the kebab-cased RPC name. `rpc.exposed(name)` falls through to the deployment service for a namespaced name with no local metadata, and Cloudflare function units with a `dependsOn` now get a `deploymentService`, which previously only gateway units had.
+
+- Updated dependencies [b28a8c0]
+  - @pikku/core@0.12.107
+
+## 0.12.74
+
+### Patch Changes
+
+- 1becc2d: Publish an MCP tool under its declared `name`
+
+  `pikkuMCPToolFunc`'s config accepts a `name`, and it is the name an AI client
+  calls the tool by, but the inspector never read it — the tool was always
+  published under whatever the export happened to be called. The declared name
+  now keys `toolsMeta`; `pikkuFuncId` is unchanged.
+
 ## 0.12.73
 
 ### Patch Changes

package/dist/add/add-functions.js

@@ -1053,13 +1053,25 @@ export const addFunctions = (logger, node, checker, state, options) => {
         };
     }
     if (mcpEnabled) {
+        // `pikkuMCPToolFunc`'s config accepts `name`, and it is the name an AI client
+        // calls the tool by — `runMCPTool` looks the tool up in `toolsMeta` by exactly
+        // this key and then dispatches through `pikkuFuncId`, so it is a public label
+        // rather than an identity. It was never read here, so a declared `name` was
+        // silently dropped and the tool published under whatever the export happened to
+        // be called. It does NOT become the `pikkuFuncId`: renaming an export's rpc id
+        // is a different decision, and the scenario-step wrappers are the only place
+        // `name` carries that weight.
+        const declaredName = objectNode
+            ? getPropertyValue(objectNode, 'name')
+            : undefined;
+        const toolName = typeof declaredName === 'string' && declaredName ? declaredName : name;
         if (!description) {
-            logger.warn(`MCP tool '${name}' is missing a description.`);
+            logger.warn(`MCP tool '${toolName}' is missing a description.`);
         }
         state.mcpEndpoints.files.add(node.getSourceFile().fileName);
-        state.mcpEndpoints.toolsMeta[name] = {
+        state.mcpEndpoints.toolsMeta[toolName] = {
             pikkuFuncId,
-            name,
+            name: toolName,
             title: title || undefined,
             description: description || undefined,
             summary,

package/dist/utils/filter-inspector-state.js

@@ -914,21 +914,17 @@ export function filterInspectorState(state, filters, logger) {
             for (const tool of agentMeta.tools ?? [])
                 referencedIds.add(tool);
         }
-        // A unit carrying the generic `/rpc/:rpcName` catch-all (the rpcCaller
-        // unit, and agent units) dispatches arbitrary RPCs at runtime via
-        // `rpc.exposed(name)`, including namespaced addon RPCs (e.g.
-        // `admin:createUser`). Those never appear in referencedIds because no
-        // app-local function statically references them, so keep every wired
-        // addon's declaration for such units — otherwise the per-unit bootstrap
-        // omits the addon package bootstrap and `rpc.exposed('admin:createUser')`
-        // throws RPCNotFoundError on the deployed stage.
-        const hasRpcCatchAll = (filters.names ?? []).includes('/rpc/:rpcName');
+        // An addon RPC named outright in the filter is what a unit built FOR that
+        // addon is given, so its declaration has to survive even though no
+        // app-local function references it.
+        for (const name of filters.names ?? []) {
+            const namespace = name.slice(0, name.indexOf(':'));
+            if (namespace && filteredState.rpc.wireAddonDeclarations.has(namespace)) {
+                referencedIds.add(name);
+            }
+        }
         const keptNamespaces = new Set();
         for (const namespace of filteredState.rpc.wireAddonDeclarations.keys()) {
-            if (hasRpcCatchAll) {
-                keptNamespaces.add(namespace);
-                continue;
-            }
             const prefix = `${namespace}:`;
             for (const id of referencedIds) {
                 if (id.startsWith(prefix)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.73",
+  "version": "0.12.75",
   "description": "TypeScript inspector for Pikku — discovers functions and wirings to drive code generation",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
@@ -45,10 +45,10 @@
     "zod-to-ts": "^2.1.0"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.102"
+    "@pikku/core": "^0.12.107"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.102",
+    "@pikku/core": "^0.12.107",
     "@types/node": "^24.13.3"
   },
   "engines": {

package/src/add/add-functions.test.ts

@@ -643,3 +643,101 @@ describe('pikkuRemoteChannelFunc', () => {
     )
   })
 })
+
+describe('MCP tool naming', () => {
+  const quietLogger = (): InspectorLogger => ({
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    diagnostic: () => {},
+    critical: () => {},
+    hasCriticalErrors: () => false,
+  })
+
+  test('a declared name is what the tool is published as', async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-mcp-tool-name-'))
+    const file = join(rootDir, 'tool.ts')
+    await writeFile(
+      file,
+      [
+        "import { pikkuMCPToolFunc } from '@pikku/core'",
+        'export const createUnansweredCountTool = pikkuMCPToolFunc({',
+        "  name: 'getUnansweredConversationCount',",
+        "  description: 'How many conversations are unanswered.',",
+        '  func: async () => ({ ok: true })',
+        '})',
+      ].join('\n')
+    )
+
+    try {
+      const state = await inspect(quietLogger(), [file], { rootDir })
+      const tools = state.mcpEndpoints.toolsMeta
+      assert.ok(
+        tools['getUnansweredConversationCount'],
+        `expected the declared name, got: ${Object.keys(tools).join(', ')}`
+      )
+      assert.strictEqual(tools['createUnansweredCountTool'], undefined)
+      assert.strictEqual(
+        tools['getUnansweredConversationCount']!.pikkuFuncId,
+        'createUnansweredCountTool'
+      )
+    } finally {
+      await rm(rootDir, { recursive: true, force: true })
+    }
+  })
+
+  test('with no declared name the export still names the tool', async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-mcp-tool-export-'))
+    const file = join(rootDir, 'tool.ts')
+    await writeFile(
+      file,
+      [
+        "import { pikkuMCPToolFunc } from '@pikku/core'",
+        'export const listOpenTickets = pikkuMCPToolFunc({',
+        "  description: 'Tickets still open.',",
+        '  func: async () => ({ ok: true })',
+        '})',
+      ].join('\n')
+    )
+
+    try {
+      const state = await inspect(quietLogger(), [file], { rootDir })
+      assert.ok(state.mcpEndpoints.toolsMeta['listOpenTickets'])
+    } finally {
+      await rm(rootDir, { recursive: true, force: true })
+    }
+  })
+  test('a plain func with mcp: true is published under its declared name', async () => {
+    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-mcp-flag-name-'))
+    const file = join(rootDir, 'tool.ts')
+    await writeFile(
+      file,
+      [
+        "import { pikkuFunc } from '@pikku/core'",
+        'export const countUnanswered = pikkuFunc({',
+        '  mcp: true,',
+        "  name: 'getUnansweredConversationCount',",
+        "  description: 'How many conversations are unanswered.',",
+        '  func: async () => ({ ok: true })',
+        '})',
+      ].join('\n')
+    )
+
+    try {
+      const state = await inspect(quietLogger(), [file], { rootDir })
+      const tools = state.mcpEndpoints.toolsMeta
+      assert.ok(
+        tools['getUnansweredConversationCount'],
+        `expected the declared name, got: ${Object.keys(tools).join(', ')}`
+      )
+      assert.strictEqual(tools['countUnanswered'], undefined)
+      assert.strictEqual(
+        tools['getUnansweredConversationCount']!.pikkuFuncId,
+        'countUnanswered'
+      )
+    } finally {
+      await rm(rootDir, { recursive: true, force: true })
+    }
+  })
+})

package/src/add/add-functions.ts

@@ -1431,13 +1431,26 @@ export const addFunctions: AddWiring = (
   }
 
   if (mcpEnabled) {
+    // `pikkuMCPToolFunc`'s config accepts `name`, and it is the name an AI client
+    // calls the tool by — `runMCPTool` looks the tool up in `toolsMeta` by exactly
+    // this key and then dispatches through `pikkuFuncId`, so it is a public label
+    // rather than an identity. It was never read here, so a declared `name` was
+    // silently dropped and the tool published under whatever the export happened to
+    // be called. It does NOT become the `pikkuFuncId`: renaming an export's rpc id
+    // is a different decision, and the scenario-step wrappers are the only place
+    // `name` carries that weight.
+    const declaredName = objectNode
+      ? getPropertyValue(objectNode, 'name')
+      : undefined
+    const toolName =
+      typeof declaredName === 'string' && declaredName ? declaredName : name
     if (!description) {
-      logger.warn(`MCP tool '${name}' is missing a description.`)
+      logger.warn(`MCP tool '${toolName}' is missing a description.`)
     }
     state.mcpEndpoints.files.add(node.getSourceFile().fileName)
-    state.mcpEndpoints.toolsMeta[name] = {
+    state.mcpEndpoints.toolsMeta[toolName] = {
       pikkuFuncId,
-      name,
+      name: toolName,
       title: title || undefined,
       description: description || undefined,
       summary,

package/src/utils/filter-inspector-state.test.ts

@@ -2143,14 +2143,6 @@ describe('invokedAgentsByFile', () => {
   })
 
   describe('Wired addon retention', () => {
-    // A unit that owns the generic `/rpc/:rpcName` catch-all (the rpcCaller
-    // unit, and agent units) dispatches arbitrary RPCs at runtime via
-    // `rpc.exposed(name)`, including namespaced addon RPCs like
-    // `admin:createUser`. No app-local function statically references those
-    // ids, so the catch-all must be enough to keep every wired addon's
-    // declaration — otherwise the per-unit bootstrap omits the addon package
-    // bootstrap and `rpc.exposed('admin:createUser')` throws RPCNotFoundError
-    // on a deployed stage.
     const withAddons = () => {
       const state = createMockInspectorState()
       state.rpc.wireAddonDeclarations = new Map([
@@ -2161,20 +2153,53 @@ describe('invokedAgentsByFile', () => {
       return state
     }
 
-    test('keeps all wired addons for a unit with the /rpc/:rpcName catch-all', () => {
+    test('keeps only the addon whose function the unit is built for', () => {
       const result = filterInspectorState(
         withAddons(),
-        { names: ['/rpc/:rpcName', 'http:post:/rpc/:rpcName', 'rpcCaller'] },
+        {
+          names: [
+            'console:runSecurityAudit',
+            '/rpc/:rpcName',
+            'http:post:/rpc/:rpcName',
+            'rpcCaller',
+          ],
+        },
         mockLogger
       )
       assert.deepStrictEqual(
-        [...result.rpc.wireAddonDeclarations.keys()].sort(),
-        ['admin', 'console']
+        [...result.rpc.wireAddonDeclarations.keys()],
+        ['console']
       )
-      assert.deepStrictEqual([...result.rpc.usedAddons].sort(), [
-        'admin',
-        'console',
-      ])
+      assert.deepStrictEqual([...result.rpc.usedAddons], ['console'])
+    })
+
+    test('drops every wired addon for a unit serving the catch-all', () => {
+      const result = filterInspectorState(
+        withAddons(),
+        {
+          names: ['/rpc/:rpcName', 'http:post:/rpc/:rpcName', 'rpcCaller'],
+        },
+        mockLogger
+      )
+      assert.deepStrictEqual([...result.rpc.wireAddonDeclarations.keys()], [])
+      assert.deepStrictEqual([...result.rpc.usedAddons], [])
+    })
+
+    test('drops wired addons for a unit given the scaffold names', () => {
+      const result = filterInspectorState(
+        withAddons(),
+        {
+          names: [
+            'addRetreatPerson',
+            '/rpc/:rpcName',
+            'http:post:/rpc/:rpcName',
+            'rpcCaller',
+          ],
+        },
+        mockLogger
+      )
+      assert.deepStrictEqual([...result.rpc.wireAddonDeclarations.keys()], [])
+      assert.deepStrictEqual([...result.rpc.usedAddons], [])
     })
 
     test('drops wired addons for a unit without the catch-all that references no namespace', () => {

package/src/utils/filter-inspector-state.ts

@@ -1258,21 +1258,17 @@ export function filterInspectorState(
     ) as Array<{ tools?: string[] }>) {
       for (const tool of agentMeta.tools ?? []) referencedIds.add(tool)
     }
-    // A unit carrying the generic `/rpc/:rpcName` catch-all (the rpcCaller
-    // unit, and agent units) dispatches arbitrary RPCs at runtime via
-    // `rpc.exposed(name)`, including namespaced addon RPCs (e.g.
-    // `admin:createUser`). Those never appear in referencedIds because no
-    // app-local function statically references them, so keep every wired
-    // addon's declaration for such units — otherwise the per-unit bootstrap
-    // omits the addon package bootstrap and `rpc.exposed('admin:createUser')`
-    // throws RPCNotFoundError on the deployed stage.
-    const hasRpcCatchAll = (filters.names ?? []).includes('/rpc/:rpcName')
+    // An addon RPC named outright in the filter is what a unit built FOR that
+    // addon is given, so its declaration has to survive even though no
+    // app-local function references it.
+    for (const name of filters.names ?? []) {
+      const namespace = name.slice(0, name.indexOf(':'))
+      if (namespace && filteredState.rpc.wireAddonDeclarations.has(namespace)) {
+        referencedIds.add(name)
+      }
+    }
     const keptNamespaces = new Set<string>()
     for (const namespace of filteredState.rpc.wireAddonDeclarations.keys()) {
-      if (hasRpcCatchAll) {
-        keptNamespaces.add(namespace)
-        continue
-      }
       const prefix = `${namespace}:`
       for (const id of referencedIds) {
         if (id.startsWith(prefix)) {