from() doesn't flatten AsyncGenerator from async factory functions - requires defer workaround

[tomsseisums]

Working with Gemini API, specifically streaming endpoints that work with AsyncGenerators, I stumbled upon an issue where if an AsyncGenerator is returned from an async factory function, from doesn't flatten it, requiring to jump through defer hoops.

const testSubject$ = new Subject<string>();

async function* asyncGeneratorTest() {
  for (let i = 0; i < 3; i++) {
    yield i
  }
}

async function generatorFactory() {
  return asyncGeneratorTest()
}

// ✅ Works as expected - direct AsyncGenerator
const test$ = testSubject$.pipe(
  concatMap(prompt => from(asyncGeneratorTest()))
)
// Type: Observable<number> ✅

// ❌ Async function breaks the flattening
const test2$ = testSubject$.pipe(
  concatMap(async (prompt) => from(asyncGeneratorTest()))
)
// Type: Observable<Observable<number>> ❌

// ❌ Promise<AsyncGenerator> doesn't get properly handled
const test3$ = testSubject$.pipe(
  concatMap(prompt => from(generatorFactory()))
)
// Type: Observable<AsyncGenerator<number, void, unknown>> ❌

Real-world Use Case

This pattern is common when working with AI/ML streaming APIs. For example, with Google's Gemini API:

const promptSubject$ = new Subject<string>();

const chat = genai.chats.create({ model: 'gemini-2.5-flash' })

// sendMessageStream returns Promise<AsyncGenerator<GenerateContentResponse>>
const output$ = promptSubject$.pipe(
  takeUntilSignal(opts.signal),
  concatMap(async (prompt) => {
    return from(await chat.sendMessageStream({ 
      message: prompt 
    }));
  })
)
// Result: Observable<Observable<GenerateContentResponse>> ❌

Current Workaround

The current solution requires using defer:

const output$ = promptSubject$.pipe(
  takeUntilSignal(opts.signal),
  concatMap(prompt => 
    defer(async () => await brain.sendMessageStream({ message: prompt }))
      .pipe(concatMap(gen => from(gen)))
  )
)
// Result: Observable<GenerateContentResponse> ✅

Expected Behavior

It would be more intuitive if from() could detect when it receives a Promise<AsyncIterable> and handle it appropriately, similar to how it already handles:

• Direct AsyncIterable/AsyncGenerator
• Promise<T> (emits the resolved value)
• Arrays, Observables, etc.

The Root Cause

Currently, when from() receives a Promise, it treats it as "emit the resolved value" rather than checking if that resolved value is itself an AsyncIterable that should be iterated.