@exaudeus/workrail 2.1.0 → 3.1.0

package/dist/application/services/compiler/resolve-templates.d.ts

@@ -9,5 +9,10 @@ export type ResolveTemplatesPassError = {
     readonly code: 'TEMPLATE_EXPAND_ERROR';
     readonly stepId: string;
     readonly cause: TemplateExpandError;
+} | {
+    readonly code: 'DUPLICATE_STEP_ID';
+    readonly stepId: string;
+    readonly templateId: string;
+    readonly message: string;
 };
 export declare function resolveTemplatesPass(steps: readonly (WorkflowStepDefinition | LoopStepDefinition)[], registry: TemplateRegistry): Result<readonly (WorkflowStepDefinition | LoopStepDefinition)[], ResolveTemplatesPassError>;

package/dist/application/services/compiler/resolve-templates.js

@@ -23,10 +23,17 @@ function resolveStepTemplate(step, registry) {
             cause: expandResult.error,
         });
     }
+    if (step.runCondition) {
+        return (0, neverthrow_1.ok)(expandResult.value.map(expanded => ({
+            ...expanded,
+            runCondition: expanded.runCondition ?? step.runCondition,
+        })));
+    }
     return (0, neverthrow_1.ok)(expandResult.value);
 }
 function resolveTemplatesPass(steps, registry) {
     const resolved = [];
+    const seenIds = new Set();
     for (const step of steps) {
         if ((0, workflow_definition_js_1.isLoopStepDefinition)(step)) {
             if (Array.isArray(step.body)) {
@@ -35,11 +42,22 @@ function resolveTemplatesPass(steps, registry) {
                     const res = resolveStepTemplate(bodyStep, registry);
                     if (res.isErr())
                         return (0, neverthrow_1.err)(res.error);
+                    for (const expanded of res.value) {
+                        const collision = checkIdCollision(expanded.id, bodyStep.templateCall?.templateId, seenIds);
+                        if (collision)
+                            return (0, neverthrow_1.err)(collision);
+                    }
                     bodyResolved.push(...res.value);
                 }
+                const loopCollision = checkIdCollision(step.id, undefined, seenIds);
+                if (loopCollision)
+                    return (0, neverthrow_1.err)(loopCollision);
                 resolved.push({ ...step, body: bodyResolved });
             }
             else {
+                const loopCollision = checkIdCollision(step.id, undefined, seenIds);
+                if (loopCollision)
+                    return (0, neverthrow_1.err)(loopCollision);
                 resolved.push(step);
             }
         }
@@ -47,8 +65,25 @@ function resolveTemplatesPass(steps, registry) {
             const res = resolveStepTemplate(step, registry);
             if (res.isErr())
                 return (0, neverthrow_1.err)(res.error);
+            for (const expanded of res.value) {
+                const collision = checkIdCollision(expanded.id, step.templateCall?.templateId, seenIds);
+                if (collision)
+                    return (0, neverthrow_1.err)(collision);
+            }
             resolved.push(...res.value);
         }
     }
     return (0, neverthrow_1.ok)(resolved);
 }
+function checkIdCollision(stepId, templateId, seenIds) {
+    if (seenIds.has(stepId)) {
+        return {
+            code: 'DUPLICATE_STEP_ID',
+            stepId,
+            templateId: templateId ?? '(none)',
+            message: `Duplicate step id '${stepId}' after template expansion${templateId ? ` (from template '${templateId}')` : ''}`,
+        };
+    }
+    seenIds.add(stepId);
+    return undefined;
+}

package/dist/application/services/compiler/routine-loader.d.ts

@@ -0,0 +1,11 @@
+import type { Result } from 'neverthrow';
+import type { WorkflowDefinition } from '../../../types/workflow-definition.js';
+export interface RoutineLoadWarning {
+    readonly file: string;
+    readonly reason: string;
+}
+export interface RoutineLoadResult {
+    readonly routines: ReadonlyMap<string, WorkflowDefinition>;
+    readonly warnings: readonly RoutineLoadWarning[];
+}
+export declare function loadRoutineDefinitions(routinesDir?: string): Result<RoutineLoadResult, string>;

package/dist/application/services/compiler/routine-loader.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRoutineDefinitions = loadRoutineDefinitions;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const neverthrow_1 = require("neverthrow");
+const workflow_definition_js_1 = require("../../../types/workflow-definition.js");
+function resolveRoutinesDir() {
+    const projectRoot = path_1.default.resolve(__dirname, '..', '..', '..', '..');
+    return path_1.default.join(projectRoot, 'workflows', 'routines');
+}
+function loadRoutineDefinitions(routinesDir) {
+    const dir = routinesDir ?? resolveRoutinesDir();
+    if (!(0, fs_1.existsSync)(dir)) {
+        return (0, neverthrow_1.ok)({ routines: new Map(), warnings: [] });
+    }
+    let files;
+    try {
+        files = (0, fs_1.readdirSync)(dir).filter(f => f.endsWith('.json'));
+    }
+    catch (e) {
+        return (0, neverthrow_1.err)(`Failed to read routines directory '${dir}': ${e}`);
+    }
+    const routines = new Map();
+    const warnings = [];
+    for (const file of files) {
+        const filePath = path_1.default.join(dir, file);
+        try {
+            const raw = (0, fs_1.readFileSync)(filePath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (!(0, workflow_definition_js_1.hasWorkflowDefinitionShape)(parsed)) {
+                warnings.push({ file, reason: 'does not match WorkflowDefinition shape (missing id, name, description, version, or steps)' });
+                continue;
+            }
+            routines.set(parsed.id, parsed);
+        }
+        catch (e) {
+            warnings.push({ file, reason: String(e) });
+        }
+    }
+    return (0, neverthrow_1.ok)({ routines, warnings });
+}

package/dist/application/services/compiler/template-registry.d.ts

@@ -1,5 +1,5 @@
 import type { Result } from 'neverthrow';
-import type { WorkflowStepDefinition } from '../../../types/workflow-definition.js';
+import type { WorkflowStepDefinition, WorkflowDefinition } from '../../../types/workflow-definition.js';
 export type TemplateExpander = (callerId: string, args: Readonly<Record<string, unknown>>) => Result<readonly WorkflowStepDefinition[], TemplateExpandError>;
 export type TemplateExpandError = {
     readonly code: 'TEMPLATE_EXPAND_FAILED';
@@ -16,4 +16,6 @@ export interface TemplateRegistry {
     readonly has: (templateId: string) => boolean;
     readonly knownIds: () => readonly string[];
 }
-export declare function createTemplateRegistry(): TemplateRegistry;
+export declare function routineIdToTemplateId(routineId: string): string;
+export declare function createRoutineExpander(routineId: string, definition: WorkflowDefinition): Result<TemplateExpander, TemplateExpandError>;
+export declare function createTemplateRegistry(routineExpanders?: ReadonlyMap<string, TemplateExpander>): TemplateRegistry;

package/dist/application/services/compiler/template-registry.js

@@ -1,13 +1,114 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.routineIdToTemplateId = routineIdToTemplateId;
+exports.createRoutineExpander = createRoutineExpander;
 exports.createTemplateRegistry = createTemplateRegistry;
 const neverthrow_1 = require("neverthrow");
+const SINGLE_BRACE_ARG = /(?<!\{)\{([^{}]+)\}(?!\})/g;
+function isSubstitutableValue(value) {
+    return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+}
+function substituteArgs(template, args, templateId, routineId, stepId) {
+    const missing = [];
+    const badType = [];
+    const result = template.replace(SINGLE_BRACE_ARG, (match, argName) => {
+        if (!(argName in args)) {
+            missing.push(argName);
+            return match;
+        }
+        const value = args[argName];
+        if (!isSubstitutableValue(value)) {
+            badType.push(argName);
+            return match;
+        }
+        return String(value);
+    });
+    if (missing.length > 0) {
+        return (0, neverthrow_1.err)({
+            code: 'TEMPLATE_EXPAND_FAILED',
+            templateId,
+            message: `MISSING_TEMPLATE_ARG: routine '${routineId}' step '${stepId}' references arg(s) '${missing.join("', '")}' but they were not provided in templateCall.args`,
+        });
+    }
+    if (badType.length > 0) {
+        return (0, neverthrow_1.err)({
+            code: 'TEMPLATE_EXPAND_FAILED',
+            templateId,
+            message: `INVALID_TEMPLATE_ARG_TYPE: routine '${routineId}' step '${stepId}' arg(s) '${badType.join("', '")}' must be string, number, or boolean (got non-primitive)`,
+        });
+    }
+    return (0, neverthrow_1.ok)(result);
+}
+function routineIdToTemplateId(routineId) {
+    const name = routineId.startsWith('routine-') ? routineId.slice('routine-'.length) : routineId;
+    return `wr.templates.routine.${name}`;
+}
+function createRoutineExpander(routineId, definition) {
+    for (const step of definition.steps) {
+        if ('templateCall' in step && step.templateCall) {
+            return (0, neverthrow_1.err)({
+                code: 'TEMPLATE_EXPAND_FAILED',
+                templateId: routineIdToTemplateId(routineId),
+                message: `Routine '${routineId}' step '${step.id}' contains a templateCall. Recursive routine injection is not allowed.`,
+            });
+        }
+    }
+    const templateId = routineIdToTemplateId(routineId);
+    const expander = (callerId, args) => {
+        const expandedSteps = [];
+        for (const step of definition.steps) {
+            if (!step.id || !step.title) {
+                return (0, neverthrow_1.err)({
+                    code: 'TEMPLATE_EXPAND_FAILED',
+                    templateId,
+                    message: `Routine '${routineId}' step '${step.id ?? '(missing id)'}' is missing required field '${!step.id ? 'id' : 'title'}'.`,
+                });
+            }
+            if (!step.prompt) {
+                return (0, neverthrow_1.err)({
+                    code: 'TEMPLATE_EXPAND_FAILED',
+                    templateId,
+                    message: `Routine '${routineId}' step '${step.id}' is missing required field 'prompt'.`,
+                });
+            }
+            const promptResult = substituteArgs(step.prompt, args, templateId, routineId, step.id);
+            if (promptResult.isErr())
+                return (0, neverthrow_1.err)(promptResult.error);
+            const titleResult = substituteArgs(step.title, args, templateId, routineId, step.id);
+            if (titleResult.isErr())
+                return (0, neverthrow_1.err)(titleResult.error);
+            const expandedStep = {
+                ...step,
+                id: `${callerId}.${step.id}`,
+                title: titleResult.value,
+                prompt: promptResult.value,
+                ...(definition.metaGuidance && definition.metaGuidance.length > 0
+                    ? {
+                        guidance: [
+                            ...(step.guidance ?? []),
+                            ...definition.metaGuidance,
+                        ],
+                    }
+                    : {}),
+            };
+            expandedSteps.push(expandedStep);
+        }
+        return (0, neverthrow_1.ok)(expandedSteps);
+    };
+    return (0, neverthrow_1.ok)(expander);
+}
 const TEMPLATE_DEFINITIONS = new Map();
-function createTemplateRegistry() {
-    const knownIds = [...TEMPLATE_DEFINITIONS.keys()];
+function createTemplateRegistry(routineExpanders) {
+    const allExpanders = new Map(TEMPLATE_DEFINITIONS);
+    if (routineExpanders) {
+        for (const [id, expander] of routineExpanders) {
+            allExpanders.set(id, expander);
+        }
+    }
+    const knownIds = [...allExpanders.keys()];
     return {
         resolve(templateId) {
-            const expander = TEMPLATE_DEFINITIONS.get(templateId);
+            const expander = allExpanders.get(templateId);
             if (!expander) {
                 return (0, neverthrow_1.err)({
                     code: 'UNKNOWN_TEMPLATE',
@@ -18,7 +119,7 @@ function createTemplateRegistry() {
             return (0, neverthrow_1.ok)(expander);
         },
         has(templateId) {
-            return TEMPLATE_DEFINITIONS.has(templateId);
+            return allExpanders.has(templateId);
         },
         knownIds() {
             return knownIds;

package/dist/application/services/workflow-compiler.js

@@ -20,16 +20,47 @@ const resolve_features_1 = require("./compiler/resolve-features");
 const feature_registry_1 = require("./compiler/feature-registry");
 const resolve_templates_1 = require("./compiler/resolve-templates");
 const template_registry_1 = require("./compiler/template-registry");
+const routine_loader_1 = require("./compiler/routine-loader");
 const _refRegistry = (0, ref_registry_1.createRefRegistry)();
 const _featureRegistry = (0, feature_registry_1.createFeatureRegistry)();
-const _templateRegistry = (0, template_registry_1.createTemplateRegistry)();
+function buildTemplateRegistry() {
+    const routineExpanders = new Map();
+    const loadResult = (0, routine_loader_1.loadRoutineDefinitions)();
+    if (loadResult.isErr()) {
+        console.warn(`[WorkflowCompiler] Failed to load routine definitions: ${loadResult.error}`);
+        return (0, template_registry_1.createTemplateRegistry)();
+    }
+    const { routines, warnings } = loadResult.value;
+    for (const w of warnings) {
+        console.warn(`[WorkflowCompiler] Skipped routine file '${w.file}': ${w.reason}`);
+    }
+    for (const [routineId, definition] of routines) {
+        const expanderResult = (0, template_registry_1.createRoutineExpander)(routineId, definition);
+        if (expanderResult.isOk()) {
+            routineExpanders.set((0, template_registry_1.routineIdToTemplateId)(routineId), expanderResult.value);
+        }
+        else {
+            console.warn(`[WorkflowCompiler] Failed to create expander for routine '${routineId}': ${expanderResult.error.message}`);
+        }
+    }
+    return (0, template_registry_1.createTemplateRegistry)(routineExpanders.size > 0 ? routineExpanders : undefined);
+}
+let _templateRegistryCache;
+function getTemplateRegistry() {
+    if (!_templateRegistryCache) {
+        _templateRegistryCache = buildTemplateRegistry();
+    }
+    return _templateRegistryCache;
+}
 function resolveDefinitionSteps(steps, features) {
-    const templatesResult = (0, resolve_templates_1.resolveTemplatesPass)(steps, _templateRegistry);
+    const templatesResult = (0, resolve_templates_1.resolveTemplatesPass)(steps, getTemplateRegistry());
     if (templatesResult.isErr()) {
         const e = templatesResult.error;
         const message = e.code === 'TEMPLATE_RESOLVE_ERROR'
             ? `Step '${e.stepId}': template error — ${e.cause.message}`
-            : `Step '${e.stepId}': template expansion error — ${e.cause.message}`;
+            : e.code === 'DUPLICATE_STEP_ID'
+                ? e.message
+                : `Step '${e.stepId}': template expansion error — ${e.cause.message}`;
         return (0, neverthrow_1.err)(error_1.Err.invalidState(message));
     }
     const featuresResult = (0, resolve_features_1.resolveFeaturesPass)(templatesResult.value, features, _featureRegistry);

package/dist/di/container.js

@@ -86,6 +86,7 @@ function detectRuntimeMode() {
 function toProcessLifecyclePolicy(mode) {
     switch (mode.kind) {
         case 'test':
+        case 'library':
             return { kind: 'no_signal_handlers' };
         case 'cli':
         case 'rpc':
@@ -103,7 +104,7 @@ function registerRuntime(options = {}) {
     const signals = policy.kind === 'no_signal_handlers' ? new noop_process_signals_js_1.NoopProcessSignals() : new node_process_signals_js_1.NodeProcessSignals();
     tsyringe_1.container.register(tokens_js_1.DI.Runtime.ProcessSignals, { useValue: signals });
     tsyringe_1.container.register(tokens_js_1.DI.Runtime.ShutdownEvents, { useValue: new in_memory_shutdown_events_js_1.InMemoryShutdownEvents() });
-    const terminator = mode.kind === 'test' ? new throwing_process_terminator_js_1.ThrowingProcessTerminator() : new node_process_terminator_js_1.NodeProcessTerminator();
+    const terminator = (mode.kind === 'test' || mode.kind === 'library') ? new throwing_process_terminator_js_1.ThrowingProcessTerminator() : new node_process_terminator_js_1.NodeProcessTerminator();
     tsyringe_1.container.register(tokens_js_1.DI.Runtime.ProcessTerminator, { useValue: terminator });
 }
 async function registerStorageChain() {
@@ -221,6 +222,7 @@ async function registerV2Services() {
         }),
     });
     const { LocalKeyringV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/keyring/index.js')));
+    const { LocalTokenAliasStoreV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/token-alias-store/index.js')));
     const { LocalSessionEventLogStoreV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/session-store/index.js')));
     const { LocalSnapshotStoreV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/snapshot-store/index.js')));
     const { LocalPinnedWorkflowStoreV2 } = await Promise.resolve().then(() => __importStar(require('../v2/infra/local/pinned-workflow-store/index.js')));
@@ -234,6 +236,13 @@ async function registerV2Services() {
             return new LocalKeyringV2(dataDir, fs, base64url, entropy);
         }),
     });
+    tsyringe_1.container.register(tokens_js_1.DI.V2.TokenAliasStore, {
+        useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => {
+            const dataDir = c.resolve(tokens_js_1.DI.V2.DataDir);
+            const fs = c.resolve(tokens_js_1.DI.V2.FileSystem);
+            return new LocalTokenAliasStoreV2(dataDir, fs);
+        }),
+    });
     tsyringe_1.container.register(tokens_js_1.DI.V2.SessionStore, {
         useFactory: (0, tsyringe_1.instanceCachingFactory)((c) => {
             const dataDir = c.resolve(tokens_js_1.DI.V2.DataDir);

package/dist/di/tokens.d.ts

@@ -38,6 +38,7 @@ export declare const DI: {
         readonly SnapshotStore: symbol;
         readonly PinnedWorkflowStore: symbol;
         readonly SessionLock: symbol;
+        readonly TokenAliasStore: symbol;
         readonly ExecutionGate: symbol;
     };
     readonly Runtime: {

package/dist/di/tokens.js

@@ -41,6 +41,7 @@ exports.DI = {
         SnapshotStore: Symbol('V2.SnapshotStore'),
         PinnedWorkflowStore: Symbol('V2.PinnedWorkflowStore'),
         SessionLock: Symbol('V2.SessionLock'),
+        TokenAliasStore: Symbol('V2.TokenAliasStore'),
         ExecutionGate: Symbol('V2.ExecutionGate'),
     },
     Runtime: {

package/dist/engine/engine-factory.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+import type { EngineConfig, EngineResult, WorkRailEngine } from './types.js';
+export declare function createWorkRailEngine(config?: EngineConfig): Promise<EngineResult<WorkRailEngine>>;