@xalia/agent 0.6.9 → 0.6.10

package/dist/agent/src/agent/tokenCounter.js

@@ -0,0 +1,390 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenCounter = exports.ModelDetector = void 0;
+exports.createTokenCounter = createTokenCounter;
+exports.countTokensQuick = countTokensQuick;
+exports.getContextWindowSize = getContextWindowSize;
+const tiktoken_1 = require("tiktoken");
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+/**
+ * Model context window sizes (from OpenRouter API)
+ * Only includes models currently used in DEFAULT_MODEL_MAP
+ */
+const MODEL_CONTEXT_WINDOWS = {
+    // OpenAI models
+    "gpt-4o-mini": 128000,
+    "gpt-4o": 128000,
+    "openai/gpt-4o-mini": 128000,
+    "openai/gpt-4o": 128000,
+    // Google models
+    "google/gemini-2.5-flash": 1048576,
+    "google/gemini-2.5-pro": 1048576,
+    "google/gemini-2.5-flash-image-preview": 32768,
+    // Anthropic models
+    "anthropic/claude-3.7-sonnet": 200000,
+    "anthropic/claude-sonnet-4": 1000000,
+    "anthropic/claude-sonnet-4.5": 1000000,
+    "claude-3-7-sonnet-20250219": 200000,
+};
+const DEFAULT_CONTEXT_WINDOW = 128000;
+/**
+ * Model provider detection and normalization
+ */
+exports.ModelDetector = {
+    /**
+     * Detect the provider from a model string
+     * Supports formats like:
+     * - "gpt-4o" -> openai
+     * - "openai/gpt-4o" -> openai
+     * - "anthropic/claude-sonnet-4.5" -> anthropic
+     * - "claude-3-7-sonnet-20250219" -> anthropic
+     * - "gemini-2.0-flash-exp" -> google
+     * - "google/gemini-2.0-flash-exp" -> google
+     */
+    detectProvider(model) {
+        const lowerModel = model.toLowerCase();
+        // Check for provider prefix (e.g., "anthropic/", "openai/")
+        if (lowerModel.startsWith("openai/")) {
+            return "openai";
+        }
+        if (lowerModel.startsWith("anthropic/")) {
+            return "anthropic";
+        }
+        if (lowerModel.startsWith("google/")) {
+            return "google";
+        }
+        // Check for model name patterns
+        if (lowerModel.includes("gpt")) {
+            return "openai";
+        }
+        if (lowerModel.includes("claude")) {
+            return "anthropic";
+        }
+        if (lowerModel.includes("gemini")) {
+            return "google";
+        }
+        if (lowerModel.includes("o1") || lowerModel.includes("o3")) {
+            return "openai";
+        }
+        return "unknown";
+    },
+    /**
+     * Normalize model string for tokenizer
+     * Primary purpose: Remove provider prefixes
+     *
+     * Note: tiktoken supports most OpenAI model variants natively
+     * (gpt-4o-mini, gpt-4o-2024-11-20, o1-preview, etc.),
+     * so we don't need to map them.
+     */
+    normalizeModel(model, _provider) {
+        // Remove provider prefix (e.g., "anthropic/" -> "")
+        // This is the main normalization needed for OpenRouter-style
+        // model strings
+        const normalized = model.replace(/^[^/]+\//, "");
+        // For OpenAI: tiktoken handles variants natively,
+        // just return normalized
+        // For Anthropic/Google: return normalized for their
+        // respective tokenizers
+        return normalized;
+    },
+};
+/**
+ * Multi-model token counter supporting OpenAI, Anthropic (Claude),
+ * and Google (Gemini)
+ */
+class TokenCounter {
+    constructor(model, options) {
+        this.encoder = null;
+        this.anthropicClient = null;
+        this.model = model;
+        this.provider = exports.ModelDetector.detectProvider(model);
+        this.normalizedModel = exports.ModelDetector.normalizeModel(model, this.provider);
+        // Initialize encoder based on provider
+        if (this.provider === "openai") {
+            try {
+                this.encoder = (0, tiktoken_1.encoding_for_model)(this.normalizedModel);
+            }
+            catch (_error) {
+                // Fallback to cl100k_base for unknown OpenAI models
+                this.encoder = (0, tiktoken_1.encoding_for_model)("gpt-4");
+            }
+        }
+        else if (this.provider === "anthropic") {
+            // Use p50k_base encoding for Claude (approximation)
+            this.encoder = (0, tiktoken_1.get_encoding)("p50k_base");
+        }
+        // Initialize Anthropic client for dev mode sanity checks
+        if (options?.enableDevMode && this.provider === "anthropic") {
+            const apiKey = process.env.ANTHROPIC_API_KEY;
+            if (apiKey) {
+                this.anthropicClient = new sdk_1.default({ apiKey });
+            }
+        }
+    }
+    getModel() {
+        return this.model;
+    }
+    getProvider() {
+        return this.provider;
+    }
+    getContextWindow() {
+        return MODEL_CONTEXT_WINDOWS[this.model] ?? DEFAULT_CONTEXT_WINDOW;
+    }
+    countTokens(text) {
+        if (!text || text.length === 0) {
+            return 0;
+        }
+        switch (this.provider) {
+            case "openai":
+                return this.countTokensOpenAI(text);
+            case "anthropic":
+                return this.countTokensAnthropic(text);
+            case "google":
+                return this.countTokensGoogle(text);
+            default:
+                return this.countTokensApproximation(text);
+        }
+    }
+    countMessageTokens(message) {
+        const contentTokens = this.countMessageContent(message);
+        const overhead = this.getMessageOverhead(message);
+        return contentTokens + overhead;
+    }
+    countMessagesTokens(messages) {
+        if (messages.length === 0) {
+            return 0;
+        }
+        let total = 0;
+        // Count each message
+        for (const message of messages) {
+            total += this.countMessageTokens(message);
+        }
+        // Add conversation-level overhead
+        total += this.getConversationOverhead(messages.length);
+        return total;
+    }
+    /**
+     * Free resources (for encoders)
+     */
+    free() {
+        if (this.encoder) {
+            this.encoder.free();
+            this.encoder = null;
+        }
+    }
+    /**
+     * DEV ONLY: Get accurate token count from Anthropic API
+     * for sanity checking
+     * This requires enableDevMode: true in constructor and
+     * ANTHROPIC_API_KEY environment variable
+     * Use this to compare against p50k_base approximation
+     */
+    async countTokensAccurate(text) {
+        if (this.provider !== "anthropic") {
+            // For non-Anthropic models, just use regular counting
+            return this.countTokens(text);
+        }
+        if (!this.anthropicClient) {
+            throw new Error("Accurate token counting requires enableDevMode: true " +
+                "and ANTHROPIC_API_KEY environment variable");
+        }
+        try {
+            const result = await this.anthropicClient.messages.countTokens({
+                model: this.normalizedModel,
+                messages: [{ role: "user", content: text }],
+            });
+            return result.input_tokens;
+        }
+        catch (_error) {
+            const errorMsg = _error instanceof Error ? _error.message : String(_error);
+            throw new Error(`Failed to get accurate token count from Anthropic API: ${errorMsg}`);
+        }
+    }
+    /**
+     * OpenAI token counting using tiktoken
+     */
+    countTokensOpenAI(text) {
+        if (!this.encoder) {
+            return this.countTokensApproximation(text);
+        }
+        try {
+            const tokens = this.encoder.encode(text);
+            return tokens.length;
+        }
+        catch (_error) {
+            // Fallback to approximation on error
+            return this.countTokensApproximation(text);
+        }
+    }
+    /**
+     * Anthropic (Claude) token counting using p50k_base approximation
+     * This is an approximation - for accurate counts,
+     * use countTokensAccurate() in dev mode
+     *
+     * Note: We add a fixed overhead of 7 tokens based on empirical
+     * testing, which improves accuracy from ~70% to ~95% for typical
+     * text lengths.
+     */
+    countTokensAnthropic(text) {
+        if (!this.encoder) {
+            return this.countTokensApproximation(text);
+        }
+        try {
+            const tokens = this.encoder.encode(text);
+            // Add fixed overhead of 7 tokens to improve approximation
+            // accuracy
+            return tokens.length + 7;
+        }
+        catch (_error) {
+            // Fallback to approximation on error
+            return this.countTokensApproximation(text);
+        }
+    }
+    /**
+     * Google (Gemini) token counting
+     * Note: Gemini doesn't have an official tokenizer library yet,
+     * so we use an approximation based on Gemini's documentation:
+     * ~4 characters per token for English text
+     */
+    countTokensGoogle(text) {
+        // Gemini approximation: ~4 chars per token
+        // More accurate than generic approximation due to Gemini-specific analysis
+        const charCount = text.length;
+        return Math.ceil(charCount / 4);
+    }
+    /**
+     * Generic approximation for unknown models
+     * Rule of thumb: ~4 characters per token for English text
+     * This is less accurate but works as a fallback
+     */
+    countTokensApproximation(text) {
+        const charCount = text.length;
+        // Add some overhead for whitespace and punctuation
+        return Math.ceil(charCount / 3.5);
+    }
+    /**
+     * Count tokens in message content (handles multimodal content)
+     */
+    countMessageContent(message) {
+        if (typeof message.content === "string") {
+            return this.countTokens(message.content);
+        }
+        if (Array.isArray(message.content)) {
+            let total = 0;
+            for (const part of message.content) {
+                if ("text" in part && typeof part.text === "string") {
+                    total += this.countTokens(part.text);
+                }
+                else if ("image_url" in part) {
+                    // Image tokens are provider-specific
+                    total += this.getImageTokens();
+                }
+            }
+            return total;
+        }
+        return 0;
+    }
+    /**
+     * Get per-message overhead tokens
+     * Based on OpenAI's documentation: each message has ~3-4 tokens of overhead
+     */
+    getMessageOverhead(message) {
+        // Base overhead for role
+        let overhead = 4;
+        // Additional overhead for tool calls
+        if ("tool_calls" in message && message.tool_calls) {
+            // Each tool call adds overhead
+            overhead += message.tool_calls.length * 3;
+            // Count tokens in tool call arguments
+            for (const toolCall of message.tool_calls) {
+                const func = toolCall.function;
+                if (func.arguments) {
+                    overhead += this.countTokens(func.arguments);
+                }
+                if (func.name) {
+                    overhead += this.countTokens(func.name);
+                }
+            }
+        }
+        // Additional overhead for tool message
+        if ("tool_call_id" in message && message.tool_call_id) {
+            overhead += 2;
+        }
+        return overhead;
+    }
+    /**
+     * Get conversation-level overhead
+     * For OpenAI: 3 tokens per request
+     * For Claude: Similar overhead
+     */
+    getConversationOverhead(messageCount) {
+        if (messageCount === 0) {
+            return 0;
+        }
+        switch (this.provider) {
+            case "openai":
+                return 3; // Per OpenAI docs
+            case "anthropic":
+                return 3; // Similar to OpenAI
+            case "google":
+                return 2; // Gemini has lower overhead
+            default:
+                return 3;
+        }
+    }
+    /**
+     * Get estimated tokens for an image
+     * This is a rough estimate - actual tokens depend on image size
+     * and detail level
+     *
+     * Sources:
+     * - OpenAI: https://platform.openai.com/docs/guides/vision
+     *   "low" detail: 85 tokens,
+     *   "high" detail: 85 base + tiles (170-765+ tokens)
+     * - Anthropic: https://docs.anthropic.com/claude/docs/vision
+     *   Standard images: ~1600 tokens
+     * - Google: No official token count documentation available
+     */
+    getImageTokens() {
+        switch (this.provider) {
+            case "openai":
+                // Using mid-range estimate between low (85) and typical
+                // high detail (~255)
+                // Most images use "auto" which chooses based on content
+                return 170;
+            case "anthropic":
+                // Claude documentation: ~1600 tokens for standard images
+                return 1600;
+            case "google":
+                // Gemini: No official documentation, using conservative estimate
+                return 1000;
+            default:
+                return 1000;
+        }
+    }
+}
+exports.TokenCounter = TokenCounter;
+/**
+ * Create a token counter for a given model
+ */
+function createTokenCounter(model) {
+    return new TokenCounter(model);
+}
+/**
+ * Utility function to count tokens in text without creating a counter instance
+ */
+function countTokensQuick(text, model) {
+    const counter = createTokenCounter(model);
+    const count = counter.countTokens(text);
+    counter.free();
+    return count;
+}
+/**
+ * Get context window size for a model without creating a counter instance
+ */
+function getContextWindowSize(model) {
+    return MODEL_CONTEXT_WINDOWS[model] ?? DEFAULT_CONTEXT_WINDOW;
+}

package/dist/agent/src/agent/tokenCounter.test.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const tokenCounter_1 = require("./tokenCounter");
+const fs_1 = require("fs");
+const path_1 = require("path");
+(0, vitest_1.describe)("ModelDetector", () => {
+    (0, vitest_1.describe)("detectProvider", () => {
+        vitest_1.it.each([
+            ["gpt-4o", "openai"],
+            ["gpt-4", "openai"],
+            ["openai/gpt-4o", "openai"],
+            ["o1-preview", "openai"],
+            ["claude-3-7-sonnet-20250219", "anthropic"],
+            ["anthropic/claude-sonnet-4.5", "anthropic"],
+            ["gemini-2.0-flash-exp", "google"],
+            ["google/gemini-pro", "google"],
+            ["unknown-model", "unknown"],
+            ["", "unknown"],
+        ])("should detect %s as %s", (model, expected) => {
+            (0, vitest_1.expect)(tokenCounter_1.ModelDetector.detectProvider(model)).toBe(expected);
+        });
+    });
+    (0, vitest_1.describe)("normalizeModel", () => {
+        vitest_1.it.each([
+            ["openai/gpt-4o", "openai", "gpt-4o"],
+            ["anthropic/claude-3-opus", "anthropic", "claude-3-opus"],
+            ["google/gemini-pro", "google", "gemini-pro"],
+            ["gpt-4o-mini", "openai", "gpt-4o-mini"], // Preserves variants
+            ["o1-preview", "openai", "o1-preview"],
+        ])("should normalize %s to %s", (input, provider, expected) => {
+            (0, vitest_1.expect)(tokenCounter_1.ModelDetector.normalizeModel(input, provider)).toBe(expected);
+        });
+    });
+});
+(0, vitest_1.describe)("TokenCounter", () => {
+    let counter;
+    (0, vitest_1.afterEach)(() => {
+        if (counter) {
+            counter.free();
+        }
+    });
+    (0, vitest_1.describe)("Basic counting", () => {
+        (0, vitest_1.it)("should count tokens for OpenAI models", () => {
+            counter = new tokenCounter_1.TokenCounter("gpt-4o");
+            (0, vitest_1.expect)(counter.getProvider()).toBe("openai");
+            (0, vitest_1.expect)(counter.countTokens("Hello, world!")).toBeGreaterThan(0);
+            (0, vitest_1.expect)(counter.countTokens("")).toBe(0);
+        });
+        (0, vitest_1.it)("should count tokens for Anthropic models with +7 overhead", () => {
+            counter = new tokenCounter_1.TokenCounter("anthropic/claude-sonnet-4.5");
+            (0, vitest_1.expect)(counter.getProvider()).toBe("anthropic");
+            // With +7 overhead, "Hello, world!" should be ~11 tokens
+            (0, vitest_1.expect)(counter.countTokens("Hello, world!")).toBeLessThan(15);
+        });
+        (0, vitest_1.it)("should handle provider prefixes", () => {
+            counter = new tokenCounter_1.TokenCounter("openai/gpt-4o");
+            (0, vitest_1.expect)(counter.getProvider()).toBe("openai");
+            (0, vitest_1.expect)(counter.getModel()).toBe("openai/gpt-4o");
+        });
+        (0, vitest_1.it)("should fall back to approximation for unknown models", () => {
+            counter = new tokenCounter_1.TokenCounter("unknown-model");
+            (0, vitest_1.expect)(counter.getProvider()).toBe("unknown");
+            const text = "Hello, world!";
+            const expected = Math.ceil(text.length / 3.5);
+            (0, vitest_1.expect)(counter.countTokens(text)).toBe(expected);
+        });
+    });
+    (0, vitest_1.describe)("Message counting", () => {
+        (0, vitest_1.beforeEach)(() => {
+            counter = new tokenCounter_1.TokenCounter("gpt-4o");
+        });
+        (0, vitest_1.it)("should count simple message with overhead", () => {
+            if (!counter)
+                throw new Error("Counter not initialized");
+            const message = {
+                role: "user",
+                content: "Hello, how are you?",
+            };
+            (0, vitest_1.expect)(counter.countMessageTokens(message)).toBeGreaterThan(4);
+        });
+        (0, vitest_1.it)("should count message with tool calls", () => {
+            if (!counter)
+                throw new Error("Counter not initialized");
+            const message = {
+                role: "assistant",
+                content: "Let me help you.",
+                tool_calls: [
+                    {
+                        id: "call_123",
+                        type: "function",
+                        function: {
+                            name: "get_file",
+                            arguments: JSON.stringify({ name: "test.txt" }),
+                        },
+                    },
+                ],
+            };
+            (0, vitest_1.expect)(counter.countMessageTokens(message)).toBeGreaterThan(10);
+        });
+        (0, vitest_1.it)("should count multimodal message with images", () => {
+            if (!counter)
+                throw new Error("Counter not initialized");
+            const message = {
+                role: "user",
+                content: [
+                    { type: "text", text: "What's in this image?" },
+                    {
+                        type: "image_url",
+                        image_url: { url: "data:image/png;base64,..." },
+                    },
+                ],
+            };
+            // OpenAI images: ~170 tokens + text + overhead
+            (0, vitest_1.expect)(counter.countMessageTokens(message)).toBeGreaterThan(170);
+        });
+        (0, vitest_1.it)("should count conversation with overhead", () => {
+            if (!counter)
+                throw new Error("Counter not initialized");
+            const messages = [
+                { role: "system", content: "You are a helpful assistant." },
+                { role: "user", content: "Hello!" },
+                { role: "assistant", content: "Hi there! How can I help?" },
+            ];
+            (0, vitest_1.expect)(counter.countMessagesTokens(messages)).toBeGreaterThan(20);
+            (0, vitest_1.expect)(counter.countMessagesTokens([])).toBe(0);
+        });
+    });
+    (0, vitest_1.describe)("Factory functions", () => {
+        (0, vitest_1.it)("should create counter with factory", () => {
+            const testCounter = (0, tokenCounter_1.createTokenCounter)("gpt-4o");
+            (0, vitest_1.expect)(testCounter.getProvider()).toBe("openai");
+            testCounter.free();
+        });
+        (0, vitest_1.it)("should count tokens quickly", () => {
+            const count = (0, tokenCounter_1.countTokensQuick)("Hello, world!", "gpt-4o");
+            (0, vitest_1.expect)(count).toBeGreaterThan(0);
+        });
+    });
+    (0, vitest_1.describe)("Edge cases", () => {
+        (0, vitest_1.beforeEach)(() => {
+            counter = new tokenCounter_1.TokenCounter("gpt-4o");
+        });
+        (0, vitest_1.it)("should handle long text, special chars, and code", () => {
+            if (!counter)
+                throw new Error("Counter not initialized");
+            (0, vitest_1.expect)(counter.countTokens("Hello ".repeat(1000))).toBeGreaterThan(1000);
+            (0, vitest_1.expect)(counter.countTokens("Hello! 你好 🌍")).toBeGreaterThan(0);
+            (0, vitest_1.expect)(counter.countTokens('function hello() { return "world"; }')).toBeGreaterThan(5);
+        });
+    });
+});
+(0, vitest_1.describe)("Dev mode accurate counting", () => {
+    (0, vitest_1.it)("should throw error without dev mode", async () => {
+        const counter = new tokenCounter_1.TokenCounter("anthropic/claude-sonnet-4.5");
+        await (0, vitest_1.expect)(counter.countTokensAccurate("test")).rejects.toThrow("Accurate token counting requires enableDevMode");
+        counter.free();
+    });
+    (0, vitest_1.it)("should compare p50k_base approximation vs Anthropic API", async () => {
+        const counter = new tokenCounter_1.TokenCounter("claude-3-7-sonnet-20250219", {
+            enableDevMode: true,
+        });
+        // Test cases covering different scales
+        const readmePath = (0, path_1.join)(__dirname, "..", "..", "README.md");
+        const harryPotterPath = (0, path_1.join)(__dirname, "test_data", "harrypotter.txt");
+        const testCases = [
+            { text: "Hello, world!", label: "short" },
+            { text: "The quick brown fox jumps over the lazy dog.", label: "medium" },
+            { text: (0, fs_1.readFileSync)(readmePath, "utf-8"), label: "README.md" },
+            {
+                text: (0, fs_1.readFileSync)(harryPotterPath, "utf-8"),
+                label: "harrypotter.txt",
+            },
+        ];
+        if (process.env.ANTHROPIC_API_KEY) {
+            console.log("\n📊 Token Count Comparison (p50k_base+7 vs Anthropic API)\n");
+            for (const { text, label } of testCases) {
+                const accurate = await counter.countTokensAccurate(text);
+                const approximate = counter.countTokens(text);
+                const diff = accurate - approximate;
+                const accuracy = ((approximate / accurate) * 100).toFixed(1);
+                const size = text.length > 1000
+                    ? `${String(text.length)} chars`
+                    : `${String(text.length)} chars`;
+                console.log(`${label.padEnd(20)} [${size}]`);
+                console.log(`  Accurate:    ${accurate.toLocaleString().padStart(8)} tokens`);
+                console.log(`  Approximate: ${approximate.toLocaleString().padStart(8)} tokens`);
+                const diffStr = (diff > 0 ? "+" : "") + String(diff);
+                console.log(`  Difference:  ${diffStr.padStart(8)} (${accuracy}%)\n`);
+                (0, vitest_1.expect)(accurate).toBeGreaterThan(0);
+                (0, vitest_1.expect)(approximate).toBeGreaterThan(0);
+            }
+        }
+        else {
+            await (0, vitest_1.expect)(counter.countTokensAccurate("test")).rejects.toThrow();
+        }
+        counter.free();
+    });
+    (0, vitest_1.it)("should return regular count for non-Anthropic models", async () => {
+        const counter = new tokenCounter_1.TokenCounter("gpt-4o", { enableDevMode: true });
+        const regular = counter.countTokens("Hello, world!");
+        const accurate = await counter.countTokensAccurate("Hello, world!");
+        (0, vitest_1.expect)(accurate).toBe(regular);
+        counter.free();
+    });
+});

package/dist/agent/src/agent/toolSettings.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Centralized settings for agent tools.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPEN_URL_MAX_LENGTH = exports.MAX_TOOL_CALL_RESPONSE_LENGTH = void 0;
+const env = (key, defaultValue) => process.env[key] || defaultValue;
+/**
+ * Maximum length for tool call responses before truncation.
+ * Applied as a final sanity check on all tool call results.
+ */
+exports.MAX_TOOL_CALL_RESPONSE_LENGTH = parseInt(env("MAX_TOOL_CALL_RESPONSE_LENGTH", "50000"), 10);
+/**
+ * Maximum length for open_url content extraction.
+ * Controls how much text is extracted from HTML pages.
+ */
+exports.OPEN_URL_MAX_LENGTH = parseInt(env("OPEN_URL_MAX_LENGTH", "50000"), 10);

package/dist/agent/src/agent/tools/calculatorTool.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculatorTool = void 0;
+exports.calculatorEval = calculatorEval;
+const expr_eval_1 = require("expr-eval");
+const utils_1 = require("./utils");
+const ARITHMETIC_DESC = {
+    type: "function",
+    function: {
+        name: "arithmetic",
+        description: "Evaluate arithmetic expression",
+        parameters: {
+            type: "object",
+            properties: {
+                expr: {
+                    type: "string",
+                    description: "Expression containing +-*/()",
+                },
+            },
+            required: ["expr"],
+        },
+    },
+};
+function calculatorEval(args) {
+    try {
+        return String(expr_eval_1.Parser.evaluate(args));
+    }
+    catch (e) {
+        if (typeof e.message === "string") {
+            return e.message;
+        }
+        return String(e);
+    }
+}
+exports.calculatorTool = {
+    // eslint-disable-next-line @typescript-eslint/require-await
+    setup: async (agent) => {
+        const getExpr = (0, utils_1.makeParseArgsFn)(["expr"]);
+        const toolFn = async (_, args) => {
+            const { expr } = getExpr(args);
+            return Promise.resolve({ response: calculatorEval(expr) });
+        };
+        agent.addAgentTool(ARITHMETIC_DESC, toolFn);
+    },
+};