mono/packages/kbot/dist-in/iterator.js

import { defaultError, defaultFilters, testFilters, transformObjectWithOptions, DEFAULT_NETWORK_OPTIONS } from './async-iterator.js';
import { run } from './commands/run.js';
import { get_cached_object, set_cached_object } from "@polymech/cache";
const dummyLogger = {
    info: () => { },
    warn: () => { },
    error: () => { }
};
export const removeEmptyObjects = (obj) => {
    if (obj === null || obj === undefined)
        return obj;
    for (const key in obj) {
        const val = obj[key];
        if (val === null || val === undefined)
            continue;
        if (typeof val === 'object' ||
            (key == 'value' && typeof val === 'number' && val === 0 || key == 'base64')) {
            obj[key] = removeEmptyObjects(obj[key]);
            if (Object.keys(obj[key]).length === 0) {
                delete obj[key];
            }
        }
    }
    return obj;
};
const DEFAULT_CACHE_CONFIG = {
    enabled: true,
    namespace: 'llm-responses',
    expiration: 7 * 24 * 60 * 60 // 7 days in seconds
};
export function createLLMTransformer(options, logger = dummyLogger, cacheConfig) {
    const config = { ...DEFAULT_CACHE_CONFIG, ...cacheConfig };
    return async (input, jsonPath) => {
        logger.info(`Transforming field at path: ${jsonPath}`);
        logger.info(`Input: ${input}`);
        logger.info(`Using prompt: ${options.prompt}`);
        const kbotTask = {
            ...options,
            prompt: `${options.prompt}\n\nText to transform: "${input}"`,
        };
        const cacheKeyObj = removeEmptyObjects({
            prompt: kbotTask.prompt,
            model: kbotTask.model,
            router: kbotTask.router,
            mode: kbotTask.mode,
            filters: [],
            tools: []
        });
        try {
            if (config.enabled) {
                const cachedResponse = await get_cached_object({ ca_options: cacheKeyObj }, config.namespace);
                if (cachedResponse?.content) {
                    logger.info(`Using cached LLM response for prompt: ${kbotTask.prompt.substring(0, 100)}...`);
                    return cachedResponse.content;
                }
            }
            const results = await run(kbotTask);
            if (results && results.length > 0 && typeof results[0] === 'string') {
                const result = results[0].trim();
                if (config.enabled) {
                    await set_cached_object({ ca_options: cacheKeyObj }, config.namespace, { content: result }, { expiration: config.expiration });
                    logger.info(`Cached LLM response for prompt: ${kbotTask.prompt.substring(0, 100)}...`);
                }
                logger.info(`Result: ${result}`);
                return result;
            }
            logger.warn(`No valid result received for ${jsonPath}, returning original`);
            return input;
        }
        catch (error) {
            logger.error(`Error calling LLM API: ${error.message}`, error);
            return input;
        }
    };
}
export function createIterator(obj, optionsMixin, globalOptions = {}) {
    const { network = {}, errorCallback = defaultError, filterCallback = testFilters(defaultFilters()), transformerFactory, logger = dummyLogger, cacheConfig, onTransform, onTransformed } = globalOptions;
    const networkOptions = {
        ...DEFAULT_NETWORK_OPTIONS,
        ...network
    };
    const config = { ...DEFAULT_CACHE_CONFIG, ...cacheConfig };
    const defaultTransformerFactory = (options) => {
        return async (input) => input;
    };
    const createTransformer = transformerFactory || defaultTransformerFactory;
    const createObjectCacheKey = (data, mappings) => {
        return removeEmptyObjects({
            data: JSON.stringify(data),
            mappings: mappings.map(m => ({
                jsonPath: m.jsonPath,
                targetPath: m.targetPath,
                options: {
                    model: optionsMixin.model,
                    router: optionsMixin.router,
                    mode: optionsMixin.mode,
                    prompt: m.options?.prompt
                }
            }))
        });
    };
    const deepMerge = (target, source) => {
        for (const key in source) {
            if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
                if (!target[key])
                    target[key] = {};
                deepMerge(target[key], source[key]);
            }
            else {
                target[key] = source[key];
            }
        }
    };
    return {
        createTransformer,
        transform: async (mappings) => {
            if (config.enabled) {
                const objectCacheKey = createObjectCacheKey(obj, mappings);
                const cachedObject = await get_cached_object({ ca_options: objectCacheKey }, 'transformed-objects');
                if (cachedObject?.content) {
                    logger.info('Using cached transformed object');
                    deepMerge(obj, cachedObject.content);
                    return;
                }
            }
            // If no cache hit or caching disabled, perform the transformations
            const transformedObj = JSON.parse(JSON.stringify(obj));
            for (const mapping of mappings) {
                const mergedOptions = { ...optionsMixin, ...mapping.options };
                const { jsonPath, targetPath = null } = mapping;
                const transformer = createTransformer(mergedOptions);
                await transformObjectWithOptions(transformedObj, transformer, {
                    jsonPath,
                    targetPath,
                    network: networkOptions,
                    errorCallback,
                    filterCallback,
                    onTransform,
                    onTransformed,
                    kbotOptions: mergedOptions
                });
            }
            // Cache the transformed object
            if (config.enabled) {
                const objectCacheKey = createObjectCacheKey(obj, mappings);
                await set_cached_object({ ca_options: objectCacheKey }, 'transformed-objects', { content: transformedObj }, { expiration: config.expiration });
                logger.info('Cached transformed object');
            }
            // Apply the transformations to the original object
            deepMerge(obj, transformedObj);
        }
    };
}
export async function transformWithMappings(obj, createTransformer, mappings, globalOptions = {}) {
    const iterator = createIterator(obj, {}, globalOptions);
    await iterator.transform(mappings);
}
/**
 * Simplified transformation function that only requires the target object and field mappings.
 * All other options are optional with sensible defaults.
 *
 * @param obj - The object to transform
 * @param mappings - Field mappings defining what to transform and how
 * @param optionsMixin - Optional global options to apply to all transformations
 * @param options - Optional advanced configuration
 * @returns The transformed object (also modifies the original)
 */
export async function transform(obj, mappings, optionsMixin = {}, options = {}) {
    const iterator = createIterator(obj, optionsMixin, options);
    await iterator.transform(mappings);
    return obj;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iterator.js","sourceRoot":"","sources":["../src/iterator.ts"],"names":[],"mappings":"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"}