@loopstack/core 0.31.0 → 0.32.0

package/dist/workflow-processor/services/processors/workflow-processor.service.js

@@ -10,195 +10,218 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var WorkflowProcessorService_1;
 import { Injectable, Logger } from '@nestjs/common';
 import { DataSource } from 'typeorm';
-import { ErrorDocument, ServerTool, getBlockArgsSchema, getBlockConfigSchema, getBlockTools, getBlockWorkflows, getGuardMetadataMap, getInjectWorkflowDefaults, normalizeRetryConfig, } from '@loopstack/common';
+import { ErrorDocument, getBlockArgsSchema, getGuardMetadataMap, normalizeRetryConfig, } from '@loopstack/common';
 import { WorkflowState, WorkflowState as WorkflowStateEnum } from '@loopstack/contracts/enums';
 import { ConfigTraceError } from '../../../common/index.js';
-import { ExecutionContextManager, ExecutionScope } from '../../utils/index.js';
-import { StateManager } from '../../utils/state/state-manager.js';
+import { ExecutionScope } from '../../utils/index.js';
 import { DocumentPersistenceService } from '../document-persistence.service.js';
-import { ToolExecutionService } from '../tool-execution.service.js';
+import { resolveDocumentName } from '../document-store.service.js';
 import { TransitionResolverService } from '../transition-resolver.service.js';
 import { WorkflowMemoryMonitorService } from '../workflow-memory-monitor.service.js';
 import { WorkflowStateService } from '../workflow-state.service.js';
-function invokeWorkflowMethod(proxy, methodName, data) {
-    const method = proxy[methodName];
-    if (typeof method !== 'function') {
-        throw new Error(`Method '${methodName}' not found on workflow ${proxy.constructor.name}`);
-    }
-    return method.call(proxy, data);
-}
 function rejectAfter(ms, methodName) {
     return new Promise((_, reject) => setTimeout(() => reject(new Error(`Transition '${methodName}' timed out after ${ms}ms`)), ms));
 }
-function invokeGuardMethod(proxy, guardMethodName) {
-    const method = proxy[guardMethodName];
-    if (typeof method !== 'function') {
-        throw new Error(`Guard method '${guardMethodName}' not found on workflow ${proxy.constructor.name}`);
-    }
-    return method.call(proxy);
-}
 let WorkflowProcessorService = WorkflowProcessorService_1 = class WorkflowProcessorService {
     workflowStateService;
     transitionResolverService;
     executionScope;
     memoryMonitor;
-    toolExecutionService;
     documentPersistenceService;
     dataSource;
     logger = new Logger(WorkflowProcessorService_1.name);
-    constructor(workflowStateService, transitionResolverService, executionScope, memoryMonitor, toolExecutionService, documentPersistenceService, dataSource) {
+    constructor(workflowStateService, transitionResolverService, executionScope, memoryMonitor, documentPersistenceService, dataSource) {
         this.workflowStateService = workflowStateService;
         this.transitionResolverService = transitionResolverService;
         this.executionScope = executionScope;
         this.memoryMonitor = memoryMonitor;
-        this.toolExecutionService = toolExecutionService;
         this.documentPersistenceService = documentPersistenceService;
         this.dataSource = dataSource;
     }
-    createCtx(workflow, context, validArgs, workflowEntity, latestCheckpoint, validConfig) {
-        const initialWorkflowData = {
-            hasError: false,
-            stop: false,
-            status: workflowEntity?.status ?? WorkflowState.Pending,
-            availableTransitions: [],
-            persistenceState: {
-                documentsUpdated: false,
-            },
-            documents: workflowEntity?.documents ?? [],
-            place: workflowEntity?.place ?? 'start',
-            tools: {},
-            result: null,
-            retryCount: workflowEntity?.retryCount ?? 0,
-            retryTransitionId: workflowEntity?.retryTransitionId ?? undefined,
-        };
-        if (workflowEntity) {
-            delete workflowEntity.documents;
-        }
-        const checkpoint = latestCheckpoint
-            ? {
-                state: latestCheckpoint.state,
-                tools: latestCheckpoint.tools,
-                version: latestCheckpoint.version,
-            }
-            : null;
-        const stateManager = new StateManager(undefined, initialWorkflowData, checkpoint);
-        return new ExecutionContextManager(workflow, context, validArgs, stateManager, validConfig);
-    }
     async process(workflow, args, context) {
         const schema = getBlockArgsSchema(workflow);
         const validArgs = schema ? schema.parse(args) : args;
-        const configSchema = getBlockConfigSchema(workflow);
-        const rawConfig = context.workflowEntity?.config;
-        const validConfig = configSchema && rawConfig ? configSchema.parse(rawConfig) : (rawConfig ?? undefined);
         const isStateless = !!context.options?.stateless;
         let workflowEntity;
         let pendingTransition;
-        let ctx;
+        let latestCheckpoint = null;
+        const meta = {
+            hasError: false,
+            stop: false,
+            status: WorkflowStateEnum.Pending,
+            availableTransitions: [],
+            persistenceState: { documentsUpdated: false },
+            documents: [],
+            place: 'start',
+            tools: {},
+            result: null,
+            retryCount: 0,
+            retryTransitionId: undefined,
+            version: 1,
+        };
         if (isStateless) {
-            ctx = this.createCtx(workflow, context, validArgs, undefined, undefined, validConfig);
-            ctx.getManager().setData('status', WorkflowStateEnum.Running);
+            meta.status = WorkflowStateEnum.Running;
         }
         else {
             workflowEntity = context.workflowEntity;
             context.workflowId = workflowEntity.id;
-            const latestCheckpoint = await this.workflowStateService.getLatestCheckpoint(workflowEntity.id);
-            ctx = this.createCtx(workflow, context, validArgs, workflowEntity, latestCheckpoint, validConfig);
-            const isInitialRun = workflowEntity.place === 'start';
+            latestCheckpoint = await this.workflowStateService.getLatestCheckpoint(workflowEntity.id);
+            meta.status = workflowEntity.status ?? WorkflowState.Pending;
+            meta.documents = workflowEntity.documents ?? [];
+            meta.place = workflowEntity.place ?? 'start';
+            meta.retryCount = workflowEntity.retryCount ?? 0;
+            meta.retryTransitionId = workflowEntity.retryTransitionId ?? undefined;
+            if (workflowEntity) {
+                delete workflowEntity.documents;
+            }
+            const isInitialRun = meta.place === 'start';
+            const payloadTransition = context.payload?.transition;
             pendingTransition =
-                !isInitialRun && ctx.getContext().payload?.transition?.workflowId === ctx.getContext().workflowId
-                    ? ctx.getContext().payload?.transition
-                    : undefined;
+                !isInitialRun && payloadTransition?.workflowId === context.workflowId ? payloadTransition : undefined;
             const isRetry = !!workflowEntity.hasError;
             if (!isInitialRun && !pendingTransition && !isRetry) {
                 this.logger.debug('Skipping processing since state is already processed.');
-                return ctx.getData();
+                return meta;
             }
-            ctx.getManager().setData('status', WorkflowStateEnum.Running);
+            meta.status = WorkflowStateEnum.Running;
         }
-        this.wireFrameworkServices(workflow, context.appInstance);
+        let state = latestCheckpoint ? (latestCheckpoint.state ?? {}) : {};
+        const checkpointVersion = latestCheckpoint ? latestCheckpoint.version + 1 : 1;
+        meta.version = checkpointVersion;
+        const scopeData = {
+            userId: context.userId,
+            workspaceId: context.workspaceId,
+            workflowId: context.workflowId ?? '',
+            labels: context.labels ?? [],
+            args: validArgs ? Object.freeze({ ...validArgs }) : undefined,
+            options: context.options,
+            cache: new Map(),
+            queryRunner: null,
+            documents: meta.documents,
+            persistenceState: meta.persistenceState,
+            transition: undefined,
+        };
         this.logger.debug(`Process state machine for workflow ${workflow.constructor.name}`);
         this.memoryMonitor.logWorkflowStart(workflow.constructor.name);
         try {
-            await this.processStateMachine(ctx, pendingTransition, workflowEntity);
+            state = await this.processStateMachine(scopeData, meta, workflow, pendingTransition, workflowEntity, state);
         }
         catch (e) {
             const error = e instanceof Error ? e : new Error(String(e));
-            this.logger.error(new ConfigTraceError(error, ctx.getInstance()));
-            ctx.getManager().setData('errorMessage', error.message);
-            ctx.getManager().setData('hasError', true);
-            ctx.getManager().setData('place', 'error');
+            this.logger.error(new ConfigTraceError(error, workflow));
+            meta.errorMessage = error.message;
+            meta.hasError = true;
+            meta.place = 'error';
         }
-        const hasRetrySignal = !!ctx.getManager().getData('_retrySignal');
+        const hasRetrySignal = !!meta._retrySignal;
         if (hasRetrySignal) {
-            ctx.getManager().setData('stop', true);
-            ctx.getManager().setData('status', WorkflowState.Waiting);
+            meta.stop = true;
+            meta.status = WorkflowState.Waiting;
         }
-        else if (ctx.getManager().getData('hasError')) {
-            ctx.getManager().setData('stop', true);
-            ctx.getManager().setData('status', WorkflowState.Failed);
+        else if (meta.hasError) {
+            meta.stop = true;
+            meta.status = WorkflowState.Failed;
         }
-        else if (ctx.getManager().getData('place') === 'end') {
-            ctx.getManager().setData('status', WorkflowState.Completed);
+        else if (meta.place === 'end') {
+            meta.status = WorkflowState.Completed;
         }
         else {
-            ctx.getManager().setData('stop', true);
-            ctx.getManager().setData('status', WorkflowState.Waiting);
+            meta.stop = true;
+            meta.status = WorkflowState.Waiting;
         }
-        this.memoryMonitor.logWorkflowEnd(workflow.constructor.name, ctx);
+        meta.documents = scopeData.documents;
+        meta.persistenceState = scopeData.persistenceState;
+        this.memoryMonitor.logWorkflowEnd(workflow.constructor.name, meta.documents, meta.version);
         if (workflowEntity) {
-            await this.workflowStateService.saveExecutionState(workflowEntity, ctx);
+            await this.workflowStateService.saveExecutionState(workflowEntity, state, meta);
         }
-        return ctx.getData();
+        return meta;
+    }
+    buildWorkflowContext(scopeData, meta) {
+        return {
+            userId: scopeData.userId,
+            workspaceId: scopeData.workspaceId,
+            workflowId: scopeData.workflowId,
+            args: scopeData.args,
+            execution: {
+                place: meta.place,
+                retryCount: meta.retryCount ?? 0,
+            },
+        };
     }
-    async executeTransition(ctx, proxy, methodName, to, data, workflowEntity, workflowName, transitionMeta) {
+    invokeTransition(workflow, methodName, workflowCtx, state, data) {
+        const method = workflow[methodName];
+        if (typeof method !== 'function') {
+            throw new Error(`Method '${methodName}' not found on workflow ${workflow.constructor.name}`);
+        }
+        if (data !== undefined) {
+            return method.call(workflow, state, data, workflowCtx);
+        }
+        else {
+            return method.call(workflow, state, workflowCtx);
+        }
+    }
+    invokeGuard(workflow, guardMethodName, state) {
+        const method = workflow[guardMethodName];
+        if (typeof method !== 'function') {
+            throw new Error(`Guard method '${guardMethodName}' not found on workflow ${workflow.constructor.name}`);
+        }
+        return method.call(workflow, state);
+    }
+    async executeTransition(scopeData, meta, workflow, methodName, to, data, state, workflowEntity, workflowName, transitionMeta) {
         const defaultTimeout = parseInt(process.env.DEFAULT_TRANSITION_TIMEOUT ?? '', 10) || 300_000;
         const timeoutMs = transitionMeta?.timeout ?? defaultTimeout;
+        const workflowCtx = this.buildWorkflowContext(scopeData, meta);
         const invokeMethod = () => {
-            const methodPromise = this.executionScope.run(ctx, () => invokeWorkflowMethod(proxy, methodName, data));
+            const methodPromise = this.executionScope.run(scopeData, () => this.invokeTransition(workflow, methodName, workflowCtx, state, data));
             return timeoutMs > 0 ? Promise.race([methodPromise, rejectAfter(timeoutMs, methodName)]) : methodPromise;
         };
         if (!workflowEntity) {
             const returnValue = await invokeMethod();
-            ctx.getManager().setData('place', to);
-            ctx.getManager().checkpoint();
-            this.memoryMonitor.logTransition(workflowName, methodName, ctx);
-            return returnValue;
+            const newState = (returnValue != null && typeof returnValue === 'object' ? returnValue : state);
+            meta.place = to;
+            meta.version++;
+            this.memoryMonitor.logTransition(workflowName, methodName, scopeData.documents, meta.version);
+            return { returnValue, newState };
         }
-        const documentsSnapshot = structuredClone(ctx.getManager().getData('documents'));
-        const persistenceStateSnapshot = structuredClone(ctx.getManager().getData('persistenceState'));
+        const documentsSnapshot = structuredClone(scopeData.documents);
+        const persistenceStateSnapshot = structuredClone(scopeData.persistenceState);
         const queryRunner = this.dataSource.createQueryRunner();
         await queryRunner.connect();
         await queryRunner.startTransaction();
         try {
-            ctx.setQueryRunner(queryRunner);
-            this.logger.debug(`Applying transition: ${methodName} (${ctx.getManager().getData('place')} → ${to})`);
+            scopeData.queryRunner = queryRunner;
+            this.logger.debug(`Applying transition: ${methodName} (${meta.place} → ${to})`);
             const returnValue = await invokeMethod();
-            if (returnValue !== undefined && returnValue !== null) {
-                ctx.getManager().setData('result', returnValue);
+            const newState = (returnValue != null && typeof returnValue === 'object' ? returnValue : state);
+            if (to === 'end' && returnValue !== undefined && returnValue !== null) {
+                meta.result = returnValue;
             }
-            ctx.getManager().setData('place', to);
-            ctx.getManager().checkpoint();
-            this.memoryMonitor.logTransition(workflowName, methodName, ctx);
-            await this.workflowStateService.saveExecutionState(workflowEntity, ctx, queryRunner);
+            meta.place = to;
+            meta.version++;
+            this.memoryMonitor.logTransition(workflowName, methodName, scopeData.documents, meta.version);
+            meta.documents = scopeData.documents;
+            meta.persistenceState = scopeData.persistenceState;
+            await this.workflowStateService.saveExecutionState(workflowEntity, newState, meta, queryRunner);
             await queryRunner.commitTransaction();
-            return returnValue;
+            return { returnValue, newState };
         }
         catch (error) {
             await queryRunner.rollbackTransaction();
-            ctx.getManager().setData('documents', documentsSnapshot);
-            ctx.getManager().setData('persistenceState', persistenceStateSnapshot);
+            scopeData.documents = documentsSnapshot;
+            scopeData.persistenceState = persistenceStateSnapshot;
             throw error;
         }
         finally {
-            ctx.setQueryRunner(null);
+            scopeData.queryRunner = null;
             await queryRunner.release();
         }
     }
-    async handleTransitionError(ctx, error, transitionMeta, _workflowEntity) {
-        ctx.getManager().checkpoint();
+    async handleTransitionError(scopeData, meta, error, transitionMeta) {
+        meta.version++;
         try {
-            await this.executionScope.run(ctx, async () => {
-                await this.documentPersistenceService.create('ErrorDocument', ErrorDocument, { error: error.message }, { id: `error_${Date.now()}` });
+            await this.executionScope.run(scopeData, async () => {
+                await this.documentPersistenceService.create(resolveDocumentName(ErrorDocument), ErrorDocument, { error: error.message }, { id: `error_${Date.now()}` });
             });
         }
         catch (docError) {
@@ -206,183 +229,142 @@ let WorkflowProcessorService = WorkflowProcessorService_1 = class WorkflowProces
         }
         const retry = transitionMeta.retry ?? normalizeRetryConfig();
         const methodName = transitionMeta.methodName;
-        const prevRetryTransitionId = ctx.getManager().getData('retryTransitionId');
-        let retryCount = ctx.getManager().getData('retryCount') ?? 0;
-        if (prevRetryTransitionId !== methodName) {
+        let retryCount = meta.retryCount ?? 0;
+        if (meta.retryTransitionId !== methodName) {
             retryCount = 0;
         }
         this.logger.warn(`Transition '${methodName}' failed (attempt ${retryCount + 1}): ${error.message}`);
         if (retry.attempts > 0 && retryCount < retry.attempts) {
             retryCount++;
-            ctx.getManager().setData('retryCount', retryCount);
-            ctx.getManager().setData('retryTransitionId', methodName);
-            ctx.getManager().setData('errorMessage', error.message);
-            ctx.getManager().setData('hasError', true);
+            meta.retryCount = retryCount;
+            meta.retryTransitionId = methodName;
+            meta.errorMessage = error.message;
+            meta.hasError = true;
             const delayMs = retry.backoff === 'exponential'
                 ? Math.min(retry.delay * Math.pow(2, retryCount - 1), retry.maxDelay)
                 : retry.delay;
             this.logger.log(`Auto-retry ${retryCount}/${retry.attempts} for '${methodName}' in ${delayMs}ms`);
-            ctx.getManager().setData('_retrySignal', { delayMs });
+            meta._retrySignal = { delayMs };
             return;
         }
         if (retry.place) {
             this.logger.log(`Retries exhausted for '${methodName}' — transitioning to custom error place '${retry.place}'`);
-            ctx.getManager().setData('place', retry.place);
-            ctx.getManager().setData('hasError', true);
-            ctx.getManager().setData('errorMessage', error.message);
-            ctx.getManager().setData('retryCount', 0);
-            ctx.getManager().setData('retryTransitionId', undefined);
+            meta.place = retry.place;
+            meta.hasError = true;
+            meta.errorMessage = error.message;
+            meta.retryCount = 0;
+            meta.retryTransitionId = undefined;
             return;
         }
         this.logger.log(`Transition '${methodName}' failed — staying at current place for manual retry`);
-        ctx.getManager().setData('hasError', true);
-        ctx.getManager().setData('errorMessage', error.message);
-        ctx.getManager().setData('retryCount', retryCount);
-        ctx.getManager().setData('retryTransitionId', methodName);
+        meta.hasError = true;
+        meta.errorMessage = error.message;
+        meta.retryCount = retryCount + 1;
+        meta.retryTransitionId = methodName;
     }
-    clearRetryState(ctx) {
-        if (ctx.getManager().getData('retryTransitionId')) {
-            ctx.getManager().setData('retryCount', 0);
-            ctx.getManager().setData('retryTransitionId', undefined);
+    clearRetryState(meta) {
+        if (meta.retryTransitionId) {
+            meta.retryCount = 0;
+            meta.retryTransitionId = undefined;
         }
     }
-    async processStateMachine(ctx, pendingTransition, workflowEntity) {
-        const proxy = ctx.getInstance();
-        const workflow = proxy;
+    async processStateMachine(scopeData, meta, workflow, pendingTransition, workflowEntity, state) {
         const guards = getGuardMetadataMap(workflow);
         const workflowName = workflow.constructor.name;
         if (pendingTransition) {
-            const currentPlace = ctx.getManager().getData('place');
-            const available = this.transitionResolverService.getAvailableTransitions(workflow, currentPlace);
+            const available = this.transitionResolverService.getAvailableTransitions(workflow, meta.place);
             const waitTransition = available.find((t) => t.wait && t.methodName === pendingTransition.id);
             if (waitTransition) {
-                ctx.getManager().setData('transition', {
+                meta.transition = {
                     id: waitTransition.methodName,
-                    from: currentPlace,
+                    from: meta.place,
                     to: waitTransition.to,
                     payload: pendingTransition.payload,
                     meta: pendingTransition.meta,
-                });
+                };
+                scopeData.transition = meta.transition;
                 const guard = guards.get(waitTransition.methodName);
                 if (guard) {
-                    const passes = await this.executionScope.run(ctx, () => {
-                        return invokeGuardMethod(proxy, guard.guardMethodName);
+                    const passes = await this.executionScope.run(scopeData, () => {
+                        return this.invokeGuard(workflow, guard.guardMethodName, state);
                     });
                     if (!passes) {
                         this.logger.debug(`Guard '${guard.guardMethodName}' rejected pending transition '${waitTransition.methodName}'`);
-                        return;
+                        return state;
                     }
                 }
                 if (workflowEntity) {
-                    await this.workflowStateService.saveExecutionState(workflowEntity, ctx);
+                    await this.workflowStateService.saveExecutionState(workflowEntity, state, meta);
                 }
                 const waitData = waitTransition.schema
                     ? waitTransition.schema.parse(pendingTransition.payload)
                     : pendingTransition.payload;
                 try {
-                    await this.executeTransition(ctx, proxy, waitTransition.methodName, waitTransition.to, waitData, workflowEntity, workflowName, waitTransition);
-                    this.clearRetryState(ctx);
+                    const result = await this.executeTransition(scopeData, meta, workflow, waitTransition.methodName, waitTransition.to, waitData, state, workflowEntity, workflowName, waitTransition);
+                    state = result.newState;
+                    this.clearRetryState(meta);
                 }
                 catch (e) {
                     const error = e instanceof Error ? e : new Error(String(e));
-                    this.logger.error(new ConfigTraceError(error, ctx.getInstance()));
-                    await this.handleTransitionError(ctx, error, waitTransition, workflowEntity);
-                    const errorPlace = ctx.getManager().getData('place');
-                    const errorAvailable = this.transitionResolverService.getAvailableTransitions(workflow, errorPlace);
-                    ctx.getManager().setData('availableTransitions', errorAvailable.map((t) => ({
+                    this.logger.error(new ConfigTraceError(error, workflow));
+                    await this.handleTransitionError(scopeData, meta, error, waitTransition);
+                    const errorAvailable = this.transitionResolverService.getAvailableTransitions(workflow, meta.place);
+                    meta.availableTransitions = errorAvailable.map((t) => ({
                         id: t.methodName,
-                        from: errorPlace,
+                        from: meta.place,
                         to: t.to,
                         trigger: t.wait ? 'manual' : undefined,
-                    })));
-                    return;
+                    }));
+                    return state;
                 }
             }
         }
         while (true) {
-            const currentPlace = ctx.getManager().getData('place');
-            if (currentPlace === 'end')
+            if (meta.place === 'end')
                 break;
-            ctx.getManager().setData('nextPlace', undefined);
-            const available = this.transitionResolverService.getAvailableTransitions(workflow, currentPlace);
-            const availableForMetadata = available.map((t) => ({
+            meta.nextPlace = undefined;
+            const available = this.transitionResolverService.getAvailableTransitions(workflow, meta.place);
+            meta.availableTransitions = available.map((t) => ({
                 id: t.methodName,
-                from: currentPlace,
+                from: meta.place,
                 to: t.to,
                 trigger: t.wait ? 'manual' : undefined,
             }));
-            ctx.getManager().setData('availableTransitions', availableForMetadata);
-            const next = this.executionScope.run(ctx, () => {
-                return this.transitionResolverService.resolveNextTransition(proxy, available, guards);
+            const next = await this.executionScope.run(scopeData, () => {
+                return this.transitionResolverService.resolveNextTransition(workflow, available, guards, state);
             });
             if (!next)
                 break;
-            ctx.getManager().setData('transition', {
+            meta.transition = {
                 id: next.methodName,
-                from: currentPlace,
+                from: meta.place,
                 to: next.to,
                 payload: null,
-            });
+            };
+            scopeData.transition = meta.transition;
             if (workflowEntity) {
-                await this.workflowStateService.saveExecutionState(workflowEntity, ctx);
+                await this.workflowStateService.saveExecutionState(workflowEntity, state, meta);
             }
-            const autoData = next.from === 'start' ? ctx.getArgs() : undefined;
             try {
-                await this.executeTransition(ctx, proxy, next.methodName, next.to, autoData, workflowEntity, workflowName, next);
-                this.clearRetryState(ctx);
+                const result = await this.executeTransition(scopeData, meta, workflow, next.methodName, next.to, undefined, state, workflowEntity, workflowName, next);
+                state = result.newState;
+                this.clearRetryState(meta);
             }
             catch (e) {
                 const error = e instanceof Error ? e : new Error(String(e));
-                this.logger.error(new ConfigTraceError(error, ctx.getInstance()));
-                await this.handleTransitionError(ctx, error, next, workflowEntity);
-                const errorPlace = ctx.getManager().getData('place');
-                const errorAvailable = this.transitionResolverService.getAvailableTransitions(workflow, errorPlace);
-                ctx.getManager().setData('availableTransitions', errorAvailable.map((t) => ({
+                this.logger.error(new ConfigTraceError(error, workflow));
+                await this.handleTransitionError(scopeData, meta, error, next);
+                const errorAvailable = this.transitionResolverService.getAvailableTransitions(workflow, meta.place);
+                meta.availableTransitions = errorAvailable.map((t) => ({
                     id: t.methodName,
-                    from: errorPlace,
+                    from: meta.place,
                     to: t.to,
                     trigger: t.wait ? 'manual' : undefined,
-                })));
+                }));
                 break;
             }
         }
-    }
-    wireFrameworkServices(workflow, app) {
-        this.wireTools(workflow);
-        this.wireWorkflows(workflow);
-        if (app) {
-            this.wireTools(app);
-            this.wireWorkflows(app);
-        }
-    }
-    wireTools(target) {
-        const toolNames = getBlockTools(target);
-        for (const name of toolNames) {
-            const tool = target[name];
-            if (!tool || tool instanceof ServerTool)
-                continue;
-            const proxy = this.toolExecutionService.wireAndProxyTool(tool, name, target);
-            target[name] = proxy;
-        }
-    }
-    wireWorkflows(target) {
-        const workflowNames = getBlockWorkflows(target);
-        for (const name of workflowNames) {
-            const workflow = target[name];
-            if (!workflow || typeof workflow !== 'object')
-                continue;
-            const defaults = getInjectWorkflowDefaults(target, name);
-            if (!defaults)
-                continue;
-            const wf = workflow;
-            if (typeof wf.run !== 'function')
-                continue;
-            const originalRun = wf.run.bind(wf);
-            wf.run = (args, options) => {
-                const runOptions = { ...options, _config: { ...defaults, ...options?._config } };
-                return originalRun(args, runOptions);
-            };
-        }
+        return state;
     }
 };
 WorkflowProcessorService = WorkflowProcessorService_1 = __decorate([
@@ -391,7 +373,6 @@ WorkflowProcessorService = WorkflowProcessorService_1 = __decorate([
         TransitionResolverService,
         ExecutionScope,
         WorkflowMemoryMonitorService,
-        ToolExecutionService,
         DocumentPersistenceService,
         DataSource])
 ], WorkflowProcessorService);