@pikku/core 0.12.14 → 0.12.16

package/dist/services/meta-service.js

@@ -0,0 +1,310 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+/**
+ * Node.js filesystem implementation of MetaService.
+ * Reads .gen.json files from a local .pikku directory.
+ */
+export class LocalMetaService {
+    basePath;
+    httpMetaCache = null;
+    channelsMetaCache = null;
+    schedulerMetaCache = null;
+    queueMetaCache = null;
+    cliMetaCache = null;
+    mcpMetaCache = null;
+    rpcMetaCache = null;
+    workflowMetaCache = null;
+    triggerMetaCache = null;
+    triggerSourceMetaCache = null;
+    functionsMetaCache = null;
+    servicesMetaCache = null;
+    secretsMetaCache = null;
+    credentialsMetaCache = null;
+    variablesMetaCache = null;
+    middlewareGroupsMetaCache = null;
+    permissionsGroupsMetaCache = null;
+    agentsMetaCache = null;
+    schemaCache = new Map();
+    constructor(basePath) {
+        this.basePath = basePath;
+    }
+    async readFile(relativePath) {
+        try {
+            return await readFile(join(this.basePath, relativePath), 'utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
+    async readDir(relativePath) {
+        try {
+            return await readdir(join(this.basePath, relativePath));
+        }
+        catch {
+            return [];
+        }
+    }
+    clearCache() {
+        this.httpMetaCache = null;
+        this.channelsMetaCache = null;
+        this.schedulerMetaCache = null;
+        this.queueMetaCache = null;
+        this.cliMetaCache = null;
+        this.mcpMetaCache = null;
+        this.rpcMetaCache = null;
+        this.workflowMetaCache = null;
+        this.triggerMetaCache = null;
+        this.triggerSourceMetaCache = null;
+        this.functionsMetaCache = null;
+        this.servicesMetaCache = null;
+        this.secretsMetaCache = null;
+        this.credentialsMetaCache = null;
+        this.variablesMetaCache = null;
+        this.middlewareGroupsMetaCache = null;
+        this.permissionsGroupsMetaCache = null;
+        this.agentsMetaCache = null;
+        this.schemaCache.clear();
+    }
+    // -- Private helpers --
+    async readMetaJson(dir, baseName) {
+        const verbose = await this.readFile(`${dir}/${baseName}-verbose.gen.json`);
+        if (verbose)
+            return verbose;
+        const minimal = await this.readFile(`${dir}/${baseName}.gen.json`);
+        if (minimal)
+            return minimal;
+        return null;
+    }
+    // -- Typed metadata accessors --
+    async getHttpMeta() {
+        if (this.httpMetaCache)
+            return this.httpMetaCache;
+        const content = await this.readMetaJson('http', 'pikku-http-wirings-meta');
+        this.httpMetaCache = content
+            ? JSON.parse(content)
+            : {
+                get: {},
+                post: {},
+                put: {},
+                delete: {},
+                patch: {},
+                head: {},
+                options: {},
+            };
+        return this.httpMetaCache;
+    }
+    async getChannelsMeta() {
+        if (this.channelsMetaCache)
+            return this.channelsMetaCache;
+        const content = await this.readMetaJson('channel', 'pikku-channels-meta');
+        this.channelsMetaCache = content ? JSON.parse(content) : {};
+        return this.channelsMetaCache;
+    }
+    async getSchedulerMeta() {
+        if (this.schedulerMetaCache)
+            return this.schedulerMetaCache;
+        const content = await this.readMetaJson('scheduler', 'pikku-schedulers-wirings-meta');
+        this.schedulerMetaCache = content ? JSON.parse(content) : {};
+        return this.schedulerMetaCache;
+    }
+    async getQueueMeta() {
+        if (this.queueMetaCache)
+            return this.queueMetaCache;
+        const content = await this.readMetaJson('queue', 'pikku-queue-workers-wirings-meta');
+        this.queueMetaCache = content ? JSON.parse(content) : {};
+        return this.queueMetaCache;
+    }
+    async getCliMeta() {
+        if (this.cliMetaCache)
+            return this.cliMetaCache;
+        const content = await this.readMetaJson('cli', 'pikku-cli-wirings-meta');
+        this.cliMetaCache = content
+            ? JSON.parse(content)
+            : { programs: {}, renderers: {} };
+        return this.cliMetaCache;
+    }
+    async getMcpMeta() {
+        if (this.mcpMetaCache)
+            return this.mcpMetaCache;
+        const content = await this.readMetaJson('mcp', 'pikku-mcp-wirings-meta');
+        if (content) {
+            const mcpData = JSON.parse(content);
+            this.mcpMetaCache = {
+                resources: mcpData.resourcesMeta || {},
+                tools: mcpData.toolsMeta || {},
+                prompts: mcpData.promptsMeta || {},
+            };
+        }
+        else {
+            this.mcpMetaCache = { resources: {}, tools: {}, prompts: {} };
+        }
+        return this.mcpMetaCache;
+    }
+    async getRpcMeta() {
+        if (this.rpcMetaCache)
+            return this.rpcMetaCache;
+        try {
+            const content = await this.readFile('rpc/pikku-rpc-wirings-meta.gen.json');
+            this.rpcMetaCache = content ? JSON.parse(content) : {};
+            return this.rpcMetaCache;
+        }
+        catch (error) {
+            console.error('Error reading RPC wirings metadata:', error);
+            this.rpcMetaCache = {};
+            return this.rpcMetaCache;
+        }
+    }
+    async getWorkflowMeta() {
+        if (this.workflowMetaCache)
+            return this.workflowMetaCache;
+        try {
+            const files = await this.readDir('workflow/meta');
+            const jsonFiles = files.filter((f) => f.endsWith('.gen.json'));
+            const verboseFiles = jsonFiles.filter((f) => f.includes('-verbose'));
+            const minimalFiles = jsonFiles.filter((f) => !f.includes('-verbose'));
+            const verboseNames = new Set(verboseFiles.map((f) => f.replace('-verbose.gen.json', '')));
+            const filesToRead = [
+                ...verboseFiles,
+                ...minimalFiles.filter((f) => !verboseNames.has(f.replace('.gen.json', ''))),
+            ];
+            const result = {};
+            await Promise.all(filesToRead.map(async (file) => {
+                const content = await this.readFile(`workflow/meta/${file}`);
+                if (content) {
+                    const meta = JSON.parse(content);
+                    result[meta.name] = meta;
+                }
+            }));
+            this.workflowMetaCache = result;
+            return this.workflowMetaCache;
+        }
+        catch (error) {
+            console.error('Error reading Workflow wirings metadata:', error);
+            this.workflowMetaCache = {};
+            return this.workflowMetaCache;
+        }
+    }
+    async getTriggerMeta() {
+        if (this.triggerMetaCache)
+            return this.triggerMetaCache;
+        const content = await this.readMetaJson('trigger', 'pikku-trigger-wirings-meta');
+        this.triggerMetaCache = content ? JSON.parse(content) : {};
+        return this.triggerMetaCache;
+    }
+    async getTriggerSourceMeta() {
+        if (this.triggerSourceMetaCache)
+            return this.triggerSourceMetaCache;
+        const content = await this.readMetaJson('trigger', 'pikku-trigger-sources-meta');
+        this.triggerSourceMetaCache = content ? JSON.parse(content) : {};
+        return this.triggerSourceMetaCache;
+    }
+    async getFunctionsMeta() {
+        if (this.functionsMetaCache)
+            return this.functionsMetaCache;
+        const content = await this.readMetaJson('function', 'pikku-functions-meta');
+        this.functionsMetaCache = content ? JSON.parse(content) : {};
+        return this.functionsMetaCache;
+    }
+    async getMiddlewareGroupsMeta() {
+        if (this.middlewareGroupsMetaCache)
+            return this.middlewareGroupsMetaCache;
+        const content = await this.readMetaJson('middleware', 'pikku-middleware-groups-meta');
+        this.middlewareGroupsMetaCache = content
+            ? JSON.parse(content)
+            : { definitions: {}, instances: {}, httpGroups: {}, tagGroups: {} };
+        return this.middlewareGroupsMetaCache;
+    }
+    async getPermissionsGroupsMeta() {
+        if (this.permissionsGroupsMetaCache)
+            return this.permissionsGroupsMetaCache;
+        const content = await this.readMetaJson('permissions', 'pikku-permissions-groups-meta');
+        this.permissionsGroupsMetaCache = content
+            ? JSON.parse(content)
+            : { definitions: {}, httpGroups: {}, tagGroups: {} };
+        return this.permissionsGroupsMetaCache;
+    }
+    async getAgentsMeta() {
+        if (this.agentsMetaCache)
+            return this.agentsMetaCache;
+        const content = await this.readMetaJson('agent', 'pikku-agent-wirings-meta');
+        if (content) {
+            const parsed = JSON.parse(content);
+            this.agentsMetaCache = parsed.agentsMeta || parsed;
+        }
+        else {
+            this.agentsMetaCache = {};
+        }
+        return this.agentsMetaCache;
+    }
+    async getSecretsMeta() {
+        if (this.secretsMetaCache)
+            return this.secretsMetaCache;
+        const content = await this.readFile('secrets/pikku-secrets-meta.gen.json');
+        this.secretsMetaCache = content ? JSON.parse(content) : {};
+        return this.secretsMetaCache;
+    }
+    async getCredentialsMeta() {
+        if (this.credentialsMetaCache)
+            return this.credentialsMetaCache;
+        const content = await this.readFile('credentials/pikku-credentials-meta.gen.json');
+        this.credentialsMetaCache = content ? JSON.parse(content) : {};
+        return this.credentialsMetaCache;
+    }
+    async getVariablesMeta() {
+        if (this.variablesMetaCache)
+            return this.variablesMetaCache;
+        const content = await this.readFile('variables/pikku-variables-meta.gen.json');
+        this.variablesMetaCache = content ? JSON.parse(content) : {};
+        return this.variablesMetaCache;
+    }
+    async getServicesMeta() {
+        if (this.servicesMetaCache)
+            return this.servicesMetaCache;
+        try {
+            const files = await this.readDir('services');
+            const jsonFiles = files.filter((f) => f.endsWith('.gen.json'));
+            const result = {};
+            await Promise.all(jsonFiles.map(async (file) => {
+                const content = await this.readFile(`services/${file}`);
+                if (content) {
+                    const meta = JSON.parse(content);
+                    result[meta.name] = meta;
+                }
+            }));
+            this.servicesMetaCache = result;
+            return this.servicesMetaCache;
+        }
+        catch (error) {
+            console.error('Error reading Services metadata:', error);
+            this.servicesMetaCache = {};
+            return this.servicesMetaCache;
+        }
+    }
+    async getSchema(schemaName) {
+        if (this.schemaCache.has(schemaName)) {
+            return this.schemaCache.get(schemaName);
+        }
+        if (!/^[a-zA-Z0-9_\-\.]+$/.test(schemaName)) {
+            return null;
+        }
+        try {
+            const content = await this.readFile(`schemas/schemas/${schemaName}.schema.json`);
+            if (!content)
+                return null;
+            const schema = JSON.parse(content);
+            this.schemaCache.set(schemaName, schema);
+            return schema;
+        }
+        catch (error) {
+            console.error(`Error reading schema ${schemaName}:`, error);
+            return null;
+        }
+    }
+    async getSchemas(schemaNames) {
+        const results = {};
+        await Promise.all(schemaNames.map(async (name) => {
+            results[name] = await this.getSchema(name);
+        }));
+        return results;
+    }
+}

package/dist/services/workflow-service.d.ts

@@ -1,5 +1,5 @@
 import type { SerializedError } from '../types/core.types.js';
-import type { WorkflowRun, WorkflowRunWire, StepState, WorkflowStatus, WorkflowVersionStatus } from '../wirings/workflow/workflow.types.js';
+import type { WorkflowRun, WorkflowRunWire, WorkflowRunStatus, StepState, WorkflowStatus, WorkflowVersionStatus } from '../wirings/workflow/workflow.types.js';
 /**
  * Interface for workflow orchestration
  * Handles workflow execution, replay, orchestration logic, and run-level state
@@ -7,6 +7,7 @@ import type { WorkflowRun, WorkflowRunWire, StepState, WorkflowStatus, WorkflowV
 export interface WorkflowService {
     createRun(workflowName: string, input: any, inline: boolean, graphHash: string, wire: WorkflowRunWire): Promise<string>;
     getRun(id: string): Promise<WorkflowRun | null>;
+    getRunStatus(id: string): Promise<WorkflowRunStatus | null>;
     getRunHistory(runId: string): Promise<Array<StepState & {
         stepName: string;
     }>>;
@@ -20,6 +21,10 @@ export interface WorkflowService {
     }): Promise<{
         runId: string;
     }>;
+    runToCompletion<I>(name: string, input: I, rpcService: any, options?: {
+        pollIntervalMs?: number;
+        wire?: WorkflowRunWire;
+    }): Promise<unknown>;
     runWorkflowJob(runId: string, rpcService: any): Promise<void>;
     orchestrateWorkflow(runId: string, rpcService: any): Promise<void>;
     executeWorkflowSleepCompleted(runId: string, stepId: string): Promise<void>;

package/dist/testing/service-tests.js

@@ -482,14 +482,6 @@ export function defineServiceTests(config) {
                     endpoint: 'http://localhost:3000',
                     functions: ['funcA', 'funcB'],
                 });
-                const infos = await service.findFunction('funcA');
-                assert.ok(infos.length >= 1);
-                assert.equal(infos[0].deploymentId, 'deploy-1');
-                assert.equal(infos[0].endpoint, 'http://localhost:3000');
-            });
-            test('findFunction returns empty for unknown function', async () => {
-                const infos = await service.findFunction('unknown-func');
-                assert.deepEqual(infos, []);
             });
         });
     }

package/dist/types/core.types.d.ts

@@ -24,6 +24,7 @@ import type { AgentRunService } from '../wirings/ai-agent/ai-agent.types.js';
 import type { PikkuAIMiddlewareHooks } from '../wirings/ai-agent/ai-agent.types.js';
 import type { WorkflowRunService } from '../wirings/workflow/workflow.types.js';
 import type { CredentialService } from '../services/credential-service.js';
+import type { MetaService } from '../services/meta-service.js';
 export type PikkuWiringTypes = 'http' | 'scheduler' | 'trigger' | 'channel' | 'rpc' | 'queue' | 'mcp' | 'cli' | 'workflow' | 'agent' | 'gateway';
 export interface FunctionServicesMeta {
     optimized: boolean;
@@ -75,6 +76,7 @@ export type FunctionRuntimeMeta = {
     remote?: boolean;
     mcp?: boolean;
     readonly?: boolean;
+    deploy?: 'serverless' | 'server' | 'auto';
     sessionless?: boolean;
     version?: number;
     approvalRequired?: boolean;
@@ -94,6 +96,8 @@ export type FunctionMeta = FunctionRuntimeMeta & Partial<{
     middleware: MiddlewareMetadata[];
     permissions: PermissionMetadata[];
     isDirectFunction: boolean;
+    sourceFile: string;
+    exportedName: string;
 } & CommonWireMeta>;
 export type FunctionsRuntimeMeta = Record<string, FunctionRuntimeMeta>;
 export type FunctionsMeta = Record<string, FunctionMeta>;
@@ -175,6 +179,8 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
     workflowRunService?: WorkflowRunService;
     /** Credential service for dynamic/managed credentials (OAuth tokens, per-user API keys) */
     credentialService?: CredentialService;
+    /** Meta service for reading .pikku metadata files (filesystem on Node, R2/KV on CF) */
+    metaService?: MetaService;
 }
 /**
  * Represents different forms of wire within Pikku and the outside world.
@@ -182,6 +188,8 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
 export type PikkuWire<In = unknown, Out = unknown, HasInitialSession extends boolean = false, UserSession extends CoreUserSession = CoreUserSession, TypedRPC extends PikkuRPC = PikkuRPC, IsChannel extends true | null = null, MCPTools extends string | never = never, TypedWorkflow extends PikkuWorkflowWire | never = PikkuWorkflowWire, TriggerOutput = unknown> = Partial<{
     wireType: PikkuWiringTypes;
     wireId: string;
+    /** Trace ID for distributed tracing — propagated across remote RPC calls via x-trace-id header */
+    traceId: string;
     http: PikkuHTTP<In>;
     mcp: PikkuMCP<MCPTools>;
     rpc: TypedRPC;
@@ -216,6 +224,17 @@ export type PikkuWire<In = unknown, Out = unknown, HasInitialSession extends boo
  * A function that can wrap an wire and be called before or after
  */
 export type CorePikkuMiddleware<SingletonServices extends CoreSingletonServices = CoreSingletonServices, UserSession extends CoreUserSession = CoreUserSession> = (services: SingletonServices, wires: PikkuWire<unknown, unknown, false, UserSession>, next: () => Promise<void>) => Promise<void>;
+/**
+ * Priority levels for middleware execution order.
+ * Lower priority runs first (outermost in the onion model).
+ *
+ * - `highest` — Runs first (outermost). Use for telemetry, request tracing.
+ * - `high` — Runs early. Use for CORS, rate limiting.
+ * - `medium` — Default. Use for auth, most user middleware.
+ * - `low` — Runs late. Use for post-auth processing.
+ * - `lowest` — Runs last (innermost, closest to function). Use for inner telemetry.
+ */
+export type MiddlewarePriority = 'highest' | 'high' | 'medium' | 'low' | 'lowest';
 /**
  * Configuration object for creating middleware with metadata
  *
@@ -229,6 +248,8 @@ export type CorePikkuMiddlewareConfig<SingletonServices extends CoreSingletonSer
     name?: string;
     /** Optional description of what the middleware does */
     description?: string;
+    /** Execution priority. Lower runs first (outermost). Defaults to 'medium'. */
+    priority?: MiddlewarePriority;
 };
 /**
  * A factory function that takes input and returns middleware

package/dist/types/core.types.js

@@ -24,7 +24,13 @@
  * ```
  */
 export const pikkuMiddleware = (middleware) => {
-    return typeof middleware === 'function' ? middleware : middleware.func;
+    if (typeof middleware === 'function')
+        return middleware;
+    const func = middleware.func;
+    if (middleware.priority) {
+        func.__priority = middleware.priority;
+    }
+    return func;
 };
 /**
  * Factory function for creating middleware factories

package/dist/types/state.types.d.ts

@@ -130,8 +130,6 @@ export interface PikkuPackageState {
         } | null;
         /** Cached singleton services for this package */
         singletonServices: CoreSingletonServices | null;
-        /** Absolute path to this package's .pikku directory */
-        metaDir: string | null;
         /** Credential metadata for this addon package */
         credentialsMeta: Record<string, {
             name: string;
@@ -139,5 +137,7 @@ export interface PikkuPackageState {
             type: string;
             oauth2?: boolean;
         }> | null;
+        /** Services this addon needs from the parent project */
+        requiredParentServices: string[] | null;
     };
 }

package/dist/wirings/ai-agent/ai-agent-prepare.js

@@ -1,4 +1,5 @@
 import { PikkuError } from '../../errors/error-handler.js';
+import { checkAuthPermissions } from '../../permissions.js';
 import { AIProviderNotConfiguredError } from '../../errors/errors.js';
 import { pikkuState, getSingletonServices } from '../../pikku-state.js';
 import { createMiddlewareSessionWireProps } from '../../services/user-session-service.js';
@@ -6,7 +7,6 @@ import { randomUUID } from 'crypto';
 import { streamAIAgent } from './ai-agent-stream.js';
 import { runAIAgent } from './ai-agent-runner.js';
 import { resolveNamespace, ContextAwareRPCService, } from '../../wirings/rpc/rpc-runner.js';
-import { buildDynamicWorkflowInstructions, buildWorkflowTools, } from './agent-dynamic-workflow.js';
 import { resolveMemoryServices, loadContextMessages, trimMessages, } from './ai-agent-memory.js';
 import { resolveModelConfig } from './ai-agent-model-config.js';
 export class ToolApprovalRequired extends PikkuError {
@@ -75,6 +75,10 @@ export function getAddonCredentialRequirements(toolNames) {
     return [...requirements.values()];
 }
 export const resolveAgent = (agentName) => {
+    if (!agentName) {
+        console.error('[resolveAgent] agentName is undefined/null! Stack:', new Error().stack);
+        throw new Error('resolveAgent called with undefined agentName');
+    }
     const mainAgent = pikkuState(null, 'agent', 'agents').get(agentName);
     if (mainAgent) {
         return { agent: mainAgent, packageName: null, resolvedName: agentName };
@@ -100,10 +104,23 @@ export const resolveAgent = (agentName) => {
 };
 export async function buildInstructions(agentName, packageName) {
     const meta = pikkuState(packageName, 'agent', 'agentsMeta')[agentName];
-    const rawInstructions = meta?.instructions ?? '';
-    let instructions = Array.isArray(rawInstructions)
-        ? rawInstructions.join('\n')
-        : rawInstructions;
+    const parts = [];
+    if (meta?.role)
+        parts.push(meta.role);
+    if (meta?.personality)
+        parts.push(meta.personality);
+    if (meta?.goal)
+        parts.push(meta.goal);
+    let instructions = parts.join('\n\n');
+    if (meta?.tools?.length) {
+        instructions +=
+            '\n\nTool usage rules:\n' +
+                '- Act immediately with the information given. Do NOT ask clarifying questions unless a required field is truly missing.\n' +
+                '- Only use fields defined in your tool schemas. Never mention or ask for fields that do not exist.\n' +
+                '- Never fill optional fields with placeholder or zero values. Omit them entirely unless the user provides a real value.\n' +
+                '- Never stuff unrelated information into the wrong field.\n' +
+                '- Keep responses concise.';
+    }
     if (meta?.agents?.length) {
         instructions +=
             '\n\nWhen calling a sub-agent, provide a short session name that describes the task. ' +
@@ -111,9 +128,6 @@ export async function buildInstructions(agentName, packageName) {
                 'Use a new session name for a new independent task. ' +
                 'When a request involves multiple actions for the same domain, combine them into a single sub-agent call rather than making separate calls.';
     }
-    if (meta?.dynamicWorkflows && meta.tools?.length) {
-        instructions += buildDynamicWorkflowInstructions(meta.tools, meta.dynamicWorkflows);
-    }
     return instructions;
 }
 export function createScopedChannel(parent, agentName, session) {
@@ -165,6 +179,10 @@ export async function buildToolDefs(params, agentSessionMap, resourceId, agentNa
     const meta = pikkuState(packageName, 'agent', 'agentsMeta')[agentName];
     if (!meta)
         return { tools, missingRpcs };
+    // Get session for permission filtering
+    const session = params.sessionService
+        ? await params.sessionService.get()
+        : null;
     const metaTools = meta.tools;
     const metaAgents = meta.agents;
     if (metaTools?.length) {
@@ -196,6 +214,14 @@ export async function buildToolDefs(params, agentSessionMap, resourceId, agentNa
                 missingRpcs.push(toolName);
                 continue;
             }
+            // Filter out tools the user doesn't have auth for
+            if (fnMeta.permissions?.length) {
+                if (!session)
+                    continue;
+                const allowed = await checkAuthPermissions(fnMeta.permissions, session, singletonServices, resolvedPkg);
+                if (!allowed)
+                    continue;
+            }
             const inputSchemaName = fnMeta?.inputSchemaName;
             let inputSchema = inputSchemaName
                 ? schemas.get(inputSchemaName)
@@ -251,6 +277,14 @@ export async function buildToolDefs(params, agentSessionMap, resourceId, agentNa
                 singletonServices.logger.warn(`Sub-agent '${subAgentName}' not found in agent registry`);
                 continue;
             }
+            // Filter out sub-agents the user doesn't have auth for
+            if (subMeta.permissions?.length) {
+                if (!session)
+                    continue;
+                const allowed = await checkAuthPermissions(subMeta.permissions, session, singletonServices);
+                if (!allowed)
+                    continue;
+            }
             tools.push({
                 name: subAgentName,
                 description: subMeta.description,
@@ -339,10 +373,6 @@ export async function buildToolDefs(params, agentSessionMap, resourceId, agentNa
             });
         }
     }
-    if (meta.dynamicWorkflows) {
-        const workflowTools = buildWorkflowTools(agentName, packageName, meta.tools ?? [], meta.dynamicWorkflows, streamContext, params.sessionService);
-        tools.push(...workflowTools);
-    }
     const hasToolHooks = aiMiddlewares?.some((mw) => mw.beforeToolCall || mw.afterToolCall);
     if (hasToolHooks) {
         for (const tool of tools) {
@@ -405,15 +435,6 @@ export async function prepareAgentRun(agentName, input, params, agentSessionMap,
     if (!agentRunner) {
         throw new AIProviderNotConfiguredError();
     }
-    if (agent.dynamicWorkflows && singletonServices.workflowService) {
-        const persisted = await singletonServices.workflowService.getAIGeneratedWorkflows(resolvedName);
-        const allMeta = pikkuState(null, 'workflows', 'meta');
-        for (const wf of persisted) {
-            if (!allMeta[wf.workflowName]) {
-                allMeta[wf.workflowName] = wf.graph;
-            }
-        }
-    }
     const { storage } = resolveMemoryServices(agent, singletonServices);
     const memoryConfig = agent.memory;
     const threadId = input.threadId;

package/dist/wirings/ai-agent/ai-agent-registry.js

@@ -1,10 +1,10 @@
 import { pikkuState } from '../../pikku-state.js';
-import { PikkuMissingMetaError } from '../../errors/errors.js';
 export const addAIAgent = (agentName, agent, packageName = null) => {
     const agentsMeta = pikkuState(packageName, 'agent', 'agentsMeta');
     const agentMeta = agentsMeta[agentName];
     if (!agentMeta) {
-        throw new PikkuMissingMetaError(`Missing generated metadata for AI agent '${agentName}'`);
+        console.warn(`[pikku] Skipping AI agent '${agentName}' — metadata not found. Consider moving this wiring to its own file.`);
+        return;
     }
     const agents = pikkuState(packageName, 'agent', 'agents');
     if (agents.has(agentName)) {

package/dist/wirings/ai-agent/ai-agent-runner.js

@@ -4,6 +4,21 @@ import { checkForApprovals, appendStepMessages } from './ai-agent-stream.js';
 import { pikkuState, getSingletonServices } from '../../pikku-state.js';
 import { resolveModelConfig } from './ai-agent-model-config.js';
 import { AIProviderNotConfiguredError } from '../../errors/errors.js';
+function stripNulls(obj) {
+    if (obj === null)
+        return undefined;
+    if (Array.isArray(obj))
+        return obj.map(stripNulls);
+    if (typeof obj !== 'object')
+        return obj;
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value !== null) {
+            result[key] = stripNulls(value);
+        }
+    }
+    return result;
+}
 import { randomUUID } from 'crypto';
 export async function runAIAgent(agentName, input, params, agentSessionMap) {
     const sessionMap = agentSessionMap ?? new Map();
@@ -287,9 +302,11 @@ export async function resumeAIAgentSync(runId, approvals, params, expectedAgentN
             if (!matchingTool) {
                 throw new Error(`Tool "${pending.toolName}" not found in agent definition`);
             }
-            const toolArgs = typeof pending.args === 'string'
+            const rawArgs = typeof pending.args === 'string'
                 ? JSON.parse(pending.args)
                 : pending.args;
+            // Strip null values recursively — LLMs send null for optional fields but Zod expects undefined
+            const toolArgs = stripNulls(rawArgs) ?? {};
             try {
                 const toolResult = await matchingTool.execute(toolArgs);
                 resultStr =

package/dist/wirings/ai-agent/ai-agent-stream.js

@@ -733,6 +733,7 @@ async function continueAfterToolResult(run, agent, packageName, resolvedName, st
     const streamContext = { channel, options };
     const resumeTools = (await buildToolDefs(params, new Map(), run.resourceId, resolvedName, packageName, streamContext, aiMiddlewares)).tools;
     const resolved = resolveModelConfig(resolvedName, agent);
+    console.log('[DEBUG resume] resolvedName:', resolvedName, 'agent.model:', agent.model, 'resolved.model:', resolved.model);
     const maxSteps = resolved.maxSteps ?? 10;
     const runnerParams = {
         model: resolved.model,

package/dist/wirings/ai-agent/ai-agent.types.d.ts

@@ -183,7 +183,9 @@ export type CoreAIAgent<PikkuPermission = CorePikkuPermission<any, any>, PikkuMi
     description: string;
     summary?: string;
     errors?: string[];
-    instructions: string | string[];
+    role?: string;
+    personality?: string;
+    goal: string;
     model: string;
     temperature?: number;
     tools?: unknown[];
@@ -192,7 +194,6 @@ export type CoreAIAgent<PikkuPermission = CorePikkuPermission<any, any>, PikkuMi
     memory?: AIAgentMemoryConfig;
     maxSteps?: number;
     toolChoice?: 'auto' | 'required' | 'none';
-    dynamicWorkflows?: 'read' | 'always' | 'ask';
     input?: unknown;
     output?: unknown;
     tags?: string[];
@@ -382,5 +383,6 @@ export type AIAgentMeta = Record<string, Omit<CoreAIAgent, 'input' | 'output' |
     channelMiddleware?: MiddlewareMetadata[];
     aiMiddleware?: MiddlewareMetadata[];
     permissions?: PermissionMetadata[];
-    dynamicWorkflows?: 'read' | 'always' | 'ask';
+    sourceFile?: string;
+    exportedName?: string;
 }>;