@exaudeus/workrail 3.15.0 → 3.17.0

package/dist/mcp/tool-call-timing.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_RING_BUFFER_CAPACITY = exports.ToolCallTimingRingBuffer = exports.noopToolCallTimingSink = void 0;
+exports.createRingBufferSink = createRingBufferSink;
+exports.createDevPerfSink = createDevPerfSink;
+exports.composeSinks = composeSinks;
+exports.withToolCallTiming = withToolCallTiming;
+const noopToolCallTimingSink = () => { };
+exports.noopToolCallTimingSink = noopToolCallTimingSink;
+class ToolCallTimingRingBuffer {
+    constructor(capacity) {
+        this.capacity = capacity;
+        this.head = 0;
+        this.count = 0;
+        if (capacity < 1)
+            throw new Error('Ring buffer capacity must be >= 1');
+        this.buffer = new Array(capacity).fill(undefined);
+    }
+    push(timing) {
+        this.buffer[this.head] = timing;
+        this.head = (this.head + 1) % this.capacity;
+        if (this.count < this.capacity)
+            this.count++;
+    }
+    recent(limit) {
+        const n = limit !== undefined ? Math.min(limit, this.count) : this.count;
+        const results = [];
+        for (let i = 1; i <= n; i++) {
+            const idx = (this.head - i + this.capacity) % this.capacity;
+            const entry = this.buffer[idx];
+            if (entry !== undefined)
+                results.push(entry);
+        }
+        return results;
+    }
+    get size() {
+        return this.count;
+    }
+}
+exports.ToolCallTimingRingBuffer = ToolCallTimingRingBuffer;
+exports.DEFAULT_RING_BUFFER_CAPACITY = 100;
+function createRingBufferSink(buffer) {
+    return (timing) => {
+        buffer.push(timing);
+    };
+}
+function createDevPerfSink() {
+    return (timing) => {
+        const outcomeLabel = timing.outcome === 'success' ? 'OK' : timing.outcome.toUpperCase();
+        const line = `[PerfTrace] ${timing.toolName} ${timing.durationMs.toFixed(1)}ms [${outcomeLabel}]`;
+        console.error(line);
+    };
+}
+function composeSinks(...sinks) {
+    return (timing) => {
+        for (const sink of sinks) {
+            try {
+                sink(timing);
+            }
+            catch { }
+        }
+    };
+}
+async function withToolCallTiming(toolName, handler, sink) {
+    const startedAtMs = Date.now();
+    const startHr = performance.now();
+    let outcome = 'error';
+    try {
+        const result = await handler();
+        outcome = result?.isError === true ? 'error' : 'success';
+        return result;
+    }
+    catch (err) {
+        outcome = 'error';
+        throw err;
+    }
+    finally {
+        const durationMs = Math.round((performance.now() - startHr) * 100) / 100;
+        try {
+            sink({ toolName, startedAtMs, durationMs, outcome });
+        }
+        catch {
+        }
+    }
+}

package/dist/mcp/transports/http-entry.js

@@ -42,9 +42,11 @@ const http_listener_js_1 = require("./http-listener.js");
 const shutdown_hooks_js_1 = require("./shutdown-hooks.js");
 const crypto = __importStar(require("crypto"));
 const express_1 = __importDefault(require("express"));
+const HTTP_PORT_SCAN_END = 3199;
 async function startHttpServer(port) {
     const { server, ctx } = await (0, server_js_1.composeServer)();
-    const listener = (0, http_listener_js_1.createHttpListener)(port);
+    const scanEnd = Math.max(port, HTTP_PORT_SCAN_END);
+    const listener = await (0, http_listener_js_1.bindWithPortFallback)(port, scanEnd);
     const { StreamableHTTPServerTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/server/streamableHttp.js')));
     const transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: () => crypto.randomUUID(),
@@ -54,7 +56,6 @@ async function startHttpServer(port) {
     listener.app.post('/mcp', (req, res) => transport.handleRequest(req, res, req.body));
     listener.app.get('/mcp', (req, res) => transport.handleRequest(req, res));
     listener.app.delete('/mcp', (req, res) => transport.handleRequest(req, res));
-    await listener.start();
     await server.connect(transport);
     const boundPort = listener.getBoundPort();
     console.error('[Transport] WorkRail MCP Server running on HTTP');

package/dist/mcp/transports/http-listener.d.ts

@@ -7,3 +7,4 @@ export interface HttpListener {
     stop(): Promise<void>;
 }
 export declare function createHttpListener(requestedPort: number): HttpListener;
+export declare function bindWithPortFallback(startPort: number, endPort: number): Promise<HttpListener>;

package/dist/mcp/transports/http-listener.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHttpListener = createHttpListener;
+exports.bindWithPortFallback = bindWithPortFallback;
 const express_1 = __importDefault(require("express"));
 const http_1 = require("http");
 function createHttpListener(requestedPort) {
@@ -62,3 +63,27 @@ function createHttpListener(requestedPort) {
         },
     };
 }
+async function bindWithPortFallback(startPort, endPort) {
+    let lastError;
+    for (let port = startPort; port <= endPort; port++) {
+        const listener = createHttpListener(port);
+        try {
+            await listener.start();
+            if (port !== startPort) {
+                console.error(`[HttpListener] Port ${startPort} unavailable; bound to fallback port ${port}`);
+            }
+            return listener;
+        }
+        catch (err) {
+            const nodeErr = err;
+            if (nodeErr.code === 'EADDRINUSE' ||
+                (err instanceof Error && err.message.includes('already in use'))) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+                continue;
+            }
+            throw err;
+        }
+    }
+    throw new Error(`[HttpListener] No available port in range ${startPort}-${endPort}. ` +
+        `Last error: ${lastError?.message}`);
+}

package/dist/mcp/transports/shutdown-hooks.d.ts

@@ -2,4 +2,7 @@ export interface ShutdownHookOptions {
     readonly onBeforeTerminate: () => Promise<void>;
 }
 export declare function wireShutdownHooks(opts: ShutdownHookOptions): void;
-export declare function wireStdinShutdown(): void;
+export interface StdinShutdownOptions {
+    readonly stdin?: NodeJS.ReadableStream;
+}
+export declare function wireStdinShutdown(opts?: StdinShutdownOptions): void;

package/dist/mcp/transports/shutdown-hooks.js

@@ -29,9 +29,10 @@ function wireShutdownHooks(opts) {
         })();
     });
 }
-function wireStdinShutdown() {
+function wireStdinShutdown(opts) {
     const shutdownEvents = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ShutdownEvents);
-    process.stdin.on('end', () => {
+    const stdin = opts?.stdin ?? process.stdin;
+    stdin.once('end', () => {
         console.error('[MCP] stdin closed, initiating shutdown');
         shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGHUP' });
     });

package/dist/mcp/transports/stdio-entry.js

@@ -35,8 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startStdioServer = startStdioServer;
 const server_js_1 = require("../server.js");
-const container_js_1 = require("../../di/container.js");
-const tokens_js_1 = require("../../di/tokens.js");
+const shutdown_hooks_js_1 = require("./shutdown-hooks.js");
 const INITIAL_ROOTS_TIMEOUT_MS = 1000;
 async function fetchInitialRootsWithTimeout(server) {
     return Promise.race([
@@ -75,31 +74,10 @@ async function startStdioServer() {
         .catch(() => {
         console.error('[Roots] Client does not support roots/list; workspace context will use server CWD fallback');
     });
-    const shutdownEvents = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ShutdownEvents);
-    const processSignals = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ProcessSignals);
-    const terminator = container_js_1.container.resolve(tokens_js_1.DI.Runtime.ProcessTerminator);
-    processSignals.on('SIGINT', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGINT' }));
-    processSignals.on('SIGTERM', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGTERM' }));
-    processSignals.on('SIGHUP', () => shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGHUP' }));
-    process.stdin.on('end', () => {
-        console.error('[MCP] stdin closed, initiating shutdown');
-        shutdownEvents.emit({ kind: 'shutdown_requested', signal: 'SIGHUP' });
-    });
-    let shutdownStarted = false;
-    shutdownEvents.onShutdown((event) => {
-        if (shutdownStarted)
-            return;
-        shutdownStarted = true;
-        void (async () => {
-            try {
-                console.error(`[Shutdown] Requested by ${event.signal}. Stopping services...`);
-                await ctx.httpServer?.stop();
-                terminator.terminate({ kind: 'success' });
-            }
-            catch (err) {
-                console.error('[Shutdown] Error while stopping services:', err);
-                terminator.terminate({ kind: 'failure' });
-            }
-        })();
+    (0, shutdown_hooks_js_1.wireStdinShutdown)();
+    (0, shutdown_hooks_js_1.wireShutdownHooks)({
+        onBeforeTerminate: async () => {
+            await ctx.httpServer?.stop();
+        },
     });
 }

package/dist/mcp/v2-response-formatter.d.ts

@@ -8,5 +8,5 @@ export interface FormattedResponse {
     readonly references?: FormattedReferences;
     readonly supplements?: readonly FormattedSupplement[];
 }
-export declare function formatV2ExecutionResponse(data: unknown): FormattedResponse | null;
+export declare function formatV2ExecutionResponse(data: unknown, cleanResponseFormat: boolean): FormattedResponse | null;
 export declare function formatV2ResumeResponse(data: unknown): FormattedResponse | null;

package/dist/mcp/v2-response-formatter.js

@@ -216,9 +216,6 @@ function formatSuccess(data) {
     }
     return lines.join('\n');
 }
-function isCleanResponseFormat() {
-    return process.env.WORKRAIL_CLEAN_RESPONSE_FORMAT === 'true';
-}
 const CLEAN_ADVANCE_FOOTERS = [
     'WorkRail: when done, call continue_workflow with your notes. Token:',
     'WorkRail: advance with continue_workflow when ready. Include your notes. Token:',
@@ -350,11 +347,11 @@ function renderReferencesSection(contentEnvelope, lifecycle) {
             return null;
     }
 }
-function formatV2ExecutionResponse(data) {
+function formatV2ExecutionResponse(data, cleanResponseFormat) {
     const renderInput = deriveRenderInput(data);
     if (!renderInput)
         return null;
-    const cleanFormat = isCleanResponseFormat();
+    const cleanFormat = cleanResponseFormat;
     const { response, lifecycle, contentEnvelope } = renderInput;
     const references = renderReferencesSection(contentEnvelope, lifecycle);
     if (cleanFormat) {

package/dist/mcp/validation/schema-introspection.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+export declare function getCachedShape(schema: z.ZodObject<z.ZodRawShape>): z.ZodRawShape;
 export declare function extractExpectedKeys(schema: z.ZodType): readonly string[];
 export declare function extractRequiredKeys(schema: z.ZodType): readonly string[];
 export declare function findUnknownKeys(args: unknown, schema: z.ZodType): readonly string[];

package/dist/mcp/validation/schema-introspection.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCachedShape = getCachedShape;
 exports.extractExpectedKeys = extractExpectedKeys;
 exports.extractRequiredKeys = extractRequiredKeys;
 exports.findUnknownKeys = findUnknownKeys;
@@ -8,9 +9,18 @@ exports.generateExampleValue = generateExampleValue;
 exports.generateTemplate = generateTemplate;
 exports.extractEnumValues = extractEnumValues;
 const zod_1 = require("zod");
+const shapeCache = new WeakMap();
+function getCachedShape(schema) {
+    const cached = shapeCache.get(schema);
+    if (cached !== undefined)
+        return cached;
+    const shape = schema._def.shape();
+    shapeCache.set(schema, shape);
+    return shape;
+}
 function extractExpectedKeys(schema) {
     if (schema instanceof zod_1.z.ZodObject) {
-        return Object.keys(schema._def.shape());
+        return Object.keys(getCachedShape(schema));
     }
     return [];
 }
@@ -18,7 +28,7 @@ function extractRequiredKeys(schema) {
     if (!(schema instanceof zod_1.z.ZodObject)) {
         return [];
     }
-    const shape = schema._def.shape();
+    const shape = getCachedShape(schema);
     const required = [];
     for (const [key, value] of Object.entries(shape)) {
         const field = value;
@@ -55,7 +65,7 @@ function generateExampleValue(schema, depth = 0, maxDepth = 3, includeOptional =
         return generateExampleValue(schema._def.innerType, depth, maxDepth, includeOptional);
     }
     if (schema instanceof zod_1.z.ZodObject) {
-        const shape = schema._def.shape();
+        const shape = getCachedShape(schema);
         const result = {};
         for (const [key, value] of Object.entries(shape)) {
             const field = value;
@@ -124,7 +134,7 @@ function extractEnumValues(schema, path) {
     let current = schema;
     for (const part of parts) {
         if (current instanceof zod_1.z.ZodObject) {
-            const shape = current._def.shape();
+            const shape = getCachedShape(current);
             const field = shape[part];
             if (!field)
                 return [];
@@ -133,7 +143,7 @@ function extractEnumValues(schema, path) {
         else if (current instanceof zod_1.z.ZodOptional) {
             current = current._def.innerType;
             if (current instanceof zod_1.z.ZodObject) {
-                const shape = current._def.shape();
+                const shape = getCachedShape(current);
                 const field = shape[part];
                 if (!field)
                     return [];

package/dist/mcp/validation/suggestion-generator.js

@@ -38,7 +38,7 @@ function generateMissingRequiredSuggestions(missingKeys, schema, config) {
     if (!(schema instanceof zod_1.z.ZodObject)) {
         return [];
     }
-    const shape = schema._def.shape();
+    const shape = (0, schema_introspection_js_1.getCachedShape)(schema);
     const suggestions = [];
     for (const key of missingKeys) {
         const field = shape[key];
@@ -118,7 +118,7 @@ function patchTemplateForFailedOptionals(correctTemplate, args, zodErrors, schem
     if (args === null || typeof args !== 'object' || Array.isArray(args))
         return correctTemplate;
     const argsObj = args;
-    const shape = schema._def.shape();
+    const shape = (0, schema_introspection_js_1.getCachedShape)(schema);
     const patched = { ...correctTemplate };
     let changed = false;
     for (const error of zodErrors) {

package/dist/runtime/adapters/node-process-signals.d.ts

@@ -1,4 +1,5 @@
 import type { ProcessSignal, ProcessSignals } from '../ports/process-signals.js';
 export declare class NodeProcessSignals implements ProcessSignals {
     on(signal: ProcessSignal, handler: () => void | Promise<void>): void;
+    once(signal: ProcessSignal, handler: () => void | Promise<void>): void;
 }

package/dist/runtime/adapters/node-process-signals.js

@@ -7,5 +7,10 @@ class NodeProcessSignals {
             void handler();
         });
     }
+    once(signal, handler) {
+        process.once(signal, () => {
+            void handler();
+        });
+    }
 }
 exports.NodeProcessSignals = NodeProcessSignals;

package/dist/runtime/adapters/noop-process-signals.d.ts

@@ -1,4 +1,5 @@
 import type { ProcessSignal, ProcessSignals } from '../ports/process-signals.js';
 export declare class NoopProcessSignals implements ProcessSignals {
     on(_signal: ProcessSignal, _handler: () => void | Promise<void>): void;
+    once(_signal: ProcessSignal, _handler: () => void | Promise<void>): void;
 }

package/dist/runtime/adapters/noop-process-signals.js

@@ -4,5 +4,7 @@ exports.NoopProcessSignals = void 0;
 class NoopProcessSignals {
     on(_signal, _handler) {
     }
+    once(_signal, _handler) {
+    }
 }
 exports.NoopProcessSignals = NoopProcessSignals;

package/dist/runtime/ports/process-signals.d.ts

@@ -1,4 +1,5 @@
 export type ProcessSignal = NodeJS.Signals | 'exit';
 export interface ProcessSignals {
     on(signal: ProcessSignal, handler: () => void | Promise<void>): void;
+    once(signal: ProcessSignal, handler: () => void | Promise<void>): void;
 }

package/dist/types/workflow-definition.d.ts

@@ -110,13 +110,15 @@ export interface WorkflowRecommendedPreferences {
     readonly recommendedAutonomy?: 'guided' | 'full_auto_stop_on_user_deps' | 'full_auto_never_stop';
     readonly recommendedRiskPolicy?: 'conservative' | 'balanced' | 'aggressive';
 }
+export declare const RESOLVE_FROM_VALUES: readonly ["workspace", "package"];
+export type ResolveFrom = typeof RESOLVE_FROM_VALUES[number];
 export interface WorkflowReference {
     readonly id: string;
     readonly title: string;
     readonly source: string;
     readonly purpose: string;
     readonly authoritative: boolean;
-    readonly resolveFrom?: 'workspace' | 'package';
+    readonly resolveFrom?: ResolveFrom;
 }
 export interface WorkflowDefinition {
     readonly id: string;
@@ -134,6 +136,8 @@ export interface WorkflowDefinition {
     readonly extensionPoints?: readonly ExtensionPoint[];
     readonly references?: readonly WorkflowReference[];
     readonly validatedAgainstSpecVersion?: number;
+    readonly about?: string;
+    readonly examples?: readonly string[];
 }
 export declare function isLoopStepDefinition(step: WorkflowStepDefinition | LoopStepDefinition): step is LoopStepDefinition;
 export declare function isWorkflowStepDefinition(step: WorkflowStepDefinition | LoopStepDefinition): step is WorkflowStepDefinition;

package/dist/types/workflow-definition.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESOLVE_FROM_VALUES = void 0;
 exports.isLoopStepDefinition = isLoopStepDefinition;
 exports.isWorkflowStepDefinition = isWorkflowStepDefinition;
 exports.stepHasPromptSource = stepHasPromptSource;
 exports.hasWorkflowDefinitionShape = hasWorkflowDefinitionShape;
 exports.createWorkflowDefinition = createWorkflowDefinition;
+exports.RESOLVE_FROM_VALUES = ['workspace', 'package'];
 function isLoopStepDefinition(step) {
     return 'type' in step && step.type === 'loop';
 }

package/dist/types/workflow.d.ts

@@ -3,6 +3,9 @@ import { WorkflowSource } from './workflow-source';
 export interface Workflow {
     readonly definition: WorkflowDefinition;
     readonly source: WorkflowSource;
+    readonly stepById: ReadonlyMap<string, WorkflowStepDefinition | LoopStepDefinition>;
+    readonly parentLoopByStepId: ReadonlyMap<string, LoopStepDefinition>;
+    readonly loopById: ReadonlyMap<string, LoopStepDefinition>;
 }
 export interface WorkflowSummary {
     readonly id: string;

package/dist/types/workflow.js

@@ -9,10 +9,35 @@ exports.getAllStepIds = getAllStepIds;
 exports.isWorkflow = isWorkflow;
 exports.isWorkflowDefinition = isWorkflowDefinition;
 const workflow_source_1 = require("./workflow-source");
+function buildWorkflowIndices(definition) {
+    const stepById = new Map();
+    const parentLoopByStepId = new Map();
+    const loopById = new Map();
+    function indexSteps(steps, parentLoop) {
+        for (const step of steps) {
+            stepById.set(step.id, step);
+            if (parentLoop !== null) {
+                parentLoopByStepId.set(step.id, parentLoop);
+            }
+            if ('type' in step && step.type === 'loop') {
+                loopById.set(step.id, step);
+                if (Array.isArray(step.body)) {
+                    indexSteps(step.body, step);
+                }
+            }
+        }
+    }
+    indexSteps(definition.steps ?? [], null);
+    return { stepById, parentLoopByStepId, loopById };
+}
 function createWorkflow(definition, source) {
+    const { stepById, parentLoopByStepId, loopById } = buildWorkflowIndices(definition);
     return Object.freeze({
         definition,
-        source
+        source,
+        stepById,
+        parentLoopByStepId,
+        loopById,
     });
 }
 function toWorkflowSummary(workflow) {
@@ -31,32 +56,10 @@ function toWorkflowSourceInfo(source) {
     });
 }
 function getStepById(workflow, stepId) {
-    const steps = workflow.definition.steps;
-    for (const step of steps) {
-        if (step.id === stepId) {
-            return step;
-        }
-        if ('type' in step && step.type === 'loop' && Array.isArray(step.body)) {
-            for (const bodyStep of step.body) {
-                if (bodyStep.id === stepId) {
-                    return bodyStep;
-                }
-            }
-        }
-    }
-    return null;
+    return workflow.stepById.get(stepId) ?? null;
 }
 function getAllStepIds(workflow) {
-    const ids = [];
-    for (const step of workflow.definition.steps) {
-        ids.push(step.id);
-        if ('type' in step && step.type === 'loop' && Array.isArray(step.body)) {
-            for (const bodyStep of step.body) {
-                ids.push(bodyStep.id);
-            }
-        }
-    }
-    return Object.freeze(ids);
+    return Object.freeze([...workflow.stepById.keys()]);
 }
 function isWorkflow(obj) {
     if (!obj || typeof obj !== 'object')
@@ -64,10 +67,16 @@ function isWorkflow(obj) {
     const candidate = obj;
     return ('definition' in candidate &&
         'source' in candidate &&
+        'stepById' in candidate &&
+        'parentLoopByStepId' in candidate &&
+        'loopById' in candidate &&
         candidate['definition'] !== null &&
         typeof candidate['definition'] === 'object' &&
         candidate['source'] !== null &&
-        typeof candidate['source'] === 'object');
+        typeof candidate['source'] === 'object' &&
+        candidate['stepById'] instanceof Map &&
+        candidate['parentLoopByStepId'] instanceof Map &&
+        candidate['loopById'] instanceof Map);
 }
 function isWorkflowDefinition(obj) {
     if (!obj || typeof obj !== 'object')

package/dist/v2/durable-core/domain/context-template-resolver.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONTEXT_TOKEN_PATTERN = void 0;
 exports.resolveContextTemplates = resolveContextTemplates;
 exports.CONTEXT_TOKEN_PATTERN = /\{\{(?!wr\.)([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)\}\}/;
-const CONTEXT_TOKEN_RE_G = new RegExp(exports.CONTEXT_TOKEN_PATTERN.source, 'g');
 function resolveDotPath(base, path) {
     let current = base;
     for (const segment of path) {
@@ -16,7 +15,8 @@ function resolveDotPath(base, path) {
 function resolveContextTemplates(template, context) {
     if (!template.includes('{{'))
         return template;
-    return template.replace(CONTEXT_TOKEN_RE_G, (_match, dotPath) => {
+    const re = new RegExp(exports.CONTEXT_TOKEN_PATTERN.source, 'g');
+    return template.replace(re, (_match, dotPath) => {
         const value = resolveDotPath(context, dotPath.split('.'));
         if (value === undefined || value === null) {
             return `[unset: ${dotPath}]`;

package/dist/v2/durable-core/domain/function-definition-expander.js

@@ -3,23 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.expandFunctionDefinitions = expandFunctionDefinitions;
 exports.formatFunctionDef = formatFunctionDef;
 const neverthrow_1 = require("neverthrow");
-const workflow_js_1 = require("../../../types/workflow.js");
 function findLoopById(workflow, loopId) {
-    function searchSteps(steps) {
-        for (const step of steps) {
-            if (!(0, workflow_js_1.isLoopStepDefinition)(step))
-                continue;
-            if (step.id === loopId)
-                return step;
-            if (Array.isArray(step.body)) {
-                const found = searchSteps(step.body);
-                if (found)
-                    return found;
-            }
-        }
-        return null;
-    }
-    return searchSteps(workflow.definition.steps);
+    return workflow.loopById.get(loopId) ?? null;
 }
 function getWorkflowScopeDefs(workflow) {
     return workflow.definition.functionDefinitions?.filter(f => !f.scope || f.scope === 'workflow') ?? [];
@@ -31,7 +16,7 @@ function getLoopScopeDefs(args) {
     });
 }
 function getStepScopeDefs(args) {
-    const step = args.workflow.definition.steps.find(s => s.id === args.stepId);
+    const step = args.workflow.stepById.get(args.stepId);
     return step?.functionDefinitions?.filter(f => !f.scope || f.scope === 'step') ?? [];
 }
 function expandFunctionDefinitions(args) {

package/dist/v2/durable-core/domain/prompt-renderer.d.ts

@@ -24,4 +24,6 @@ export declare function renderPendingPrompt(args: {
     readonly runId: RunId;
     readonly nodeId: NodeId;
     readonly rehydrateOnly: boolean;
+    readonly precomputedIndex?: import('../session-index.js').SessionIndex;
+    readonly cleanResponseFormat?: boolean;
 }): Result<StepMetadata, PromptRenderError>;