@ghchinoy/litflow 0.2.8 → 0.4.0

package/src/breadboard/engine/file-system/ephemeral-blob-store.ts

@@ -0,0 +1,46 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  EphemeralBlobHandle,
+  EphemeralBlobStore,
+  PersistentBlobHandle,
+} from "@breadboard-ai/types";
+
+export { createEphemeralBlobStore };
+
+class EphemeralBlobsImpl implements EphemeralBlobStore {
+  #byBlobHandle: Map<PersistentBlobHandle, EphemeralBlobHandle> = new Map();
+  #byEphemeralHandle: Map<EphemeralBlobHandle, PersistentBlobHandle> =
+    new Map();
+
+  byEphemeralHandle(
+    handle: EphemeralBlobHandle
+  ): PersistentBlobHandle | undefined {
+    return this.#byEphemeralHandle.get(handle);
+  }
+  byPersistentHandle(handle: PersistentBlobHandle): string | undefined {
+    return this.#byBlobHandle.get(handle);
+  }
+  add(
+    blob: Blob,
+    persistent?: PersistentBlobHandle
+  ): { ephemeral: EphemeralBlobHandle; persistent: PersistentBlobHandle } {
+    const ephemeral = URL.createObjectURL(blob);
+    persistent ??= `files:${crypto.randomUUID()}`;
+    this.#byBlobHandle.set(persistent, ephemeral);
+    this.#byEphemeralHandle.set(ephemeral, persistent);
+    return { ephemeral, persistent };
+  }
+  get size() {
+    return this.#byBlobHandle.size;
+  }
+}
+
+function createEphemeralBlobStore(): EphemeralBlobStore {
+  return new EphemeralBlobsImpl();
+}

package/src/breadboard/engine/file-system/in-memory-blob-store.ts

@@ -0,0 +1,87 @@
+// @ts-nocheck
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {
+  FileSystemBlobStore,
+  FileSystemBlobTransform,
+  FileSystemPath,
+  Outcome,
+} from "@breadboard-ai/types";
+import { toInlineDataPart, toStoredDataPart } from "../../data/common.js";
+
+export { InMemoryBlobStore };
+
+class InMemoryBlobStore implements FileSystemBlobStore {
+  handles: Map<FileSystemPath, string[]> = new Map();
+  #inflator: FileSystemBlobTransform;
+  #deflator: FileSystemBlobTransform;
+
+  constructor() {
+    this.#inflator = {
+      transform: async (_, part) => {
+        if ("storedData" in part) {
+          return toInlineDataPart(part);
+        }
+        return part;
+      },
+    };
+    this.#deflator = {
+      transform: async (path, part) => {
+        if ("inlineData" in part) {
+          const stored = await toStoredDataPart(part);
+          this.#registerHandle(path, stored.storedData.handle);
+          return stored;
+        }
+        return part;
+      },
+    };
+  }
+
+  #registerHandle(path: FileSystemPath, handle: string) {
+    let pathHandles = this.handles.get(path);
+    if (!pathHandles) {
+      pathHandles = [];
+      this.handles.set(path, pathHandles);
+    }
+    pathHandles.push(handle);
+  }
+
+  #deleteHandlesForPath(path: FileSystemPath) {
+    const pathHandles = this.handles.get(path);
+    if (pathHandles) {
+      pathHandles.forEach((handle) => URL.revokeObjectURL(handle));
+    }
+    this.handles.delete(path);
+  }
+
+  async delete(): Promise<Outcome<void>> {
+    // blobs are scoped to the session, so we don't ever delete
+    // anything.
+  }
+
+  inflator(): FileSystemBlobTransform {
+    return this.#inflator;
+  }
+
+  deflator(): FileSystemBlobTransform {
+    return this.#deflator;
+  }
+
+  async copy(): Promise<Outcome<void>> {
+    // a no op, there's nothing here to do.
+  }
+
+  async move(): Promise<Outcome<void>> {
+    // a no op, there's nothing here to do.
+  }
+
+  async close(): Promise<void> {
+    [...this.handles.keys()].forEach((path) => {
+      this.#deleteHandlesForPath(path);
+    });
+  }
+}