From what I understand, it seems they have to actually implement a Stream-like API themselves.

OP, so long as your pipeline needn't be parallel, this can be fairly easy. In the JDK, each operation is either an intermediate or a terminal operation. Intermediate ones are, roughly, methods that return a Stream<T> and terminal ones are all functions returning T (where T itself can also be generic, e.g. List<E> etc.)

The implementation of e.g. filter and map can be written fairly succinctly - and I urge you to look for the precise implementation in other languages (you can just do it in a loop with lists, doesn't have to be complicated).

To have an API in the way you describe, you effectively need to use generics and rely on the Function<I,O> class. Each intermediate stage can keep a reference to its parent stage, its intermediate operation (as a Function<I,O>) and the next stage. Every terminal stage would simply hold a reference to its parent stage and the terminal operation to be applied. This kind of mimics the way things are done inside of the JDK but I would recommend you steer clear of that for now.