@loopstack/claude-module 0.21.0 → 0.22.0

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

@@ -1,19 +1,12 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { Inject } from '@nestjs/common';
 import { z } from 'zod';
-import {
-  Input,
-  RunContext,
-  Tool,
-  ToolInterface,
-  ToolResult,
-  WorkflowInterface,
-  WorkflowMetadataInterface,
-} from '@loopstack/common';
+import { BaseTool, Tool, ToolCallEntry, ToolCallsMap, ToolResult } from '@loopstack/common';
 import { ClaudeGenerateToolBaseSchema } from '../schemas/claude-generate-tool-base.schema';
 import { ClaudeClientService } from '../services';
 import { ClaudeMessagesHelperService } from '../services';
 import { ClaudeToolsHelperService } from '../services';
+import { ClaudeGenerateTextResult } from '../types';
 import { applyCacheBreakpoints } from '../utils/cache.utils';
 
 export const ClaudeGenerateTextSchema = ClaudeGenerateToolBaseSchema.extend({
@@ -23,11 +16,12 @@ export const ClaudeGenerateTextSchema = ClaudeGenerateToolBaseSchema.extend({
 type ClaudeGenerateTextArgsType = z.infer<typeof ClaudeGenerateTextSchema>;
 
 @Tool({
-  config: {
+  uiConfig: {
     description: 'Generates text using the Anthropic Claude API',
   },
+  schema: ClaudeGenerateTextSchema,
 })
-export class ClaudeGenerateText implements ToolInterface<ClaudeGenerateTextArgsType> {
+export class ClaudeGenerateText extends BaseTool {
   @Inject()
   private readonly claudeClientService: ClaudeClientService;
   @Inject()
@@ -35,17 +29,7 @@ export class ClaudeGenerateText implements ToolInterface<ClaudeGenerateTextArgsT
   @Inject()
   private readonly claudeToolsHelperService: ClaudeToolsHelperService;
 
-  @Input({
-    schema: ClaudeGenerateTextSchema,
-  })
-  args: ClaudeGenerateTextArgsType;
-
-  async execute(
-    args: ClaudeGenerateTextArgsType,
-    ctx: RunContext,
-    parent: WorkflowInterface,
-    runtime: WorkflowMetadataInterface,
-  ): Promise<ToolResult> {
+  async call(args: ClaudeGenerateTextArgsType): Promise<ToolResult<ClaudeGenerateTextResult>> {
     const client = this.claudeClientService.getClient(args.claude);
     const model = this.claudeClientService.getModel(args.claude);
 
@@ -54,14 +38,14 @@ export class ClaudeGenerateText implements ToolInterface<ClaudeGenerateTextArgsT
     if (args.prompt) {
       messages.push({ role: 'user', content: args.prompt });
     } else {
-      const resolved = this.claudeMessagesHelperService.getMessages(runtime.documents, {
+      const resolved = this.claudeMessagesHelperService.getMessages(this.ctx.runtime.documents, {
         messages: args.messages as Anthropic.MessageParam[],
         messagesSearchTag: args.messagesSearchTag,
       });
       messages.push(...resolved);
     }
 
-    const tools = args.tools ? this.claudeToolsHelperService.getTools(args.tools, parent) : undefined;
+    const tools = args.tools ? this.claudeToolsHelperService.getTools(args.tools, this.ctx.parent) : undefined;
 
     const response = await this.handleGenerateText(client, {
       model,
@@ -72,8 +56,13 @@ export class ClaudeGenerateText implements ToolInterface<ClaudeGenerateTextArgsT
       cache: args.claude?.cache,
     });
 
+    const toolCalls = this.extractToolCalls(response);
+
     return {
-      data: response,
+      data: {
+        ...response,
+        ...(toolCalls ? { toolCalls } : {}),
+      },
       metadata: {
         usage: {
           inputTokens: response.usage.input_tokens,
@@ -85,6 +74,25 @@ export class ClaudeGenerateText implements ToolInterface<ClaudeGenerateTextArgsT
     };
   }
 
+  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,139 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { Injectable, Logger } from '@nestjs/common';
+import { z } from 'zod';
+import {
+  BaseTool,
+  DocumentClass,
+  Tool,
+  ToolCallOptions,
+  ToolResult,
+  getBlockTool,
+  getBlockTypeFromMetadata,
+} from '@loopstack/common';
+import type { DelegateToolCallsResult, DelegateToolResultEntry } from '../types';
+
+const DelegateToolCallsSchema = z.object({
+  message: z.object({
+    id: z.string().optional(),
+    content: z.array(z.any()),
+  }),
+  document: z
+    .custom<DocumentClass>((val) => typeof val === 'function' && getBlockTypeFromMetadata(val as object) === 'document')
+    .optional(),
+  skipResponseMessage: z.boolean().optional(),
+  callback: z
+    .object({
+      transition: z.string(),
+    })
+    .optional(),
+});
+
+type DelegateToolCallsArgs = z.infer<typeof DelegateToolCallsSchema>;
+
+@Injectable()
+@Tool({
+  uiConfig: {
+    description: 'Delegate tool calls from an LLM response. Handles both sync tools and async task tools.',
+  },
+  schema: DelegateToolCallsSchema,
+})
+export class DelegateToolCalls extends BaseTool {
+  private readonly logger = new Logger(DelegateToolCalls.name);
+
+  async call(args: DelegateToolCallsArgs): Promise<ToolResult<DelegateToolCallsResult>> {
+    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 as DelegateToolCallsResult['message'],
+          pendingCount: 0,
+        },
+      };
+    }
+
+    // 1. Execute ALL tools in parallel, passing callback via options (not args)
+    const results = await Promise.all(
+      toolUseBlocks.map((block) => {
+        const toolCallback = args.callback
+          ? {
+              transition: args.callback.transition,
+              metadata: { toolUseId: block.id, toolName: block.name },
+            }
+          : undefined;
+        return this.executeTool(block, toolCallback ? { callback: toolCallback } : undefined);
+      }),
+    );
+
+    // 2. Build toolResults array — async tools signal via result.pending
+    let pendingCount = 0;
+    const toolResults: DelegateToolResultEntry[] = [];
+
+    for (let i = 0; i < toolUseBlocks.length; i++) {
+      const block = toolUseBlocks[i];
+      const result = results[i];
+
+      if (result.pending) {
+        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 (tool call message)
+    if (args.document && !args.skipResponseMessage) {
+      await this.createResponseDocument(args.document, args, toolResults);
+    }
+
+    return {
+      data: {
+        allCompleted: pendingCount === 0,
+        toolResults,
+        message: args.message as DelegateToolCallsResult['message'],
+        pendingCount,
+      },
+    };
+  }
+
+  private async executeTool(block: Anthropic.ToolUseBlock, options?: ToolCallOptions): Promise<ToolResult> {
+    try {
+      const tool = getBlockTool<BaseTool>(this.ctx.parent, block.name);
+      if (!tool) {
+        throw new Error(`Tool with name ${block.name} not found.`);
+      }
+
+      return await tool.call(block.input as Record<string, unknown>, options);
+    } 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(
+    document: DocumentClass,
+    args: DelegateToolCallsArgs,
+    toolResults: DelegateToolResultEntry[],
+  ): Promise<void> {
+    await this.repository.save(
+      document,
+      {
+        role: 'assistant',
+        content: args.message.content,
+        toolResults,
+      },
+      { id: args.message.id, validate: 'skip' },
+    );
+  }
+}

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,99 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { z } from 'zod';
+import { BaseTool, DocumentClass, Tool, ToolResult, getBlockTool, getBlockTypeFromMetadata } from '@loopstack/common';
+
+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
+    .custom<DocumentClass>((val) => typeof val === 'function' && getBlockTypeFromMetadata(val as object) === 'document')
+    .optional(),
+});
+
+type UpdateToolResultArgs = z.infer<typeof UpdateToolResultSchema>;
+
+@Injectable()
+@Tool({
+  uiConfig: {
+    description: 'Handle async tool completion callback. Updates the response document and tracks completion state.',
+  },
+  schema: UpdateToolResultSchema,
+})
+export class UpdateToolResult extends BaseTool {
+  private readonly logger = new Logger(UpdateToolResult.name);
+
+  async call(args: UpdateToolResultArgs): 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()
+    const tool = getBlockTool<BaseTool>(this.ctx.parent, toolName);
+    if (!tool) {
+      throw new Error(`Tool with name ${toolName} not found.`);
+    }
+    let toolResult: ToolResult;
+    try {
+      toolResult = await tool.complete(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. Update response document (invalidates previous)
+    if (args.document) {
+      await this.repository.save(
+        args.document,
+        {
+          role: 'assistant',
+          content: (delegateResult.message as Record<string, unknown>).content,
+          toolResults: updatedResults,
+        },
+        { id: (delegateResult.message as Record<string, unknown>).id as string, validate: 'skip' },
+      );
+    }
+
+    return {
+      data: {
+        ...delegateResult,
+        toolResults: updatedResults,
+        allCompleted,
+        pendingCount,
+      },
+    };
+  }
+}

package/src/types/claude.types.ts

@@ -1,4 +1,5 @@
 import Anthropic from '@anthropic-ai/sdk';
+import type { ToolCallsMap } from '@loopstack/common';
 
 /**
  * Configuration for creating a Claude client and selecting a model.
@@ -30,5 +31,30 @@ export interface ClaudeToolDefinition {
   input_schema: Anthropic.Tool['input_schema'];
 }
 
+/**
+ * Result data from ClaudeGenerateText tool.
+ * Extends the Anthropic Message with optional tool call metadata.
+ */
+export interface ClaudeGenerateTextResult extends Anthropic.Message {
+  toolCalls?: ToolCallsMap;
+}
+
+/**
+ * Result data from DelegateToolCalls tool.
+ */
+export interface DelegateToolCallsResult {
+  allCompleted: boolean;
+  toolResults: DelegateToolResultEntry[];
+  message: { id?: string; content: Anthropic.ContentBlock[] };
+  pendingCount: number;
+}
+
+export interface DelegateToolResultEntry {
+  type: 'tool_result';
+  tool_use_id: string;
+  content?: string;
+  is_error?: boolean;
+}
+
 // Re-export Anthropic namespace for consumer convenience
 export { default as Anthropic } from '@anthropic-ai/sdk';

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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"}

package/src/tools/claude-delegate-tool-call.tool.ts

@@ -1,125 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-import { Logger } from '@nestjs/common';
-import { z } from 'zod';
-import {
-  Input,
-  RunContext,
-  Tool,
-  ToolInterface,
-  ToolResult,
-  WorkflowInterface,
-  WorkflowMetadataInterface,
-  getBlockTool,
-} from '@loopstack/common';
-
-const ClaudeDelegateToolCallSchema = z.object({
-  message: z.object({
-    id: z.string().optional(),
-    content: z.array(z.any()),
-  }),
-  document: z.string().optional(),
-  skipResponseMessage: z.boolean().optional(),
-});
-
-type ClaudeDelegateToolCallArgs = z.infer<typeof ClaudeDelegateToolCallSchema>;
-
-@Tool({
-  config: {
-    description: 'Delegate tool calls from a Claude response.',
-  },
-})
-export class ClaudeDelegateToolCall implements ToolInterface<ClaudeDelegateToolCallArgs> {
-  private readonly logger = new Logger(ClaudeDelegateToolCall.name);
-
-  @Input({
-    schema: ClaudeDelegateToolCallSchema,
-  })
-  args: ClaudeDelegateToolCallArgs;
-
-  async execute(
-    args: ClaudeDelegateToolCallArgs,
-    ctx: RunContext,
-    parent: WorkflowInterface,
-    runtime: WorkflowMetadataInterface,
-  ): Promise<ToolResult> {
-    const contentBlocks = args.message.content as Anthropic.ContentBlock[];
-    const toolResults: Anthropic.ToolResultBlockParam[] = [];
-
-    for (const block of contentBlocks) {
-      if (block.type !== 'tool_use') {
-        continue;
-      }
-
-      const tool = getBlockTool<ToolInterface>(parent, block.name);
-
-      if (!tool) {
-        throw new Error(`Tool ${block.name} not found.`);
-      }
-
-      try {
-        const result: ToolResult = await tool.execute(block.input as Record<string, unknown>, 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,
-    };
-  }
-
-  private async createResponseMessage(
-    args: ClaudeDelegateToolCallArgs,
-    toolResults: Anthropic.ToolResultBlockParam[],
-    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: args.message.id,
-        document: args.document,
-        update: {
-          content: {
-            role: 'assistant',
-            content: args.message.content,
-            toolResults,
-          },
-        },
-      },
-      ctx,
-      parent,
-      runtime,
-    );
-  }
-}