From b2ef96e786294a6e7aa7b756ce9ee60bd32984e5 Mon Sep 17 00:00:00 2001 From: babayaga Date: Mon, 7 Apr 2025 16:01:06 +0200 Subject: [PATCH] kbot iterator callbacks --- packages/kbot/dist-in/async-iterator.d.ts | 17 +- packages/kbot/dist-in/async-iterator.js | 65 ++++++- .../examples/core/iterator-factory-example.js | 86 +++++++-- packages/kbot/dist-in/iterator.d.ts | 4 +- packages/kbot/dist-in/iterator.js | 9 +- packages/kbot/docs_/iterator.md | 174 +++++++++++++++++- packages/kbot/logs/params.json | 2 +- packages/kbot/src/async-iterator.ts | 76 ++++++-- .../examples/core/iterator-factory-example.ts | 105 ++++++++--- packages/kbot/src/iterator.ts | 13 +- .../test-data/core/iterator-factory-data.json | 8 +- 11 files changed, 483 insertions(+), 76 deletions(-) diff --git a/packages/kbot/dist-in/async-iterator.d.ts b/packages/kbot/dist-in/async-iterator.d.ts index 68c2b4c4..4e1c1b17 100644 --- a/packages/kbot/dist-in/async-iterator.d.ts +++ b/packages/kbot/dist-in/async-iterator.d.ts @@ -1,7 +1,10 @@ +import { IKBotTask } from '@polymech/ai-tools'; export type AsyncTransformer = (input: string, path: string) => Promise; export type ErrorCallback = (path: string, value: string, error: unknown) => void; export type FilterCallback = (input: string, path: string) => Promise; export type Filter = (input: string) => Promise; +export type OnTransformCallback = (jsonPath: string, value: string, options?: Partial) => Promise; +export type OnTransformedCallback = (jsonPath: string, transformedValue: string, options?: Partial) => Promise; export interface INetworkOptions { throttleDelay?: number; concurrentTasks?: number; @@ -21,14 +24,21 @@ export interface GlobalOptions { network?: INetworkOptions; errorCallback?: ErrorCallback; filterCallback?: FilterCallback; + onTransform?: OnTransformCallback; + onTransformed?: OnTransformedCallback; } export declare const isNumber: Filter; export declare const isBoolean: Filter; export declare const isValidString: Filter; export declare const testFilters: (filters: Filter[]) => FilterCallback; export declare const defaultFilters: (filters?: Filter[]) => Filter[]; -export declare function transformObject(obj: Record, transform: AsyncTransformer, path: string, networkOptions: Required, errorCallback: ErrorCallback, testCallback: FilterCallback): Promise; -export declare function transformPath(obj: Record, keys: string[], transform: AsyncTransformer, networkOptions: Required, currentPath: string, errorCallback: ErrorCallback, testCallback: FilterCallback): Promise; +export declare function transformObject(obj: Record, transform: AsyncTransformer, path: string, networkOptions: Required, errorCallback: ErrorCallback, testCallback: FilterCallback, onTransform: OnTransformCallback, // Pass callbacks down +onTransformed: OnTransformedCallback, // Pass callbacks down +options?: Partial): Promise; +export declare function transformPath(obj: Record, keys: string[], transform: AsyncTransformer, networkOptions: Required, currentPath: string, // Changed from jsonPointer to represent the logical path +errorCallback: ErrorCallback, testCallback: FilterCallback, onTransform: OnTransformCallback, // Receive callbacks +onTransformed: OnTransformedCallback, // Receive callbacks +options?: Partial): Promise; export declare const defaultError: ErrorCallback; export interface TransformWithOptionsInput { jsonPath: string; @@ -36,6 +46,9 @@ export interface TransformWithOptionsInput { network?: INetworkOptions; errorCallback?: ErrorCallback; filterCallback?: FilterCallback; + onTransform?: OnTransformCallback; + onTransformed?: OnTransformedCallback; + kbotOptions?: Partial; } export declare function transformObjectWithOptions(obj: Record, transform: AsyncTransformer, options: TransformWithOptionsInput): Promise; export declare const defaultOptions: (options?: Partial) => TransformOptions; diff --git a/packages/kbot/dist-in/async-iterator.js b/packages/kbot/dist-in/async-iterator.js index ac2375fe..ac327c5b 100644 --- a/packages/kbot/dist-in/async-iterator.js +++ b/packages/kbot/dist-in/async-iterator.js @@ -26,14 +26,24 @@ export const testFilters = (filters) => { export const defaultFilters = (filters = []) => [ isNumber, isBoolean, isValidString, ...filters ]; -export async function transformObject(obj, transform, path, networkOptions, errorCallback, testCallback) { +export async function transformObject(obj, transform, path, networkOptions, errorCallback, testCallback, onTransform, // Pass callbacks down +onTransformed, // Pass callbacks down +options // Pass options context if available +) { const paths = JSONPath({ path, json: obj, resultType: 'pointer' }); await pMap(paths, async (jsonPointer) => { const keys = jsonPointer.slice(1).split('/'); - await transformPath(obj, keys, transform, networkOptions, jsonPointer, errorCallback, testCallback); + await transformPath(obj, keys, transform, networkOptions, jsonPointer, errorCallback, testCallback, onTransform, // Pass callbacks down + onTransformed, // Pass callbacks down + options // Pass options context if available + ); }, { concurrency: networkOptions.concurrentTasks }); } -export async function transformPath(obj, keys, transform, networkOptions, currentPath, errorCallback, testCallback) { +export async function transformPath(obj, keys, transform, networkOptions, currentPath, // Changed from jsonPointer to represent the logical path +errorCallback, testCallback, onTransform, // Receive callbacks +onTransformed, // Receive callbacks +options // Pass options context if available +) { let current = obj; for (let i = 0; i < keys.length - 1; i++) { if (current[keys[i]] === undefined || current[keys[i]] === null) { @@ -53,9 +63,28 @@ export async function transformPath(obj, keys, transform, networkOptions, curren let attempts = 0; let success = false; let lastError; + let valueToTransform = current[lastKey]; + const fullJsonPath = `${currentPath}/${lastKey}`; // Construct full path + // Call onTransform before transformation + try { + valueToTransform = await onTransform(fullJsonPath, valueToTransform, options); + } + catch (error) { + console.error(`Error in onTransform callback for path ${fullJsonPath}:`, error); + // Decide if you want to proceed with the original value or stop + } while (attempts < networkOptions.maxRetries && !success) { try { - current[lastKey] = await throttle(transform)(current[lastKey], `${currentPath}/${lastKey}`); + let transformedValue = await throttle(transform)(valueToTransform, fullJsonPath); + // Call onTransformed after successful transformation + try { + transformedValue = await onTransformed(fullJsonPath, transformedValue, options); + } + catch (error) { + console.error(`Error in onTransformed callback for path ${fullJsonPath}:`, error); + // Decide if you want to proceed with the transformed value or stop/modify + } + current[lastKey] = transformedValue; // Assign potentially modified transformed value success = true; } catch (error) { @@ -69,32 +98,48 @@ export async function transformPath(obj, keys, transform, networkOptions, curren } } if (!success) { - errorCallback(currentPath, lastKey, lastError); + errorCallback(currentPath, lastKey, lastError); // Use currentPath (logical path) } } } else if (typeof current[lastKey] === 'object' && current[lastKey] !== null) { - await transformObject(current[lastKey], transform, '$.*', networkOptions, errorCallback, testCallback); + await transformObject(current[lastKey], transform, '$.*', // Recurse on all properties + networkOptions, errorCallback, testCallback, onTransform, // Pass callbacks down + onTransformed, // Pass callbacks down + options // Pass options context down + ); } } } export const defaultError = (path, value, error) => { console.error(`Error at path: ${path}, value: ${value}, error: ${error}`); }; +// Default no-op implementations for the new callbacks +const defaultOnTransform = async (_, value) => value; +const defaultOnTransformed = async (_, transformedValue) => transformedValue; export async function transformObjectWithOptions(obj, transform, options) { - const { jsonPath, targetPath = null, network = {}, errorCallback = defaultError, filterCallback = testFilters(defaultFilters()) } = options; + const { jsonPath, targetPath = null, network = {}, errorCallback = defaultError, filterCallback = testFilters(defaultFilters()), onTransform = defaultOnTransform, // Use default if not provided + onTransformed = defaultOnTransformed, // Use default if not provided + kbotOptions // Destructure kbot options + } = options; const networkOptions = { ...DEFAULT_NETWORK_OPTIONS, ...network }; // If targetPath is null, directly transform the object at jsonPath if (!targetPath) { - return transformObject(obj, transform, jsonPath, networkOptions, errorCallback, filterCallback); + return transformObject(obj, transform, jsonPath, networkOptions, errorCallback, filterCallback, onTransform, // Pass down + onTransformed, // Pass down + kbotOptions // Pass down kbot options + ); } // For targetPath case, create a deep clone and transform it const dataCopy = deepClone(obj); // Transform the copy - await transformObject(dataCopy, transform, jsonPath, networkOptions, errorCallback, filterCallback); + await transformObject(dataCopy, transform, jsonPath, networkOptions, errorCallback, filterCallback, onTransform, // Pass down + onTransformed, // Pass down + kbotOptions // Pass down kbot options + ); // Get paths from original object const paths = JSONPath({ path: jsonPath, json: obj, resultType: 'pointer' }); // Apply transformed values to original object with targetPath @@ -137,4 +182,4 @@ export const defaultOptions = (options = {}) => { targetPath: options.targetPath }; }; -//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"async-iterator.js","sourceRoot":"","sources":["../src/async-iterator.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/kbot/dist-in/examples/core/iterator-factory-example.js b/packages/kbot/dist-in/examples/core/iterator-factory-example.js index 94302499..47fd72cc 100644 --- a/packages/kbot/dist-in/examples/core/iterator-factory-example.js +++ b/packages/kbot/dist-in/examples/core/iterator-factory-example.js @@ -3,7 +3,8 @@ import * as path from 'path'; import * as fs from 'fs'; import { E_OPENROUTER_MODEL } from '../../models/cache/openrouter-models.js'; import { E_Mode } from '../../zod_schema.js'; -import { createIterator, createLLMTransformer, transform } from '../../iterator.js'; +import { createIterator, createLLMTransformer, transform, removeEmptyObjects } from '../../iterator.js'; +import { rm_cached_object } from '@polymech/cache'; /** * Notes for LLM modifications * @@ -26,6 +27,9 @@ export async function simpleTransformExample() { model: MODEL, router: ROUTER, mode: E_Mode.COMPLETION + }, { + onTransform: simpleOnTransform, + onTransformed: simpleOnTransformed }); console.log("\nSimplified Transform Result:"); console.log(JSON.stringify(data.products.fruits[0], null, 2)); @@ -196,6 +200,33 @@ Do not add any extra fields not in the schema, and make sure to use the exact fi } } ]; +// Example onTransform callback +const exampleOnTransform = async (jsonPath, value, options) => { + console.log(` -> onTransform: Path='${jsonPath}', Original Value='${value.substring(0, 30)}...', Options Model='${options?.model}'`); + // Example: Prefix value before sending to LLM + if (jsonPath.includes('description')) { + return `[PRODUCT INFO] ${value}`; + } + return value; // Return original value if no modification needed +}; +// Example onTransformed callback +const exampleOnTransformed = async (jsonPath, transformedValue, options) => { + console.log(` <- onTransformed: Path='${jsonPath}', Transformed Value='${transformedValue.substring(0, 30)}...', Options Model='${options?.model}'`); + // Example: Post-process the LLM response + if (jsonPath.includes('nutrition')) { + return `${transformedValue} [HEALTH FOCUS]`; + } + return transformedValue; // Return transformed value if no modification needed +}; +// Simpler callbacks for the second example +const simpleOnTransform = async (jsonPath, value) => { + console.log(` -> simpleOnTransform: Path='${jsonPath}'`); + return value; +}; +const simpleOnTransformed = async (jsonPath, transformedValue) => { + console.log(` <- simpleOnTransformed: Path='${jsonPath}'`); + return transformedValue; +}; // Error handler const errorCallback = (path, value, error) => { logger.error(`Error transforming ${path}: ${error.message}`); @@ -226,8 +257,33 @@ export async function factoryExample() { logLevel: LOG_LEVEL, mode: E_Mode.COMPLETION }; - // Create an iterator factory instance - const iterator = createIterator(data, globalOptionsMixin, { + // --- Cache Clearing Logic --- + // Calculate the expected cache key for the object transformation + const objectCacheKey = removeEmptyObjects({ + data: JSON.stringify(exampleData), // Use the initial data state + mappings: fieldMappings.map(m => ({ + jsonPath: m.jsonPath, + targetPath: m.targetPath, + options: { + model: globalOptionsMixin.model, + router: globalOptionsMixin.router, + mode: globalOptionsMixin.mode, + prompt: m.options?.prompt + } + })) + }); + const objectCacheNamespace = 'transformed-objects'; + console.log(`Attempting to clear cache for key in namespace '${objectCacheNamespace}' before first run...`); + try { + await rm_cached_object({ ca_options: objectCacheKey }, objectCacheNamespace); + console.log('Cache cleared successfully (or key did not exist).'); + } + catch (error) { + console.warn('Failed to clear cache, proceeding anyway:', error); + } + // --- End Cache Clearing Logic --- + // Combine all options including callbacks for createIterator + const iteratorOptions = { network: networkOptions, errorCallback, filterCallback: async () => true, @@ -235,12 +291,15 @@ export async function factoryExample() { logger, cacheConfig: { ...cacheConfig, - // Force a new response for format testing enabled: process.argv.includes('--no-cache') ? false : cacheConfig.enabled - } - }); + }, + onTransform: exampleOnTransform, + onTransformed: exampleOnTransformed + }; + // Create an iterator factory instance + const iterator = createIterator(data, globalOptionsMixin, iteratorOptions); // Use the iterator to transform the data - console.log("First run - should transform and cache results:"); + console.log("First run - should transform, run callbacks, and cache results:"); await iterator.transform(fieldMappings); const outputPath = path.resolve('./tests/test-data/core/iterator-factory-data.json'); const outputDir = path.dirname(outputPath); @@ -275,15 +334,8 @@ export async function factoryExample() { console.log("Second run - should use cached results:"); console.log("========================================"); const data2 = JSON.parse(JSON.stringify(exampleData)); - const iterator2 = createIterator(data2, globalOptionsMixin, { - network: networkOptions, - errorCallback, - filterCallback: async () => true, - transformerFactory: (options) => createLLMTransformer(options, logger, cacheConfig), - logger, - cacheConfig - }); - // Should use cached values + const iterator2 = createIterator(data2, globalOptionsMixin, iteratorOptions); + // Should use cached values (callbacks won't run for cached object transform) await iterator2.transform(fieldMappings); console.log("\nBefore/After Comparison Example:"); console.log(`Original description: ${exampleData.products.fruits[0].description}`); @@ -337,4 +389,4 @@ if (process.argv[1] && process.argv[1].includes('iterator-factory-example')) { console.error("Unhandled error:", error); }); } -//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iterator-factory-example.js","sourceRoot":"","sources":["../../../src/examples/core/iterator-factory-example.ts"],"names":[],"mappings":"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"} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iterator-factory-example.js","sourceRoot":"","sources":["../../../src/examples/core/iterator-factory-example.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/kbot/dist-in/iterator.d.ts b/packages/kbot/dist-in/iterator.d.ts index a1e4813e..99e3b2aa 100644 --- a/packages/kbot/dist-in/iterator.d.ts +++ b/packages/kbot/dist-in/iterator.d.ts @@ -1,5 +1,5 @@ import { IKBotTask } from '@polymech/ai-tools'; -import { AsyncTransformer, ErrorCallback, FilterCallback, INetworkOptions } from './async-iterator.js'; +import { AsyncTransformer, ErrorCallback, FilterCallback, OnTransformCallback, OnTransformedCallback, INetworkOptions } from './async-iterator.js'; /** * Notes for LLM modifications * @@ -34,6 +34,8 @@ export interface IOptions { transformerFactory?: (options: IKBotTask) => AsyncTransformer; logger?: ILogger; cacheConfig?: CacheConfig; + onTransform?: OnTransformCallback; + onTransformed?: OnTransformedCallback; } export { INetworkOptions }; export declare function createLLMTransformer(options: IKBotTask, logger?: ILogger, cacheConfig?: CacheConfig): AsyncTransformer; diff --git a/packages/kbot/dist-in/iterator.js b/packages/kbot/dist-in/iterator.js index f3bc3441..890e394c 100644 --- a/packages/kbot/dist-in/iterator.js +++ b/packages/kbot/dist-in/iterator.js @@ -74,7 +74,7 @@ export function createLLMTransformer(options, logger = dummyLogger, cacheConfig) }; } export function createIterator(obj, optionsMixin, globalOptions = {}) { - const { network = {}, errorCallback = defaultError, filterCallback = testFilters(defaultFilters()), transformerFactory, logger = dummyLogger, cacheConfig } = globalOptions; + const { network = {}, errorCallback = defaultError, filterCallback = testFilters(defaultFilters()), transformerFactory, logger = dummyLogger, cacheConfig, onTransform, onTransformed } = globalOptions; const networkOptions = { ...DEFAULT_NETWORK_OPTIONS, ...network @@ -134,7 +134,10 @@ export function createIterator(obj, optionsMixin, globalOptions = {}) { targetPath, network: networkOptions, errorCallback, - filterCallback + filterCallback, + onTransform, + onTransformed, + kbotOptions: mergedOptions }); } // Cache the transformed object @@ -167,4 +170,4 @@ export async function transform(obj, mappings, 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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"} \ No newline at end of file +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iterator.js","sourceRoot":"","sources":["../src/iterator.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/packages/kbot/docs_/iterator.md b/packages/kbot/docs_/iterator.md index 0c3cf514..dd7c6b63 100644 --- a/packages/kbot/docs_/iterator.md +++ b/packages/kbot/docs_/iterator.md @@ -137,6 +137,160 @@ To keep the original value and add a transformed version, specify a `targetPath` This keeps the original `name` and adds a new `marketingName` field. +### Structured Output with Format Option + +The `format` option allows you to define a JSON schema that the LLM output should conform to. This is extremely useful for ensuring consistent, structured responses that can be easily parsed and used in your application. + +#### Basic Format Usage + +To request structured output, add a `format` property to your field mapping options: + +```typescript +{ + jsonPath: '$.productReview.reviewText', + targetPath: 'analysis', + options: { + prompt: 'Analyze this product review and extract key information', + format: { + type: "object", + properties: { + sentiment: { + type: "string", + enum: ["positive", "neutral", "negative"], + description: "The overall sentiment of the review" + }, + pros: { + type: "array", + items: { + type: "string" + }, + description: "Positive aspects mentioned in the review", + minItems: 1, + maxItems: 3 + }, + cons: { + type: "array", + items: { + type: "string" + }, + description: "Negative aspects mentioned in the review", + minItems: 0, + maxItems: 3 + } + }, + required: ["sentiment", "pros", "cons"] + } + } +} +``` + +#### Processing Structured Responses + +The formatted response may be returned as a JSON string. When working with formatted responses, it's good practice to handle potential string parsing: + +```typescript +// After transformation +if (data.productReview && data.productReview.analysis) { + try { + // Parse the JSON string if needed + const analysisJson = typeof data.productReview.analysis === 'string' + ? JSON.parse(data.productReview.analysis) + : data.productReview.analysis; + + // Now you can work with the structured data + console.log(`Sentiment: ${analysisJson.sentiment}`); + console.log(`Pros: ${analysisJson.pros.join(', ')}`); + console.log(`Cons: ${analysisJson.cons.join(', ')}`); + } catch (e) { + console.error("Error parsing structured output:", e); + } +} +``` + +#### Best Practices for Formatted Output + +1. **Clear Prompt Instructions**: Include explicit instructions in your prompt about the expected format. +2. **Schema Validation**: Use detailed JSON schemas with required fields and appropriate types. +3. **Parsing Handling**: Always include error handling when parsing the output. +4. **Schema Examples**: Consider including examples in your prompt for more complex schemas. + +#### Format Option Example + +Here's a complete example from the iterator-factory-example.ts file: + +```typescript +// Define a field mapping with format option +const fieldMappings = [ + { + jsonPath: '$.productReview.reviewText', + targetPath: 'analysis', + options: { + // Clear and explicit prompt that includes the schema format details + prompt: `Analyze this product review and extract key information using EXACTLY the schema specified below. + +The review: "Great selection of fruits with good prices and quality. Some items were out of stock." + +Your response MUST be a valid JSON object following this exact schema: +{ + "sentiment": "positive" | "neutral" | "negative", + "pros": ["string", "string"...], // 1-3 items + "cons": ["string"...] // 0-3 items +} + +Do not add any extra fields not in the schema, and make sure to use the exact field names as specified.`, + // Schema validation ensures structured output format + format: { + type: "object", + properties: { + sentiment: { + type: "string", + enum: ["positive", "neutral", "negative"], + description: "The overall sentiment of the review" + }, + pros: { + type: "array", + items: { + type: "string" + }, + description: "Positive aspects mentioned in the review", + minItems: 1, + maxItems: 3 + }, + cons: { + type: "array", + items: { + type: "string" + }, + description: "Negative aspects mentioned in the review", + minItems: 0, + maxItems: 3 + } + }, + required: ["sentiment", "pros", "cons"] + } + } + } +] +``` + +When run, this produces a structured output like: + +```json +{ + "sentiment": "positive", + "pros": [ + "great selection of fruits", + "good prices", + "good quality" + ], + "cons": [ + "some items were out of stock" + ] +} +``` + +This structured format is much easier to work with programmatically than free-form text responses. + ## Filtering Filters determine which values should be transformed: @@ -441,9 +595,15 @@ async function transformProductsWithCaching() { 8. **Use targetPath for non-destructive transformations**: When generating new content related to existing fields, use targetPath to preserve the original data. -9. **Implement custom cache for production**: For production scenarios, implement a persistent cache solution rather than relying on in-memory caching. +9. **Use format for structured outputs**: When you need consistent, structured data from LLMs, use the format option with clear JSON schemas. -10. **Use appropriate namespaces**: When multiple parts of your application use the same cache implementation, use distinct namespaces to prevent collisions. +10. **Include schema details in prompts**: For complex schemas, include the schema structure in your prompt to guide the LLM. + +11. **Handle string parsing**: Always add error handling when parsing structured responses, as they may be returned as string JSON. + +12. **Implement custom cache for production**: For production scenarios, implement a persistent cache solution rather than relying on in-memory caching. + +13. **Use appropriate namespaces**: When multiple parts of your application use the same cache implementation, use distinct namespaces to prevent collisions. ## API Reference @@ -465,7 +625,14 @@ async function transformProductsWithCaching() { - `FilterCallback`: Function that determines if a value should be transformed - `ErrorCallback`: Function that handles transformation errors - `FieldMapping`: Configuration for a transformation + - `jsonPath`: JSONPath expression to select values + - `targetPath`: Optional field to store transformed value (null for in-place) + - `options`: Configuration for the transformation including: + - `prompt`: The prompt for the LLM + - `format`: Optional JSON schema for structured output - `TransformOptions`: Options for the transformation process +- `CacheConfig`: Configuration for the caching mechanism +- `INetworkOptions`: Configuration for throttling and concurrency ## Limitations @@ -495,6 +662,9 @@ npm run examples:iterator-factory # Run with debug logging npm run examples:async-iterator -- --debug + +# Run with caching disabled (forces fresh responses) +npm run examples:iterator-factory -- --no-cache ``` The examples will transform sample JSON data and save the results to the `tests/test-data/core/` directory. diff --git a/packages/kbot/logs/params.json b/packages/kbot/logs/params.json index 1ece8737..86f8aa6f 100644 --- a/packages/kbot/logs/params.json +++ b/packages/kbot/logs/params.json @@ -3,7 +3,7 @@ "messages": [ { "role": "user", - "content": "Analyze this product review and extract key information using EXACTLY the schema specified below.\n\nThe review: \"Great selection of fruits with good prices and quality. Some items were out of stock.\"\n\nYour response MUST be a valid JSON object following this exact schema:\n{\n \"sentiment\": \"positive\" | \"neutral\" | \"negative\",\n \"pros\": [\"string\", \"string\"...], // 1-3 items\n \"cons\": [\"string\"...] // 0-3 items\n}\n\nDo not add any extra fields not in the schema, and make sure to use the exact field names as specified.\n\nText to transform: \"Great selection of fruits with good prices and quality. Some items were out of stock.\"" + "content": "Make this description more engaging and detailed, around 10 words\n\nText to transform: \"[PRODUCT INFO] A yellow tropical fruit\"" }, { "role": "user", diff --git a/packages/kbot/src/async-iterator.ts b/packages/kbot/src/async-iterator.ts index 8fe8e037..473ab72d 100644 --- a/packages/kbot/src/async-iterator.ts +++ b/packages/kbot/src/async-iterator.ts @@ -2,11 +2,15 @@ import { JSONPath } from 'jsonpath-plus' import pThrottle from 'p-throttle' import pMap from 'p-map' import { deepClone } from "@polymech/core/objects" +import { IKBotTask } from '@polymech/ai-tools'; // Assuming IKBotTask might be relevant context for callbacks export type AsyncTransformer = (input: string, path: string) => Promise export type ErrorCallback = (path: string, value: string, error: unknown) => void export type FilterCallback = (input: string, path: string) => Promise export type Filter = (input: string) => Promise +// Define the new callback types, passing IKBotTask options might be useful context +export type OnTransformCallback = (jsonPath: string, value: string, options?: Partial) => Promise; +export type OnTransformedCallback = (jsonPath: string, transformedValue: string, options?: Partial) => Promise; export interface INetworkOptions { throttleDelay?: number; @@ -35,6 +39,8 @@ export interface GlobalOptions { network?: INetworkOptions errorCallback?: ErrorCallback filterCallback?: FilterCallback + onTransform?: OnTransformCallback // Add pre-transform callback + onTransformed?: OnTransformedCallback // Add post-transform callback } // Sleep utility for retry mechanism @@ -66,7 +72,10 @@ export async function transformObject( path: string, networkOptions: Required, errorCallback: ErrorCallback, - testCallback: FilterCallback + testCallback: FilterCallback, + onTransform: OnTransformCallback, // Pass callbacks down + onTransformed: OnTransformedCallback, // Pass callbacks down + options?: Partial // Pass options context if available ): Promise { const paths = JSONPath({ path, json: obj, resultType: 'pointer' }); await pMap( @@ -80,7 +89,10 @@ export async function transformObject( networkOptions, jsonPointer, errorCallback, - testCallback + testCallback, + onTransform, // Pass callbacks down + onTransformed, // Pass callbacks down + options // Pass options context if available ) }, { concurrency: networkOptions.concurrentTasks } @@ -92,9 +104,12 @@ export async function transformPath( keys: string[], transform: AsyncTransformer, networkOptions: Required, - currentPath: string, + currentPath: string, // Changed from jsonPointer to represent the logical path errorCallback: ErrorCallback, - testCallback: FilterCallback + testCallback: FilterCallback, + onTransform: OnTransformCallback, // Receive callbacks + onTransformed: OnTransformedCallback, // Receive callbacks + options?: Partial // Pass options context if available ): Promise { let current: Record = obj @@ -117,10 +132,30 @@ export async function transformPath( let attempts = 0; let success = false; let lastError: unknown; + let valueToTransform = current[lastKey]; + const fullJsonPath = `${currentPath}/${lastKey}`; // Construct full path + + // Call onTransform before transformation + try { + valueToTransform = await onTransform(fullJsonPath, valueToTransform, options); + } catch (error) { + console.error(`Error in onTransform callback for path ${fullJsonPath}:`, error); + // Decide if you want to proceed with the original value or stop + } while (attempts < networkOptions.maxRetries && !success) { try { - current[lastKey] = await throttle(transform)(current[lastKey], `${currentPath}/${lastKey}`); + let transformedValue = await throttle(transform)(valueToTransform, fullJsonPath); + + // Call onTransformed after successful transformation + try { + transformedValue = await onTransformed(fullJsonPath, transformedValue, options); + } catch (error) { + console.error(`Error in onTransformed callback for path ${fullJsonPath}:`, error); + // Decide if you want to proceed with the transformed value or stop/modify + } + + current[lastKey] = transformedValue; // Assign potentially modified transformed value success = true; } catch (error) { lastError = error; @@ -135,17 +170,20 @@ export async function transformPath( } if (!success) { - errorCallback(currentPath, lastKey, lastError); + errorCallback(currentPath, lastKey, lastError); // Use currentPath (logical path) } } } else if (typeof current[lastKey] === 'object' && current[lastKey] !== null) { await transformObject( current[lastKey] as Record, transform, - '$.*', + '$.*', // Recurse on all properties networkOptions, errorCallback, - testCallback + testCallback, + onTransform, // Pass callbacks down + onTransformed, // Pass callbacks down + options // Pass options context down ) } } @@ -161,8 +199,15 @@ export interface TransformWithOptionsInput { network?: INetworkOptions errorCallback?: ErrorCallback filterCallback?: FilterCallback + onTransform?: OnTransformCallback // Add to options + onTransformed?: OnTransformedCallback // Add to options + kbotOptions?: Partial // Add kbot options context } +// Default no-op implementations for the new callbacks +const defaultOnTransform: OnTransformCallback = async (_, value) => value; +const defaultOnTransformed: OnTransformedCallback = async (_, transformedValue) => transformedValue; + export async function transformObjectWithOptions( obj: Record, transform: AsyncTransformer, @@ -173,7 +218,10 @@ export async function transformObjectWithOptions( targetPath = null, network = {}, errorCallback = defaultError, - filterCallback = testFilters(defaultFilters()) + filterCallback = testFilters(defaultFilters()), + onTransform = defaultOnTransform, // Use default if not provided + onTransformed = defaultOnTransformed, // Use default if not provided + kbotOptions // Destructure kbot options } = options; const networkOptions: Required = { @@ -189,7 +237,10 @@ export async function transformObjectWithOptions( jsonPath, networkOptions, errorCallback, - filterCallback + filterCallback, + onTransform, // Pass down + onTransformed, // Pass down + kbotOptions // Pass down kbot options ); } @@ -203,7 +254,10 @@ export async function transformObjectWithOptions( jsonPath, networkOptions, errorCallback, - filterCallback + filterCallback, + onTransform, // Pass down + onTransformed, // Pass down + kbotOptions // Pass down kbot options ); // Get paths from original object diff --git a/packages/kbot/src/examples/core/iterator-factory-example.ts b/packages/kbot/src/examples/core/iterator-factory-example.ts index d45c6fb2..7ce5d749 100644 --- a/packages/kbot/src/examples/core/iterator-factory-example.ts +++ b/packages/kbot/src/examples/core/iterator-factory-example.ts @@ -4,7 +4,9 @@ import * as fs from 'fs'; import type { IKBotTask } from '@polymech/ai-tools'; import { E_OPENROUTER_MODEL } from '../../models/cache/openrouter-models.js'; import { E_Mode } from '../../zod_schema.js'; -import { FieldMapping, createIterator, createLLMTransformer, CacheConfig, INetworkOptions, transform } from '../../iterator.js'; +import { FieldMapping, createIterator, createLLMTransformer, CacheConfig, INetworkOptions, transform, IOptions, removeEmptyObjects } from '../../iterator.js'; +import { OnTransformCallback, OnTransformedCallback } from '../../async-iterator.js'; +import { rm_cached_object } from '@polymech/cache'; /** * Notes for LLM modifications @@ -32,6 +34,9 @@ export async function simpleTransformExample() { model: MODEL, router: ROUTER, mode: E_Mode.COMPLETION + }, { + onTransform: simpleOnTransform, + onTransformed: simpleOnTransformed }); console.log("\nSimplified Transform Result:"); @@ -211,6 +216,37 @@ Do not add any extra fields not in the schema, and make sure to use the exact fi } ]; +// Example onTransform callback +const exampleOnTransform: OnTransformCallback = async (jsonPath, value, options) => { + console.log(` -> onTransform: Path='${jsonPath}', Original Value='${value.substring(0, 30)}...', Options Model='${options?.model}'`); + // Example: Prefix value before sending to LLM + if (jsonPath.includes('description')) { + return `[PRODUCT INFO] ${value}`; + } + return value; // Return original value if no modification needed +}; + +// Example onTransformed callback +const exampleOnTransformed: OnTransformedCallback = async (jsonPath, transformedValue, options) => { + console.log(` <- onTransformed: Path='${jsonPath}', Transformed Value='${transformedValue.substring(0, 30)}...', Options Model='${options?.model}'`); + // Example: Post-process the LLM response + if (jsonPath.includes('nutrition')) { + return `${transformedValue} [HEALTH FOCUS]`; + } + return transformedValue; // Return transformed value if no modification needed +}; + +// Simpler callbacks for the second example +const simpleOnTransform: OnTransformCallback = async (jsonPath, value) => { + console.log(` -> simpleOnTransform: Path='${jsonPath}'`); + return value; +}; + +const simpleOnTransformed: OnTransformedCallback = async (jsonPath, transformedValue) => { + console.log(` <- simpleOnTransformed: Path='${jsonPath}'`); + return transformedValue; +}; + // Error handler const errorCallback = (path: string, value: string, error: any) => { logger.error(`Error transforming ${path}: ${error.message}`); @@ -247,26 +283,56 @@ export async function factoryExample() { mode: E_Mode.COMPLETION }; + // --- Cache Clearing Logic --- + // Calculate the expected cache key for the object transformation + const objectCacheKey = removeEmptyObjects({ + data: JSON.stringify(exampleData), // Use the initial data state + mappings: fieldMappings.map(m => ({ + jsonPath: m.jsonPath, + targetPath: m.targetPath, + options: { + model: globalOptionsMixin.model, + router: globalOptionsMixin.router, + mode: globalOptionsMixin.mode, + prompt: m.options?.prompt + } + })) + }); + + const objectCacheNamespace = 'transformed-objects'; + console.log(`Attempting to clear cache for key in namespace '${objectCacheNamespace}' before first run...`); + try { + await rm_cached_object({ ca_options: objectCacheKey }, objectCacheNamespace); + console.log('Cache cleared successfully (or key did not exist).'); + } catch (error) { + console.warn('Failed to clear cache, proceeding anyway:', error); + } + // --- End Cache Clearing Logic --- + + // Combine all options including callbacks for createIterator + const iteratorOptions: IOptions = { + network: networkOptions, + errorCallback, + filterCallback: async () => true, + transformerFactory: (options) => createLLMTransformer(options, logger, cacheConfig), + logger, + cacheConfig: { + ...cacheConfig, + enabled: process.argv.includes('--no-cache') ? false : cacheConfig.enabled + }, + onTransform: exampleOnTransform, + onTransformed: exampleOnTransformed + }; + // Create an iterator factory instance const iterator = createIterator( data, globalOptionsMixin, - { - network: networkOptions, - errorCallback, - filterCallback: async () => true, - transformerFactory: (options) => createLLMTransformer(options, logger, cacheConfig), - logger, - cacheConfig: { - ...cacheConfig, - // Force a new response for format testing - enabled: process.argv.includes('--no-cache') ? false : cacheConfig.enabled - } - } + iteratorOptions ); // Use the iterator to transform the data - console.log("First run - should transform and cache results:"); + console.log("First run - should transform, run callbacks, and cache results:"); await iterator.transform(fieldMappings); const outputPath = path.resolve('./tests/test-data/core/iterator-factory-data.json'); @@ -309,17 +375,10 @@ export async function factoryExample() { const iterator2 = createIterator( data2, globalOptionsMixin, - { - network: networkOptions, - errorCallback, - filterCallback: async () => true, - transformerFactory: (options) => createLLMTransformer(options, logger, cacheConfig), - logger, - cacheConfig - } + iteratorOptions ); - // Should use cached values + // Should use cached values (callbacks won't run for cached object transform) await iterator2.transform(fieldMappings); console.log("\nBefore/After Comparison Example:"); diff --git a/packages/kbot/src/iterator.ts b/packages/kbot/src/iterator.ts index 87c22962..85ba97df 100644 --- a/packages/kbot/src/iterator.ts +++ b/packages/kbot/src/iterator.ts @@ -3,6 +3,8 @@ import { AsyncTransformer, ErrorCallback, FilterCallback, + OnTransformCallback, + OnTransformedCallback, defaultError, defaultFilters, testFilters, @@ -75,6 +77,8 @@ export interface IOptions { transformerFactory?: (options: IKBotTask) => AsyncTransformer; logger?: ILogger; cacheConfig?: CacheConfig; + onTransform?: OnTransformCallback; + onTransformed?: OnTransformedCallback; } const DEFAULT_CACHE_CONFIG: Required = { @@ -159,7 +163,9 @@ export function createIterator( filterCallback = testFilters(defaultFilters()), transformerFactory, logger = dummyLogger, - cacheConfig + cacheConfig, + onTransform, + onTransformed } = globalOptions; const networkOptions: Required = { @@ -234,7 +240,10 @@ export function createIterator( targetPath, network: networkOptions, errorCallback, - filterCallback + filterCallback, + onTransform, + onTransformed, + kbotOptions: mergedOptions } ); } diff --git a/packages/kbot/tests/test-data/core/iterator-factory-data.json b/packages/kbot/tests/test-data/core/iterator-factory-data.json index 9fafc397..29ee672f 100644 --- a/packages/kbot/tests/test-data/core/iterator-factory-data.json +++ b/packages/kbot/tests/test-data/core/iterator-factory-data.json @@ -4,22 +4,22 @@ { "id": "f1", "name": "apple", - "description": "A delightfully crisp and juicy fruit bursting with natural sweetness.", + "description": "A deliciously sweet, crisp, and refreshing fruit packed with flavor.", "details": { "color": "red", "origin": "Worldwide", - "nutrition": "Rich in fiber and vitamin D, this food supports healthy digestion, helps regulate blood sugar levels, and promotes strong bones by enhancing calcium absorption and supporting the immune system." + "nutrition": "Rich in fiber and vitamin D, this food supports healthy digestion, helps regulate blood sugar levels, and promotes strong bones by enhancing calcium absorption and supporting the immune system. [HEALTH FOCUS]" }, "marketingName": "Sure! Here are a few appealing marketing name options for \"apple\":\n\n1. Crimson Bliss\n2. Orchard Jewel\n3. Scarlet Crunch\n4. Nature’s Candy\n5. Ruby Crisp\n6. SweetHarvest\n7. Eden Bite\n8. Golden Orchard (if it’s a yellow variety)\n9. PurePom\n10. FreshMuse\n\nLet me know if you'd like names tailored to a specific apple variety or target audience!" }, { "id": "f2", "name": "banana", - "description": "A sweet, sun-ripened yellow fruit bursting with tropical flavor.", + "description": "Vibrant, sun-kissed yellow tropical fruit bursting with sweet flavor", "details": { "color": "yellow", "origin": "Southeast Asia", - "nutrition": "High in potassium, which helps regulate blood pressure, supports proper muscle function, and maintains fluid balance in the body, contributing to overall cardiovascular and muscular health." + "nutrition": "High in potassium, which helps regulate blood pressure, supports proper muscle function, and maintains fluid balance in the body, contributing to overall cardiovascular and muscular health. [HEALTH FOCUS]" }, "marketingName": "Golden Delight" }