@loopstack/delegate-error-example-workflow 0.21.6

package/dist/delegate-error-example.module.d.ts

@@ -0,0 +1,3 @@
+export declare class DelegateErrorExampleModule {
+}
+//# sourceMappingURL=delegate-error-example.module.d.ts.map

package/dist/delegate-error-example.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegate-error-example.module.d.ts","sourceRoot":"","sources":["../src/delegate-error-example.module.ts"],"names":[],"mappings":"AASA,qBAKa,0BAA0B;CAAG"}

package/dist/delegate-error-example.module.js

@@ -0,0 +1,28 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegateErrorExampleModule = void 0;
+const common_1 = require("@nestjs/common");
+const claude_module_1 = require("@loopstack/claude-module");
+const core_1 = require("@loopstack/core");
+const delegate_error_workflow_1 = require("./delegate-error.workflow");
+const failing_sub_workflow_tool_1 = require("./tools/failing-sub-workflow.tool");
+const runtime_error_tool_1 = require("./tools/runtime-error.tool");
+const strict_schema_tool_1 = require("./tools/strict-schema.tool");
+const failing_workflow_1 = require("./workflows/failing.workflow");
+let DelegateErrorExampleModule = class DelegateErrorExampleModule {
+};
+exports.DelegateErrorExampleModule = DelegateErrorExampleModule;
+exports.DelegateErrorExampleModule = DelegateErrorExampleModule = __decorate([
+    (0, common_1.Module)({
+        imports: [core_1.LoopCoreModule, claude_module_1.ClaudeModule],
+        providers: [strict_schema_tool_1.StrictSchemaTool, runtime_error_tool_1.RuntimeErrorTool, failing_sub_workflow_tool_1.FailingSubWorkflowTool, failing_workflow_1.FailingWorkflow, delegate_error_workflow_1.DelegateErrorWorkflow],
+        exports: [delegate_error_workflow_1.DelegateErrorWorkflow],
+    })
+], DelegateErrorExampleModule);
+//# sourceMappingURL=delegate-error-example.module.js.map

package/dist/delegate-error-example.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegate-error-example.module.js","sourceRoot":"","sources":["../src/delegate-error-example.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAAwC;AACxC,4DAAwD;AACxD,0CAAiD;AACjD,uEAAkE;AAClE,iFAA2E;AAC3E,mEAA8D;AAC9D,mEAA8D;AAC9D,mEAA+D;AAOxD,IAAM,0BAA0B,GAAhC,MAAM,0BAA0B;CAAG,CAAA;AAA7B,gEAA0B;qCAA1B,0BAA0B;IALtC,IAAA,eAAM,EAAC;QACN,OAAO,EAAE,CAAC,qBAAc,EAAE,4BAAY,CAAC;QACvC,SAAS,EAAE,CAAC,qCAAgB,EAAE,qCAAgB,EAAE,kDAAsB,EAAE,kCAAe,EAAE,+CAAqB,CAAC;QAC/G,OAAO,EAAE,CAAC,+CAAqB,CAAC;KACjC,CAAC;GACW,0BAA0B,CAAG"}

package/dist/delegate-error.ui.yaml

@@ -0,0 +1,22 @@
+title: 'Delegate Error Handling Example'
+
+description: |
+  Demonstrates how tool errors (validation, runtime, and failed sub-workflows)
+  are handled by DelegateToolCalls and fed back to the LLM for self-correction.
+
+  The workflow instructs the LLM to:
+  1. Call strictSchema with wrong args (triggers Zod validation error)
+  2. Observe the error and retry with correct args
+  3. Call runtimeError with shouldFail: true (triggers runtime error)
+  4. Observe the error and retry with shouldFail: false
+  5. Call failingSubWorkflow (launches a sub-workflow that fails)
+  6. Observe the sub-workflow error and summarize
+
+ui:
+  widgets:
+    - widget: button
+      showWhen:
+        - awaiting_tools
+      options:
+        transition: cancelPendingTools
+        label: Cancel pending tools

package/dist/delegate-error.workflow.d.ts

@@ -0,0 +1,27 @@
+import { ClaudeGenerateText, ClaudeGenerateTextResult, DelegateToolCalls, DelegateToolCallsResult, UpdateToolResult } from '@loopstack/claude-module';
+import { BaseWorkflow } from '@loopstack/common';
+import { FailingSubWorkflowTool } from './tools/failing-sub-workflow.tool';
+import { RuntimeErrorTool } from './tools/runtime-error.tool';
+import { StrictSchemaTool } from './tools/strict-schema.tool';
+export declare class DelegateErrorWorkflow extends BaseWorkflow {
+    claudeGenerateText: ClaudeGenerateText;
+    delegateToolCalls: DelegateToolCalls;
+    updateToolResult: UpdateToolResult;
+    strictSchema: StrictSchemaTool;
+    runtimeError: RuntimeErrorTool;
+    failingSubWorkflow: FailingSubWorkflowTool;
+    llmResult?: ClaudeGenerateTextResult;
+    delegateResult?: DelegateToolCallsResult;
+    turnCount: number;
+    setup(): Promise<void>;
+    llmTurn(): Promise<void>;
+    executeToolCalls(): Promise<void>;
+    toolResultReceived(payload: unknown): Promise<void>;
+    toolsComplete(): Promise<void>;
+    cancelPendingTools(): Promise<void>;
+    respond(): Promise<void>;
+    private hasToolCalls;
+    private allToolsComplete;
+    private isEndTurn;
+}
+//# sourceMappingURL=delegate-error.workflow.d.ts.map

package/dist/delegate-error.workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegate-error.workflow.d.ts","sourceRoot":"","sources":["../src/delegate-error.workflow.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,wBAAwB,EAExB,iBAAiB,EACjB,uBAAuB,EACvB,gBAAgB,EACjB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,YAAY,EASb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAU9D,qBAGa,qBAAsB,SAAQ,YAAY;IACvC,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,YAAY,EAAE,gBAAgB,CAAC;IAC/B,YAAY,EAAE,gBAAgB,CAAC;IAC/B,kBAAkB,EAAE,sBAAsB,CAAC;IAEzD,SAAS,CAAC,EAAE,wBAAwB,CAAC;IACrC,cAAc,CAAC,EAAE,uBAAuB,CAAC;IACzC,SAAS,EAAG,MAAM,CAAC;IAGb,KAAK;IAoBL,OAAO;IAwBP,gBAAgB;IAUhB,kBAAkB,CAAC,OAAO,EAAE,OAAO;IAWnC,aAAa;IAGb,kBAAkB;IASlB,OAAO;IAIb,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,SAAS;CAGlB"}

package/dist/delegate-error.workflow.js

@@ -0,0 +1,173 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegateErrorWorkflow = void 0;
+const claude_module_1 = require("@loopstack/claude-module");
+const common_1 = require("@loopstack/common");
+const failing_sub_workflow_tool_1 = require("./tools/failing-sub-workflow.tool");
+const runtime_error_tool_1 = require("./tools/runtime-error.tool");
+const strict_schema_tool_1 = require("./tools/strict-schema.tool");
+let DelegateErrorWorkflow = class DelegateErrorWorkflow extends common_1.BaseWorkflow {
+    claudeGenerateText;
+    delegateToolCalls;
+    updateToolResult;
+    strictSchema;
+    runtimeError;
+    failingSubWorkflow;
+    llmResult;
+    delegateResult;
+    turnCount;
+    async setup() {
+        this.turnCount = 0;
+        await this.repository.save(common_1.MessageDocument, {
+            role: 'assistant',
+            content: '# Delegate Error Handling Example\n\n' +
+                'This workflow tests how tool errors are handled and fed back to the LLM.\n\n' +
+                'The LLM will deliberately trigger errors, then self-correct.',
+        });
+        await this.repository.save(claude_module_1.ClaudeMessageDocument, {
+            role: 'user',
+            content: 'Follow the instructions in your system prompt exactly. ' +
+                'Start with step 1: call strictSchema with no arguments.',
+        });
+    }
+    async llmTurn() {
+        this.turnCount++;
+        const result = await this.claudeGenerateText.call({
+            system: 'You are a test assistant that follows instructions precisely. ' +
+                'You are fully autonomous — do NOT ask the user for input or confirmation. ' +
+                'Just proceed through each step on your own.\n\n' +
+                'Complete these steps IN ORDER. Do exactly one step per turn:\n\n' +
+                '1. Call the `strictSchema` tool with NO arguments (empty object {}). This will fail — that is expected.\n' +
+                '2. After seeing the validation error, call `strictSchema` correctly with { "name": "World" }.\n' +
+                '3. Call the `runtimeError` tool with { "shouldFail": true }. This will fail — that is expected.\n' +
+                '4. After seeing the runtime error, call `runtimeError` with { "shouldFail": false }.\n' +
+                '5. Call the `failingSubWorkflow` tool with {}. This launches a sub-workflow that will fail — that is expected.\n' +
+                '6. After seeing the sub-workflow error, respond with a brief summary of what happened (do NOT call any tools).\n\n' +
+                'IMPORTANT: Only perform ONE step per turn. Do NOT skip steps. Do NOT wait for user input between steps.',
+            claude: { model: 'claude-sonnet-4-6' },
+            messagesSearchTag: 'message',
+            tools: ['strictSchema', 'runtimeError', 'failingSubWorkflow'],
+        });
+        this.llmResult = result.data;
+    }
+    async executeToolCalls() {
+        const result = await this.delegateToolCalls.call({
+            message: this.llmResult,
+            document: claude_module_1.ClaudeMessageDocument,
+            callback: { transition: 'toolResultReceived' },
+        });
+        this.delegateResult = result.data;
+    }
+    async toolResultReceived(payload) {
+        const result = await this.updateToolResult.call({
+            delegateResult: this.delegateResult,
+            completedTool: payload,
+            document: claude_module_1.ClaudeMessageDocument,
+        });
+        this.delegateResult = result.data;
+    }
+    async toolsComplete() { }
+    async cancelPendingTools() {
+        const workflowId = this.ctx.context.workflowId;
+        if (workflowId) {
+            await this.orchestrator.cancelChildren(workflowId);
+        }
+    }
+    async respond() {
+        await this.repository.save(claude_module_1.ClaudeMessageDocument, this.llmResult, { id: this.llmResult.id });
+    }
+    hasToolCalls() {
+        return this.llmResult?.stop_reason === 'tool_use';
+    }
+    allToolsComplete() {
+        return !!this.delegateResult?.allCompleted;
+    }
+    isEndTurn() {
+        return this.llmResult?.stop_reason === 'end_turn';
+    }
+};
+exports.DelegateErrorWorkflow = DelegateErrorWorkflow;
+__decorate([
+    (0, common_1.InjectTool)(),
+    __metadata("design:type", claude_module_1.ClaudeGenerateText)
+], DelegateErrorWorkflow.prototype, "claudeGenerateText", void 0);
+__decorate([
+    (0, common_1.InjectTool)(),
+    __metadata("design:type", claude_module_1.DelegateToolCalls)
+], DelegateErrorWorkflow.prototype, "delegateToolCalls", void 0);
+__decorate([
+    (0, common_1.InjectTool)(),
+    __metadata("design:type", claude_module_1.UpdateToolResult)
+], DelegateErrorWorkflow.prototype, "updateToolResult", void 0);
+__decorate([
+    (0, common_1.InjectTool)(),
+    __metadata("design:type", strict_schema_tool_1.StrictSchemaTool)
+], DelegateErrorWorkflow.prototype, "strictSchema", void 0);
+__decorate([
+    (0, common_1.InjectTool)(),
+    __metadata("design:type", runtime_error_tool_1.RuntimeErrorTool)
+], DelegateErrorWorkflow.prototype, "runtimeError", void 0);
+__decorate([
+    (0, common_1.InjectTool)(),
+    __metadata("design:type", failing_sub_workflow_tool_1.FailingSubWorkflowTool)
+], DelegateErrorWorkflow.prototype, "failingSubWorkflow", void 0);
+__decorate([
+    (0, common_1.Initial)({ to: 'ready' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], DelegateErrorWorkflow.prototype, "setup", null);
+__decorate([
+    (0, common_1.Transition)({ from: 'ready', to: 'prompt_executed' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], DelegateErrorWorkflow.prototype, "llmTurn", null);
+__decorate([
+    (0, common_1.Transition)({ from: 'prompt_executed', to: 'awaiting_tools', priority: 10 }),
+    (0, common_1.Guard)('hasToolCalls'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], DelegateErrorWorkflow.prototype, "executeToolCalls", null);
+__decorate([
+    (0, common_1.Transition)({ from: 'awaiting_tools', to: 'awaiting_tools', wait: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], DelegateErrorWorkflow.prototype, "toolResultReceived", null);
+__decorate([
+    (0, common_1.Transition)({ from: 'awaiting_tools', to: 'ready' }),
+    (0, common_1.Guard)('allToolsComplete'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], DelegateErrorWorkflow.prototype, "toolsComplete", null);
+__decorate([
+    (0, common_1.Transition)({ from: 'awaiting_tools', to: 'ready', wait: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], DelegateErrorWorkflow.prototype, "cancelPendingTools", null);
+__decorate([
+    (0, common_1.Final)({ from: 'prompt_executed' }),
+    (0, common_1.Guard)('isEndTurn'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], DelegateErrorWorkflow.prototype, "respond", null);
+exports.DelegateErrorWorkflow = DelegateErrorWorkflow = __decorate([
+    (0, common_1.Workflow)({
+        uiConfig: __dirname + '/delegate-error.ui.yaml',
+    })
+], DelegateErrorWorkflow);
+//# sourceMappingURL=delegate-error.workflow.js.map

package/dist/delegate-error.workflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegate-error.workflow.js","sourceRoot":"","sources":["../src/delegate-error.workflow.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './delegate-error-example.module';
+export * from './delegate-error.workflow';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,2BAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./delegate-error-example.module"), exports);
+__exportStar(require("./delegate-error.workflow"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kEAAgD;AAChD,4DAA0C"}

package/dist/tools/failing-sub-workflow.tool.d.ts

@@ -0,0 +1,6 @@
+import { BaseTool, ToolCallOptions, ToolResult } from '@loopstack/common';
+export declare class FailingSubWorkflowTool extends BaseTool {
+    private failingWorkflow;
+    call(_args: object, options?: ToolCallOptions): Promise<ToolResult>;
+}
+//# sourceMappingURL=failing-sub-workflow.tool.d.ts.map

package/dist/tools/failing-sub-workflow.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failing-sub-workflow.tool.d.ts","sourceRoot":"","sources":["../../src/tools/failing-sub-workflow.tool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAwB,eAAe,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGhG,qBAQa,sBAAuB,SAAQ,QAAQ;IAChC,OAAO,CAAC,eAAe,CAAkB;IAErD,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,UAAU,CAAC;CAQ1E"}

package/dist/tools/failing-sub-workflow.tool.js

@@ -0,0 +1,40 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FailingSubWorkflowTool = void 0;
+const zod_1 = require("zod");
+const common_1 = require("@loopstack/common");
+const failing_workflow_1 = require("../workflows/failing.workflow");
+let FailingSubWorkflowTool = class FailingSubWorkflowTool extends common_1.BaseTool {
+    failingWorkflow;
+    async call(_args, options) {
+        const result = await this.failingWorkflow.run({}, { alias: 'failingWorkflow', callback: options?.callback });
+        return {
+            data: { workflowId: result.workflowId },
+            pending: { workflowId: result.workflowId },
+        };
+    }
+};
+exports.FailingSubWorkflowTool = FailingSubWorkflowTool;
+__decorate([
+    (0, common_1.InjectWorkflow)(),
+    __metadata("design:type", failing_workflow_1.FailingWorkflow)
+], FailingSubWorkflowTool.prototype, "failingWorkflow", void 0);
+exports.FailingSubWorkflowTool = FailingSubWorkflowTool = __decorate([
+    (0, common_1.Tool)({
+        uiConfig: {
+            description: 'Launch an async sub-workflow that always fails. ' +
+                'Used to test that failed sub-workflow errors propagate back to the parent.',
+        },
+        schema: zod_1.z.object({}),
+    })
+], FailingSubWorkflowTool);
+//# sourceMappingURL=failing-sub-workflow.tool.js.map

package/dist/tools/failing-sub-workflow.tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"failing-sub-workflow.tool.js","sourceRoot":"","sources":["../../src/tools/failing-sub-workflow.tool.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,6BAAwB;AACxB,8CAAgG;AAChG,oEAAgE;AAUzD,IAAM,sBAAsB,GAA5B,MAAM,sBAAuB,SAAQ,iBAAQ;IACxB,eAAe,CAAkB;IAE3D,KAAK,CAAC,IAAI,CAAC,KAAa,EAAE,OAAyB;QACjD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC;QAE7G,OAAO;YACL,IAAI,EAAE,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE;YACvC,OAAO,EAAE,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,EAAE;SAC3C,CAAC;IACJ,CAAC;CACF,CAAA;AAXY,wDAAsB;AACP;IAAzB,IAAA,uBAAc,GAAE;8BAA0B,kCAAe;+DAAC;iCADhD,sBAAsB;IARlC,IAAA,aAAI,EAAC;QACJ,QAAQ,EAAE;YACR,WAAW,EACT,kDAAkD;gBAClD,4EAA4E;SAC/E;QACD,MAAM,EAAE,OAAC,CAAC,MAAM,CAAC,EAAE,CAAC;KACrB,CAAC;GACW,sBAAsB,CAWlC"}

package/dist/tools/runtime-error.tool.d.ts

@@ -0,0 +1,7 @@
+import { BaseTool, ToolResult } from '@loopstack/common';
+export declare class RuntimeErrorTool extends BaseTool {
+    call(args: {
+        shouldFail: boolean;
+    }): Promise<ToolResult>;
+}
+//# sourceMappingURL=runtime-error.tool.d.ts.map

package/dist/tools/runtime-error.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-error.tool.d.ts","sourceRoot":"","sources":["../../src/tools/runtime-error.tool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAQ,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/D,qBAUa,gBAAiB,SAAQ,QAAQ;IAC5C,IAAI,CAAC,IAAI,EAAE;QAAE,UAAU,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,UAAU,CAAC;CASzD"}

package/dist/tools/runtime-error.tool.js

@@ -0,0 +1,34 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeErrorTool = void 0;
+const zod_1 = require("zod");
+const common_1 = require("@loopstack/common");
+let RuntimeErrorTool = class RuntimeErrorTool extends common_1.BaseTool {
+    call(args) {
+        if (args.shouldFail) {
+            throw new Error('Simulated runtime error: external service unavailable.');
+        }
+        return Promise.resolve({
+            data: 'Action completed successfully.',
+        });
+    }
+};
+exports.RuntimeErrorTool = RuntimeErrorTool;
+exports.RuntimeErrorTool = RuntimeErrorTool = __decorate([
+    (0, common_1.Tool)({
+        uiConfig: {
+            description: 'Perform an action that may fail at runtime. ' +
+                'Pass shouldFail: true to simulate a runtime error, or false to succeed.',
+        },
+        schema: zod_1.z.object({
+            shouldFail: zod_1.z.boolean().describe('Whether the tool should simulate a runtime failure.'),
+        }),
+    })
+], RuntimeErrorTool);
+//# sourceMappingURL=runtime-error.tool.js.map

package/dist/tools/runtime-error.tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-error.tool.js","sourceRoot":"","sources":["../../src/tools/runtime-error.tool.ts"],"names":[],"mappings":";;;;;;;;;AAAA,6BAAwB;AACxB,8CAA+D;AAYxD,IAAM,gBAAgB,GAAtB,MAAM,gBAAiB,SAAQ,iBAAQ;IAC5C,IAAI,CAAC,IAA6B;QAChC,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;QAC5E,CAAC;QAED,OAAO,OAAO,CAAC,OAAO,CAAC;YACrB,IAAI,EAAE,gCAAgC;SACvC,CAAC,CAAC;IACL,CAAC;CACF,CAAA;AAVY,4CAAgB;2BAAhB,gBAAgB;IAV5B,IAAA,aAAI,EAAC;QACJ,QAAQ,EAAE;YACR,WAAW,EACT,8CAA8C;gBAC9C,yEAAyE;SAC5E;QACD,MAAM,EAAE,OAAC,CAAC,MAAM,CAAC;YACf,UAAU,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,qDAAqD,CAAC;SACxF,CAAC;KACH,CAAC;GACW,gBAAgB,CAU5B"}

package/dist/tools/strict-schema.tool.d.ts

@@ -0,0 +1,7 @@
+import { BaseTool, ToolResult } from '@loopstack/common';
+export declare class StrictSchemaTool extends BaseTool {
+    call(args: {
+        name: string;
+    }): Promise<ToolResult>;
+}
+//# sourceMappingURL=strict-schema.tool.d.ts.map

package/dist/tools/strict-schema.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strict-schema.tool.d.ts","sourceRoot":"","sources":["../../src/tools/strict-schema.tool.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAQ,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/D,qBAUa,gBAAiB,SAAQ,QAAQ;IAC5C,IAAI,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,UAAU,CAAC;CAKlD"}

package/dist/tools/strict-schema.tool.js

@@ -0,0 +1,32 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrictSchemaTool = void 0;
+const zod_1 = require("zod");
+const common_1 = require("@loopstack/common");
+let StrictSchemaTool = class StrictSchemaTool extends common_1.BaseTool {
+    call(args) {
+        return Promise.resolve({
+            data: `Hello, ${args.name}! Nice to meet you.`,
+        });
+    }
+};
+exports.StrictSchemaTool = StrictSchemaTool;
+exports.StrictSchemaTool = StrictSchemaTool = __decorate([
+    (0, common_1.Tool)({
+        uiConfig: {
+            description: 'Greet a person by name. Requires a name argument. ' + 'Returns a greeting message.',
+        },
+        schema: zod_1.z
+            .object({
+            name: zod_1.z.string().describe('The name of the person to greet.'),
+        })
+            .strict(),
+    })
+], StrictSchemaTool);
+//# sourceMappingURL=strict-schema.tool.js.map

package/dist/tools/strict-schema.tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strict-schema.tool.js","sourceRoot":"","sources":["../../src/tools/strict-schema.tool.ts"],"names":[],"mappings":";;;;;;;;;AAAA,6BAAwB;AACxB,8CAA+D;AAYxD,IAAM,gBAAgB,GAAtB,MAAM,gBAAiB,SAAQ,iBAAQ;IAC5C,IAAI,CAAC,IAAsB;QACzB,OAAO,OAAO,CAAC,OAAO,CAAC;YACrB,IAAI,EAAE,UAAU,IAAI,CAAC,IAAI,qBAAqB;SAC/C,CAAC,CAAC;IACL,CAAC;CACF,CAAA;AANY,4CAAgB;2BAAhB,gBAAgB;IAV5B,IAAA,aAAI,EAAC;QACJ,QAAQ,EAAE;YACR,WAAW,EAAE,oDAAoD,GAAG,6BAA6B;SAClG;QACD,MAAM,EAAE,OAAC;aACN,MAAM,CAAC;YACN,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,kCAAkC,CAAC;SAC9D,CAAC;aACD,MAAM,EAAE;KACZ,CAAC;GACW,gBAAgB,CAM5B"}

package/dist/workflows/failing.workflow.d.ts

@@ -0,0 +1,5 @@
+import { BaseWorkflow } from '@loopstack/common';
+export declare class FailingWorkflow extends BaseWorkflow {
+    start(): Promise<unknown>;
+}
+//# sourceMappingURL=failing.workflow.d.ts.map

package/dist/workflows/failing.workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failing.workflow.d.ts","sourceRoot":"","sources":["../../src/workflows/failing.workflow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAqB,MAAM,mBAAmB,CAAC;AAMpE,qBACa,eAAgB,SAAQ,YAAY;IAE/C,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC;CAG1B"}

package/dist/workflows/failing.workflow.js

@@ -0,0 +1,29 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FailingWorkflow = void 0;
+const common_1 = require("@loopstack/common");
+let FailingWorkflow = class FailingWorkflow extends common_1.BaseWorkflow {
+    start() {
+        return Promise.reject(new Error('Simulated sub-workflow failure.'));
+    }
+};
+exports.FailingWorkflow = FailingWorkflow;
+__decorate([
+    (0, common_1.Initial)({ to: 'done' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], FailingWorkflow.prototype, "start", null);
+exports.FailingWorkflow = FailingWorkflow = __decorate([
+    (0, common_1.Workflow)({})
+], FailingWorkflow);
+//# sourceMappingURL=failing.workflow.js.map

package/dist/workflows/failing.workflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"failing.workflow.js","sourceRoot":"","sources":["../../src/workflows/failing.workflow.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,8CAAoE;AAO7D,IAAM,eAAe,GAArB,MAAM,eAAgB,SAAQ,qBAAY;IAE/C,KAAK;QACH,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC,CAAC;IACtE,CAAC;CACF,CAAA;AALY,0CAAe;AAE1B;IADC,IAAA,gBAAO,EAAC,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC;;;;4CAGvB;0BAJU,eAAe;IAD3B,IAAA,iBAAQ,EAAC,EAAE,CAAC;GACA,eAAe,CAK3B"}

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@loopstack/delegate-error-example-workflow",
+  "displayName": "Loopstack Delegate Error Example Workflow",
+  "description": "A workflow demonstrating how tool validation errors and runtime errors are handled by DelegateToolCalls and fed back to the LLM.",
+  "keywords": [
+    "error",
+    "delegate",
+    "tool calling",
+    "example",
+    "workflow"
+  ],
+  "version": "0.21.6",
+  "license": "MIT",
+  "author": {
+    "name": "Jakob Klippel",
+    "url": "https://www.linkedin.com/in/jakob-klippel/"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./src/*": "./src/*"
+  },
+  "scripts": {
+    "build": "nest build",
+    "compile": "tsc --noEmit",
+    "format": "prettier --write .",
+    "lint": "eslint .",
+    "test": "jest --passWithNoTests",
+    "watch": "nest build --watch"
+  },
+  "dependencies": {
+    "@loopstack/claude-module": "^0.22.5",
+    "@loopstack/common": "^0.28.0",
+    "@loopstack/core": "^0.28.0",
+    "@nestjs/common": "^11.1.19",
+    "zod": "^4.3.6"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "jest": {
+    "testEnvironment": "node",
+    "rootDir": "src",
+    "testRegex": ".*\\.spec\\.ts$",
+    "transform": {
+      "^.+\\.ts$": "ts-jest"
+    },
+    "testTimeout": 10000,
+    "forceExit": true,
+    "maxWorkers": 1
+  },
+  "loopstack": {
+    "modules": [
+      {
+        "path": "src/delegate-error-example.module.ts",
+        "className": "DelegateErrorExampleModule"
+      }
+    ],
+    "workflows": [
+      {
+        "path": "src/delegate-error.workflow.ts",
+        "className": "DelegateErrorWorkflow",
+        "propertyName": "delegateError"
+      }
+    ],
+    "installModes": [
+      "add",
+      "install"
+    ]
+  }
+}

package/src/__tests__/delegate-error.workflow.spec.ts

@@ -0,0 +1,216 @@
+import { TestingModule } from '@nestjs/testing';
+import { ClaudeGenerateText, ClaudeModule } from '@loopstack/claude-module';
+import { LoopCoreModule, WorkflowProcessorService } from '@loopstack/core';
+import { ToolMock, createStatelessContext, createWorkflowTest } from '@loopstack/testing';
+import { DelegateErrorWorkflow } from '../delegate-error.workflow';
+import { FailingSubWorkflowTool } from '../tools/failing-sub-workflow.tool';
+import { RuntimeErrorTool } from '../tools/runtime-error.tool';
+import { StrictSchemaTool } from '../tools/strict-schema.tool';
+import { FailingWorkflow } from '../workflows/failing.workflow';
+
+/**
+ * Helper to create a mock LLM response with a single tool_use block.
+ */
+function mockToolUseResponse(toolName: string, input: Record<string, unknown>, toolUseId = 'toolu_test_1') {
+  return {
+    data: {
+      id: 'msg_test',
+      role: 'assistant',
+      stop_reason: 'tool_use',
+      content: [
+        { type: 'text', text: `Calling ${toolName}...` },
+        { type: 'tool_use', id: toolUseId, name: toolName, input },
+      ],
+    },
+  };
+}
+
+/**
+ * Helper to create a mock LLM response with end_turn (no tool calls).
+ */
+function mockEndTurnResponse(text: string) {
+  return {
+    data: {
+      id: 'msg_final',
+      role: 'assistant',
+      stop_reason: 'end_turn',
+      content: [{ type: 'text', text }],
+    },
+  };
+}
+
+describe('DelegateErrorWorkflow', () => {
+  let module: TestingModule;
+  let workflow: DelegateErrorWorkflow;
+  let processor: WorkflowProcessorService;
+  let mockClaude: ToolMock;
+
+  beforeEach(async () => {
+    module = await createWorkflowTest()
+      .forWorkflow(DelegateErrorWorkflow)
+      .withImports(LoopCoreModule, ClaudeModule)
+      .withToolOverride(ClaudeGenerateText)
+      // Real tools — we want to test actual validation and runtime errors
+      .withProviders(StrictSchemaTool, RuntimeErrorTool, FailingSubWorkflowTool, FailingWorkflow)
+      .compile();
+
+    workflow = module.get(DelegateErrorWorkflow);
+    processor = module.get(WorkflowProcessorService);
+    mockClaude = module.get(ClaudeGenerateText);
+  });
+
+  afterEach(async () => {
+    await module.close();
+  });
+
+  it('should be defined', () => {
+    expect(workflow).toBeDefined();
+  });
+
+  describe('validation error (bad schema args)', () => {
+    it('should capture validation error as is_error tool result and loop back to ready', async () => {
+      // LLM calls strictSchema with empty args — Zod validation will fail
+      mockClaude.call
+        .mockResolvedValueOnce(mockToolUseResponse('strictSchema', {}))
+        .mockResolvedValueOnce(mockEndTurnResponse('Done.'));
+
+      const context = createStatelessContext();
+      const result = await processor.process(workflow, {}, context);
+
+      expect(result.hasError).toBe(false);
+      expect(result.place).toBe('end');
+
+      // ClaudeGenerateText should have been called twice:
+      // 1st: LLM returns bad tool call → error fed back → loops to ready
+      // 2nd: LLM sees the error and responds with end_turn
+      expect(mockClaude.call).toHaveBeenCalledTimes(2);
+
+      // Should have tool result documents with is_error
+      const toolResultDocs = result.documents.filter((d) =>
+        d.content?.toolResults?.some((tr: { is_error?: boolean }) => tr.is_error),
+      );
+      expect(toolResultDocs.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('runtime error (tool throws)', () => {
+    it('should capture runtime error as is_error tool result and loop back to ready', async () => {
+      // LLM calls runtimeError with shouldFail: true — tool will throw
+      mockClaude.call
+        .mockResolvedValueOnce(mockToolUseResponse('runtimeError', { shouldFail: true }))
+        .mockResolvedValueOnce(mockEndTurnResponse('Done.'));
+
+      const context = createStatelessContext();
+      const result = await processor.process(workflow, {}, context);
+
+      expect(result.hasError).toBe(false);
+      expect(result.place).toBe('end');
+      expect(mockClaude.call).toHaveBeenCalledTimes(2);
+
+      const toolResultDocs = result.documents.filter((d) =>
+        d.content?.toolResults?.some((tr: { is_error?: boolean }) => tr.is_error),
+      );
+      expect(toolResultDocs.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('successful tool call', () => {
+    it('should process successful tool call without errors', async () => {
+      // LLM calls strictSchema with valid args
+      mockClaude.call
+        .mockResolvedValueOnce(mockToolUseResponse('strictSchema', { name: 'World' }))
+        .mockResolvedValueOnce(mockEndTurnResponse('Done.'));
+
+      const context = createStatelessContext();
+      const result = await processor.process(workflow, {}, context);
+
+      expect(result.hasError).toBe(false);
+      expect(result.place).toBe('end');
+      expect(mockClaude.call).toHaveBeenCalledTimes(2);
+
+      // No error tool results
+      const errorToolResults = result.documents.filter((d) =>
+        d.content?.toolResults?.some((tr: { is_error?: boolean }) => tr.is_error),
+      );
+      expect(errorToolResults).toHaveLength(0);
+    });
+  });
+
+  describe('error metadata in tool result documents', () => {
+    it('should include validation error message in is_error tool result', async () => {
+      mockClaude.call
+        .mockResolvedValueOnce(mockToolUseResponse('strictSchema', {}))
+        .mockResolvedValueOnce(mockEndTurnResponse('Done.'));
+
+      const context = createStatelessContext();
+      const result = await processor.process(workflow, {}, context);
+
+      expect(result.hasError).toBe(false);
+
+      const toolResultDocs = result.documents.filter((d) =>
+        d.content?.toolResults?.some((tr: { is_error?: boolean }) => tr.is_error),
+      );
+      expect(toolResultDocs.length).toBeGreaterThan(0);
+
+      const errorResult = toolResultDocs[0].content.toolResults.find((tr: { is_error?: boolean }) => tr.is_error);
+      expect(errorResult.content).toBeDefined();
+      // Zod v4 error message for missing required string field
+      expect(errorResult.content).toContain('invalid_type');
+    });
+
+    it('should include runtime error message in is_error tool result', async () => {
+      mockClaude.call
+        .mockResolvedValueOnce(mockToolUseResponse('runtimeError', { shouldFail: true }))
+        .mockResolvedValueOnce(mockEndTurnResponse('Done.'));
+
+      const context = createStatelessContext();
+      const result = await processor.process(workflow, {}, context);
+
+      expect(result.hasError).toBe(false);
+
+      const toolResultDocs = result.documents.filter((d) =>
+        d.content?.toolResults?.some((tr: { is_error?: boolean }) => tr.is_error),
+      );
+      expect(toolResultDocs.length).toBeGreaterThan(0);
+
+      const errorResult = toolResultDocs[0].content.toolResults.find((tr: { is_error?: boolean }) => tr.is_error);
+      expect(errorResult.content).toContain('external service unavailable');
+    });
+  });
+
+  describe('validation and runtime errors produce identical structure', () => {
+    it('should produce the same is_error tool result shape for both error types', async () => {
+      // Run validation error
+      mockClaude.call.mockResolvedValueOnce(mockToolUseResponse('strictSchema', {}));
+      const context1 = createStatelessContext();
+      const result1 = await processor.process(workflow, {}, context1);
+
+      const validationErrorDoc = result1.documents.find((d) =>
+        d.content?.toolResults?.some((tr: { is_error?: boolean }) => tr.is_error),
+      );
+      const validationError = validationErrorDoc?.content.toolResults.find((tr: { is_error?: boolean }) => tr.is_error);
+
+      // Run runtime error (fresh module needed for clean state)
+      mockClaude.call.mockResolvedValueOnce(mockToolUseResponse('runtimeError', { shouldFail: true }));
+      const context2 = createStatelessContext();
+      const result2 = await processor.process(workflow, {}, context2);
+
+      const runtimeErrorDoc = result2.documents.find((d) =>
+        d.content?.toolResults?.some((tr: { is_error?: boolean }) => tr.is_error),
+      );
+      const runtimeError = runtimeErrorDoc?.content.toolResults.find((tr: { is_error?: boolean }) => tr.is_error);
+
+      // Both should have the same structure
+      expect(validationError).toBeDefined();
+      expect(runtimeError).toBeDefined();
+      expect(validationError.type).toBe('tool_result');
+      expect(runtimeError.type).toBe('tool_result');
+      expect(validationError.is_error).toBe(true);
+      expect(runtimeError.is_error).toBe(true);
+      expect(typeof validationError.content).toBe('string');
+      expect(typeof runtimeError.content).toBe('string');
+      expect(typeof validationError.tool_use_id).toBe('string');
+      expect(typeof runtimeError.tool_use_id).toBe('string');
+    });
+  });
+});

package/src/delegate-error-example.module.ts

@@ -0,0 +1,15 @@
+import { Module } from '@nestjs/common';
+import { ClaudeModule } from '@loopstack/claude-module';
+import { LoopCoreModule } from '@loopstack/core';
+import { DelegateErrorWorkflow } from './delegate-error.workflow';
+import { FailingSubWorkflowTool } from './tools/failing-sub-workflow.tool';
+import { RuntimeErrorTool } from './tools/runtime-error.tool';
+import { StrictSchemaTool } from './tools/strict-schema.tool';
+import { FailingWorkflow } from './workflows/failing.workflow';
+
+@Module({
+  imports: [LoopCoreModule, ClaudeModule],
+  providers: [StrictSchemaTool, RuntimeErrorTool, FailingSubWorkflowTool, FailingWorkflow, DelegateErrorWorkflow],
+  exports: [DelegateErrorWorkflow],
+})
+export class DelegateErrorExampleModule {}

package/src/delegate-error.ui.yaml

@@ -0,0 +1,22 @@
+title: 'Delegate Error Handling Example'
+
+description: |
+  Demonstrates how tool errors (validation, runtime, and failed sub-workflows)
+  are handled by DelegateToolCalls and fed back to the LLM for self-correction.
+
+  The workflow instructs the LLM to:
+  1. Call strictSchema with wrong args (triggers Zod validation error)
+  2. Observe the error and retry with correct args
+  3. Call runtimeError with shouldFail: true (triggers runtime error)
+  4. Observe the error and retry with shouldFail: false
+  5. Call failingSubWorkflow (launches a sub-workflow that fails)
+  6. Observe the sub-workflow error and summarize
+
+ui:
+  widgets:
+    - widget: button
+      showWhen:
+        - awaiting_tools
+      options:
+        transition: cancelPendingTools
+        label: Cancel pending tools

package/src/delegate-error.workflow.ts

@@ -0,0 +1,140 @@
+import {
+  ClaudeGenerateText,
+  ClaudeGenerateTextResult,
+  ClaudeMessageDocument,
+  DelegateToolCalls,
+  DelegateToolCallsResult,
+  UpdateToolResult,
+} from '@loopstack/claude-module';
+import {
+  BaseWorkflow,
+  Final,
+  Guard,
+  Initial,
+  InjectTool,
+  MessageDocument,
+  ToolResult,
+  Transition,
+  Workflow,
+} from '@loopstack/common';
+import { FailingSubWorkflowTool } from './tools/failing-sub-workflow.tool';
+import { RuntimeErrorTool } from './tools/runtime-error.tool';
+import { StrictSchemaTool } from './tools/strict-schema.tool';
+
+/**
+ * Demonstrates how tool errors (validation, runtime, and failed sub-workflows)
+ * are handled by DelegateToolCalls and fed back to the LLM for self-correction.
+ *
+ * The LLM is instructed to deliberately trigger errors first, then correct them.
+ * This verifies that all error types produce identical is_error tool results
+ * and that the LLM agent loop handles them correctly.
+ */
+@Workflow({
+  uiConfig: __dirname + '/delegate-error.ui.yaml',
+})
+export class DelegateErrorWorkflow extends BaseWorkflow {
+  @InjectTool() claudeGenerateText: ClaudeGenerateText;
+  @InjectTool() delegateToolCalls: DelegateToolCalls;
+  @InjectTool() updateToolResult: UpdateToolResult;
+  @InjectTool() strictSchema: StrictSchemaTool;
+  @InjectTool() runtimeError: RuntimeErrorTool;
+  @InjectTool() failingSubWorkflow: FailingSubWorkflowTool;
+
+  llmResult?: ClaudeGenerateTextResult;
+  delegateResult?: DelegateToolCallsResult;
+  turnCount!: number;
+
+  @Initial({ to: 'ready' })
+  async setup() {
+    this.turnCount = 0;
+
+    await this.repository.save(MessageDocument, {
+      role: 'assistant',
+      content:
+        '# Delegate Error Handling Example\n\n' +
+        'This workflow tests how tool errors are handled and fed back to the LLM.\n\n' +
+        'The LLM will deliberately trigger errors, then self-correct.',
+    });
+
+    await this.repository.save(ClaudeMessageDocument, {
+      role: 'user',
+      content:
+        'Follow the instructions in your system prompt exactly. ' +
+        'Start with step 1: call strictSchema with no arguments.',
+    });
+  }
+
+  @Transition({ from: 'ready', to: 'prompt_executed' })
+  async llmTurn() {
+    this.turnCount++;
+    const result: ToolResult<ClaudeGenerateTextResult> = await this.claudeGenerateText.call({
+      system:
+        'You are a test assistant that follows instructions precisely. ' +
+        'You are fully autonomous — do NOT ask the user for input or confirmation. ' +
+        'Just proceed through each step on your own.\n\n' +
+        'Complete these steps IN ORDER. Do exactly one step per turn:\n\n' +
+        '1. Call the `strictSchema` tool with NO arguments (empty object {}). This will fail — that is expected.\n' +
+        '2. After seeing the validation error, call `strictSchema` correctly with { "name": "World" }.\n' +
+        '3. Call the `runtimeError` tool with { "shouldFail": true }. This will fail — that is expected.\n' +
+        '4. After seeing the runtime error, call `runtimeError` with { "shouldFail": false }.\n' +
+        '5. Call the `failingSubWorkflow` tool with {}. This launches a sub-workflow that will fail — that is expected.\n' +
+        '6. After seeing the sub-workflow error, respond with a brief summary of what happened (do NOT call any tools).\n\n' +
+        'IMPORTANT: Only perform ONE step per turn. Do NOT skip steps. Do NOT wait for user input between steps.',
+      claude: { model: 'claude-sonnet-4-6' },
+      messagesSearchTag: 'message',
+      tools: ['strictSchema', 'runtimeError', 'failingSubWorkflow'],
+    });
+    this.llmResult = result.data;
+  }
+
+  @Transition({ from: 'prompt_executed', to: 'awaiting_tools', priority: 10 })
+  @Guard('hasToolCalls')
+  async executeToolCalls() {
+    const result: ToolResult<DelegateToolCallsResult> = await this.delegateToolCalls.call({
+      message: this.llmResult!,
+      document: ClaudeMessageDocument,
+      callback: { transition: 'toolResultReceived' },
+    });
+    this.delegateResult = result.data;
+  }
+
+  @Transition({ from: 'awaiting_tools', to: 'awaiting_tools', wait: true })
+  async toolResultReceived(payload: unknown) {
+    const result = await this.updateToolResult.call({
+      delegateResult: this.delegateResult!,
+      completedTool: payload,
+      document: ClaudeMessageDocument,
+    });
+    this.delegateResult = result.data as DelegateToolCallsResult;
+  }
+
+  @Transition({ from: 'awaiting_tools', to: 'ready' })
+  @Guard('allToolsComplete')
+  async toolsComplete() {}
+
+  @Transition({ from: 'awaiting_tools', to: 'ready', wait: true })
+  async cancelPendingTools() {
+    const workflowId = this.ctx.context.workflowId;
+    if (workflowId) {
+      await this.orchestrator.cancelChildren(workflowId);
+    }
+  }
+
+  @Final({ from: 'prompt_executed' })
+  @Guard('isEndTurn')
+  async respond() {
+    await this.repository.save(ClaudeMessageDocument, this.llmResult!, { id: this.llmResult!.id });
+  }
+
+  private hasToolCalls(): boolean {
+    return this.llmResult?.stop_reason === 'tool_use';
+  }
+
+  private allToolsComplete(): boolean {
+    return !!this.delegateResult?.allCompleted;
+  }
+
+  private isEndTurn(): boolean {
+    return this.llmResult?.stop_reason === 'end_turn';
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './delegate-error-example.module';
+export * from './delegate-error.workflow';

package/src/tools/failing-sub-workflow.tool.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { BaseTool, InjectWorkflow, Tool, ToolCallOptions, ToolResult } from '@loopstack/common';
+import { FailingWorkflow } from '../workflows/failing.workflow';
+
+@Tool({
+  uiConfig: {
+    description:
+      'Launch an async sub-workflow that always fails. ' +
+      'Used to test that failed sub-workflow errors propagate back to the parent.',
+  },
+  schema: z.object({}),
+})
+export class FailingSubWorkflowTool extends BaseTool {
+  @InjectWorkflow() private failingWorkflow: FailingWorkflow;
+
+  async call(_args: object, options?: ToolCallOptions): Promise<ToolResult> {
+    const result = await this.failingWorkflow.run({}, { alias: 'failingWorkflow', callback: options?.callback });
+
+    return {
+      data: { workflowId: result.workflowId },
+      pending: { workflowId: result.workflowId },
+    };
+  }
+}

package/src/tools/runtime-error.tool.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { BaseTool, Tool, ToolResult } from '@loopstack/common';
+
+@Tool({
+  uiConfig: {
+    description:
+      'Perform an action that may fail at runtime. ' +
+      'Pass shouldFail: true to simulate a runtime error, or false to succeed.',
+  },
+  schema: z.object({
+    shouldFail: z.boolean().describe('Whether the tool should simulate a runtime failure.'),
+  }),
+})
+export class RuntimeErrorTool extends BaseTool {
+  call(args: { shouldFail: boolean }): Promise<ToolResult> {
+    if (args.shouldFail) {
+      throw new Error('Simulated runtime error: external service unavailable.');
+    }
+
+    return Promise.resolve({
+      data: 'Action completed successfully.',
+    });
+  }
+}

package/src/tools/strict-schema.tool.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { BaseTool, Tool, ToolResult } from '@loopstack/common';
+
+@Tool({
+  uiConfig: {
+    description: 'Greet a person by name. Requires a name argument. ' + 'Returns a greeting message.',
+  },
+  schema: z
+    .object({
+      name: z.string().describe('The name of the person to greet.'),
+    })
+    .strict(),
+})
+export class StrictSchemaTool extends BaseTool {
+  call(args: { name: string }): Promise<ToolResult> {
+    return Promise.resolve({
+      data: `Hello, ${args.name}! Nice to meet you.`,
+    });
+  }
+}

package/src/workflows/failing.workflow.ts

@@ -0,0 +1,13 @@
+import { BaseWorkflow, Initial, Workflow } from '@loopstack/common';
+
+/**
+ * A minimal sub-workflow that always fails on its initial transition.
+ * Used to verify that failed sub-workflow callbacks propagate errors to the parent.
+ */
+@Workflow({})
+export class FailingWorkflow extends BaseWorkflow {
+  @Initial({ to: 'done' })
+  start(): Promise<unknown> {
+    return Promise.reject(new Error('Simulated sub-workflow failure.'));
+  }
+}