@pikku/core 0.12.4 → 0.12.6

package/CHANGELOG.md

@@ -1,9 +1,29 @@
-## 0.12.0
+## 0.12.4
+
+## 0.12.6
+
+### Patch Changes
+
+- bb27710: Add optional `uploadHeaders` to `ContentService.getUploadURL` return type, allowing storage backends (e.g. Backblaze B2) to provide required headers for direct uploads.
+- a31bc63: Fix SSE error handler to send `[DONE]` as JSON (`{"type":"done"}`) for consistency with all other SSE messages.
+- 3e79248: Add setStepChildRunId to workflow service implementations and auto-bootstrap in pikku all
+- b0a81cc: Support sub-workflows in `workflow.do()`: when a string name is passed, it now checks if the name refers to a registered workflow and runs it as a sub-workflow, falling back to RPC invocation if not found. The `TypedWorkflow.do` type now also accepts workflow names with typed input/output. Steps that spawn sub-workflows expose `childRunId` on the step state so clients can stream sub-workflow progress.
+- 6413df7: Propagate session and RPC service from the originating request to workflow runs, fixing "Authentication required" errors for workflows with `auth: true`.
+
+## 0.12.5
+
+### Patch Changes
+
+- 198e68f: Add hot-reload for dev mode: reload functions, middleware, and permissions without server restart.
 
 ## 0.12.4
 
 ### Patch Changes
 
+- 688b5e8: InMemoryWorkflowService now implements WorkflowRunService interface, adding listRuns, getRunSteps, getDistinctWorkflowNames, and deleteRun methods.
+
+### Patch Changes
+
 - InMemoryWorkflowService now implements WorkflowRunService interface (listRuns, getRunSteps, getDistinctWorkflowNames, deleteRun)
 
 ## 0.12.3

package/dist/dev/hot-reload.d.ts

@@ -0,0 +1,10 @@
+import type { Logger } from '../services/logger.js';
+interface PikkuDevReloaderOptions {
+    srcDirectories: string[];
+    logger: Logger;
+    pikkuDir?: string;
+}
+export declare function pikkuDevReloader(options: PikkuDevReloaderOptions): Promise<{
+    close: () => void;
+}>;
+export {};

package/dist/dev/hot-reload.js

@@ -0,0 +1,158 @@
+import { watch } from 'node:fs';
+import { stat, readFile } from 'node:fs/promises';
+import { join, resolve, relative } from 'node:path';
+import { pikkuState } from '../pikku-state.js';
+import { addFunction } from '../function/function-runner.js';
+import { clearMiddlewareCache } from '../middleware-runner.js';
+import { clearPermissionsCache } from '../permissions.js';
+import { clearChannelMiddlewareCache } from '../wirings/channel/channel-middleware-runner.js';
+import { httpRouter } from '../wirings/http/routers/http-router.js';
+import { addSchema, compileAllSchemas } from '../schema.js';
+const isFunctionConfig = (value) => {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'func' in value &&
+        typeof value.func === 'function');
+};
+const findCompiledFile = async (tsFile, srcDir, pikkuDir) => {
+    const rel = relative(srcDir, tsFile).replace(/\.ts$/, '.js');
+    const candidates = [
+        join(pikkuDir, 'dist', rel),
+        join(srcDir, rel),
+        tsFile.replace(/\.ts$/, '.js'),
+    ];
+    for (const candidate of candidates) {
+        try {
+            await stat(candidate);
+            return candidate;
+        }
+        catch {
+            // not found, try next
+        }
+    }
+    return null;
+};
+// Use data: URLs to import modules. This bypasses TypeScript loaders
+// (e.g. tsx) that intercept file:// imports and break dynamic ESM loading.
+// Each import gets unique content so there's no module cache to worry about.
+const reimportModule = async (filePath) => {
+    try {
+        const content = await readFile(resolve(filePath), 'utf-8');
+        const dataUrl = 'data:text/javascript;base64,' + Buffer.from(content).toString('base64');
+        return await import(dataUrl);
+    }
+    catch {
+        return null;
+    }
+};
+const isWatchedTsFile = (filename) => {
+    return (filename.endsWith('.ts') &&
+        !filename.endsWith('.test.ts') &&
+        !filename.endsWith('.d.ts') &&
+        !filename.endsWith('.gen.ts'));
+};
+export async function pikkuDevReloader(options) {
+    const { srcDirectories, logger, pikkuDir = '.pikku' } = options;
+    const absSrcDirs = srcDirectories.map((d) => resolve(d));
+    const absPikkuDir = resolve(pikkuDir);
+    const watchers = [];
+    const functionsMap = pikkuState(null, 'function', 'functions');
+    const handleFileChange = async (changedTsFile) => {
+        const start = Date.now();
+        const reloadedNames = [];
+        const srcDir = absSrcDirs.find((d) => changedTsFile.startsWith(d));
+        if (!srcDir)
+            return;
+        const compiledFile = await findCompiledFile(changedTsFile, srcDir, absPikkuDir);
+        if (!compiledFile) {
+            logger.warn(`Could not find compiled JS for: ${relative(process.cwd(), changedTsFile)}`);
+            return;
+        }
+        const mod = await reimportModule(compiledFile);
+        if (!mod) {
+            logger.error(`Failed to import: ${relative(process.cwd(), compiledFile)} (keeping old code)`);
+            return;
+        }
+        let schemasChanged = false;
+        for (const [exportName, exportValue] of Object.entries(mod)) {
+            if (isFunctionConfig(exportValue) && functionsMap.has(exportName)) {
+                addFunction(exportName, exportValue);
+                reloadedNames.push(exportName);
+                if (exportValue.input) {
+                    addSchema(exportName, exportValue.input);
+                    schemasChanged = true;
+                }
+                if (exportValue.output) {
+                    addSchema(`${exportName}Output`, exportValue.output);
+                    schemasChanged = true;
+                }
+            }
+        }
+        if (reloadedNames.length > 0) {
+            clearMiddlewareCache();
+            clearPermissionsCache();
+            clearChannelMiddlewareCache();
+            httpRouter.reset();
+            if (schemasChanged) {
+                try {
+                    compileAllSchemas(logger);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    if (msg.includes('SchemaService') ||
+                        (msg.includes('schema') && msg.includes('not'))) {
+                        logger.warn('Schema recompilation skipped (no SchemaService)');
+                    }
+                    else {
+                        logger.error(`Schema recompilation failed: ${msg}`);
+                        return;
+                    }
+                }
+            }
+            const elapsed = Date.now() - start;
+            logger.info(`Hot-reloaded: ${reloadedNames.join(', ')} (${elapsed}ms)`);
+        }
+    };
+    let debounceTimer;
+    const pendingChanges = new Set();
+    const scheduleReload = (filePath) => {
+        pendingChanges.add(filePath);
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(async () => {
+            const files = [...pendingChanges];
+            pendingChanges.clear();
+            for (const file of files) {
+                try {
+                    await handleFileChange(file);
+                }
+                catch (err) {
+                    logger.error(`Hot-reload error for ${relative(process.cwd(), file)}: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        }, 50);
+    };
+    for (const srcDir of absSrcDirs) {
+        try {
+            const watcher = watch(srcDir, { recursive: true }, (eventType, filename) => {
+                if (filename && isWatchedTsFile(filename)) {
+                    scheduleReload(join(srcDir, filename));
+                }
+            });
+            watchers.push(watcher);
+        }
+        catch (err) {
+            logger.error(`Failed to watch directory ${srcDir}: ${err?.message || err}`);
+        }
+    }
+    logger.info(`Hot-reload active for: ${srcDirectories.join(', ')}`);
+    return {
+        close: () => {
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            for (const watcher of watchers) {
+                watcher.close();
+            }
+        },
+    };
+}

package/dist/middleware-runner.d.ts

@@ -51,6 +51,7 @@ export declare const runMiddleware: <Middleware extends CorePikkuMiddleware>(ser
  * ```
  */
 export declare const addMiddleware: <PikkuMiddleware extends CorePikkuMiddleware>(tag: string, middleware: CorePikkuMiddlewareGroup, packageName?: string | null) => CorePikkuMiddlewareGroup;
+export declare const clearMiddlewareCache: () => void;
 /**
  * Combines wiring-specific middleware with function-level middleware.
  *

package/dist/middleware-runner.js

@@ -98,6 +98,11 @@ const middlewareCache = {
     workflow: {},
     gateway: {},
 };
+export const clearMiddlewareCache = () => {
+    for (const key of Object.keys(middlewareCache)) {
+        middlewareCache[key] = {};
+    }
+};
 /**
  * Combines wiring-specific middleware with function-level middleware.
  *

package/dist/permissions.d.ts

@@ -29,6 +29,7 @@ import type { CorePermissionGroup, CorePikkuPermission } from './function/functi
  * ```
  */
 export declare const addPermission: (tag: string, permissions: CorePermissionGroup | CorePikkuPermission[], packageName?: string | null) => CorePermissionGroup | CorePikkuPermission[];
+export declare const clearPermissionsCache: () => void;
 /**
  * Runs permission checks using combined permissions from all sources.
  * Combines permissions from wire and function levels, then validates them.

package/dist/permissions.js

@@ -101,6 +101,11 @@ const combinedPermissionsCache = {
     workflow: {},
     gateway: {},
 };
+export const clearPermissionsCache = () => {
+    for (const key of Object.keys(combinedPermissionsCache)) {
+        combinedPermissionsCache[key] = {};
+    }
+};
 /**
  * Combines wiring-specific permissions with function-level permissions.
  *

package/dist/services/content-service.d.ts

@@ -22,6 +22,8 @@ export interface ContentService {
     getUploadURL(fileKey: string, contentType: string): Promise<{
         uploadUrl: string;
         assetKey: string;
+        uploadHeaders?: Record<string, string>;
+        uploadMethod?: 'PUT' | 'POST';
     }>;
     /**
      * Deletes a file from the storage backend.

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

@@ -36,6 +36,7 @@ export declare class InMemoryWorkflowService extends PikkuWorkflowService implem
     setStepScheduled(stepId: string): Promise<void>;
     setStepResult(stepId: string, result: any): Promise<void>;
     setStepError(stepId: string, error: Error): Promise<void>;
+    setStepChildRunId(stepId: string, childRunId: string): Promise<void>;
     createRetryAttempt(failedStepId: string, status: 'pending' | 'running'): Promise<StepState>;
     listRuns(options?: {
         workflowName?: string;

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

@@ -73,13 +73,14 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
             retryDelay: stepOptions?.retryDelay,
             createdAt: now,
             updatedAt: now,
+            stepName,
         };
         const key = `${runId}:${stepName}`;
         this.steps.set(key, step);
         this.stepData.set(stepId, { rpcName, data, stepName });
-        // Add to history
+        // Add to history (same reference so mutations are reflected)
         const history = this.stepHistory.get(runId) || [];
-        history.push({ ...step, stepName });
+        history.push(step);
         this.stepHistory.set(runId, history);
         return step;
     }
@@ -87,13 +88,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
         const key = `${runId}:${stepName}`;
         const step = this.steps.get(key);
         if (!step) {
-            return {
-                stepId: '',
-                status: 'pending',
-                attemptCount: 0,
-                createdAt: new Date(),
-                updatedAt: new Date(),
-            };
+            throw new Error(`Step not found: runId=${runId}, stepName=${stepName}. Use insertStepState to create it.`);
         }
         return step;
     }
@@ -143,6 +138,15 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
             }
         }
     }
+    async setStepChildRunId(stepId, childRunId) {
+        for (const step of this.steps.values()) {
+            if (step.stepId === stepId) {
+                step.childRunId = childRunId;
+                step.updatedAt = new Date();
+                break;
+            }
+        }
+    }
     async createRetryAttempt(failedStepId, status) {
         // Find the failed step
         let failedStep;
@@ -171,6 +175,7 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
             retryDelay: failedStep.retryDelay,
             createdAt: now,
             updatedAt: now,
+            stepName: stepName,
         };
         if (status === 'running') {
             newStep.runningAt = now;
@@ -181,9 +186,9 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
         if (failedStepData) {
             this.stepData.set(newStepId, { ...failedStepData });
         }
-        // Add to history
+        // Add to history (same reference so mutations are reflected)
         const history = this.stepHistory.get(runId) || [];
-        history.push({ ...newStep, stepName });
+        history.push(newStep);
         this.stepHistory.set(runId, history);
         return newStep;
     }

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

@@ -31,6 +31,7 @@ export interface WorkflowService {
     setStepRunning(stepId: string): Promise<void>;
     setStepScheduled(stepId: string): Promise<void>;
     setStepResult(stepId: string, result: any): Promise<void>;
+    setStepChildRunId(stepId: string, childRunId: string): Promise<void>;
     setStepError(stepId: string, error: Error): Promise<void>;
     createRetryAttempt(stepId: string, status: 'pending' | 'running'): Promise<StepState>;
     executeWorkflowStep(runId: string, stepName: string, rpcName: string | null, data: any, rpcService: any): Promise<void>;

package/dist/wirings/ai-agent/ai-agent-prepare.js

@@ -5,7 +5,7 @@ import { randomUUID } from 'crypto';
 import { streamAIAgent } from './ai-agent-stream.js';
 import { runAIAgent } from './ai-agent-runner.js';
 import { resolveNamespace, ContextAwareRPCService, } from '../../wirings/rpc/rpc-runner.js';
-import { buildDynamicWorkflowInstructions, buildWorkflowTools } from './agent-dynamic-workflow.js';
+import { buildDynamicWorkflowInstructions, buildWorkflowTools, } from './agent-dynamic-workflow.js';
 import { resolveMemoryServices, loadContextMessages, trimMessages, } from './ai-agent-memory.js';
 import { resolveModelConfig } from './ai-agent-model-config.js';
 export class ToolApprovalRequired extends PikkuError {
@@ -272,6 +272,21 @@ export async function buildToolDefs(params, agentSessionMap, resourceId, agentNa
                     }
                     // No stream context: sub-agent runs non-streaming
                     const result = await runAIAgent(subAgentName, { message, threadId, resourceId }, params, agentSessionMap);
+                    if (result.status === 'suspended' &&
+                        result.pendingApprovals?.length) {
+                        return {
+                            __approvalRequired: true,
+                            toolName: subAgentName,
+                            args: toolInput,
+                            agentRunId: result.runId,
+                            subApprovals: result.pendingApprovals.map((a) => ({
+                                toolCallId: a.toolCallId,
+                                toolName: a.toolName,
+                                args: a.args,
+                                runId: a.runId,
+                            })),
+                        };
+                    }
                     return result.object ?? result.text;
                 },
             });

package/dist/wirings/channel/channel-middleware-runner.d.ts

@@ -1,6 +1,7 @@
 import type { CoreSingletonServices, MiddlewareMetadata, PikkuWire } from '../../types/core.types.js';
 import type { CorePikkuChannelMiddleware } from './channel.types.js';
 export declare const addChannelMiddleware: (tag: string, middleware: CorePikkuChannelMiddleware[], packageName?: string | null) => CorePikkuChannelMiddleware[];
+export declare const clearChannelMiddlewareCache: () => void;
 export declare const combineChannelMiddleware: (wireType: string, uid: string, { wireInheritedChannelMiddleware, wireChannelMiddleware, packageName, }?: {
     wireInheritedChannelMiddleware?: MiddlewareMetadata[];
     wireChannelMiddleware?: CorePikkuChannelMiddleware[];

package/dist/wirings/channel/channel-middleware-runner.js

@@ -11,6 +11,11 @@ const getChannelMiddlewareByName = (name) => {
     return middleware?.[0];
 };
 const channelMiddlewareCache = {};
+export const clearChannelMiddlewareCache = () => {
+    for (const key of Object.keys(channelMiddlewareCache)) {
+        delete channelMiddlewareCache[key];
+    }
+};
 export const combineChannelMiddleware = (wireType, uid, { wireInheritedChannelMiddleware, wireChannelMiddleware, packageName = null, } = {}) => {
     const cacheKey = `${wireType}:${uid}`;
     if (channelMiddlewareCache[cacheKey]) {

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

@@ -402,7 +402,7 @@ export const fetchData = async (request, response, { skipUserSession = false, re
                     type: 'error',
                     errorText: e instanceof Error ? e.message : String(e),
                 }));
-                response.arrayBuffer('[DONE]');
+                response.arrayBuffer(JSON.stringify({ type: 'done' }));
             }
             catch (streamErr) {
                 singletonServices.logger.error(`SSE error while sending error payload: ${streamErr instanceof Error ? streamErr.message : String(streamErr)}`);

package/dist/wirings/workflow/pikku-workflow-service.d.ts

@@ -119,6 +119,12 @@ export declare abstract class PikkuWorkflowService implements WorkflowService {
      * @param result - Step result
      */
     abstract setStepResult(stepId: string, result: any): Promise<void>;
+    /**
+     * Set the child workflow run ID on a step
+     * @param stepId - Step ID
+     * @param childRunId - Child workflow run ID
+     */
+    abstract setStepChildRunId(stepId: string, childRunId: string): Promise<void>;
     /**
      * Store step error and mark as failed
      * Updates both workflow_step and workflow_step_history

package/dist/wirings/workflow/pikku-workflow-service.js

@@ -175,17 +175,16 @@ export class PikkuWorkflowService {
         if (!workflowMeta.graphHash) {
             throw new Error(`Missing workflow graphHash for '${name}'`);
         }
-        const runId = await this.createRun(name, input, options?.inline ?? false, workflowMeta.graphHash, wire);
-        if (options?.inline) {
+        const shouldInline = options?.inline || !getSingletonServices()?.queueService;
+        const runId = await this.createRun(name, input, shouldInline, workflowMeta.graphHash, wire);
+        if (shouldInline) {
             this.inlineRuns.add(runId);
-        }
-        if (options?.inline || !getSingletonServices()?.queueService) {
             this.runWorkflowJob(runId, rpcService)
-                .catch(() => { })
+                .catch((err) => {
+                getSingletonServices().logger.error(`Workflow ${name} (run ${runId}) failed:`, err);
+            })
                 .finally(() => {
-                if (options?.inline) {
-                    this.inlineRuns.delete(runId);
-                }
+                this.inlineRuns.delete(runId);
             });
         }
         else {
@@ -237,7 +236,11 @@ export class PikkuWorkflowService {
         }
         await this.withRunLock(runId, async () => {
             const workflowWire = this.createWorkflowWire(run.workflow, runId, rpcService);
-            const wire = { workflow: workflowWire };
+            const wire = {
+                workflow: workflowWire,
+                session: rpcService.wire?.session,
+                rpc: rpcService.wire?.rpc,
+            };
             try {
                 const result = await runPikkuFunc('workflow', workflowMeta.name, workflowMeta.pikkuFuncId, {
                     singletonServices: getSingletonServices(),
@@ -460,13 +463,45 @@ export class PikkuWorkflowService {
             while (true) {
                 try {
                     await this.setStepRunning(currentStepState.stepId);
-                    const result = await rpcService.rpcWithWire(rpcName, data, {
-                        workflowStep: {
-                            runId,
-                            stepId: currentStepState.stepId,
-                            attemptCount: currentStepState.attemptCount,
-                        },
-                    });
+                    // Check if the name refers to a workflow
+                    const workflowMeta = pikkuState(null, 'workflows', 'meta')[rpcName];
+                    let result;
+                    if (workflowMeta) {
+                        const childWire = {
+                            type: 'workflow',
+                            id: rpcName,
+                            parentRunId: runId,
+                        };
+                        const { runId: childRunId } = await this.startWorkflow(rpcName, data, childWire, rpcService, { inline: true });
+                        await this.setStepChildRunId(currentStepState.stepId, childRunId);
+                        // Poll until child workflow completes
+                        while (true) {
+                            const childRun = await this.getRun(childRunId);
+                            if (!childRun) {
+                                throw new WorkflowRunNotFoundError(childRunId);
+                            }
+                            if (WORKFLOW_END_STATES.has(childRun.status)) {
+                                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;
+                                break;
+                            }
+                            await new Promise((resolve) => setTimeout(resolve, 500));
+                        }
+                    }
+                    else {
+                        result = await rpcService.rpcWithWire(rpcName, data, {
+                            workflowStep: {
+                                runId,
+                                stepId: currentStepState.stepId,
+                                attemptCount: currentStepState.attemptCount,
+                            },
+                        });
+                    }
                     await this.setStepResult(currentStepState.stepId, result);
                     return result;
                 }

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

@@ -76,6 +76,8 @@ export interface StepState {
     createdAt: Date;
     /** Last update timestamp */
     updatedAt: Date;
+    /** Child workflow run ID (if this step spawned a sub-workflow) */
+    childRunId?: string;
     /** Timestamp when step started running */
     runningAt?: Date;
     /** Timestamp when step was scheduled */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/core",
-  "version": "0.12.4",
+  "version": "0.12.6",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",
@@ -13,7 +13,8 @@
     "release": "npm run build && npm test",
     "test": "bash run-tests.sh",
     "test:watch": "bash run-tests.sh --watch",
-    "test:coverage": "bash run-tests.sh --coverage"
+    "test:coverage": "bash run-tests.sh --coverage",
+    "prepublishOnly": "yarn build"
   },
   "exports": {
     ".": "./dist/index.js",
@@ -44,7 +45,8 @@
     "./crypto-utils": "./dist/crypto-utils.js",
     "./internal": "./dist/internal.js",
     "./schema": "./dist/schema.js",
-    "./testing": "./dist/testing/index.js"
+    "./testing": "./dist/testing/index.js",
+    "./dev": "./dist/dev/hot-reload.js"
   },
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",