@pikku/core 0.12.8 → 0.12.9

package/src/wirings/channel/local/local-channel-runner.ts

@@ -5,6 +5,8 @@ import { processMessageHandlers } from '../channel-handler.js'
 import type { CoreChannel, RunChannelOptions } from '../channel.types.js'
 import { PikkuLocalChannelHandler } from './local-channel-handler.js'
 import type { PikkuWire, WireServices } from '../../../types/core.types.js'
+import { isProduction } from '../../../env.js'
+import { getErrorResponse } from '../../../errors/error-handler.js'
 import { handleHTTPError } from '../../../handle-error.js'
 import {
   PikkuSessionService,
@@ -121,9 +123,10 @@ export const runLocalChannel = async ({
             }
           } catch (e: any) {
             singletonServices.logger.error(`Error handling onConnect: ${e}`)
+            const errorResponse = getErrorResponse(e)
             channel.send({
-              error: e.message || 'Unknown error',
-              errorName: e.constructor?.name,
+              error: errorResponse?.message ?? (isProduction() ? 'Internal server error' : e.message),
+              ...(!isProduction() && { errorName: e.constructor?.name }),
             })
           }
         }
@@ -143,9 +146,10 @@ export const runLocalChannel = async ({
             })
           } catch (e: any) {
             singletonServices.logger.error(`Error handling onDisconnect: ${e}`)
+            const errorResponse = getErrorResponse(e)
             channel.send({
-              error: e.message || 'Unknown error',
-              errorName: e.constructor?.name,
+              error: errorResponse?.message ?? (isProduction() ? 'Internal server error' : e.message),
+              ...(!isProduction() && { errorName: e.constructor?.name }),
             })
           }
         }
@@ -165,9 +169,10 @@ export const runLocalChannel = async ({
           await channel.send(result)
         } catch (e: any) {
           singletonServices.logger.error(e)
+          const errorResponse = getErrorResponse(e)
           channel.send({
-            error: e.message || 'Unknown error',
-            errorName: e.constructor?.name,
+            error: errorResponse?.message ?? (isProduction() ? 'Internal server error' : e.message),
+            ...(!isProduction() && { errorName: e.constructor?.name }),
           })
           setTimeout(() => channel.close(), 200)
         }

package/src/wirings/http/http-runner.ts

@@ -32,6 +32,7 @@ import {
   getCreateWireServices,
 } from '../../pikku-state.js'
 import { PikkuSessionService } from '../../services/user-session-service.js'
+import { getErrorResponse } from '../../errors/error-handler.js'
 import { handleHTTPError } from '../../handle-error.js'
 import { pikkuState } from '../../pikku-state.js'
 import { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js'
@@ -530,7 +531,7 @@ export const fetchData = async <In, Out>(
         apiRoute,
         apiType,
       })
-      throw new NotFoundError(`Route not found: ${apiRoute}`)
+      throw new NotFoundError()
     }
 
     // Execute the matched route along with its middleware and session management
@@ -552,10 +553,11 @@ export const fetchData = async <In, Out>(
       // For SSE routes, send error through the stream since the response is already in stream mode
       singletonServices.logger.error(e instanceof Error ? e.message : e)
       try {
+        const errorResponse = getErrorResponse(e)
         response.arrayBuffer(
           JSON.stringify({
             type: 'error',
-            errorText: e instanceof Error ? e.message : String(e),
+            errorText: errorResponse?.message ?? 'Internal server error',
           })
         )
         response.arrayBuffer(JSON.stringify({ type: 'done' }))

package/src/wirings/http/pikku-fetch-http-request.ts

@@ -105,6 +105,9 @@ export class PikkuFetchHTTPRequest<In = unknown>
     const merged: Record<string, unknown> = {}
     for (const part of parts) {
       for (const [key, value] of Object.entries(part)) {
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+          continue
+        }
         if (key in merged && !valuesAreEquivalent(merged[key], value)) {
           throw new UnprocessableContentError(
             `Conflicting values for key "${key}": "${merged[key]}" vs "${value}"`
@@ -141,7 +144,14 @@ export class PikkuFetchHTTPRequest<In = unknown>
         body = { data: buffer }
       } else if (contentType === 'application/x-www-form-urlencoded') {
         const text = await this.request.text()
-        body = Object.fromEntries(new URLSearchParams(text))
+        const params = new URLSearchParams(text)
+        let count = 0
+        for (const _ of params) {
+          if (++count > 256) {
+            throw new UnprocessableContentError('Too many form parameters')
+          }
+        }
+        body = Object.fromEntries(params)
       } else {
         throw new UnprocessableContentError(
           `Unsupported content type ${contentType}`

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,20 @@
 import type { PikkuWorkflowService } 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 +453,44 @@ 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,
+      })
+    }
 
     if (wireState.branchKey) {
       await workflowService.setBranchTaken(stepId, wireState.branchKey)
@@ -452,6 +498,9 @@ export async function executeGraphStep(
 
     return result
   } catch (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 +590,37 @@ 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,
+      })
+    }
 
     if (wireState.branchKey) {
       await workflowService.setBranchTaken(

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)
       }
 
@@ -725,6 +786,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 +916,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,

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) */