@utcp/sdk/dist/src/client/tool-repositories/in-mem-tool-repository.js

Universal Tool Calling Protocol (UTCP) client library for TypeScript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.InMemToolRepository = void 0;
/**
 * An in-memory implementation of the ToolRepository.
 * This repository stores tools and providers in memory and does not persist them.
 */
class InMemToolRepository {
    constructor() {
        this.tools = [];
        this.toolPerProvider = new Map();
    }
    async saveProviderWithTools(provider, tools) {
        this.tools.push(...tools);
        this.toolPerProvider.set(provider.name, { provider, tools });
        return Promise.resolve();
    }
    async removeProvider(providerName) {
        const providerData = this.toolPerProvider.get(providerName);
        if (!providerData) {
            throw new Error(`Provider '${providerName}' not found`);
        }
        const toolsToRemove = new Set(providerData.tools);
        this.tools = this.tools.filter(tool => !toolsToRemove.has(tool));
        this.toolPerProvider.delete(providerName);
        return Promise.resolve();
    }
    async removeTool(toolName) {
        const providerName = toolName.split('.')[0];
        const providerData = this.toolPerProvider.get(providerName);
        if (!providerData) {
            throw new Error(`Provider '${providerName}' not found`);
        }
        const initialToolCount = this.tools.length;
        this.tools = this.tools.filter(tool => tool.name !== toolName);
        if (this.tools.length === initialToolCount) {
            throw new Error(`Tool '${toolName}' not found`);
        }
        providerData.tools = providerData.tools.filter(tool => tool.name !== toolName);
        this.toolPerProvider.set(providerName, providerData);
        return Promise.resolve();
    }
    async getTool(toolName) {
        return Promise.resolve(this.tools.find(tool => tool.name === toolName));
    }
    async getTools() {
        return Promise.resolve(this.tools);
    }
    async getToolsByProvider(providerName) {
        const providerData = this.toolPerProvider.get(providerName);
        return Promise.resolve(providerData?.tools);
    }
    async getProvider(providerName) {
        const providerData = this.toolPerProvider.get(providerName);
        return Promise.resolve(providerData?.provider);
    }
    async getProviders() {
        const providers = Array.from(this.toolPerProvider.values()).map(data => data.provider);
        return Promise.resolve(providers);
    }
}
exports.InMemToolRepository = InMemToolRepository;
//# sourceMappingURL=in-mem-tool-repository.js.map