@pikku/core 0.12.70 → 0.12.72

package/CHANGELOG.md

@@ -1,3 +1,146 @@
+## 0.12.72
+
+### Patch Changes
+
+- 384e484: Apply schema defaults, which nothing was ever filling in
+
+  A `default` on an input property reaches the generated JSON Schema and keeps
+  that property out of `required`, so a call that omits it validates. Nothing
+  then filled it in: JSON Schema validators are pure by specification, and
+  neither `@cfworker/json-schema` nor Ajv (without `useDefaults`) annotates the
+  instance being checked. The function received `undefined` for a property its
+  own generated type declares as present.
+
+  That is the worst shape the mismatch can take. Validation permits the omission,
+  the type promises a value, and the body reads `undefined` — so it surfaces far
+  from its cause, as `const offset = (page - 1) * limit` evaluating to `NaN` and
+  `.limit(undefined)` reaching the database on a paginated call made with no
+  arguments.
+
+  Defaults are now filled in before validation, on every path. Deliberately not
+  gated on `coerceDataFromSchema`, the flag guarding the neighbouring coercion
+  step: that flag is about decoding transport-encoded values (a query string's
+  `"1,2"` into an array) and is absent on a direct RPC invocation. A default
+  belongs to the schema rather than to the transport a call arrived on, so
+  gating it there would fill defaults over HTTP and skip them on RPC.
+
+  Filling is by presence rather than truthiness, so a supplied `0` or `false`
+  survives, and a call made with no arguments at all still gets its defaults.
+  Values are cloned, because an object or array default would otherwise be a
+  single mutable instance shared by every request in the process — one request's
+  `push` showing up in the next.
+
+  Nothing needs to change in generated types or call sites: both were already
+  written as though defaults worked. This makes them true.
+
+- b5a73fb: fix: stop leaking internal error detail and bound the request body size
+
+  HTTP error responses no longer forward an error's `payload` or its raw `message` for
+  registered 5xx errors — those responses carry the registered error message instead, so an
+  internal error that happens to hold a `payload` cannot leak it to the client. Errors
+  registered with a 4xx status keep their message and payload, and `exposeErrors` still
+  surfaces the full detail outside production.
+
+  `PikkuFetchHTTPRequest` now caps how much of a request body it buffers, rejecting the
+  declared `content-length` up front and measuring the stream as it arrives so a lying or
+  absent header cannot exhaust memory. Exceeding the limit throws `PayloadTooLargeError`
+  (413). The ceiling defaults to 10MB and is configurable via the new `maxBodySize` option on
+  the constructor and on `RunHTTPWiringOptions`.
+
+- 6be5ab0: Security hardening: removed the gopass secret service and stopped MCP internal errors leaking stack traces.
+
+  **Breaking:** `GopassSecretService` and the `@pikku/core/services/gopass-secrets` subpath export are gone. The service shelled out to the `gopass` binary and its key validation accepted `../`, so a caller-supplied key could traverse out of the configured prefix namespace and read secrets outside it. Rather than harden a shell-out that few projects used, the service is removed. Anyone importing it should implement `SecretService` against their own secret backend. Pre-0.13 breaking changes still ship as a patch.
+
+  MCP internal errors (JSON-RPC `-32603`) previously always attached `data: { message, stack }`, handing any MCP client an internal stack trace. That payload is now gated on `exposeErrors`, which defaults to `!isProduction()` — the same convention `handleHTTPError` already uses. In production a client receives a bare `Internal error` with no `message` and no `stack`. `RunMCPEndpointParams` accepts an explicit `exposeErrors` to suppress the detail outside production as well; it cannot force the detail on in production, because the check is `exposeErrors && !isProduction()` — again matching `handleHTTPError`.
+
+## 0.12.71
+
+### Patch Changes
+
+- 8a2c993: Make the workflow service cheaper to run, and fix two ways it lost state.
+
+  The SQL workflow tables had no indexes at all, so every step read, every
+  history walk and every orchestrator tick was a sequential scan; five indexes
+  now cover the columns the engine actually queries by. A replay used to ask for
+  each step's row individually — O(N) reads per replay, O(N^2) over a run — and
+  now takes one read of the run's steps and serves the walk from it. A step
+  transition wrote the step row and its history row as two separate statements,
+  so a crash between them left a step saying `succeeded` whose history still said
+  `running`; both halves are now one transaction, and the history row is found by
+  attempt number rather than by sorting on `created_at`, which two attempts can
+  share. Resolving a dynamic workflow read and parsed every AI-generated workflow
+  in the deployment to `.find()` one by name; it is a point lookup now.
+
+  Waiting on a run no longer polls at a fixed interval. `pollIntervalMs` became a
+  ceiling rather than a cadence: polling starts at 10ms and widens towards it, so
+  a workflow that finishes in milliseconds is no longer held for a full second,
+  and a long-running one is not read at full rate for its whole life.
+
+  Two backend-specific defects: Redis kept a run's state as one JSON blob and
+  read-modified-wrote it, so parallel branches setting different variables
+  overwrote each other — state is a field per variable now, with the old blob
+  still read underneath so runs in flight keep what they had. Mongo's
+  `setStepScheduled` never wrote history, leaving a queued step reading as never
+  dispatched.
+
+  Also: dispatch no longer JSON round-trips every step payload before handing it
+  to a queue that serialises it anyway — the in-process dev queue, which is the
+  only one that was relying on it, does it itself now.
+
+  Two more defects. A transition whose step had no live attempt wrote its status
+  to the step row and silently nothing to history — the exact divergence the
+  transaction exists to prevent — and now repairs the step and writes the
+  missing row. And resolving a dynamic workflow was non-deterministic on all
+  three backends: a name can hold several active versions, and none of them
+  ordered the candidates, so which one ran could change between two calls
+  reading identical data. The newest version wins, with the graph hash breaking
+  a tie.
+
+  The two attempt columns and the five indexes are declared in the workflow
+  schema, so a fresh database gets them at boot. An existing one gets them from
+  a migration — `pikku db generate` writes the declaration down — rather than
+  from DDL issued at boot.
+
+- a261006: **Breaking:** removed dynamic workflows — runtime-defined workflow graphs stored in the database and resolved by name instead of by codegen.
+
+  The feature was already half-gone. Its authoring surface (`createAgentWorkflow`, `saveAgentWorkflow`, `listAgentWorkflows`, `executeAgentWorkflow`, and the AI-agent instruction builder) was deleted in April 2026 along with its entire e2e suite, and nothing has written a dynamic workflow since. What remained could not execute one either: `executeAgentWorkflow` gated on `pikkuState('workflows', 'meta')`, which only codegen ever populates, so a graph that existed solely in the database was never findable. The two backend families had also drifted onto different `source` sentinels (`'ai-agent'` vs `'dynamic-workflow'`), and the two Redis implementations disagreed on key escaping — so at least one of them matched nothing. Rather than keep shipping plumbing for a path no caller could complete, it is removed until it can be reintroduced deliberately.
+
+  Removed:
+  - `getAIGeneratedWorkflows` from `WorkflowService` and `WorkflowRunService`, and from every backend (in-memory, Redis, MongoDB, Kysely, and the Cloudflare Durable Object service and client — the last two were already a `return []` stub and a rejection).
+  - The database-lookup fallbacks in `startWorkflow` and `runWorkflowJob` that resolved a workflow name against stored graphs when static meta had no match.
+  - `'dynamic-workflow'` from the `WorkflowRuntimeMeta['source']` union.
+  - `validateWorkflowWiring` and `computeEntryNodeIds` from `@pikku/core/workflow`. These validated AI-authored graphs and had no callers in core; the inspector keeps its own private entry-node computation for static graph wiring, which is unaffected.
+  - The `workflow-created` AI stream event and its AG-UI `pikku:workflow-created` custom event. Its only emitter went with the April deletion, so it could never fire.
+  - The console's `console:getAIWorkflows` RPC, the `useAIWorkflows` hook, the "Dynamic" workflow filter and badge, and the trigger-schema scraper that derived an input form from a stored graph's `$ref` bindings.
+
+  Kept, because static graph workflows depend on them and this is not a change to versioning:
+  - `upsertWorkflowVersion`, `getWorkflowVersion`, `updateWorkflowVersionStatus`, and the `workflowVersions` storage in every backend. These back version-mismatch replay: when a deployed graph's hash changes, in-flight runs continue against the exact graph they started on. No schema migration is needed — the table, its columns, and its `(workflowName, graphHash)` upsert key are unchanged.
+  - `generateMermaidDiagram`, which renders any workflow graph and is not specific to dynamic ones.
+
+  Static `pikkuWorkflowGraph` and DSL workflows are entirely unaffected: they resolve from codegen'd meta, which was always the only path that worked.
+
+  To revive this post-MVP, the deleted authoring code is recoverable in full — its prompt engineering (a compact tool table upfront, full schemas with flattened dotted output paths returned only after a validation failure) is worth reading before rewriting:
+
+  ```
+  git show f52f3308b^:packages/core/src/wirings/ai-agent/agent-dynamic-workflow.ts
+  git show f52f3308b^:packages/core/src/wirings/workflow/graph/graph-validation.ts
+  git show f52f3308b --stat   # the April removal, incl. the three e2e feature files
+  ```
+
+  Note that reviving it needs more than restoring those files: the queued-step path (`executeWorkflowStep`), `onError` compensation, and sub-workflow resolution all read static meta only and would need a fallback for a graph that exists solely in the database.
+
+- 09973b9: Scenarios, features and steps no longer reach a deployment.
+
+  Steps were already held back from the app bootstrap, so a deployed server never imported a step body. Everything _about_ a scenario still travelled with the application: a `pikkuScenario(...)` is a function, so its name, schemas and hashes sat in the app function meta; the schemas it and its steps validate against sat in the app's `register.gen.ts` — on one project 458 of the 582 registered schemas belonged to tests; its name sat in the internal RPC meta; and because a scenario is _also_ a workflow, the inspector synthesised a `wf-orchestrator-<scenario>` queue worker for each one. The deploy analyzer, which reads inspector state rather than the partitioned codegen output, then read all of it back as application code: a unit per scenario, a `WorkflowDefinition` per scenario, and a real queue per scenario. A 13-scenario suite turned into 13 production queues named after tests, waiting for a provider to create them.
+
+  The existing scenario/app partition is now applied everywhere it was missing. `FunctionRuntimeMeta` gains a `scenario` marker (the counterpart of `scenarioStep`) so a scenario body is recognisable without walking the workflow graph; scenario bodies join their steps on the scenario side of the function-meta and registration split; schemas only a scenario or step needs are written and registered under `.pikku/scenarios/schemas/` and imported by the scenario bootstrap alone; scenario names are dropped from the internal RPC meta; no orchestrator queue worker is synthesised for a scenario; and the deploy analyzer drops both scenario functions and scenario workflows before it decides what a deployment contains.
+
+  The MCP metas are keyed by wiring rather than by function, so a scenario wired as an MCP tool, resource or prompt was the one id that still reached the manifest after the function and workflow filters — as an endpoint on the gateway plus a gateway dependency on a unit that was never emitted. Those ids are now filtered too.
+
+  `scenarioSchemaDirectory` is rejected when it resolves to the same directory as `schemaDirectory`. A schema write owns its directory — it emits `register.gen.ts` and prunes every schema file its own required-set does not name — so sharing one would replace the application register with the scenario-only one and delete the app's schema files, which nothing downstream can detect.
+
+  Nothing changes for `pikku scenario run` — the scenario bootstrap still registers every scenario, feature, step, meta and schema. What changes is that a bundle stops carrying them.
+
 ## 0.12.70
 
 ### Patch Changes

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 - present Yasser Fadl and Pikku contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/function/function-runner.js

@@ -2,7 +2,7 @@ import { runMiddleware, combineMiddleware } from '../middleware-runner.js';
 import { combineChannelMiddleware, wrapChannelWithMiddleware, } from '../wirings/channel/channel-middleware-runner.js';
 import { runPermissions } from '../permissions.js';
 import { pikkuState } from '../pikku-state.js';
-import { coerceTopLevelDataFromSchema, validateSchema } from '../schema.js';
+import { applyDefaultsFromSchema, coerceTopLevelDataFromSchema, validateSchema, } from '../schema.js';
 import { parseVersionedId } from '../version.js';
 import { PikkuSessionService } from '../services/user-session-service.js';
 import { ForbiddenError, ReadonlySessionError } from '../errors/errors.js';
@@ -166,10 +166,15 @@ export const runPikkuFunc = async (wireType, wireId, funcName, { singletonServic
         // evaluates the function's own OR-groups against request data.
         verifyScopes(funcConfig.scopes ?? funcMeta.scopes, session);
         // Evaluate the data from the lazy function
-        const actualData = await data();
+        let actualData = await data();
         // Validate and coerce data if schema is defined
         const inputSchemaName = funcMeta.inputSchemaName;
         if (inputSchemaName) {
+            // Fill in schema defaults before anything reads the data. Unconditional:
+            // a default belongs to the schema, not to the transport the call arrived
+            // on. Runs before coercion so a defaulted value and a supplied one are
+            // treated identically from here on.
+            actualData = applyDefaultsFromSchema(inputSchemaName, actualData, packageName);
             // Coerce (top level) data types before validation (e.g. string→array, string→date)
             if (coerceDataFromSchema) {
                 coerceTopLevelDataFromSchema(inputSchemaName, actualData, packageName);

package/dist/handle-error.d.ts

@@ -10,5 +10,7 @@ import type { PikkuHTTP } from './wirings/http/http.types.js';
  * @param {number[]} logWarningsForStatusCodes - HTTP status codes to log as warnings
  * @param {boolean} respondWith404 - Whether to respond with 404 for NotFoundError
  * @param {boolean} bubbleError - Whether to throw the error after handling
+ * @param {boolean} exposeErrors - Whether to include internal error details (message, stack and
+ * payload of 5xx errors) in the response body. Ignored in production.
  */
 export declare const handleHTTPError: (e: any, http: PikkuHTTP | undefined, traceId: string | undefined, logger: Logger, logWarningsForStatusCodes: number[], respondWith404: boolean, bubbleError: boolean, exposeErrors?: boolean) => void;

package/dist/handle-error.js

@@ -11,6 +11,8 @@ import { NotFoundError } from './errors/errors.js';
  * @param {number[]} logWarningsForStatusCodes - HTTP status codes to log as warnings
  * @param {boolean} respondWith404 - Whether to respond with 404 for NotFoundError
  * @param {boolean} bubbleError - Whether to throw the error after handling
+ * @param {boolean} exposeErrors - Whether to include internal error details (message, stack and
+ * payload of 5xx errors) in the response body. Ignored in production.
  */
 export const handleHTTPError = (e, http, traceId, logger, logWarningsForStatusCodes, respondWith404, bubbleError, exposeErrors = false) => {
     // Skip 404 handling if configured to do so
@@ -20,14 +22,18 @@ export const handleHTTPError = (e, http, traceId, logger, logWarningsForStatusCo
     // Get appropriate error response
     const errorResponse = getErrorResponse(e);
     if (errorResponse != null) {
+        const clientFacing = errorResponse.status < 500 || (exposeErrors && !isProduction());
         // Set status and response body
         http?.response?.status(errorResponse.status);
         http?.response?.json({
             name: e instanceof Error ? e.name : undefined,
-            message: e instanceof Error && e.message && e.message !== 'An error occurred'
+            message: clientFacing &&
+                e instanceof Error &&
+                e.message &&
+                e.message !== 'An error occurred'
                 ? e.message
                 : errorResponse.message,
-            payload: e.payload,
+            payload: clientFacing ? e.payload : undefined,
             errorId: traceId,
         });
         // Log certain status codes as warnings

package/dist/schema.d.ts

@@ -21,5 +21,29 @@ export declare const getSchema: (name: string, packageName?: string | null) => R
  * @param logger - A logger for logging information.
  */
 export declare const compileAllSchemas: (logger: Logger, schemaService?: SchemaService) => void;
+/**
+ * Fill in absent top-level properties from their schema `default`.
+ *
+ * A `default` reaches the generated JSON Schema and keeps the property out of
+ * `required`, so omitting it validates — but nothing was ever filling it in.
+ * JSON Schema validators are pure by specification and none of the ones Pikku
+ * ships with (`@cfworker/json-schema`, and Ajv unless `useDefaults` is set)
+ * annotate the instance, so the function received `undefined` for a property
+ * its generated type declares as present. That is the worst shape a mismatch
+ * can take: validation permits the omission, the type says the value is there,
+ * and the body reads `undefined`.
+ *
+ * Applied unconditionally rather than alongside `coerceTopLevelDataFromSchema`,
+ * whose `coerceDataFromSchema` flag is about decoding transport-encoded values
+ * (a query string's `"1,2"` into an array). Defaults are a property of the
+ * schema, not of how the call arrived, so gating them on that flag would apply
+ * them over HTTP and skip them on a direct RPC invocation.
+ *
+ * Returns the data to use, which is a new object only when defaults had to be
+ * added to a nullish input — a call made with no arguments at all still gets
+ * them. Values are cloned so an object or array default (`[]`, `{}`) is never
+ * shared as one mutable instance across every request.
+ */
+export declare const applyDefaultsFromSchema: (schemaName: string, data: any, packageName?: string | null) => any;
 export declare const coerceTopLevelDataFromSchema: (schemaName: string, data: any, packageName?: string | null) => void;
 export declare const validateSchema: (logger: Logger, schemaService: SchemaService | undefined, schemaName: string | undefined | null, data: any, packageName?: string | null) => Promise<void>;

package/dist/schema.js

@@ -65,6 +65,52 @@ const validateAllSchemasLoaded = (logger, schemaService) => {
         logger.info('All schemas loaded');
     }
 };
+/**
+ * Fill in absent top-level properties from their schema `default`.
+ *
+ * A `default` reaches the generated JSON Schema and keeps the property out of
+ * `required`, so omitting it validates — but nothing was ever filling it in.
+ * JSON Schema validators are pure by specification and none of the ones Pikku
+ * ships with (`@cfworker/json-schema`, and Ajv unless `useDefaults` is set)
+ * annotate the instance, so the function received `undefined` for a property
+ * its generated type declares as present. That is the worst shape a mismatch
+ * can take: validation permits the omission, the type says the value is there,
+ * and the body reads `undefined`.
+ *
+ * Applied unconditionally rather than alongside `coerceTopLevelDataFromSchema`,
+ * whose `coerceDataFromSchema` flag is about decoding transport-encoded values
+ * (a query string's `"1,2"` into an array). Defaults are a property of the
+ * schema, not of how the call arrived, so gating them on that flag would apply
+ * them over HTTP and skip them on a direct RPC invocation.
+ *
+ * Returns the data to use, which is a new object only when defaults had to be
+ * added to a nullish input — a call made with no arguments at all still gets
+ * them. Values are cloned so an object or array default (`[]`, `{}`) is never
+ * shared as one mutable instance across every request.
+ */
+export const applyDefaultsFromSchema = (schemaName, data, packageName = null) => {
+    const schema = pikkuState(packageName, 'misc', 'schemas').get(schemaName);
+    if (!schema?.properties)
+        return data;
+    // A primitive body cannot carry named properties; leave it for the validator
+    // to reject rather than reshaping it into something that would pass.
+    if (data != null && typeof data !== 'object')
+        return data;
+    let result = data;
+    for (const key in schema.properties) {
+        const property = schema.properties[key];
+        if (typeof property === 'boolean' || !('default' in property)) {
+            continue;
+        }
+        // Allocated only once a default is actually found, so a schema without any
+        // leaves the caller's data (and its absence) exactly as it was.
+        result ??= {};
+        if (result[key] === undefined) {
+            result[key] = structuredClone(property.default);
+        }
+    }
+    return result;
+};
 export const coerceTopLevelDataFromSchema = (schemaName, data, packageName = null) => {
     const schema = pikkuState(packageName, 'misc', 'schemas').get(schemaName);
     if (!schema?.properties)

package/dist/services/in-memory-queue-service.d.ts

@@ -5,6 +5,12 @@ import type { QueueService, JobOptions } from '../wirings/queue/queue.types.js';
  * a real queue — and redelivers a failed job up to `options.attempts` times with
  * backoff, so a transiently-failing workflow step recovers exactly as it would
  * on pg-boss/bullmq instead of being silently dropped on its first error.
+ *
+ * Payloads are JSON round-tripped on the way in, because every real backend
+ * puts the job on a wire (SQS body, Redis value, jsonb column) and the worker
+ * therefore never sees the caller's live object. Doing it here keeps dev
+ * behaviour honest, and keeps the callers — who cannot know which backend they
+ * are talking to — from having to serialise defensively.
  */
 export declare class InMemoryQueueService implements QueueService {
     readonly supportsResults = false;

package/dist/services/in-memory-queue-service.js

@@ -5,6 +5,12 @@ import { runQueueJob } from '../wirings/queue/queue-runner.js';
  * a real queue — and redelivers a failed job up to `options.attempts` times with
  * backoff, so a transiently-failing workflow step recovers exactly as it would
  * on pg-boss/bullmq instead of being silently dropped on its first error.
+ *
+ * Payloads are JSON round-tripped on the way in, because every real backend
+ * puts the job on a wire (SQS body, Redis value, jsonb column) and the worker
+ * therefore never sees the caller's live object. Doing it here keeps dev
+ * behaviour honest, and keeps the callers — who cannot know which backend they
+ * are talking to — from having to serialise defensively.
  */
 export class InMemoryQueueService {
     supportsResults = false;
@@ -14,12 +20,13 @@ export class InMemoryQueueService {
         const maxAttempts = Math.max(1, options?.attempts ?? 1);
         let attemptsMade = 0;
         const createdAt = new Date();
+        const payload = data === undefined ? data : JSON.parse(JSON.stringify(data));
         const runAttempt = async () => {
             attemptsMade++;
             const job = {
                 id: jobId,
                 queueName,
-                data,
+                data: payload,
                 status: () => 'active',
                 metadata: () => ({ attemptsMade, maxAttempts, createdAt }),
                 pikkuUserId: options?.pikkuUserId,

package/dist/services/in-memory-workflow-service.d.ts

@@ -66,6 +66,9 @@ export declare class InMemoryWorkflowService extends PikkuWorkflowService implem
         branchKeys: Record<string, string>;
     }>;
     getNodesWithoutSteps(runId: string, nodeIds: string[]): Promise<string[]>;
+    protected listStepStates(runId: string): Promise<Array<StepState & {
+        stepName: string;
+    }>>;
     getStepInstances(runId: string): Promise<Array<{
         stepName: string;
         status: StepStatus;
@@ -82,9 +85,4 @@ export declare class InMemoryWorkflowService extends PikkuWorkflowService implem
         graph: any;
         source: string;
     } | null>;
-    getAIGeneratedWorkflows(agentName?: string): Promise<Array<{
-        workflowName: string;
-        graphHash: string;
-        graph: any;
-    }>>;
 }

package/dist/services/in-memory-workflow-service.js

@@ -324,6 +324,16 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
         }
         return nodeIds.filter((id) => !existingSteps.has(id));
     }
+    async listStepStates(runId) {
+        const prefix = `${runId}:`;
+        const steps = [];
+        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) {
         const prefix = `${runId}:`;
         const instances = [];
@@ -387,23 +397,4 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
             return null;
         return { graph: version.graph, source: version.source };
     }
-    async getAIGeneratedWorkflows(agentName) {
-        const results = [];
-        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/dist/services/workflow-service.d.ts

@@ -35,6 +35,13 @@ export interface WorkflowService {
     }): 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, rpcService: any, options?: {
         pollIntervalMs?: number;
         wire?: WorkflowRunWire;
@@ -60,9 +67,4 @@ export interface WorkflowService {
         graph: any;
         source: string;
     } | null>;
-    getAIGeneratedWorkflows(agentName?: string): Promise<Array<{
-        workflowName: string;
-        graphHash: string;
-        graph: any;
-    }>>;
 }

package/dist/types/core.types.d.ts

@@ -95,6 +95,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/dist/wirings/ai-agent/ai-agent-agui.js

@@ -256,14 +256,6 @@ export function wrapChannelWithAGUI(inner, options) {
                     });
                     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/dist/wirings/ai-agent/ai-agent-prepare.js

@@ -312,8 +312,7 @@ export function createScopedChannel(parent, agentName, session) {
                 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 });
             }
             else {

package/dist/wirings/ai-agent/ai-agent.types.d.ts

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

package/dist/wirings/http/http-runner.d.ts

@@ -116,4 +116,4 @@ export declare const pikkuFetch: <In, Out>(request: Request | PikkuHTTPRequest,
  * @param {RunHTTPWiringOptions} options - Options such as singleton services, session handling, and error configuration.
  * @returns {Promise<Out | void>} The output from the route handler or void if an error occurred.
  */
-export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, exposeErrors, generateRequestId, traceId: externalTraceId, }?: RunHTTPWiringOptions) => Promise<Out | void>;
+export declare const fetchData: <In, Out>(request: Request | PikkuHTTPRequest, response: PikkuHTTPResponse, { skipUserSession, respondWith404, logWarningsForStatusCodes, coerceDataFromSchema, bubbleErrors, exposeErrors, generateRequestId, traceId: externalTraceId, maxBodySize, }?: RunHTTPWiringOptions) => Promise<Out | void>;

package/dist/wirings/http/http-runner.js

@@ -386,13 +386,15 @@ export const pikkuFetch = async (request, params = {}) => {
  */
 export const fetchData = async (request, response, { skipUserSession = false, respondWith404 = true, logWarningsForStatusCodes = [], coerceDataFromSchema = true, bubbleErrors = false, 
 // Surface the error message + stack on unexpected 500s unless in production.
-exposeErrors = !isProduction(), generateRequestId, traceId: externalTraceId, } = {}) => {
+exposeErrors = !isProduction(), generateRequestId, traceId: externalTraceId, maxBodySize, } = {}) => {
     const singletonServices = getSingletonServices();
     const createWireServices = getCreateWireServices();
     let wireServices;
     let result;
     // Combine the request and response into one wire object
-    const pikkuRequest = request instanceof Request ? new PikkuFetchHTTPRequest(request) : request;
+    const pikkuRequest = request instanceof Request
+        ? new PikkuFetchHTTPRequest(request, { maxBodySize })
+        : request;
     // Resolve traceId: external (e.g. CF-Ray) > x-request-id header > generated
     let requestId = externalTraceId ?? null;
     if (!requestId) {

package/dist/wirings/http/http.types.d.ts

@@ -19,6 +19,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;
 }>;
 /**
  * Represents the HTTP methods supported for API HTTP wirings.

package/dist/wirings/http/index.d.ts

@@ -1,4 +1,5 @@
-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';
 export { fetch, fetchData, wireHTTP, addHTTPMiddleware, addHTTPPermission, } from './http-runner.js';

package/dist/wirings/http/index.js

@@ -1,4 +1,4 @@
-export { PikkuFetchHTTPRequest } from './pikku-fetch-http-request.js';
+export { PikkuFetchHTTPRequest, DEFAULT_MAX_BODY_SIZE, } from './pikku-fetch-http-request.js';
 export { PikkuFetchHTTPResponse } from './pikku-fetch-http-response.js';
 export { logRoutes } from './log-http-routes.js';
 export { fetch, fetchData, wireHTTP, addHTTPMiddleware, addHTTPPermission, } from './http-runner.js';

package/dist/wirings/http/pikku-fetch-http-request.d.ts

@@ -1,4 +1,14 @@
 import type { HTTPMethod, PikkuHTTPRequest, PikkuQuery } from './http.types.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 declare const DEFAULT_MAX_BODY_SIZE: number;
+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.
  * @template In - The type of the request body.
@@ -7,7 +17,7 @@ import type { HTTPMethod, PikkuHTTPRequest, PikkuQuery } from './http.types.js';
 export declare class PikkuFetchHTTPRequest<In = unknown> implements PikkuHTTPRequest<In> {
     #private;
     private request;
-    constructor(request: Request);
+    constructor(request: Request, { maxBodySize }?: PikkuFetchHTTPRequestOptions);
     method(): HTTPMethod;
     path(): string;
     /**