@pikku/inspector 0.12.1 → 0.12.3

package/dist/add/add-wire-addon.js

@@ -32,6 +32,7 @@ export function addWireAddon(node, state, logger) {
     let name;
     let pkg;
     let rpcEndpoint;
+    let mcp;
     let secretOverrides;
     let variableOverrides;
     for (const prop of firstArg.properties) {
@@ -47,6 +48,11 @@ export function addWireAddon(node, state, logger) {
         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)) {
             secretOverrides = parseStringRecord(prop.initializer);
@@ -62,6 +68,7 @@ export function addWireAddon(node, state, logger) {
     state.rpc.wireAddonDeclarations.set(name, {
         package: pkg,
         rpcEndpoint,
+        mcp,
         secretOverrides,
         variableOverrides,
     });

package/dist/index.d.ts

@@ -13,4 +13,5 @@ export { serializeMCPJson } from './utils/serialize-mcp-json.js';
 export type { OpenAPISpecInfo } from './utils/serialize-openapi-json.js';
 export { deserializeDslWorkflow, deserializeGraphWorkflow, 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, } from './utils/workflow/graph/index.js';

package/dist/index.js

@@ -7,3 +7,4 @@ export { createEmptyManifest, serializeManifest, } from './utils/contract-hashes
 export { serializeMCPJson } from './utils/serialize-mcp-json.js';
 export { deserializeDslWorkflow, deserializeGraphWorkflow, deserializeAllDslWorkflows, } from './utils/workflow/dsl/index.js';
 export { getFilesAndMethods } from './utils/get-files-and-methods.js';
+export { resolveFunctionMeta } from './utils/resolve-function-meta.js';

package/dist/inspector.js

@@ -11,6 +11,7 @@ import { resolveLatestVersions } from './utils/resolve-versions.js';
 import { finalizeWorkflows } from './utils/workflow/graph/finalize-workflows.js';
 import { finalizeWorkflowHelperTypes, 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, updateManifest, createEmptyManifest, validateContracts, } from './utils/contract-hashes.js';
 /**
  * Creates an initial/empty inspector state with all required properties initialized
@@ -37,6 +38,7 @@ export function getInitialInspectorState(rootDir) {
             typesMap: new TypesMap(),
             meta: {},
             files: new Map(),
+            approvalDescriptions: {},
         },
         http: {
             metaInputTypes: new Map(),
@@ -57,6 +59,10 @@ export function getInitialInspectorState(rootDir) {
             files: new Set(),
             meta: {},
         },
+        gateways: {
+            meta: {},
+            files: new Set(),
+        },
         triggers: {
             meta: {},
             sourceMeta: {},
@@ -167,6 +173,7 @@ export function getInitialInspectorState(rootDir) {
         requiredSchemas: new Set(),
         openAPISpec: null,
         diagnostics: [],
+        addonFunctions: {},
     };
 }
 export const inspect = async (logger, routeFiles, options = {}) => {
@@ -201,6 +208,8 @@ export const inspect = async (logger, routeFiles, options = {}) => {
         ts.forEachChild(sourceFile, (child) => visitSetup(logger, checker, child, state, options));
     }
     logger.debug(`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();
@@ -214,6 +223,8 @@ export const inspect = async (logger, routeFiles, options = {}) => {
             computeContractHashes(state.schemas, state.functions.typesMap, state.functions.meta);
             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/dist/types.d.ts

@@ -1,5 +1,6 @@
 import type * as ts from 'typescript';
 import type { ChannelsMeta } from '@pikku/core/channel';
+import type { GatewaysMeta } from '@pikku/core/gateway';
 import type { HTTPWiringsMeta } from '@pikku/core/http';
 import type { ScheduledTasksMeta } from '@pikku/core/scheduler';
 import type { TriggerMeta, TriggerSourceMeta } from '@pikku/core/trigger';
@@ -72,6 +73,7 @@ export interface InspectorFunctionState {
         path: string;
         exportedName: string;
     }>;
+    approvalDescriptions: Record<string, InspectorApprovalDescriptionDefinition>;
 }
 export interface InspectorChannelState {
     meta: ChannelsMeta;
@@ -107,6 +109,13 @@ export interface InspectorChannelMiddlewareState {
 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;
@@ -262,6 +271,10 @@ export interface InspectorState {
     http: InspectorHTTPState;
     functions: InspectorFunctionState;
     channels: InspectorChannelState;
+    gateways: {
+        meta: GatewaysMeta;
+        files: Set<string>;
+    };
     triggers: {
         meta: TriggerMeta;
         sourceMeta: TriggerSourceMeta;
@@ -304,6 +317,7 @@ export interface InspectorState {
         wireAddonDeclarations: Map<string, {
             package: string;
             rpcEndpoint?: string;
+            mcp?: boolean;
             secretOverrides?: Record<string, string>;
             variableOverrides?: Record<string, string>;
         }>;
@@ -378,4 +392,5 @@ export interface InspectorState {
     requiredSchemas: Set<string>;
     openAPISpec: Record<string, any> | null;
     diagnostics: InspectorDiagnostic[];
+    addonFunctions: Record<string, FunctionsMeta>;
 }

package/dist/utils/load-addon-functions-meta.d.ts

@@ -0,0 +1,12 @@
+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 declare function loadAddonFunctionsMeta(logger: InspectorLogger, state: InspectorState): Promise<void>;
+/**
+ * Load addon schemas into state.schemas. Called after generateAllSchemas
+ * to ensure addon schemas aren't overwritten.
+ */
+export declare function loadAddonSchemas(logger: InspectorLogger, state: InspectorState): Promise<void>;

package/dist/utils/load-addon-functions-meta.js

@@ -0,0 +1,76 @@
+import { readFile, readdir } from 'fs/promises';
+import { createRequire } from 'module';
+import { join, dirname } from 'path';
+/**
+ * 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, state) {
+    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(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) {
+            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, state) {
+    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) {
+            logger.warn(`Failed to load addon schemas for '${namespace}' (${decl.package}): ${error.message}`);
+        }
+    }
+}

package/dist/utils/post-process.js

@@ -217,6 +217,32 @@ export function computeResolvedIOTypes(state) {
             }
         }
         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;
+                }
+            });
+        }
     }
 }
 const serializeGroupMap = (groupMap) => {

package/dist/utils/resolve-function-meta.d.ts

@@ -0,0 +1,11 @@
+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 declare function resolveFunctionMeta(state: {
+    functions: {
+        meta: FunctionsMeta;
+    };
+    addonFunctions: Record<string, FunctionsMeta>;
+}, pikkuFuncId: string): FunctionMeta | undefined;

package/dist/utils/resolve-function-meta.js

@@ -0,0 +1,17 @@
+/**
+ * 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, pikkuFuncId) {
+    // 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];
+}

package/dist/utils/serialize-inspector-state.d.ts

@@ -100,6 +100,7 @@ export interface SerializableInspectorState {
             path: string;
             exportedName: string;
         }]>;
+        approvalDescriptions: InspectorState['functions']['approvalDescriptions'];
     };
     http: {
         metaInputTypes: Array<[
@@ -125,6 +126,10 @@ export interface SerializableInspectorState {
         files: string[];
         meta: InspectorState['channels']['meta'];
     };
+    gateways: {
+        meta: InspectorState['gateways']['meta'];
+        files: string[];
+    };
     triggers: {
         meta: InspectorState['triggers']['meta'];
         sourceMeta: InspectorState['triggers']['sourceMeta'];
@@ -249,6 +254,7 @@ export interface SerializableInspectorState {
     requiredSchemas: string[];
     openAPISpec: Record<string, any> | null;
     diagnostics: InspectorDiagnostic[];
+    addonFunctions: InspectorState['addonFunctions'];
 }
 /**
  * Serializes InspectorState to a JSON-compatible format

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

@@ -32,6 +32,7 @@ export function serializeInspectorState(state) {
             typesMap: serializeTypesMap(state.functions.typesMap),
             meta: state.functions.meta,
             files: Array.from(state.functions.files.entries()),
+            approvalDescriptions: state.functions.approvalDescriptions,
         },
         http: {
             metaInputTypes: Array.from(state.http.metaInputTypes.entries()),
@@ -44,6 +45,10 @@ export function serializeInspectorState(state) {
             files: Array.from(state.channels.files),
             meta: state.channels.meta,
         },
+        gateways: {
+            meta: state.gateways.meta,
+            files: Array.from(state.gateways.files),
+        },
         triggers: {
             meta: state.triggers.meta,
             sourceMeta: state.triggers.sourceMeta,
@@ -133,6 +138,7 @@ export function serializeInspectorState(state) {
         requiredSchemas: Array.from(state.requiredSchemas),
         openAPISpec: state.openAPISpec,
         diagnostics: state.diagnostics,
+        addonFunctions: state.addonFunctions,
     };
 }
 /**
@@ -169,6 +175,7 @@ export function deserializeInspectorState(data) {
             typesMap: deserializeTypesMap(data.functions.typesMap),
             meta: data.functions.meta,
             files: new Map(data.functions.files),
+            approvalDescriptions: data.functions.approvalDescriptions || {},
         },
         http: {
             metaInputTypes: new Map(data.http.metaInputTypes),
@@ -181,6 +188,10 @@ export function deserializeInspectorState(data) {
             files: new Set(data.channels.files),
             meta: data.channels.meta,
         },
+        gateways: {
+            meta: data.gateways?.meta ?? {},
+            files: new Set(data.gateways?.files ?? []),
+        },
         triggers: {
             meta: data.triggers?.meta ?? {},
             sourceMeta: data.triggers?.sourceMeta ?? {},
@@ -280,5 +291,6 @@ export function deserializeInspectorState(data) {
         requiredSchemas: new Set(data.requiredSchemas || []),
         openAPISpec: data.openAPISpec || null,
         diagnostics: data.diagnostics || [],
+        addonFunctions: data.addonFunctions || {},
     };
 }

package/dist/utils/serialize-mcp-json.js

@@ -1,6 +1,7 @@
+import { resolveFunctionMeta } from './resolve-function-meta.js';
 export const serializeMCPJson = (logger, state) => {
     const { mcpEndpoints, functions, schemas } = state;
-    const { meta: functionsMeta, typesMap } = functions;
+    const { typesMap } = functions;
     const { resourcesMeta, toolsMeta, promptsMeta } = mcpEndpoints;
     const tools = [];
     const resources = [];
@@ -19,9 +20,14 @@ export const serializeMCPJson = (logger, state) => {
             ].includes(typeName)) {
             return undefined;
         }
-        const uniqueName = typesMap.getUniqueName(typeName);
-        if (!uniqueName) {
-            return undefined;
+        // Try local typesMap first, fall back to direct schema lookup (for addon types)
+        let uniqueName;
+        try {
+            uniqueName = typesMap.getUniqueName(typeName);
+        }
+        catch {
+            // Type not in local typesMap — try direct schema lookup (addon schemas)
+            uniqueName = typeName;
         }
         const schema = schemas[uniqueName];
         if (!schema) {
@@ -31,7 +37,7 @@ export const serializeMCPJson = (logger, state) => {
         return schema;
     };
     for (const [name, endpointMeta] of Object.entries(resourcesMeta)) {
-        const functionMeta = functionsMeta[endpointMeta.pikkuFuncId];
+        const functionMeta = resolveFunctionMeta(state, endpointMeta.pikkuFuncId);
         if (!functionMeta) {
             logger.warn(`Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping resource ${name}.`);
             continue;
@@ -50,7 +56,7 @@ export const serializeMCPJson = (logger, state) => {
         });
     }
     for (const [name, endpointMeta] of Object.entries(toolsMeta)) {
-        const functionMeta = functionsMeta[endpointMeta.pikkuFuncId];
+        const functionMeta = resolveFunctionMeta(state, endpointMeta.pikkuFuncId);
         if (!functionMeta) {
             logger.warn(`Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping tool ${name}.`);
             continue;
@@ -68,7 +74,7 @@ export const serializeMCPJson = (logger, state) => {
         });
     }
     for (const [name, endpointMeta] of Object.entries(promptsMeta)) {
-        const functionMeta = functionsMeta[endpointMeta.pikkuFuncId];
+        const functionMeta = resolveFunctionMeta(state, endpointMeta.pikkuFuncId);
         if (!functionMeta) {
             logger.warn(`Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping prompt ${name}.`);
             continue;

package/dist/visit.js

@@ -11,6 +11,7 @@ import { addMCPResource } from './add/add-mcp-resource.js';
 import { addMCPPrompt } from './add/add-mcp-prompt.js';
 import { addFunctions } from './add/add-functions.js';
 import { addChannel } from './add/add-channel.js';
+import { addGateway } from './add/add-gateway.js';
 import { addRPCInvocations } from './add/add-rpc-invocations.js';
 import { addWireAddon } from './add/add-wire-addon.js';
 import { addMiddleware } from './add/add-middleware.js';
@@ -20,6 +21,7 @@ import { addSecret, addOAuth2Credential } from './add/add-secret.js';
 import { addVariable } from './add/add-variable.js';
 import { addWorkflowGraph } from './add/add-workflow-graph.js';
 import { addAIAgent } from './add/add-ai-agent.js';
+import { addApprovalDescription } from './add/add-approval-description.js';
 export const visitSetup = (logger, checker, node, state, options) => {
     addFileExtendsCoreType(node, checker, state.singletonServicesTypeImportMap, 'CoreSingletonServices', state);
     addFileExtendsCoreType(node, checker, state.wireServicesTypeImportMap, 'CoreServices', state);
@@ -32,6 +34,7 @@ export const visitSetup = (logger, checker, node, state, options) => {
     addWireAddon(node, state, logger);
     addMiddleware(logger, node, checker, state, options);
     addPermission(logger, node, checker, state, options);
+    addApprovalDescription(logger, node, checker, state, options);
     addWorkflow(logger, node, checker, state, options);
     ts.forEachChild(node, (child) => visitSetup(logger, checker, child, state, options));
 };
@@ -46,6 +49,7 @@ export const visitRoutes = (logger, checker, node, state, options) => {
     addTrigger(logger, node, checker, state, options);
     addQueueWorker(logger, node, checker, state, options);
     addChannel(logger, node, checker, state, options);
+    addGateway(logger, node, checker, state, options);
     addCLI(logger, node, checker, state, options);
     addCLIRenderers(logger, node, checker, state, options);
     addMCPResource(logger, node, checker, state, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.1",
+  "version": "0.12.3",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
   "type": "module",
@@ -34,7 +34,7 @@
   },
   "dependencies": {
     "@openapi-contrib/json-schema-to-openapi-schema": "^4.3.1",
-    "@pikku/core": "^0.12.1",
+    "@pikku/core": "^0.12.3",
     "path-to-regexp": "^8.3.0",
     "ts-json-schema-generator": "^2.5.0",
     "tsx": "^4.21.0",
@@ -43,7 +43,7 @@
     "zod-to-ts": "^2.0.0"
   },
   "devDependencies": {
-    "@types/node": "^24.10.12"
+    "@types/node": "^24.11.0"
   },
   "engines": {
     "node": ">=18"

package/src/add/add-ai-agent.ts

@@ -268,6 +268,9 @@ export const addAIAgent: AddWiring = (
       | number
       | null
     const toolChoiceValue = getPropertyValue(obj, 'toolChoice') as string | null
+    const dynamicWorkflowsValue = getPropertyValue(obj, 'dynamicWorkflows') as
+      | string
+      | null
     const toolsValue = resolveToolReferences(
       obj,
       checker,
@@ -455,6 +458,9 @@ export const addAIAgent: AddWiring = (
       }),
       ...(toolsValue !== null && { tools: toolsValue }),
       ...(agentsValue !== null && { agents: agentsValue }),
+      ...(dynamicWorkflowsValue !== null && {
+        dynamicWorkflows: dynamicWorkflowsValue as 'read' | 'always' | 'ask',
+      }),
       tags,
       inputSchema,
       outputSchema,

package/src/add/add-approval-description.ts

@@ -0,0 +1,76 @@
+import * as ts from 'typescript'
+import type { AddWiring } from '../types.js'
+import { extractFunctionName } from '../utils/extract-function-name.js'
+import {
+  extractServicesFromFunction,
+  extractUsedWires,
+} from '../utils/extract-services.js'
+
+/**
+ * Inspect pikkuApprovalDescription() calls and extract metadata
+ */
+export const addApprovalDescription: AddWiring = (
+  logger,
+  node,
+  checker,
+  state
+) => {
+  if (!ts.isCallExpression(node)) return
+
+  const { expression, arguments: args } = node
+
+  if (!ts.isIdentifier(expression)) return
+  if (expression.text !== 'pikkuApprovalDescription') return
+
+  const arg = args[0]
+  if (!arg) return
+
+  let actualHandler: ts.ArrowFunction | ts.FunctionExpression
+
+  if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
+    actualHandler = arg
+  } else {
+    logger.error(`• Handler for pikkuApprovalDescription is not a function.`)
+    return
+  }
+
+  const services = extractServicesFromFunction(actualHandler)
+  const wires = extractUsedWires(actualHandler, 1)
+  let { pikkuFuncId, exportedName } = extractFunctionName(
+    node,
+    checker,
+    state.rootDir
+  )
+
+  if (pikkuFuncId.startsWith('__temp_')) {
+    if (
+      ts.isVariableDeclaration(node.parent) &&
+      ts.isIdentifier(node.parent.name)
+    ) {
+      pikkuFuncId = node.parent.name.text
+    } else if (
+      ts.isPropertyAssignment(node.parent) &&
+      ts.isIdentifier(node.parent.name)
+    ) {
+      pikkuFuncId = node.parent.name.text
+    } else {
+      logger.error(
+        `• pikkuApprovalDescription() must be assigned to a variable or object property. ` +
+          `Extract it to a const: const myApproval = pikkuApprovalDescription(...)`
+      )
+      return
+    }
+  }
+
+  state.functions.approvalDescriptions[pikkuFuncId] = {
+    services,
+    wires: wires.wires.length > 0 || !wires.optimized ? wires : undefined,
+    sourceFile: node.getSourceFile().fileName,
+    position: node.getStart(),
+    exportedName,
+  }
+
+  logger.debug(
+    `• Found approval description '${pikkuFuncId}' with services: ${services.services.join(', ')}`
+  )
+}