@loopstack/claude-module 0.21.0 → 0.21.1

package/src/claude.module.ts

@@ -1,11 +1,17 @@
 import { Module } from '@nestjs/common';
-import { CoreUiModule } from '@loopstack/core-ui-module';
+import { LoopCoreModule } from '@loopstack/core';
 import { ClaudeMessageDocument } from './documents';
 import { ClaudeClientService, ClaudeMessagesHelperService, ClaudeToolsHelperService } from './services';
-import { ClaudeDelegateToolCall, ClaudeGenerateDocument, ClaudeGenerateObject, ClaudeGenerateText } from './tools';
+import {
+  ClaudeGenerateDocument,
+  ClaudeGenerateObject,
+  ClaudeGenerateText,
+  DelegateToolCalls,
+  UpdateToolResult,
+} from './tools';
 
 @Module({
-  imports: [CoreUiModule],
+  imports: [LoopCoreModule],
   providers: [
     // services
     ClaudeClientService,
@@ -16,7 +22,8 @@ import { ClaudeDelegateToolCall, ClaudeGenerateDocument, ClaudeGenerateObject, C
     ClaudeGenerateText,
     ClaudeGenerateObject,
     ClaudeGenerateDocument,
-    ClaudeDelegateToolCall,
+    DelegateToolCalls,
+    UpdateToolResult,
 
     // documents
     ClaudeMessageDocument,
@@ -25,7 +32,8 @@ import { ClaudeDelegateToolCall, ClaudeGenerateDocument, ClaudeGenerateObject, C
     ClaudeGenerateText,
     ClaudeGenerateObject,
     ClaudeGenerateDocument,
-    ClaudeDelegateToolCall,
+    DelegateToolCalls,
+    UpdateToolResult,
     ClaudeMessageDocument,
   ],
 })

package/src/services/claude-tools-helper.service.ts

@@ -22,15 +22,13 @@ export class ClaudeToolsHelperService {
         throw new Error(`Block ${tool.constructor.name} is missing @BlockConfig decorator`);
       }
 
-      if (inputSchema) {
-        const jsonSchema = toJSONSchema(inputSchema);
+      const jsonSchema = inputSchema ? toJSONSchema(inputSchema) : { type: 'object' };
 
-        toolDefinitions.push({
-          name: toolName,
-          description: config.description ?? '',
-          input_schema: jsonSchema as Anthropic.Tool['input_schema'],
-        });
-      }
+      toolDefinitions.push({
+        name: toolName,
+        description: config.description ?? '',
+        input_schema: jsonSchema as Anthropic.Tool['input_schema'],
+      });
     }
 
     return toolDefinitions.length ? toolDefinitions : undefined;

package/src/tools/claude-generate-document.tool.ts

@@ -9,7 +9,7 @@ import {
   WorkflowMetadataInterface,
   getBlockTool,
 } from '@loopstack/common';
-import { CreateDocument } from '@loopstack/core-ui-module';
+import { CreateDocument } from '@loopstack/core';
 import {
   ClaudeGenerateObject,
   ClaudeGenerateObjectArgsType,

package/src/tools/claude-generate-text.tool.ts

@@ -5,10 +5,14 @@ import {
   Input,
   RunContext,
   Tool,
+  ToolCallEntry,
+  ToolCallsMap,
   ToolInterface,
   ToolResult,
+  ToolSideEffects,
   WorkflowInterface,
   WorkflowMetadataInterface,
+  getBlockTool,
 } from '@loopstack/common';
 import { ClaudeGenerateToolBaseSchema } from '../schemas/claude-generate-tool-base.schema';
 import { ClaudeClientService } from '../services';
@@ -18,6 +22,7 @@ import { applyCacheBreakpoints } from '../utils/cache.utils';
 
 export const ClaudeGenerateTextSchema = ClaudeGenerateToolBaseSchema.extend({
   tools: z.array(z.string()).optional(),
+  document: z.string().optional(),
 }).strict();
 
 type ClaudeGenerateTextArgsType = z.infer<typeof ClaudeGenerateTextSchema>;
@@ -72,8 +77,23 @@ export class ClaudeGenerateText implements ToolInterface<ClaudeGenerateTextArgsT
       cache: args.claude?.cache,
     });
 
+    const toolCalls = this.extractToolCalls(response);
+
+    let effects: ToolSideEffects[] = [];
+
+    if (args.document) {
+      const docResult = await this.createResponseMessage(args.document, response, ctx, parent, runtime);
+      if (docResult.effects) {
+        effects = [...docResult.effects];
+      }
+    }
+
     return {
-      data: response,
+      data: {
+        ...response,
+        ...(toolCalls ? { toolCalls } : {}),
+      },
+      ...(effects.length > 0 ? { effects } : {}),
       metadata: {
         usage: {
           inputTokens: response.usage.input_tokens,
@@ -85,6 +105,51 @@ export class ClaudeGenerateText implements ToolInterface<ClaudeGenerateTextArgsT
     };
   }
 
+  private async createResponseMessage(
+    document: string,
+    response: Anthropic.Message,
+    ctx: RunContext,
+    parent: WorkflowInterface,
+    runtime: WorkflowMetadataInterface,
+  ): Promise<ToolResult> {
+    const createDocumentTool = getBlockTool<ToolInterface>(parent, 'createDocument');
+    if (!createDocumentTool) {
+      throw new Error('createDocument tool not found in parent context.');
+    }
+
+    return createDocumentTool.execute(
+      {
+        id: response.id,
+        document,
+        update: {
+          content: response,
+        },
+      },
+      ctx,
+      parent,
+      runtime,
+    );
+  }
+
+  private extractToolCalls(response: Anthropic.Message): ToolCallsMap | null {
+    if (response.stop_reason !== 'tool_use') {
+      return null;
+    }
+
+    const toolCalls: ToolCallsMap = {};
+    for (const block of response.content) {
+      if (block.type === 'tool_use') {
+        toolCalls[block.name] = {
+          id: block.id,
+          name: block.name,
+          input: block.input,
+        } satisfies ToolCallEntry;
+      }
+    }
+
+    return Object.keys(toolCalls).length > 0 ? toolCalls : null;
+  }
+
   private async handleGenerateText(
     client: Anthropic,
     options: {

package/src/tools/delegate-tool-calls.tool.ts

@@ -0,0 +1,198 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { Injectable, Logger } from '@nestjs/common';
+import { z } from 'zod';
+import {
+  InjectTool,
+  Input,
+  RunContext,
+  Tool,
+  ToolInterface,
+  ToolResult,
+  ToolSideEffects,
+  WorkflowInterface,
+  WorkflowMetadataInterface,
+} from '@loopstack/common';
+import { CreateDocument, EventSubscriberService, StateMachineToolCallProcessorService } from '@loopstack/core';
+
+const DelegateToolCallsSchema = z.object({
+  message: z.object({
+    id: z.string().optional(),
+    content: z.array(z.any()),
+  }),
+  document: z.string().optional(),
+  skipResponseMessage: z.boolean().optional(),
+  callback: z
+    .object({
+      transition: z.string(),
+    })
+    .optional(),
+});
+
+type DelegateToolCallsArgs = z.infer<typeof DelegateToolCallsSchema>;
+
+interface ToolResultEntry {
+  type: 'tool_result';
+  tool_use_id: string;
+  content?: string;
+  is_error?: boolean;
+}
+
+@Injectable()
+@Tool({
+  config: {
+    description: 'Delegate tool calls from an LLM response. Handles both sync tools and async task tools.',
+  },
+})
+export class DelegateToolCalls implements ToolInterface<DelegateToolCallsArgs> {
+  private readonly logger = new Logger(DelegateToolCalls.name);
+
+  @InjectTool() private createDocument: CreateDocument;
+
+  constructor(
+    private readonly toolCallProcessor: StateMachineToolCallProcessorService,
+    private readonly eventSubscriberService: EventSubscriberService,
+  ) {}
+
+  @Input({
+    schema: DelegateToolCallsSchema,
+  })
+  args: DelegateToolCallsArgs;
+
+  async execute(
+    args: DelegateToolCallsArgs,
+    ctx: RunContext,
+    parent: WorkflowInterface,
+    metadata: WorkflowMetadataInterface,
+  ): Promise<ToolResult> {
+    const contentBlocks = args.message.content as Anthropic.ContentBlock[];
+    const toolUseBlocks = contentBlocks.filter((b): b is Anthropic.ToolUseBlock => b.type === 'tool_use');
+
+    if (toolUseBlocks.length === 0) {
+      return {
+        data: { allCompleted: true, toolResults: [], message: args.message, pendingCount: 0 },
+      };
+    }
+
+    // 1. Execute ALL tools in parallel
+    const results = await Promise.all(toolUseBlocks.map((block) => this.executeTool(block, ctx, parent, metadata)));
+
+    // 2. Register subscribers for async results + build toolResults array
+    let pendingCount = 0;
+    const toolResults: ToolResultEntry[] = [];
+    const toolEffects: ToolSideEffects[] = [];
+
+    for (let i = 0; i < toolUseBlocks.length; i++) {
+      const block = toolUseBlocks[i];
+      const result = results[i];
+
+      // Collect effects from tool execution (e.g. link documents)
+      if (result.effects) {
+        toolEffects.push(...result.effects);
+      }
+
+      const resultData = result.data as Record<string, unknown> | undefined;
+      if (resultData?.mode === 'async') {
+        // Validate callback is provided
+        if (!args.callback?.transition) {
+          throw new Error(
+            `Tool "${block.name}" returned an async result but no callback.transition was provided. ` +
+              `Add a callback configuration to the delegateToolCalls args.`,
+          );
+        }
+
+        // Register event subscriber
+        await this.eventSubscriberService.registerSubscriber(
+          ctx.pipelineId,
+          ctx.workflowId!,
+          args.callback.transition,
+          resultData.correlationId as string,
+          resultData.eventName as string,
+          ctx.userId,
+          ctx.workspaceId,
+          { toolUseId: block.id, toolName: block.name },
+        );
+
+        pendingCount++;
+      } else {
+        toolResults.push({
+          type: 'tool_result',
+          tool_use_id: block.id,
+          content: result.data ? JSON.stringify(result.data, null, 2) : '',
+          is_error: !!result.error,
+        });
+      }
+    }
+
+    // 3. Create response document first (tool call message), then append
+    //    tool execution effects (e.g. link documents) so they appear after.
+    const effects: ToolSideEffects[] = [];
+    if (args.document && !args.skipResponseMessage) {
+      const docResult = await this.createResponseDocument(args, toolResults, ctx, parent, metadata);
+      if (docResult.effects) {
+        effects.push(...docResult.effects);
+      }
+    }
+    effects.push(...toolEffects);
+
+    return {
+      data: {
+        allCompleted: pendingCount === 0,
+        toolResults,
+        message: args.message,
+        pendingCount,
+      },
+      effects,
+    };
+  }
+
+  private async executeTool(
+    block: Anthropic.ToolUseBlock,
+    ctx: RunContext,
+    parent: WorkflowInterface,
+    metadata: WorkflowMetadataInterface,
+  ): Promise<ToolResult> {
+    const tool = this.toolCallProcessor.getTool(parent, block.name);
+    const parsedArgs = this.toolCallProcessor.parseArgs(
+      tool,
+      block.input as Record<string, unknown> | undefined,
+      metadata.transition!,
+    );
+
+    try {
+      return await this.toolCallProcessor.executeToolCall(tool, parsedArgs, ctx, parent, metadata);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Tool "${block.name}" failed: ${errorMessage}`);
+      return {
+        data: errorMessage,
+        error: errorMessage,
+      };
+    }
+  }
+
+  private async createResponseDocument(
+    args: DelegateToolCallsArgs,
+    toolResults: ToolResultEntry[],
+    ctx: RunContext,
+    parent: WorkflowInterface,
+    metadata: WorkflowMetadataInterface,
+  ): Promise<ToolResult> {
+    return this.createDocument.execute(
+      {
+        id: args.message.id,
+        document: args.document!,
+        validate: 'skip' as const,
+        update: {
+          content: {
+            role: 'assistant',
+            content: args.message.content,
+            toolResults,
+          },
+        },
+      },
+      ctx,
+      parent,
+      metadata,
+    );
+  }
+}

package/src/tools/index.ts

@@ -1,4 +1,5 @@
 export * from './claude-generate-text.tool';
 export * from './claude-generate-object.tool';
 export * from './claude-generate-document.tool';
-export * from './claude-delegate-tool-call.tool';
+export * from './delegate-tool-calls.tool';
+export * from './update-tool-result.tool';

package/src/tools/update-tool-result.tool.ts

@@ -0,0 +1,139 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { z } from 'zod';
+import {
+  InjectTool,
+  Input,
+  RunContext,
+  Tool,
+  ToolInterface,
+  ToolResult,
+  ToolSideEffects,
+  WorkflowInterface,
+  WorkflowMetadataInterface,
+} from '@loopstack/common';
+import { CreateDocument, StateMachineToolCallProcessorService } from '@loopstack/core';
+
+const UpdateToolResultSchema = z.object({
+  delegateResult: z.object({
+    allCompleted: z.boolean(),
+    toolResults: z.array(z.any()),
+    message: z.any(),
+    pendingCount: z.number(),
+  }),
+  completedTool: z.any(),
+  document: z.string().optional(),
+});
+
+type UpdateToolResultArgs = z.infer<typeof UpdateToolResultSchema>;
+
+@Injectable()
+@Tool({
+  config: {
+    description: 'Handle async tool completion callback. Updates the response document and tracks completion state.',
+  },
+})
+export class UpdateToolResult implements ToolInterface<UpdateToolResultArgs> {
+  private readonly logger = new Logger(UpdateToolResult.name);
+
+  @InjectTool() private createDocument: CreateDocument;
+
+  constructor(private readonly toolCallProcessor: StateMachineToolCallProcessorService) {}
+
+  @Input({
+    schema: UpdateToolResultSchema,
+  })
+  args: UpdateToolResultArgs;
+
+  async execute(
+    args: UpdateToolResultArgs,
+    ctx: RunContext,
+    parent: WorkflowInterface,
+    metadata: WorkflowMetadataInterface,
+  ): Promise<ToolResult> {
+    const { delegateResult } = args;
+    const completedToolRecord = args.completedTool as Record<string, unknown>;
+
+    // 1. Extract tool identity from subscriber metadata
+    const subscriberMetadata = completedToolRecord._subscriberMetadata as
+      | { toolUseId: string; toolName: string }
+      | undefined;
+    if (!subscriberMetadata?.toolUseId || !subscriberMetadata?.toolName) {
+      throw new Error(
+        'Callback payload is missing _subscriberMetadata with toolUseId and toolName. ' +
+          'Ensure the event subscriber was registered with metadata by delegateToolCalls.',
+      );
+    }
+
+    const { toolUseId, toolName } = subscriberMetadata;
+
+    // 2. Resolve tool and call complete() if it exists
+    const tool = this.toolCallProcessor.getTool(parent, toolName);
+    let toolResult: ToolResult;
+    try {
+      if (tool.complete) {
+        toolResult = await tool.complete(completedToolRecord, ctx, parent, metadata);
+      } else {
+        toolResult = { data: completedToolRecord.result ?? completedToolRecord };
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Tool "${toolName}" complete() failed: ${errorMessage}`);
+      toolResult = {
+        data: errorMessage,
+        error: errorMessage,
+      };
+    }
+
+    // 3. Merge into toolResults (append completed result)
+    const completedEntry = {
+      type: 'tool_result' as const,
+      tool_use_id: toolUseId,
+      content: toolResult.data ? JSON.stringify(toolResult.data, null, 2) : '',
+      is_error: !!toolResult.error,
+    };
+    const updatedResults = [...(delegateResult.toolResults as Record<string, unknown>[]), completedEntry];
+
+    // 4. Update completion state
+    const pendingCount = delegateResult.pendingCount - 1;
+    const allCompleted = pendingCount === 0;
+
+    // 5. Create updated response document (invalidates previous)
+    const allEffects: ToolSideEffects[] = [];
+    if (toolResult.effects) {
+      allEffects.push(...toolResult.effects);
+    }
+
+    if (args.document) {
+      const docResult = await this.createDocument.execute(
+        {
+          id: (delegateResult.message as Record<string, unknown>).id as string,
+          document: args.document,
+          validate: 'skip' as const,
+          update: {
+            content: {
+              role: 'assistant',
+              content: (delegateResult.message as Record<string, unknown>).content,
+              toolResults: updatedResults,
+            },
+          },
+        },
+        ctx,
+        parent,
+        metadata,
+      );
+      if (docResult.effects) {
+        allEffects.push(...docResult.effects);
+      }
+    }
+
+    return {
+      data: {
+        ...delegateResult,
+        toolResults: updatedResults,
+        allCompleted,
+        pendingCount,
+      },
+      effects: allEffects.length > 0 ? allEffects : undefined,
+    };
+  }
+}

package/dist/tools/claude-delegate-tool-call.tool.d.ts

@@ -1,19 +0,0 @@
-import { z } from 'zod';
-import { RunContext, ToolInterface, ToolResult, WorkflowInterface, WorkflowMetadataInterface } from '@loopstack/common';
-declare const ClaudeDelegateToolCallSchema: z.ZodObject<{
-    message: z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        content: z.ZodArray<z.ZodAny>;
-    }, z.core.$strip>;
-    document: z.ZodOptional<z.ZodString>;
-    skipResponseMessage: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-type ClaudeDelegateToolCallArgs = z.infer<typeof ClaudeDelegateToolCallSchema>;
-export declare class ClaudeDelegateToolCall implements ToolInterface<ClaudeDelegateToolCallArgs> {
-    private readonly logger;
-    args: ClaudeDelegateToolCallArgs;
-    execute(args: ClaudeDelegateToolCallArgs, ctx: RunContext, parent: WorkflowInterface, runtime: WorkflowMetadataInterface): Promise<ToolResult>;
-    private createResponseMessage;
-}
-export {};
-//# sourceMappingURL=claude-delegate-tool-call.tool.d.ts.map

package/dist/tools/claude-delegate-tool-call.tool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"claude-delegate-tool-call.tool.d.ts","sourceRoot":"","sources":["../../src/tools/claude-delegate-tool-call.tool.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAEL,UAAU,EAEV,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,yBAAyB,EAE1B,MAAM,mBAAmB,CAAC;AAE3B,QAAA,MAAM,4BAA4B;;;;;;;iBAOhC,CAAC;AAEH,KAAK,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAE/E,qBAKa,sBAAuB,YAAW,aAAa,CAAC,0BAA0B,CAAC;IACtF,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2C;IAKlE,IAAI,EAAE,0BAA0B,CAAC;IAE3B,OAAO,CACX,IAAI,EAAE,0BAA0B,EAChC,GAAG,EAAE,UAAU,EACf,MAAM,EAAE,iBAAiB,EACzB,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,UAAU,CAAC;YAoDR,qBAAqB;CA6BpC"}

package/dist/tools/claude-delegate-tool-call.tool.js

@@ -1,102 +0,0 @@
-"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);
-};
-var ClaudeDelegateToolCall_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClaudeDelegateToolCall = void 0;
-const common_1 = require("@nestjs/common");
-const zod_1 = require("zod");
-const common_2 = require("@loopstack/common");
-const ClaudeDelegateToolCallSchema = zod_1.z.object({
-    message: zod_1.z.object({
-        id: zod_1.z.string().optional(),
-        content: zod_1.z.array(zod_1.z.any()),
-    }),
-    document: zod_1.z.string().optional(),
-    skipResponseMessage: zod_1.z.boolean().optional(),
-});
-let ClaudeDelegateToolCall = ClaudeDelegateToolCall_1 = class ClaudeDelegateToolCall {
-    logger = new common_1.Logger(ClaudeDelegateToolCall_1.name);
-    args;
-    async execute(args, ctx, parent, runtime) {
-        const contentBlocks = args.message.content;
-        const toolResults = [];
-        for (const block of contentBlocks) {
-            if (block.type !== 'tool_use') {
-                continue;
-            }
-            const tool = (0, common_2.getBlockTool)(parent, block.name);
-            if (!tool) {
-                throw new Error(`Tool ${block.name} not found.`);
-            }
-            try {
-                const result = await tool.execute(block.input, ctx, parent, runtime);
-                toolResults.push({
-                    type: 'tool_result',
-                    tool_use_id: block.id,
-                    content: JSON.stringify(result.data, null, 2),
-                });
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                this.logger.error(`Tool "${block.name}" failed: ${errorMessage}`);
-                toolResults.push({
-                    type: 'tool_result',
-                    tool_use_id: block.id,
-                    content: errorMessage,
-                    is_error: true,
-                });
-            }
-        }
-        const resultData = { toolResults };
-        if (args.document && !args.skipResponseMessage) {
-            const docResult = await this.createResponseMessage(args, toolResults, ctx, parent, runtime);
-            return {
-                data: resultData,
-                effects: docResult.effects,
-            };
-        }
-        return {
-            data: resultData,
-        };
-    }
-    async createResponseMessage(args, toolResults, ctx, parent, runtime) {
-        const createDocumentTool = (0, common_2.getBlockTool)(parent, 'createDocument');
-        if (!createDocumentTool) {
-            throw new Error('createDocument tool not found in parent context.');
-        }
-        return createDocumentTool.execute({
-            id: args.message.id,
-            document: args.document,
-            update: {
-                content: {
-                    role: 'assistant',
-                    content: args.message.content,
-                    toolResults,
-                },
-            },
-        }, ctx, parent, runtime);
-    }
-};
-exports.ClaudeDelegateToolCall = ClaudeDelegateToolCall;
-__decorate([
-    (0, common_2.Input)({
-        schema: ClaudeDelegateToolCallSchema,
-    }),
-    __metadata("design:type", Object)
-], ClaudeDelegateToolCall.prototype, "args", void 0);
-exports.ClaudeDelegateToolCall = ClaudeDelegateToolCall = ClaudeDelegateToolCall_1 = __decorate([
-    (0, common_2.Tool)({
-        config: {
-            description: 'Delegate tool calls from a Claude response.',
-        },
-    })
-], ClaudeDelegateToolCall);
-//# sourceMappingURL=claude-delegate-tool-call.tool.js.map

package/dist/tools/claude-delegate-tool-call.tool.js.map

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