@far-world-labs/verblets 0.1.1

package/src/prompts/code-features.js

@@ -0,0 +1,28 @@
+import {
+  asJSON,
+  explainAndSeparate,
+  explainAndSeparateJSON,
+} from './constants.js';
+
+export default ({ text, schema }) => {
+  return `Analyze the following code to provide scores for each of the features described below.
+
+For each feature, assign a score between 0.0 and 1.0 based on the criteria outlined in the description. If the code does not exhibit the feature, provide a score of 0.0.
+
+Ensure that all scores are assigned as numeric decimal values, even if the feature is not applicable or not present in the code.
+
+Include only the properties defined in the schema, no comment, description, summary, evaluation or any similar properties.
+
+<json-schema defines-output output-shape>
+${JSON.stringify(schema, null, 2)}
+</json-schema>
+
+<code-to-analyze do-not-output>
+${text}
+</code-to-analyze>
+
+${asJSON}
+
+${explainAndSeparate} ${explainAndSeparateJSON}
+`;
+};

package/src/prompts/constants.js

@@ -0,0 +1,101 @@
+// Basic
+export const asUndefinedByDefault =
+  'If you are unsure, say "undefined" as your answer.';
+export const asBool = `Answer the question either with "true" or "false" as your answer.`;
+export const asNumber = `Answer the question with a number that could be parsed by the JS Number constructor. Do not include formatting, units, digit group separators, or spelled-out numbers in your answer.`;
+export const asJSON = `Respond with a JSON object or array that parses with JSON.parse, with no wrapping code block, and no wrapping XML.`;
+
+// Response steering
+export const useLineNumber =
+  'Include the line number where each check is performed.';
+export const noFalseInformation = 'Do not include false information.';
+export const strictFormat = 'You MUST follow the format as described.';
+export const tryCompleteData =
+  'Err towards giving complete data, even if you have to guess.';
+
+// JSON Output
+export const onlyJSON =
+  'Respond with a JSON object or array that parses with JSON.parse, with no other text and no code block.';
+const onlyJSONArrayBase =
+  'Respond with a JSON array that parses with JSON.parse, with no additional text, no punctuation, and no code block.';
+export const onlyJSONArray = onlyJSONArrayBase;
+export const onlyJSONStringArray = `${onlyJSONArrayBase} The array should only contain text. No additional structure.`;
+export const onlyJSONObjectArray =
+  'Return an array of obects--not strings, and not just the objects.';
+export const onlyJSONStringArrayAlt1 = 'Output an JSON array of strings.';
+export const asSplitIntoJSONArray = 'Split the following to a JSON array.';
+export const onlyFullCode =
+  'Output only the full code generated, with no other text and no code block.';
+export const asNumberWithUnits = `${onlyJSON} It should take the form "{ "value": 42, "unit": "<SI or other unit name>" }".`;
+export const shapeAsJSON =
+  'Even if the input is not JSON, describe as much as possible in a JSON structure that corresponds to the input.';
+
+// Content headers
+export const contentIsQuestion = 'Question:';
+export const contentIsInstructions = 'Instructions:';
+export const contentIsDetails = 'Details:';
+export const contentIsFixes = 'Fixes:';
+export const contentIsMain = 'Focus all efforts on this content here:';
+export const contentToJSON = 'Contents to convert to JSON:';
+export const contentIsExample = 'Use this as example output only:';
+export const contentIsChoices = 'Choose only from the following:';
+export const contentIsTransformationSource = 'Transform the following object:';
+export const contentListCriteria =
+  'Create a list of items with the following description:';
+export const contentListItemCriteria =
+  'Make sure each item meets the following conditions:';
+export const contentListToOmit = 'Do not use any of the following items:';
+export const contentIsExampleObject =
+  'The returned object must look like the following, including all the same properties:';
+export const contentIsSchema =
+  'Make it conform exactly to the following schema:';
+export const contentHasIntent = 'What is the intent of the following message:';
+export const contentIsSortCriteria = 'Sort the following items by:';
+
+// Give explanation
+export const explainAndSeparate =
+  'Give an explanation followed by a succinct answer. The explanation part should come first, and should be at least 100 words. Next, insert a row of 20 equal signs (=) to create a clear separation.';
+export const explainAndSeparateJSON =
+  'The content below the dividing line should only be valid JSON that can be parsed with JSON.parse.';
+export const explainAndSeparatePrimitive = `Next insert the succinctly-stated answer should be below the dividing line and work as a primitive datatype in JS. Be as succinct as possible as it will be parsed by a script.`;
+
+// Reflective
+export const thinkStepByStep = `Let's think step by step`;
+export const identifyUnclearInfo =
+  'Identify any unclear or ambiguous information in your response, and rephrase it for clarity.';
+export const argueAgainstOutput =
+  'Try to argue against your own output and see if you can find any flaws. If so, address them. Walk me through the process';
+export const rateBasic =
+  'Rate on a scale in the decimal from 0-1 how the content satisfies the following criteria. Be candidly critical and strict in your assessment.';
+export const rateSatisfaction =
+  'Rate on a scale in the decimal from 0-1 how well you satisfied each point in the initial prompt. Be very critical, no need to justify yourself.';
+export const rewriteBasedOnRating = 'If 0.3 or lower, rewrite to address.';
+export const requestAdditionalInput =
+  'What additional input do you need from me to help you write better output?';
+export const summarizeRequest =
+  'Please summarise what I am asking for you before you begin your answer.';
+
+// Analytical
+export const considerProsCons =
+  'Consider both pros and cons before arriving at a conclusion.';
+export const provideExamples =
+  'Provide specific examples to illustrate your point.';
+export const explainReasoning = 'Explain the reasoning behind your answer.';
+export const alternativeSolutions =
+  'If there are any alternative solutions or perspectives, please share them.';
+export const explainToChild = 'How would you explain this topic to a child?';
+export const identifyAssumptions = 'What assumptions are you making?';
+export const alternativeInterpretations = 'How else could this be interpreted?';
+
+// Evidence-Based
+export const evidenceSupportsView = 'What evidence supports your view?';
+export const expertResponse = 'How would an expert in this field respond?';
+export const limitationsOfApproach =
+  'What are the limitations of your approach?';
+export const missingInformation = 'What information is still missing?';
+export const evaluateDifferingViews = 'How would you evaluate differing views?';
+export const confidenceInResponse = 'How confident are you in your response?';
+export const lessKnowledgeResponse =
+  'How would you answer this if you knew less about the topic?';
+export const analogyForUnderstanding =
+  'Come up with an analogy to make this easier to understand.';

package/src/prompts/features-json-schema.js

@@ -0,0 +1,27 @@
+const makeFeatureDefinition = ({ name, criteria, score0, score1 }) => {
+  const descriptionPrompt = `criteria: "${criteria}", scoring: "${score0} ${score1}"`;
+
+  return {
+    [name]: {
+      type: 'number',
+      minimum: 0,
+      maximum: 1,
+      description: descriptionPrompt,
+    },
+  };
+};
+
+export default (features) => {
+  if (!features?.length) {
+    throw new Error('Features json schema [error]: Features list not defined');
+  }
+
+  return {
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    type: 'object',
+    properties: features.reduce((acc, feature) => {
+      return { ...acc, ...makeFeatureDefinition(feature) };
+    }, {}),
+    required: features.map((f) => f.name),
+  };
+};

package/src/prompts/generate-collection.js

@@ -0,0 +1,26 @@
+import {
+  onlyJSON,
+  onlyJSONObjectArray,
+  contentListItemCriteria,
+  tryCompleteData,
+} from './constants.js';
+import asObjectWithSchema from './as-object-with-schema.js';
+
+const schemaDefault = {
+  type: 'object',
+  properties: {
+    name: {
+      type: 'string',
+    },
+  },
+};
+
+export default (text, { schema = schemaDefault } = {}) => {
+  return `Make an array of "${text}" objects.
+
+${contentListItemCriteria}
+ - ${asObjectWithSchema(schema)}
+ - ${tryCompleteData}
+
+${onlyJSON} ${onlyJSONObjectArray}`;
+};

package/src/prompts/generate-list.js

@@ -0,0 +1,48 @@
+import {
+  contentIsDetails,
+  contentListCriteria,
+  contentListItemCriteria,
+  contentListToOmit,
+  onlyJSONStringArray,
+} from './constants.js';
+import wrapVariable from './wrap-variable.js';
+
+const instruction = 'Please continue building the list.';
+
+const targetNewItemsCountDefault = 10;
+
+export default (
+  description,
+  {
+    existing = [],
+    attachments = {},
+    fixes = '',
+    targetNewItemsCount = targetNewItemsCountDefault,
+  } = {}
+) => {
+  const existingJoined = JSON.stringify(existing, null, 2);
+
+  const attachmentsJoined = Object.entries(attachments).map(([key, value]) => {
+    return `${wrapVariable(value, { tag: 'reference-material', name: key })}
+`;
+  });
+
+  return `${onlyJSONStringArray}
+${contentListCriteria} ${wrapVariable(description, { tag: 'criteria' })}
+
+${attachmentsJoined}
+
+${contentListToOmit} ${wrapVariable(existingJoined, { tag: 'omitted' })}
+
+${instruction}
+You must return least ${targetNewItemsCount} unless the items are thoroughly exhausted.
+
+${contentListItemCriteria}
+- Meet the description criteria
+- Not already in the list
+- Not a duplicate or a variant of an existing item
+
+${contentIsDetails} ${wrapVariable(fixes, { tag: 'fixes' })}
+
+${onlyJSONStringArray}`;
+};

package/src/prompts/generate-questions.js

@@ -0,0 +1,19 @@
+import {
+  contentIsQuestion,
+  contentListToOmit,
+  expertResponse,
+  onlyJSONStringArrayAlt1,
+} from './constants.js';
+import wrapVariable from './wrap-variable.js';
+
+export default (text, { existing = [] } = {}) => {
+  const existingJoined = existing.map((item) => `"${item}"`).join(', ');
+
+  return `Instead of answering the following question, I would like you to generate additional questions. Consider interesting perspectives. Consider what information is unknown. ${expertResponse}. Overall, just come up with good questions.
+
+${contentIsQuestion} ${text}
+
+${contentListToOmit} ${wrapVariable(existingJoined, { tag: 'omitted' })}
+
+${onlyJSONStringArrayAlt1} One question per string.`;
+};

package/src/prompts/index.js

@@ -0,0 +1,20 @@
+export * as constants from './constants.js';
+
+export { default as asEnum } from './as-enum.js';
+export { default as asJSONSchema } from './as-json-schema.js';
+export { default as asObjectWithSchema } from './as-object-with-schema.js';
+export { default as asSchemaOrgText } from './as-schema-org-text.js';
+export { default as asSchemaOrgType } from './as-schema-org-type.js';
+export { default as blogPost } from './blog-post.js';
+export { default as generateCollection } from './generate-collection.js';
+export { default as generateList } from './generate-list.js';
+export { default as generateQuestions } from './generate-questions.js';
+export { default as intent } from './intent.js';
+export { default as selectFromThreshold } from './select-from-threshold.js';
+export { default as outputSuccinctNames } from './output-succinct-names.js';
+export { default as wrapVariable } from './wrap-variable.js';
+export { default as sort } from './sort.js';
+export { default as style } from './style.js';
+export { default as tokenBudget } from './token-budget.js';
+export { default as summarize } from './summarize.js';
+export { default as wrapList } from './wrap-list.js';

package/src/prompts/intent.js

@@ -0,0 +1,66 @@
+import fs from 'node:fs/promises';
+
+import { contentIsExample, contentIsSchema, onlyJSON } from './constants.js';
+import wrapVariable from './wrap-variable.js';
+
+const contentIsIntent = 'Give me an intent response for the following:';
+const contentIsOperationOption =
+  'The extracted operation must be one of the following:';
+const contentIsParametersOptions =
+  'The extracted perameters must be from the following options:';
+
+const exampleJSON = `{
+  "queryText": "play some music",
+  "intent": {
+    "operation": "play-music",
+    "displayName": "Play Music"
+  },
+  "parameters": {
+    "genre": "rock"
+  },
+  "optionalParameters": {
+    "artist": "The Beatles"
+  }
+}`;
+
+const intentSchema = JSON.parse(
+  await fs.readFile('./src/json-schemas/intent.json')
+);
+
+/**
+ * Approximates intent recognition like you might find with Wit.ai,
+ * for tasks where you want the model to extract the intent and parameters
+ * so an existing function can compute the result.
+ */
+export default (text, { operations = [], parameters = [] } = {}) => {
+  let operationsSection = '';
+  if (operations.length) {
+    operationsSection = `\n${contentIsOperationOption} ${operations.join(
+      ', '
+    )}\n`;
+  }
+  let parametersSection = '';
+  if (parameters.length) {
+    parametersSection = `\n${contentIsParametersOptions} ${parameters.join(
+      ', '
+    )}\n`;
+  }
+
+  return `
+${contentIsIntent} ${wrapVariable(text ?? 'None given', { tag: 'input' })}
+
+${contentIsSchema} ${wrapVariable(intentSchema ?? 'None given', {
+    tag: 'schema',
+  })}
+
+${contentIsExample} ${wrapVariable(exampleJSON ?? 'None given', {
+    tag: 'example',
+  })}
+${operationsSection ?? ''}${parametersSection ?? ''}
+Ensure the result is sufficiently abstract.
+Include the full list of supplied parameters.
+Don't include optional parameters under "parameters" unless they were found when the intent was parsed.
+
+${onlyJSON}
+`;
+};

package/src/prompts/output-succinct-names.js

@@ -0,0 +1,3 @@
+export default (numWords = 10) => {
+  return `Provide a (<${numWords} words) descriptive name for each result.`;
+};

package/src/prompts/select-from-threshold.js

@@ -0,0 +1,18 @@
+import * as R from 'ramda';
+
+// Returns a modifier function that generates a prompt fragment based on a given value
+/*
+ * let openEndedDegree = findDegreeModifier(openEnded, [
+ *   { threshold: 0.2, degree: 'must not be' },
+ *   { threshold: 0.4, degree: 'must be minimally' },
+ *   { threshold: 0.6, degree: 'must be somewhat' },
+ *   { threshold: 0.8, degree: 'must be very' },
+ *   { threshold: 1.0, degree: 'must be extremely' },
+ * ]);
+ * const openEndedPrompt = `Questions ${openEndedDegree} open-ended. `
+ */
+export default (value, thresholds = []) => {
+  const threshold =
+    thresholds.find((t) => value <= t.threshold) || R.last(thresholds);
+  return threshold.degree;
+};

package/src/prompts/sort.js

@@ -0,0 +1,35 @@
+import wrapVariable from './wrap-variable.js';
+import {
+  contentIsSortCriteria,
+  contentIsMain,
+  contentIsFixes,
+  contentIsDetails,
+  onlyJSONStringArray,
+} from './constants.js';
+
+export const defaultSortDescription = 'alphabetical order';
+export const defaultFixes = 'Ignore duplicates in the list';
+export const defaultSortOrder = 'descending';
+
+export default (
+  {
+    description = defaultSortDescription,
+    fixes = defaultFixes,
+    sortOrder = defaultSortOrder,
+  },
+  list
+) => {
+  const listLines = JSON.stringify(list, undefined, 2);
+
+  return `${contentIsSortCriteria} ${wrapVariable(description, {
+    tag: 'criteria',
+  })}
+
+${contentIsMain} ${wrapVariable(listLines, { tag: 'main-content' })}
+
+${contentIsDetails} ${sortOrder} order
+
+${contentIsFixes} ${wrapVariable(fixes, { tag: 'fixes' })}
+
+${onlyJSONStringArray}`;
+};

package/src/prompts/style.js

@@ -0,0 +1,41 @@
+export default (
+  text,
+  {
+    tone = ['informal'],
+    vocabulary = ['software engineering'],
+    sentenceStructure = ['varied sentence length', 'active voice'],
+    pointOfView = ['first person plural'],
+    noise = 0,
+    minWords = 0,
+    maxWords,
+  } = {}
+) => {
+  const toneModifiers = `Tone: ${tone.join(', ')}`;
+  const vocabularyModifiers = `Vocabulary: ${vocabulary.join(', ')}`;
+  const sentenceStructureModifiers = `Sentence structure: ${sentenceStructure.join(
+    ', '
+  )}`;
+  const pointOfViewModifiers = `Point of view: ${pointOfView.join(', ')}`;
+  const lengthModifier = `Use between ${minWords} and ${
+    maxWords ?? 'any number'
+  } of words`;
+
+  let noiseModifier = '';
+  if (noise > 0.5) {
+    noiseModifier = `Completely reshape the ideas here, don't stick with the original structure. Don't change the meaning of the content though.`;
+  }
+
+  return `Rewrite the following content:
+\`\`\`
+${text}
+\`\`\`
+
+Use the following style:
+${toneModifiers}
+${vocabularyModifiers}
+${sentenceStructureModifiers}
+${pointOfViewModifiers}
+${lengthModifier}
+${noiseModifier}
+`;
+};

package/src/prompts/summarize.js

@@ -0,0 +1,13 @@
+import wrapVariable from './wrap-variable.js';
+import { onlyFullCode } from './constants.js';
+
+export default (text, instructions = '') => {
+  return `Summarize the following content. ${onlyFullCode}
+
+${wrapVariable(instructions, {
+  forceHTML: true,
+  tag: 'summarization-instructions',
+})}
+
+${wrapVariable(text, { forceHTML: true, tag: 'content-to-summarize' })}`;
+};

package/src/prompts/token-budget.js

@@ -0,0 +1,3 @@
+export default (budget = 10) => {
+  return `Keep the output within ${budget} tokens.`;
+};

package/src/prompts/wrap-list.js

@@ -0,0 +1,14 @@
+import wrapVariable from './wrap-variable.js';
+
+export default (
+  list = [],
+  { introText = 'Consider the following items:' } = {}
+) => {
+  const listText = list.map((f, i) => ` - ${i + 1}. ${f}`).join('\n');
+
+  let listFragment = wrapVariable('\n');
+  if (list.length) {
+    listFragment = `${introText} ${wrapVariable(listText)}`;
+  }
+  return listFragment;
+};

package/src/prompts/wrap-variable.js

@@ -0,0 +1,36 @@
+export default (
+  variable,
+  { forceHTML = false, name, tag = 'data', title, fit = 'comfortable' } = {}
+) => {
+  if (!variable) {
+    return '';
+  }
+
+  let nameAttribute = '';
+  if (name) {
+    nameAttribute = `name="${name}"`;
+  }
+
+  let variableResolved = typeof variable !== 'undefined' ? variable : '';
+  if (typeof variable !== 'string') {
+    variableResolved = JSON.stringify(variable, null, 2);
+  }
+
+  const isHTML = /\n/.test(variableResolved) || forceHTML || name;
+  let variableWrapped = !isHTML ? `"${variableResolved}"` : variableResolved;
+  if (isHTML) {
+    let fitChar = '\n';
+    if (fit !== 'comfortable') {
+      fitChar = '';
+    }
+
+    variableWrapped = `<${tag}${nameAttribute}>${fitChar}${variableResolved}${fitChar}</${tag}>`;
+  }
+
+  let titlePrefixed = variableWrapped;
+  if (title && variableResolved.length > 0) {
+    titlePrefixed = `${title} ${variableWrapped}`;
+  }
+
+  return titlePrefixed;
+};

package/src/services/llm-model/index.js

@@ -0,0 +1,114 @@
+import { camelCase, camelCaseTransformMerge } from 'change-case';
+import * as tokenizer from 'gpt-tokenizer';
+
+import Model from './model.js';
+import {
+  frequencyPenalty as frequencyPenaltyConfig,
+  models,
+  presencePenalty as presencePenaltyConfig,
+  temperature as temperatureConfig,
+  topP as topPConfig,
+} from '../../constants/openai.js';
+
+class ModelService {
+  constructor() {
+    this.models = {};
+    this.models = Object.entries(models).reduce(
+      (acc, [key, modelDef]) => ({
+        ...acc,
+        [key]:
+          new Model({
+            ...modelDef,
+            tokenizer: tokenizer.encode,
+          }),
+      }),
+      {}
+    );
+
+    this.bestAvailableModel = this.models.gpt4 ?? this.models.gpt35Turbo;
+    if (process.env.TEST === 'true') {
+      // this.bestAvailableModel = this.models.textDavinci003;
+      this.bestAvailableModel = this.models.gpt35Turbo;
+    }
+  }
+
+  getBestAvailableModel() {
+    return this.bestAvailableModel;
+  }
+
+  updateBestAvailableModel(name) {
+    this.bestAvailableModel = this.getModel(name);
+  }
+
+  getModel(name) {
+    let modelFound = this.getBestAvailableModel();
+    if (name && process.env.TEST !== 'true') {
+      modelFound = this.models[name];
+      if (!modelFound) {
+        throw new Error(`Get model by name [error]: '${name}' not found.`);
+      }
+    }
+    return modelFound;
+  }
+
+  getRequestParameters(options = {}) {
+    const frequencyPenalty = options.frequencyPenalty ?? frequencyPenaltyConfig;
+    const presencePenalty = options.presencePenalty ?? presencePenaltyConfig;
+    const temperature = options.temperature ?? temperatureConfig;
+    const topP = options.topP ?? topPConfig;
+    const { maxTokens, modelName, prompt } = options;
+
+    const modelFound = this.getModel(modelName);
+
+    let maxTokensFound = maxTokens;
+    if (!maxTokens) {
+      maxTokensFound = modelFound.maxTokens - modelFound.toTokens(prompt);
+    }
+
+    return {
+      model: modelFound.name,
+      temperature,
+      max_tokens: maxTokensFound,
+      top_p: topP,
+      frequency_penalty: frequencyPenalty,
+      presence_penalty: presencePenalty,
+    };
+  }
+
+  getRequestConfig(options) {
+    const {
+      tools,
+      toolChoice,
+      modelName,
+      prompt,
+      systemPrompt,
+    } = options;
+
+    const modelFound = this.getModel(modelName);
+
+    let requestPrompt = { prompt: prompt };
+    if (/chat/.test(modelFound.endpoint)) {
+      const userMessage = { role: 'user', content: prompt };
+      const systemMessages = systemPrompt ? [{
+        role: 'system',
+        content: systemPrompt,
+      }] : [];
+      requestPrompt = {
+        messages: [
+          ...systemMessages,
+          userMessage
+        ],
+        tools,
+	tool_choice: (tools && !toolChoice) ? 'auto' : toolChoice,
+      };
+    }
+    const data = this.getRequestParameters(options);
+
+    return {
+      ...requestPrompt,
+      ...data,
+    };
+  }
+}
+
+export default new ModelService();

package/src/services/llm-model/model.js

@@ -0,0 +1,21 @@
+export default class Model {
+  constructor(options) {
+    Object.assign(this, options);
+  }
+
+  toTokens(text) {
+    return this.tokenizer(text);
+  }
+
+  budgetTokens(text, { completionMax = Infinity } = {}) {
+    const prompt = this.toTokens(text).length;
+    const total = this.maxTokens;
+    const completion = Math.min(total - prompt, completionMax);
+
+    return {
+      completion,
+      prompt,
+      total,
+    };
+  }
+}