@far-world-labs/verblets 0.1.1 → 0.1.3

package/src/chains/list/index.examples.js

@@ -27,21 +27,15 @@ describe('List verblet', () => {
   examples.forEach((example) => {
     let jsonSchemaDisplay = '';
     if (example.inputs.jsonSchemaQuery) {
-      const jsonSchemaEllipsis =
-        example.inputs.jsonSchemaQuery.length > 10 ? '...' : '';
-      jsonSchemaDisplay = ` - ${example.inputs.jsonSchemaQuery.slice(
-        0,
-        10
-      )}${jsonSchemaEllipsis}`;
+      const jsonSchemaEllipsis = example.inputs.jsonSchemaQuery.length > 10 ? '...' : '';
+      jsonSchemaDisplay = ` - ${example.inputs.jsonSchemaQuery.slice(0, 10)}${jsonSchemaEllipsis}`;
     }
     it(
-      `${example.inputs.text}${jsonSchemaDisplay}`,
+      `${example.inputs.description}${jsonSchemaDisplay}`,
       async () => {
         let schema;
         if (example.inputs.jsonSchemaQuery) {
-          schema = await toObject(
-            await chatGPT(asJSONSchema(example.inputs.schemaQuery))
-          );
+          schema = await toObject(await chatGPT(asJSONSchema(example.inputs.jsonSchemaQuery)));
         }
 
         const result = await list(example.inputs.description, {
@@ -53,16 +47,18 @@ describe('List verblet', () => {
         }
 
         if (example.want.listContains) {
-          expect(
-            result.some((item) => item.includes(example.want.listContains))
-          ).equals(true);
+          expect(result.some((item) => item.includes(example.want.listContains))).equals(true);
         }
 
         if (example.want.listModelContains) {
           expect(
-            result.some((item) =>
-              item.model.includes(example.want.listModelContains)
-            )
+            result.some((item) => {
+              // Handle both string and object results
+              if (typeof item === 'string') {
+                return item.includes(example.want.listModelContains);
+              }
+              return item.model?.includes(example.want.listModelContains);
+            })
           ).equals(true);
         }
       },

package/src/chains/list/index.js

@@ -1,16 +1,58 @@
-/* eslint-disable no-await-in-loop */
-
-import { operationTimeoutMultiplier } from '../../constants/openai.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { operationTimeoutMultiplier } from '../../constants/models.js';
 import chatGPT from '../../lib/chatgpt/index.js';
 import {
-  constants as promptConstants,
   asObjectWithSchema as asObjectWithSchemaPrompt,
   generateList as generateListPrompt,
+  constants as promptConstants,
 } from '../../prompts/index.js';
 import modelService from '../../services/llm-model/index.js';
-import toObject from '../../verblets/to-object/index.js';
 
-const { onlyJSON, contentIsTransformationSource } = promptConstants;
+const { onlyJSON, contentIsTransformationSource, onlyJSONArray } = promptConstants;
+
+// Get the directory of this module
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Load the JSON schema for list results
+ * @returns {Promise<Object>} JSON schema for validation
+ */
+async function getListSchema() {
+  const schemaPath = path.join(__dirname, 'list-result.json');
+  return JSON.parse(await fs.readFile(schemaPath, 'utf8'));
+}
+
+/**
+ * Create model options for structured outputs
+ * @param {string|Object} llm - LLM model name or configuration object
+ * @returns {Promise<Object>} Model options for chatGPT
+ */
+async function createModelOptions(llm = 'fastGoodCheap') {
+  const schema = await getListSchema();
+
+  const responseFormat = {
+    type: 'json_schema',
+    json_schema: {
+      name: 'list_result',
+      schema,
+    },
+  };
+
+  if (typeof llm === 'string') {
+    return {
+      modelName: llm,
+      response_format: responseFormat,
+    };
+  } else {
+    return {
+      ...llm,
+      response_format: responseFormat,
+    };
+  }
+}
 
 const outputTransformPrompt = (result, schema) => {
   return `${contentIsTransformationSource} ${result}
@@ -28,22 +70,21 @@ const shouldStopDefault = ({ queryCount, startTime } = {}) => {
   return (
     queryCount > 5 ||
     new Date() - startTime >
-      operationTimeoutMultiplier *
-        modelService.getBestAvailableModel().requestTimeout
+      operationTimeoutMultiplier * modelService.getBestPublicModel().requestTimeout
   );
 };
 
-export const generateList = async function* generateListGenerator(
-  text,
-  options = {}
-) {
+export const generateList = async function* generateListGenerator(text, options = {}) {
   const resultsAll = [];
   const resultsAllMap = {};
   let isDone = false;
   const {
     shouldSkip = shouldSkipDefault,
     shouldStop = shouldStopDefault,
-    model = modelService.getBestAvailableModel(),
+    model = 'fastGoodCheap',
+    // eslint-disable-next-line no-unused-vars
+    _schema,
+    ...passThroughOptions
   } = options;
 
   const startTime = new Date();
@@ -55,26 +96,27 @@ export const generateList = async function* generateListGenerator(
       existing: resultsAll,
     });
 
-    const budget = model.budgetTokens(listPrompt);
-
     let resultsNew = [];
     try {
+      const modelOptions = await createModelOptions(model);
+      // eslint-disable-next-line no-await-in-loop
       const results = await chatGPT(listPrompt, {
-        modelOptions: {
-          maxTokens: budget.completion,
-        },
-        ...options,
+        modelOptions,
+        ...passThroughOptions,
       });
 
-      // debug helper:
-      // console.error(R.sort((a, b) => a.localeCompare(b), await toObject(results)));
-
-      resultsNew = await toObject(results);
+      // With structured outputs, response should already be parsed and validated
+      const parsed = typeof results === 'string' ? JSON.parse(results) : results;
+      // Extract items from the object structure
+      const resultArray = parsed?.items || parsed;
+      resultsNew = Array.isArray(resultArray) ? resultArray.filter(Boolean) : [];
     } catch (error) {
       if (/The operation was aborted/.test(error.message)) {
+        // eslint-disable-next-line no-console
         console.error('Generate list [error]: Aborted');
         resultsNew = []; // continue
       } else {
+        // eslint-disable-next-line no-console
         console.error(
           `Generate list [error]: ${error.message}`,
           listPrompt.slice(0, 100).replace('\n', '\\n')
@@ -84,9 +126,7 @@ export const generateList = async function* generateListGenerator(
       }
     }
 
-    const resultsNewUnique = resultsNew.filter(
-      (item) => !(item in resultsAllMap)
-    );
+    const resultsNewUnique = resultsNew.filter((item) => !(item in resultsAllMap));
 
     queryCount += 1;
 
@@ -99,11 +139,13 @@ export const generateList = async function* generateListGenerator(
         startTime,
       };
 
+      // eslint-disable-next-line no-await-in-loop
       if (await shouldStop(perResultControlFactors)) {
         isDone = true;
         break;
       }
 
+      // eslint-disable-next-line no-await-in-loop
       if (!(await shouldSkip(perResultControlFactors))) {
         resultsAllMap[result] = true;
         resultsAll.push(result);
@@ -123,39 +165,50 @@ export const generateList = async function* generateListGenerator(
       startTime,
     };
 
+    // eslint-disable-next-line no-await-in-loop
     if (await shouldStop(perQueryControlFactors)) {
       isDone = true;
     }
   }
 };
 
-export default async (text, options) => {
-  const generator = generateList(text, options);
-  const { schema, model = modelService.getBestAvailableModel() } =
-    options ?? {};
-
-  const results = [];
-  for await (const result of generator) {
-    results.push(result);
-  }
-
-  if (!schema) {
-    return results;
-  }
-
-  const resultObjects = await Promise.all(
-    results.map(async (result) => {
-      const prompt = outputTransformPrompt(result, schema);
-      const budget = model.budgetTokens(prompt);
-
-      const resultObject = await chatGPT(prompt, {
-        maxTokens: budget.completion,
+export default async function list(prompt, config = {}) {
+  const { llm, schema, ...options } = config;
+  const fullPrompt = `${prompt}\n\n${onlyJSONArray}`;
+
+  const modelOptions = await createModelOptions(llm);
+  const response = await chatGPT(fullPrompt, {
+    modelOptions,
+    ...options,
+  });
+
+  // With structured outputs, response should already be parsed and validated
+  const result = typeof response === 'string' ? JSON.parse(response) : response;
+  // Extract items from the object structure
+  const resultArray = result?.items || result;
+  const items = Array.isArray(resultArray) ? resultArray : [];
+
+  // If schema is provided, transform each item to match the schema
+  if (schema && items.length > 0) {
+    const transformedItems = [];
+    for (const item of items) {
+      const transformPrompt = outputTransformPrompt(item, schema);
+      const transformResponse = await chatGPT(transformPrompt, {
+        modelOptions: {
+          ...llm,
+        },
         ...options,
       });
+      try {
+        const transformedItem = JSON.parse(transformResponse);
+        transformedItems.push(transformedItem);
+      } catch {
+        // If transformation fails, keep the original item
+        transformedItems.push(item);
+      }
+    }
+    return transformedItems;
+  }
 
-      return toObject(resultObject);
-    })
-  );
-
-  return resultObjects;
-};
+  return items;
+}

package/src/chains/list/index.spec.js

@@ -1,13 +1,16 @@
 import fs from 'node:fs/promises';
 import { describe, expect, it, vi } from 'vitest';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
 
 import toObject from '../../verblets/to-object/index.js';
 import list from './index.js';
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
 const loadSchema = async () => {
-  const file = (
-    await fs.readFile('./src/json-schemas/cars-test.json')
-  ).toString();
+  const file = (await fs.readFile(join(__dirname, '../../json-schemas/cars-test.json'))).toString();
 
   return toObject(file);
 };
@@ -53,15 +56,11 @@ describe('List verblet', () => {
       });
 
       if (example.want.listContains) {
-        expect(
-          result.some((item) => example.want.listContains.test(item))
-        ).equals(true);
+        expect(result.some((item) => example.want.listContains.test(item))).equals(true);
       }
 
       if (example.want.listModelContains) {
-        expect(
-          result.some((item) => example.want.listModelContains.test(item.model))
-        ).equals(true);
+        expect(result.some((item) => example.want.listModelContains.test(item.model))).equals(true);
       }
     });
   });

package/src/chains/list/list-result.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "items": {
+      "type": "array",
+      "description": "Array of generated list items",
+      "items": {
+        "type": "string",
+        "description": "A generated list item"
+      }
+    }
+  },
+  "required": ["items"],
+  "additionalProperties": false
+} 

package/src/chains/llm-logger/README.md

@@ -0,0 +1,208 @@
+# LLM Logger
+
+The LLM Logger is an **advanced logger implementation** that you can use with the global logger service. It provides sophisticated features like ring buffers, multi-lane processing, and file context tracking.
+
+## ⚠️ Important: Not Used Automatically
+
+The LLM Logger is **NOT automatically used** by the application. You must:
+
+1. **Create an LLM Logger instance** using `createLLMLogger()`
+2. **Set it as the global logger** using `setLogger()`
+
+The application uses a noop logger by default and will be silent unless you explicitly configure logging.
+
+## Basic Usage
+
+```javascript
+import { setLogger } from 'verblets/lib/logger-service';
+import { createLLMLogger, createConsoleWriter } from 'verblets/chains/llm-logger';
+
+// Create an LLM logger instance
+const llmLogger = createLLMLogger({
+  ringBufferSize: 1000,
+  lanes: [
+    {
+      laneId: 'console',
+      writer: createConsoleWriter('[LOG] ')
+    }
+  ]
+});
+
+// Set it as the global logger
+setLogger(llmLogger);
+
+// Now all verblets and chains will use this logger
+import { bulkMap } from 'verblets';
+const result = await bulkMap(items, processor); // Will log using LLM logger
+```
+
+## Features
+
+- **Ring Buffer**: Memory-efficient circular buffer for log storage
+- **Multi-lane Processing**: Route logs to different outputs based on filters
+- **File Context Tracking**: Automatically captures file and line information
+- **Batch Processing**: Efficient batching of log outputs
+- **Advanced Filtering**: Custom filter functions for sophisticated log routing
+
+## Configuration
+
+### Basic Configuration
+
+```javascript
+import { createLLMLogger, createConsoleWriter } from 'verblets/chains/llm-logger';
+
+const logger = createLLMLogger({
+  ringBufferSize: 1000,        // Size of the ring buffer
+  flushInterval: 100,          // Flush interval in milliseconds
+  lanes: [                     // Lane configurations
+    {
+      laneId: 'all',
+      writer: createConsoleWriter()
+    }
+  ]
+});
+```
+
+### Multi-lane Configuration
+
+```javascript
+const logger = createLLMLogger({
+  ringBufferSize: 5000,
+  lanes: [
+    {
+      laneId: 'errors',
+      filters: (log) => log.meta.get('level') === 'error',
+      writer: createConsoleWriter('[ERROR] ')
+    },
+    {
+      laneId: 'structured',
+      filters: (log) => typeof log.raw === 'object',
+      writer: createConsoleWriter('[STRUCT] ')
+    },
+    {
+      laneId: 'all',
+      writer: createFileWriter('/tmp/all.log')
+    }
+  ]
+});
+```
+
+## Lane Configuration
+
+Each lane can have:
+
+- **`laneId`**: Unique identifier for the lane
+- **`writer`**: Function that receives an array of log strings
+- **`filters`** (optional): Function that determines if a log should be processed by this lane
+
+### Filter Function
+
+The filter function receives a log entry object:
+
+```javascript
+{
+  id: 'log_1234567890_abc123',
+  ts: 1234567890123,
+  raw: 'original log data',
+  fileContext: { filePath: '/path/to/file.js', line: 42 },
+  meta: Map { 'level' => 'info', 'fileContext' => {...} }
+}
+```
+
+## Writers
+
+### Console Writer
+
+```javascript
+import { createConsoleWriter } from 'verblets/chains/llm-logger';
+
+const writer = createConsoleWriter('[PREFIX] ');
+// Outputs: [PREFIX] log message
+```
+
+### File Writer
+
+```javascript
+import { createFileWriter } from 'verblets/chains/llm-logger';
+
+const writer = createFileWriter('/path/to/logfile.log');
+// Currently a placeholder - shows: [FILE:/path/to/logfile.log] N lines
+```
+
+### Custom Writer
+
+```javascript
+const customWriter = (logs) => {
+  logs.forEach(log => {
+    // Send to external service, database, etc.
+    sendToLogService(log);
+  });
+};
+```
+
+## Advanced Usage
+
+### Accessing Ring Buffer
+
+```javascript
+const logger = createLLMLogger({...});
+
+// Get all logs
+const allLogs = logger.ringBuffer.all();
+
+// Get recent logs
+const recentLogs = logger.ringBuffer.tail(10);
+
+// Get oldest logs
+const oldestLogs = logger.ringBuffer.head(5);
+```
+
+### Manual Flush
+
+```javascript
+// Force flush all lanes immediately
+logger.flush();
+```
+
+### Clear Logs
+
+```javascript
+// Clear ring buffer and lane buffers
+logger.clear();
+```
+
+## Integration with Global Logger Service
+
+```javascript
+import { setLogger, log, info, warn, error } from 'verblets';
+import { createLLMLogger, createConsoleWriter } from 'verblets/chains/llm-logger';
+
+// Create and set LLM logger
+const llmLogger = createLLMLogger({
+  lanes: [
+    {
+      laneId: 'console',
+      writer: createConsoleWriter()
+    }
+  ]
+});
+
+setLogger(llmLogger);
+
+// Now you can use global logging functions
+log('This goes through the LLM logger');
+error('This is an error log');
+```
+
+## Examples
+
+See `index.examples.js` for comprehensive examples including:
+
+- Security monitoring systems
+- Performance monitoring
+- E-commerce transaction processing
+- Bulk log analysis
+
+## Legacy API (Deprecated)
+
+The old `initLogger()` and `log(data, logger)` functions are still available for backward compatibility but are deprecated. Use `createLLMLogger()` and the global logger service instead.