@pikku/core 0.12.8 → 0.12.10

package/src/wirings/oauth2/oauth2.types.ts

@@ -40,30 +40,3 @@ export type OAuth2Config = {
   /** Additional query parameters for authorization URL */
   additionalParams?: Record<string, string>
 }
-
-/**
- * Configuration for wireOAuth2Credential.
- * Combines standard credential fields with OAuth2-specific config.
- */
-export type CoreOAuth2Credential = {
-  /** Unique identifier for this credential */
-  name: string
-  /** Human-readable name for UI display */
-  displayName: string
-  /** Optional description for UI */
-  description?: string
-  /** Key used with SecretService to retrieve app credentials (clientId/clientSecret) */
-  secretId: string
-  /** Where access/refresh tokens are stored */
-  tokenSecretId: string
-  /** OAuth2 authorization URL */
-  authorizationUrl: string
-  /** OAuth2 token exchange URL */
-  tokenUrl: string
-  /** Required scopes */
-  scopes: string[]
-  /** Use PKCE flow */
-  pkce?: boolean
-  /** Additional query parameters for authorization URL */
-  additionalParams?: Record<string, string>
-}

package/src/wirings/workflow/graph/graph-runner.test.ts

@@ -484,4 +484,46 @@ describe('graph-runner bugs', () => {
 
     delete metaState['testInlineRpcMissing']
   })
+
+  test('graph workflow with inline: true in meta should run inline', async () => {
+    const ws = new InMemoryWorkflowService()
+    let executed = false
+
+    const mockRpcService = {
+      rpcWithWire: async () => {
+        executed = true
+        return { done: true }
+      },
+    }
+
+    // Set up queue service to verify nothing is queued
+    let queued = false
+    pikkuState(null, 'package', 'singletonServices', {
+      queueService: {
+        add: async () => {
+          queued = true
+        },
+      },
+    } as any)
+
+    const metaState = pikkuState(null, 'workflows', 'meta')
+    metaState['testInlineMetaGraph'] = {
+      name: 'testInlineMetaGraph',
+      pikkuFuncId: 'testInlineMetaGraph',
+      source: 'graph',
+      inline: true,
+      entryNodeIds: ['a'],
+      graphHash: 'inline-meta-graph-hash',
+      nodes: {
+        a: { nodeId: 'a', rpcName: 'doA' },
+      },
+    }
+
+    await runWorkflowGraph(ws, 'testInlineMetaGraph', {}, mockRpcService, true)
+
+    assert.equal(executed, true, 'RPC should have been executed inline')
+    assert.equal(queued, false, 'nothing should have been queued')
+
+    delete metaState['testInlineMetaGraph']
+  })
 })

package/src/wirings/workflow/graph/graph-runner.ts

@@ -1,9 +1,24 @@
-import type { PikkuWorkflowService } from '../pikku-workflow-service.js'
+import {
+  type PikkuWorkflowService,
+  WorkflowAsyncException,
+  WorkflowSuspendedException,
+} from '../pikku-workflow-service.js'
 import type { GraphWireState, PikkuGraphWire } from './workflow-graph.types.js'
-import { pikkuState } from '../../../pikku-state.js'
+import { pikkuState, getSingletonServices } from '../../../pikku-state.js'
 import type { WorkflowRuntimeMeta, WorkflowRunWire } from '../workflow.types.js'
 import { RPCNotFoundError } from '../../rpc/rpc-runner.js'
 
+export class ChildWorkflowStartedException extends Error {
+  name = 'ChildWorkflowStartedException'
+  constructor(
+    public parentRunId: string,
+    public stepId: string,
+    public childRunId: string
+  ) {
+    super(`Child workflow started: ${childRunId}`)
+  }
+}
+
 function buildTemplateRegex(nodeId: string): RegExp | null {
   if (!nodeId.includes('${')) return null
   const escaped = nodeId
@@ -442,9 +457,49 @@ export async function executeGraphStep(
   }
 
   try {
-    const result = await rpcService.rpcWithWire(rpcName, data, {
-      graph: graphWire,
-    })
+    let result: any
+
+    const subWorkflowMeta = pikkuState(null, 'workflows', 'meta')[rpcName]
+    if (subWorkflowMeta) {
+      const childWire: WorkflowRunWire = {
+        type: 'workflow',
+        id: rpcName,
+        parentRunId: runId,
+        parentStepId: stepId,
+      }
+      const shouldInline =
+        subWorkflowMeta.inline || !getSingletonServices()?.queueService
+      const { runId: childRunId } = await workflowService.startWorkflow(
+        rpcName,
+        data,
+        childWire,
+        rpcService,
+        { inline: shouldInline }
+      )
+      await workflowService.setStepChildRunId(stepId, childRunId)
+
+      if (shouldInline) {
+        const childRun = await workflowService.getRun(childRunId)
+        if (childRun?.status === 'failed') {
+          throw new Error(childRun.error?.message || 'Sub-workflow failed')
+        }
+        if (childRun?.status === 'cancelled') {
+          throw new Error('Sub-workflow was cancelled')
+        }
+        result = childRun?.output
+      } else {
+        throw new ChildWorkflowStartedException(runId, stepId, childRunId)
+      }
+    } else {
+      result = await rpcService.rpcWithWire(rpcName, data, {
+        graph: graphWire,
+        workflow: workflowService.createWorkflowWire(
+          graphName,
+          runId,
+          rpcService
+        ),
+      })
+    }
 
     if (wireState.branchKey) {
       await workflowService.setBranchTaken(stepId, wireState.branchKey)
@@ -452,6 +507,15 @@ export async function executeGraphStep(
 
     return result
   } catch (error) {
+    if (
+      error instanceof WorkflowAsyncException ||
+      error instanceof WorkflowSuspendedException
+    ) {
+      throw error
+    }
+    if (error instanceof ChildWorkflowStartedException) {
+      throw error
+    }
     if (error instanceof RPCNotFoundError) {
       await workflowService.updateRunStatus(runId, 'suspended', undefined, {
         message: `RPC '${rpcName}' not found. Deploy the missing function and resume.`,
@@ -541,9 +605,42 @@ async function executeGraphNodeInline(
   }
 
   try {
-    const result = await rpcService.rpcWithWire(rpcName, input, {
-      graph: graphWire,
-    })
+    let result: any
+
+    const subWorkflowMeta = pikkuState(null, 'workflows', 'meta')[rpcName]
+    if (subWorkflowMeta) {
+      const childWire: WorkflowRunWire = {
+        type: 'workflow',
+        id: rpcName,
+        parentRunId: runId,
+        parentStepId: stepState.stepId,
+      }
+      const { runId: childRunId } = await workflowService.startWorkflow(
+        rpcName,
+        input,
+        childWire,
+        rpcService,
+        { inline: true }
+      )
+      await workflowService.setStepChildRunId(stepState.stepId, childRunId)
+      const childRun = await workflowService.getRun(childRunId)
+      if (childRun?.status === 'failed') {
+        throw new Error(childRun.error?.message || 'Sub-workflow failed')
+      }
+      if (childRun?.status === 'cancelled') {
+        throw new Error('Sub-workflow was cancelled')
+      }
+      result = childRun?.output
+    } else {
+      result = await rpcService.rpcWithWire(rpcName, input, {
+        graph: graphWire,
+        workflow: workflowService.createWorkflowWire(
+          graphName,
+          runId,
+          rpcService
+        ),
+      })
+    }
 
     if (wireState.branchKey) {
       await workflowService.setBranchTaken(
@@ -554,6 +651,12 @@ async function executeGraphNodeInline(
 
     await workflowService.setStepResult(stepState.stepId, result)
   } catch (error) {
+    if (
+      error instanceof WorkflowAsyncException ||
+      error instanceof WorkflowSuspendedException
+    ) {
+      throw error
+    }
     if (error instanceof RPCNotFoundError) {
       await workflowService.setStepError(stepState.stepId, error as Error)
       await workflowService.updateRunStatus(runId, 'suspended', undefined, {
@@ -778,6 +881,12 @@ export async function runWorkflowGraph(
           entryNodes
         )
       } catch (error) {
+        if (
+          error instanceof WorkflowAsyncException ||
+          error instanceof WorkflowSuspendedException
+        ) {
+          return
+        }
         await workflowService.updateRunStatus(runId, 'failed', undefined, {
           message: (error as Error).message,
           stack: (error as Error).stack || '',

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

@@ -9,6 +9,115 @@ import {
   type PikkuWorkflowWire,
 } from './pikku-workflow-service.js'
 
+describe('pikku-workflow-service inline meta flag', () => {
+  test('workflow with inline: true in meta should create inline run and not queue', async () => {
+    const ws = new InMemoryWorkflowService()
+    const workflowName = 'testInlineMetaFlag'
+    const graphHash = 'inline-meta-hash'
+
+    // Set up a queue service that tracks if anything was queued
+    let queued = false
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: {
+        error: () => {},
+        info: () => {},
+        warn: () => {},
+        debug: () => {},
+      },
+      queueService: {
+        add: async () => {
+          queued = true
+        },
+      },
+    } as any)
+
+    const metaState = pikkuState(null, 'workflows', 'meta')
+    metaState[workflowName] = {
+      name: workflowName,
+      pikkuFuncId: workflowName,
+      source: 'dsl',
+      graphHash,
+      inline: true,
+    }
+
+    const functionMetaState = pikkuState(null, 'function', 'meta')
+    functionMetaState[workflowName] = {
+      name: workflowName,
+      sessionless: true,
+      permissions: [],
+    } as any
+
+    addWorkflow(workflowName, {
+      func: async () => {
+        return { ok: true }
+      },
+    })
+
+    const { runId } = await ws.startWorkflow(workflowName, {}, {})
+
+    // The run should be created as inline
+    const run = await ws.getRun(runId)
+    assert.equal(run?.inline, true, 'run should be marked as inline')
+    assert.equal(
+      queued,
+      false,
+      'nothing should have been queued to the queue service'
+    )
+
+    delete metaState[workflowName]
+    delete functionMetaState[workflowName]
+    pikkuState(null, 'workflows', 'registrations').delete(workflowName)
+  })
+
+  test('workflow without inline flag should use queue when queueService exists', async () => {
+    const ws = new InMemoryWorkflowService()
+    const workflowName = 'testNonInlineMetaFlag'
+    const graphHash = 'non-inline-meta-hash'
+
+    let queued = false
+    pikkuState(null, 'package', 'singletonServices', {
+      queueService: {
+        add: async () => {
+          queued = true
+        },
+      },
+    } as any)
+
+    const metaState = pikkuState(null, 'workflows', 'meta')
+    metaState[workflowName] = {
+      name: workflowName,
+      pikkuFuncId: workflowName,
+      source: 'dsl',
+      graphHash,
+      // no inline flag
+    }
+
+    const functionMetaState = pikkuState(null, 'function', 'meta')
+    functionMetaState[workflowName] = {
+      name: workflowName,
+      sessionless: true,
+      permissions: [],
+    } as any
+
+    addWorkflow(workflowName, {
+      func: async () => {
+        return { ok: true }
+      },
+    })
+
+    await ws.startWorkflow(workflowName, {}, {})
+
+    // Wait a tick
+    await new Promise((r) => setTimeout(r, 50))
+
+    assert.equal(queued, true, 'workflow should have been queued')
+
+    delete metaState[workflowName]
+    delete functionMetaState[workflowName]
+    pikkuState(null, 'workflows', 'registrations').delete(workflowName)
+  })
+})
+
 describe('pikku-workflow-service version mismatch fallback', () => {
   test('should fall back to stored graph for dsl workflow version mismatch', async () => {
     const ws = new InMemoryWorkflowService()

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

@@ -26,6 +26,7 @@ import {
 import type { WorkflowService } from '../../services/workflow-service.js'
 import { PikkuError, addError } from '../../errors/error-handler.js'
 import { RPCNotFoundError } from '../rpc/rpc-runner.js'
+import { ChildWorkflowStartedException } from './graph/graph-runner.js'
 
 /**
  * Exception thrown when workflow needs to pause for async step
@@ -111,6 +112,10 @@ const WORKFLOW_END_STATES: ReadonlySet<string> = new Set([
 export abstract class PikkuWorkflowService implements WorkflowService {
   private inlineRuns = new Set<string>()
 
+  protected get logger() {
+    return getSingletonServices()?.logger
+  }
+
   constructor() {}
 
   /**
@@ -386,12 +391,17 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     data: any
   ): Promise<void> {
     const queueService = this.verifyQueueService()
-    await queueService.add(this.getConfig().stepWorkerQueueName, {
-      runId,
-      stepName,
-      rpcName,
-      data,
-    })
+    await queueService.add(
+      this.getConfig().stepWorkerQueueName,
+      JSON.parse(
+        JSON.stringify({
+          runId,
+          stepName,
+          rpcName,
+          data,
+        })
+      )
+    )
   }
 
   /**
@@ -447,7 +457,9 @@ export abstract class PikkuWorkflowService implements WorkflowService {
 
     if (workflowMeta.source === 'graph' || workflowMeta.source === 'ai-agent') {
       const shouldInline =
-        options?.inline || !getSingletonServices()?.queueService
+        options?.inline ||
+        workflowMeta.inline ||
+        !getSingletonServices()?.queueService
       return runWorkflowGraph(
         this,
         name,
@@ -472,7 +484,9 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     }
 
     const shouldInline =
-      options?.inline || !getSingletonServices()?.queueService
+      options?.inline ||
+      workflowMeta.inline ||
+      !getSingletonServices()?.queueService
 
     const runId = await this.createRun(
       name,
@@ -484,16 +498,22 @@ export abstract class PikkuWorkflowService implements WorkflowService {
 
     if (shouldInline) {
       this.inlineRuns.add(runId)
-      this.runWorkflowJob(runId, rpcService)
-        .catch((err) => {
+      try {
+        await this.runWorkflowJob(runId, rpcService)
+      } catch (error: any) {
+        if (
+          error.name !== 'WorkflowAsyncException' &&
+          error.name !== 'WorkflowCancelledException' &&
+          error.name !== 'WorkflowSuspendedException'
+        ) {
           getSingletonServices()!.logger.error(
             `Workflow ${name} (run ${runId}) failed:`,
-            err
+            error
           )
-        })
-        .finally(() => {
-          this.inlineRuns.delete(runId)
-        })
+        }
+      } finally {
+        this.inlineRuns.delete(runId)
+      }
     } else {
       await this.resumeWorkflow(runId)
     }
@@ -553,6 +573,18 @@ export abstract class PikkuWorkflowService implements WorkflowService {
 
     if (workflowMeta?.source === 'graph') {
       await continueGraph(this, runId, run.workflow)
+      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
     }
 
@@ -587,6 +619,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
         )
 
         await this.updateRunStatus(runId, 'completed', result)
+        await this.onChildWorkflowCompleted(run, result)
       } catch (error: any) {
         if (error instanceof WorkflowAsyncException) {
           throw error
@@ -598,6 +631,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
             stack: '',
             code: 'WORKFLOW_CANCELLED',
           })
+          await this.onChildWorkflowFailed(run, error)
           throw error
         }
 
@@ -615,12 +649,41 @@ export abstract class PikkuWorkflowService implements WorkflowService {
           stack: error.stack,
           code: error.code,
         })
+        await this.onChildWorkflowFailed(run, error)
 
         throw error
       }
     })
   }
 
+  private async onChildWorkflowCompleted(
+    childRun: WorkflowRun,
+    result: any
+  ): Promise<void> {
+    const { parentRunId, parentStepId } = childRun.wire ?? {}
+    if (!parentRunId || !parentStepId) return
+
+    this.logger?.debug(
+      `Child workflow ${childRun.id} completed, updating parent step ${parentStepId}`
+    )
+    await this.setStepResult(parentStepId, result)
+    await this.resumeWorkflow(parentRunId)
+  }
+
+  private async onChildWorkflowFailed(
+    childRun: WorkflowRun,
+    error: Error
+  ): Promise<void> {
+    const { parentRunId, parentStepId } = childRun.wire ?? {}
+    if (!parentRunId || !parentStepId) return
+
+    this.logger?.debug(
+      `Child workflow ${childRun.id} failed, updating parent step ${parentStepId}`
+    )
+    await this.setStepError(parentStepId, error)
+    await this.resumeWorkflow(parentRunId)
+  }
+
   private async runVersionMismatchFallback(
     run: WorkflowRun,
     currentMeta: { source: string },
@@ -666,9 +729,8 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       // Get step state
       let stepState = await this.getStepState(runId, stepName)
 
-      // Idempotency - if already succeeded, resume orchestrator and return
+      // Idempotency - if already succeeded, nothing to do
       if (stepState.status === 'succeeded') {
-        await this.resumeWorkflow(runId)
         return
       }
 
@@ -682,8 +744,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
         stepState = await this.createRetryAttempt(stepState.stepId, 'running')
       }
 
-      if (stepState.status === 'pending') {
-        // Mark pending step as running before execution
+      if (stepState.status === 'pending' || stepState.status === 'scheduled') {
         await this.setStepRunning(stepState.stepId)
       }
 
@@ -698,7 +759,14 @@ export abstract class PikkuWorkflowService implements WorkflowService {
         const meta = pikkuState(null, 'workflows', 'meta')
         const workflowMeta = meta[run.workflow]
 
-        if (workflowMeta?.nodes && stepName in workflowMeta.nodes) {
+        const isGraphWorkflow =
+          workflowMeta?.source === 'graph' ||
+          workflowMeta?.source === 'ai-agent'
+        if (
+          isGraphWorkflow &&
+          workflowMeta?.nodes &&
+          stepName in workflowMeta.nodes
+        ) {
           result = await executeGraphStep(
             this,
             rpcService,
@@ -710,13 +778,52 @@ export abstract class PikkuWorkflowService implements WorkflowService {
             run.workflow
           )
         } else {
-          result = await rpcService.rpcWithWire(rpcName, data, {
-            workflowStep: {
-              runId,
-              stepId: stepState.stepId,
-              attemptCount: stepState.attemptCount,
-            },
-          })
+          // Check if rpcName refers to a sub-workflow
+          const subWorkflowMeta = meta[rpcName]
+          if (subWorkflowMeta) {
+            const childWire: WorkflowRunWire = {
+              type: 'workflow',
+              id: rpcName,
+              parentRunId: runId,
+              parentStepId: stepState.stepId,
+            }
+            const shouldInline =
+              subWorkflowMeta.inline || !getSingletonServices()?.queueService
+            const { runId: childRunId } = await this.startWorkflow(
+              rpcName,
+              data,
+              childWire,
+              rpcService,
+              { inline: shouldInline }
+            )
+            await this.setStepChildRunId(stepState.stepId, childRunId)
+            if (shouldInline) {
+              const childRun = await this.getRun(childRunId)
+              if (childRun?.status === 'failed') {
+                throw new Error(
+                  childRun.error?.message || 'Sub-workflow failed'
+                )
+              }
+              if (childRun?.status === 'cancelled') {
+                throw new Error('Sub-workflow was cancelled')
+              }
+              result = childRun?.output
+            } else {
+              throw new ChildWorkflowStartedException(
+                runId,
+                stepState.stepId,
+                childRunId
+              )
+            }
+          } else {
+            result = await rpcService.rpcWithWire(rpcName, data, {
+              workflowStep: {
+                runId,
+                stepId: stepState.stepId,
+                attemptCount: stepState.attemptCount,
+              },
+            })
+          }
         }
 
         // Store result and mark succeeded
@@ -725,6 +832,13 @@ export abstract class PikkuWorkflowService implements WorkflowService {
         // Resume orchestrator to continue workflow
         await this.resumeWorkflow(runId)
       } catch (error: any) {
+        if (error instanceof ChildWorkflowStartedException) {
+          this.logger?.debug(
+            `Workflow step '${stepName}': child workflow ${error.childRunId} started, waiting for completion`
+          )
+          return
+        }
+
         if (error instanceof RPCNotFoundError) {
           await this.setStepError(stepState.stepId, error)
           await this.updateRunStatus(runId, 'suspended', undefined, {
@@ -848,12 +962,14 @@ export abstract class PikkuWorkflowService implements WorkflowService {
 
       await getSingletonServices()!.queueService!.add(
         this.getConfig().stepWorkerQueueName,
-        {
-          runId,
-          stepName,
-          rpcName,
-          data,
-        },
+        JSON.parse(
+          JSON.stringify({
+            runId,
+            stepName,
+            rpcName,
+            data,
+          })
+        ),
         {
           // attempts includes initial attempt, retries doesn't
           attempts: retries + 1,
@@ -1153,7 +1269,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     })
   }
 
-  private createWorkflowWire(
+  public createWorkflowWire(
     name: string,
     runId: string,
     rpcService: any

package/src/wirings/workflow/workflow.types.ts

@@ -40,6 +40,7 @@ export interface WorkflowRunWire {
   type: string
   id?: string
   parentRunId?: string
+  parentStepId?: string
 }
 
 export interface WorkflowServiceConfig {
@@ -224,6 +225,7 @@ export type WorkflowsMeta = Record<
     steps: WorkflowStepMeta[]
     context?: WorkflowContext
     dsl?: boolean
+    inline?: boolean
   }
 >
 
@@ -243,6 +245,8 @@ export interface WorkflowRuntimeMeta {
   description?: string
   /** Tags for organization */
   tags?: string[]
+  /** If true, workflow always executes inline without queues */
+  inline?: boolean
   /** Serialized nodes */
   nodes?: Record<string, any>
   /** Entry node IDs for graph workflows (computed at build time) */