@davia/agent 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Davia Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/agent/agent.d.ts

@@ -0,0 +1,13 @@
+import { todoListMiddleware } from "langchain";
+export declare const createDaviaAgent: (modelName: string) => Promise<import("langchain").ReactAgent<import("langchain").ResponseFormatUndefined, undefined, import("zod").ZodObject<{
+    projectId: import("zod").ZodString;
+    projectPath: import("zod").ZodString;
+    isUpdate: import("zod").ZodBoolean;
+    modelName: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, readonly [import("langchain").AgentMiddleware<undefined, import("zod").ZodObject<{
+    projectId: import("zod").ZodString;
+    projectPath: import("zod").ZodString;
+    isUpdate: import("zod").ZodBoolean;
+    modelName: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, any>, typeof todoListMiddleware, import("langchain").AgentMiddleware<undefined, undefined, any>]>>;
+//# sourceMappingURL=agent.d.ts.map

package/dist/agent/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/agent/agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAa3E,eAAO,MAAM,gBAAgB,GAAU,WAAW,MAAM;;;;;;;;;;oIAmCvD,CAAC"}

package/dist/agent/agent.js

@@ -0,0 +1,40 @@
+import { createAgent, initChatModel, todoListMiddleware } from "langchain";
+import { writeTool, searchReplaceTool, readFileTool, deleteTool, multiEditTool, } from "./tools.js";
+import { repositoryInitializationMiddleware } from "./middlewares/initialization.js";
+import { afterModelCachingMiddleware } from "./middlewares/after-model.js";
+import { contextSchema } from "./context.js";
+// Create and return the agent with the model and tools
+export const createDaviaAgent = async (modelName) => {
+    // Select the appropriate model based on the provider
+    let modelString;
+    switch (modelName) {
+        case "anthropic":
+            modelString = "claude-sonnet-4-5";
+            break;
+        case "openai":
+            modelString = "openai:gpt-5";
+            break;
+        case "google":
+            modelString = "google-genai:gemini-3-pro-preview";
+            break;
+        default:
+            throw new Error(`Unsupported model provider: ${modelName}`);
+    }
+    const model = await initChatModel(modelString);
+    return createAgent({
+        model,
+        tools: [
+            writeTool,
+            searchReplaceTool,
+            readFileTool,
+            deleteTool,
+            multiEditTool,
+        ],
+        middleware: [
+            repositoryInitializationMiddleware,
+            todoListMiddleware,
+            afterModelCachingMiddleware,
+        ],
+        contextSchema,
+    });
+};

package/dist/agent/context.d.ts

@@ -0,0 +1,9 @@
+import * as z from "zod";
+export declare const contextSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    projectPath: z.ZodString;
+    isUpdate: z.ZodBoolean;
+    modelName: z.ZodString;
+}, z.core.$strip>;
+export type ContextType = z.infer<typeof contextSchema>;
+//# sourceMappingURL=context.d.ts.map

package/dist/agent/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/agent/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB,eAAO,MAAM,aAAa;;;;;iBAKxB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/agent/context.js

@@ -0,0 +1,7 @@
+import * as z from "zod";
+export const contextSchema = z.object({
+    projectId: z.string(),
+    projectPath: z.string(),
+    isUpdate: z.boolean(),
+    modelName: z.string(),
+});

package/dist/agent/helpers/initialization.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Check if a file should be excluded from content analysis.
+ * @param filePath - Path to the file
+ * @returns True if the file should be excluded, False otherwise
+ */
+export declare function shouldExcludeFile(filePath: string): boolean;
+/**
+ * Calculate the maximum characters allowed per file based on token budget.
+ * Uses the rule of thumb: 4 characters = 1 token
+ * @param totalChars - Total characters in all non-excluded files
+ * @param numFiles - Number of non-excluded files
+ * @param maxTokens - Maximum tokens allowed for the entire repository
+ * @returns Maximum characters allowed per file, or -1 if no limit needed
+ */
+export declare function calculateMaxCharsPerFile(totalChars: number, numFiles: number, maxTokens: number): number;
+/**
+ * Trim file content from the middle while preserving beginning and end.
+ * @param content - Original file content
+ * @param maxChars - Maximum characters allowed for this file
+ * @param headRatio - Ratio of content to keep from the beginning (default: 0.6)
+ * @returns Trimmed content with clear markers showing what was removed
+ */
+export declare function trimFileContent(content: string, maxChars: number, headRatio?: number): string;
+/**
+ * Read all files from a repository recursively with intelligent trimming.
+ * @param sourcePath - Path to the source directory
+ * @returns Promise resolving to a dictionary of file paths to trimmed content
+ */
+export declare function readRepositoryContent(sourcePath: string): Promise<Record<string, string>>;
+//# sourceMappingURL=initialization.d.ts.map

package/dist/agent/helpers/initialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialization.d.ts","sourceRoot":"","sources":["../../../src/agent/helpers/initialization.ts"],"names":[],"mappings":"AASA;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAqC3D;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,MAAM,CAUR;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,GAAE,MAAY,GACtB,MAAM,CAwBR;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CA8KjC"}

package/dist/agent/helpers/initialization.js

@@ -0,0 +1,247 @@
+import fs from "fs-extra";
+import * as path from "path";
+import ignore from "ignore";
+import { EXCLUDED_FILE_EXTENSIONS, MAX_FILES, MAX_TOKENS, } from "../../config.js";
+/**
+ * Check if a file should be excluded from content analysis.
+ * @param filePath - Path to the file
+ * @returns True if the file should be excluded, False otherwise
+ */
+export function shouldExcludeFile(filePath) {
+    // Get file extension (case insensitive)
+    const filePathLower = filePath.toLowerCase();
+    // Check for exact extension matches
+    for (const ext of EXCLUDED_FILE_EXTENSIONS) {
+        if (filePathLower.endsWith(ext.toLowerCase())) {
+            return true;
+        }
+    }
+    // Check for files without extensions that might be binary
+    if (!filePathLower.includes(".")) {
+        // Common text files without extensions that should be included
+        const textFiles = new Set([
+            "makefile",
+            "dockerfile",
+            "readme",
+            "license",
+            "changelog",
+            "authors",
+            "contributors",
+            "install",
+            "configure",
+            "makefile.in",
+            "gemfile",
+            "rakefile",
+            "procfile",
+        ]);
+        const filename = filePathLower.split("/").pop() || "";
+        if (!textFiles.has(filename)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Calculate the maximum characters allowed per file based on token budget.
+ * Uses the rule of thumb: 4 characters = 1 token
+ * @param totalChars - Total characters in all non-excluded files
+ * @param numFiles - Number of non-excluded files
+ * @param maxTokens - Maximum tokens allowed for the entire repository
+ * @returns Maximum characters allowed per file, or -1 if no limit needed
+ */
+export function calculateMaxCharsPerFile(totalChars, numFiles, maxTokens) {
+    const maxCharsTotal = maxTokens * 4;
+    // If total is within budget, no trimming needed
+    if (totalChars <= maxCharsTotal) {
+        return -1;
+    }
+    // Calculate per-file limit
+    return Math.floor(maxCharsTotal / numFiles);
+}
+/**
+ * Trim file content from the middle while preserving beginning and end.
+ * @param content - Original file content
+ * @param maxChars - Maximum characters allowed for this file
+ * @param headRatio - Ratio of content to keep from the beginning (default: 0.6)
+ * @returns Trimmed content with clear markers showing what was removed
+ */
+export function trimFileContent(content, maxChars, headRatio = 0.6) {
+    // If content is within limit, return unchanged
+    if (content.length <= maxChars) {
+        return content;
+    }
+    // Calculate how much to keep from beginning and end
+    const headChars = Math.floor(maxChars * headRatio);
+    const tailChars = maxChars - headChars;
+    // Extract beginning and end portions
+    const headContent = content.slice(0, headChars);
+    const tailContent = content.slice(-tailChars);
+    // Calculate how many characters were trimmed
+    const trimmedChars = content.length - maxChars;
+    // Create trimmed content with clear marker
+    const trimmedContent = headContent +
+        `\n\n... [TRIMMED ${trimmedChars} chars from middle] ...\n\n` +
+        tailContent;
+    return trimmedContent;
+}
+/**
+ * Read all files from a repository recursively with intelligent trimming.
+ * @param sourcePath - Path to the source directory
+ * @returns Promise resolving to a dictionary of file paths to trimmed content
+ */
+export async function readRepositoryContent(sourcePath) {
+    const result = {};
+    // Initialize ignore instance
+    const ig = ignore();
+    // Try to read .gitignore file
+    const gitignorePath = path.join(sourcePath, ".gitignore");
+    try {
+        const gitignoreContent = await fs.readFile(gitignorePath, "utf-8");
+        ig.add(gitignoreContent);
+    }
+    catch {
+        // No .gitignore file or can't read it, continue without it
+    }
+    // Always ignore common directories from all languages and frameworks
+    ig.add([
+        // Version control
+        ".git",
+        ".svn",
+        ".hg",
+        // Node.js / JavaScript
+        "node_modules",
+        ".next",
+        ".turbo",
+        ".cache",
+        ".parcel-cache",
+        ".yarn",
+        ".pnp",
+        ".pnpm-store",
+        // Python
+        ".venv",
+        "venv",
+        "env",
+        "ENV",
+        "__pycache__",
+        ".pytest_cache",
+        ".mypy_cache",
+        ".tox",
+        ".coverage",
+        "htmlcov",
+        ".hypothesis",
+        // Ruby
+        ".bundle",
+        "vendor/bundle",
+        ".rbenv",
+        // Java / JVM
+        "target",
+        ".gradle",
+        ".mvn",
+        "build",
+        "out",
+        // Go
+        "vendor",
+        ".go",
+        // Rust
+        "Cargo.lock",
+        // PHP
+        "vendor",
+        ".composer",
+        // .NET
+        "bin",
+        "obj",
+        ".vs",
+        // Build outputs
+        "dist",
+        "build",
+        ".output",
+        // Framework-specific
+        ".nuxt",
+        ".vuepress/dist",
+        ".serverless",
+        // Infrastructure
+        ".terraform",
+        ".terraform.lock.hcl",
+        ".vagrant",
+        ".docker",
+        // Testing / Coverage
+        "coverage",
+        ".nyc_output",
+        ".jest",
+        // IDE / Editor
+        ".idea",
+        ".vscode",
+        "*.swp",
+        "*.swo",
+        ".sublime-project",
+        ".sublime-workspace",
+        // OS
+        ".DS_Store",
+        "Thumbs.db",
+        // Logs
+        "*.log",
+        "logs",
+    ]);
+    // Recursively read all files
+    const allFiles = [];
+    async function traverseDirectory(currentPath) {
+        if (allFiles.length >= MAX_FILES) {
+            return;
+        }
+        try {
+            const entries = await fs.readdir(currentPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (allFiles.length >= MAX_FILES) {
+                    break;
+                }
+                const fullPath = path.join(currentPath, entry.name);
+                const relativePath = path.relative(sourcePath, fullPath);
+                // Skip if ignored by gitignore
+                if (ig.ignores(relativePath)) {
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    await traverseDirectory(fullPath);
+                }
+                else if (entry.isFile()) {
+                    // Skip excluded file extensions
+                    if (!shouldExcludeFile(relativePath)) {
+                        allFiles.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip directories we can't read
+        }
+    }
+    await traverseDirectory(sourcePath);
+    // Read all file contents
+    const fileContents = [];
+    for (const filePath of allFiles) {
+        try {
+            const content = await fs.readFile(filePath, "utf-8");
+            const relativePath = path.relative(sourcePath, filePath);
+            fileContents.push({ path: relativePath, content });
+        }
+        catch {
+            // Skip files that can't be read
+        }
+    }
+    // Calculate total characters
+    const totalChars = fileContents.reduce((sum, file) => sum + file.content.length, 0);
+    // Calculate max chars per file
+    const maxCharsPerFile = calculateMaxCharsPerFile(totalChars, fileContents.length, MAX_TOKENS);
+    // Apply trimming and build result dictionary
+    for (const file of fileContents) {
+        if (maxCharsPerFile === -1) {
+            // No trimming needed
+            result[file.path] = file.content;
+        }
+        else {
+            // Apply trimming
+            result[file.path] = trimFileContent(file.content, maxCharsPerFile);
+        }
+    }
+    return result;
+}

package/dist/agent/helpers/messages-caching-handler.d.ts

@@ -0,0 +1,14 @@
+import { BaseMessage } from "langchain";
+/**
+ * Ensures only the last AI message has cache control (TTL).
+ * Removes cache control from all other AI messages.
+ * @param messages - List of messages to modify
+ */
+export declare function handleAIMessageCaching(messages: BaseMessage[]): void;
+/**
+ * Ensures only the last ToolMessage has cache control (TTL).
+ * Converts string content to list format and removes cache control from all other ToolMessages.
+ * @param messages - List of messages to modify
+ */
+export declare function handleToolMessageCaching(messages: BaseMessage[]): void;
+//# sourceMappingURL=messages-caching-handler.d.ts.map

package/dist/agent/helpers/messages-caching-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages-caching-handler.d.ts","sourceRoot":"","sources":["../../../src/agent/helpers/messages-caching-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,WAAW,EAAE,MAAM,WAAW,CAAC;AA4BhE;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,IAAI,CAwEpE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,IAAI,CAoFtE"}

package/dist/agent/helpers/messages-caching-handler.js

@@ -0,0 +1,162 @@
+import { AIMessage, ToolMessage } from "langchain";
+/**
+ * Deep clone a message to avoid mutating the original
+ * @param message - Message to clone
+ * @returns Cloned message
+ */
+function cloneMessage(message) {
+    // Use structuredClone if available, otherwise fall back to JSON
+    if (typeof structuredClone !== "undefined") {
+        return structuredClone(message);
+    }
+    return JSON.parse(JSON.stringify(message));
+}
+/**
+ * Ensures only the last AI message has cache control (TTL).
+ * Removes cache control from all other AI messages.
+ * @param messages - List of messages to modify
+ */
+export function handleAIMessageCaching(messages) {
+    // Find all AI message indices
+    const aiIndices = [];
+    for (let i = 0; i < messages.length; i++) {
+        if (messages[i] instanceof AIMessage) {
+            aiIndices.push(i);
+        }
+    }
+    if (aiIndices.length === 0) {
+        return;
+    }
+    // Remove cache control from all AI messages first
+    for (const idx of aiIndices) {
+        const aiMsg = messages[idx];
+        if (aiMsg && Array.isArray(aiMsg.content)) {
+            // Create a deep copy to avoid modifying the original
+            const aiMsgCopy = cloneMessage(aiMsg);
+            for (const block of aiMsgCopy.content) {
+                if (typeof block === "object" &&
+                    block !== null &&
+                    "cache_control" in block) {
+                    const blockWithCache = block;
+                    delete blockWithCache.cache_control;
+                }
+            }
+            messages[idx] = aiMsgCopy;
+        }
+    }
+    // Add cache control only to the last AI message
+    const lastAiIdx = aiIndices[aiIndices.length - 1];
+    if (lastAiIdx === undefined) {
+        return;
+    }
+    const lastAiMsg = messages[lastAiIdx];
+    if (!lastAiMsg) {
+        return;
+    }
+    if (Array.isArray(lastAiMsg.content) && lastAiMsg.content.length > 0) {
+        // Ensure we have a copy to modify
+        const lastAiMsgCopy = cloneMessage(lastAiMsg);
+        const contentArray = [...lastAiMsgCopy.content];
+        const lastBlock = contentArray[contentArray.length - 1];
+        // Add cache control to the last content block
+        if (typeof lastBlock === "object" && lastBlock !== null) {
+            const blockWithCache = { ...lastBlock };
+            blockWithCache.cache_control = {
+                type: "ephemeral",
+                ttl: "5m",
+            };
+            contentArray[contentArray.length - 1] =
+                blockWithCache;
+        }
+        else {
+            // If last block is not a dict, wrap it
+            contentArray[contentArray.length - 1] = {
+                type: "text",
+                text: lastBlock,
+                cache_control: { type: "ephemeral", ttl: "5m" },
+            };
+        }
+        lastAiMsgCopy.content = contentArray;
+        messages[lastAiIdx] = lastAiMsgCopy;
+    }
+}
+/**
+ * Ensures only the last ToolMessage has cache control (TTL).
+ * Converts string content to list format and removes cache control from all other ToolMessages.
+ * @param messages - List of messages to modify
+ */
+export function handleToolMessageCaching(messages) {
+    // Find all ToolMessage indices
+    const toolIndices = [];
+    for (let i = 0; i < messages.length; i++) {
+        if (messages[i] instanceof ToolMessage) {
+            toolIndices.push(i);
+        }
+    }
+    if (toolIndices.length === 0) {
+        return;
+    }
+    // Remove cache control from all ToolMessages first
+    for (const idx of toolIndices) {
+        const toolMsg = messages[idx];
+        if (toolMsg && Array.isArray(toolMsg.content)) {
+            // Create a copy to avoid modifying the original
+            const toolMsgCopy = cloneMessage(toolMsg);
+            for (const block of toolMsgCopy.content) {
+                if (typeof block === "object" &&
+                    block !== null &&
+                    "cache_control" in block) {
+                    const blockWithCache = block;
+                    delete blockWithCache.cache_control;
+                }
+            }
+            messages[idx] = toolMsgCopy;
+        }
+    }
+    // Add cache control only to the last ToolMessage
+    const lastToolIdx = toolIndices[toolIndices.length - 1];
+    if (lastToolIdx === undefined) {
+        return;
+    }
+    const lastToolMsg = messages[lastToolIdx];
+    if (!lastToolMsg) {
+        return;
+    }
+    // Convert string content to list format with cache control
+    if (typeof lastToolMsg.content === "string") {
+        const lastToolMsgCopy = cloneMessage(lastToolMsg);
+        lastToolMsgCopy.content = [
+            {
+                type: "text",
+                text: lastToolMsg.content,
+                cache_control: { type: "ephemeral", ttl: "5m" },
+            },
+        ];
+        messages[lastToolIdx] = lastToolMsgCopy;
+    }
+    else if (Array.isArray(lastToolMsg.content) &&
+        lastToolMsg.content.length > 0) {
+        // If already a list, add cache control to the first element
+        const lastToolMsgCopy = cloneMessage(lastToolMsg);
+        const contentArray = [...lastToolMsgCopy.content];
+        const firstBlock = contentArray[0];
+        if (typeof firstBlock === "object" && firstBlock !== null) {
+            const blockWithCache = { ...firstBlock };
+            blockWithCache.cache_control = {
+                type: "ephemeral",
+                ttl: "5m",
+            };
+            contentArray[0] = blockWithCache;
+        }
+        else {
+            // Wrap non-dict content
+            contentArray[0] = {
+                type: "text",
+                text: firstBlock,
+                cache_control: { type: "ephemeral", ttl: "5m" },
+            };
+        }
+        lastToolMsgCopy.content = contentArray;
+        messages[lastToolIdx] = lastToolMsgCopy;
+    }
+}

package/dist/agent/helpers/tools.d.ts

@@ -0,0 +1,46 @@
+import { ContextType } from "../context.js";
+/**
+ * Create a clickable terminal hyperlink using OSC 8 escape sequence
+ */
+export declare function createTerminalLink(url: string, text: string): string;
+/**
+ * Generate a log message for file creation based on file type
+ */
+export declare function getFileCreationMessage(filePath: string, context: ContextType): string;
+/**
+ * Get the base destination path based on isUpdate flag
+ */
+export declare function getBaseDestinationPath(projectPath: string, isUpdate: boolean): string;
+/**
+ * Get the assets path (for reading existing files)
+ */
+export declare function getAssetsPath(projectPath: string): string;
+/**
+ * Helper function to resolve file path using runtime context
+ * @param filePath - Relative file path
+ * @param context - Runtime context with projectPath and isUpdate
+ * @returns Absolute file path
+ * @throws Error if path validation fails
+ */
+export declare function resolveFilePath(filePath: string, context: ContextType): string;
+/**
+ * Parse Mermaid diagram to Excalidraw using Puppeteer headless browser
+ * This is the same approach used by mermaid-cli for reliable rendering
+ * @param mermaidContent - Mermaid diagram definition
+ * @returns Excalidraw elements and files
+ */
+export declare function parseMermaidWithPuppeteer(mermaidContent: string): Promise<any>;
+/**
+ * Helper function to perform robust search and replace with validation
+ * @param content - Original file content
+ * @param oldString - String to search for
+ * @param newString - String to replace with
+ * @param replaceAll - Whether to replace all occurrences
+ * @returns Object with new content, success status, and error message
+ */
+export declare function robustSearchReplace(content: string, oldString: string, newString: string, replaceAll?: boolean): {
+    newContent: string;
+    success: boolean;
+    errorMessage?: string;
+};
+//# sourceMappingURL=tools.d.ts.map

package/dist/agent/helpers/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/agent/helpers/tools.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAGpE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,WAAW,GACnB,MAAM,CAmCR;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,OAAO,GAChB,MAAM,CAKR;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,WAAW,GACnB,MAAM,CA2BR;AAED;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAAC,cAAc,EAAE,MAAM,gBAmCrE;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,UAAU,GAAE,OAAe,GAC1B;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,CAwCjE"}