@ghchinoy/litflow 0.2.8 → 0.3.0

package/src/breadboard/data/recent-boards.ts

@@ -0,0 +1,118 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as idb from "idb";
+import * as BreadboardUI from "../ui/index.js";
+import { SignalArray } from "signal-utils/array";
+import { SignalObject } from "signal-utils/object";
+import { RecentBoard } from "../ui/types/types.js";
+
+interface RecentBoardsDB extends idb.DBSchema {
+  boards: {
+    key: "recent";
+    value: BreadboardUI.Types.RecentBoard[];
+  };
+}
+
+const RECENT_BOARDS_NAME = "recent-boards";
+const RECENT_BOARDS_VERSION = 3;
+
+export class RecentBoardStore {
+  static #instance: RecentBoardStore;
+  static instance() {
+    if (!this.#instance) {
+      this.#instance = new RecentBoardStore();
+    }
+    return this.#instance;
+  }
+
+  readonly boards = new SignalArray<RecentBoard>();
+
+  // Not instantiated directly.
+  private constructor() {}
+
+  async add(board: RecentBoard) {
+    const index = this.boards.findIndex((b) => b.url === board.url);
+    if (index !== -1) {
+      const [existing] = this.boards.splice(index, 1);
+      if (board.title) {
+        existing.title = board.title;
+      }
+      this.boards.unshift(existing);
+    } else {
+      this.boards.unshift(board);
+    }
+
+    if (this.boards.length > 50) {
+      this.boards.length = 50;
+    }
+
+    await this.#store();
+  }
+
+  async remove(url: string) {
+    const index = this.boards.findIndex((b) => b.url === url);
+    if (index !== -1) {
+      this.boards.splice(index, 1);
+      await this.#store();
+    }
+  }
+
+  async setPin(url: string, pinned: boolean) {
+    const board = this.boards.find((b) => b.url === url);
+    if (board) {
+      board.pinned = pinned;
+      await this.#store();
+    }
+  }
+
+  async #store() {
+    const recentBoardsDb = await idb.openDB<RecentBoardsDB>(
+      RECENT_BOARDS_NAME,
+      RECENT_BOARDS_VERSION
+    );
+
+    // Flatten the SignalArray back down so that it can be stored in IDB.
+    const storeBoards = [];
+    for (const board of this.boards) {
+      storeBoards.push({
+        title: board.title,
+        url: board.url,
+        pinned: board.pinned ?? false,
+      });
+    }
+    recentBoardsDb.put("boards", storeBoards, "recent");
+  }
+
+  async restore(): Promise<void> {
+    const recentBoardsDb = await idb.openDB<RecentBoardsDB>(
+      RECENT_BOARDS_NAME,
+      RECENT_BOARDS_VERSION,
+      {
+        upgrade(db) {
+          if (db.objectStoreNames.contains("boards")) return;
+          db.createObjectStore("boards");
+        },
+      }
+    );
+
+    const boards = await recentBoardsDb.get("boards", "recent");
+    if (!boards) {
+      return;
+    }
+
+    for (const board of boards) {
+      this.boards.push(
+        new SignalObject({
+          url: board.url,
+          title: board.title,
+          pinned: board.pinned ?? false,
+        })
+      );
+    }
+  }
+}

package/src/breadboard/data/save-outputs-as-file.ts

@@ -0,0 +1,104 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  DataPart,
+  InlineDataCapabilityPart,
+  Outcome,
+  OutputValues,
+} from "@breadboard-ai/types";
+import { isLLMContentArray } from "./common.js";
+import { createZip } from "littlezipper";
+
+export { saveOutputsAsFile, extensionFromMimeType };
+
+const COMMON_FILE_EXTENSIONS: ReadonlyMap<string, string> = new Map([
+  ["text/plain", "txt"],
+  ["text/html", "html"],
+  ["text/css", "css"],
+  ["text/javascript", "js"],
+  ["text/csv", "csv"],
+  ["text/xml", "xml"],
+  ["text/markdown", "md"],
+  ["application/json", "json"],
+  ["application/ld+json", "jsonld"],
+  ["image/jpeg", "jpg"],
+  ["image/png", "png"],
+  ["audio/mpeg", "mp3"],
+  ["video/mp4", "mp4"],
+  ["video/webm", "webm"],
+  ["application/pdf", "pdf"],
+]);
+
+function extensionFromMimeType(mimeType: string): string {
+  if (!mimeType) {
+    return "";
+  }
+  const normalizedMimeType = mimeType.toLowerCase().split(";")[0].trim();
+  return COMMON_FILE_EXTENSIONS.get(normalizedMimeType) || "";
+}
+
+type FileData = InlineDataCapabilityPart["inlineData"];
+
+async function saveOutputsAsFile(
+  outputs: OutputValues
+): Promise<Outcome<Blob>> {
+  const parts: DataPart[] = [];
+  for (const value of Object.values(outputs)) {
+    if (isLLMContentArray(value)) {
+      for (const content of value) {
+        parts.push(...content.parts);
+      }
+    } else {
+      parts.push({ text: JSON.stringify(value) });
+    }
+  }
+  const files: FileData[] = [];
+  for (const part of parts) {
+    if ("text" in part) {
+      files.push({ mimeType: "text/markdown", data: part.text });
+    } else if ("inlineData" in part) {
+      files.push(part.inlineData);
+    }
+  }
+  if (files.length === 1) {
+    // just save one file
+    const file = files[0];
+    return new Blob([encode(file)], { type: file.mimeType });
+  }
+  const zip = await createZip(
+    files.map((file, index) => ({
+      path: getFilename(file.mimeType, index + 1),
+      data: encode(file),
+    }))
+  );
+  return new Blob([new Uint8Array(zip.buffer as ArrayBuffer)], {
+    type: "application/zip",
+  });
+}
+
+function getFilename(mimeType: string, index: number) {
+  return `file-${index}.${extensionFromMimeType(mimeType)}`;
+}
+
+function encode(file: FileData) {
+  const { mimeType: type, data } = file;
+  if (type.startsWith("text/")) {
+    return data;
+  }
+  return b64toBlob(data);
+}
+
+function b64toBlob(s: string) {
+  const binaryString = atob(s);
+  const len = binaryString.length;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+}

package/src/breadboard/engine/add-run-module.ts

@@ -0,0 +1,168 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { CapabilitiesManagerImpl } from "./runtime/legacy.js";
+import type {
+  InputValues,
+  Kit,
+  MutableGraph,
+  NodeDescriberContext,
+  NodeDescriberResult,
+  NodeHandlerContext,
+  NodeHandlerObject,
+  Schema,
+} from "@breadboard-ai/types";
+import { err, ok } from "@breadboard-ai/utils";
+import { RunnableModuleFactory } from "@breadboard-ai/types/sandbox.js";
+import { Telemetry } from "./telemetry.js";
+
+export { addRunModule };
+
+/**
+ * This is likely too limiting and crude for the long term, but it works well
+ * for the specific use case we need right now.
+ *
+ * In the future, I am imagining something like a capability attenuator, which
+ * allows tuning capabilities for each invoked module, including module
+ * invocation itself.
+ */
+
+function findHandler(handlerName: string, kits?: Kit[]) {
+  const handler = kits
+    ?.flatMap((kit) => Object.entries(kit.handlers))
+    .find(([name]) => name === handlerName)
+    ?.at(1);
+
+  return handler;
+}
+
+function addRunModule(factory: RunnableModuleFactory, kits: Kit[]): Kit[] {
+  const existingRunModule = findHandler("runModule", kits);
+  const originalDescriber =
+    (existingRunModule &&
+    typeof existingRunModule !== "string" &&
+    "describe" in existingRunModule
+      ? existingRunModule.describe
+      : undefined) ??
+    (() => ({
+      outputSchema: {},
+      inputSchema: {},
+    }));
+
+  return [
+    {
+      url: import.meta.url,
+      handlers: {
+        runModule: {
+          invoke: async ({ $module, ...inputs }, context) => {
+            const graph = context.outerGraph;
+
+            const moduleDeclaration = graph?.modules;
+            if (!moduleDeclaration) {
+              return {
+                $error: `Unable to run module: no modules found within board ${context.board?.url || "uknown board"}`,
+              };
+            }
+            const telemetry = Telemetry.create(context);
+            const mutable = await getMutableGraph(context);
+            if (!mutable) {
+              return err(`Unable to create runnable module: invalid graph`);
+            }
+
+            const module = await factory.createRunnableModule(
+              mutable,
+              graph,
+              context,
+              new CapabilitiesManagerImpl(context)
+            );
+            if (!ok(module)) {
+              return err(`Unable to create runnable module: ${module.$error}`);
+            }
+
+            const result = await module.invoke(
+              $module as string,
+              inputs,
+              telemetry
+            );
+            return result as InputValues;
+          },
+          describe: async (
+            inputs?: InputValues,
+            inputSchema?: Schema,
+            outputSchema?: Schema,
+            /**
+             * The context in which the node is described.
+             */
+            context?: NodeDescriberContext
+          ) => {
+            const { $module } = inputs || {};
+            if (context) {
+              const graph = context.outerGraph;
+              const moduleDeclaration = graph?.modules;
+              if ($module && moduleDeclaration) {
+                const mutable = await getMutableGraph(context);
+                if (mutable) {
+                  const module = await factory.createRunnableModule(
+                    mutable,
+                    graph,
+                    context
+                  );
+                  if (ok(module)) {
+                    try {
+                      const result = (await module.describe($module as string, {
+                        inputs,
+                        inputSchema,
+                        outputSchema,
+                      })) as NodeDescriberResult;
+                      return {
+                        inputSchema: {
+                          type: "object",
+                          properties: {
+                            $module: {
+                              type: "string",
+                              title: "Module ID",
+                              behavior: ["config", "module"],
+                            },
+                            ...result.inputSchema.properties,
+                          },
+                        },
+                        outputSchema: result.outputSchema,
+                      };
+                    } catch {
+                      // swallow the error. It's okay that some modules don't have
+                      // custom describers.
+                    }
+                  }
+                }
+              }
+            }
+
+            return originalDescriber(
+              inputs,
+              inputSchema,
+              outputSchema,
+              context
+            );
+          },
+        } satisfies NodeHandlerObject,
+      },
+    },
+    ...kits,
+  ];
+}
+
+async function getMutableGraph(
+  context: NodeHandlerContext
+): Promise<MutableGraph | undefined> {
+  if (!context.graphStore) return;
+  const { graphStore, outerGraph } = context;
+  if (!outerGraph) return;
+  const mainGraphId = graphStore.getByDescriptor(outerGraph);
+  if (!mainGraphId.success) return;
+
+  return graphStore.getLatest(graphStore.get(mainGraphId.result)!);
+}

package/src/breadboard/engine/editor/blank.ts

@@ -0,0 +1,65 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { GraphDescriptor, GraphTag, Schema } from "@breadboard-ai/types";
+
+const llmContentConfig = (type: string) => ({
+  schema: {
+    properties: {
+      context: {
+        type: "array",
+        title: "Context",
+        items: {
+          type: "object",
+          behavior: ["llm-content"],
+        },
+        default:
+          type === "input" ? '[{"role":"user","parts":[{"text":""}]}]' : "null",
+      },
+    },
+    type: "object",
+    required: [],
+  } satisfies Schema,
+});
+
+const BLANK_GRAPH: GraphDescriptor = {
+  title: "Untitled Flow",
+  description: "",
+  version: "0.0.1",
+  nodes: [],
+  edges: [],
+};
+
+const BLANK_LLM_CONTENT_GRAPH: GraphDescriptor = {
+  title: "Untitled Flow",
+  description: "",
+  version: "0.0.1",
+  nodes: [
+    { type: "input", id: "input", configuration: llmContentConfig("input") },
+    { type: "output", id: "output", configuration: llmContentConfig("output") },
+  ],
+  edges: [{ from: "input", out: "context", to: "output", in: "context" }],
+};
+
+/**
+ * Creates a `GraphDescriptor` of a blank graph.
+ */
+export const blank = (): GraphDescriptor => {
+  return structuredClone(BLANK_GRAPH);
+};
+
+/**
+ * Creates a `GraphDescriptor` of a blank graph with inputs/outputs pre-set
+ * to the LLM content array schema.
+ */
+export const blankLLMContent = (...tags: GraphTag[]): GraphDescriptor => {
+  const graph = structuredClone(BLANK_LLM_CONTENT_GRAPH);
+  if (tags.length) {
+    graph.metadata = { tags };
+  }
+  return graph;
+};

package/src/breadboard/engine/editor/edge.ts

@@ -0,0 +1,27 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { EditableEdgeSpec, GraphDescriptor } from "@breadboard-ai/types";
+
+export const findEdgeIndex = (
+  graph: GraphDescriptor,
+  spec: EditableEdgeSpec
+) => {
+  return graph.edges.findIndex((edge) => {
+    return edgesEqual(spec, edge);
+  });
+};
+
+export const edgesEqual = (a: EditableEdgeSpec, b: EditableEdgeSpec) => {
+  return (
+    a.from === b.from &&
+    a.to === b.to &&
+    a.out === b.out &&
+    a.in === b.in &&
+    b.constant === b.constant
+  );
+};

package/src/breadboard/engine/editor/events.ts

@@ -0,0 +1,64 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  AffectedNode,
+  ChangeEventType,
+  ErrorRejection,
+  GraphChangeEvent,
+  GraphChangeRejectEvent,
+  GraphDescriptor,
+  GraphIdentifier,
+  NoChangeRejection,
+  NodeIdentifier,
+} from "@breadboard-ai/types";
+
+/**
+ * This event is dispatched whenever the graph changes due to edits.
+ */
+export class ChangeEvent extends Event implements GraphChangeEvent {
+  static eventName = "graphchange";
+
+  constructor(
+    public readonly graph: GraphDescriptor,
+    public readonly visualOnly: boolean,
+    public readonly changeType: ChangeEventType,
+    public readonly affectedNodes: AffectedNode[],
+    public readonly affectedModules: NodeIdentifier[],
+    public readonly affectedGraphs: GraphIdentifier[],
+    public readonly topologyChange: boolean,
+    public readonly integrationsChange: boolean,
+    public readonly label: string | null
+  ) {
+    super(ChangeEvent.eventName, {
+      bubbles: false,
+      cancelable: true,
+      composed: true,
+    });
+  }
+}
+
+/**
+ * This event is dispatched whenever a proposed change to the graph is
+ * rejected. The rejection may happen for two reasons
+ * - error: the change would create an invalid graph. For instance, adding an edge to a non-existent node.
+ * - nochange: the change is unnecessary, because it results in no actual change to the graph. For example, adding an edge that already exists.
+ */
+export class ChangeRejectEvent extends Event implements GraphChangeRejectEvent {
+  static eventName = "graphchangereject";
+
+  constructor(
+    public graph: GraphDescriptor,
+    public reason: ErrorRejection | NoChangeRejection
+  ) {
+    super(ChangeRejectEvent.eventName, {
+      bubbles: false,
+      cancelable: true,
+      composed: true,
+    });
+  }
+}