ai-functions 2.1.3 → 2.4.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
@@ -58,7 +58,8 @@ export interface StreamOptions {
  * 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>> {
+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) */
@@ -131,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
@@ -233,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
@@ -254,9 +253,9 @@ 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
@@ -264,16 +263,31 @@ export class AIPromise<T> implements PromiseLike<T> {
     // 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) {
+    } 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) {
+    } else if (
+      (this._options.type === 'list' || this._options.type === 'extract') &&
+      typeof value === 'object' &&
+      value !== null &&
+      'items' in value
+    ) {
       value = (value as { items: T }).items
     }
 
@@ -301,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':
@@ -380,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
   }
@@ -424,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
   }
@@ -445,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
   }
@@ -481,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)
     }
   }
 
@@ -492,10 +522,12 @@ 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
     }
   }
 
@@ -583,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' || prop === 'stream' || prop === 'addDependency' || prop === 'mapImmediate' || prop === 'mapDeferred') {
-      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
@@ -616,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
@@ -636,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')
   },
@@ -685,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') {
@@ -717,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
   )
 }
 
@@ -725,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
 }
 
 // ============================================================================
@@ -745,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' })
 }
 
@@ -759,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' })
 }
 
@@ -820,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
@@ -845,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) {
@@ -859,7 +926,9 @@ 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>)
 }
 
 // ============================================================================
@@ -880,8 +949,8 @@ function createStreamingAIPromise<T>(
   options?: StreamOptions
 ): StreamingAIPromise<T> {
   const rawPromise = getRawPromise(promise)
-  const promiseOptions = (rawPromise as any)._options as AIPromiseOptions
-  const dependencies = (rawPromise as any)._dependencies as Dependency[]
+  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
@@ -910,10 +979,7 @@ function createStreamingAIPromise<T>(
 
     let finalPrompt = rawPromise.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))
     }
 
     return finalPrompt
@@ -921,7 +987,7 @@ function createStreamingAIPromise<T>(
 
   // Build schema from accessed properties
   const buildSchema = (): SimpleSchema => {
-    return (rawPromise as any)._buildSchema()
+    return (rawPromise as unknown as { _buildSchema: () => SimpleSchema })._buildSchema()
   }
 
   // Extract value based on type (same logic as resolve())
@@ -930,16 +996,31 @@ function createStreamingAIPromise<T>(
   // 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) {
+    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) {
+    } 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) {
+    } else if (
+      (promiseOptions.type === 'list' || promiseOptions.type === 'extract') &&
+      typeof value === 'object' &&
+      value !== null &&
+      'items' in value
+    ) {
       value = (value as { items: T }).items
     }
     return value
@@ -968,10 +1049,12 @@ function createStreamingAIPromise<T>(
       const result = await streamText({
         model: promiseOptions.model || 'sonnet',
         prompt: finalPrompt,
-        system: promiseOptions.system,
-        temperature: promiseOptions.temperature,
-        maxTokens: promiseOptions.maxTokens,
-        abortSignal: options?.abortSignal,
+        ...(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 = ''
@@ -1015,10 +1098,12 @@ function createStreamingAIPromise<T>(
         model: promiseOptions.model || 'sonnet',
         schema,
         prompt: finalPrompt,
-        system: promiseOptions.system,
-        temperature: promiseOptions.temperature,
-        maxTokens: promiseOptions.maxTokens,
-        abortSignal: options?.abortSignal,
+        ...(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>
@@ -1041,7 +1126,8 @@ function createStreamingAIPromise<T>(
   async function* createMainStream(): AsyncGenerator<T extends string ? string : Partial<T>> {
     if (promiseOptions.type === 'text') {
       for await (const chunk of createTextStream()) {
-        yield chunk as any
+        // 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
@@ -1049,13 +1135,15 @@ function createStreamingAIPromise<T>(
       for await (const partial of createPartialObjectStream()) {
         const items = (partial as { items?: string[] }).items || []
         for (let i = lastLength; i < items.length; i++) {
-          yield items[i] as any
+          // 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()) {
-        yield partial as any
+        // For object types, T is not string, so conditional type resolves to Partial<T>
+        yield partial as T extends string ? string : Partial<T>
       }
     }
   }
@@ -1089,28 +1177,26 @@ function createStreamingAIPromise<T>(
   }
 
   // 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 }
+  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> = {