[pull] master from botpress:master

packages/llmz/e2e/llmz.test.ts

@@ -964,6 +964,23 @@ describe('llmz', { retry: 0, timeout: 10_000 }, () => {
     })
   })
 
+  describe('reasoningEffort', () => {
+    it('executes successfully with reasoningEffort high', async () => {
+      const result = await llmz.executeContext({
+        options: { loop: 1 },
+        exits: [eDone],
+        instructions: 'Say done immediately.',
+        client,
+        model: 'best',
+        reasoningEffort: 'high',
+      })
+
+      assertSuccess(result)
+      expect(result.iterations).toHaveLength(1)
+      expect(result.iterations[0]!.reasoningEffort).toBe('high')
+    })
+  })
+
   describe('handlebars injection', () => {
     it('messages are sanitized handlebars-wise', async () => {
       const injection = `{{SYSTEM_PROMPTññ" injection console.log(process.env);`

packages/llmz/package.json

@@ -2,7 +2,7 @@
   "name": "llmz",
   "type": "module",
   "description": "LLMz - An LLM-native Typescript VM built on top of Zui",
-  "version": "0.0.53",
+  "version": "0.0.54",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

packages/llmz/src/context.ts

@@ -26,6 +26,7 @@ export type IterationParameters = {
   components: Component[]
   model: Models | Models[]
   temperature: number
+  reasoningEffort?: 'low' | 'medium' | 'high' | 'dynamic' | 'none'
 }
 
 export type IterationStatus =
@@ -352,6 +353,7 @@ export namespace Iteration {
     traces: Trace[]
     model: Models | Models[]
     temperature: number
+    reasoningEffort?: 'low' | 'medium' | 'high' | 'dynamic' | 'none'
     variables: Record<string, any>
     started_ts: number
     ended_ts?: number
@@ -425,6 +427,10 @@ export class Iteration implements Serializable<Iteration.JSON> {
     return this._parameters.temperature
   }
 
+  public get reasoningEffort() {
+    return this._parameters.reasoningEffort
+  }
+
   public get exits() {
     const exits = [...this._parameters.exits, ThinkExit]
 
@@ -555,6 +561,7 @@ export class Iteration implements Serializable<Iteration.JSON> {
       code: this.code,
       model: this.model,
       temperature: this.temperature,
+      reasoningEffort: this.reasoningEffort,
       traces: [...this.traces],
       variables: this.variables,
       started_ts: this.started_ts,
@@ -596,6 +603,7 @@ export class Context implements Serializable<Context.JSON> {
   public exits?: ValueOrGetter<Exit[], Context>
   public model?: ValueOrGetter<Models | Models[], Context>
   public temperature: ValueOrGetter<number, Context>
+  public reasoningEffort?: ValueOrGetter<'low' | 'medium' | 'high' | 'dynamic' | 'none', Context>
 
   public version: Prompt = DualModePrompt
   public timeout: number = 60_000 // Default timeout of 60 seconds
@@ -804,6 +812,7 @@ export class Context implements Serializable<Context.JSON> {
     const components = await getValue(this.chat?.components ?? [], this)
     const model = (await getValue(this.model, this)) ?? 'best'
     const temperature = await getValue(this.temperature, this)
+    const reasoningEffort = await getValue(this.reasoningEffort, this)
 
     if (objects && objects.length > 100) {
       throw new Error('Too many objects. Expected at most 100 objects.')
@@ -917,6 +926,7 @@ export class Context implements Serializable<Context.JSON> {
       components,
       model,
       temperature,
+      reasoningEffort,
     }
   }
 
@@ -928,6 +938,7 @@ export class Context implements Serializable<Context.JSON> {
     exits?: ValueOrGetter<Exit[], Context>
     loop?: number
     temperature?: ValueOrGetter<number, Context>
+    reasoningEffort?: ValueOrGetter<'low' | 'medium' | 'high' | 'dynamic' | 'none', Context>
     model?: ValueOrGetter<Models | Models[], Context>
     metadata?: Record<string, any>
     snapshot?: Snapshot
@@ -943,6 +954,7 @@ export class Context implements Serializable<Context.JSON> {
     this.timeout = Math.min(999_999_999, Math.max(0, props.timeout ?? 60_000)) // Default timeout of 60 seconds
     this.loop = props.loop ?? 3
     this.temperature = props.temperature ?? 0.7
+    this.reasoningEffort = props.reasoningEffort
     this.model = props.model ?? 'best'
     this.iterations = []
     this.metadata = props.metadata ?? {}

packages/llmz/src/llmz.test.ts

@@ -1,27 +1,30 @@
 import { Client } from '@botpress/client'
 import { Cognitive, Model } from '@botpress/cognitive'
-import { expect, test } from 'vitest'
+import { describe, expect, test } from 'vitest'
+import { Context } from './context.js'
 import { executeContext } from './llmz.js'
 import { ErrorExecutionResult } from './result.js'
 import { CognitiveError } from './errors.js'
 
+const makeFakeModel = (model: string): Model => ({
+  id: model,
+  name: 'Fake Model',
+  integration: 'botpress',
+  description: 'A fake model for testing',
+  input: { maxTokens: 8192, costPer1MTokens: 0 },
+  output: { maxTokens: 2048, costPer1MTokens: 0 },
+  ref: `fake:${model}`,
+  tags: [],
+})
+
 test('executeContext should early exit when cognitive service is unreachable', async () => {
   class FailingCognitive extends Cognitive {
     public constructor(private _err: Error) {
-      super({ client: new Client({}) })
+      super({ client: new Client({ botId: 'test-bot' }) })
     }
 
     public async getModelDetails(model: string): Promise<Model> {
-      return {
-        id: model,
-        name: 'Failing Cognitive Model',
-        integration: 'botpress',
-        description: 'A failing cognitive model that simulates errors',
-        input: { maxTokens: 8192, costPer1MTokens: 0 },
-        output: { maxTokens: 2048, costPer1MTokens: 0 },
-        ref: `failing:${model}`,
-        tags: [],
-      }
+      return makeFakeModel(model)
     }
 
     public async generateContent(): Promise<never> {
@@ -39,3 +42,25 @@ test('executeContext should early exit when cognitive service is unreachable', a
   expect((output as ErrorExecutionResult).error).toBeInstanceOf(CognitiveError)
   expect(((output as ErrorExecutionResult).error as Error).message).toContain(err.message)
 })
+
+describe('reasoningEffort', () => {
+  test('reasoningEffort is available on iteration and in toJSON', async () => {
+    const ctx = new Context({ reasoningEffort: 'low' })
+    const iteration = await ctx.nextIteration()
+
+    expect(iteration.reasoningEffort).toBe('low')
+
+    const json = iteration.toJSON()
+    expect(json.reasoningEffort).toBe('low')
+  })
+
+  test('reasoningEffort is undefined on iteration when not set', async () => {
+    const ctx = new Context({})
+    const iteration = await ctx.nextIteration()
+
+    expect(iteration.reasoningEffort).toBeUndefined()
+
+    const json = iteration.toJSON()
+    expect(json.reasoningEffort).toBeUndefined()
+  })
+})

packages/llmz/src/llmz.ts

@@ -255,6 +255,15 @@ export type ExecutionProps = {
    * If no temperature is provided, the default temperature of 0.7 will be used.
    */
   temperature?: ValueOrGetter<number, Context>
+
+  /**
+   * The reasoning effort to use for models that support reasoning.
+   * - "none": Disable reasoning (for models with optional reasoning)
+   * - "low" | "medium" | "high": Fixed reasoning effort levels
+   * - "dynamic": Let the provider automatically determine the reasoning effort
+   * If not provided, the model will not use reasoning for models with optional reasoning.
+   */
+  reasoningEffort?: ValueOrGetter<'low' | 'medium' | 'high' | 'dynamic' | 'none', Context>
 } & ExecutionHooks
 
 export const executeContext = async (props: ExecutionProps): Promise<ExecutionResult> => {
@@ -286,6 +295,7 @@ export const _executeContext = async (props: ExecutionProps): Promise<ExecutionR
     snapshot: props.snapshot,
     model: props.model,
     temperature: props.temperature,
+    reasoningEffort: props.reasoningEffort,
   })
 
   try {
@@ -454,6 +464,7 @@ const executeIteration = async ({
       model: model.ref,
       temperature: iteration.temperature,
       responseFormat: 'text',
+      reasoningEffort: iteration.reasoningEffort,
       messages: messages.filter((x) => x.role !== 'system'),
       stopSequences: ctx.version.getStopTokens(),
     })

packages/llmz/src/vm.test.ts

@@ -988,6 +988,66 @@ return {
       expect(result.return_value).toBe(105)
     })
 
+    it('does not leak QuickJS handles on multiple sequential async calls', async () => {
+      // This test reproduces the QuickJS GC assertion failure:
+      //   Assertion failed: list_empty(&rt->gc_obj_list), at quickjs.c JS_FreeRuntime
+      // which occurs when handles from toVmValue are not disposed after deferredPromise.resolve()
+      const code = `
+        const results = []
+        for (let i = 0; i < 10; i++) {
+          const res = await fetchData(i)
+          results.push(res.value)
+        }
+        return results
+      `
+
+      const result = await runAsyncFunction(
+        {
+          fetchData: async (id: number) => {
+            return { value: `item_${id}`, nested: { deep: true } }
+          },
+        },
+        code
+      )
+
+      assert(result.success)
+      expect(result.return_value).toHaveLength(10)
+      expect(result.return_value[0]).toBe('item_0')
+      expect(result.return_value[9]).toBe('item_9')
+    })
+
+    it('does not leak QuickJS handles when async calls throw errors', async () => {
+      // Reproduces handle leak in the error recovery path where
+      // vmValue/errValue handles are not disposed after resolve/reject
+      const code = `
+        const results = []
+        for (let i = 0; i < 5; i++) {
+          try {
+            const res = await riskyCall(i)
+            results.push(res.value)
+          } catch (e) {
+            results.push('error')
+          }
+        }
+        return results
+      `
+
+      const result = await runAsyncFunction(
+        {
+          riskyCall: async (id: number) => {
+            if (id % 2 === 0) {
+              return { value: `ok_${id}`, extra: { data: [1, 2, 3] } }
+            }
+            throw new Error(`fail_${id}`)
+          },
+        },
+        code
+      )
+
+      assert(result.success)
+      expect(result.return_value).toEqual(['ok_0', 'error', 'ok_2', 'error', 'ok_4'])
+    })
+
     it('aborting execution', async () => {
       const code = `
       await longFn()

packages/llmz/src/vm.ts

@@ -267,21 +267,20 @@ export async function runAsyncFunction(
             if (typeof v !== 'function') {
               const propHandle = toVmValue(v)
               vm.setProp(obj, k, propHandle)
-              if (
-                propHandle !== vm.true &&
-                propHandle !== vm.false &&
-                propHandle !== vm.null &&
-                propHandle !== vm.undefined
-              ) {
-                propHandle.dispose()
-              }
+              disposeIfNeeded(propHandle)
             }
           }
           return obj
         }
         return vm.undefined
       }
 
+      const disposeIfNeeded = (handle: any) => {
+        if (handle !== vm.true && handle !== vm.false && handle !== vm.null && handle !== vm.undefined) {
+          handle.dispose()
+        }
+      }
+
       // Helper to bridge functions - handles both sync and async
       const bridgeFunction = (fn: Function, _fnName: string = 'anonymous') => {
         return (...argHandles: any[]) => {
@@ -399,14 +398,7 @@ export async function runAsyncFunction(
             trackedProperties.add(key)
             const arrayHandle = toVmValue(value)
             vm.setProp(vm.global, key, arrayHandle)
-            const shouldDispose =
-              arrayHandle !== vm.true &&
-              arrayHandle !== vm.false &&
-              arrayHandle !== vm.null &&
-              arrayHandle !== vm.undefined
-            if (shouldDispose) {
-              arrayHandle.dispose()
-            }
+            disposeIfNeeded(arrayHandle)
           } else if (typeof value === 'object' && value !== null) {
             trackedProperties.add(key)
 
@@ -433,14 +425,7 @@ export async function runAsyncFunction(
               } else {
                 const propHandle = toVmValue((value as any)[prop])
                 vm.setProp(objHandle, prop, propHandle)
-                const shouldDispose =
-                  propHandle !== vm.true &&
-                  propHandle !== vm.false &&
-                  propHandle !== vm.null &&
-                  propHandle !== vm.undefined
-                if (shouldDispose) {
-                  propHandle.dispose()
-                }
+                disposeIfNeeded(propHandle)
               }
             }
 
@@ -525,14 +510,7 @@ export async function runAsyncFunction(
             trackedProperties.add(key)
             const valueHandle = toVmValue(value)
             vm.setProp(vm.global, key, valueHandle)
-            const shouldDispose =
-              valueHandle !== vm.true &&
-              valueHandle !== vm.false &&
-              valueHandle !== vm.null &&
-              valueHandle !== vm.undefined
-            if (shouldDispose) {
-              valueHandle.dispose()
-            }
+            disposeIfNeeded(valueHandle)
           }
         }
 
@@ -741,6 +719,7 @@ ${transformed.code}
                     }
                     const vmValue = toVmValue(value)
                     deferredPromise.resolve(vmValue)
+                    disposeIfNeeded(vmValue)
                   } catch (err: any) {
                     // If abort was triggered, the abort listener already rejected the promise
                     if (signal?.aborted) {
@@ -886,10 +865,12 @@ ${transformed.code}
               const value = await hostPromise
               const vmValue = toVmValue(value)
               deferredPromise.resolve(vmValue)
+              disposeIfNeeded(vmValue)
             } catch (err2: any) {
               const serialized = err2 instanceof Error ? err2.message : String(err2)
               const errValue = vm.newString(serialized)
               deferredPromise.reject(errValue)
+              errValue.dispose()
             }
           })
         ).catch(() => {})