@pikku/core 0.12.14 → 0.12.15

package/dist/wirings/workflow/pikku-workflow-service.js

@@ -1,6 +1,33 @@
-import { runPikkuFunc } from '../../function/function-runner.js';
+import { runPikkuFunc, addFunction } from '../../function/function-runner.js';
+import { pikkuWorkflowWorkerFunc, pikkuWorkflowOrchestratorFunc, pikkuWorkflowSleeperFunc, } from './workflow-queue-workers.js';
+import { wireQueueWorker } from '../queue/queue-runner.js';
 import { getSingletonServices, getCreateWireServices, pikkuState, } from '../../pikku-state.js';
 import { getDurationInMilliseconds } from '../../time-utils.js';
+const resolveWorkflowMeta = (name) => {
+    const rootMeta = pikkuState(null, 'workflows', 'meta');
+    if (rootMeta[name]) {
+        return { meta: rootMeta[name], packageName: null, resolvedName: name };
+    }
+    const colonIndex = name.indexOf(':');
+    if (colonIndex !== -1) {
+        const namespace = name.substring(0, colonIndex);
+        const localName = name.substring(colonIndex + 1);
+        const addons = pikkuState(null, 'addons', 'packages');
+        const pkgConfig = addons?.get(namespace);
+        if (pkgConfig) {
+            const addonMeta = pikkuState(pkgConfig.package, 'workflows', 'meta');
+            if (addonMeta?.[localName]) {
+                return {
+                    meta: addonMeta[localName],
+                    packageName: pkgConfig.package,
+                    resolvedName: localName,
+                };
+            }
+        }
+    }
+    return null;
+};
+const toKebab = (s) => s.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
 import { continueGraph, executeGraphStep, runWorkflowGraph, runFromMeta, } from './graph/graph-runner.js';
 import { PikkuError, addError } from '../../errors/error-handler.js';
 import { RPCNotFoundError } from '../rpc/rpc-runner.js';
@@ -88,7 +115,62 @@ export class PikkuWorkflowService {
     get logger() {
         return getSingletonServices()?.logger;
     }
-    constructor() { }
+    constructor() {
+        const functions = pikkuState(null, 'function', 'functions');
+        const functionsMeta = pikkuState(null, 'function', 'meta');
+        // Minimal meta for internal workflow functions (satisfies FunctionMeta)
+        const mkMeta = (funcId) => ({
+            pikkuFuncId: funcId,
+            sessionless: true,
+            functionType: 'helper',
+            inputSchemaName: null,
+            outputSchemaName: null,
+        });
+        const queueMeta = pikkuState(null, 'queue', 'meta');
+        const registerWorkflowFunc = (funcId, func, queueName) => {
+            if (functions.has(funcId))
+                return;
+            addFunction(funcId, func);
+            if (!queueMeta[queueName]) {
+                queueMeta[queueName] = { pikkuFuncId: funcId, name: queueName };
+            }
+            wireQueueWorker({ name: queueName, func });
+            if (!functionsMeta[funcId]) {
+                functionsMeta[funcId] = mkMeta(funcId);
+            }
+        };
+        // Register shared queue workers for monolith deployments
+        registerWorkflowFunc('pikkuWorkflowOrchestrator', { func: pikkuWorkflowOrchestratorFunc }, 'pikku-workflow-orchestrator');
+        registerWorkflowFunc('pikkuWorkflowStepWorker', { func: pikkuWorkflowWorkerFunc }, 'pikku-workflow-step-worker');
+        // Register per-workflow queue workers (root + addon packages)
+        const registerQueueWorkers = (queueMeta) => {
+            for (const [queueName, meta] of Object.entries(queueMeta)) {
+                if (functions.has(meta.pikkuFuncId))
+                    continue;
+                if (queueName.startsWith('wf-orchestrator-')) {
+                    registerWorkflowFunc(meta.pikkuFuncId, { func: pikkuWorkflowOrchestratorFunc }, queueName);
+                }
+                else if (queueName.startsWith('wf-step-')) {
+                    registerWorkflowFunc(meta.pikkuFuncId, { func: pikkuWorkflowWorkerFunc }, queueName);
+                }
+            }
+        };
+        registerQueueWorkers(pikkuState(null, 'queue', 'meta'));
+        const addons = pikkuState(null, 'addons', 'packages');
+        if (addons) {
+            for (const [, addon] of addons) {
+                const addonQueueMeta = pikkuState(addon.package, 'queue', 'meta');
+                if (addonQueueMeta) {
+                    registerQueueWorkers(addonQueueMeta);
+                }
+            }
+        }
+        if (!functions.has('pikkuWorkflowSleeper')) {
+            addFunction('pikkuWorkflowSleeper', {
+                func: pikkuWorkflowSleeperFunc,
+            });
+        }
+    }
     /**
      * Check if a run is executing inline (without queues)
      */
@@ -115,6 +197,47 @@ export class PikkuWorkflowService {
             await this.upsertWorkflowVersion(name, meta.graphHash, meta, meta.source);
         }
     }
+    /**
+     * Get minimal workflow run status with step summaries.
+     * Used by the public API — the console addon provides the full verbose view.
+     */
+    async getRunStatus(id) {
+        const run = await this.getRun(id);
+        if (!run)
+            return null;
+        const history = await this.getRunHistory(id);
+        const terminalStatuses = new Set(['completed', 'failed', 'cancelled']);
+        // Build step summaries from history (latest attempt per step)
+        const stepMap = new Map();
+        for (const step of history) {
+            const existing = stepMap.get(step.stepName);
+            if (!existing || step.updatedAt > existing.completedAt) {
+                stepMap.set(step.stepName, {
+                    status: step.status,
+                    startedAt: step.runningAt ?? step.createdAt,
+                    completedAt: step.succeededAt ?? step.failedAt,
+                });
+            }
+        }
+        const steps = [...stepMap.entries()].map(([name, s]) => ({
+            name,
+            status: s.status,
+            duration: s.startedAt && s.completedAt
+                ? s.completedAt.getTime() - s.startedAt.getTime()
+                : undefined,
+        }));
+        return {
+            id: run.id,
+            status: run.status,
+            startedAt: run.createdAt,
+            completedAt: terminalStatuses.has(run.status) ? run.updatedAt : undefined,
+            steps,
+            output: run.status === 'completed' ? run.output : undefined,
+            error: run.error
+                ? { message: run.error.message ?? 'Unknown error' }
+                : undefined,
+        };
+    }
     // ============================================================================
     // Workflow Lifecycle Methods
     // ============================================================================
@@ -122,13 +245,19 @@ export class PikkuWorkflowService {
      * Resume a paused workflow by triggering the orchestrator
      * @param runId - Run ID
      */
-    async resumeWorkflow(runId) {
+    async resumeWorkflow(runId, workflowName) {
         const queueService = this.verifyQueueService();
-        await queueService.add(this.getConfig().orchestratorQueueName, { runId });
+        if (!workflowName) {
+            const run = await this.getRun(runId);
+            workflowName = run?.workflow;
+        }
+        await queueService.add(this.getOrchestratorQueueName(workflowName), {
+            runId,
+        });
     }
     async queueStepWorker(runId, stepName, rpcName, data) {
         const queueService = this.verifyQueueService();
-        await queueService.add(this.getConfig().stepWorkerQueueName, JSON.parse(JSON.stringify({
+        await queueService.add(this.getStepWorkerQueueName(rpcName), JSON.parse(JSON.stringify({
             runId,
             stepName,
             rpcName,
@@ -149,9 +278,13 @@ export class PikkuWorkflowService {
      * @param runId - Run ID
      * @param retryDelay - Delay in milliseconds or duration string (optional)
      */
-    async scheduleOrchestratorRetry(runId, retryDelay) {
+    async scheduleOrchestratorRetry(runId, retryDelay, workflowName) {
         const queueService = this.verifyQueueService();
-        await queueService.add(this.getConfig().orchestratorQueueName, { runId }, retryDelay ? { delay: getDurationInMilliseconds(retryDelay) } : undefined);
+        if (!workflowName) {
+            const run = await this.getRun(runId);
+            workflowName = run?.workflow;
+        }
+        await queueService.add(this.getOrchestratorQueueName(workflowName), { runId }, retryDelay ? { delay: getDurationInMilliseconds(retryDelay) } : undefined);
     }
     /**
      * Start a new workflow run
@@ -160,21 +293,30 @@ export class PikkuWorkflowService {
      * @param options.startNode - Starting node ID for graph workflows (from wire config)
      */
     async startWorkflow(name, input, wire, rpcService, options) {
-        // Check meta to determine workflow type
-        const meta = pikkuState(null, 'workflows', 'meta');
-        const workflowMeta = meta[name];
+        // Resolve workflow from static meta (root or addon namespace), then dynamic DB
+        const resolved = resolveWorkflowMeta(name);
+        let workflowMeta = resolved?.meta;
+        const packageName = resolved?.packageName ?? null;
+        if (!workflowMeta) {
+            const dynamicWorkflows = await this.getAIGeneratedWorkflows();
+            const match = dynamicWorkflows.find((w) => w.workflowName === name);
+            if (match?.graph) {
+                workflowMeta = match.graph;
+            }
+        }
         if (!workflowMeta) {
             throw new WorkflowNotFoundError(name);
         }
-        if (workflowMeta.source === 'graph' || workflowMeta.source === 'ai-agent') {
+        if (workflowMeta.source === 'graph' ||
+            workflowMeta.source === 'dynamic-workflow') {
             const shouldInline = options?.inline ||
                 workflowMeta.inline ||
                 !getSingletonServices()?.queueService;
-            return runWorkflowGraph(this, name, input, rpcService, shouldInline, options?.startNode, wire);
+            return runWorkflowGraph(this, name, input, rpcService, shouldInline, options?.startNode, wire, workflowMeta);
         }
         // DSL workflow - check registration exists
-        const registrations = pikkuState(null, 'workflows', 'registrations');
-        const workflow = registrations.get(name);
+        const registrations = pikkuState(packageName, 'workflows', 'registrations');
+        const workflow = registrations.get(resolved?.resolvedName ?? name);
         if (!workflow) {
             throw new WorkflowNotFoundError(name);
         }
@@ -231,15 +373,17 @@ export class PikkuWorkflowService {
         if (!run) {
             throw new WorkflowRunNotFoundError(runId);
         }
-        const meta = pikkuState(null, 'workflows', 'meta');
-        const workflowMeta = meta[run.workflow];
+        const resolved = resolveWorkflowMeta(run.workflow);
+        const workflowMeta = resolved?.meta;
+        const pkgName = resolved?.packageName ?? null;
         if (run.graphHash &&
             workflowMeta?.graphHash &&
             run.graphHash !== workflowMeta.graphHash) {
             await this.runVersionMismatchFallback(run, workflowMeta, rpcService);
             return;
         }
-        if (workflowMeta?.source === 'graph') {
+        if (workflowMeta?.source === 'graph' ||
+            workflowMeta?.source === 'dynamic-workflow') {
             await continueGraph(this, runId, run.workflow);
             const updatedRun = await this.getRun(runId);
             if (updatedRun?.status === 'completed') {
@@ -251,13 +395,32 @@ export class PikkuWorkflowService {
             }
             return;
         }
-        const registrations = pikkuState(null, 'workflows', 'registrations');
-        const workflow = registrations.get(run.workflow);
+        if (!workflowMeta) {
+            const dynamicWorkflows = await this.getAIGeneratedWorkflows();
+            const match = dynamicWorkflows.find((w) => w.workflowName === run.workflow);
+            if (match?.graph) {
+                await continueGraph(this, runId, run.workflow, match.graph);
+                const updatedRun = await this.getRun(runId);
+                if (updatedRun?.status === 'completed') {
+                    await this.onChildWorkflowCompleted(updatedRun, updatedRun.output);
+                }
+                else if (updatedRun?.status === 'failed' ||
+                    updatedRun?.status === 'cancelled') {
+                    await this.onChildWorkflowFailed(updatedRun, new Error(updatedRun.error?.message || 'Child workflow failed'));
+                }
+                return;
+            }
+        }
+        const registrations = pikkuState(pkgName, 'workflows', 'registrations');
+        const workflow = registrations.get(resolved?.resolvedName ?? run.workflow);
         if (!workflow) {
             throw new WorkflowNotFoundError(run.workflow);
         }
         await this.withRunLock(runId, async () => {
-            const workflowWire = this.createWorkflowWire(run.workflow, runId, rpcService);
+            const addonNs = run.workflow.includes(':')
+                ? run.workflow.substring(0, run.workflow.indexOf(':'))
+                : null;
+            const workflowWire = this.createWorkflowWire(run.workflow, runId, rpcService, addonNs);
             workflowWire.pikkuUserId = run.wire?.pikkuUserId;
             const wire = {
                 workflow: workflowWire,
@@ -271,6 +434,7 @@ export class PikkuWorkflowService {
                     wire,
                     createWireServices: getCreateWireServices(),
                     data: () => run.input,
+                    packageName: pkgName ?? undefined,
                 });
                 await this.updateRunStatus(runId, 'completed', result);
                 await this.onChildWorkflowCompleted(run, result);
@@ -376,7 +540,7 @@ export class PikkuWorkflowService {
                 const meta = pikkuState(null, 'workflows', 'meta');
                 const workflowMeta = meta[run.workflow];
                 const isGraphWorkflow = workflowMeta?.source === 'graph' ||
-                    workflowMeta?.source === 'ai-agent';
+                    workflowMeta?.source === 'dynamic-workflow';
                 if (isGraphWorkflow &&
                     workflowMeta?.nodes &&
                     stepName in workflowMeta.nodes) {
@@ -514,7 +678,7 @@ export class PikkuWorkflowService {
             // Map step retry options to queue job options
             const retries = stepOptions?.retries ?? 0;
             const retryDelay = stepOptions?.retryDelay;
-            await getSingletonServices().queueService.add(this.getConfig().stepWorkerQueueName, JSON.parse(JSON.stringify({
+            await getSingletonServices().queueService.add(this.getStepWorkerQueueName(rpcName), JSON.parse(JSON.stringify({
                 runId,
                 stepName,
                 rpcName,
@@ -758,7 +922,7 @@ export class PikkuWorkflowService {
             throw new WorkflowSuspendedException(runId, reason);
         });
     }
-    createWorkflowWire(name, runId, rpcService) {
+    createWorkflowWire(name, runId, rpcService, addonNamespace) {
         const workflowWire = {
             name,
             runId,
@@ -767,7 +931,10 @@ export class PikkuWorkflowService {
             do: async (stepName, rpcNameOrFn, dataOrOptions, options) => {
                 this.verifyStepName(stepName);
                 if (typeof rpcNameOrFn === 'string') {
-                    return await this.rpcStep(runId, stepName, rpcNameOrFn, dataOrOptions, rpcService, options);
+                    const resolvedRpcName = addonNamespace && !rpcNameOrFn.includes(':')
+                        ? `${addonNamespace}:${rpcNameOrFn}`
+                        : rpcNameOrFn;
+                    return await this.rpcStep(runId, stepName, resolvedRpcName, dataOrOptions, rpcService, options);
                 }
                 else {
                     return await this.inlineStep(runId, stepName, rpcNameOrFn, dataOrOptions);
@@ -800,4 +967,29 @@ export class PikkuWorkflowService {
             sleeperRPCName: workflow?.sleeperRPCName ?? 'pikkuWorkflowSleeper',
         };
     }
+    /**
+     * Get the orchestrator queue name for a specific workflow.
+     * Checks queue meta for a per-workflow queue first (e.g. wf-orchestrator-{name}),
+     * falls back to the shared orchestrator queue.
+     */
+    getOrchestratorQueueName(workflowName) {
+        if (workflowName) {
+            const perWorkflow = `wf-orchestrator-${toKebab(workflowName)}`;
+            const registrations = pikkuState(null, 'queue', 'registrations');
+            if (registrations.has(perWorkflow)) {
+                return perWorkflow;
+            }
+        }
+        return this.getConfig().orchestratorQueueName;
+    }
+    getStepWorkerQueueName(rpcName) {
+        if (rpcName) {
+            const perStep = `wf-step-${toKebab(rpcName)}`;
+            const registrations = pikkuState(null, 'queue', 'registrations');
+            if (registrations.has(perStep)) {
+                return perStep;
+            }
+        }
+        return this.getConfig().stepWorkerQueueName;
+    }
 }

package/dist/wirings/workflow/workflow-queue-workers.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Queue worker functions for workflow orchestration.
+ *
+ * These are registered as queue consumers by the codegen pipeline
+ * (injected into queue meta when workflows exist). They provide
+ * the runtime implementations that process queued workflow jobs.
+ */
+import type { PikkuRPC } from '../rpc/rpc-types.js';
+export interface WorkflowStepInput {
+    runId: string;
+    stepName: string;
+    rpcName: string;
+    data: unknown;
+}
+export interface PikkuWorkflowOrchestratorInput {
+    runId: string;
+}
+export interface PikkuWorkflowSleeperInput {
+    runId: string;
+    stepId: string;
+}
+/**
+ * Step worker — executes individual workflow steps dispatched via queue.
+ * The orchestrator queues steps here when they're async (not inline).
+ */
+export declare function pikkuWorkflowWorkerFunc(_services: Record<string, unknown>, { runId, stepName, rpcName, data }: WorkflowStepInput, { rpc }: {
+    rpc: PikkuRPC;
+}): Promise<void>;
+/**
+ * Orchestrator — resumes workflow execution after an async step completes.
+ * Called when a step worker finishes and the workflow needs to continue.
+ */
+export declare function pikkuWorkflowOrchestratorFunc(_services: Record<string, unknown>, { runId }: PikkuWorkflowOrchestratorInput, { rpc }: {
+    rpc: PikkuRPC;
+}): Promise<void>;
+/**
+ * Sleeper — wakes a workflow after a workflow.sleep() duration expires.
+ * Triggered by a delayed queue message or scheduler callback.
+ */
+export declare function pikkuWorkflowSleeperFunc(_services: Record<string, unknown>, { runId, stepId }: PikkuWorkflowSleeperInput): Promise<void>;

package/dist/wirings/workflow/workflow-queue-workers.js

@@ -0,0 +1,41 @@
+/**
+ * Queue worker functions for workflow orchestration.
+ *
+ * These are registered as queue consumers by the codegen pipeline
+ * (injected into queue meta when workflows exist). They provide
+ * the runtime implementations that process queued workflow jobs.
+ */
+import { getSingletonServices } from '../../pikku-state.js';
+/**
+ * Step worker — executes individual workflow steps dispatched via queue.
+ * The orchestrator queues steps here when they're async (not inline).
+ */
+export async function pikkuWorkflowWorkerFunc(_services, { runId, stepName, rpcName, data }, { rpc }) {
+    const services = getSingletonServices();
+    if (!services?.workflowService) {
+        throw new Error(`Workflow service not initialized: cannot execute workflow step for runId ${runId}, stepName ${stepName}`);
+    }
+    await services.workflowService.executeWorkflowStep(runId, stepName, rpcName, data, rpc);
+}
+/**
+ * Orchestrator — resumes workflow execution after an async step completes.
+ * Called when a step worker finishes and the workflow needs to continue.
+ */
+export async function pikkuWorkflowOrchestratorFunc(_services, { runId }, { rpc }) {
+    const services = getSingletonServices();
+    if (!services?.workflowService) {
+        throw new Error(`Workflow service not initialized: cannot orchestrate workflow for runId ${runId}`);
+    }
+    await services.workflowService.orchestrateWorkflow(runId, rpc);
+}
+/**
+ * Sleeper — wakes a workflow after a workflow.sleep() duration expires.
+ * Triggered by a delayed queue message or scheduler callback.
+ */
+export async function pikkuWorkflowSleeperFunc(_services, { runId, stepId }) {
+    const services = getSingletonServices();
+    if (!services?.workflowService) {
+        throw new Error(`Workflow service not initialized: cannot execute workflow sleep completed for runId ${runId}, stepId ${stepId}`);
+    }
+    await services.workflowService.executeWorkflowSleepCompleted(runId, stepId);
+}

package/dist/wirings/workflow/workflow.types.d.ts

@@ -90,6 +90,21 @@ export interface StepState {
     /** Timestamp when step failed */
     failedAt?: Date;
 }
+export interface WorkflowRunStatus {
+    id: string;
+    status: WorkflowStatus;
+    startedAt: Date;
+    completedAt?: Date;
+    steps: Array<{
+        name: string;
+        status: StepStatus;
+        duration?: number;
+    }>;
+    output?: unknown;
+    error?: {
+        message: string;
+    };
+}
 export interface WorkflowRunService {
     listRuns(options?: {
         workflowName?: string;
@@ -170,6 +185,7 @@ export type WorkflowsMeta = Record<string, CommonWireMeta & {
     context?: WorkflowContext;
     dsl?: boolean;
     inline?: boolean;
+    expose?: boolean;
 }>;
 /**
  * Unified workflow runtime meta (used by runtime to execute workflows)
@@ -182,7 +198,7 @@ export interface WorkflowRuntimeMeta {
     /** Pikku function name (for execution) */
     pikkuFuncId: string;
     /** Source type: 'dsl' (serializable), 'complex' (has inline steps), 'graph' */
-    source: 'dsl' | 'complex' | 'graph' | 'ai-agent';
+    source: 'dsl' | 'complex' | 'graph' | 'dynamic-workflow';
     /** Optional description */
     description?: string;
     /** Tags for organization */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.12.14",
+  "version": "0.12.15",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",
@@ -25,6 +25,7 @@
     "./channel/local": "./dist/wirings/channel/local/index.js",
     "./channel/serverless": "./dist/wirings/channel/serverless/index.js",
     "./http": "./dist/wirings/http/index.js",
+    "./remote": "./dist/remote.js",
     "./queue": "./dist/wirings/queue/index.js",
     "./scheduler": "./dist/wirings/scheduler/index.js",
     "./trigger": "./dist/wirings/trigger/index.js",
@@ -41,6 +42,7 @@
     "./oauth2": "./dist/wirings/oauth2/index.js",
     "./errors": "./dist/errors/index.js",
     "./services": "./dist/services/index.js",
+    "./services/local-meta": "./dist/services/meta-service.js",
     "./services/local-content": "./dist/services/local-content.js",
     "./services/gopass-secrets": "./dist/services/gopass-secrets.js",
     "./crypto-utils": "./dist/crypto-utils.js",
@@ -52,6 +54,7 @@
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
     "cookie": "^1.1.1",
+    "json-schema": "^0.4.0",
     "path-to-regexp": "^8.3.0",
     "picoquery": "^2.5.0"
   },

package/src/errors/errors.ts

@@ -15,6 +15,18 @@ addError(PikkuMissingMetaError, {
   message: 'Required metadata is missing',
 })
 
+export class MissingServiceError extends PikkuError {}
+addError(MissingServiceError, {
+  status: 500,
+  message: 'A required service is not configured',
+})
+
+export class LocalEnvironmentOnlyError extends PikkuError {}
+addError(LocalEnvironmentOnlyError, {
+  status: 403,
+  message: 'This operation is only available in local development mode',
+})
+
 /**
  * The server cannot or will not process the request due to client error (e.g., malformed request syntax).
  * @group Error

package/src/function/function-runner.ts

@@ -333,11 +333,12 @@ export const runPikkuFunc = async <In = any, Out = any>(
       })
     }
 
-    const wireServices = await resolvedCreateWireServices?.(
-      resolvedSingletonServices,
-      resolvedWire
-    )
+    let wireServices: Record<string, unknown> | undefined
     try {
+      wireServices = (await resolvedCreateWireServices?.(
+        resolvedSingletonServices,
+        resolvedWire
+      )) as Record<string, unknown> | undefined
       const services =
         wireServices && Object.keys(wireServices).length > 0
           ? { ...resolvedSingletonServices, ...wireServices }

package/src/function/functions.types.ts

@@ -257,6 +257,7 @@ export const pikkuAuth = <
     if (!session) return false
     return fn(services, session as Session)
   }
+  ;(wrapper as any).__pikkuAuth = true
   return wrapper as any
 }
 

package/src/function/index.ts

@@ -1,5 +1,15 @@
 export { addFunction, getAllFunctionNames } from './function-runner.js'
+export {
+  pikkuAuth,
+  pikkuPermission,
+  pikkuPermissionFactory,
+  pikkuApprovalDescription,
+} from './functions.types.js'
 export type {
   CorePikkuFunction,
   CorePikkuFunctionSessionless,
+  CorePikkuFunctionConfig,
+  CorePikkuAuth,
+  CorePikkuAuthConfig,
+  CorePikkuPermission,
 } from './functions.types.js'

package/src/handle-error.test.ts

@@ -91,7 +91,7 @@ describe('handleHTTPError', () => {
     assert.deepStrictEqual(http._state.jsonBody, {
       message: 'The server cannot find the requested resource.',
       payload: undefined,
-      traceId: 'tracker-1',
+      errorId: 'tracker-1',
     })
   })
 
@@ -112,7 +112,7 @@ describe('handleHTTPError', () => {
 
     assert.strictEqual(http._state.statusCode, 400)
     assert.ok(http._state.jsonBody.message.includes('client error'))
-    assert.strictEqual(http._state.jsonBody.traceId, 'tracker-2')
+    assert.strictEqual(http._state.jsonBody.errorId, 'tracker-2')
   })
 
   test('should set status 403 for ForbiddenError', () => {

package/src/handle-error.ts

@@ -9,7 +9,7 @@ import type { PikkuHTTP } from './wirings/http/http.types.js'
  *
  * @param {any} e - The error that occurred
  * @param {PikkuHTTP | undefined} http - HTTP wire object
- * @param {string} trackerId - Unique ID for tracking this error
+ * @param {string} traceId - Unique ID for tracking this error
  * @param {Logger} logger - Logger service
  * @param {number[]} logWarningsForStatusCodes - HTTP status codes to log as warnings
  * @param {boolean} respondWith404 - Whether to respond with 404 for NotFoundError
@@ -18,7 +18,7 @@ import type { PikkuHTTP } from './wirings/http/http.types.js'
 export const handleHTTPError = (
   e: any,
   http: PikkuHTTP | undefined,
-  trackerId: string | undefined,
+  traceId: string | undefined,
   logger: Logger,
   logWarningsForStatusCodes: number[],
   respondWith404: boolean,
@@ -38,13 +38,13 @@ export const handleHTTPError = (
     http?.response?.json({
       message: errorResponse.message,
       payload: (e as any).payload,
-      traceId: trackerId,
+      errorId: traceId,
     })
 
     // Log certain status codes as warnings
     if (logWarningsForStatusCodes.includes(errorResponse.status)) {
-      if (trackerId) {
-        logger.warn(`Warning id: ${trackerId}`)
+      if (traceId) {
+        logger.warn(`Warning id: ${traceId}`)
       }
       logger.warn(e instanceof Error ? e.message : e)
     }
@@ -53,9 +53,9 @@ export const handleHTTPError = (
     logger.error(e instanceof Error ? e.message : e)
     http?.response?.status(500)
 
-    if (trackerId) {
-      logger.warn(`Error id: ${trackerId}`)
-      const errorBody: Record<string, unknown> = { errorId: trackerId }
+    if (traceId) {
+      logger.warn(`Error id: ${traceId}`)
+      const errorBody: Record<string, unknown> = { errorId: traceId }
       if (exposeErrors && !isProduction() && e instanceof Error) {
         errorBody.message = e.message
         errorBody.stack = e.stack

package/src/index.ts

@@ -103,12 +103,11 @@ export type { AIStorageService } from './services/ai-storage-service.js'
 export type { HTTPMethod } from './wirings/http/http.types.js'
 export type { GraphNodeConfig } from './wirings/workflow/graph/workflow-graph.types.js'
 export { createGraph } from './wirings/workflow/graph/graph-node.js'
-export { workflow as wireWorkflow } from './wirings/workflow/workflow-helpers.js'
 export { wireAddon } from './wirings/rpc/wire-addon.js'
 export type { WireAddonConfig } from './wirings/rpc/wire-addon.js'
 export type { PikkuPackageState } from './types/state.types.js'
 export { runMiddleware, addMiddleware } from './middleware-runner.js'
-export { addPermission } from './permissions.js'
+export { addPermission, checkAuthPermissions } from './permissions.js'
 export { isSerializable, stopSingletonServices } from './utils.js'
 export { getSingletonServices, getCreateWireServices } from './pikku-state.js'
 export {

package/src/middleware/index.ts

@@ -3,3 +3,5 @@ export { authCookie } from './auth-cookie.js'
 export { authBearer } from './auth-bearer.js'
 export { pikkuRemoteAuthMiddleware } from './remote-auth.js'
 export { cors } from './cors.js'
+export { addMiddleware, runMiddleware } from '../middleware-runner.js'
+export { addPermission } from '../permissions.js'