@pikku/core 0.12.70 → 0.12.72

package/src/services/in-memory-workflow-service.ts

@@ -456,6 +456,18 @@ export class InMemoryWorkflowService
     return nodeIds.filter((id) => !existingSteps.has(id))
   }
 
+  protected override async listStepStates(
+    runId: string
+  ): Promise<Array<StepState & { stepName: string }>> {
+    const prefix = `${runId}:`
+    const steps: Array<StepState & { stepName: string }> = []
+    for (const [key, step] of this.steps.entries()) {
+      if (!key.startsWith(prefix)) continue
+      steps.push({ ...step, stepName: key.substring(prefix.length) })
+    }
+    return steps
+  }
+
   async getStepInstances(
     runId: string
   ): Promise<
@@ -560,29 +572,4 @@ export class InMemoryWorkflowService
     if (!version) return null
     return { graph: version.graph, source: version.source }
   }
-
-  async getAIGeneratedWorkflows(
-    agentName?: string
-  ): Promise<Array<{ workflowName: string; graphHash: string; graph: any }>> {
-    const results: Array<{
-      workflowName: string
-      graphHash: string
-      graph: any
-    }> = []
-    const prefix = agentName ? `ai:${agentName}:` : 'ai:'
-    for (const [key, value] of this.workflowVersions) {
-      if (value.source !== 'ai-agent' || value.status !== 'active') continue
-      const separatorIdx = key.lastIndexOf(':')
-      const wfName = key.substring(0, separatorIdx)
-      const hash = key.substring(separatorIdx + 1)
-      if (wfName.startsWith(prefix)) {
-        results.push({
-          workflowName: wfName,
-          graphHash: hash,
-          graph: value.graph,
-        })
-      }
-    }
-    return results
-  }
 }

package/src/services/workflow-service.ts

@@ -64,6 +64,13 @@ export interface WorkflowService {
     rpcService: any,
     options?: { inline?: boolean; startNode?: string }
   ): Promise<{ runId: string }>
+  /**
+   * Start a run and wait for it to end.
+   *
+   * `pollIntervalMs` is the ceiling on the wait between reads of the run, not a
+   * fixed cadence: polling starts far shorter than this and widens towards it,
+   * so a run that finishes quickly is not held for a whole interval.
+   */
   runToCompletion<I>(
     name: string,
     input: I,
@@ -119,8 +126,4 @@ export interface WorkflowService {
     name: string,
     graphHash: string
   ): Promise<{ graph: any; source: string } | null>
-
-  getAIGeneratedWorkflows(
-    agentName?: string
-  ): Promise<Array<{ workflowName: string; graphHash: string; graph: any }>>
 }

package/src/types/core.types.ts

@@ -139,6 +139,13 @@ export type FunctionRuntimeMeta = {
    * may drive a browser or assert against fixtures.
    */
   scenarioStep?: boolean
+  /**
+   * The function behind a `pikkuScenario(...)` — a scenario's own body, as
+   * opposed to the steps it calls. Marked for the same reason as
+   * `scenarioStep`: a scenario is only ever run by `pikku scenario run`, so it
+   * has to be held back from the app bootstrap and from every deployed unit.
+   */
+  scenario?: boolean
   mcp?: boolean
   readonly?: boolean
   deploy?: 'serverless' | 'server' | 'auto'

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

@@ -510,22 +510,6 @@ describe('wrapChannelWithAGUI — Pikku CUSTOM events', () => {
     assert.deepEqual(c.value.data, [{ title: 'foo' }])
   })
 
-  it('emits CUSTOM pikku:workflow-created', () => {
-    const { channel, events } = makeChannel()
-    const wrapped = wrapChannelWithAGUI(channel)
-
-    wrapped.send({
-      type: 'workflow-created',
-      workflowName: 'myFlow',
-      graph: { nodes: [] },
-    } as AIStreamEvent)
-
-    const c = find(events, 'CUSTOM', 'pikku:workflow-created')
-    assert.ok(c)
-    assert.equal(c.value.workflowName, 'myFlow')
-    assert.deepEqual(c.value.graph, { nodes: [] })
-  })
-
   it('emits CUSTOM pikku:agent-call', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)

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

@@ -333,15 +333,6 @@ export function wrapChannelWithAGUI(
           break
         }
 
-        case 'workflow-created': {
-          send({
-            type: 'CUSTOM',
-            name: 'pikku:workflow-created',
-            value: { workflowName: event.workflowName, graph: event.graph },
-          })
-          break
-        }
-
         case 'agent-call': {
           send({
             type: 'CUSTOM',

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

@@ -462,8 +462,7 @@ export function createScopedChannel(
         event.type === 'tool-call' ||
         event.type === 'tool-result' ||
         event.type === 'usage' ||
-        event.type === 'error' ||
-        event.type === 'workflow-created'
+        event.type === 'error'
       ) {
         parent.send({ ...event, agent: agentName, session } as AIStreamEvent)
       } else {

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

@@ -350,13 +350,6 @@ export type AIStreamEvent =
       session?: string
     }
   | { type: 'audio-done'; agent?: string; session?: string }
-  | {
-      type: 'workflow-created'
-      workflowName: string
-      graph: any
-      agent?: string
-      session?: string
-    }
   | {
       type: 'data'
       name: string

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

@@ -531,6 +531,7 @@ export const fetchData = async <In, Out>(
     exposeErrors = !isProduction(),
     generateRequestId,
     traceId: externalTraceId,
+    maxBodySize,
   }: RunHTTPWiringOptions = {}
 ): Promise<Out | void> => {
   const singletonServices = getSingletonServices()
@@ -540,7 +541,9 @@ export const fetchData = async <In, Out>(
 
   // Combine the request and response into one wire object
   const pikkuRequest =
-    request instanceof Request ? new PikkuFetchHTTPRequest(request) : request
+    request instanceof Request
+      ? new PikkuFetchHTTPRequest(request, { maxBodySize })
+      : request
 
   // Resolve traceId: external (e.g. CF-Ray) > x-request-id header > generated
   let requestId: string | null = externalTraceId ?? null

package/src/wirings/http/http.types.ts

@@ -38,6 +38,8 @@ export type RunHTTPWiringOptions = Partial<{
   generateRequestId: () => string
   /** Pre-resolved trace ID (e.g. CF-Ray). Falls back to x-request-id header or generated ID. */
   traceId: string
+  /** Maximum request body size in bytes, applied when pikku wraps a fetch `Request`. */
+  maxBodySize: number
 }>
 
 /**

package/src/wirings/http/index.ts

@@ -1,4 +1,8 @@
-export { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js'
+export {
+  PikkuFetchHTTPRequest,
+  DEFAULT_MAX_BODY_SIZE,
+} from './pikku-fetch-http-request.js'
+export type { PikkuFetchHTTPRequestOptions } from './pikku-fetch-http-request.js'
 export { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js'
 export { logRoutes } from './log-http-routes.js'
 

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

@@ -221,6 +221,95 @@ test('data() throws on boolean conflict', async () => {
 
 // --- Safe fallback: only one source
 
+// --- Body size limits
+
+const streamedRequest = (chunks) =>
+  new Request('http://localhost', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: new ReadableStream({
+      start(controller) {
+        for (const chunk of chunks) {
+          controller.enqueue(new TextEncoder().encode(chunk))
+        }
+        controller.close()
+      },
+    }),
+    duplex: 'half',
+  })
+
+test('arrayBuffer() rejects a body larger than the configured limit', async () => {
+  const req = new Request('http://localhost', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/octet-stream' },
+    body: 'x'.repeat(64),
+  })
+  const pikkuReq = new PikkuFetchHTTPRequest(req, { maxBodySize: 16 })
+  await assert.rejects(async () => await pikkuReq.arrayBuffer(), {
+    name: 'PayloadTooLargeError',
+  })
+})
+
+test('arrayBuffer() rejects an oversized body with no content-length header', async () => {
+  const req = streamedRequest(['x'.repeat(32), 'y'.repeat(32)])
+  assert.equal(req.headers.get('content-length'), null)
+  const pikkuReq = new PikkuFetchHTTPRequest(req, { maxBodySize: 16 })
+  await assert.rejects(async () => await pikkuReq.arrayBuffer(), {
+    name: 'PayloadTooLargeError',
+  })
+})
+
+test('arrayBuffer() rejects a body whose content-length under-reports its size', async () => {
+  const req = new Request('http://localhost', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': '4',
+    },
+    body: new ReadableStream({
+      start(controller) {
+        controller.enqueue(new TextEncoder().encode('z'.repeat(128)))
+        controller.close()
+      },
+    }),
+    duplex: 'half',
+  })
+  const pikkuReq = new PikkuFetchHTTPRequest(req, { maxBodySize: 16 })
+  await assert.rejects(async () => await pikkuReq.arrayBuffer(), {
+    name: 'PayloadTooLargeError',
+  })
+})
+
+test('data() surfaces PayloadTooLargeError rather than wrapping it', async () => {
+  const req = createRequest(
+    'POST',
+    'http://localhost',
+    { padding: 'x'.repeat(256) },
+    { 'Content-Type': 'application/json' }
+  )
+  const pikkuReq = new PikkuFetchHTTPRequest(req, { maxBodySize: 16 })
+  await assert.rejects(async () => await pikkuReq.data(), {
+    name: 'PayloadTooLargeError',
+  })
+})
+
+test('data() accepts a body within the configured limit', async () => {
+  const req = createRequest(
+    'POST',
+    'http://localhost',
+    { ok: true },
+    { 'Content-Type': 'application/json' }
+  )
+  const pikkuReq = new PikkuFetchHTTPRequest(req, { maxBodySize: 1024 })
+  assert.deepEqual(await pikkuReq.data(), { ok: true })
+})
+
+test('data() accepts a streamed body within the default limit', async () => {
+  const req = streamedRequest(['{"ok"', ':true}'])
+  const pikkuReq = new PikkuFetchHTTPRequest(req)
+  assert.deepEqual(await pikkuReq.data(), { ok: true })
+})
+
 test('data() works when only body has values', async () => {
   const req = createRequest(
     'POST',

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

@@ -1,7 +1,22 @@
 import { parse as parseQuery } from 'picoquery'
 import { parse as parseCookie } from 'cookie'
 import type { HTTPMethod, PikkuHTTPRequest, PikkuQuery } from './http.types.js'
-import { UnprocessableContentError } from '../../errors/errors.js'
+import {
+  PayloadTooLargeError,
+  UnprocessableContentError,
+} from '../../errors/errors.js'
+
+/**
+ * The largest request body read into memory when no limit is configured. Ample
+ * for JSON APIs and typical uploads while keeping a single request's memory
+ * footprint bounded.
+ */
+export const DEFAULT_MAX_BODY_SIZE = 10 * 1024 * 1024
+
+export type PikkuFetchHTTPRequestOptions = Partial<{
+  /** Maximum request body size in bytes. Defaults to {@link DEFAULT_MAX_BODY_SIZE}. */
+  maxBodySize: number
+}>
 
 /**
  * Abstract class representing a pikku request.
@@ -17,9 +32,14 @@ export class PikkuFetchHTTPRequest<
   #rawBodyText: string | undefined
   #rawBodyBuffer: ArrayBuffer | undefined
   #rawBufferPromise: Promise<ArrayBuffer> | undefined
+  #maxBodySize: number
 
-  constructor(private request: Request) {
+  constructor(
+    private request: Request,
+    { maxBodySize = DEFAULT_MAX_BODY_SIZE }: PikkuFetchHTTPRequestOptions = {}
+  ) {
     this.#url = new URL(request.url)
+    this.#maxBodySize = maxBodySize
   }
 
   public method(): HTTPMethod {
@@ -78,13 +98,72 @@ export class PikkuFetchHTTPRequest<
       )
       return this.#rawBufferPromise
     }
-    this.#rawBufferPromise = this.request.arrayBuffer().then((buf) => {
+    this.#rawBufferPromise = this.#readBoundedBuffer().then((buf) => {
       this.#rawBodyBuffer = buf
       return buf
     })
     return this.#rawBufferPromise
   }
 
+  /**
+   * Reads the body while refusing to buffer more than `maxBodySize` bytes. The
+   * declared `content-length` is rejected up front so an oversized body is never
+   * transferred, and the stream is measured as it arrives because that header is
+   * both optional and attacker-controlled.
+   */
+  async #readBoundedBuffer(): Promise<ArrayBuffer> {
+    const contentLength = this.request.headers.get('content-length')
+    if (contentLength !== null) {
+      const declaredSize = Number(contentLength)
+      if (Number.isFinite(declaredSize) && declaredSize > this.#maxBodySize) {
+        throw this.#payloadTooLarge()
+      }
+    }
+
+    const stream = this.request.body
+    if (stream === null) {
+      const buffer = await this.request.arrayBuffer()
+      if (buffer.byteLength > this.#maxBodySize) {
+        throw this.#payloadTooLarge()
+      }
+      return buffer
+    }
+
+    const reader = stream.getReader()
+    const chunks: Uint8Array[] = []
+    let size = 0
+    try {
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) {
+          break
+        }
+        size += value.byteLength
+        if (size > this.#maxBodySize) {
+          await reader.cancel()
+          throw this.#payloadTooLarge()
+        }
+        chunks.push(value)
+      }
+    } finally {
+      reader.releaseLock()
+    }
+
+    const body = new Uint8Array(size)
+    let offset = 0
+    for (const chunk of chunks) {
+      body.set(chunk, offset)
+      offset += chunk.byteLength
+    }
+    return body.buffer as ArrayBuffer
+  }
+
+  #payloadTooLarge(): PayloadTooLargeError {
+    return new PayloadTooLargeError(
+      `Request body exceeds the maximum size of ${this.#maxBodySize} bytes`
+    )
+  }
+
   async #readRawText(): Promise<string> {
     if (this.#rawBodyText !== undefined) {
       return this.#rawBodyText
@@ -214,6 +293,9 @@ export class PikkuFetchHTTPRequest<
         )
       }
     } catch (e) {
+      if (e instanceof PayloadTooLargeError) {
+        throw e
+      }
       throw new UnprocessableContentError(`Error parsing body: ${e}`)
     }
     return body

package/src/wirings/mcp/mcp-runner.test.ts

@@ -329,6 +329,46 @@ describe('runMCPTool', () => {
       }
     )
   })
+
+  test('withholds the error message and stack from internal MCP errors in production', async () => {
+    pikkuState(null, 'mcp', 'toolsMeta').prodBoom = {
+      name: 'prodBoom',
+      title: 'Prod Boom',
+      description: 'Prod Boom',
+      pikkuFuncId: 'prodBoomFunc',
+      inputSchema: null,
+      outputSchema: null,
+    } as never
+    registerFunction('prodBoomFunc', async () => {
+      throw new Error('secret internal detail')
+    })
+
+    const originalNodeEnv = process.env.NODE_ENV
+    process.env.NODE_ENV = 'production'
+    try {
+      await assert.rejects(
+        () =>
+          runMCPTool(
+            { jsonrpc: '2.0', id: 'prod-boom-1', params: {} },
+            { mcp: mcpWire as never },
+            'prodBoom'
+          ),
+        (error: unknown) => {
+          assert.ok(error instanceof MCPError)
+          assert.equal(error.error.code, -32603)
+          assert.equal(error.error.message, 'Internal error')
+          assert.equal(error.error.data, undefined)
+          return true
+        }
+      )
+    } finally {
+      if (originalNodeEnv === undefined) {
+        delete process.env.NODE_ENV
+      } else {
+        process.env.NODE_ENV = originalNodeEnv
+      }
+    }
+  })
 })
 
 describe('runMCPPrompt', () => {

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

@@ -12,6 +12,7 @@ import type {
   CorePikkuFunctionSessionless,
 } from '../../function/functions.types.js'
 import { getErrorResponse } from '../../errors/error-handler.js'
+import { isProduction } from '../../env.js'
 import { closeWireServices } from '../../utils.js'
 import {
   pikkuState,
@@ -35,6 +36,11 @@ export class MCPError extends Error {
 
 export type RunMCPEndpointParams<Tools extends string = any> = {
   mcp?: PikkuMCP<Tools>
+  /**
+   * Surface the error message + stack on unexpected internal errors.
+   * Defaults to enabled outside of production.
+   */
+  exposeErrors?: boolean
 }
 
 export type JsonRpcError = {
@@ -187,7 +193,7 @@ async function runMCPPikkuFunc(
   name: string,
   mcp: CoreMCPResource | CoreMCPPrompt | undefined,
   pikkuFuncId: string | undefined,
-  { mcp: mcpWire }: RunMCPEndpointParams
+  { mcp: mcpWire, exposeErrors = !isProduction() }: RunMCPEndpointParams
 ): Promise<JsonRpcResponse> {
   const singletonServices = getSingletonServices()
   const createWireServices = getCreateWireServices()
@@ -289,7 +295,10 @@ async function runMCPPikkuFunc(
         id: request.id,
         code: -32603,
         message: 'Internal error',
-        data: { message: e.message, stack: e.stack },
+        data:
+          exposeErrors && !isProduction() && e instanceof Error
+            ? { message: e.message, stack: e.stack }
+            : undefined,
       })
     }
   } finally {

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

@@ -538,8 +538,9 @@ export async function continueGraph(
     return
   }
 
-  const run = await workflowService.getRun(runId)
-  const triggerInput = run?.input
+  // The same run read a few lines up: nothing between here and there writes it,
+  // and `input` is fixed at creation anyway.
+  const triggerInput = currentRun?.input
 
   for (const fire of plan.toFire) {
     const node = nodes[fire.logical]

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

@@ -1,150 +1,7 @@
 import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
 
-import {
-  computeEntryNodeIds,
-  validateWorkflowWiring,
-  generateMermaidDiagram,
-} from './graph-validation.js'
-
-describe('computeEntryNodeIds', () => {
-  it('returns nodes not referenced by any other node', () => {
-    const nodes = {
-      start: { rpcName: 'a', next: 'middle' },
-      middle: { rpcName: 'b', next: 'end' },
-      end: { rpcName: 'c' },
-    }
-    assert.deepEqual(computeEntryNodeIds(nodes), ['start'])
-  })
-
-  it('returns multiple entry nodes for parallel starts', () => {
-    const nodes = {
-      a: { rpcName: 'x' },
-      b: { rpcName: 'y' },
-      c: { rpcName: 'z', next: 'a' },
-    }
-    const entries = computeEntryNodeIds(nodes)
-    assert.ok(entries.includes('b'))
-    assert.ok(entries.includes('c'))
-    assert.ok(!entries.includes('a'))
-  })
-
-  it('returns empty for fully circular graph', () => {
-    const nodes = {
-      a: { rpcName: 'x', next: 'b' },
-      b: { rpcName: 'y', next: 'a' },
-    }
-    assert.deepEqual(computeEntryNodeIds(nodes), [])
-  })
-
-  it('handles onError references', () => {
-    const nodes = {
-      start: { rpcName: 'a', next: 'ok', onError: 'err' },
-      ok: { rpcName: 'b' },
-      err: { rpcName: 'c' },
-    }
-    assert.deepEqual(computeEntryNodeIds(nodes), ['start'])
-  })
-
-  it('handles branching next as object', () => {
-    const nodes = {
-      start: { rpcName: 'a', next: { yes: 'b', no: 'c' } },
-      b: { rpcName: 'x' },
-      c: { rpcName: 'y' },
-    }
-    assert.deepEqual(computeEntryNodeIds(nodes), ['start'])
-  })
-
-  it('handles parallel next as array', () => {
-    const nodes = {
-      start: { rpcName: 'a', next: ['b', 'c'] },
-      b: { rpcName: 'x' },
-      c: { rpcName: 'y' },
-    }
-    assert.deepEqual(computeEntryNodeIds(nodes), ['start'])
-  })
-})
-
-describe('validateWorkflowWiring', () => {
-  const tools = ['toolA', 'toolB', 'toolC']
-
-  it('returns no errors for a valid workflow', () => {
-    const nodes = {
-      step1: { rpcName: 'toolA', input: {}, next: 'step2' },
-      step2: { rpcName: 'toolB', input: {} },
-    }
-    const errors = validateWorkflowWiring(nodes, tools)
-    assert.deepEqual(errors, [])
-  })
-
-  it('errors on missing rpcName', () => {
-    const nodes = {
-      step1: { input: {} },
-    }
-    const errors = validateWorkflowWiring(nodes, tools)
-    assert.ok(errors.some((e) => e.includes("missing 'rpcName'")))
-  })
-
-  it('errors on unknown tool', () => {
-    const nodes = {
-      step1: { rpcName: 'unknownTool', input: {} },
-    }
-    const errors = validateWorkflowWiring(nodes, tools)
-    assert.ok(errors.some((e) => e.includes('unknown tool')))
-  })
-
-  it('errors on next referencing unknown node', () => {
-    const nodes = {
-      step1: { rpcName: 'toolA', next: 'nonexistent' },
-    }
-    const errors = validateWorkflowWiring(nodes, tools)
-    assert.ok(errors.some((e) => e.includes("unknown node 'nonexistent'")))
-  })
-
-  it('errors on onError referencing unknown node', () => {
-    const nodes = {
-      step1: { rpcName: 'toolA', onError: 'missing' },
-    }
-    const errors = validateWorkflowWiring(nodes, tools)
-    assert.ok(errors.some((e) => e.includes("unknown node 'missing'")))
-  })
-
-  it('errors on input referencing unknown node', () => {
-    const nodes = {
-      step1: {
-        rpcName: 'toolA',
-        input: { field: { $ref: 'missing', path: 'x' } },
-      },
-    }
-    const errors = validateWorkflowWiring(nodes, tools)
-    assert.ok(errors.some((e) => e.includes("unknown node 'missing'")))
-  })
-
-  it('allows trigger refs without errors', () => {
-    const nodes = {
-      step1: {
-        rpcName: 'toolA',
-        input: { field: { $ref: 'trigger', path: 'title' } },
-        next: 'step2',
-      },
-      step2: { rpcName: 'toolB', input: {} },
-    }
-    const errors = validateWorkflowWiring(nodes, tools)
-    assert.deepEqual(errors, [])
-  })
-
-  it('allows valid node-to-node refs', () => {
-    const nodes = {
-      step1: { rpcName: 'toolA', input: {}, next: 'step2' },
-      step2: {
-        rpcName: 'toolB',
-        input: { data: { $ref: 'step1', path: 'result' } },
-      },
-    }
-    const errors = validateWorkflowWiring(nodes, tools)
-    assert.deepEqual(errors, [])
-  })
-})
+import { generateMermaidDiagram } from './graph-validation.js'
 
 describe('generateMermaidDiagram', () => {
   it('generates valid mermaid output', () => {