@pikku/core 0.12.14 → 0.12.15

package/src/wirings/workflow/pikku-workflow-service.ts

@@ -1,16 +1,56 @@
-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: string
+): { meta: any; packageName: string | null; resolvedName: string } | null => {
+  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: string) =>
+  s.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase()
 import type { PikkuWire, SerializedError } from '../../types/core.types.js'
 import type { QueueService } from '../queue/queue.types.js'
 import type {
   PikkuWorkflowWire,
   StepState,
+  StepStatus,
   WorkflowRun,
+  WorkflowRunStatus,
   WorkflowRunWire,
   WorkflowStatus,
   WorkflowVersionStatus,
@@ -116,7 +156,87 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     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: string) => ({
+      pikkuFuncId: funcId,
+      sessionless: true,
+      functionType: 'helper' as const,
+      inputSchemaName: null,
+      outputSchemaName: null,
+    })
+
+    const queueMeta = pikkuState(null, 'queue', 'meta')
+
+    const registerWorkflowFunc = (
+      funcId: string,
+      func: { func: unknown },
+      queueName: string
+    ) => {
+      if (functions.has(funcId)) return
+      addFunction(funcId, func as never)
+      if (!queueMeta[queueName]) {
+        queueMeta[queueName] = { pikkuFuncId: funcId, name: queueName }
+      }
+      wireQueueWorker({ name: queueName, func } as never)
+      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: Record<string, any>) => {
+      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)
@@ -162,6 +282,55 @@ export abstract class PikkuWorkflowService implements WorkflowService {
    */
   abstract getRun(id: string): Promise<WorkflowRun | null>
 
+  /**
+   * Get minimal workflow run status with step summaries.
+   * Used by the public API — the console addon provides the full verbose view.
+   */
+  async getRunStatus(id: string): Promise<WorkflowRunStatus | null> {
+    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<
+      string,
+      { status: StepStatus; startedAt?: Date; completedAt?: Date }
+    >()
+    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,
+    }
+  }
+
   /**
    * Get workflow run history (all step attempts in chronological order)
    * @param runId - Run ID
@@ -379,9 +548,18 @@ export abstract class PikkuWorkflowService implements WorkflowService {
    * Resume a paused workflow by triggering the orchestrator
    * @param runId - Run ID
    */
-  public async resumeWorkflow(runId: string): Promise<void> {
+  public async resumeWorkflow(
+    runId: string,
+    workflowName?: string
+  ): Promise<void> {
     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,
+    })
   }
 
   public async queueStepWorker(
@@ -392,7 +570,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
   ): Promise<void> {
     const queueService = this.verifyQueueService()
     await queueService.add(
-      this.getConfig().stepWorkerQueueName,
+      this.getStepWorkerQueueName(rpcName),
       JSON.parse(
         JSON.stringify({
           runId,
@@ -424,11 +602,16 @@ export abstract class PikkuWorkflowService implements WorkflowService {
    */
   protected async scheduleOrchestratorRetry(
     runId: string,
-    retryDelay?: number | string
+    retryDelay?: number | string,
+    workflowName?: string
   ): Promise<void> {
     const queueService = this.verifyQueueService()
+    if (!workflowName) {
+      const run = await this.getRun(runId)
+      workflowName = run?.workflow
+    }
     await queueService.add(
-      this.getConfig().orchestratorQueueName,
+      this.getOrchestratorQueueName(workflowName),
       { runId },
       retryDelay ? { delay: getDurationInMilliseconds(retryDelay) } : undefined
     )
@@ -447,15 +630,27 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     rpcService: any,
     options?: { inline?: boolean; startNode?: string }
   ): Promise<{ runId: string }> {
-    // 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 ||
@@ -467,13 +662,14 @@ export abstract class PikkuWorkflowService implements WorkflowService {
         rpcService,
         shouldInline,
         options?.startNode,
-        wire
+        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)
@@ -559,8 +755,9 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       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 &&
@@ -571,7 +768,10 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       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') {
@@ -588,17 +788,44 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       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 addonNs = run.workflow.includes(':')
+        ? run.workflow.substring(0, run.workflow.indexOf(':'))
+        : null
       const workflowWire = this.createWorkflowWire(
         run.workflow,
         runId,
-        rpcService
+        rpcService,
+        addonNs
       )
       workflowWire.pikkuUserId = run.wire?.pikkuUserId
       const wire: PikkuWire = {
@@ -617,6 +844,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
             wire,
             createWireServices: getCreateWireServices(),
             data: () => run.input,
+            packageName: pkgName ?? undefined,
           }
         )
 
@@ -763,7 +991,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
 
         const isGraphWorkflow =
           workflowMeta?.source === 'graph' ||
-          workflowMeta?.source === 'ai-agent'
+          workflowMeta?.source === 'dynamic-workflow'
         if (
           isGraphWorkflow &&
           workflowMeta?.nodes &&
@@ -963,7 +1191,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       const retryDelay = stepOptions?.retryDelay
 
       await getSingletonServices()!.queueService!.add(
-        this.getConfig().stepWorkerQueueName,
+        this.getStepWorkerQueueName(rpcName),
         JSON.parse(
           JSON.stringify({
             runId,
@@ -1274,7 +1502,8 @@ export abstract class PikkuWorkflowService implements WorkflowService {
   public createWorkflowWire(
     name: string,
     runId: string,
-    rpcService: any
+    rpcService: any,
+    addonNamespace?: string | null
   ): PikkuWorkflowWire {
     const workflowWire: PikkuWorkflowWire = {
       name,
@@ -1290,10 +1519,14 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       ) => {
         this.verifyStepName(stepName)
         if (typeof rpcNameOrFn === 'string') {
+          const resolvedRpcName =
+            addonNamespace && !rpcNameOrFn.includes(':')
+              ? `${addonNamespace}:${rpcNameOrFn}`
+              : rpcNameOrFn
           return await this.rpcStep(
             runId,
             stepName,
-            rpcNameOrFn,
+            resolvedRpcName,
             dataOrOptions,
             rpcService,
             options
@@ -1344,4 +1577,31 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       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.
+   */
+  protected getOrchestratorQueueName(workflowName?: string): string {
+    if (workflowName) {
+      const perWorkflow = `wf-orchestrator-${toKebab(workflowName)}`
+      const registrations = pikkuState(null, 'queue', 'registrations')
+      if (registrations.has(perWorkflow)) {
+        return perWorkflow
+      }
+    }
+    return this.getConfig().orchestratorQueueName
+  }
+
+  protected getStepWorkerQueueName(rpcName?: string): string {
+    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/src/wirings/workflow/workflow-queue-workers.ts

@@ -0,0 +1,85 @@
+/**
+ * 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'
+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 async function pikkuWorkflowWorkerFunc(
+  _services: Record<string, unknown>,
+  { runId, stepName, rpcName, data }: WorkflowStepInput,
+  { rpc }: { rpc: PikkuRPC }
+): Promise<void> {
+  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: Record<string, unknown>,
+  { runId }: PikkuWorkflowOrchestratorInput,
+  { rpc }: { rpc: PikkuRPC }
+): Promise<void> {
+  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: Record<string, unknown>,
+  { runId, stepId }: PikkuWorkflowSleeperInput
+): Promise<void> {
+  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/src/wirings/workflow/workflow.types.ts

@@ -141,6 +141,20 @@ export interface StepState {
   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
@@ -228,6 +242,7 @@ export type WorkflowsMeta = Record<
     context?: WorkflowContext
     dsl?: boolean
     inline?: boolean
+    expose?: boolean
   }
 >
 
@@ -242,7 +257,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 */