@mondaydotcomorg/atp-client/dist/core/service-providers.js

Client SDK for Agent Tool Protocol

import { CallbackType, ToolOperation } from '@mondaydotcomorg/atp-protocol';
const LLMOperation = {
    CALL: 'call',
    EXTRACT: 'extract',
    CLASSIFY: 'classify',
};
const EmbeddingOperation = {
    EMBED: 'embed',
    SEARCH: 'search',
};
export class ServiceProviders {
    providers = {};
    toolHandlers = new Map();
    constructor(providers) {
        this.providers = providers || {};
        if (providers?.tools) {
            for (const tool of providers.tools) {
                this.toolHandlers.set(tool.name, tool.handler);
            }
        }
    }
    provideLLM(handler) {
        this.providers.llm = handler;
    }
    provideApproval(handler) {
        this.providers.approval = handler;
    }
    provideEmbedding(handler) {
        this.providers.embedding = handler;
    }
    provideTools(tools) {
        this.providers.tools = tools;
        for (const tool of tools) {
            this.toolHandlers.set(tool.name, tool.handler);
        }
    }
    getLLM() {
        return this.providers.llm;
    }
    getApproval() {
        return this.providers.approval;
    }
    getEmbedding() {
        return this.providers.embedding;
    }
    getTools() {
        return this.providers.tools;
    }
    /**
     * Get tool definitions (without handlers) for sending to server
     */
    getToolDefinitions() {
        if (!this.providers.tools) {
            return [];
        }
        return this.providers.tools.map((tool) => {
            const { handler, ...definition } = tool;
            return definition;
        });
    }
    /**
     * Check if client has tools
     */
    hasTools() {
        return !!(this.providers.tools && this.providers.tools.length > 0);
    }
    /**
     * Check if client has any services or tools
     */
    hasAnyServices() {
        return !!(this.providers.llm ||
            this.providers.approval ||
            this.providers.embedding ||
            this.hasTools());
    }
    /**
     * Check if client has a service for a specific callback type
     */
    hasServiceForCallback(callbackType) {
        switch (callbackType) {
            case CallbackType.LLM:
                return !!this.providers.llm;
            case CallbackType.APPROVAL:
                return !!this.providers.approval;
            case CallbackType.EMBEDDING:
                return !!this.providers.embedding;
            case CallbackType.TOOL:
                return this.hasTools();
            default:
                return false;
        }
    }
    async handleCallback(callbackType, payload) {
        if (payload.operation === 'batch_parallel' && payload.calls) {
            return await Promise.all(payload.calls.map(async (call) => {
                return await this.handleCallback(call.type, {
                    ...call.payload,
                    operation: call.operation,
                });
            }));
        }
        switch (callbackType) {
            case CallbackType.LLM:
                if (!this.providers.llm) {
                    throw new Error('LLM service not provided by client');
                }
                if (payload.operation === LLMOperation.CALL) {
                    return await this.providers.llm.call(payload.prompt, payload.options);
                }
                else if (payload.operation === LLMOperation.EXTRACT && this.providers.llm.extract) {
                    return await this.providers.llm.extract(payload.prompt, payload.schema, payload.options);
                }
                else if (payload.operation === LLMOperation.CLASSIFY && this.providers.llm.classify) {
                    return await this.providers.llm.classify(payload.text, payload.categories, payload.options);
                }
                throw new Error(`Unsupported LLM operation: ${payload.operation}`);
            case CallbackType.APPROVAL:
                if (!this.providers.approval) {
                    throw new Error('Approval service not provided by client');
                }
                const contextWithExecutionId = payload.context
                    ? { ...payload.context, executionId: payload.executionId }
                    : { executionId: payload.executionId };
                return await this.providers.approval.request(payload.message, contextWithExecutionId);
            case CallbackType.EMBEDDING:
                if (!this.providers.embedding) {
                    throw new Error('Embedding service not provided by client');
                }
                if (payload.operation === EmbeddingOperation.EMBED) {
                    return await this.providers.embedding.embed(payload.text);
                }
                else if (payload.operation === EmbeddingOperation.SEARCH) {
                    const queryEmbedding = await this.providers.embedding.embed(payload.query);
                    return queryEmbedding;
                }
                else if (payload.operation === 'similarity' && this.providers.embedding.similarity) {
                    return await this.providers.embedding.similarity(payload.text1, payload.text2);
                }
                throw new Error(`Unsupported embedding operation: ${payload.operation}`);
            case CallbackType.TOOL:
                if (payload.operation === ToolOperation.CALL) {
                    const toolName = payload.toolName;
                    const handler = this.toolHandlers.get(toolName);
                    if (!handler) {
                        throw new Error(`Tool '${toolName}' not found in client tools`);
                    }
                    const result = await handler(payload.input);
                    return result;
                }
                throw new Error(`Unsupported tool operation: ${payload.operation}`);
            default:
                throw new Error(`Unknown callback type: ${callbackType}`);
        }
    }
}
//# sourceMappingURL=service-providers.js.map