@far-world-labs/verblets 0.1.1

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

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+
+import Dismantle from './index.js';
+import { longTestTimeout } from '../../constants/common.js';
+
+describe('Dismantle chain', () => {
+  it(
+    '2022 Aprilia Tuono 660',
+    async () => {
+      const dismantleBike = new Dismantle('2022 Aprilia Tuono 660', {
+        enhanceFixes: `
+ - IMPORTANT If the component is "Electronics", output empty results.
+ - If the component is "Dashboard", output empty results.
+`,
+      });
+      await dismantleBike.makeSubtree({ depth: 1 });
+      await dismantleBike.attachSubtree({
+        depth: 1,
+        find: (node) => node.name === 'Fuel Injector',
+      });
+      await dismantleBike.attachSubtree({
+        depth: 1,
+        find: (node) => node.name === 'Exhaust System',
+      });
+
+      expect(true).toStrictEqual(true);
+    },
+    longTestTimeout
+  );
+});

package/src/chains/dismantle/index.js

@@ -0,0 +1,314 @@
+/* eslint-disable no-await-in-loop */
+
+import { v4 as uuid } from 'uuid';
+
+import chatGPT from '../../lib/chatgpt/index.js';
+import {
+  constants as promptConstants,
+  outputSuccinctNames,
+} from '../../prompts/index.js';
+import modelService from '../../services/llm-model/index.js';
+import toObject from '../../verblets/to-object/index.js';
+
+const { onlyJSONStringArray } = promptConstants;
+
+const subComponentsPrompt = (component, thing, fixes = '') => {
+  let focus = '';
+  if (component !== thing) {
+    focus = `"${component}" within "${thing}"`;
+  } else {
+    focus = thing;
+  }
+
+  return `
+${onlyJSONStringArray}
+
+Exhaustively enumerate all physical and logical subcomponents of ${focus}, including containers or abstract components.
+
+Apply the specifics listed here when dealing with component or entity:
+ - ${outputSuccinctNames()}
+ - If some components are subcomponents of others in the list, don't include them.
+ - The output must not include "${thing}" or "${component}" in the list.
+ - Only subcomponents, no accessories.
+${fixes}
+
+${onlyJSONStringArray}
+`;
+};
+
+const componentOptionsPrompt = (component, thing, fixes = '') => {
+  let focus = '';
+  if (component !== thing) {
+    focus = `Considering "${component}" as a separate component within "${thing}" entity`;
+  } else {
+    focus = `Considering "${component}"`;
+  }
+  return `
+${onlyJSONStringArray}
+
+${focus}, list specific variants for this component. Only provide known variants, don't speculate. Output an empty list if you must.
+
+Apply the specifics listed here when dealing with component or entity:
+ - ${outputSuccinctNames()}
+ - Do not list subcomponents, that's not what this is about.
+${fixes}
+
+${onlyJSONStringArray}
+`;
+};
+
+const defaultMatch = () => false;
+
+const deepClone = (obj) => JSON.parse(JSON.stringify(obj));
+
+const search = (node, { match = defaultMatch, matches = [] } = {}) => {
+  if (match(node)) {
+    matches.push(node);
+  }
+
+  if (!node.children) {
+    return matches.length > 0 ? matches : undefined;
+  }
+
+  for (const child of node.children) {
+    search(child, { match, matches });
+  }
+
+  return matches.length > 0 ? matches : undefined;
+};
+
+const defaultDecompose = async ({
+  name,
+  focus,
+  rootName,
+  fixes,
+  model = modelService.getBestAvailableModel(),
+} = {}) => {
+  const focusFormatted = focus ? `: ${focus}` : '';
+
+  const promptCreated = subComponentsPrompt(
+    `${name}${focusFormatted}`,
+    rootName,
+    fixes
+  );
+  const budget = model.budgetTokens(promptCreated);
+  return toObject(
+    await chatGPT(promptCreated, {
+      modelOptions: {
+        maxTokens: budget.completion,
+        frequencyPenalty: 0.7,
+        temperature: 0.7,
+      },
+    })
+  );
+};
+
+const defaultEnhance = async ({
+  name,
+  rootName,
+  fixes,
+  model = modelService.getBestAvailableModel(),
+} = {}) => {
+  const promptCreated = componentOptionsPrompt(name, rootName, fixes);
+  const budget = model.budgetTokens(promptCreated);
+  const options = toObject(
+    await chatGPT(promptCreated, {
+      maxTokens: budget.completion,
+      frequencyPenalty: 0.5,
+      temperature: 0.3,
+    })
+  );
+
+  return {
+    name,
+    options,
+    topOptionName: options?.[0],
+  };
+};
+
+const makeNode = async ({
+  node = {},
+  name: nameInitial,
+  rootName,
+  decompose = defaultDecompose,
+  enhance = defaultEnhance,
+  makeId = uuid,
+  enhanceFixes,
+  decomposeFixes,
+} = {}) => {
+  const name = nameInitial ?? rootName;
+
+  let nodeNew = node;
+
+  if (!node.isEnhanced) {
+    nodeNew = await enhance({
+      name,
+      rootName,
+      fixes: enhanceFixes,
+    });
+    nodeNew.isEnhanced = true;
+
+    const focus = node.options?.[0];
+
+    const childNames = await decompose({
+      name,
+      focus,
+      rootName,
+      fixes: decomposeFixes,
+    });
+    nodeNew.children = childNames.map((childName) => ({
+      id: makeId(),
+      name: childName,
+    }));
+  }
+
+  if (!node.id) {
+    nodeNew.id = makeId();
+  }
+
+  return {
+    ...node,
+    ...nodeNew,
+  };
+};
+
+const makeSubtree = async ({
+  name,
+  rootName,
+  tree: treeInitial,
+  depth = 0,
+  decompose,
+  enhance,
+  enhanceFixes,
+  decomposeFixes,
+  makeId,
+} = {}) => {
+  let tree = { ...(treeInitial ?? {}) };
+
+  const nodeNew = await makeNode({
+    node: tree,
+    name: name ?? tree.name,
+    rootName,
+    enhance,
+    decompose,
+    makeId,
+    enhanceFixes,
+    decomposeFixes,
+  });
+
+  tree = {
+    ...tree,
+    ...nodeNew,
+  };
+
+  if (depth <= 0) {
+    return tree;
+  }
+
+  const children = [];
+  for (const child of tree.children) {
+    const subtree = await makeSubtree({
+      tree: child,
+      rootName,
+      decompose,
+      enhance,
+      depth: depth - 1,
+      makeId,
+      enhanceFixes,
+      decomposeFixes,
+    });
+
+    children.push(subtree);
+  }
+
+  tree.children = children;
+
+  return tree;
+};
+
+export const simplifyTree = (node) => {
+  if (!node.children || node.children.length === 0) {
+    const parts = (node.children ?? []).map((child) => child.name);
+    return {
+      id: node.id,
+      name: `${node.name}${node.options?.[0] ? `: ${node.options?.[0]}` : ''}`,
+      parts: parts.length ? parts : undefined,
+    };
+  }
+
+  const parts = node.children.map((child) => simplifyTree(child));
+  return {
+    id: node.id,
+    name: `${node.name}${node.options?.[0] ? `: ${node.options?.[0]}` : ''}`,
+    parts: parts.length ? parts : undefined,
+  };
+};
+
+class ChainTree {
+  constructor(
+    name,
+    { decompose, enhance, makeId, enhanceFixes, decomposeFixes } = {}
+  ) {
+    this.rootName = name;
+    this.tree = {};
+    this.decompose = decompose;
+    this.enhance = enhance;
+    this.makeId = makeId;
+    this.enhanceFixes = enhanceFixes;
+    this.decomposeFixes = decomposeFixes;
+  }
+
+  getTree() {
+    return this.tree;
+  }
+
+  async attachSubtree({ find, depth }) {
+    const clonedTree = deepClone(this.tree);
+
+    // Find the node to attach the subtree to in the cloned tree
+    const targetNodes = search(clonedTree, { match: find });
+
+    if (!targetNodes || targetNodes.length !== 1) {
+      return undefined;
+    }
+
+    const targetNode = targetNodes[0];
+
+    const newNode = await makeSubtree({
+      ...this,
+      rootName: clonedTree.name,
+      tree: targetNode,
+      depth,
+    });
+
+    Object.assign(targetNode, newNode);
+
+    const nodeStripped = {
+      ...newNode,
+      children: newNode.children.map((child) => ({
+        ...child,
+        children: [],
+      })),
+    };
+
+    this.tree = clonedTree;
+
+    return nodeStripped;
+  }
+
+  async makeSubtree(config = {}) {
+    this.tree = await makeSubtree({
+      ...this,
+      rootName: this.tree.name || this.rootName,
+      ...config,
+    });
+
+    return this.tree;
+  }
+}
+
+export const dismantle = (text, options) => {
+  return new ChainTree(text, options);
+};
+
+export default ChainTree;

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

@@ -0,0 +1,33 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { dismantle } from './index.js';
+
+vi.mock('../../lib/chatgpt/index.js', () => ({
+  default: vi.fn().mockImplementation((text) => {
+    if (/prompt text to match/.test(text)) {
+      return 'True';
+    }
+    return 'undefined';
+  }),
+}));
+
+const examples = [
+  {
+    name: 'Basic usage',
+    inputs: { text: 'test' },
+    want: { result: {} },
+  },
+];
+
+describe('Dismantle chain', () => {
+  examples.forEach((example) => {
+    it(example.name, async () => {
+      const result = await dismantle(example.inputs.text);
+
+      if (example.want.typeOfResult) {
+        expect(JSON.stringify(result.tree))
+          .toStrictEqual(JSON.stringify(example.want.result));
+      }
+    });
+  });
+});

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

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+
+import { longTestTimeout } from '../../constants/common.js';
+import chatGPT from '../../lib/chatgpt/index.js';
+import { asJSONSchema } from '../../prompts/index.js';
+import toObject from '../../verblets/to-object/index.js';
+
+import list from './index.js';
+
+const examples = [
+  {
+    inputs: { description: '2021 EV cars' },
+    want: { minLength: 10, listContains: 'Model Y' },
+  },
+  {
+    inputs: {
+      description: '2021 EV cars',
+      jsonSchemaQuery:
+        'make, model, releaseDate (ISO),\
+maxRange (miles), batteryCapacity (kWH), startingCost (USD)',
+    },
+    want: { minLength: 10, listModelContains: 'Model Y' },
+  },
+];
+
+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}`;
+    }
+    it(
+      `${example.inputs.text}${jsonSchemaDisplay}`,
+      async () => {
+        let schema;
+        if (example.inputs.jsonSchemaQuery) {
+          schema = await toObject(
+            await chatGPT(asJSONSchema(example.inputs.schemaQuery))
+          );
+        }
+
+        const result = await list(example.inputs.description, {
+          schema,
+        });
+
+        if (example.want.minLength) {
+          expect(result.length).gt(5);
+        }
+
+        if (example.want.listContains) {
+          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)
+            )
+          ).equals(true);
+        }
+      },
+      longTestTimeout
+    );
+  });
+});

package/src/chains/list/index.js

@@ -0,0 +1,161 @@
+/* eslint-disable no-await-in-loop */
+
+import { operationTimeoutMultiplier } from '../../constants/openai.js';
+import chatGPT from '../../lib/chatgpt/index.js';
+import {
+  constants as promptConstants,
+  asObjectWithSchema as asObjectWithSchemaPrompt,
+  generateList as generateListPrompt,
+} 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 outputTransformPrompt = (result, schema) => {
+  return `${contentIsTransformationSource} ${result}
+
+${asObjectWithSchemaPrompt(schema)}
+
+${onlyJSON}`;
+};
+
+const shouldSkipDefault = ({ result, resultsAll } = {}) => {
+  return resultsAll.includes(result);
+};
+
+const shouldStopDefault = ({ queryCount, startTime } = {}) => {
+  return (
+    queryCount > 5 ||
+    new Date() - startTime >
+      operationTimeoutMultiplier *
+        modelService.getBestAvailableModel().requestTimeout
+  );
+};
+
+export const generateList = async function* generateListGenerator(
+  text,
+  options = {}
+) {
+  const resultsAll = [];
+  const resultsAllMap = {};
+  let isDone = false;
+  const {
+    shouldSkip = shouldSkipDefault,
+    shouldStop = shouldStopDefault,
+    model = modelService.getBestAvailableModel(),
+  } = options;
+
+  const startTime = new Date();
+  let queryCount = 0;
+
+  while (!isDone) {
+    const listPrompt = generateListPrompt(text, {
+      ...options,
+      existing: resultsAll,
+    });
+
+    const budget = model.budgetTokens(listPrompt);
+
+    let resultsNew = [];
+    try {
+      const results = await chatGPT(listPrompt, {
+        modelOptions: {
+          maxTokens: budget.completion,
+        },
+        ...options,
+      });
+
+      // debug helper:
+      // console.error(R.sort((a, b) => a.localeCompare(b), await toObject(results)));
+
+      resultsNew = await toObject(results);
+    } catch (error) {
+      if (/The operation was aborted/.test(error.message)) {
+        console.error('Generate list [error]: Aborted');
+        resultsNew = []; // continue
+      } else {
+        console.error(
+          `Generate list [error]: ${error.message}`,
+          listPrompt.slice(0, 100).replace('\n', '\\n')
+        );
+        isDone = true;
+        break;
+      }
+    }
+
+    const resultsNewUnique = resultsNew.filter(
+      (item) => !(item in resultsAllMap)
+    );
+
+    queryCount += 1;
+
+    for (const result of resultsNewUnique) {
+      const perResultControlFactors = {
+        result,
+        resultsAll,
+        resultsNew,
+        queryCount,
+        startTime,
+      };
+
+      if (await shouldStop(perResultControlFactors)) {
+        isDone = true;
+        break;
+      }
+
+      if (!(await shouldSkip(perResultControlFactors))) {
+        resultsAllMap[result] = true;
+        resultsAll.push(result);
+
+        // debug helper:
+        // console.error(R.sort((a, b) => a.localeCompare(b), resultsAll));
+
+        yield result;
+      }
+    }
+
+    const perQueryControlFactors = {
+      result: undefined,
+      resultsAll: [],
+      resultsNew: [],
+      queryCount,
+      startTime,
+    };
+
+    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,
+        ...options,
+      });
+
+      return toObject(resultObject);
+    })
+  );
+
+  return resultObjects;
+};

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

@@ -0,0 +1,68 @@
+import fs from 'node:fs/promises';
+import { describe, expect, it, vi } from 'vitest';
+
+import toObject from '../../verblets/to-object/index.js';
+import list from './index.js';
+
+const loadSchema = async () => {
+  const file = (
+    await fs.readFile('./src/json-schemas/cars-test.json')
+  ).toString();
+
+  return toObject(file);
+};
+
+vi.mock('../../lib/chatgpt/index.js', () => ({
+  default: vi.fn().mockImplementation((text) => {
+    if (/Transform/.test(text) && /Model Y/.test(text)) {
+      return '{"make":"Tesla", "model": "Model Y"}';
+    }
+    if (/EV cars/.test(text)) {
+      return '["Tesla Model Y"]';
+    }
+    return 'undefined';
+  }),
+}));
+
+const examples = [
+  {
+    name: 'Basic usage',
+    inputs: { description: '2021 EV cars' },
+    want: { listContains: /Model Y/ },
+  },
+  {
+    name: 'Basic usage with schema',
+    inputs: {
+      description: '2021 EV cars',
+      schema: loadSchema,
+    },
+    want: { listModelContains: /Model Y/ },
+  },
+];
+
+describe('List verblet', () => {
+  examples.forEach((example) => {
+    it(example.name, async () => {
+      let schema;
+      if (example.inputs.schema) {
+        schema = await example.inputs.schema();
+      }
+      const result = await list(example.inputs.description, {
+        shouldStop: ({ queryCount }) => queryCount > 1,
+        schema,
+      });
+
+      if (example.want.listContains) {
+        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);
+      }
+    });
+  });
+});

package/src/chains/list/schema.json

@@ -0,0 +1,24 @@
+{
+  "name": "list",
+  "description": "Generate a list based on the input text, optionally specifying a JSON schema for the subsequent output to conform to",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "name": {
+        "type": "string",
+        "description": "Name or description of the list to be generated"
+      },
+      "options": {
+        "type": "object",
+        "description": "Options for list generation and transformation",
+        "properties": {
+          "jsonSchema": {
+            "type": "object",
+            "description": "The JSONSchema used for transforming list results"
+          }
+        }
+      }
+    },
+    "required": []
+  }
+}