@far-world-labs/verblets 0.1.1 → 0.1.3

package/src/lib/parse-llm-list/index.js

@@ -0,0 +1,54 @@
+/**
+ * Parse a list of items from LLM response that could be JSON array or CSV format.
+ * Handles common LLM response patterns and filters out invalid entries.
+ *
+ * @param {string} response - The LLM response string
+ * @param {object} [options] - Parsing options
+ * @param {string[]} [options.excludeValues=['none', 'null', 'undefined']] - Values to exclude (case-insensitive)
+ * @param {boolean} [options.trimItems=true] - Whether to trim whitespace from items
+ * @param {boolean} [options.filterEmpty=true] - Whether to filter out empty strings
+ * @returns {string[]} Array of parsed items
+ */
+export default function parseLLMList(
+  response,
+  { excludeValues = ['none', 'null', 'undefined'], trimItems = true, filterEmpty = true } = {}
+) {
+  if (!response || typeof response !== 'string') {
+    return [];
+  }
+
+  // Skip responses that contain notes or are empty arrays
+  if (response === '[]' || response.includes('<note>')) {
+    return [];
+  }
+
+  const items = [];
+
+  try {
+    // First try to parse as JSON array
+    const parsed = JSON.parse(response);
+    if (Array.isArray(parsed)) {
+      items.push(...parsed.filter((item) => typeof item === 'string'));
+    }
+  } catch {
+    // Fallback to comma-separated parsing if JSON fails
+    items.push(...response.split(','));
+  }
+
+  // Process the items
+  let processedItems = items;
+
+  if (trimItems) {
+    processedItems = processedItems.map((item) => item.trim());
+  }
+
+  if (filterEmpty) {
+    processedItems = processedItems.filter(Boolean);
+  }
+
+  // Filter out excluded values (case-insensitive)
+  const excludeSet = new Set(excludeValues.map((val) => val.toLowerCase()));
+  processedItems = processedItems.filter((item) => !excludeSet.has(item.toLowerCase()));
+
+  return processedItems;
+}

package/src/lib/parse-llm-list/index.spec.js

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import parseLLMList from './index.js';
+
+describe('parseLLMList', () => {
+  it('parses JSON array format', () => {
+    const input = '["term1", "term2", "term3"]';
+    const result = parseLLMList(input);
+    expect(result).toEqual(['term1', 'term2', 'term3']);
+  });
+
+  it('parses CSV format', () => {
+    const input = 'term1, term2, term3';
+    const result = parseLLMList(input);
+    expect(result).toEqual(['term1', 'term2', 'term3']);
+  });
+
+  it('handles empty array response', () => {
+    const input = '[]';
+    const result = parseLLMList(input);
+    expect(result).toEqual([]);
+  });
+
+  it('handles responses with notes', () => {
+    const input = '<note>No terms found</note>';
+    const result = parseLLMList(input);
+    expect(result).toEqual([]);
+  });
+
+  it('filters out excluded values', () => {
+    const input = 'term1, none, term2, null, term3';
+    const result = parseLLMList(input);
+    expect(result).toEqual(['term1', 'term2', 'term3']);
+  });
+
+  it('trims whitespace from items', () => {
+    const input = '  term1  ,  term2  ,  term3  ';
+    const result = parseLLMList(input);
+    expect(result).toEqual(['term1', 'term2', 'term3']);
+  });
+
+  it('filters out empty strings', () => {
+    const input = 'term1, , term2, , term3';
+    const result = parseLLMList(input);
+    expect(result).toEqual(['term1', 'term2', 'term3']);
+  });
+
+  it('handles custom exclude values', () => {
+    const input = 'term1, n/a, term2, unknown, term3';
+    const result = parseLLMList(input, { excludeValues: ['n/a', 'unknown'] });
+    expect(result).toEqual(['term1', 'term2', 'term3']);
+  });
+
+  it('handles invalid input gracefully', () => {
+    expect(parseLLMList(null)).toEqual([]);
+    expect(parseLLMList(undefined)).toEqual([]);
+    expect(parseLLMList('')).toEqual([]);
+    expect(parseLLMList(123)).toEqual([]);
+  });
+});

package/src/lib/path-aliases/index.js

@@ -24,9 +24,7 @@ export default (sequences, delimiter = defaultDelimiter) => {
 
     for (let i = 1; i <= splitSequence.length; i += 1) {
       const tail = splitSequence.slice(-i).join(delimiter);
-      const conflictingSequences = sequences.filter((seq) =>
-        seq.endsWith(tail)
-      );
+      const conflictingSequences = sequences.filter((seq) => seq.endsWith(tail));
 
       if (conflictingSequences.length === 1) {
         tailsUnique[sequence] = tail;

package/src/lib/path-aliases/index.spec.js

@@ -45,14 +45,8 @@ describe('Path aliases', async () => {
   examples.forEach((example) => {
     it(example.name, () => {
       const got = alias(example.inputs.sequences, example.inputs.delimiter);
-      const gotSorted = R.sort(
-        ([k1], [k2]) => k1.localeCompare(k2),
-        Object.entries(got)
-      );
-      const wantSorted = R.sort(
-        ([k1], [k2]) => k1.localeCompare(k2),
-        Object.entries(example.want)
-      );
+      const gotSorted = R.sort(([k1], [k2]) => k1.localeCompare(k2), Object.entries(got));
+      const wantSorted = R.sort(([k1], [k2]) => k1.localeCompare(k2), Object.entries(example.want));
 
       expect(gotSorted).toStrictEqual(wantSorted);
     });

package/src/lib/pave/index.js

@@ -15,16 +15,16 @@ export default (obj, path, value) => {
   const objNew = JSON.parse(JSON.stringify(obj));
   let objMutating = objNew;
 
+  const isNumeric = (str) => /^\d+$/.test(str);
+
   for (let i = 0; i < keys.length; i += 1) {
-    const key = Number.isNaN(parseInt(keys[i], 10))
-      ? keys[i]
-      : parseInt(keys[i], 10);
+    const key = isNumeric(keys[i]) ? parseInt(keys[i], 10) : keys[i];
 
     if (i === keys.length - 1) {
       objMutating[key] = value;
     } else {
       if (!objMutating[key]) {
-        objMutating[key] = Number.isNaN(parseInt(keys[i + 1], 10)) ? {} : [];
+        objMutating[key] = isNumeric(keys[i + 1]) ? [] : {};
       }
       objMutating = objMutating[key];
     }

package/src/lib/pave/index.spec.js

@@ -53,6 +53,11 @@ const examples = [
     inputs: { obj: {}, path: 'a', value: 42 },
     want: { result: { a: 42 } },
   },
+  {
+    name: 'Handle numeric-like string keys',
+    inputs: { obj: {}, path: 'a.1b.c', value: 42 },
+    want: { result: { a: { '1b': { c: 42 } } } },
+  },
 ];
 
 describe('pave', () => {
@@ -61,9 +66,7 @@ describe('pave', () => {
       const { obj } = example.inputs;
 
       if (example.want.throws) {
-        expect(() =>
-          pave(obj, example.inputs.path, example.inputs.value)
-        ).toThrow();
+        expect(() => pave(obj, example.inputs.path, example.inputs.value)).toThrow();
       } else {
         const result = pave(obj, example.inputs.path, example.inputs.value);
         expect(result).toEqual(example.want.result);

package/src/lib/prompt-cache/index.js

@@ -1,13 +1,21 @@
 import crypto from 'node:crypto';
 import * as R from 'ramda';
 
-import { cacheTTL } from '../../constants/openai.js';
+import { cacheTTL } from '../../constants/models.js';
 
 const variableKeys = ['created', 'id', 'max_tokens', 'usage'];
 
 const sortKeys = (data) => {
   const sortedData = R.sortBy(R.identity, R.keys(data)).reduce((acc, key) => {
-    acc[key] = key === 'messages' ? data[key]?.[0]?.content : data[key];
+    if (key === 'messages') {
+      // Preserve all messages and their roles
+      acc[key] = data[key].map((msg) => ({
+        role: msg.role,
+        content: msg.content,
+      }));
+    } else {
+      acc[key] = data[key];
+    }
     return acc;
   }, {});
 
@@ -23,9 +31,7 @@ export const toKey = (data) => {
 };
 
 export const get = async (redis, inputData) => {
-  const resultFromRedis = await redis.get(
-    toKey(R.omit(variableKeys, inputData))
-  );
+  const resultFromRedis = await redis.get(toKey(R.omit(variableKeys, inputData)));
 
   const foundInRedis = !!resultFromRedis;
 
@@ -38,9 +44,7 @@ export const get = async (redis, inputData) => {
 };
 
 export const set = async (redis, inputData, outputData) => {
-  await redis.set(
-    toKey(R.omit(variableKeys, inputData)),
-    JSON.stringify(outputData),
-    { EX: cacheTTL }
-  );
+  await redis.set(toKey(R.omit(variableKeys, inputData)), JSON.stringify(outputData), {
+    EX: cacheTTL,
+  });
 };

package/src/lib/retry/index.js

@@ -1,4 +1,3 @@
-/* eslint-disable no-await-in-loop */
 import {
   maxRetries as maxRetriesDefault,
   retryDelay as retryDelayDefault,
@@ -16,8 +15,10 @@ export default async (
   let retry = 0;
   let lastError = new Error('Nothing to run');
 
-  // eslint-disable-next-line no-promise-executor-return
-  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  const sleep = (ms) =>
+    new Promise((resolve) => {
+      setTimeout(resolve, ms);
+    });
 
   const labelDisplay = label ? `"${label}"` : '';
 
@@ -27,14 +28,15 @@ export default async (
         const variables = [`retry: ${retry}`].join(', ');
         const startTag = `${retry > 0 ? 'retry' : 'started'}`;
         const startVariablesDisplay = `${retry > 0 ? ` (${variables})` : ''}`;
-        console.error(
-          `Run ${labelDisplay} [${startTag}]${startVariablesDisplay}`
-        );
+        // eslint-disable-next-line no-console
+        console.error(`Run ${labelDisplay} [${startTag}]${startVariablesDisplay}`);
       }
 
+      // eslint-disable-next-line no-await-in-loop
       const result = await fn();
 
       if (label) {
+        // eslint-disable-next-line no-console
         console.error(`Run ${labelDisplay} [complete]`);
       }
 
@@ -42,10 +44,10 @@ export default async (
     } catch (error) {
       lastError = error;
 
-      const isRetry =
-        retryOnAll || (error.response && error.response.status === 429);
+      const isRetry = retryOnAll || (error.response && error.response.status === 429);
 
       if (isRetry) {
+        // eslint-disable-next-line no-await-in-loop
         await sleep(retryDelay * retry);
         retry += 1;
       } else {
@@ -54,6 +56,7 @@ export default async (
       const doneTag = `${retry >= maxRetries ? 'abort' : 'retry'}`;
 
       if (label) {
+        // eslint-disable-next-line no-console
         console.error(`Run ${labelDisplay} [${doneTag}]: ${error.message}`);
       }
     }