@pikku/inspector 0.12.2 → 0.12.3

package/src/add/add-cli.ts

@@ -12,9 +12,11 @@ import {
   makeContextBasedId,
 } from '../utils/extract-function-name.js'
 import { resolveMiddleware } from '../utils/middleware.js'
+import { resolveFunctionMeta } from '../utils/resolve-function-meta.js'
 import { extractWireNames } from '../utils/post-process.js'
 import { getPropertyValue } from '../utils/get-property-value.js'
 import { resolveIdentifier } from '../utils/resolve-identifier.js'
+import { resolveAddonName } from '../utils/resolve-addon-package.js'
 import { validateAuthSessionless } from '../utils/validate-auth-sessionless.js'
 
 // Track if we've warned about missing Config type to avoid duplicate warnings
@@ -344,15 +346,53 @@ function processCommand(
     const propName = prop.name.text
 
     if (propName === 'func') {
-      pikkuFuncId = extractFunctionName(
-        prop.initializer,
-        typeChecker,
-        inspectorState.rootDir
-      ).pikkuFuncId
-      if (pikkuFuncId.startsWith('__temp_')) {
-        pikkuFuncId = makeContextBasedId('cli', programName, ...fullPath)
+      if (
+        ts.isCallExpression(prop.initializer) &&
+        ts.isIdentifier(prop.initializer.expression) &&
+        prop.initializer.expression.text === 'addon'
+      ) {
+        const [firstArg] = prop.initializer.arguments
+        if (!firstArg || !ts.isStringLiteral(firstArg)) {
+          throw new Error(
+            `addon() call requires a string literal argument in the form "namespace:funcName"`
+          )
+        }
+        pikkuFuncId = firstArg.text
+        const addonNamespace = pikkuFuncId.split(':')[0]
+        if (!addonNamespace || !pikkuFuncId.includes(':')) {
+          throw new Error(
+            `Malformed addon function ID "${pikkuFuncId}": expected "namespace:funcName" format`
+          )
+        }
+        if (!inspectorState.rpc.wireAddonDeclarations.has(addonNamespace)) {
+          throw new Error(
+            `Unknown addon namespace "${addonNamespace}" in "${pikkuFuncId}": no matching wireAddonDeclarations entry found`
+          )
+        }
+        meta.pikkuFuncId = pikkuFuncId
+        meta.packageName =
+          inspectorState.rpc.wireAddonDeclarations.get(addonNamespace)!.package
+      } else {
+        pikkuFuncId = extractFunctionName(
+          prop.initializer,
+          typeChecker,
+          inspectorState.rootDir
+        ).pikkuFuncId
+        if (pikkuFuncId.startsWith('__temp_')) {
+          pikkuFuncId = makeContextBasedId('cli', programName, ...fullPath)
+        }
+        meta.pikkuFuncId = pikkuFuncId
+        const cliPackageName = ts.isIdentifier(prop.initializer)
+          ? resolveAddonName(
+              prop.initializer,
+              typeChecker,
+              inspectorState.rpc.wireAddonDeclarations
+            )
+          : null
+        if (cliPackageName) {
+          meta.packageName = cliPackageName
+        }
       }
-      meta.pikkuFuncId = pikkuFuncId
     } else if (
       propName === 'options' &&
       ts.isObjectLiteralExpression(prop.initializer)
@@ -573,22 +613,31 @@ function processOptions(
       }
 
       // Extract enum values from the function input type if available
-      // Get the input type if we have a pikkuFuncId
-      let inputTypes: ts.Type[] | undefined
+      let derivedChoices: string[] | null = null
+
       if (pikkuFuncId) {
-        inputTypes = inspectorState.typesLookup.get(pikkuFuncId)
-      }
+        // 1. Try TypeScript types first (most precise — handles unions, TS enums)
+        const inputTypes = inspectorState.typesLookup.get(pikkuFuncId)
+        if (inputTypes && inputTypes.length > 0) {
+          derivedChoices = extractEnumFromPropertyType(
+            inputTypes[0]!,
+            optionName,
+            typeChecker
+          )
+        }
 
-      let derivedChoices: string[] | null = null
+        // 2. Fallback: try JSON schema (works for addon functions)
+        if (!derivedChoices) {
+          derivedChoices = extractEnumFromJsonSchema(
+            inspectorState,
+            pikkuFuncId,
+            optionName
+          )
+        }
+      }
 
-      if (inputTypes && inputTypes.length > 0) {
-        derivedChoices = extractEnumFromPropertyType(
-          inputTypes[0]!,
-          optionName,
-          typeChecker
-        )
-      } else {
-        // Fallback: try to extract from Config type
+      // 3. Last resort: try Config type
+      if (!derivedChoices) {
         derivedChoices = extractEnumFromConfigType(
           logger,
           optionName,
@@ -750,6 +799,44 @@ function extractEnumFromConfigType(
   return extractEnumFromPropertyType(configType, propertyName, typeChecker)
 }
 
+/**
+ * Extracts enum values from the function's JSON schema.
+ * Works for addon functions whose schemas are generated from OpenAPI/Zod.
+ */
+function extractEnumFromJsonSchema(
+  inspectorState: InspectorState,
+  pikkuFuncId: string,
+  propertyName: string
+): string[] | null {
+  const fnMeta = resolveFunctionMeta(inspectorState, pikkuFuncId)
+  if (!fnMeta?.inputSchemaName) return null
+
+  const schema = inspectorState.schemas[fnMeta.inputSchemaName] as any
+  if (!schema?.properties?.[propertyName]) return null
+
+  const prop = schema.properties[propertyName]
+
+  // Direct enum on property
+  if (prop.enum && Array.isArray(prop.enum)) {
+    const strings = prop.enum.filter((v: unknown) => typeof v === 'string')
+    if (strings.length > 0) return strings
+  }
+
+  // Array with enum items (e.g. z.array(z.enum([...])))
+  if (
+    prop.type === 'array' &&
+    prop.items?.enum &&
+    Array.isArray(prop.items.enum)
+  ) {
+    const strings = prop.items.enum.filter(
+      (v: unknown) => typeof v === 'string'
+    )
+    if (strings.length > 0) return strings
+  }
+
+  return null
+}
+
 /**
  * Gets the property name from a property assignment
  */

package/src/add/add-file-with-factory.ts

@@ -9,6 +9,7 @@ const wrapperFunctionMap: Record<string, string> = {
   pikkuServices: 'CreateSingletonServices',
   pikkuAddonServices: 'CreateSingletonServices',
   pikkuWireServices: 'CreateWireServices',
+  pikkuAddonWireServices: 'CreateWireServices',
 }
 
 export const addFileWithFactory = (

package/src/add/add-functions.ts

@@ -339,7 +339,8 @@ export const addFunctions: AddWiring = (
   let remote: boolean | undefined
   let mcp: boolean | undefined
   let readonly_: boolean | undefined
-  let requiresApproval: boolean | undefined
+  let approvalRequired: boolean | undefined
+  let approvalDescription: string | undefined
   let version: number | undefined
   let objectNode: ts.ObjectLiteralExpression | undefined
   let nodeDisplayName: string | null = null
@@ -421,10 +422,33 @@ export const addFunctions: AddWiring = (
     remote = getPropertyValue(firstArg, 'remote') as boolean | undefined
     mcp = getPropertyValue(firstArg, 'mcp') as boolean | undefined
     readonly_ = getPropertyValue(firstArg, 'readonly') as boolean | undefined
-    requiresApproval = getPropertyValue(firstArg, 'requiresApproval') as
+    approvalRequired = getPropertyValue(firstArg, 'approvalRequired') as
       | boolean
       | undefined
 
+    // Extract approvalDescription identifier reference
+    for (const prop of firstArg.properties) {
+      if (
+        ts.isPropertyAssignment(prop) &&
+        ts.isIdentifier(prop.name) &&
+        prop.name.text === 'approvalDescription' &&
+        ts.isIdentifier(prop.initializer)
+      ) {
+        const { pikkuFuncId: descId } = extractFunctionName(
+          prop.initializer,
+          checker,
+          state.rootDir
+        )
+        if (descId && !descId.startsWith('__temp_')) {
+          approvalDescription = descId
+        } else {
+          // Try resolving the identifier directly
+          approvalDescription = prop.initializer.text
+        }
+        break
+      }
+    }
+
     const versionRaw = getPropertyValue(firstArg, 'version')
     if (versionRaw !== null && versionRaw !== undefined) {
       const parsed = Number(versionRaw)
@@ -759,7 +783,8 @@ export const addFunctions: AddWiring = (
     remote: remote || undefined,
     mcp: mcpEnabled || undefined,
     readonly: readonly_ || undefined,
-    requiresApproval: requiresApproval || undefined,
+    approvalRequired: approvalRequired || undefined,
+    approvalDescription: approvalDescription || undefined,
     version,
     title,
     tags: tags || undefined,

package/src/add/add-gateway.ts

@@ -11,6 +11,7 @@ import {
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
 import { resolveMiddleware } from '../utils/middleware.js'
 import { extractWireNames } from '../utils/post-process.js'
+import { resolveAddonName } from '../utils/resolve-addon-package.js'
 import type { GatewayTransportType } from '@pikku/core/gateway'
 
 import { ErrorCode } from '../error-codes.js'
@@ -68,6 +69,10 @@ export const addGateway: AddWiring = (
     pikkuFuncId = makeContextBasedId('gateway', nameValue)
   }
 
+  const packageName = ts.isIdentifier(funcInitializer)
+    ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+    : null
+
   if (!nameValue || !typeValue) {
     return
   }
@@ -82,6 +87,7 @@ export const addGateway: AddWiring = (
   state.gateways.files.add(node.getSourceFile().fileName)
   state.gateways.meta[nameValue] = {
     pikkuFuncId,
+    ...(packageName && { packageName }),
     name: nameValue,
     type: typeValue,
     route: routeValue,

package/src/add/add-http-route.ts

@@ -21,6 +21,7 @@ import { ensureFunctionMetadata } from '../utils/ensure-function-metadata.js'
 import { ErrorCode } from '../error-codes.js'
 import { validateAuthSessionless } from '../utils/validate-auth-sessionless.js'
 import { detectSchemaVendorOrError } from '../utils/detect-schema-vendor.js'
+import { resolveAddonName } from '../utils/resolve-addon-package.js'
 
 import type { InspectorLogger } from '../types.js'
 
@@ -203,6 +204,10 @@ export function registerHTTPRoute({
     funcName = makeContextBasedId('http', method, fullRoute)
   }
 
+  const packageName = ts.isIdentifier(funcInitializer)
+    ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+    : null
+
   ensureFunctionMetadata(
     state,
     funcName,
@@ -320,6 +325,7 @@ export function registerHTTPRoute({
   state.http.files.add(sourceFile.fileName)
   state.http.meta[method][fullRoute] = {
     pikkuFuncId: funcName,
+    ...(packageName && { packageName }),
     route: fullRoute,
     method: method as HTTPMethod,
     params: params.length > 0 ? params : undefined,

package/src/add/add-mcp-prompt.ts

@@ -13,6 +13,7 @@ import {
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
 import { resolveMiddleware } from '../utils/middleware.js'
 import { resolvePermissions } from '../utils/permissions.js'
+import { resolveAddonName } from '../utils/resolve-addon-package.js'
 import { ErrorCode } from '../error-codes.js'
 
 export const addMCPPrompt: AddWiring = (
@@ -72,6 +73,10 @@ export const addMCPPrompt: AddWiring = (
       pikkuFuncId = makeContextBasedId('mcp', 'prompt', nameValue)
     }
 
+    const packageName = ts.isIdentifier(funcInitializer)
+      ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+      : null
+
     ensureFunctionMetadata(
       state,
       pikkuFuncId,
@@ -128,6 +133,7 @@ export const addMCPPrompt: AddWiring = (
 
     state.mcpEndpoints.promptsMeta[nameValue] = {
       pikkuFuncId,
+      ...(packageName && { packageName }),
       name: nameValue,
       description,
       summary,

package/src/add/add-mcp-resource.ts

@@ -13,6 +13,7 @@ import {
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
 import { resolveMiddleware } from '../utils/middleware.js'
 import { resolvePermissions } from '../utils/permissions.js'
+import { resolveAddonName } from '../utils/resolve-addon-package.js'
 import { ErrorCode } from '../error-codes.js'
 
 export const addMCPResource: AddWiring = (
@@ -81,6 +82,10 @@ export const addMCPResource: AddWiring = (
       pikkuFuncId = makeContextBasedId('mcp', 'resource', uriValue)
     }
 
+    const packageName = ts.isIdentifier(funcInitializer)
+      ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+      : null
+
     ensureFunctionMetadata(
       state,
       pikkuFuncId,
@@ -145,6 +150,7 @@ export const addMCPResource: AddWiring = (
 
     state.mcpEndpoints.resourcesMeta[uriValue] = {
       pikkuFuncId,
+      ...(packageName && { packageName }),
       uri: uriValue,
       title: titleValue,
       description,

package/src/add/add-queue-worker.ts

@@ -11,6 +11,7 @@ import {
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
 import { resolveMiddleware } from '../utils/middleware.js'
 import { extractWireNames } from '../utils/post-process.js'
+import { resolveAddonName } from '../utils/resolve-addon-package.js'
 import { ErrorCode } from '../error-codes.js'
 
 export const addQueueWorker: AddWiring = (logger, node, checker, state) => {
@@ -65,6 +66,10 @@ export const addQueueWorker: AddWiring = (logger, node, checker, state) => {
       pikkuFuncId = makeContextBasedId('queue', name)
     }
 
+    const packageName = ts.isIdentifier(funcInitializer)
+      ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+      : null
+
     if (!name) {
       logger.critical(
         ErrorCode.MISSING_QUEUE_NAME,
@@ -85,6 +90,7 @@ export const addQueueWorker: AddWiring = (logger, node, checker, state) => {
     state.queueWorkers.files.add(node.getSourceFile().fileName)
     state.queueWorkers.meta[name] = {
       pikkuFuncId,
+      ...(packageName && { packageName }),
       name,
       summary,
       description,

package/src/add/add-schedule.ts

@@ -11,6 +11,7 @@ import {
 import { getPropertyAssignmentInitializer } from '../utils/type-utils.js'
 import { resolveMiddleware } from '../utils/middleware.js'
 import { extractWireNames } from '../utils/post-process.js'
+import { resolveAddonName } from '../utils/resolve-addon-package.js'
 
 import { ErrorCode } from '../error-codes.js'
 export const addSchedule: AddWiring = (
@@ -71,6 +72,10 @@ export const addSchedule: AddWiring = (
       pikkuFuncId = makeContextBasedId('scheduler', nameValue)
     }
 
+    const packageName = ts.isIdentifier(funcInitializer)
+      ? resolveAddonName(funcInitializer, checker, state.rpc.wireAddonDeclarations)
+      : null
+
     if (!nameValue || !scheduleValue) {
       return
     }
@@ -87,6 +92,7 @@ export const addSchedule: AddWiring = (
     state.scheduledTasks.files.add(node.getSourceFile().fileName)
     state.scheduledTasks.meta[nameValue] = {
       pikkuFuncId,
+      ...(packageName && { packageName }),
       name: nameValue,
       schedule: scheduleValue,
       summary,

package/src/add/add-wire-addon.ts

@@ -40,6 +40,7 @@ export function addWireAddon(
   let name: string | undefined
   let pkg: string | undefined
   let rpcEndpoint: string | undefined
+  let mcp: boolean | undefined
   let secretOverrides: Record<string, string> | undefined
   let variableOverrides: Record<string, string> | undefined
 
@@ -53,6 +54,12 @@ export function addWireAddon(
       pkg = prop.initializer.text
     } else if (key === 'rpcEndpoint' && ts.isStringLiteral(prop.initializer)) {
       rpcEndpoint = prop.initializer.text
+    } else if (
+      key === 'mcp' &&
+      (prop.initializer.kind === ts.SyntaxKind.TrueKeyword ||
+        prop.initializer.kind === ts.SyntaxKind.FalseKeyword)
+    ) {
+      mcp = prop.initializer.kind === ts.SyntaxKind.TrueKeyword
     } else if (
       key === 'secretOverrides' &&
       ts.isObjectLiteralExpression(prop.initializer)
@@ -72,6 +79,7 @@ export function addWireAddon(
   state.rpc.wireAddonDeclarations.set(name, {
     package: pkg,
     rpcEndpoint,
+    mcp,
     secretOverrides,
     variableOverrides,
   })

package/src/index.ts

@@ -32,6 +32,7 @@ export {
   deserializeAllDslWorkflows,
 } from './utils/workflow/dsl/index.js'
 export { getFilesAndMethods } from './utils/get-files-and-methods.js'
+export { resolveFunctionMeta } from './utils/resolve-function-meta.js'
 export type {
   SerializedWorkflowGraph,
   SerializedWorkflowGraphs,

package/src/inspector.ts

@@ -30,6 +30,10 @@ import {
   finalizeWorkflowWires,
 } from './utils/workflow/graph/finalize-workflow-wires.js'
 import { generateAllSchemas } from './utils/schema-generator.js'
+import {
+  loadAddonFunctionsMeta,
+  loadAddonSchemas,
+} from './utils/load-addon-functions-meta.js'
 import {
   computeContractHashes,
   extractContractsFromMeta,
@@ -63,6 +67,7 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
       typesMap: new TypesMap(),
       meta: {},
       files: new Map(),
+      approvalDescriptions: {},
     },
     http: {
       metaInputTypes: new Map(),
@@ -197,6 +202,7 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
     requiredSchemas: new Set(),
     openAPISpec: null,
     diagnostics: [],
+    addonFunctions: {},
   }
 }
 
@@ -252,6 +258,9 @@ export const inspect = async (
     `Visit setup phase completed in ${(performance.now() - startSetup).toFixed(2)}ms`
   )
 
+  // Load addon function metadata so wirings can reference addon functions
+  await loadAddonFunctionsMeta(logger, state)
+
   if (!options.setupOnly) {
     // Second sweep: add all transports
     const startRoutes = performance.now()
@@ -280,6 +289,9 @@ export const inspect = async (
       computeRequiredSchemas(state, options)
     }
 
+    // Re-load addon schemas (generateAllSchemas replaces state.schemas)
+    await loadAddonSchemas(logger, state)
+
     state.manifest.initial = options.manifest ?? null
     const contracts = extractContractsFromMeta(state.functions.meta)
     const baseManifest = state.manifest.initial ?? createEmptyManifest()

package/src/types.ts

@@ -98,6 +98,7 @@ export interface InspectorFunctionState {
   typesMap: TypesMap
   meta: FunctionsMeta
   files: Map<string, { path: string; exportedName: string }>
+  approvalDescriptions: Record<string, InspectorApprovalDescriptionDefinition>
 }
 
 export interface InspectorChannelState {
@@ -140,6 +141,14 @@ export interface InspectorAIMiddlewareState {
   definitions: Record<string, InspectorMiddlewareDefinition>
 }
 
+export interface InspectorApprovalDescriptionDefinition {
+  services: FunctionServicesMeta
+  wires?: FunctionWiresMeta
+  sourceFile: string
+  position: number
+  exportedName: string | null
+}
+
 export interface InspectorPermissionDefinition {
   services: FunctionServicesMeta
   wires?: FunctionWiresMeta
@@ -340,6 +349,7 @@ export interface InspectorState {
       {
         package: string
         rpcEndpoint?: string
+        mcp?: boolean
         secretOverrides?: Record<string, string>
         variableOverrides?: Record<string, string>
       }
@@ -409,4 +419,5 @@ export interface InspectorState {
   requiredSchemas: Set<string>
   openAPISpec: Record<string, any> | null
   diagnostics: InspectorDiagnostic[]
+  addonFunctions: Record<string, FunctionsMeta> // namespace -> addon's function metadata
 }

package/src/utils/load-addon-functions-meta.ts

@@ -0,0 +1,94 @@
+import { readFile, readdir } from 'fs/promises'
+import { createRequire } from 'module'
+import { join, dirname } from 'path'
+import type { InspectorState, InspectorLogger } from '../types.js'
+
+/**
+ * After the setup sweep discovers wireAddon() declarations, load each addon
+ * package's function metadata so that wiring handlers (channels, HTTP routes,
+ * schedules, etc.) can look up addon function types during the routes sweep.
+ */
+export async function loadAddonFunctionsMeta(
+  logger: InspectorLogger,
+  state: InspectorState
+): Promise<void> {
+  const { wireAddonDeclarations } = state.rpc
+  if (wireAddonDeclarations.size === 0) return
+
+  const require = createRequire(join(state.rootDir, 'package.json'))
+
+  for (const [namespace, decl] of wireAddonDeclarations) {
+    try {
+      const metaPath = require.resolve(
+        `${decl.package}/.pikku/function/pikku-functions-meta.gen.json`
+      )
+      const raw = await readFile(metaPath, 'utf-8')
+      const meta = JSON.parse(raw)
+      state.addonFunctions[namespace] = meta
+      logger.debug(
+        `Loaded ${Object.keys(meta).length} addon functions for '${namespace}' from ${decl.package}`
+      )
+
+      // If wireAddon has mcp: true, expose addon functions with mcp: true as MCP tools
+      if (decl.mcp) {
+        for (const [funcName, funcMeta] of Object.entries<any>(meta)) {
+          if (funcMeta.mcp) {
+            const toolName = `${namespace}:${funcName}`
+            state.mcpEndpoints.toolsMeta[toolName] = {
+              pikkuFuncId: `${namespace}:${funcName}`,
+              name: toolName,
+              description: funcMeta.description || funcMeta.title || funcName,
+              inputSchema: funcMeta.inputSchemaName ?? null,
+              outputSchema: funcMeta.outputSchemaName ?? null,
+              tags: funcMeta.tags,
+            }
+          }
+        }
+      }
+    } catch (error: any) {
+      logger.warn(
+        `Failed to load addon function metadata for '${namespace}' (${decl.package}): ${error.message}`
+      )
+    }
+  }
+}
+
+/**
+ * Load addon schemas into state.schemas. Called after generateAllSchemas
+ * to ensure addon schemas aren't overwritten.
+ */
+export async function loadAddonSchemas(
+  logger: InspectorLogger,
+  state: InspectorState
+): Promise<void> {
+  const { wireAddonDeclarations } = state.rpc
+  if (wireAddonDeclarations.size === 0) return
+
+  const require = createRequire(join(state.rootDir, 'package.json'))
+
+  for (const [namespace, decl] of wireAddonDeclarations) {
+    try {
+      const metaPath = require.resolve(
+        `${decl.package}/.pikku/function/pikku-functions-meta.gen.json`
+      )
+      const schemasDir = join(dirname(metaPath), '..', 'schemas', 'schemas')
+      try {
+        const schemaFiles = await readdir(schemasDir)
+        for (const file of schemaFiles) {
+          if (!file.endsWith('.schema.json')) continue
+          const schemaName = file.replace('.schema.json', '')
+          if (!state.schemas[schemaName]) {
+            const schemaRaw = await readFile(join(schemasDir, file), 'utf-8')
+            state.schemas[schemaName] = JSON.parse(schemaRaw)
+          }
+        }
+      } catch {
+        // No schemas directory — that's fine
+      }
+    } catch (error: any) {
+      logger.warn(
+        `Failed to load addon schemas for '${namespace}' (${decl.package}): ${error.message}`
+      )
+    }
+  }
+}

package/src/utils/post-process.ts

@@ -296,6 +296,31 @@ export function computeResolvedIOTypes(state: InspectorState): void {
     }
 
     state.resolvedIOTypes[pikkuFuncId] = { inputType, outputType }
+
+    if (meta.inputSchemaName && inputType !== 'null') {
+      meta.inputSchemaName = inputType
+    }
+    if (meta.outputSchemaName && outputType !== 'null') {
+      meta.outputSchemaName = outputType
+    }
+    if (meta.inputs) {
+      meta.inputs = meta.inputs.map((name) => {
+        try {
+          return functions.typesMap.getTypeMeta(name).uniqueName
+        } catch {
+          return name
+        }
+      })
+    }
+    if (meta.outputs) {
+      meta.outputs = meta.outputs.map((name) => {
+        try {
+          return functions.typesMap.getTypeMeta(name).uniqueName
+        } catch {
+          return name
+        }
+      })
+    }
   }
 }
 

package/src/utils/resolve-function-meta.ts

@@ -0,0 +1,25 @@
+import type { FunctionMeta, FunctionsMeta } from '@pikku/core'
+
+/**
+ * Look up function metadata by pikkuFuncId, checking both local functions
+ * and addon functions. Addon functions use namespaced IDs like 'namespace:funcName'.
+ */
+export function resolveFunctionMeta(
+  state: {
+    functions: { meta: FunctionsMeta }
+    addonFunctions: Record<string, FunctionsMeta>
+  },
+  pikkuFuncId: string
+): FunctionMeta | undefined {
+  // Check local functions first
+  const local = state.functions.meta[pikkuFuncId]
+  if (local) return local
+
+  // Check addon functions (namespaced like 'swaggerPetstore:addPet')
+  const colonIndex = pikkuFuncId.indexOf(':')
+  if (colonIndex === -1) return undefined
+
+  const namespace = pikkuFuncId.substring(0, colonIndex)
+  const funcName = pikkuFuncId.substring(colonIndex + 1)
+  return state.addonFunctions[namespace]?.[funcName]
+}