askui/dist/esm/core/models/anthropic/tools/base.js

Reliable, automated end-to-end-testing that depends on what is shown on your screen instead of the technology you are running on

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
/* eslint-disable */
import { AgentError } from './agent-errors';
export class ToolFailure {
    constructor(error) {
        this.error = error;
    }
}
export class ToolError extends Error {
    constructor(message) {
        super(message);
        this.name = 'ToolError';
    }
}
export class BaseAgentTool {
    get ToolName() {
        return this.constructor.name;
    }
}
export class ToolCollection {
    constructor(tools) {
        this.toolMap = new Map();
        tools.forEach((tool) => {
            const params = tool.toParams();
            this.toolMap.set(params.name, tool);
        });
    }
    toParams() {
        return Array.from(this.toolMap.values()).map((tool) => tool.toParams());
    }
    run(name, toolInput) {
        return __awaiter(this, void 0, void 0, function* () {
            const tool = this.toolMap.get(name);
            if (!tool) {
                return new ToolFailure(`Tool ${name} is invalid`);
            }
            try {
                return yield tool.execute(toolInput);
            }
            catch (err) {
                if (err instanceof AgentError) {
                    throw err;
                }
                if (err instanceof ToolError) {
                    return new ToolFailure(err.message);
                }
                return new ToolFailure(`Unknown error: ${err}`);
            }
        });
    }
}