@loopstack/claude-module 0.22.4 → 0.22.5

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

@@ -1,139 +0,0 @@
-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,5 +0,0 @@
-export * from './claude-generate-text.tool';
-export * from './claude-generate-object.tool';
-export * from './claude-generate-document.tool';
-export * from './delegate-tool-calls.tool';
-export * from './update-tool-result.tool';

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

@@ -1,99 +0,0 @@
-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,60 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-import type { ToolCallsMap } from '@loopstack/common';
-
-/**
- * Configuration for creating a Claude client and selecting a model.
- */
-export interface ClaudeModelConfig {
-  /** Model name (e.g. 'claude-sonnet-4-20250514'). Falls back to CLAUDE_MODEL env var. */
-  model?: string;
-  /** Environment variable name containing the API key. Falls back to ANTHROPIC_API_KEY. */
-  envApiKey?: string;
-}
-
-/**
- * Options for a Claude messages API call.
- */
-export interface ClaudeGenerateOptions {
-  messages: Anthropic.MessageParam[];
-  system?: string;
-  tools?: Anthropic.Tool[];
-  maxTokens?: number;
-  toolChoice?: Anthropic.MessageCreateParams['tool_choice'];
-}
-
-/**
- * A tool definition in Anthropic's native format.
- */
-export interface ClaudeToolDefinition {
-  name: string;
-  description: string;
-  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/src/types/index.ts

@@ -1 +0,0 @@
-export * from './claude.types';

package/src/utils/cache.utils.ts

@@ -1,59 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-
-const CACHE_CONTROL: Anthropic.CacheControlEphemeral = { type: 'ephemeral' };
-
-/**
- * Returns a copy of the API call options with prompt caching breakpoints applied.
- *
- * Breakpoints are placed on:
- * 1. The system prompt (stable across turns)
- * 2. The last tool definition (stable across turns)
- * 3. The last content block of the last message (covers growing conversation)
- *
- * Does not mutate the input — returns new objects with cache_control markers.
- */
-export function applyCacheBreakpoints(options: {
-  system?: string | Anthropic.TextBlockParam[];
-  tools?: Anthropic.Tool[];
-  messages: Anthropic.MessageParam[];
-}): {
-  system?: string | Anthropic.TextBlockParam[];
-  tools?: Anthropic.Tool[];
-  messages: Anthropic.MessageParam[];
-} {
-  // 1. System prompt → convert string to block array with cache_control
-  let system: string | Anthropic.TextBlockParam[] | undefined = options.system;
-  if (system && typeof system === 'string') {
-    system = [{ type: 'text', text: system, cache_control: CACHE_CONTROL }];
-  }
-
-  // 2. Last tool definition — shallow-clone the array and mark the last entry
-  let tools = options.tools;
-  if (tools?.length) {
-    tools = [...tools];
-    const last = tools.length - 1;
-    tools[last] = { ...tools[last], cache_control: CACHE_CONTROL };
-  }
-
-  // 3. Last message — clone only the last message and mark its last content block
-  let messages = options.messages;
-  if (messages.length > 0) {
-    messages = [...messages];
-    const lastIdx = messages.length - 1;
-    const lastMsg = messages[lastIdx];
-
-    if (typeof lastMsg.content === 'string') {
-      messages[lastIdx] = {
-        ...lastMsg,
-        content: [{ type: 'text', text: lastMsg.content, cache_control: CACHE_CONTROL }],
-      };
-    } else if (Array.isArray(lastMsg.content) && lastMsg.content.length > 0) {
-      const blocks: Anthropic.ContentBlockParam[] = [...lastMsg.content];
-      const lastBlockIdx = blocks.length - 1;
-      blocks[lastBlockIdx] = { ...blocks[lastBlockIdx], cache_control: CACHE_CONTROL } as Anthropic.ContentBlockParam;
-      messages[lastIdx] = { ...lastMsg, content: blocks };
-    }
-  }
-
-  return { system, tools, messages };
-}