ai-functions 2.1.1 → 2.3.0

package/src/ai-promise.ts

@@ -1,7 +1,7 @@
 /**
- * AIPromise - RPC-style promise pipelining for AI functions
+ * AIPromise - Promise pipelining for AI functions
  *
- * Inspired by capnweb's RpcPromise, this enables:
+ * This enables:
  * - Property access tracking for dynamic schema inference
  * - Promise pipelining without await
  * - Magical .map() for batch processing
@@ -30,7 +30,7 @@
  * @packageDocumentation
  */
 
-import { generateObject } from './generate.js'
+import { generateObject, streamObject, streamText } from './generate.js'
 import type { SimpleSchema } from './schema.js'
 import type { FunctionOptions } from './template.js'
 import {
@@ -42,6 +42,37 @@ import {
 } from './batch-map.js'
 import { getModel } from './context.js'
 
+// ============================================================================
+// Streaming Types
+// ============================================================================
+
+/**
+ * Options for streaming
+ */
+export interface StreamOptions {
+  /** Abort signal for cancellation */
+  abortSignal?: AbortSignal
+}
+
+/**
+ * Streaming result wrapper that provides both AsyncIterable interface
+ * and access to the final result
+ */
+export interface StreamingAIPromise<T>
+  extends AsyncIterable<T extends string ? string : Partial<T>> {
+  /** Stream of text chunks (for text generation) */
+  textStream: AsyncIterable<string>
+  /** Stream of partial objects (for object generation) */
+  partialObjectStream: AsyncIterable<Partial<T>>
+  /** Promise that resolves to the final complete result */
+  result: Promise<T>
+  /** Promise interface - then() */
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null
+  ): Promise<TResult1 | TResult2>
+}
+
 // ============================================================================
 // Types
 // ============================================================================
@@ -101,7 +132,7 @@ let resolutionScheduled = false
 // ============================================================================
 
 /**
- * AIPromise - Like capnweb's RpcPromise but for AI functions
+ * AIPromise - Promise wrapper for AI functions
  *
  * Acts as both a Promise AND a stub that:
  * - Tracks property accesses for dynamic schema inference
@@ -203,17 +234,15 @@ export class AIPromise<T> implements PromiseLike<T> {
     const resolvedDeps: Record<string, unknown> = {}
     for (const dep of this._dependencies) {
       const value = await dep.promise.resolve()
-      const key = dep.path.length > 0 ? dep.path.join('.') : `dep_${this._dependencies.indexOf(dep)}`
+      const key =
+        dep.path.length > 0 ? dep.path.join('.') : `dep_${this._dependencies.indexOf(dep)}`
       resolvedDeps[key] = value
     }
 
     // Substitute resolved dependencies into prompt
     let finalPrompt = this._prompt
     for (const [key, value] of Object.entries(resolvedDeps)) {
-      finalPrompt = finalPrompt.replace(
-        new RegExp(`\\$\\{${key}\\}`, 'g'),
-        String(value)
-      )
+      finalPrompt = finalPrompt.replace(new RegExp(`\\$\\{${key}\\}`, 'g'), String(value))
     }
 
     // Build schema from accessed properties
@@ -224,19 +253,41 @@ export class AIPromise<T> implements PromiseLike<T> {
       model: this._options.model || 'sonnet',
       schema,
       prompt: finalPrompt,
-      system: this._options.system,
-      temperature: this._options.temperature,
-      maxTokens: this._options.maxTokens,
+      ...(this._options.system !== undefined && { system: this._options.system }),
+      ...(this._options.temperature !== undefined && { temperature: this._options.temperature }),
+      ...(this._options.maxTokens !== undefined && { maxTokens: this._options.maxTokens }),
     })
 
     // Extract the value based on type
+    // Type assertions here are safe because:
+    // 1. Runtime type checking validates the response structure
+    // 2. The type parameter T corresponds to the expected output type for each mode
     let value = result.object as T
-    if (this._options.type === 'text' && typeof value === 'object' && value !== null && 'text' in value) {
+    if (
+      this._options.type === 'text' &&
+      typeof value === 'object' &&
+      value !== null &&
+      'text' in value
+    ) {
       value = (value as { text: T }).text
-    } else if (this._options.type === 'boolean' && typeof value === 'object' && value !== null && 'answer' in value) {
-      const answer = (value as { answer: string }).answer
-      value = (answer === 'true' || answer === true) as unknown as T
-    } else if ((this._options.type === 'list' || this._options.type === 'extract') && typeof value === 'object' && value !== null && 'items' in value) {
+    } else if (
+      this._options.type === 'boolean' &&
+      typeof value === 'object' &&
+      value !== null &&
+      'answer' in value
+    ) {
+      const answer = (value as { answer: string | boolean }).answer
+      // When type === 'boolean', T is constrained to boolean at the call site.
+      // TypeScript can't express this dependent relationship, so we use a simple cast.
+      // Runtime validation: answer is verified to be 'true', 'false', or boolean.
+      const booleanValue = answer === 'true' || answer === true
+      value = booleanValue as T
+    } else if (
+      (this._options.type === 'list' || this._options.type === 'extract') &&
+      typeof value === 'object' &&
+      value !== null &&
+      'items' in value
+    ) {
       value = (value as { items: T }).items
     }
 
@@ -264,7 +315,11 @@ export class AIPromise<T> implements PromiseLike<T> {
         case 'list':
           return { items: ['List items'] }
         case 'extract':
-          return { items: ['Extracted items'] }
+          return {
+            items: [
+              'Array of extracted items as strings - extract ALL matching items from the text',
+            ],
+          }
         case 'lists':
           return { categories: ['Category names'], data: 'JSON object with categorized lists' }
         case 'boolean':
@@ -343,30 +398,31 @@ export class AIPromise<T> implements PromiseLike<T> {
    * }))
    * ```
    */
-  map<U>(
-    callback: (item: T extends (infer I)[] ? I : T, index: number) => U
-  ): BatchMapPromise<U> {
+  map<U>(callback: (item: T extends (infer I)[] ? I : T, index: number) => U): BatchMapPromise<U> {
     // Create a wrapper that resolves this promise first, then maps
     const mapPromise = new BatchMapPromise<U>([], [], {})
 
     // Override the resolve to first get the list items
-    const originalResolve = mapPromise.resolve.bind(mapPromise)
-    ;(mapPromise as any).resolve = async () => {
-      // First, resolve the list
-      const items = await this.resolve()
-
-      if (!Array.isArray(items)) {
-        throw new Error('Cannot map over non-array result')
-      }
+    // Type assertion: BatchMapPromise.resolve is a public method that we're replacing
+    // with a compatible async function returning Promise<U[]>
+    const self = this
+    Object.defineProperty(mapPromise, 'resolve', {
+      value: async function (): Promise<U[]> {
+        // First, resolve the list
+        const items = await self.resolve()
+
+        if (!Array.isArray(items)) {
+          throw new Error('Cannot map over non-array result')
+        }
 
-      // Now create the actual batch map with the resolved items
-      const actualBatchMap = createBatchMap(
-        items as (T extends (infer I)[] ? I : T)[],
-        callback
-      )
+        // Now create the actual batch map with the resolved items
+        const actualBatchMap = createBatchMap(items as (T extends (infer I)[] ? I : T)[], callback)
 
-      return actualBatchMap.resolve()
-    }
+        return actualBatchMap.resolve()
+      },
+      writable: true,
+      configurable: true,
+    })
 
     return mapPromise
   }
@@ -387,19 +443,24 @@ export class AIPromise<T> implements PromiseLike<T> {
     callback: (item: T extends (infer I)[] ? I : T, index: number) => U
   ): BatchMapPromise<U> {
     const mapPromise = new BatchMapPromise<U>([], [], { immediate: true })
+    const self = this
 
-    ;(mapPromise as any).resolve = async () => {
-      const items = await this.resolve()
-      if (!Array.isArray(items)) {
-        throw new Error('Cannot map over non-array result')
-      }
-      const actualBatchMap = createBatchMap(
-        items as (T extends (infer I)[] ? I : T)[],
-        callback,
-        { immediate: true }
-      )
-      return actualBatchMap.resolve()
-    }
+    Object.defineProperty(mapPromise, 'resolve', {
+      value: async function (): Promise<U[]> {
+        const items = await self.resolve()
+        if (!Array.isArray(items)) {
+          throw new Error('Cannot map over non-array result')
+        }
+        const actualBatchMap = createBatchMap(
+          items as (T extends (infer I)[] ? I : T)[],
+          callback,
+          { immediate: true }
+        )
+        return actualBatchMap.resolve()
+      },
+      writable: true,
+      configurable: true,
+    })
 
     return mapPromise
   }
@@ -408,19 +469,24 @@ export class AIPromise<T> implements PromiseLike<T> {
     callback: (item: T extends (infer I)[] ? I : T, index: number) => U
   ): BatchMapPromise<U> {
     const mapPromise = new BatchMapPromise<U>([], [], { deferred: true })
+    const self = this
 
-    ;(mapPromise as any).resolve = async () => {
-      const items = await this.resolve()
-      if (!Array.isArray(items)) {
-        throw new Error('Cannot map over non-array result')
-      }
-      const actualBatchMap = createBatchMap(
-        items as (T extends (infer I)[] ? I : T)[],
-        callback,
-        { deferred: true }
-      )
-      return actualBatchMap.resolve()
-    }
+    Object.defineProperty(mapPromise, 'resolve', {
+      value: async function (): Promise<U[]> {
+        const items = await self.resolve()
+        if (!Array.isArray(items)) {
+          throw new Error('Cannot map over non-array result')
+        }
+        const actualBatchMap = createBatchMap(
+          items as (T extends (infer I)[] ? I : T)[],
+          callback,
+          { deferred: true }
+        )
+        return actualBatchMap.resolve()
+      },
+      writable: true,
+      configurable: true,
+    })
 
     return mapPromise
   }
@@ -444,7 +510,8 @@ export class AIPromise<T> implements PromiseLike<T> {
         await callback(items[i], i)
       }
     } else {
-      await callback(items as any, 0)
+      // When T is not an array, the conditional type T extends (infer I)[] ? I : T resolves to T
+      await callback(items as T extends (infer I)[] ? I : T, 0)
     }
   }
 
@@ -455,13 +522,44 @@ export class AIPromise<T> implements PromiseLike<T> {
     const items = await this.resolve()
     if (Array.isArray(items)) {
       for (const item of items) {
-        yield item as any
+        // Each array item is the inferred element type I when T extends I[]
+        yield item as T extends (infer I)[] ? I : T
       }
     } else {
-      yield items as any
+      // When T is not an array, the item type is T itself
+      yield items as T extends (infer I)[] ? I : T
     }
   }
 
+  /**
+   * Stream the AI generation - returns chunks as they arrive
+   *
+   * For text generation, yields string chunks.
+   * For object generation, yields partial objects as they build up.
+   * For list generation, yields items as they're generated.
+   *
+   * @example
+   * ```ts
+   * // Text streaming
+   * const stream = write`Write a story`.stream()
+   * for await (const chunk of stream.textStream) {
+   *   process.stdout.write(chunk)
+   * }
+   *
+   * // Object streaming with partial updates
+   * const stream = ai`Generate a recipe`.stream()
+   * for await (const partial of stream.partialObjectStream) {
+   *   console.log('Building:', partial)
+   * }
+   *
+   * // Get final result after streaming
+   * const finalResult = await stream.result
+   * ```
+   */
+  stream(options?: StreamOptions): StreamingAIPromise<T> {
+    return createStreamingAIPromise(this, options)
+  }
+
   /**
    * Promise interface - then()
    */
@@ -517,28 +615,44 @@ export class AIPromise<T> implements PromiseLike<T> {
 // ============================================================================
 
 const PROXY_HANDLERS: ProxyHandler<AIPromise<unknown>> = {
-  get(target, prop: string | symbol, receiver) {
+  get(target, prop: string | symbol, _receiver) {
     // Handle symbols
     if (typeof prop === 'symbol') {
       if (prop === AI_PROMISE_SYMBOL) return true
       if (prop === RAW_PROMISE_SYMBOL) return target
       if (prop === Symbol.asyncIterator) return target[Symbol.asyncIterator].bind(target)
-      return (target as any)[prop]
+      return (target as unknown as Record<symbol, unknown>)[prop]
     }
 
     // Handle promise methods
     if (prop === 'then' || prop === 'catch' || prop === 'finally') {
-      return (target as any)[prop].bind(target)
+      const method = (target as unknown as Record<string, (...args: unknown[]) => unknown>)[prop]
+      return method?.bind(target)
     }
 
     // Handle AIPromise methods
-    if (prop === 'map' || prop === 'forEach' || prop === 'resolve') {
-      return (target as any)[prop].bind(target)
+    if (
+      prop === 'map' ||
+      prop === 'forEach' ||
+      prop === 'resolve' ||
+      prop === 'stream' ||
+      prop === 'addDependency' ||
+      prop === 'mapImmediate' ||
+      prop === 'mapDeferred'
+    ) {
+      const method = (target as unknown as Record<string, (...args: unknown[]) => unknown>)[prop]
+      return method?.bind(target)
     }
 
     // Handle internal properties
-    if (prop.startsWith('_') || prop === 'prompt' || prop === 'path' || prop === 'isResolved' || prop === 'accessedProps') {
-      return (target as any)[prop]
+    if (
+      prop.startsWith('_') ||
+      prop === 'prompt' ||
+      prop === 'path' ||
+      prop === 'isResolved' ||
+      prop === 'accessedProps'
+    ) {
+      return (target as unknown as Record<string, unknown>)[prop]
     }
 
     // Track property access for schema inference
@@ -550,14 +664,11 @@ const PROXY_HANDLERS: ProxyHandler<AIPromise<unknown>> = {
     }
 
     // Return a new AIPromise for the property path
-    return new AIPromise<unknown>(
-      target.prompt,
-      {
-        ...target['_options'],
-        parent: target,
-        propertyPath: [...target.path, prop],
-      }
-    )
+    return new AIPromise<unknown>(target.prompt, {
+      ...target['_options'],
+      parent: target,
+      propertyPath: [...target.path, prop],
+    })
   },
 
   // Prevent mutation
@@ -570,10 +681,11 @@ const PROXY_HANDLERS: ProxyHandler<AIPromise<unknown>> = {
   },
 
   // Handle function calls (for chained methods)
-  apply(target, thisArg, args) {
+  apply(target, _thisArg, args) {
     // If the target is callable (e.g., from a template function), call it
-    if (typeof (target as any)._call === 'function') {
-      return (target as any)._call(...args)
+    const call = (target as unknown as Record<string, unknown>)['_call']
+    if (typeof call === 'function') {
+      return (call as (...args: unknown[]) => unknown)(...args)
     }
     throw new Error('AIPromise is not callable')
   },
@@ -619,10 +731,12 @@ function analyzeRecordingResult(result: unknown, recording: MapRecording): Simpl
       // Infer schema from the promise's accessed properties or type
       if (aiPromise.accessedProps.size > 0) {
         schema[key] = Object.fromEntries(
-          Array.from(aiPromise.accessedProps).map(p => [p, `The ${p}`])
+          Array.from(aiPromise.accessedProps).map((p) => [p, `The ${p}`])
         )
       } else {
-        const type = (aiPromise as any)._options?.type
+        // Access private _options through type-safe assertion
+        const options = (aiPromise as unknown as { _options: AIPromiseOptions })._options
+        const type = options?.type
         if (type === 'boolean') {
           schema[key] = 'true | false'
         } else if (type === 'list') {
@@ -651,7 +765,7 @@ export function isAIPromise(value: unknown): value is AIPromise<unknown> {
     value !== null &&
     typeof value === 'object' &&
     AI_PROMISE_SYMBOL in value &&
-    (value as any)[AI_PROMISE_SYMBOL] === true
+    (value as Record<symbol, unknown>)[AI_PROMISE_SYMBOL] === true
   )
 }
 
@@ -659,10 +773,8 @@ export function isAIPromise(value: unknown): value is AIPromise<unknown> {
  * Get the raw AIPromise from a proxied value
  */
 export function getRawPromise<T>(value: AIPromise<T>): AIPromise<T> {
-  if (RAW_PROMISE_SYMBOL in value) {
-    return (value as any)[RAW_PROMISE_SYMBOL]
-  }
-  return value
+  const raw = (value as unknown as Record<symbol, AIPromise<T> | undefined>)[RAW_PROMISE_SYMBOL]
+  return raw ?? value
 }
 
 // ============================================================================
@@ -679,7 +791,10 @@ export function createTextPromise(prompt: string, options?: FunctionOptions): AI
 /**
  * Create an AIPromise for object generation with dynamic schema
  */
-export function createObjectPromise<T = unknown>(prompt: string, options?: FunctionOptions): AIPromise<T> {
+export function createObjectPromise<T = unknown>(
+  prompt: string,
+  options?: FunctionOptions
+): AIPromise<T> {
   return new AIPromise<T>(prompt, { ...options, type: 'object' })
 }
 
@@ -693,21 +808,30 @@ export function createListPromise(prompt: string, options?: FunctionOptions): AI
 /**
  * Create an AIPromise for multiple lists generation
  */
-export function createListsPromise(prompt: string, options?: FunctionOptions): AIPromise<Record<string, string[]>> {
+export function createListsPromise(
+  prompt: string,
+  options?: FunctionOptions
+): AIPromise<Record<string, string[]>> {
   return new AIPromise<Record<string, string[]>>(prompt, { ...options, type: 'lists' })
 }
 
 /**
  * Create an AIPromise for boolean/is check
  */
-export function createBooleanPromise(prompt: string, options?: FunctionOptions): AIPromise<boolean> {
+export function createBooleanPromise(
+  prompt: string,
+  options?: FunctionOptions
+): AIPromise<boolean> {
   return new AIPromise<boolean>(prompt, { ...options, type: 'boolean' })
 }
 
 /**
  * Create an AIPromise for extraction
  */
-export function createExtractPromise<T = unknown>(prompt: string, options?: FunctionOptions): AIPromise<T[]> {
+export function createExtractPromise<T = unknown>(
+  prompt: string,
+  options?: FunctionOptions
+): AIPromise<T[]> {
   return new AIPromise<T[]>(prompt, { ...options, type: 'extract' })
 }
 
@@ -754,15 +878,14 @@ export function createAITemplateFunction<T>(
   type: AIPromiseOptions['type'],
   baseOptions?: FunctionOptions
 ): ((strings: TemplateStringsArray, ...values: unknown[]) => AIPromise<T>) &
-   ((prompt: string, options?: FunctionOptions) => AIPromise<T>) {
-
+  ((prompt: string, options?: FunctionOptions) => AIPromise<T>) {
   function templateFn(
     promptOrStrings: string | TemplateStringsArray,
     ...args: unknown[]
   ): AIPromise<T> {
     let prompt: string
     let dependencies: Dependency[] = []
-    let options: FunctionOptions = { ...baseOptions }
+    let options: FunctionOptions & { baseSchema?: SimpleSchema } = { ...baseOptions }
 
     if (Array.isArray(promptOrStrings) && 'raw' in promptOrStrings) {
       // Tagged template literal
@@ -779,11 +902,21 @@ export function createAITemplateFunction<T>(
 
     // If we're in recording mode (inside a .map() callback), capture this operation
     if (isInRecordingMode()) {
-      const batchType = type === 'text' ? 'text' : type === 'boolean' ? 'boolean' : type === 'list' ? 'list' : 'object'
-      captureOperation(prompt, batchType, (options as any).baseSchema, options.system)
+      const batchType =
+        type === 'text'
+          ? 'text'
+          : type === 'boolean'
+          ? 'boolean'
+          : type === 'list'
+          ? 'list'
+          : 'object'
+      captureOperation(prompt, batchType, options.baseSchema, options.system)
     }
 
-    const promise = new AIPromise<T>(prompt, { ...options, type })
+    const promise = new AIPromise<T>(prompt, {
+      ...options,
+      ...(type !== undefined && { type }),
+    })
 
     // Add dependencies
     for (const dep of dependencies) {
@@ -793,5 +926,301 @@ export function createAITemplateFunction<T>(
     return promise
   }
 
-  return templateFn as any
+  // Return type matches the declared intersection type
+  return templateFn as ((strings: TemplateStringsArray, ...values: unknown[]) => AIPromise<T>) &
+    ((prompt: string, options?: FunctionOptions) => AIPromise<T>)
+}
+
+// ============================================================================
+// Streaming Implementation
+// ============================================================================
+
+/**
+ * Create a streaming wrapper for an AIPromise
+ *
+ * This function creates a StreamingAIPromise that:
+ * - Resolves dependencies before streaming
+ * - Streams text or partial objects based on the promise type
+ * - Collects the final result as stream is consumed
+ * - Supports cancellation via AbortSignal
+ */
+function createStreamingAIPromise<T>(
+  promise: AIPromise<T>,
+  options?: StreamOptions
+): StreamingAIPromise<T> {
+  const rawPromise = getRawPromise(promise)
+  const promiseOptions = (rawPromise as unknown as { _options: AIPromiseOptions })._options
+  const dependencies = (rawPromise as unknown as { _dependencies: Dependency[] })._dependencies
+
+  // Result promise state
+  let resultResolve: (value: T) => void
+  let resultReject: (error: unknown) => void
+  const resultPromise = new Promise<T>((resolve, reject) => {
+    resultResolve = resolve
+    resultReject = reject
+  })
+
+  // Shared state to prevent multiple API calls
+  let streamStarted = false
+  let cachedTextChunks: string[] | null = null
+  let cachedPartialObjects: Partial<T>[] | null = null
+  let streamError: unknown = null
+  let finalValue: T | undefined
+
+  // Resolve dependencies and prepare the final prompt
+  const preparePrompt = async (): Promise<string> => {
+    const resolvedDeps: Record<string, unknown> = {}
+
+    for (const dep of dependencies) {
+      const value = await dep.promise.resolve()
+      const key = dep.path.length > 0 ? dep.path.join('.') : `dep_${dependencies.indexOf(dep)}`
+      resolvedDeps[key] = value
+    }
+
+    let finalPrompt = rawPromise.prompt
+    for (const [key, value] of Object.entries(resolvedDeps)) {
+      finalPrompt = finalPrompt.replace(new RegExp(`\\$\\{${key}\\}`, 'g'), String(value))
+    }
+
+    return finalPrompt
+  }
+
+  // Build schema from accessed properties
+  const buildSchema = (): SimpleSchema => {
+    return (rawPromise as unknown as { _buildSchema: () => SimpleSchema })._buildSchema()
+  }
+
+  // Extract value based on type (same logic as resolve())
+  // Type assertions here are safe because:
+  // 1. Runtime type checking validates the response structure
+  // 2. The type parameter T corresponds to the expected output type for each mode
+  const extractFinalValue = (obj: unknown): T => {
+    let value = obj as T
+    if (
+      promiseOptions.type === 'text' &&
+      typeof value === 'object' &&
+      value !== null &&
+      'text' in value
+    ) {
+      value = (value as { text: T }).text
+    } else if (
+      promiseOptions.type === 'boolean' &&
+      typeof value === 'object' &&
+      value !== null &&
+      'answer' in value
+    ) {
+      const answer = (value as { answer: string | boolean }).answer
+      // When type === 'boolean', T is constrained to boolean at the call site.
+      // TypeScript can't express this dependent relationship, so we use a simple cast.
+      // Runtime validation: answer is verified to be 'true', 'false', or boolean.
+      const booleanValue = answer === 'true' || answer === true
+      value = booleanValue as T
+    } else if (
+      (promiseOptions.type === 'list' || promiseOptions.type === 'extract') &&
+      typeof value === 'object' &&
+      value !== null &&
+      'items' in value
+    ) {
+      value = (value as { items: T }).items
+    }
+    return value
+  }
+
+  // Create text stream that collects chunks for result
+  async function* createTextStream(): AsyncGenerator<string> {
+    if (cachedTextChunks !== null) {
+      // Return cached chunks if we already streamed
+      for (const chunk of cachedTextChunks) {
+        yield chunk
+      }
+      return
+    }
+
+    if (streamStarted && streamError) {
+      throw streamError
+    }
+
+    streamStarted = true
+    cachedTextChunks = []
+
+    try {
+      const finalPrompt = await preparePrompt()
+
+      const result = await streamText({
+        model: promiseOptions.model || 'sonnet',
+        prompt: finalPrompt,
+        ...(promiseOptions.system !== undefined && { system: promiseOptions.system }),
+        ...(promiseOptions.temperature !== undefined && {
+          temperature: promiseOptions.temperature,
+        }),
+        ...(promiseOptions.maxTokens !== undefined && { maxTokens: promiseOptions.maxTokens }),
+        ...(options?.abortSignal !== undefined && { abortSignal: options.abortSignal }),
+      })
+
+      let fullText = ''
+      for await (const chunk of result.textStream) {
+        cachedTextChunks!.push(chunk)
+        fullText += chunk
+        yield chunk
+      }
+
+      finalValue = fullText as T
+      resultResolve!(finalValue)
+    } catch (error) {
+      streamError = error
+      resultReject!(error)
+      throw error
+    }
+  }
+
+  // Create partial object stream that collects objects for result
+  async function* createPartialObjectStream(): AsyncGenerator<Partial<T>> {
+    if (cachedPartialObjects !== null) {
+      // Return cached partials if we already streamed
+      for (const partial of cachedPartialObjects) {
+        yield partial
+      }
+      return
+    }
+
+    if (streamStarted && streamError) {
+      throw streamError
+    }
+
+    streamStarted = true
+    cachedPartialObjects = []
+
+    try {
+      const finalPrompt = await preparePrompt()
+      const schema = buildSchema()
+
+      const result = await streamObject({
+        model: promiseOptions.model || 'sonnet',
+        schema,
+        prompt: finalPrompt,
+        ...(promiseOptions.system !== undefined && { system: promiseOptions.system }),
+        ...(promiseOptions.temperature !== undefined && {
+          temperature: promiseOptions.temperature,
+        }),
+        ...(promiseOptions.maxTokens !== undefined && { maxTokens: promiseOptions.maxTokens }),
+        ...(options?.abortSignal !== undefined && { abortSignal: options.abortSignal }),
+      })
+
+      let lastPartial: Partial<T> = {} as Partial<T>
+      for await (const partial of result.partialObjectStream) {
+        cachedPartialObjects!.push(partial as Partial<T>)
+        lastPartial = partial as Partial<T>
+        yield partial as Partial<T>
+      }
+
+      finalValue = extractFinalValue(lastPartial)
+      resultResolve!(finalValue)
+    } catch (error) {
+      streamError = error
+      resultReject!(error)
+      throw error
+    }
+  }
+
+  // Create main stream based on type
+  async function* createMainStream(): AsyncGenerator<T extends string ? string : Partial<T>> {
+    if (promiseOptions.type === 'text') {
+      for await (const chunk of createTextStream()) {
+        // When type is 'text', T is string, so the conditional type resolves to string
+        yield chunk as T extends string ? string : Partial<T>
+      }
+    } else if (promiseOptions.type === 'list') {
+      // For lists, yield new items as they appear
+      let lastLength = 0
+      for await (const partial of createPartialObjectStream()) {
+        const items = (partial as { items?: string[] }).items || []
+        for (let i = lastLength; i < items.length; i++) {
+          // List items are strings, cast to the conditional return type
+          yield items[i] as T extends string ? string : Partial<T>
+        }
+        lastLength = items.length
+      }
+    } else {
+      for await (const partial of createPartialObjectStream()) {
+        // For object types, T is not string, so conditional type resolves to Partial<T>
+        yield partial as T extends string ? string : Partial<T>
+      }
+    }
+  }
+
+  // Start the stream collection in background if result is awaited
+  const ensureStreamStarted = (): void => {
+    if (!streamStarted) {
+      // Start consuming the appropriate stream to populate result
+      if (promiseOptions.type === 'text') {
+        ;(async () => {
+          try {
+            for await (const _ of createTextStream()) {
+              // consume
+            }
+          } catch {
+            // Error already handled in stream
+          }
+        })()
+      } else {
+        ;(async () => {
+          try {
+            for await (const _ of createPartialObjectStream()) {
+              // consume
+            }
+          } catch {
+            // Error already handled in stream
+          }
+        })()
+      }
+    }
+  }
+
+  // Create a lazy result promise that starts streaming when accessed
+  const lazyResult: Promise<T> & { _started?: boolean } = Object.assign({
+    then<TResult1 = T, TResult2 = never>(
+      onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+      onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null
+    ): Promise<TResult1 | TResult2> {
+      ensureStreamStarted()
+      return resultPromise.then(onfulfilled, onrejected)
+    },
+    catch<TResult = never>(
+      onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null
+    ): Promise<T | TResult> {
+      ensureStreamStarted()
+      return resultPromise.catch(onrejected)
+    },
+    finally(onfinally?: (() => void) | null): Promise<T> {
+      ensureStreamStarted()
+      return resultPromise.finally(onfinally)
+    },
+    [Symbol.toStringTag]: 'Promise' as const,
+  }) as Promise<T> & { _started?: boolean }
+
+  // Create the streaming object
+  const streamingPromise: StreamingAIPromise<T> = {
+    textStream: {
+      [Symbol.asyncIterator]: createTextStream,
+    },
+
+    partialObjectStream: {
+      [Symbol.asyncIterator]: createPartialObjectStream,
+    },
+
+    result: lazyResult,
+
+    [Symbol.asyncIterator]: createMainStream,
+
+    then<TResult1 = T, TResult2 = never>(
+      onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+      onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null
+    ): Promise<TResult1 | TResult2> {
+      // If result is awaited before stream consumption, start the stream
+      ensureStreamStarted()
+      return resultPromise.then(onfulfilled, onrejected)
+    },
+  }
+
+  return streamingPromise
 }