@pikku/core 0.12.7 → 0.12.9

package/src/wirings/ai-agent/ai-agent-prepare.ts

@@ -11,6 +11,7 @@ import type {
 } from './ai-agent.types.js'
 import type { AIAgentRunnerParams } from '../../services/ai-agent-runner-service.js'
 import { PikkuError } from '../../errors/error-handler.js'
+import { AIProviderNotConfiguredError } from '../../errors/errors.js'
 import { pikkuState, getSingletonServices } from '../../pikku-state.js'
 import { createMiddlewareSessionWireProps } from '../../services/user-session-service.js'
 import type { SessionService } from '../../services/user-session-service.js'
@@ -520,7 +521,7 @@ export async function prepareAgentRun(
 
   const agentRunner = singletonServices.aiAgentRunner
   if (!agentRunner) {
-    throw new Error('AIAgentRunnerService not available in singletonServices')
+    throw new AIProviderNotConfiguredError()
   }
 
   if (agent.dynamicWorkflows && singletonServices.workflowService) {

package/src/wirings/ai-agent/ai-agent-runner.test.ts

@@ -5,6 +5,7 @@ import { resetPikkuState, pikkuState } from '../../pikku-state.js'
 import { runAIAgent } from './ai-agent-runner.js'
 import type { CoreAIAgent, PikkuAIMiddlewareHooks } from './ai-agent.types.js'
 import type { AIAgentStepResult } from '../../services/ai-agent-runner-service.js'
+import { AIProviderNotConfiguredError } from '../../errors/errors.js'
 
 beforeEach(() => {
   resetPikkuState()
@@ -42,6 +43,39 @@ const makeStepResult = (
 })
 
 describe('runAIAgent', () => {
+  test('throws AIProviderNotConfiguredError when aiAgentRunner is missing', async () => {
+    addTestAgent('no-provider-agent')
+
+    const mockServices = {
+      logger: {
+        info: () => {},
+        warn: () => {},
+        error: () => {},
+        debug: () => {},
+      },
+      aiRunState: {
+        createRun: async () => 'run-no-provider',
+        updateRun: async () => {},
+      },
+    } as any
+
+    pikkuState(null, 'package', 'singletonServices', mockServices)
+
+    await assert.rejects(
+      () =>
+        runAIAgent(
+          'no-provider-agent',
+          { message: 'hello', threadId: 't', resourceId: 'r' },
+          {}
+        ),
+      (error: unknown) => {
+        assert.ok(error instanceof AIProviderNotConfiguredError)
+        assert.match((error as Error).message, /AI provider/)
+        return true
+      }
+    )
+  })
+
   test('marks run as failed when runner throws', async () => {
     addTestAgent('failing-agent')
 

package/src/wirings/ai-agent/ai-agent-runner.ts

@@ -31,6 +31,7 @@ import {
 import { checkForApprovals, appendStepMessages } from './ai-agent-stream.js'
 import { pikkuState, getSingletonServices } from '../../pikku-state.js'
 import { resolveModelConfig } from './ai-agent-model-config.js'
+import { AIProviderNotConfiguredError } from '../../errors/errors.js'
 import { randomUUID } from 'crypto'
 
 export async function runAIAgent(
@@ -367,7 +368,7 @@ export async function resumeAIAgentSync(
   const memoryConfig = agent.memory
   const agentRunner = singletonServices.aiAgentRunner
   if (!agentRunner) {
-    throw new Error('AIAgentRunnerService not available')
+    throw new AIProviderNotConfiguredError()
   }
 
   const approvedIds = new Set(

package/src/wirings/ai-agent/ai-agent-stream.ts

@@ -10,6 +10,7 @@ import type {
   AIAgentMemoryConfig,
 } from './ai-agent.types.js'
 import { pikkuState, getSingletonServices } from '../../pikku-state.js'
+import { AIProviderNotConfiguredError } from '../../errors/errors.js'
 import {
   combineChannelMiddleware,
   wrapChannelWithMiddleware,
@@ -748,7 +749,7 @@ export async function resumeAIAgent(
   const memoryConfig = agent.memory
   const agentRunner = singletonServices.aiAgentRunner
   if (!agentRunner) {
-    throw new Error('AIAgentRunnerService not available in singletonServices')
+    throw new AIProviderNotConfiguredError()
   }
 
   if (!input.approved) {

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/http/web-request.ts

@@ -6,9 +6,11 @@ import type { PikkuHTTPResponse } from './http.types.js'
  * Useful for bridging Pikku routes to libraries that expect standard Web Request objects.
  */
 export function toWebRequest(req: PikkuHTTPRequest, baseUrl?: string): Request {
+  const proto = req.header('x-forwarded-proto') ?? 'http'
+  const host = req.header('x-forwarded-host') ?? req.header('host') ?? 'localhost'
   const url = new URL(
     req.path(),
-    baseUrl ?? `http://${req.header('host') ?? 'localhost'}`
+    baseUrl ?? `${proto}://${host}`
   )
 
   const query = req.query()

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()