@townco/agent 0.1.44 → 0.1.46

package/dist/acp-server/tool-summarizer.js

@@ -1,182 +0,0 @@
-import { z } from "zod";
-/**
- * Anthropic API tool call format
- */
-export const AnthropicToolCallSchema = z.object({
-    id: z.string(),
-    type: z.literal("tool_use"),
-    name: z.string(),
-    input: z.record(z.string(), z.unknown()),
-});
-/**
- * Anthropic API content block format
- */
-export const AnthropicContentBlockSchema = z.discriminatedUnion("type", [
-    z.object({
-        type: z.literal("text"),
-        text: z.string(),
-    }),
-    AnthropicToolCallSchema,
-    z.object({
-        type: z.literal("tool_result"),
-        tool_use_id: z.string(),
-        content: z.union([
-            z.string(),
-            z.array(z.object({
-                type: z.literal("text"),
-                text: z.string(),
-            })),
-        ]),
-        is_error: z.boolean().optional(),
-    }),
-]);
-/**
- * Anthropic API message format
- */
-export const AnthropicMessageSchema = z.object({
-    role: z.enum(["user", "assistant"]),
-    content: z.union([z.string(), z.array(AnthropicContentBlockSchema)]),
-});
-/**
- * Anthropic API request format
- */
-export const AnthropicRequestSchema = z.object({
-    model: z.string().optional(),
-    messages: z.array(AnthropicMessageSchema),
-    max_tokens: z.number().optional(),
-    temperature: z.number().optional(),
-    tools: z.array(z.any()).optional(),
-    system: z.union([z.string(), z.array(z.any())]).optional(),
-});
-/**
- * Extract tool calls from Anthropic API messages
- */
-export function extractToolCalls(messages) {
-    const summaries = [];
-    const toolResultsMap = new Map();
-    // First pass: collect all tool results
-    for (const message of messages) {
-        if (typeof message.content === "string")
-            continue;
-        for (const block of message.content) {
-            if (block.type === "tool_result") {
-                const content = typeof block.content === "string"
-                    ? block.content
-                    : block.content.map((c) => c.text).join("\n");
-                toolResultsMap.set(block.tool_use_id, {
-                    content,
-                    isError: block.is_error ?? false,
-                });
-            }
-        }
-    }
-    // Second pass: collect all tool calls and match with results
-    for (const message of messages) {
-        if (typeof message.content === "string")
-            continue;
-        for (const block of message.content) {
-            if (block.type === "tool_use") {
-                const result = toolResultsMap.get(block.id);
-                const summary = {
-                    id: block.id,
-                    name: block.name,
-                    description: generateToolDescription(block.name, block.input),
-                    input: block.input,
-                    output: result?.content ?? undefined,
-                    status: result
-                        ? result.isError
-                            ? "error"
-                            : "completed"
-                        : "pending",
-                    error: result?.isError ? result.content : undefined,
-                };
-                summaries.push(summary);
-            }
-        }
-    }
-    return summaries;
-}
-/**
- * Generate a human-readable description for a tool call
- */
-function generateToolDescription(toolName, input) {
-    switch (toolName) {
-        case "read_file":
-            return `Reading file: ${input.target_file || "unknown"}`;
-        case "write":
-            return `Writing file: ${input.file_path || "unknown"}`;
-        case "search_replace":
-            return `Editing file: ${input.file_path || "unknown"}`;
-        case "grep":
-            return `Searching for: "${input.pattern || "unknown"}"`;
-        case "codebase_search":
-            return `Semantic search: "${input.query || "unknown"}"`;
-        case "run_terminal_cmd":
-            return `Running command: ${input.command || "unknown"}`;
-        case "list_dir":
-            return `Listing directory: ${input.target_directory || "unknown"}`;
-        case "glob_file_search":
-            return `Finding files: ${input.glob_pattern || "unknown"}`;
-        case "delete_file":
-            return `Deleting file: ${input.target_file || "unknown"}`;
-        case "todo_write":
-            return `Updating TODO list (${input.todos?.length || 0} items)`;
-        default:
-            return `${toolName}(${Object.keys(input).join(", ")})`;
-    }
-}
-/**
- * Generate a summary of tool calls for the entire conversation
- */
-export function summarizeToolCalls(request) {
-    const summaries = extractToolCalls(request.messages);
-    const byStatus = {
-        pending: 0,
-        completed: 0,
-        error: 0,
-    };
-    const byTool = {};
-    for (const summary of summaries) {
-        byStatus[summary.status] = (byStatus[summary.status] || 0) + 1;
-        byTool[summary.name] = (byTool[summary.name] || 0) + 1;
-    }
-    return {
-        total: summaries.length,
-        byStatus,
-        byTool,
-        summaries,
-    };
-}
-/**
- * Generate a text summary of tool calls
- */
-export function generateTextSummary(summaries, options) {
-    if (summaries.length === 0) {
-        return "No tool calls in this conversation.";
-    }
-    const { includeDetails = false, maxLength = 1000 } = options || {};
-    let text = `Found ${summaries.length} tool call(s):\n\n`;
-    for (const summary of summaries) {
-        const statusEmoji = summary.status === "completed"
-            ? "✓"
-            : summary.status === "error"
-                ? "✗"
-                : "⋯";
-        text += `${statusEmoji} ${summary.description}\n`;
-        if (includeDetails) {
-            if (summary.output) {
-                const outputPreview = summary.output.length > 100
-                    ? `${summary.output.slice(0, 100)}...`
-                    : summary.output;
-                text += `  Output: ${outputPreview}\n`;
-            }
-            if (summary.error) {
-                text += `  Error: ${summary.error}\n`;
-            }
-        }
-    }
-    if (text.length > maxLength) {
-        text = `${text.slice(0, maxLength)}...\n\n(truncated)`;
-    }
-    return text;
-}