another pass through all recipes

generateText -> llm

Author: anotherjesse

typescript/packages/common-builder/src/built-in.ts

@@ -1,19 +1,20 @@
 import { lift, createNodeFactory } from "./module.js";
 import { Value, NodeFactory, CellProxy } from "./types.js";
 
-export function generateText(
+export function llm(
   params: Value<{
-    messages: string[];
+    messages?: string[];
+    prompt?: string;
     system?: string;
     stop?: string;
     max_tokens?: number;
   }>
-): CellProxy<{ pending: boolean; result: string; partial: string; error: any }> {
-  generateTextFactory ||= createNodeFactory({
+): CellProxy<{ pending: boolean; result?: string; partial?: string; error: any }> {
+  llmFactory ||= createNodeFactory({
     type: "builtin",
-    implementation: "generateText",
+    implementation: "llm",
   });
-  return generateTextFactory(params);
+  return llmFactory(params);
 }
 
 export function fetchData<T>(
@@ -52,10 +53,10 @@ export function ifElse<T, U, V>(
 
 let ifElseFactory: NodeFactory<[any, any, any], any> | undefined = undefined;
 
-let generateTextFactory:
+let llmFactory:
   | NodeFactory<
-      { messages: string[]; system?: string; stop?: string; max_tokens?: number },
-      { pending: boolean; result: any; partial: any; error: any }
+      { messages?: string[]; prompt?: string; system?: string; stop?: string; max_tokens?: number },
+      { pending: boolean; result?: string; partial?: string; error: any }
     >
   | undefined = undefined;
 

typescript/packages/common-builder/src/index.ts

@@ -6,7 +6,7 @@ export {
   isolated,
 } from "./module.js";
 export { recipe } from "./recipe.js";
-export { streamData, fetchData, generateText, ifElse, str } from "./built-in.js";
+export { streamData, fetchData, llm, ifElse, str } from "./built-in.js";
 export {
   ID,
   TYPE,

typescript/packages/common-runner/src/builtins/index.ts

@@ -3,14 +3,14 @@ import { type CellImpl } from "../cell.js";
 import { map } from "./map.js";
 import { fetchData } from "./fetch-data.js";
 import { streamData } from "./stream-data.js";
-import { generateText } from "./generate-text.js";
+import { llm } from "./llm.js";
 import { ifElse } from "./if-else.js";
 export const builtins: {
   [key: string]: (recipeCell: CellImpl<any>, node: Node) => void;
 } = {
   map,
   fetchData,
   streamData,
-  generateText,
+  llm,
   ifElse,
 };

typescript/packages/common-runner/src/builtins/generate-text.ts renamed to typescript/packages/common-runner/src/builtins/llm.ts

@@ -23,11 +23,11 @@ import { makeClient, SimpleMessage, SimpleContent } from "../llm-client.js";
  * @param stop - A cell to store (optional) stop sequence.
  * @param max_tokens - A cell to store the maximum number of tokens to generate.
  * 
- * @returns { pending: boolean, result: any, partial: any } - As individual
+ * @returns { pending: boolean, result?: string, partial?: string } - As individual
  *   cells, representing `pending` state, final `result` and incrementally
  *   updating `partial` result.
  */
-export function generateText(
+export function llm(
   recipeCell: CellImpl<any>,
   { inputs, outputs }: Node
 ) {
@@ -41,37 +41,33 @@ export function generateText(
   const inputsCell = cell(inputBindings);
 
   const pending = cell(false);
-  const fullResult = cell<string | undefined>(undefined);
-  const partialResult = cell<string | undefined>(undefined);
+  const result = cell<string | undefined>(undefined);
+  const partial = cell<string | undefined>(undefined);
 
-  const resultCell = cell({
-    pending,
-    result: fullResult,
-    partial: partialResult,
-  });
+  const outputCell = cell({ pending, result, partial });
 
   const outputBindings = mapBindingsToCell(outputs, recipeCell) as any[];
-  sendValueToBinding(recipeCell, outputBindings, resultCell);
+  sendValueToBinding(recipeCell, outputBindings, outputCell);
 
   let currentRun = 0;
 
   const startGeneration: Action = (log: ReactivityLog) => {
     const thisRun = ++currentRun;
 
-    const { system, messages, prompt, stop, max_tokens } = inputsCell.getAsProxy([], log);
+    const { system, messages, prompt, stop, max_tokens } = inputsCell.getAsProxy([], log) ?? {};
 
-    fullResult.setAtPath([], undefined, log);
-    partialResult.setAtPath([], undefined, log);
+    result.setAtPath([], undefined, log);
+    partial.setAtPath([], undefined, log);
 
     if (((prompt === undefined || prompt.length === 0) && (messages === undefined || messages.length === 0)) || system === undefined) {
       pending.setAtPath([], false, log);
       return;
     }
     pending.setAtPath([], true, log);
 
-    const updatePartial = (t: string) => {
+    const updatePartial = (text: string) => {
       if (thisRun != currentRun) return;
-      partialResult.setAtPath([], t, log);
+      partial.setAtPath([], text, log);
     }
 
     let resultPromise = makeClient().sendRequest({
@@ -83,20 +79,20 @@ export function generateText(
     }, updatePartial)
 
     resultPromise
-      .then((result) => {
+      .then((text) => {
         if (thisRun !== currentRun) return;
         // normalizeToCells(result, undefined, log);
 
         pending.setAtPath([], false, log);
-        fullResult.setAtPath([], result, log);
-        partialResult.setAtPath([], result, log);
+        result.setAtPath([], text, log);
+        partial.setAtPath([], text, log);
       }).catch((error) => {
         if (thisRun !== currentRun) return;
 
         console.error("Error generating data", error);
         pending.setAtPath([], false, log);
-        fullResult.setAtPath([], undefined, log);
-        partialResult.setAtPath([], undefined, log);
+        result.setAtPath([], undefined, log);
+        partial.setAtPath([], undefined, log);
       });
   };
 

typescript/packages/common-ui/src/components/common-suggestions.ts

@@ -57,6 +57,8 @@ export class CommonSuggestionsElement extends LitElement {
       }
     };
 
+    // FIXME(ja): Cannot read properties of undefined (reading 'slice')
+    // broken on main - doesn't seem to be regression of the llm changes
     const suggestions = this.suggestions.slice(0, this.limit);
 
     return html`

typescript/packages/lookslike-high-level/src/recipes/annotation.ts

@@ -9,7 +9,7 @@ import {
   NAME,
   TYPE,
   ifElse,
-  generateData,
+  llm,
 } from "@commontools/common-builder";
 import { type Charm, openCharm } from "../data.js";
 import {
@@ -18,9 +18,17 @@ import {
   getCellReferenceOrValue,
 } from "@commontools/common-runner";
 import { suggestions } from "../suggestions.js";
+import { z } from "zod";
 
 const MINIMUM_CONFIDENCE = -1.0;
 
+const Suggestion = z.object({
+  index: z.number(),
+  confidence: z.number(),
+  reason: z.string(),
+});
+type Suggestion = z.infer<typeof Suggestion>;
+
 type CharmInfo = { id: number; name: string; type: string };
 
 // Lifted functions at module scope
@@ -36,11 +44,13 @@ const getCharmInfo = lift(({ charms }) => {
   return charmInfo;
 });
 
-const buildMessages = lift(
+const buildQuery = lift(
   ({ query, charmInfo }) => {
 
-    return [
-      `Given the following user query and list of data charms, return the indices of the charms that are most relevant to the query.
+    return {
+      system: "You are an assistant that helps match user queries to relevant data charms based on their names and types.",
+      messages: [
+        `Given the following user query and list of data charms, return the indices of the charms that are most relevant to the query.
 Consider both the names and types of the charms when making your selection.
 Think broadly, e.g. a stay in a hotel could match a charm called "morning routine", as the user would want to pick a hotel that supports their morning routine.
 
@@ -61,11 +71,32 @@ Respond with only JSON array of suggestions, e.g.
   { index: 5, chosen: "suzy collab", reason: "could this be related to Susan? she appears in several project related lists", confidence: 0.33 }
 ]
 \`\`\`
-`, '```json\n['];
+`, '```json\n['
+      ],
+      stop: '```',
+    };
   });
 
+const grabJson = lift<{ result?: string }, Suggestion[]>(({ result }) => {
+  if (!result) {
+    return [];
+  }
+  const jsonMatch = result.match(/```json\n([\s\S]+?)```/);
+  if (!jsonMatch) {
+    console.error("No JSON found in text:", result);
+    return [];
+  }
+  let rawData = JSON.parse(jsonMatch[1]);
+  let parsedData = z.array(Suggestion).safeParse(rawData);
+  if (!parsedData.success) {
+    console.error("Invalid JSON:", parsedData.error);
+    return [];
+  }
+  return parsedData.data;
+});
+
 const filterMatchingCharms = lift<{
-  matchedIndices: { index: number; confidence: number }[];
+  matchedIndices: Suggestion[];
   charmInfo: CharmInfo[];
 }>(
   ({ matchedIndices, charmInfo }) =>
@@ -168,12 +199,7 @@ export const annotation = recipe<{
   charms: Charm[];
 }>("annotation", ({ query, target, data, charms }) => {
   const charmInfo = getCharmInfo({ charms });
-  const { result: matchedIndices } = generateData<
-    { index: number; confidence: number }[]
-  >({
-    messages: buildMessages({ query, charmInfo }),
-    system: "You are an assistant that helps match user queries to relevant data charms based on their names and types.",
-  });
+  const matchedIndices = grabJson(llm(buildQuery({ query, charmInfo })));
   const matchingCharms = filterMatchingCharms({ matchedIndices, charmInfo });
   const suggestion = findSuggestion({ matchingCharms, data });
 

typescript/packages/lookslike-high-level/src/recipes/generator.ts

@@ -1,5 +1,5 @@
 import { html } from "@commontools/common-html";
-import { recipe, NAME, UI, handler, lift, generateText } from "@commontools/common-builder";
+import { recipe, NAME, UI, handler, lift, llm } from "@commontools/common-builder";
 import { z } from 'zod';
 import zodToJsonSchema from 'zod-to-json-schema';
 
@@ -17,7 +17,7 @@ const prepText = lift(({ prompt }) => {
     }
     return {};
 });
-const grabText = lift(({ partial }) => { return partial || '' })
+const grabText = lift<{ partial?: string }, string>(({ partial }) => { return partial || '' })
 
 
 const prepHTML = lift(({ prompt }) => {
@@ -30,13 +30,13 @@ const prepHTML = lift(({ prompt }) => {
     }
     return {};
 });
-const grabHtml = lift(({ partial, pending }) => {
+const grabHtml = lift<{ partial?: string; pending?: boolean }, string>(({ partial, pending }) => {
     if (!partial) {
         return ""
     }
 
     if (pending) {
-        return `<code>${partial.slice(-1000).replace(/</g, "&lt;").replace(/>/g, "&gt;").slice(-1000)}</code>`;
+        return `<code>${partial.split('\n').slice(-5).join('\n').replace(/</g, "&lt;").replace(/>/g, "&gt;")}</code>`;
     }
 
     const html = partial.match(/```html\n([\s\S]+?)```/)?.[1];
@@ -69,7 +69,7 @@ const prepJSON = lift(({ prompt }) => {
     }
     return {};
 });
-const grabJson = lift<{ result: string }, Character | undefined>(({ result }) => {
+const grabJson = lift<{ result?: string }, Character | undefined>(({ result }) => {
     if (!result) {
         return;
     }
@@ -93,14 +93,13 @@ export const generator = recipe<{ jsonprompt: string; htmlprompt: string; textpr
     ({ jsonprompt, htmlprompt, textprompt, data }) => {
 
         textprompt.setDefault("2 sentence story");
-        const maybeText = grabText(generateText(prepText({ prompt: textprompt })))
+        const maybeText = grabText(llm(prepText({ prompt: textprompt })))
 
         jsonprompt.setDefault("pet");
-        data = grabJson(generateText(prepJSON({ prompt: jsonprompt })));
-        const maybeJSON = jsonify({ data });
+        data = grabJson(llm(prepJSON({ prompt: jsonprompt })));
 
         htmlprompt.setDefault("simple html about recipes");
-        const maybeHTML = grabHtml(generateText(prepHTML({ prompt: htmlprompt })));
+        const maybeHTML = grabHtml(llm(prepHTML({ prompt: htmlprompt })));
 
         return {
             [NAME]: 'data generator',
@@ -119,7 +118,7 @@ export const generator = recipe<{ jsonprompt: string; htmlprompt: string; textpr
                             placeholder="Request to LLM"
                             oncommon-input=${updateValue({ value: jsonprompt })}
                             ></common-input>
-                            <pre>${maybeJSON}</pre>
+                            <pre>${jsonify({ data })}</pre>
 
                             <p>HTML</p>
                             <common-input