@ai-sdk-tool/eval 1.0.0 → 1.1.0

package/dist/index.cjs

@@ -30,12 +30,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  bfclMultiTurnBaseBenchmark: () => bfclMultiTurnBaseBenchmark,
+  bfclMultiTurnLongContextBenchmark: () => bfclMultiTurnLongContextBenchmark,
+  bfclMultiTurnMissFuncBenchmark: () => bfclMultiTurnMissFuncBenchmark,
+  bfclMultiTurnMissParamBenchmark: () => bfclMultiTurnMissParamBenchmark,
   bfclMultipleBenchmark: () => bfclMultipleBenchmark,
   bfclParallelBenchmark: () => bfclParallelBenchmark,
   bfclParallelMultipleBenchmark: () => bfclParallelMultipleBenchmark,
   bfclSimpleBenchmark: () => bfclSimpleBenchmark,
   complexFuncBenchBenchmark: () => complexFuncBenchBenchmark,
   evaluate: () => evaluate,
+  executeMultiTurnFuncCall: () => executeMultiTurnFuncCall,
   jsonGenerationBenchmark: () => jsonGenerationBenchmark,
   jsonGenerationSchemaOnlyBenchmark: () => jsonGenerationSchemaOnlyBenchmark
 });
@@ -565,33 +570,33 @@ function createBfclBenchmark(name, description, testDataFile, answerDataFile) {
             );
           }
         };
-        const fixSchema2 = (schema) => {
+        const fixSchema3 = (schema) => {
           if (!schema || typeof schema !== "object") {
             return { type: "object", properties: {} };
           }
-          const copy = Array.isArray(schema) ? schema.map((v) => fixSchema2(v)) : { ...schema };
+          const copy = Array.isArray(schema) ? schema.map((v) => fixSchema3(v)) : { ...schema };
           if (!Array.isArray(copy)) {
             fixSchemaType2(copy);
-            fixSchemaProperties(copy, fixSchema2);
+            fixSchemaProperties(copy, fixSchema3);
             if (copy.items) {
-              copy.items = fixSchema2(copy.items);
+              copy.items = fixSchema3(copy.items);
             }
             return copy;
           }
           return copy;
         };
         const flattenMessages = (messages) => Array.isArray(messages) && messages.some((m) => Array.isArray(m)) ? messages.flat(1) : messages;
-        const sanitizeName = (toolName) => {
+        const sanitizeName2 = (toolName) => {
           const s = toolName.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
           return s.length > 0 ? s : "tool";
         };
-        const buildTransformedTools = (tools, fixSchemaFn) => {
+        const buildTransformedTools2 = (tools, fixSchemaFn) => {
           const nameMap = /* @__PURE__ */ new Map();
           const transformedTools = tools.map((t) => {
             const fixed = fixSchemaFn(t.parameters);
             const isObjectSchema = fixed && typeof fixed === "object" && fixed.type === "object";
             const inputSchema = isObjectSchema ? fixed : { type: "object", properties: {} };
-            const sanitized = sanitizeName(t.name);
+            const sanitized = sanitizeName2(t.name);
             nameMap.set(sanitized, t.name);
             return {
               type: "function",
@@ -613,14 +618,14 @@ function createBfclBenchmark(name, description, testDataFile, answerDataFile) {
             return [];
           }
         };
-        const getSanitizedName = (rawName, transformedTools) => {
+        const getSanitizedName2 = (rawName, transformedTools) => {
           var _a, _b;
           if (typeof rawName === "string" && NUMERIC_STRING_REGEX.test(rawName)) {
             return (_b = (_a = transformedTools[Number(rawName)]) == null ? void 0 : _a.name) != null ? _b : rawName;
           }
           return rawName;
         };
-        const parseToolArgs = (extractedArgs) => {
+        const parseToolArgs2 = (extractedArgs) => {
           if (typeof extractedArgs !== "string") {
             return extractedArgs;
           }
@@ -630,17 +635,17 @@ function createBfclBenchmark(name, description, testDataFile, answerDataFile) {
             return extractedArgs;
           }
         };
-        const restoreToolCalls = (toolCalls, nameMap, transformedTools) => (toolCalls || []).map((c) => {
+        const restoreToolCalls2 = (toolCalls, nameMap, transformedTools) => (toolCalls || []).map((c) => {
           var _a, _b, _c, _d, _e, _f;
           const call = c;
           const rawName = (_a = call.toolName) != null ? _a : call.name;
-          const sanitizedFromIndex = getSanitizedName(
+          const sanitizedFromIndex = getSanitizedName2(
             rawName,
             transformedTools
           );
           const originalName = (_b = nameMap.get(sanitizedFromIndex)) != null ? _b : sanitizedFromIndex;
           const extractedArgs = (_f = (_e = (_d = (_c = call.args) != null ? _c : call.arguments) != null ? _d : call.input) != null ? _e : call.params) != null ? _f : call.parameters;
-          const parsedArgs = parseToolArgs(extractedArgs);
+          const parsedArgs = parseToolArgs2(extractedArgs);
           return {
             ...call,
             toolName: originalName,
@@ -1036,7 +1041,7 @@ function createBfclBenchmark(name, description, testDataFile, answerDataFile) {
             caseLogs.push(`[DEBUG] ${testCase.id}: failed to build debug diff`);
           }
         };
-        const buildToolsMap = (transformedTools) => Object.fromEntries(
+        const buildToolsMap2 = (transformedTools) => Object.fromEntries(
           transformedTools.map((t) => [
             t.name,
             (0, import_ai.tool)({
@@ -1109,11 +1114,11 @@ function createBfclBenchmark(name, description, testDataFile, answerDataFile) {
         const prepareTestCaseData = (testCase) => {
           const { function: tools, question: messages } = testCase;
           const flatMessages = flattenMessages(messages);
-          const { transformedTools, nameMap } = buildTransformedTools(
+          const { transformedTools, nameMap } = buildTransformedTools2(
             tools,
-            fixSchema2
+            fixSchema3
           );
-          const toolsMap = buildToolsMap(transformedTools);
+          const toolsMap = buildToolsMap2(transformedTools);
           return { flatMessages, transformedTools, nameMap, toolsMap };
         };
         const processModelResponse = (options) => {
@@ -1160,7 +1165,7 @@ function createBfclBenchmark(name, description, testDataFile, answerDataFile) {
             testCaseId: testCase.id,
             caseLogs
           });
-          const restoredCalls = restoreToolCalls(
+          const restoredCalls = restoreToolCalls2(
             toolCalls || [],
             nameMap,
             transformedTools
@@ -1310,11 +1315,4416 @@ var bfclParallelMultipleBenchmark = createBfclBenchmark(
   "BFCL_v4_parallel_multiple_possible_answer.jsonl"
 );
 
+// src/benchmarks/bfcl-multi-turn.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = __toESM(require("path"), 1);
+var import_ai2 = require("ai");
+
+// src/multi-turn/classes/gorilla-file-system.ts
+var TRAILING_SLASHES_REGEX = /\/+$/;
+var PATH_TRAILING_SLASHES_REGEX = /\/+$/;
+var WHITESPACE_REGEX = /\s+/;
+var File = class {
+  constructor(name, content = "") {
+    this.name = name;
+    this.content = content;
+  }
+  _write(newContent) {
+    this.content = newContent;
+  }
+  _read() {
+    return this.content;
+  }
+};
+var Directory = class _Directory {
+  constructor(name, parent = null) {
+    this.name = name;
+    this.parent = parent;
+    this.contents = {};
+  }
+  _addFile(fileName, content = "") {
+    this.contents[fileName] = new File(fileName, content);
+  }
+  _addDirectory(dirName) {
+    this.contents[dirName] = new _Directory(dirName, this);
+  }
+  _getItem(itemName) {
+    if (itemName === ".") {
+      return this;
+    }
+    return this.contents[itemName] || null;
+  }
+  _listContents() {
+    return Object.keys(this.contents);
+  }
+};
+var GorillaFileSystem = class _GorillaFileSystem {
+  constructor() {
+    this.root = new Directory("/", null);
+    this._currentDir = this.root;
+  }
+  // biome-ignore lint/suspicious/noExplicitAny: Dynamic scenario loading from JSON
+  _loadScenario(scenario, _longContext = false) {
+    this.root = new Directory("/", null);
+    if (scenario == null ? void 0 : scenario.root) {
+      const rootKeys = Object.keys(scenario.root);
+      if (rootKeys.length > 0) {
+        const rootDirName = rootKeys[0];
+        const rootDir = new Directory(rootDirName, null);
+        this.root = this._loadDirectory(
+          scenario.root[rootDirName].contents || {},
+          rootDir
+        );
+      }
+    }
+    this._currentDir = this.root;
+  }
+  _loadDirectory(current, parent) {
+    for (const [name, data] of Object.entries(
+      current
+    )) {
+      if (data.type === "directory") {
+        const newDir = new Directory(name, parent);
+        const loadedDir = this._loadDirectory(data.contents || {}, newDir);
+        parent.contents[name] = loadedDir;
+      } else if (data.type === "file") {
+        parent.contents[name] = new File(name, data.content || "");
+      }
+    }
+    return parent;
+  }
+  pwd() {
+    const path6 = [];
+    let dir = this._currentDir;
+    while (dir !== null) {
+      path6.push(dir.name);
+      dir = dir.parent;
+    }
+    return { current_working_directory: `/${path6.reverse().join("/")}` };
+  }
+  ls(a = false) {
+    let contents = this._currentDir._listContents();
+    if (!a) {
+      contents = contents.filter((item) => !item.startsWith("."));
+    }
+    return { current_directory_content: contents };
+  }
+  cd(folder) {
+    let normalizedFolder = folder.replace(TRAILING_SLASHES_REGEX, "");
+    if (normalizedFolder === "") {
+      normalizedFolder = "/";
+    }
+    if (normalizedFolder !== "." && normalizedFolder !== ".." && normalizedFolder !== "/" && normalizedFolder.includes("/")) {
+      return {
+        error: `cd: ${normalizedFolder}: Unsupported path. Only one folder level at a time is supported.`
+      };
+    }
+    if (normalizedFolder === "..") {
+      if (this._currentDir.parent) {
+        this._currentDir = this._currentDir.parent;
+        return {};
+      }
+      if (this.root === this._currentDir) {
+        return {
+          error: "Current directory is already the root. Cannot go back."
+        };
+      }
+      return { error: "cd: ..: No such directory" };
+    }
+    const targetDir = this._navigateToDirectory(normalizedFolder);
+    if (targetDir && "error" in targetDir) {
+      return targetDir;
+    }
+    if (targetDir instanceof Directory) {
+      this._currentDir = targetDir;
+      return { current_working_directory: targetDir.name };
+    }
+    return { error: `cd: ${normalizedFolder}: No such file or directory` };
+  }
+  mkdir(dir_name) {
+    if (dir_name in this._currentDir.contents) {
+      return {
+        error: `mkdir: cannot create directory '${dir_name}': File exists`
+      };
+    }
+    this._currentDir._addDirectory(dir_name);
+    return null;
+  }
+  touch(file_name) {
+    if (file_name in this._currentDir.contents) {
+      return { error: `touch: cannot touch '${file_name}': File exists` };
+    }
+    this._currentDir._addFile(file_name);
+    return null;
+  }
+  echo(content, file_name) {
+    if (file_name === void 0 || file_name === null) {
+      return { terminal_output: content };
+    }
+    if (file_name in this._currentDir.contents) {
+      const item = this._currentDir._getItem(file_name);
+      if (item instanceof File) {
+        item._write(content);
+        return null;
+      }
+    }
+    return { error: `echo: cannot write to '${file_name}': No such file` };
+  }
+  cat(file_name) {
+    if (file_name in this._currentDir.contents) {
+      const item = this._currentDir._getItem(file_name);
+      if (item instanceof File) {
+        return { file_content: item._read() };
+      }
+      return { error: `cat: '${file_name}': Is a directory` };
+    }
+    return { error: `cat: '${file_name}': No such file or directory` };
+  }
+  find(path6 = ".", name) {
+    const targetDir = this._navigateToDirectory(path6);
+    if (targetDir && "error" in targetDir) {
+      const errMsg = targetDir.error || "";
+      if (errMsg.startsWith("cd:")) {
+        return { error: errMsg.replace("cd:", "find:") };
+      }
+      return targetDir;
+    }
+    const matches = [];
+    const recursiveSearch = (directory, basePath) => {
+      for (const [itemName, item] of Object.entries(directory.contents)) {
+        const itemPath = `${basePath}/${itemName}`;
+        if (name === void 0 || name === null || itemName.includes(name)) {
+          matches.push(itemPath);
+        }
+        if (item instanceof Directory) {
+          recursiveSearch(item, itemPath);
+        }
+      }
+    };
+    if (targetDir instanceof Directory) {
+      recursiveSearch(targetDir, path6.replace(PATH_TRAILING_SLASHES_REGEX, ""));
+    }
+    return { matches };
+  }
+  wc(file_name, mode = "l") {
+    if (!["l", "w", "c"].includes(mode)) {
+      return { error: `wc: invalid mode '${mode}'` };
+    }
+    if (file_name in this._currentDir.contents) {
+      const file = this._currentDir._getItem(file_name);
+      if (file instanceof File) {
+        const content = file._read();
+        if (mode === "l") {
+          return { count: content.split("\n").length, type: "lines" };
+        }
+        if (mode === "w") {
+          return {
+            count: content.split(WHITESPACE_REGEX).filter(Boolean).length,
+            type: "words"
+          };
+        }
+        if (mode === "c") {
+          return { count: content.length, type: "characters" };
+        }
+      }
+    }
+    return { error: `wc: ${file_name}: No such file or directory` };
+  }
+  sort(file_name) {
+    if (file_name in this._currentDir.contents) {
+      const file = this._currentDir._getItem(file_name);
+      if (file instanceof File) {
+        const content = file._read();
+        const sortedContent = content.split("\n").sort().join("\n");
+        return { sorted_content: sortedContent };
+      }
+    }
+    return { error: `sort: ${file_name}: No such file or directory` };
+  }
+  grep(file_name, pattern) {
+    if (file_name in this._currentDir.contents) {
+      const file = this._currentDir._getItem(file_name);
+      if (file instanceof File) {
+        const content = file._read();
+        const matchingLines = content.split("\n").filter((line) => line.includes(pattern));
+        return { matching_lines: matchingLines };
+      }
+    }
+    return { error: `grep: ${file_name}: No such file or directory` };
+  }
+  du(human_readable = false) {
+    const getSize = (item) => {
+      if (item instanceof File) {
+        return new TextEncoder().encode(item._read()).length;
+      }
+      if (item instanceof Directory) {
+        return Object.values(item.contents).reduce(
+          (acc, child) => acc + getSize(child),
+          0
+        );
+      }
+      return 0;
+    };
+    const totalSize = getSize(this._currentDir);
+    if (human_readable) {
+      const units = ["B", "KB", "MB", "GB", "TB"];
+      let unitIndex = 0;
+      let size = totalSize;
+      while (size >= 1024 && unitIndex < units.length - 1) {
+        size /= 1024;
+        unitIndex++;
+      }
+      return { disk_usage: `${size.toFixed(2)} ${units[unitIndex]}` };
+    }
+    return { disk_usage: `${totalSize} bytes` };
+  }
+  tail(file_name, lines = 10) {
+    if (file_name in this._currentDir.contents) {
+      const file = this._currentDir._getItem(file_name);
+      if (file instanceof File) {
+        const content = file._read().split("\n");
+        const actualLines = Math.min(lines, content.length);
+        const lastLines = content.slice(-actualLines);
+        return { last_lines: lastLines.join("\n") };
+      }
+    }
+    return { error: `tail: ${file_name}: No such file or directory` };
+  }
+  diff(file_name1, file_name2) {
+    if (file_name1 in this._currentDir.contents && file_name2 in this._currentDir.contents) {
+      const file1 = this._currentDir._getItem(file_name1);
+      const file2 = this._currentDir._getItem(file_name2);
+      if (file1 instanceof File && file2 instanceof File) {
+        const content1 = file1._read().split("\n");
+        const content2 = file2._read().split("\n");
+        const diffLines = [];
+        const maxLen = Math.max(content1.length, content2.length);
+        for (let i = 0; i < maxLen; i++) {
+          const line1 = content1[i] || "";
+          const line2 = content2[i] || "";
+          if (line1 !== line2) {
+            diffLines.push(`- ${line1}
++ ${line2}`);
+          }
+        }
+        return { diff_lines: diffLines.join("\n") };
+      }
+    }
+    return {
+      error: `diff: ${file_name1} or ${file_name2}: No such file or directory`
+    };
+  }
+  mv(source, destination) {
+    if (!(source in this._currentDir.contents)) {
+      return {
+        error: `mv: cannot move '${source}': No such file or directory`
+      };
+    }
+    const item = this._currentDir._getItem(source);
+    if (!(item instanceof File || item instanceof Directory)) {
+      return { error: `mv: cannot move '${source}': Not a file or directory` };
+    }
+    if (destination.includes("/")) {
+      return {
+        error: "mv: path not allowed in destination. Provide only a file or directory name."
+      };
+    }
+    if (destination in this._currentDir.contents) {
+      const destItem = this._currentDir._getItem(destination);
+      if (destItem instanceof Directory) {
+        if (source in destItem.contents) {
+          return {
+            error: `mv: cannot move '${source}' to '${destination}/${source}': File exists`
+          };
+        }
+        delete this._currentDir.contents[source];
+        if (item instanceof File) {
+          destItem._addFile(source, item.content);
+        } else {
+          destItem._addDirectory(source);
+          destItem.contents[source].contents = item.contents;
+        }
+        return { result: `'${source}' moved to '${destination}/${source}'` };
+      }
+      return {
+        error: `mv: cannot move '${source}' to '${destination}': Not a directory`
+      };
+    }
+    delete this._currentDir.contents[source];
+    if (item instanceof File) {
+      this._currentDir._addFile(destination, item.content);
+    } else {
+      this._currentDir._addDirectory(destination);
+      this._currentDir.contents[destination].contents = item.contents;
+    }
+    return { result: `'${source}' moved to '${destination}'` };
+  }
+  rm(file_name) {
+    if (file_name in this._currentDir.contents) {
+      delete this._currentDir.contents[file_name];
+      return { result: `'${file_name}' removed` };
+    }
+    return {
+      error: `rm: cannot remove '${file_name}': No such file or directory`
+    };
+  }
+  rmdir(dir_name) {
+    if (dir_name in this._currentDir.contents) {
+      const item = this._currentDir._getItem(dir_name);
+      if (item instanceof Directory) {
+        if (Object.keys(item.contents).length > 0) {
+          return {
+            error: `rmdir: cannot remove '${dir_name}': Directory not empty`
+          };
+        }
+        delete this._currentDir.contents[dir_name];
+        return { result: `'${dir_name}' removed` };
+      }
+      return { error: `rmdir: cannot remove '${dir_name}': Not a directory` };
+    }
+    return {
+      error: `rmdir: cannot remove '${dir_name}': No such file or directory`
+    };
+  }
+  cp(source, destination) {
+    if (!(source in this._currentDir.contents)) {
+      return {
+        error: `cp: cannot copy '${source}': No such file or directory`
+      };
+    }
+    const item = this._currentDir._getItem(source);
+    if (!(item instanceof File || item instanceof Directory)) {
+      return { error: `cp: cannot copy '${source}': Not a file or directory` };
+    }
+    if (destination.includes("/")) {
+      return {
+        error: "cp: path not allowed in destination. Provide only a file or directory name."
+      };
+    }
+    if (destination in this._currentDir.contents) {
+      const destItem = this._currentDir._getItem(destination);
+      if (destItem instanceof Directory) {
+        if (source in destItem.contents) {
+          return {
+            error: `cp: cannot copy '${source}' to '${destination}/${source}': File exists`
+          };
+        }
+        if (item instanceof File) {
+          destItem._addFile(source, item.content);
+        } else {
+          destItem._addDirectory(source);
+          destItem.contents[source].contents = {
+            ...item.contents
+          };
+        }
+        return { result: `'${source}' copied to '${destination}/${source}'` };
+      }
+      return {
+        error: `cp: cannot copy '${source}' to '${destination}': Not a directory`
+      };
+    }
+    if (item instanceof File) {
+      this._currentDir._addFile(destination, item.content);
+    } else {
+      this._currentDir._addDirectory(destination);
+      this._currentDir.contents[destination].contents = {
+        ...item.contents
+      };
+    }
+    return { result: `'${source}' copied to '${destination}'` };
+  }
+  _navigateToDirectory(path6) {
+    if (path6 === null || path6 === ".") {
+      return this._currentDir;
+    }
+    if (path6 === "/") {
+      return this.root;
+    }
+    const dirs = path6.replace(/^\/+|\/+$/g, "").split("/");
+    let tempDir = path6.startsWith("/") ? this.root : this._currentDir;
+    for (const dirName of dirs) {
+      const nextDir = tempDir._getItem(dirName);
+      if (nextDir instanceof Directory) {
+        tempDir = nextDir;
+      } else {
+        return { error: `cd: '${path6}': No such file or directory` };
+      }
+    }
+    return tempDir;
+  }
+  equals(other) {
+    if (!(other instanceof _GorillaFileSystem)) {
+      return false;
+    }
+    return JSON.stringify(this.root) === JSON.stringify(other.root);
+  }
+};
+
+// src/multi-turn/classes/math-api.ts
+var import_decimal = require("decimal.js");
+var MathAPI = class {
+  logarithm(value, base, precision) {
+    try {
+      import_decimal.Decimal.set({ precision });
+      const result = new import_decimal.Decimal(value).ln().div(new import_decimal.Decimal(base).ln());
+      return { result: result.toNumber() };
+    } catch (e) {
+      return { error: String(e) };
+    }
+  }
+  mean(numbers) {
+    if (!numbers.length) {
+      return { error: "Cannot calculate mean of an empty list" };
+    }
+    try {
+      return { result: numbers.reduce((a, b) => a + b, 0) / numbers.length };
+    } catch (_e) {
+      return { error: "All elements in the list must be numbers" };
+    }
+  }
+  standardDeviation(numbers) {
+    if (!numbers.length) {
+      return { error: "Cannot calculate standard deviation of an empty list" };
+    }
+    try {
+      const mean = numbers.reduce((a, b) => a + b, 0) / numbers.length;
+      const variance = numbers.reduce((sum, x) => sum + (x - mean) ** 2, 0) / numbers.length;
+      return { result: Math.sqrt(variance) };
+    } catch (_e) {
+      return { error: "All elements in the list must be numbers" };
+    }
+  }
+  siUnitConversion(value, unitIn, unitOut) {
+    const toMeters = {
+      km: 1e3,
+      m: 1,
+      cm: 0.01,
+      mm: 1e-3,
+      um: 1e-6,
+      nm: 1e-9
+    };
+    const fromMeters = Object.fromEntries(
+      Object.entries(toMeters).map(([k, v]) => [k, 1 / v])
+    );
+    if (typeof value !== "number") {
+      return { error: "Value must be a number" };
+    }
+    if (!(unitIn in toMeters && unitOut in fromMeters)) {
+      return {
+        error: `Conversion from '${unitIn}' to '${unitOut}' is not supported`
+      };
+    }
+    try {
+      const valueInMeters = value * toMeters[unitIn];
+      const result = valueInMeters * fromMeters[unitOut];
+      return { result };
+    } catch (_e) {
+      return { error: "Conversion resulted in a value too large to represent" };
+    }
+  }
+  imperialSiConversion(value, unitIn, unitOut) {
+    const conversion = {
+      cm_to_in: 0.393701,
+      in_to_cm: 2.54,
+      m_to_ft: 3.28084,
+      ft_to_m: 0.3048,
+      m_to_yd: 1.09361,
+      yd_to_m: 0.9144,
+      km_to_miles: 0.621371,
+      miles_to_km: 1.60934,
+      kg_to_lb: 2.20462,
+      lb_to_kg: 0.453592,
+      celsius_to_fahrenheit: 1.8,
+      fahrenheit_to_celsius: 5 / 9
+    };
+    if (typeof value !== "number") {
+      return { error: "Value must be a number" };
+    }
+    if (unitIn === unitOut) {
+      return { result: value };
+    }
+    const conversionKey = `${unitIn}_to_${unitOut}`;
+    if (!(conversionKey in conversion)) {
+      return {
+        error: `Conversion from '${unitIn}' to '${unitOut}' is not supported`
+      };
+    }
+    try {
+      let result;
+      if (unitIn === "celsius" && unitOut === "fahrenheit") {
+        result = value * conversion[conversionKey] + 32;
+      } else if (unitIn === "fahrenheit" && unitOut === "celsius") {
+        result = (value - 32) * conversion[conversionKey];
+      } else {
+        result = value * conversion[conversionKey];
+      }
+      return { result };
+    } catch (_e) {
+      return { error: "Conversion resulted in a value too large to represent" };
+    }
+  }
+  add(a, b) {
+    try {
+      return { result: a + b };
+    } catch (_e) {
+      return { error: "Both inputs must be numbers" };
+    }
+  }
+  subtract(a, b) {
+    try {
+      return { result: a - b };
+    } catch (_e) {
+      return { error: "Both inputs must be numbers" };
+    }
+  }
+  multiply(a, b) {
+    if (typeof a !== "number" || typeof b !== "number") {
+      return { error: "Both inputs must be numbers" };
+    }
+    try {
+      return { result: a * b };
+    } catch (_e) {
+      return { error: "Both inputs must be numbers" };
+    }
+  }
+  divide(a, b) {
+    try {
+      if (b === 0) {
+        return { error: "Cannot divide by zero" };
+      }
+      return { result: a / b };
+    } catch (_e) {
+      return { error: "Both inputs must be numbers" };
+    }
+  }
+  power(base, exponent) {
+    try {
+      return { result: base ** exponent };
+    } catch (_e) {
+      return { error: "Both inputs must be numbers" };
+    }
+  }
+  squareRoot(number, precision) {
+    try {
+      if (number < 0) {
+        return { error: "Cannot calculate square root of a negative number" };
+      }
+      import_decimal.Decimal.set({ precision });
+      const decimalNumber = new import_decimal.Decimal(number);
+      const result = decimalNumber.sqrt();
+      return { result: result.toNumber() };
+    } catch (_e) {
+      return {
+        error: "Input must be a number or computation resulted in an invalid operation"
+      };
+    }
+  }
+  absoluteValue(number) {
+    try {
+      return { result: Math.abs(number) };
+    } catch (_e) {
+      return { error: "Input must be a number" };
+    }
+  }
+  roundNumber(number, decimalPlaces = 0) {
+    try {
+      return {
+        result: Math.round(number * 10 ** decimalPlaces) / 10 ** decimalPlaces
+      };
+    } catch (_e) {
+      return {
+        error: "First input must be a number, second input must be an integer"
+      };
+    }
+  }
+  percentage(part, whole) {
+    try {
+      if (whole === 0) {
+        return { error: "Whole value cannot be zero" };
+      }
+      return { result: part / whole * 100 };
+    } catch (_e) {
+      return { error: "Both inputs must be numbers" };
+    }
+  }
+  minValue(numbers) {
+    if (!numbers.length) {
+      return { error: "Cannot find minimum of an empty list" };
+    }
+    try {
+      return { result: Math.min(...numbers) };
+    } catch (_e) {
+      return { error: "All elements in the list must be numbers" };
+    }
+  }
+  maxValue(numbers) {
+    if (!numbers.length) {
+      return { error: "Cannot find maximum of an empty list" };
+    }
+    try {
+      return { result: Math.max(...numbers) };
+    } catch (_e) {
+      return { error: "All elements in the list must be numbers" };
+    }
+  }
+  sumValues(numbers) {
+    if (!numbers.length) {
+      return { error: "Cannot calculate sum of an empty list" };
+    }
+    try {
+      return { result: numbers.reduce((a, b) => a + b, 0) };
+    } catch (_e) {
+      return { error: "All elements in the list must be numbers" };
+    }
+  }
+};
+
+// src/multi-turn/classes/message-api.ts
+var DEFAULT_STATE = {
+  generated_ids: [],
+  user_count: 4,
+  user_map: {
+    Alice: "USR001",
+    Bob: "USR002",
+    Catherine: "USR003",
+    Daniel: "USR004"
+  },
+  inbox: [
+    { USR002: "My name is Alice. I want to connect." },
+    { USR003: "Could you upload the file?" },
+    { USR004: "Could you upload the file?" }
+  ],
+  message_count: 3,
+  current_user: null
+};
+var MessageAPI = class _MessageAPI {
+  constructor() {
+    this.generatedIds = /* @__PURE__ */ new Set();
+    this.userCount = 4;
+    this.userMap = {};
+    this.inbox = [];
+    this.messageCount = 0;
+    this.currentUser = null;
+  }
+  _loadScenario(scenario, _longContext = false) {
+    const defaultCopy = JSON.parse(JSON.stringify(DEFAULT_STATE));
+    const generatedIdsData = scenario.generated_ids || [];
+    this.generatedIds = new Set(generatedIdsData);
+    this.userCount = scenario.user_count || defaultCopy.user_count;
+    this.userMap = { ...defaultCopy.user_map, ...scenario.user_map };
+    this.inbox = scenario.inbox || defaultCopy.inbox;
+    this.messageCount = scenario.message_count || defaultCopy.message_count;
+    this.currentUser = scenario.current_user || defaultCopy.current_user;
+  }
+  equals(other) {
+    if (!(other instanceof _MessageAPI)) {
+      return false;
+    }
+    const excludeKeys = /* @__PURE__ */ new Set(["_random", "_apiDescription"]);
+    for (const key of Object.keys(this)) {
+      if (key.startsWith("_") || excludeKeys.has(key)) {
+        continue;
+      }
+      const thisValue = this[key];
+      const otherValue = other[key];
+      if (thisValue !== otherValue) {
+        return false;
+      }
+    }
+    return true;
+  }
+  _generateId() {
+    let newId = Math.floor(Math.random() * 9e4) + 1e4;
+    while (this.generatedIds.has(newId)) {
+      newId = Math.floor(Math.random() * 9e4) + 1e4;
+    }
+    this.generatedIds.add(newId);
+    return { new_id: newId };
+  }
+  listUsers() {
+    return { user_list: Object.keys(this.userMap) };
+  }
+  list_users() {
+    return this.listUsers();
+  }
+  getUserId(user) {
+    if (!(user in this.userMap)) {
+      return { error: `User '${user}' not found in the workspace.` };
+    }
+    return { user_id: this.userMap[user] };
+  }
+  messageLogin(userId) {
+    if (!Object.values(this.userMap).includes(userId)) {
+      return { login_status: false, message: `User ID '${userId}' not found.` };
+    }
+    this.currentUser = userId;
+    return {
+      login_status: true,
+      message: `User '${userId}' logged in successfully.`
+    };
+  }
+  messageGetLoginStatus() {
+    return { login_status: !!this.currentUser };
+  }
+  sendMessage(receiverId, message) {
+    if (!this.currentUser) {
+      return { error: "No user is currently logged in." };
+    }
+    if (!Object.values(this.userMap).includes(receiverId)) {
+      return { error: `Receiver ID '${receiverId}' not found.` };
+    }
+    const messageId = this._generateId();
+    this.inbox.push({ [receiverId]: message });
+    this.messageCount += 1;
+    return {
+      sent_status: true,
+      message_id: messageId,
+      message: `Message sent to '${receiverId}' successfully.`
+    };
+  }
+  deleteMessage(receiverId) {
+    if (!this.currentUser) {
+      return { error: "No user is currently logged in." };
+    }
+    for (let i = this.inbox.length - 1; i >= 0; i--) {
+      const message = this.inbox[i];
+      const [receiver] = Object.keys(message);
+      if (receiver === receiverId) {
+        this.inbox.splice(i, 1);
+        return {
+          deleted_status: true,
+          receiver_id: receiver,
+          message: `Receiver ${receiverId}'s latest message deleted successfully.`
+        };
+      }
+    }
+    return { error: `Receiver ID ${receiverId} not found.` };
+  }
+  viewMessagesSent() {
+    if (!this.currentUser) {
+      return { error: "No user is currently logged in." };
+    }
+    const sentMessages = {};
+    for (const message of this.inbox) {
+      const [receiver, content] = Object.entries(message)[0];
+      if (!sentMessages[receiver]) {
+        sentMessages[receiver] = [];
+      }
+      sentMessages[receiver].push(content);
+    }
+    return { messages: sentMessages };
+  }
+  addContact(userName) {
+    if (userName in this.userMap) {
+      return { error: `User name '${userName}' already exists.` };
+    }
+    this.userCount += 1;
+    const userId = `USR${String(this.userCount).padStart(3, "0")}`;
+    if (Object.values(this.userMap).includes(userId)) {
+      return { error: `User ID '${userId}' already exists.` };
+    }
+    this.userMap[userName] = userId;
+    return {
+      added_status: true,
+      user_id: userId,
+      message: `Contact '${userName}' added successfully.`
+    };
+  }
+  searchMessages(keyword) {
+    if (!this.currentUser) {
+      return { error: "No user is currently logged in." };
+    }
+    const keywordLower = keyword.toLowerCase();
+    const results = [];
+    for (const messageData of this.inbox) {
+      const [receiverId, messageContent] = Object.entries(messageData)[0];
+      if (messageContent.toLowerCase().includes(keywordLower)) {
+        results.push({
+          receiver_id: receiverId,
+          message: messageContent
+        });
+      }
+    }
+    return { results };
+  }
+  getMessageStats() {
+    if (!this.currentUser) {
+      return { error: "No user is currently logged in." };
+    }
+    const receivedCount = this.inbox.length;
+    const contacts = new Set(this.inbox.map((msg) => Object.keys(msg)[0]));
+    const totalContacts = contacts.size;
+    return {
+      stats: {
+        received_count: receivedCount,
+        total_contacts: totalContacts
+      }
+    };
+  }
+};
+
+// src/multi-turn/classes/ticket-api.ts
+var DEFAULT_STATE2 = {
+  ticket_queue: [],
+  ticket_counter: 1,
+  current_user: null
+};
+var TicketAPI = class {
+  constructor() {
+    this.ticketQueue = [];
+    this.ticketCounter = 1;
+    this.currentUser = null;
+  }
+  _loadScenario(scenario, _longContext = false) {
+    var _a, _b, _c, _d, _e, _f;
+    const defaultCopy = JSON.parse(
+      JSON.stringify(DEFAULT_STATE2)
+    );
+    this.ticketQueue = (_b = (_a = scenario.ticket_queue) != null ? _a : defaultCopy.ticket_queue) != null ? _b : [];
+    this.ticketCounter = (_d = (_c = scenario.ticket_counter) != null ? _c : defaultCopy.ticket_counter) != null ? _d : 1;
+    this.currentUser = (_f = (_e = scenario.current_user) != null ? _e : defaultCopy.current_user) != null ? _f : null;
+  }
+  create_ticket(title, description = "", priority = 1) {
+    if (!this.currentUser) {
+      return {
+        error: "User not authenticated. Please log in to create a ticket."
+      };
+    }
+    if (priority < 1 || priority > 5) {
+      return { error: "Invalid priority. Priority must be between 1 and 5." };
+    }
+    const ticket = {
+      id: this.ticketCounter,
+      title,
+      description,
+      status: "Open",
+      priority,
+      created_by: this.currentUser
+    };
+    this.ticketQueue.push(ticket);
+    this.ticketCounter += 1;
+    return ticket;
+  }
+  get_ticket(ticket_id) {
+    const ticket = this._findTicket(ticket_id);
+    if (!ticket) {
+      return { error: `Ticket with ID ${ticket_id} not found.` };
+    }
+    return ticket;
+  }
+  close_ticket(ticket_id) {
+    const ticket = this._findTicket(ticket_id);
+    if (!ticket) {
+      return { error: `Ticket with ID ${ticket_id} not found.` };
+    }
+    if (ticket.status === "Closed") {
+      return { error: `Ticket with ID ${ticket_id} is already closed.` };
+    }
+    ticket.status = "Closed";
+    return { status: `Ticket ${ticket_id} has been closed successfully.` };
+  }
+  resolve_ticket(ticket_id, resolution) {
+    const ticket = this._findTicket(ticket_id);
+    if (!ticket) {
+      return { error: `Ticket with ID ${ticket_id} not found.` };
+    }
+    if (ticket.status === "Resolved") {
+      return { error: `Ticket with ID ${ticket_id} is already resolved.` };
+    }
+    ticket.status = "Resolved";
+    ticket.resolution = resolution;
+    return { status: `Ticket ${ticket_id} has been resolved successfully.` };
+  }
+  edit_ticket(ticket_id, updates) {
+    const ticket = this._findTicket(ticket_id);
+    if (!ticket) {
+      return { error: `Ticket with ID ${ticket_id} not found.` };
+    }
+    const validFields = /* @__PURE__ */ new Set(["title", "description", "status", "priority"]);
+    const invalidFields = Object.keys(updates).filter(
+      (field) => !validFields.has(field)
+    );
+    if (invalidFields.length > 0) {
+      return {
+        error: `Invalid fields for update: ${invalidFields.join(", ")}`
+      };
+    }
+    for (const [key, value] of Object.entries(updates)) {
+      if (value !== null) {
+        ticket[key] = value;
+      }
+    }
+    return { status: `Ticket ${ticket_id} has been updated successfully.` };
+  }
+  _findTicket(ticket_id) {
+    return this.ticketQueue.find((ticket) => ticket.id === ticket_id);
+  }
+  ticket_login(username, password) {
+    if (username && password) {
+      this.currentUser = username;
+      return { success: true };
+    }
+    return { success: false };
+  }
+  ticket_get_login_status() {
+    return { login_status: !!this.currentUser };
+  }
+  logout() {
+    if (this.currentUser) {
+      this.currentUser = null;
+      return { success: true };
+    }
+    return { success: false };
+  }
+  get_user_tickets(status) {
+    if (!this.currentUser) {
+      return [
+        { error: "User not authenticated. Please log in to view tickets." }
+      ];
+    }
+    let userTickets = this.ticketQueue.filter(
+      (ticket) => ticket.created_by === this.currentUser
+    );
+    if (status) {
+      userTickets = userTickets.filter(
+        (ticket) => ticket.status.toLowerCase() === status.toLowerCase()
+      );
+    }
+    return userTickets;
+  }
+};
+
+// src/multi-turn/classes/trading-bot.ts
+var CURRENT_TIME = new Date(2024, 8, 1, 10, 30);
+var DEFAULT_STATE3 = {
+  orders: {
+    12345: {
+      id: 12345,
+      order_type: "Buy",
+      symbol: "AAPL",
+      price: 210.65,
+      amount: 10,
+      status: "Completed"
+    },
+    12446: {
+      id: 12446,
+      order_type: "Sell",
+      symbol: "GOOG",
+      price: 2840.56,
+      amount: 5,
+      status: "Pending"
+    }
+  },
+  account_info: {
+    account_id: 12345,
+    balance: 1e4,
+    binding_card: 1974202140965533
+  },
+  authenticated: false,
+  market_status: "Closed",
+  order_counter: 12446,
+  stocks: {
+    AAPL: {
+      price: 227.16,
+      percent_change: 0.17,
+      volume: 2.552,
+      "MA(5)": 227.11,
+      "MA(20)": 227.09
+    },
+    GOOG: {
+      price: 2840.34,
+      percent_change: 0.24,
+      volume: 1.123,
+      "MA(5)": 2835.67,
+      "MA(20)": 2842.15
+    },
+    TSLA: {
+      price: 667.92,
+      percent_change: -0.12,
+      volume: 1.654,
+      "MA(5)": 671.15,
+      "MA(20)": 668.2
+    },
+    MSFT: {
+      price: 310.23,
+      percent_change: 0.09,
+      volume: 3.234,
+      "MA(5)": 309.88,
+      "MA(20)": 310.11
+    },
+    NVDA: {
+      price: 220.34,
+      percent_change: 0.34,
+      volume: 1.234,
+      "MA(5)": 220.45,
+      "MA(20)": 220.67
+    },
+    ALPH: {
+      price: 1320.45,
+      percent_change: -0.08,
+      volume: 1.567,
+      "MA(5)": 1321.12,
+      "MA(20)": 1325.78
+    },
+    OMEG: {
+      price: 457.23,
+      percent_change: 0.12,
+      volume: 2.345,
+      "MA(5)": 456.78,
+      "MA(20)": 458.12
+    },
+    QUAS: {
+      price: 725.89,
+      percent_change: -0.03,
+      volume: 1.789,
+      "MA(5)": 726.45,
+      "MA(20)": 728
+    },
+    NEPT: {
+      price: 88.34,
+      percent_change: 0.19,
+      volume: 0.654,
+      "MA(5)": 88.21,
+      "MA(20)": 88.67
+    },
+    SYNX: {
+      price: 345.67,
+      percent_change: 0.11,
+      volume: 2.112,
+      "MA(5)": 345.34,
+      "MA(20)": 346.12
+    },
+    ZETA: {
+      price: 22.09,
+      percent_change: -0.05,
+      volume: 0.789,
+      "MA(5)": 22.12,
+      "MA(20)": 22.34
+    }
+  },
+  watch_list: ["NVDA"],
+  transaction_history: [],
+  random_seed: 1053520
+};
+var SeededRandom = class {
+  constructor(seed) {
+    this.seed = seed;
+  }
+  randint(min, max) {
+    this.seed = (this.seed * 9301 + 49297) % 233280;
+    return Math.floor(min + this.seed / 233280 * (max - min + 1));
+  }
+};
+var TradingBot = class _TradingBot {
+  constructor() {
+    // Aliases for camelCase compatibility
+    this.placeOrder = this.place_order.bind(this);
+    this.getAccountInfo = this.get_account_info.bind(this);
+    this.tradingLogin = this.trading_login.bind(this);
+    this.tradingGetLoginStatus = this.trading_get_login_status.bind(this);
+    this.getOrderHistory = this.get_order_history.bind(this);
+    this.orders = {};
+    this.accountInfo = { account_id: 0, balance: 0, binding_card: 0 };
+    this.authenticated = false;
+    this.marketStatus = "Closed";
+    this.orderCounter = 0;
+    this.stocks = {};
+    this.watchList = [];
+    this.transactionHistory = [];
+    this._random = new SeededRandom(1053520);
+  }
+  _loadScenario(scenario, _longContext = false) {
+    var _a, _b, _c, _d, _e, _f;
+    const defaultCopy = JSON.parse(JSON.stringify(DEFAULT_STATE3));
+    this.orders = { ...defaultCopy.orders, ...scenario.orders };
+    const convertedOrders = {};
+    for (const [k, v] of Object.entries(this.orders)) {
+      const numKey = Number.parseInt(k, 10);
+      if (!Number.isNaN(numKey)) {
+        convertedOrders[numKey] = v;
+      }
+    }
+    this.orders = convertedOrders;
+    this.accountInfo = {
+      ...defaultCopy.account_info,
+      ...scenario.account_info
+    };
+    this.authenticated = (_a = scenario.authenticated) != null ? _a : defaultCopy.authenticated;
+    this.marketStatus = (_b = scenario.market_status) != null ? _b : defaultCopy.market_status;
+    this.orderCounter = (_c = scenario.order_counter) != null ? _c : defaultCopy.order_counter;
+    this.stocks = { ...defaultCopy.stocks, ...scenario.stocks };
+    this.watchList = (_d = scenario.watch_list) != null ? _d : defaultCopy.watch_list;
+    this.transactionHistory = (_e = scenario.transaction_history) != null ? _e : defaultCopy.transaction_history;
+    this._random = new SeededRandom(
+      (_f = scenario.random_seed) != null ? _f : defaultCopy.random_seed
+    );
+  }
+  _generateTransactionTimestamp() {
+    const startDate = CURRENT_TIME;
+    const endDate = new Date(startDate.getTime() + 24 * 60 * 60 * 1e3);
+    const startTimestamp = Math.floor(startDate.getTime() / 1e3);
+    const endTimestamp = Math.floor(endDate.getTime() / 1e3);
+    const randomTimestamp = this._random.randint(startTimestamp, endTimestamp);
+    const randomDate = new Date(randomTimestamp * 1e3);
+    const pad = (n) => n.toString().padStart(2, "0");
+    return `${randomDate.getFullYear()}-${pad(randomDate.getMonth() + 1)}-${pad(randomDate.getDate())} ${pad(randomDate.getHours())}:${pad(randomDate.getMinutes())}:${pad(randomDate.getSeconds())}`;
+  }
+  equals(other) {
+    if (!(other instanceof _TradingBot)) {
+      return false;
+    }
+    return JSON.stringify(this.orders) === JSON.stringify(other.orders) && JSON.stringify(this.accountInfo) === JSON.stringify(other.accountInfo) && this.authenticated === other.authenticated && this.marketStatus === other.marketStatus && JSON.stringify(this.watchList) === JSON.stringify(other.watchList);
+  }
+  get_current_time() {
+    const hours = CURRENT_TIME.getHours();
+    const minutes = CURRENT_TIME.getMinutes();
+    const ampm = hours >= 12 ? "PM" : "AM";
+    const formattedHours = hours % 12 || 12;
+    const formattedMinutes = minutes.toString().padStart(2, "0");
+    return { current_time: `${formattedHours}:${formattedMinutes} ${ampm}` };
+  }
+  get_symbol_by_name(name) {
+    var _a;
+    const symbolMap = {
+      Apple: "AAPL",
+      Google: "GOOG",
+      Tesla: "TSLA",
+      Microsoft: "MSFT",
+      Nvidia: "NVDA",
+      "Zeta Corp": "ZETA",
+      "Alpha Tech": "ALPH",
+      "Omega Industries": "OMEG",
+      "Quasar Ltd.": "QUAS",
+      "Neptune Systems": "NEPT",
+      "Synex Solutions": "SYNX",
+      Amazon: "AMZN",
+      Gorilla: "GORI"
+    };
+    return { symbol: (_a = symbolMap[name]) != null ? _a : "Stock not found" };
+  }
+  get_stock_info(symbol) {
+    if (!(symbol in this.stocks)) {
+      return { error: `Stock with symbol '${symbol}' not found.` };
+    }
+    return this.stocks[symbol];
+  }
+  get_order_details(order_id) {
+    const orderId = Number(order_id);
+    if (!(orderId in this.orders)) {
+      return {
+        error: `Order with ID ${orderId} not found. Here is the list of orders_id: ${Object.keys(this.orders).join(", ")}`
+      };
+    }
+    return this.orders[orderId];
+  }
+  cancel_order(order_id) {
+    const orderId = Number(order_id);
+    if (!(orderId in this.orders)) {
+      return { error: `Order with ID ${orderId} not found.` };
+    }
+    if (this.orders[orderId].status === "Completed") {
+      return {
+        error: `Can't cancel order ${orderId}. Order is already completed.`
+      };
+    }
+    this.orders[orderId].status = "Cancelled";
+    return { order_id: orderId, status: "Cancelled" };
+  }
+  place_order(order_type, symbol, price, amount) {
+    var _a, _b;
+    if (!this.authenticated) {
+      return {
+        error: "User not authenticated. Please log in to place an order."
+      };
+    }
+    if (!(symbol in this.stocks)) {
+      return { error: `Invalid stock symbol: ${symbol}` };
+    }
+    if (price <= 0 || amount <= 0) {
+      return { error: "Price and amount must be positive values." };
+    }
+    if (order_type.toLowerCase() === "buy") {
+      const totalCost = Number(price) * Number(amount);
+      if (totalCost > ((_a = this.accountInfo.balance) != null ? _a : 0)) {
+        return {
+          error: `Insufficient funds: required $${totalCost.toFixed(2)} but only $${((_b = this.accountInfo.balance) != null ? _b : 0).toFixed(2)} available.`
+        };
+      }
+    }
+    const orderId = this.orderCounter;
+    this.orders[orderId] = {
+      id: orderId,
+      order_type,
+      symbol,
+      price: Number(price),
+      amount: Number(amount),
+      status: "Open"
+    };
+    this.orderCounter += 1;
+    return {
+      order_id: orderId,
+      order_type,
+      status: "Pending",
+      price: Number(price),
+      amount: Number(amount)
+    };
+  }
+  withdraw_funds(amount) {
+    if (!this.authenticated) {
+      return {
+        error: "User not authenticated. Please log in to make a transaction."
+      };
+    }
+    if (this.marketStatus !== "Open") {
+      return { error: "Market is closed. Transactions are not allowed." };
+    }
+    if (amount <= 0) {
+      return { error: "Transaction amount must be positive." };
+    }
+    if (amount > this.accountInfo.balance) {
+      return { error: "Insufficient funds for withdrawal." };
+    }
+    this.accountInfo.balance -= amount;
+    this.transactionHistory.push({
+      type: "withdrawal",
+      amount,
+      timestamp: this._generateTransactionTimestamp()
+    });
+    return {
+      status: "Withdrawal successful",
+      new_balance: this.accountInfo.balance
+    };
+  }
+  get_account_info() {
+    if (!this.authenticated) {
+      return {
+        error: "User not authenticated. Please log in to view account information."
+      };
+    }
+    return this.accountInfo;
+  }
+  trading_login(_username, _password) {
+    if (this.authenticated) {
+      return { status: "Already logged in" };
+    }
+    this.authenticated = true;
+    return { status: "Logged in successfully" };
+  }
+  trading_get_login_status() {
+    return { status: this.authenticated };
+  }
+  trading_logout() {
+    if (!this.authenticated) {
+      return { status: "No user is currently logged in" };
+    }
+    this.authenticated = false;
+    return { status: "Logged out successfully" };
+  }
+  fund_account(amount) {
+    if (!this.authenticated) {
+      return {
+        error: "User not authenticated. Please log in to fund the account."
+      };
+    }
+    if (amount <= 0) {
+      return { error: "Funding amount must be positive." };
+    }
+    this.accountInfo.balance += amount;
+    this.transactionHistory.push({
+      type: "deposit",
+      amount,
+      timestamp: this._generateTransactionTimestamp()
+    });
+    return {
+      status: "Account funded successfully",
+      new_balance: this.accountInfo.balance
+    };
+  }
+  remove_stock_from_watchlist(symbol) {
+    if (!this.authenticated) {
+      return {
+        error: "User not authenticated. Please log in to modify the watchlist."
+      };
+    }
+    const idx = this.watchList.indexOf(symbol);
+    if (idx === -1) {
+      return { error: `Stock ${symbol} not found in watchlist.` };
+    }
+    this.watchList.splice(idx, 1);
+    return { status: `Stock ${symbol} removed from watchlist successfully.` };
+  }
+  get_watchlist() {
+    if (!this.authenticated) {
+      return {
+        error: "User not authenticated. Please log in to view the watchlist."
+      };
+    }
+    return { watchlist: this.watchList };
+  }
+  get_order_history() {
+    if (!this.authenticated) {
+      return {
+        error: "User not authenticated. Please log in to view order history."
+      };
+    }
+    return { history: Object.keys(this.orders).map(Number) };
+  }
+  get_transaction_history(start_date, end_date) {
+    if (!this.authenticated) {
+      return {
+        error: "User not authenticated. Please log in to view transaction history."
+      };
+    }
+    const start = start_date ? new Date(start_date) : /* @__PURE__ */ new Date(0);
+    const end = end_date ? new Date(end_date) : /* @__PURE__ */ new Date(864e13);
+    const filteredHistory = this.transactionHistory.filter((t) => {
+      const txDate = new Date(t.timestamp);
+      return txDate >= start && txDate <= end;
+    });
+    return { transaction_history: filteredHistory };
+  }
+  get_available_stocks(sector) {
+    var _a;
+    const sectorMap = {
+      Technology: ["AAPL", "GOOG", "MSFT", "NVDA"],
+      Automobile: ["TSLA", "F", "GM"]
+    };
+    return { stock_list: (_a = sectorMap[sector]) != null ? _a : [] };
+  }
+  filter_stocks_by_price(stocks, min_price, max_price) {
+    const filteredStocks = stocks.filter((symbol) => {
+      const stock = this.stocks[symbol];
+      if (!stock) {
+        return false;
+      }
+      return stock.price >= min_price && stock.price <= max_price;
+    });
+    return { filtered_stocks: filteredStocks };
+  }
+  add_to_watchlist(stock) {
+    if (!this.watchList.includes(stock) && stock in this.stocks) {
+      this.watchList.push(stock);
+    }
+    return { watchlist: this.watchList };
+  }
+  notify_price_change(stocks, threshold) {
+    const changedStocks = stocks.filter((symbol) => {
+      const stock = this.stocks[symbol];
+      if (!stock) {
+        return false;
+      }
+      return Math.abs(stock.percent_change) >= threshold;
+    });
+    if (changedStocks.length > 0) {
+      return {
+        notification: `Stocks ${changedStocks.join(", ")} have significant price changes.`
+      };
+    }
+    return {
+      notification: "No significant price changes in the selected stocks."
+    };
+  }
+};
+
+// src/multi-turn/classes/travel-api.ts
+var DIGIT_REGEX = /\d/;
+var DATE_FORMAT_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+var DEFAULT_STATE4 = {
+  random_seed: 141053,
+  credit_card_list: {},
+  booking_record: {},
+  access_token: void 0,
+  token_type: void 0,
+  token_expires_in: void 0,
+  token_scope: void 0,
+  user_first_name: void 0,
+  user_last_name: void 0,
+  budget_limit: void 0
+};
+var BASE_COSTS = /* @__PURE__ */ new Map([
+  ["SFO|LAX", 200],
+  ["SFO|JFK", 500],
+  ["SFO|ORD", 400],
+  ["SFO|BOS", 450],
+  ["SFO|RMS", 300],
+  ["SFO|SBK", 350],
+  ["SFO|MPC", 370],
+  ["SFO|SVP", 320],
+  ["SFO|SHD", 330],
+  ["SFO|SSV", 340],
+  ["SFO|OKD", 360],
+  ["SFO|WLB", 310],
+  ["SFO|CRH", 380],
+  ["SFO|ATV", 390],
+  ["SFO|PHV", 420],
+  ["SFO|GFD", 430],
+  ["SFO|CIA", 700],
+  ["LAX|SFO", 100],
+  ["LAX|JFK", 600],
+  ["LAX|ORD", 500],
+  ["LAX|BOS", 550],
+  ["LAX|RMS", 310],
+  ["LAX|SBK", 320],
+  ["LAX|MPC", 330],
+  ["LAX|SVP", 340],
+  ["LAX|SHD", 350],
+  ["LAX|SSV", 360],
+  ["LAX|OKD", 370],
+  ["LAX|WLB", 380],
+  ["LAX|CRH", 390],
+  ["LAX|ATV", 400],
+  ["LAX|PHV", 410],
+  ["LAX|GFD", 420],
+  ["LAX|HND", 430],
+  ["JFK|ORD", 300],
+  ["JFK|BOS", 250],
+  ["JFK|RMS", 450],
+  ["JFK|SBK", 460],
+  ["JFK|MPC", 470],
+  ["JFK|SVP", 480],
+  ["JFK|SHD", 490],
+  ["JFK|SSV", 500],
+  ["JFK|OKD", 510],
+  ["JFK|WLB", 520],
+  ["JFK|CRH", 530],
+  ["JFK|ATV", 540],
+  ["JFK|PHV", 550],
+  ["JFK|GFD", 560],
+  ["JFK|LAX", 570],
+  ["JFK|HND", 800],
+  ["JFK|PVG", 950],
+  ["JFK|PEK", 1e3],
+  ["ORD|LAX", 180],
+  ["ORD|BOS", 200],
+  ["ORD|RMS", 350],
+  ["ORD|SBK", 360],
+  ["ORD|MPC", 370],
+  ["ORD|SVP", 380],
+  ["ORD|SHD", 390],
+  ["ORD|SSV", 400],
+  ["ORD|OKD", 410],
+  ["ORD|WLB", 420],
+  ["ORD|CRH", 430],
+  ["ORD|ATV", 440],
+  ["ORD|PHV", 450],
+  ["ORD|GFD", 460],
+  ["BOS|RMS", 400],
+  ["BOS|SBK", 410],
+  ["BOS|MPC", 420],
+  ["BOS|SVP", 430],
+  ["BOS|SHD", 440],
+  ["BOS|SSV", 450],
+  ["BOS|OKD", 460],
+  ["BOS|WLB", 470],
+  ["BOS|CRH", 480],
+  ["BOS|ATV", 490],
+  ["BOS|PHV", 500],
+  ["BOS|GFD", 510],
+  ["RMS|BOS", 200],
+  ["RMS|JFK", 210],
+  ["RMS|SBK", 220],
+  ["RMS|MPC", 230],
+  ["RMS|SVP", 240],
+  ["RMS|SHD", 250],
+  ["RMS|SSV", 260],
+  ["RMS|OKD", 270],
+  ["RMS|WLB", 280],
+  ["RMS|CRH", 290],
+  ["RMS|ATV", 300],
+  ["RMS|PHV", 310],
+  ["RMS|GFD", 320],
+  ["RMS|LAX", 330],
+  ["SBK|MPC", 200],
+  ["SBK|SVP", 210],
+  ["SBK|SHD", 220],
+  ["SBK|SSV", 230],
+  ["SBK|OKD", 240],
+  ["SBK|WLB", 250],
+  ["SBK|CRH", 260],
+  ["SBK|ATV", 270],
+  ["SBK|PHV", 280],
+  ["SBK|GFD", 290],
+  ["MPC|SVP", 210],
+  ["MPC|SHD", 220],
+  ["MPC|SSV", 230],
+  ["MPC|OKD", 240],
+  ["MPC|WLB", 250],
+  ["MPC|CRH", 260],
+  ["MPC|ATV", 270],
+  ["MPC|PHV", 280],
+  ["MPC|GFD", 290],
+  ["SVP|SHD", 230],
+  ["SVP|SSV", 240],
+  ["SVP|OKD", 250],
+  ["SVP|WLB", 260],
+  ["SVP|CRH", 270],
+  ["SVP|ATV", 280],
+  ["SVP|PHV", 290],
+  ["SVP|GFD", 300],
+  ["SHD|SSV", 220],
+  ["SHD|OKD", 230],
+  ["SHD|WLB", 240],
+  ["SHD|CRH", 250],
+  ["SHD|ATV", 260],
+  ["SHD|PHV", 270],
+  ["SHD|GFD", 280],
+  ["SSV|OKD", 240],
+  ["SSV|WLB", 250],
+  ["SSV|CRH", 260],
+  ["SSV|ATV", 270],
+  ["SSV|PHV", 280],
+  ["SSV|GFD", 290],
+  ["OKD|WLB", 230],
+  ["OKD|CRH", 240],
+  ["OKD|ATV", 250],
+  ["OKD|PHV", 260],
+  ["OKD|GFD", 270],
+  ["WLB|CRH", 250],
+  ["WLB|ATV", 260],
+  ["WLB|PHV", 270],
+  ["WLB|GFD", 280],
+  ["CRH|ATV", 240],
+  ["CRH|PHV", 250],
+  ["CRH|GFD", 260],
+  ["CRH|SFO", 270],
+  ["CRH|RMS", 280],
+  ["CRH|HKG", 290],
+  ["CRH|JFK", 300],
+  ["ATV|PHV", 230],
+  ["ATV|GFD", 240],
+  ["PHV|GFD", 220],
+  ["LHR|CDG", 100],
+  ["OKD|LAX", 220]
+]);
+var AIRPORT_MAP = {
+  Rivermist: "RMS",
+  Stonebrook: "SBK",
+  Maplecrest: "MPC",
+  Silverpine: "SVP",
+  Shadowridge: "SHD",
+  London: "LHR",
+  Paris: "CDG",
+  "Sunset Valley": "SSV",
+  Oakendale: "OKD",
+  Willowbend: "WLB",
+  "Crescent Hollow": "CRH",
+  Autumnville: "ATV",
+  Pinehaven: "PHV",
+  Greenfield: "GFD",
+  "San Francisco": "SFO",
+  "Los Angeles": "LAX",
+  "New York": "JFK",
+  Chicago: "ORD",
+  Boston: "BOS",
+  Beijing: "PEK",
+  "Hong Kong": "HKG",
+  Rome: "CIA",
+  Tokyo: "HND"
+};
+var EXCHANGE_RATES = /* @__PURE__ */ new Map([
+  ["USD|RMB", 7],
+  ["USD|EUR", 0.8],
+  ["USD|JPY", 110],
+  ["USD|GBP", 0.7],
+  ["USD|CAD", 1.3],
+  ["USD|AUD", 1.4],
+  ["USD|INR", 70],
+  ["USD|RUB", 60],
+  ["USD|BRL", 3.8],
+  ["USD|MXN", 20]
+]);
+var ALL_AIRPORTS = [
+  "RMS",
+  "SBK",
+  "MPC",
+  "SVP",
+  "SHD",
+  "CDG",
+  "LHR",
+  "SSV",
+  "OKD",
+  "WLB",
+  "PEK",
+  "HND",
+  "HKG",
+  "CIA",
+  "CRH",
+  "ATV",
+  "PHV",
+  "GFD",
+  "SFO",
+  "LAX",
+  "JFK",
+  "ORD",
+  "BOS"
+];
+var SeededRandom2 = class {
+  constructor(seed) {
+    this.seed = seed;
+  }
+  next() {
+    this.seed = this.seed * 1103515245 + 12345 & 2147483647;
+    return this.seed;
+  }
+  randInt(min, max) {
+    return min + this.next() % (max - min + 1);
+  }
+};
+var TravelAPI = class {
+  constructor() {
+    this.longContext = false;
+    this._flightCostLookup = /* @__PURE__ */ new Map();
+    var _a;
+    this.creditCardList = {};
+    this.bookingRecord = {};
+    this._random = new SeededRandom2((_a = DEFAULT_STATE4.random_seed) != null ? _a : 141053);
+  }
+  _loadScenario(scenario, longContext = false) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    const defaultCopy = JSON.parse(JSON.stringify(DEFAULT_STATE4));
+    this._random = new SeededRandom2(
+      (_a = scenario.random_seed) != null ? _a : defaultCopy.random_seed
+    );
+    this.creditCardList = (_b = scenario.credit_card_list) != null ? _b : defaultCopy.credit_card_list;
+    this.bookingRecord = (_c = scenario.booking_record) != null ? _c : defaultCopy.booking_record;
+    this.accessToken = (_d = scenario.access_token) != null ? _d : defaultCopy.access_token;
+    this.tokenType = (_e = scenario.token_type) != null ? _e : defaultCopy.token_type;
+    this.tokenExpiresIn = (_f = scenario.token_expires_in) != null ? _f : defaultCopy.token_expires_in;
+    this.tokenScope = (_g = scenario.token_scope) != null ? _g : defaultCopy.token_scope;
+    this.userFirstName = (_h = scenario.user_first_name) != null ? _h : defaultCopy.user_first_name;
+    this.userLastName = (_i = scenario.user_last_name) != null ? _i : defaultCopy.user_last_name;
+    this.budgetLimit = (_j = scenario.budget_limit) != null ? _j : defaultCopy.budget_limit;
+    this.longContext = longContext;
+  }
+  authenticateTravel(_clientId, _clientSecret, _refreshToken, grantType, userFirstName, userLastName) {
+    this.tokenExpiresIn = 2;
+    this.accessToken = String(this._random.randInt(1e5, 999999));
+    this.tokenType = "Bearer";
+    this.tokenScope = grantType;
+    this.userFirstName = userFirstName;
+    this.userLastName = userLastName;
+    return {
+      expires_in: 2,
+      access_token: this.accessToken,
+      token_type: "Bearer",
+      scope: grantType
+    };
+  }
+  travelGetLoginStatus() {
+    const isNotLoggedIn = this.tokenExpiresIn === void 0 || this.tokenExpiresIn === 0;
+    return { status: !isNotLoggedIn };
+  }
+  getBudgetFiscalYear(_lastModifiedAfter, _includeRemoved) {
+    return { budget_fiscal_year: "2018" };
+  }
+  registerCreditCard(accessToken, cardNumber, expirationDate, cardholderName, cardVerificationNumber) {
+    if (this.tokenExpiresIn === void 0) {
+      return { error: "Token not initialized" };
+    }
+    if (this.tokenExpiresIn === 0) {
+      return { error: "Token expired" };
+    }
+    if (accessToken !== this.accessToken) {
+      return { error: "Invalid access token" };
+    }
+    if (cardNumber in this.creditCardList) {
+      return { error: "Card already registered" };
+    }
+    const cardId = String(
+      this._random.randInt(1e11, 999999999999)
+    );
+    this.creditCardList[cardId] = {
+      card_number: cardNumber,
+      expiration_date: expirationDate,
+      cardholder_name: cardholderName,
+      card_verification_number: cardVerificationNumber,
+      balance: this._random.randInt(1e4, 99999)
+    };
+    return { card_id: cardId };
+  }
+  getFlightCost(travelFrom, travelTo, travelDate, travelClass) {
+    const key = `${travelFrom}|${travelTo}`;
+    const baseCost = BASE_COSTS.get(key);
+    if (baseCost === void 0) {
+      throw new Error("No available route for the given airports.");
+    }
+    let factor = 1;
+    if (travelClass === "economy") {
+      factor = 1;
+    } else if (travelClass === "business") {
+      factor = 2;
+    } else if (travelClass === "first") {
+      factor = 5;
+    } else {
+      throw new Error(
+        "Invalid travel class. Options are: economy, business, first."
+      );
+    }
+    const digitSum = travelDate.split("").filter((c) => DIGIT_REGEX.test(c)).reduce((sum, c) => sum + Number.parseInt(c, 10), 0);
+    const travelDateMultiplier = digitSum % 2 === 0 ? 2 : 1;
+    const travelCost = baseCost * factor * travelDateMultiplier;
+    const travelCostList = [];
+    if (this.longContext) {
+      this._flightCostLookup.clear();
+      for (const [route, base] of BASE_COSTS.entries()) {
+        const cost = base * factor * travelDateMultiplier;
+        const [from, to] = route.split("|");
+        const cacheKey = `${from}|${to}|${travelClass}|${travelDate}`;
+        this._flightCostLookup.set(cacheKey, { cost });
+        travelCostList.push(cost);
+      }
+    } else {
+      travelCostList.push(travelCost);
+      const cacheKey = `${travelFrom}|${travelTo}|${travelClass}|${travelDate}`;
+      this._flightCostLookup.set(cacheKey, { cost: travelCost });
+    }
+    return { travel_cost_list: travelCostList };
+  }
+  getCreditCardBalance(accessToken, cardId) {
+    if (this.tokenExpiresIn === 0) {
+      return { error: "Token expired" };
+    }
+    if (accessToken !== this.accessToken) {
+      return { error: "Invalid access token" };
+    }
+    if (!(cardId in this.creditCardList)) {
+      return {
+        error: `Card not registered. Here are a list of card_id's: ${Object.keys(this.creditCardList).join(", ")}`
+      };
+    }
+    return { card_balance: this.creditCardList[cardId].balance };
+  }
+  bookFlight(accessToken, cardId, travelDate, travelFrom, travelTo, travelClass) {
+    if (this.tokenExpiresIn === 0) {
+      return { booking_status: false, error: "Token expired" };
+    }
+    if (accessToken !== this.accessToken) {
+      return { booking_status: false, error: "Invalid access token" };
+    }
+    if (!(cardId in this.creditCardList)) {
+      return { booking_status: false, error: "Card not registered" };
+    }
+    if (!("balance" in this.creditCardList[cardId])) {
+      return { booking_status: false, error: "Balance not found" };
+    }
+    const allAirports = this.listAllAirports();
+    if (!allAirports.includes(travelFrom)) {
+      return {
+        booking_status: false,
+        error: `Invalid departure airport code: ${travelFrom}`
+      };
+    }
+    if (!allAirports.includes(travelTo)) {
+      return {
+        booking_status: false,
+        error: `Invalid destination airport code: ${travelTo}`
+      };
+    }
+    if (!DATE_FORMAT_REGEX.test(travelDate)) {
+      return {
+        booking_status: false,
+        error: "Invalid date format. Use YYYY-MM-DD."
+      };
+    }
+    const validClasses = /* @__PURE__ */ new Set(["economy", "business", "first"]);
+    if (!validClasses.has(travelClass)) {
+      return {
+        booking_status: false,
+        error: `Invalid travel class. Must be one of ${[...validClasses].join(", ")}`
+      };
+    }
+    try {
+      this.getFlightCost(travelFrom, travelTo, travelDate, travelClass);
+      const cacheKey = `${travelFrom}|${travelTo}|${travelClass}|${travelDate}`;
+      const travelCostEntry = this._flightCostLookup.get(cacheKey);
+      if (!travelCostEntry) {
+        return {
+          booking_status: false,
+          error: "No available route for the given parameters"
+        };
+      }
+      const travelCost = travelCostEntry.cost;
+      if (this.creditCardList[cardId].balance < travelCost) {
+        return { booking_status: false, error: "Insufficient funds" };
+      }
+      if (this.budgetLimit !== void 0 && this.creditCardList[cardId].balance < this.budgetLimit) {
+        return {
+          booking_status: false,
+          error: "Balance is less than budget limit"
+        };
+      }
+      this.creditCardList[cardId].balance -= travelCost;
+      const bookingId = String(this._random.randInt(1e6, 9999999));
+      const transactionId = String(
+        this._random.randInt(1e7, 99999999)
+      );
+      this.bookingRecord[bookingId] = {
+        card_id: cardId,
+        travel_date: travelDate,
+        travel_from: travelFrom,
+        travel_to: travelTo,
+        travel_class: travelClass,
+        travel_cost: travelCost,
+        transaction_id: transactionId
+      };
+      if (this.longContext) {
+        return {
+          booking_id: bookingId,
+          transaction_id: transactionId,
+          booking_status: true,
+          booking_history: this.bookingRecord
+        };
+      }
+      return {
+        booking_id: bookingId,
+        transaction_id: transactionId,
+        booking_status: true,
+        booking_history: {}
+      };
+    } catch (e) {
+      return { booking_status: false, error: String(e) };
+    }
+  }
+  retrieveInvoice(accessToken, bookingId, _insuranceId) {
+    if (this.tokenExpiresIn === 0) {
+      return { error: "Token expired" };
+    }
+    if (accessToken !== this.accessToken) {
+      return { error: "Invalid access token" };
+    }
+    if (!(bookingId && bookingId in this.bookingRecord)) {
+      return { error: "Booking not found" };
+    }
+    const booking = this.bookingRecord[bookingId];
+    return {
+      invoice: {
+        booking_id: bookingId,
+        travel_date: booking.travel_date,
+        travel_from: booking.travel_from,
+        travel_to: booking.travel_to,
+        travel_class: booking.travel_class,
+        travel_cost: booking.travel_cost,
+        transaction_id: booking.transaction_id
+      }
+    };
+  }
+  getBookingHistory(accessToken) {
+    if (this.tokenExpiresIn === 0) {
+      return { error: "Token expired" };
+    }
+    if (accessToken !== this.accessToken) {
+      return { error: "Invalid access token" };
+    }
+    return { booking_history: JSON.parse(JSON.stringify(this.bookingRecord)) };
+  }
+  listAllAirports() {
+    return ALL_AIRPORTS;
+  }
+  cancelBooking(accessToken, bookingId) {
+    if (this.tokenExpiresIn === 0) {
+      return { cancel_status: false, error: "Token expired" };
+    }
+    if (accessToken !== this.accessToken) {
+      return { cancel_status: false, error: "Invalid access token" };
+    }
+    if (!(bookingId in this.bookingRecord)) {
+      return { cancel_status: false, error: "Booking not found" };
+    }
+    const cardId = this.bookingRecord[bookingId].card_id;
+    const travelCost = this.bookingRecord[bookingId].travel_cost;
+    this.creditCardList[cardId].balance += travelCost;
+    delete this.bookingRecord[bookingId];
+    return { cancel_status: true };
+  }
+  computeExchangeRate(baseCurrency, targetCurrency, value) {
+    const forwardKey = `${baseCurrency}|${targetCurrency}`;
+    const reverseKey = `${targetCurrency}|${baseCurrency}`;
+    const forwardRate = EXCHANGE_RATES.get(forwardKey);
+    if (forwardRate !== void 0) {
+      return { exchanged_value: value * forwardRate };
+    }
+    const reverseRate = EXCHANGE_RATES.get(reverseKey);
+    if (reverseRate !== void 0) {
+      return { exchanged_value: Math.round(value / reverseRate * 100) / 100 };
+    }
+    throw new Error("No available exchange rate for the given currencies.");
+  }
+  verifyTravelerInformation(firstName, lastName, dateOfBirth, passportNumber) {
+    if (this.userFirstName !== firstName || this.userLastName !== lastName) {
+      return {
+        verification_status: false,
+        verification_failure: `Cannot book flight information for another user. Expected ${this.userFirstName} ${this.userLastName}, got ${firstName} ${lastName}`
+      };
+    }
+    if (!DATE_FORMAT_REGEX.test(dateOfBirth)) {
+      return {
+        verification_status: false,
+        verification_failure: "Invalid date of birth format. Please use YYYY-MM-DD."
+      };
+    }
+    const birthDate = new Date(dateOfBirth);
+    const today = /* @__PURE__ */ new Date();
+    let age = today.getFullYear() - birthDate.getFullYear();
+    const monthDiff = today.getMonth() - birthDate.getMonth();
+    if (monthDiff < 0 || monthDiff === 0 && today.getDate() < birthDate.getDate()) {
+      age--;
+    }
+    if (age < 18) {
+      return {
+        verification_status: false,
+        verification_failure: "Traveler must be at least 18 years old."
+      };
+    }
+    if (!passportNumber.startsWith("US")) {
+      return {
+        verification_status: false,
+        verification_failure: "Passport must be issued by the United States."
+      };
+    }
+    return { verification_status: true };
+  }
+  setBudgetLimit(accessToken, budgetLimit) {
+    if (this.tokenExpiresIn === 0) {
+      return { error: "Token expired" };
+    }
+    if (accessToken !== this.accessToken) {
+      return { error: "Invalid access token" };
+    }
+    this.budgetLimit = Number(budgetLimit);
+    return { budget_limit: this.budgetLimit };
+  }
+  getNearestAirportByCity(location) {
+    var _a;
+    return { nearest_airport: (_a = AIRPORT_MAP[location]) != null ? _a : "Unknown" };
+  }
+  purchaseInsurance(accessToken, _insuranceType, bookingId, insuranceCost, cardId) {
+    if (this.tokenExpiresIn === 0) {
+      return { insurance_status: false, error: "Token expired" };
+    }
+    if (accessToken !== this.accessToken) {
+      return { insurance_status: false, error: "Invalid access token" };
+    }
+    if (this.budgetLimit !== void 0 && this.budgetLimit < insuranceCost) {
+      return { insurance_status: false, error: "Exceeded budget limit" };
+    }
+    if (!(bookingId in this.bookingRecord)) {
+      return { insurance_status: false, error: "Booking not found" };
+    }
+    if (!(cardId in this.creditCardList)) {
+      return { insurance_status: false, error: "Credit card not registered" };
+    }
+    this.creditCardList[cardId].balance -= insuranceCost;
+    return {
+      insurance_id: String(this._random.randInt(1e8, 999999999)),
+      insurance_status: true
+    };
+  }
+  contactCustomerSupport(bookingId, _message) {
+    if (!(bookingId in this.bookingRecord)) {
+      return { error: "Booking not found" };
+    }
+    return {
+      customer_support_message: "Thank you for contacting customer support. Your message has been received and we will get back to you shortly."
+    };
+  }
+  getAllCreditCards() {
+    return { credit_card_list: this.creditCardList };
+  }
+};
+
+// src/multi-turn/classes/twitter-api.ts
+var DEFAULT_STATE5 = {
+  username: "john",
+  password: "john123",
+  authenticated: false,
+  tweets: {},
+  comments: {},
+  retweets: {},
+  following_list: ["alice", "bob"],
+  tweet_counter: 0
+};
+var TwitterAPI = class {
+  constructor() {
+    this.username = "john";
+    this.password = "john123";
+    this.authenticated = false;
+    this.tweets = {};
+    this.comments = {};
+    this.retweets = {};
+    this.followingList = [];
+    this.tweetCounter = 0;
+  }
+  _loadScenario(scenario, _longContext = false) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const defaultCopy = JSON.parse(
+      JSON.stringify(DEFAULT_STATE5)
+    );
+    this.username = (_a = scenario.username) != null ? _a : defaultCopy.username;
+    this.password = (_b = scenario.password) != null ? _b : defaultCopy.password;
+    this.authenticated = (_c = scenario.authenticated) != null ? _c : defaultCopy.authenticated;
+    this.tweets = (_d = scenario.tweets) != null ? _d : defaultCopy.tweets;
+    this.tweets = Object.fromEntries(
+      Object.entries(this.tweets).map(([k, v]) => [Number.parseInt(k, 10), v])
+    );
+    this.comments = (_e = scenario.comments) != null ? _e : defaultCopy.comments;
+    this.retweets = (_f = scenario.retweets) != null ? _f : defaultCopy.retweets;
+    this.followingList = (_g = scenario.following_list) != null ? _g : defaultCopy.following_list;
+    this.tweetCounter = (_h = scenario.tweet_counter) != null ? _h : defaultCopy.tweet_counter;
+  }
+  authenticate_twitter(username, password) {
+    if (username === this.username && password === this.password) {
+      this.authenticated = true;
+      return { authentication_status: true };
+    }
+    return { authentication_status: false };
+  }
+  posting_get_login_status() {
+    return { login_status: !!this.authenticated };
+  }
+  post_tweet(content, tags = [], mentions = []) {
+    if (!this.authenticated) {
+      return {
+        error: "User not authenticated. Please authenticate before posting."
+      };
+    }
+    const tweet = {
+      id: this.tweetCounter,
+      username: this.username,
+      content,
+      tags,
+      mentions
+    };
+    this.tweets[this.tweetCounter] = tweet;
+    this.tweetCounter += 1;
+    return tweet;
+  }
+  retweet(tweetId) {
+    if (!this.authenticated) {
+      return {
+        error: "User not authenticated. Please authenticate before retweeting."
+      };
+    }
+    if (!(tweetId in this.tweets)) {
+      return { error: `Tweet with ID ${tweetId} not found.` };
+    }
+    if (!(this.username in this.retweets)) {
+      this.retweets[this.username] = [];
+    }
+    if (this.retweets[this.username].includes(tweetId)) {
+      return { retweet_status: "Already retweeted" };
+    }
+    this.retweets[this.username].push(tweetId);
+    return { retweet_status: "Successfully retweeted" };
+  }
+  comment(tweetId, commentContent) {
+    if (!this.authenticated) {
+      return {
+        error: "User not authenticated. Please authenticate before commenting."
+      };
+    }
+    if (!(tweetId in this.tweets)) {
+      return { error: `Tweet with ID ${tweetId} not found.` };
+    }
+    if (!(tweetId in this.comments)) {
+      this.comments[tweetId] = [];
+    }
+    this.comments[tweetId].push({
+      username: this.username,
+      content: commentContent
+    });
+    return { comment_status: "Comment added successfully" };
+  }
+  mention(tweetId, mentionedUsernames) {
+    if (!(tweetId in this.tweets)) {
+      return { error: `Tweet with ID ${tweetId} not found.` };
+    }
+    const tweet = this.tweets[tweetId];
+    tweet.mentions.push(...mentionedUsernames);
+    return { mention_status: "Users mentioned successfully" };
+  }
+  follow_user(username_to_follow) {
+    if (!this.authenticated) {
+      return {
+        error: "User not authenticated. Please authenticate before following."
+      };
+    }
+    if (this.followingList.includes(username_to_follow)) {
+      return { follow_status: false };
+    }
+    this.followingList.push(username_to_follow);
+    return { follow_status: true };
+  }
+  list_all_following() {
+    if (!this.authenticated) {
+      return {
+        error: "User not authenticated. Please authenticate before listing following."
+      };
+    }
+    return { following_list: this.followingList };
+  }
+  unfollow_user(username_to_unfollow) {
+    if (!this.authenticated) {
+      return {
+        error: "User not authenticated. Please authenticate before unfollowing."
+      };
+    }
+    if (!this.followingList.includes(username_to_unfollow)) {
+      return { unfollow_status: false };
+    }
+    this.followingList = this.followingList.filter(
+      (u) => u !== username_to_unfollow
+    );
+    return { unfollow_status: true };
+  }
+  get_tweet(tweet_id) {
+    if (!(tweet_id in this.tweets)) {
+      return { error: `Tweet with ID ${tweet_id} not found.` };
+    }
+    return this.tweets[tweet_id];
+  }
+  get_user_tweets(username) {
+    return Object.values(this.tweets).filter(
+      (tweet) => tweet.username === username
+    );
+  }
+  search_tweets(keyword) {
+    const keywordLower = keyword.toLowerCase();
+    return Object.values(this.tweets).filter(
+      (tweet) => tweet.content.toLowerCase().includes(keywordLower) || tweet.tags.some(
+        (tag) => tag.toLowerCase().includes(keywordLower)
+      )
+    );
+  }
+  get_tweet_comments(tweet_id) {
+    if (!(tweet_id in this.tweets)) {
+      return [{ error: `Tweet with ID ${tweet_id} not found.` }];
+    }
+    return this.comments[tweet_id] || [];
+  }
+  get_user_stats(username) {
+    const tweetCount = Object.values(this.tweets).filter(
+      (tweet) => tweet.username === username
+    ).length;
+    const followingCount = username === this.username ? this.followingList.length : 0;
+    const retweetCount = (this.retweets[username] || []).length;
+    return {
+      tweet_count: tweetCount,
+      following_count: followingCount,
+      retweet_count: retweetCount
+    };
+  }
+};
+
+// src/multi-turn/classes/vehicle-control-api.ts
+var MAX_FUEL_LEVEL = 50;
+var MIN_FUEL_LEVEL = 0;
+var MILE_PER_GALLON = 20;
+var DEFAULT_STATE6 = {
+  random_seed: 141053,
+  fuelLevel: 0,
+  batteryVoltage: 12.6,
+  engineState: "stopped",
+  remainingUnlockedDoors: 4,
+  doorStatus: {
+    driver: "unlocked",
+    passenger: "unlocked",
+    rear_left: "unlocked",
+    rear_right: "unlocked"
+  },
+  acTemperature: 25,
+  fanSpeed: 50,
+  acMode: "auto",
+  humidityLevel: 50,
+  headLightStatus: "off",
+  parkingBrakeStatus: "released",
+  parkingBrakeForce: 0,
+  slopeAngle: 0,
+  brakePedalStatus: "released",
+  brakePedalForce: 0,
+  distanceToNextVehicle: 50,
+  cruiseStatus: "inactive",
+  destination: "None",
+  frontLeftTirePressure: 32,
+  frontRightTirePressure: 32,
+  rearLeftTirePressure: 30,
+  rearRightTirePressure: 30
+};
+var SeededRandom3 = class {
+  constructor(seed) {
+    this.seed = seed;
+  }
+  uniform(min, max) {
+    this.seed = (this.seed * 9301 + 49297) % 233280;
+    const rnd = this.seed / 233280;
+    return min + rnd * (max - min);
+  }
+};
+var VehicleControlAPI = class _VehicleControlAPI {
+  constructor() {
+    this.longContext = false;
+    this._apiDescription = "This tool belongs to the vehicle control system, which allows users to control various aspects of the car such as engine, doors, climate control, lights, and more.";
+    this.fuelLevel = 0;
+    this.batteryVoltage = 12.6;
+    this.engineState = "stopped";
+    this.remainingUnlockedDoors = 4;
+    this.doorStatus = {
+      driver: "unlocked",
+      passenger: "unlocked",
+      rear_left: "unlocked",
+      rear_right: "unlocked"
+    };
+    this.acTemperature = 25;
+    this.fanSpeed = 50;
+    this.acMode = "auto";
+    this.humidityLevel = 50;
+    this.headLightStatus = "off";
+    this.parkingBrakeStatus = "released";
+    this._parkingBrakeForce = 0;
+    this._slopeAngle = 0;
+    this.brakePedalStatus = "released";
+    this._brakePedalForce = 0;
+    this.distanceToNextVehicle = 50;
+    this.cruiseStatus = "inactive";
+    this.destination = "None";
+    this.frontLeftTirePressure = 32;
+    this.frontRightTirePressure = 32;
+    this.rearLeftTirePressure = 30;
+    this.rearRightTirePressure = 30;
+    this._random = new SeededRandom3(141053);
+  }
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: Scenario loading requires many field initializations
+  _loadScenario(scenario, longContext = false) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v;
+    const defaultCopy = JSON.parse(JSON.stringify(DEFAULT_STATE6));
+    this._random = new SeededRandom3(
+      (_a = scenario.random_seed) != null ? _a : defaultCopy.random_seed
+    );
+    this.fuelLevel = (_b = scenario.fuelLevel) != null ? _b : defaultCopy.fuelLevel;
+    this.batteryVoltage = (_c = scenario.batteryVoltage) != null ? _c : defaultCopy.batteryVoltage;
+    this.engineState = (_d = scenario.engineState) != null ? _d : defaultCopy.engineState;
+    this.doorStatus = (_e = scenario.doorStatus) != null ? _e : defaultCopy.doorStatus;
+    this.remainingUnlockedDoors = 4 - Object.values(this.doorStatus).filter((status) => status === "locked").length;
+    this.acTemperature = (_f = scenario.acTemperature) != null ? _f : defaultCopy.acTemperature;
+    this.fanSpeed = (_g = scenario.fanSpeed) != null ? _g : defaultCopy.fanSpeed;
+    this.acMode = (_h = scenario.acMode) != null ? _h : defaultCopy.acMode;
+    this.humidityLevel = (_i = scenario.humidityLevel) != null ? _i : defaultCopy.humidityLevel;
+    this.headLightStatus = (_j = scenario.headLightStatus) != null ? _j : defaultCopy.headLightStatus;
+    this.parkingBrakeStatus = (_k = scenario.parkingBrakeStatus) != null ? _k : defaultCopy.parkingBrakeStatus;
+    this._parkingBrakeForce = (_l = scenario.parkingBrakeForce) != null ? _l : defaultCopy.parkingBrakeForce;
+    this._slopeAngle = (_m = scenario.slopeAngle) != null ? _m : defaultCopy.slopeAngle;
+    this.brakePedalStatus = (_n = scenario.brakePedalStatus) != null ? _n : defaultCopy.brakePedalStatus;
+    this._brakePedalForce = (_o = scenario.brakePedalForce) != null ? _o : defaultCopy.brakePedalForce;
+    this.distanceToNextVehicle = (_p = scenario.distanceToNextVehicle) != null ? _p : defaultCopy.distanceToNextVehicle;
+    this.cruiseStatus = (_q = scenario.cruiseStatus) != null ? _q : defaultCopy.cruiseStatus;
+    this.destination = (_r = scenario.destination) != null ? _r : defaultCopy.destination;
+    this.frontLeftTirePressure = (_s = scenario.frontLeftTirePressure) != null ? _s : defaultCopy.frontLeftTirePressure;
+    this.frontRightTirePressure = (_t = scenario.frontRightTirePressure) != null ? _t : defaultCopy.frontRightTirePressure;
+    this.rearLeftTirePressure = (_u = scenario.rearLeftTirePressure) != null ? _u : defaultCopy.rearLeftTirePressure;
+    this.rearRightTirePressure = (_v = scenario.rearRightTirePressure) != null ? _v : defaultCopy.rearRightTirePressure;
+    this.longContext = longContext;
+  }
+  equals(other) {
+    if (!(other instanceof _VehicleControlAPI)) {
+      return false;
+    }
+    for (const attrName of Object.keys(this)) {
+      if (attrName.startsWith("_")) {
+        continue;
+      }
+      const modelAttr = this[attrName];
+      const groundTruthAttr = other[attrName];
+      if (JSON.stringify(modelAttr) !== JSON.stringify(groundTruthAttr)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  startEngine(ignitionMode) {
+    if (ignitionMode === "STOP") {
+      this.engineState = "stopped";
+    }
+    if (this.remainingUnlockedDoors > 0) {
+      const unlockedDoors = Object.entries(this.doorStatus).filter(([, status]) => status === "unlocked").map(([door]) => door).join(", ");
+      return {
+        error: `All doors must be locked before starting the engine. Here are the unlocked doors: ${unlockedDoors}`
+      };
+    }
+    if (this.brakePedalStatus !== "pressed") {
+      return {
+        error: "Brake pedal needs to be pressed when starting the engine."
+      };
+    }
+    if (this._brakePedalForce !== 1e3) {
+      return {
+        error: "Must press the brake fully before starting the engine."
+      };
+    }
+    if (this.fuelLevel < MIN_FUEL_LEVEL) {
+      return { error: "Fuel tank is empty." };
+    }
+    if (ignitionMode === "START") {
+      this.engineState = "running";
+    } else {
+      return { error: "Invalid ignition mode." };
+    }
+    return {
+      engineState: this.engineState,
+      fuelLevel: this.fuelLevel,
+      batteryVoltage: this.batteryVoltage
+    };
+  }
+  fillFuelTank(fuelAmount) {
+    if (fuelAmount < 0) {
+      return { error: "Fuel amount cannot be negative." };
+    }
+    if (this.fuelLevel + fuelAmount > MAX_FUEL_LEVEL) {
+      return { error: "Cannot fill gas above the tank capacity." };
+    }
+    if (this.fuelLevel + fuelAmount < MIN_FUEL_LEVEL) {
+      return { error: "Fuel tank is empty. Min fuel level is 0 gallons." };
+    }
+    this.fuelLevel += fuelAmount;
+    return { fuelLevel: this.fuelLevel };
+  }
+  lockDoors(unlock, door) {
+    if (unlock) {
+      for (const d of door) {
+        if (this.doorStatus[d] === "unlocked") {
+          continue;
+        }
+        this.doorStatus[d] = "unlocked";
+        this.remainingUnlockedDoors += 1;
+      }
+      return {
+        lockStatus: "unlocked",
+        remainingUnlockedDoors: this.remainingUnlockedDoors
+      };
+    }
+    for (const d of door) {
+      if (this.doorStatus[d] === "locked") {
+        continue;
+      }
+      this.doorStatus[d] = "locked";
+      this.remainingUnlockedDoors -= 1;
+    }
+    return {
+      lockStatus: "locked",
+      remainingUnlockedDoors: this.remainingUnlockedDoors
+    };
+  }
+  adjustClimateControl(temperature, unit = "celsius", fanSpeed = 50, mode = "auto") {
+    if (fanSpeed < 0 || fanSpeed > 100) {
+      return { error: "Fan speed must be between 0 and 100." };
+    }
+    this.acTemperature = temperature;
+    if (unit === "fahrenheit") {
+      this.acTemperature = (temperature - 32) * 5 / 9;
+    }
+    this.fanSpeed = fanSpeed;
+    this.acMode = mode;
+    return {
+      currentACTemperature: temperature,
+      climateMode: mode,
+      humidityLevel: this.humidityLevel
+    };
+  }
+  get_outside_temperature_from_google() {
+    return { outsideTemperature: this._random.uniform(-10, 40) };
+  }
+  get_outside_temperature_from_weather_com() {
+    return { error: 404 };
+  }
+  setHeadlights(mode) {
+    if (!["on", "off", "auto"].includes(mode)) {
+      return { error: "Invalid headlight mode." };
+    }
+    this.headLightStatus = mode === "on" ? "on" : "off";
+    return { headlightStatus: this.headLightStatus };
+  }
+  displayCarStatus(option) {
+    const status = {};
+    if (option === "fuel") {
+      status.fuelLevel = this.fuelLevel;
+    } else if (option === "battery") {
+      status.batteryVoltage = this.batteryVoltage;
+    } else if (option === "doors") {
+      status.doorStatus = this.doorStatus;
+    } else if (option === "climate") {
+      status.currentACTemperature = this.acTemperature;
+      status.fanSpeed = this.fanSpeed;
+      status.climateMode = this.acMode;
+      status.humidityLevel = this.humidityLevel;
+    } else if (option === "headlights") {
+      status.headlightStatus = this.headLightStatus;
+    } else if (option === "parkingBrake") {
+      status.parkingBrakeStatus = this.parkingBrakeStatus;
+      status.parkingBrakeForce = this._parkingBrakeForce;
+      status.slopeAngle = this._slopeAngle;
+    } else if (option === "brakePedal") {
+      status.brakePedalStatus = this.brakePedalStatus;
+      status.brakePedalForce = this._brakePedalForce;
+    } else if (option === "engine") {
+      status.engineState = this.engineState;
+    } else {
+      status.error = "Invalid option";
+    }
+    return status;
+  }
+  activateParkingBrake(mode) {
+    if (!["engage", "release"].includes(mode)) {
+      return { error: "Invalid mode" };
+    }
+    if (mode === "engage") {
+      this.parkingBrakeStatus = "engaged";
+      this._parkingBrakeForce = 500;
+      this._slopeAngle = 10;
+      return {
+        parkingBrakeStatus: "engaged",
+        _parkingBrakeForce: 500,
+        _slopeAngle: 10
+      };
+    }
+    this.parkingBrakeStatus = "released";
+    this._parkingBrakeForce = 0;
+    this._slopeAngle = 10;
+    return {
+      parkingBrakeStatus: "released",
+      _parkingBrakeForce: 0,
+      _slopeAngle: 10
+    };
+  }
+  pressBrakePedal(pedalPosition) {
+    if (pedalPosition < 0 || pedalPosition > 1) {
+      return { error: "Pedal position must be between 0 and 1." };
+    }
+    if (pedalPosition === 0) {
+      this.brakePedalStatus = "released";
+      this._brakePedalForce = 0;
+      return { brakePedalStatus: "released", brakePedalForce: 0 };
+    }
+    const maxBrakeForce = 1e3;
+    const force = pedalPosition * maxBrakeForce;
+    this.brakePedalStatus = "pressed";
+    this._brakePedalForce = force;
+    return { brakePedalStatus: "pressed", brakePedalForce: force };
+  }
+  releaseBrakePedal() {
+    this.brakePedalStatus = "released";
+    this._brakePedalForce = 0;
+    return { brakePedalStatus: "released", brakePedalForce: 0 };
+  }
+  setCruiseControl(speed, activate, distanceToNextVehicle) {
+    const dist = Number(distanceToNextVehicle);
+    const spd = Number(speed);
+    if (this.engineState === "stopped") {
+      return {
+        error: "Start the engine before activating the cruise control."
+      };
+    }
+    if (activate) {
+      this.distanceToNextVehicle = dist;
+      if (spd < 0 || spd > 120 || spd % 5 !== 0) {
+        return { error: "Invalid speed" };
+      }
+      this.cruiseStatus = "active";
+      return {
+        cruiseStatus: "active",
+        currentSpeed: spd,
+        distanceToNextVehicle: dist
+      };
+    }
+    this.cruiseStatus = "inactive";
+    this.distanceToNextVehicle = dist;
+    return {
+      cruiseStatus: "inactive",
+      currentSpeed: spd,
+      distanceToNextVehicle: dist
+    };
+  }
+  get_current_speed() {
+    return { currentSpeed: this._random.uniform(0, 120) };
+  }
+  display_log(messages) {
+    return { log: messages };
+  }
+  estimate_drive_feasibility_by_mileage(distance) {
+    if (this.fuelLevel * MILE_PER_GALLON < distance) {
+      return { canDrive: false };
+    }
+    return { canDrive: true };
+  }
+  liter_to_gallon(liter) {
+    return { gallon: liter * 0.264172 };
+  }
+  gallon_to_liter(gallon) {
+    return { liter: gallon * 3.78541 };
+  }
+  estimate_distance(cityA, cityB) {
+    const distances = {
+      "83214-74532": 750,
+      "56108-62947": 320,
+      "71354-83462": 450,
+      "47329-52013": 290,
+      "69238-51479": 630,
+      "94016-83214": 980,
+      "94016-94704": 600,
+      "94704-08540": 2550,
+      "94016-08540": 1950,
+      "62947-47329": 1053,
+      "94016-62947": 780,
+      "74532-94016": 880
+    };
+    const key1 = `${cityA}-${cityB}`;
+    const key2 = `${cityB}-${cityA}`;
+    if (distances[key1] !== void 0) {
+      return { distance: distances[key1] };
+    }
+    if (distances[key2] !== void 0) {
+      return { distance: distances[key2] };
+    }
+    return { error: "distance not found in database." };
+  }
+  get_zipcode_based_on_city(city) {
+    var _a;
+    const zipcodes = {
+      Rivermist: "83214",
+      Stonebrook: "74532",
+      Maplecrest: "56108",
+      Silverpine: "62947",
+      Shadowridge: "71354",
+      "Sunset Valley": "83462",
+      Oakendale: "47329",
+      Willowbend: "52013",
+      "Crescent Hollow": "69238",
+      Autumnville: "51479",
+      "San Francisco": "94016"
+    };
+    return { zipcode: (_a = zipcodes[city]) != null ? _a : "00000" };
+  }
+  set_navigation(destination) {
+    this.destination = destination;
+    return { status: `Navigating to ${destination}` };
+  }
+  check_tire_pressure() {
+    const avgPressure = (this.frontLeftTirePressure + this.frontRightTirePressure + this.rearLeftTirePressure + this.rearRightTirePressure) / 4;
+    const healthyTirePressure = avgPressure >= 30 && avgPressure <= 35;
+    return {
+      frontLeftTirePressure: this.frontLeftTirePressure,
+      frontRightTirePressure: this.frontRightTirePressure,
+      rearLeftTirePressure: this.rearLeftTirePressure,
+      rearRightTirePressure: this.rearRightTirePressure,
+      healthy_tire_pressure: healthyTirePressure,
+      car_info: {}
+    };
+  }
+  find_nearest_tire_shop() {
+    return { shopLocation: "456 Oakwood Avenue, Rivermist, 83214" };
+  }
+};
+
+// src/multi-turn/constants.ts
+var CLASS_NAME_TO_CLASS = {
+  MathAPI,
+  MessageAPI,
+  TicketAPI,
+  TwitterAPI,
+  TravelAPI,
+  TradingBot,
+  VehicleControlAPI,
+  GorillaFileSystem
+};
+var STATELESS_CLASSES = /* @__PURE__ */ new Set(["MathAPI"]);
+
+// src/multi-turn/method-registry.ts
+var MethodRegistry = class {
+  // method_name -> instance_key
+  constructor() {
+    this.instances = {};
+    this.methodMapping = {};
+    for (const className of STATELESS_CLASSES) {
+      const ClassConstructor = CLASS_NAME_TO_CLASS[className];
+      if (ClassConstructor) {
+        const instance = new ClassConstructor();
+        const instanceKey = `${className}_stateless_instance`;
+        this.instances[instanceKey] = instance;
+        const methods = Object.getOwnPropertyNames(
+          Object.getPrototypeOf(instance)
+        ).filter(
+          (name) => typeof instance[name] === "function" && name !== "constructor"
+        );
+        for (const methodName of methods) {
+          this.methodMapping[methodName] = instanceKey;
+        }
+      }
+    }
+  }
+  getOrCreateInstance(className, testEntryId, modelName, scenario, longContext = false, isEvalRun = false) {
+    const instanceKey = `${modelName}_${testEntryId}_${className}_${isEvalRun ? "eval" : "model"}_instance`;
+    if (!this.instances[instanceKey]) {
+      const ClassConstructor = CLASS_NAME_TO_CLASS[className];
+      if (!ClassConstructor) {
+        throw new Error(`Unknown class: ${className}`);
+      }
+      const instance = new ClassConstructor();
+      if (!STATELESS_CLASSES.has(className) && typeof instance._loadScenario === "function") {
+        instance._loadScenario(scenario, longContext);
+      }
+      this.instances[instanceKey] = instance;
+      const methods = Object.getOwnPropertyNames(
+        Object.getPrototypeOf(instance)
+      ).filter(
+        (name) => typeof instance[name] === "function" && name !== "constructor" && !name.startsWith("_")
+      );
+      for (const methodName of methods) {
+        this.methodMapping[methodName] = instanceKey;
+      }
+    }
+    return this.instances[instanceKey];
+  }
+  // biome-ignore lint/suspicious/noExplicitAny: Returns dynamically typed class instance
+  getInstanceByMethod(methodName) {
+    const instanceKey = this.methodMapping[methodName];
+    if (!instanceKey) {
+      throw new Error(`Method not found: ${methodName}`);
+    }
+    return this.instances[instanceKey];
+  }
+  // Get all instances for a specific test case
+  getInstancesForTest(testEntryId, modelName) {
+    const result = {};
+    for (const [key, instance] of Object.entries(this.instances)) {
+      if (key.includes(`${modelName}_${testEntryId}`)) {
+        result[key] = instance;
+      }
+    }
+    return result;
+  }
+  // Clear instances for a specific test case
+  clearInstancesForTest(testEntryId, modelName) {
+    const keysToDelete = [];
+    for (const key of Object.keys(this.instances)) {
+      if (key.includes(`${modelName}_${testEntryId}`)) {
+        keysToDelete.push(key);
+      }
+    }
+    for (const key of keysToDelete) {
+      delete this.instances[key];
+    }
+    const methodsToDelete = [];
+    for (const [method, instanceKey] of Object.entries(this.methodMapping)) {
+      if (keysToDelete.includes(instanceKey)) {
+        methodsToDelete.push(method);
+      }
+    }
+    for (const method of methodsToDelete) {
+      delete this.methodMapping[method];
+    }
+  }
+  // Reset all instances (for testing)
+  reset() {
+    this.instances = {};
+    this.methodMapping = {};
+    for (const className of STATELESS_CLASSES) {
+      const ClassConstructor = CLASS_NAME_TO_CLASS[className];
+      if (ClassConstructor) {
+        const instance = new ClassConstructor();
+        const instanceKey = `${className}_stateless_instance`;
+        this.instances[instanceKey] = instance;
+        const methods = Object.getOwnPropertyNames(
+          Object.getPrototypeOf(instance)
+        ).filter(
+          (name) => typeof instance[name] === "function" && name !== "constructor"
+        );
+        for (const methodName of methods) {
+          this.methodMapping[methodName] = instanceKey;
+        }
+      }
+    }
+  }
+};
+var globalMethodRegistry = new MethodRegistry();
+
+// src/multi-turn/safe-executor.ts
+var WHITESPACE_REGEX2 = /\s/;
+var DELIMITER_REGEX = /[,)\]}]/;
+var FUNCTION_CALL_REGEX = /^(\w+(?:\.\w+)?)\((.*)\)$/s;
+var KEY_EQUALS_REGEX = /^(\w+)\s*=/;
+var _SafeExecutor = class _SafeExecutor {
+  static extractMethodName(toolName) {
+    var _a;
+    return (_a = toolName.split(".").pop()) != null ? _a : toolName;
+  }
+  static snakeToCamel(str) {
+    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+  }
+  static getMethodVariants(methodName) {
+    const camelCase = _SafeExecutor.snakeToCamel(methodName);
+    if (camelCase === methodName) {
+      return [methodName];
+    }
+    return [methodName, camelCase];
+  }
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: Method resolution requires nested loops
+  static findInstanceAndMethod(methodName, involvedInstances) {
+    const variants = _SafeExecutor.getMethodVariants(methodName);
+    if (involvedInstances) {
+      for (const instance of Object.values(involvedInstances)) {
+        if (instance && typeof instance === "object") {
+          for (const variant of variants) {
+            if (variant in instance && typeof instance[variant] === "function") {
+              return { instance, resolvedMethodName: variant };
+            }
+          }
+        }
+      }
+    }
+    for (const variant of variants) {
+      try {
+        const instance = globalMethodRegistry.getInstanceByMethod(variant);
+        if (instance) {
+          return { instance, resolvedMethodName: variant };
+        }
+      } catch (e) {
+      }
+    }
+    return void 0;
+  }
+  static buildArgs(methodName, args) {
+    const paramOrder = _SafeExecutor.METHOD_PARAM_ORDER[methodName];
+    if (!paramOrder) {
+      return Object.values(args);
+    }
+    return paramOrder.map((param) => args[param]);
+  }
+  static isDangerous(methodName) {
+    return _SafeExecutor.DANGEROUS_METHODS.has(methodName) || methodName.startsWith("__");
+  }
+  static async execute(toolCall, involvedInstances) {
+    const methodName = _SafeExecutor.extractMethodName(toolCall.toolName);
+    if (_SafeExecutor.isDangerous(methodName)) {
+      return {
+        success: false,
+        error: `Dangerous method blocked: ${methodName}`
+      };
+    }
+    const found = _SafeExecutor.findInstanceAndMethod(
+      methodName,
+      involvedInstances
+    );
+    if (!found) {
+      return {
+        success: false,
+        error: `Instance not found for method: ${methodName}`
+      };
+    }
+    const { instance, resolvedMethodName } = found;
+    const method = instance[resolvedMethodName];
+    if (typeof method !== "function") {
+      return {
+        success: false,
+        error: `Method not found: ${methodName}`
+      };
+    }
+    try {
+      const args = _SafeExecutor.buildArgs(methodName, toolCall.args);
+      const result = method.apply(instance, args);
+      const finalResult = result instanceof Promise ? await result : result;
+      return { success: true, result: finalResult };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Execution error: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  static async executeMany(toolCalls, involvedInstances) {
+    const results = [];
+    for (const toolCall of toolCalls) {
+      results.push(await _SafeExecutor.execute(toolCall, involvedInstances));
+    }
+    return results;
+  }
+  static serializeResult(result) {
+    if (result === null || result === void 0) {
+      return "None";
+    }
+    if (typeof result === "string") {
+      return result;
+    }
+    if (typeof result === "object") {
+      try {
+        return JSON.stringify(result);
+      } catch (e) {
+        return String(result);
+      }
+    }
+    return String(result);
+  }
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: Python call parsing requires complex branching
+  static parsePythonCall(pythonCall) {
+    const match = pythonCall.match(FUNCTION_CALL_REGEX);
+    if (!match) {
+      throw new Error(`Invalid function call format: ${pythonCall}`);
+    }
+    const [, fullMethodName, argsString] = match;
+    const methodName = fullMethodName.split(".").pop() || fullMethodName;
+    const args = {};
+    if (!argsString.trim()) {
+      return { toolName: methodName, args };
+    }
+    const parsedArgs = _SafeExecutor.parseArgsString(argsString);
+    const paramOrder = _SafeExecutor.METHOD_PARAM_ORDER[methodName];
+    if (paramOrder && parsedArgs.some((a) => a.key)) {
+      for (const arg of parsedArgs) {
+        if (arg.key) {
+          args[arg.key] = arg.value;
+        }
+      }
+    } else if (paramOrder) {
+      let idx = 0;
+      for (const arg of parsedArgs) {
+        if (arg.key) {
+          args[arg.key] = arg.value;
+        } else if (idx < paramOrder.length) {
+          args[paramOrder[idx]] = arg.value;
+          idx++;
+        }
+      }
+    } else {
+      let idx = 0;
+      for (const arg of parsedArgs) {
+        if (arg.key) {
+          args[arg.key] = arg.value;
+        } else {
+          args[`arg${idx}`] = arg.value;
+          idx++;
+        }
+      }
+    }
+    return { toolName: methodName, args };
+  }
+  static parseArgsString(argsString) {
+    const results = [];
+    let i = 0;
+    const s = argsString.trim();
+    while (i < s.length) {
+      while (i < s.length && WHITESPACE_REGEX2.test(s[i])) {
+        i++;
+      }
+      if (i >= s.length) {
+        break;
+      }
+      let key;
+      const keyMatch = s.slice(i).match(KEY_EQUALS_REGEX);
+      if (keyMatch) {
+        key = keyMatch[1];
+        i += keyMatch[0].length;
+      }
+      while (i < s.length && WHITESPACE_REGEX2.test(s[i])) {
+        i++;
+      }
+      const value = _SafeExecutor.parseValue(s, i);
+      i = value.endIndex;
+      results.push({ key, value: value.value });
+      while (i < s.length && WHITESPACE_REGEX2.test(s[i])) {
+        i++;
+      }
+      if (i < s.length && s[i] === ",") {
+        i++;
+      }
+    }
+    return results;
+  }
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: Python value parsing requires complex branching for strings, lists, dicts, etc.
+  static parseValue(s, start) {
+    let i = start;
+    while (i < s.length && WHITESPACE_REGEX2.test(s[i])) {
+      i++;
+    }
+    if (s[i] === "'" || s[i] === '"') {
+      const quote = s[i];
+      i++;
+      let value = "";
+      while (i < s.length && s[i] !== quote) {
+        if (s[i] === "\\" && i + 1 < s.length) {
+          const next = s[i + 1];
+          if (next === "n") {
+            value += "\n";
+          } else if (next === "t") {
+            value += "	";
+          } else if (next === "r") {
+            value += "\r";
+          } else {
+            value += next;
+          }
+          i += 2;
+        } else {
+          value += s[i];
+          i++;
+        }
+      }
+      return { value, endIndex: i + 1 };
+    }
+    if (s[i] === "[") {
+      return _SafeExecutor.parseList(s, i);
+    }
+    if (s[i] === "{") {
+      return _SafeExecutor.parseDict(s, i);
+    }
+    let token = "";
+    while (i < s.length && !DELIMITER_REGEX.test(s[i])) {
+      token += s[i];
+      i++;
+    }
+    token = token.trim();
+    if (token === "True") {
+      return { value: true, endIndex: i };
+    }
+    if (token === "False") {
+      return { value: false, endIndex: i };
+    }
+    if (token === "None") {
+      return { value: null, endIndex: i };
+    }
+    const num = Number(token);
+    if (!Number.isNaN(num)) {
+      return { value: num, endIndex: i };
+    }
+    return { value: token, endIndex: i };
+  }
+  static parseList(s, start) {
+    const items = [];
+    let i = start + 1;
+    while (i < s.length && s[i] !== "]") {
+      while (i < s.length && WHITESPACE_REGEX2.test(s[i])) {
+        i++;
+      }
+      if (s[i] === "]") {
+        break;
+      }
+      const item = _SafeExecutor.parseValue(s, i);
+      items.push(item.value);
+      i = item.endIndex;
+      while (i < s.length && WHITESPACE_REGEX2.test(s[i])) {
+        i++;
+      }
+      if (s[i] === ",") {
+        i++;
+      }
+    }
+    return { value: items, endIndex: i + 1 };
+  }
+  static parseDict(s, start) {
+    const obj = {};
+    let i = start + 1;
+    while (i < s.length && s[i] !== "}") {
+      while (i < s.length && WHITESPACE_REGEX2.test(s[i])) {
+        i++;
+      }
+      if (s[i] === "}") {
+        break;
+      }
+      const keyResult = _SafeExecutor.parseValue(s, i);
+      i = keyResult.endIndex;
+      while (i < s.length && WHITESPACE_REGEX2.test(s[i])) {
+        i++;
+      }
+      if (s[i] === ":") {
+        i++;
+      }
+      const valResult = _SafeExecutor.parseValue(s, i);
+      obj[String(keyResult.value)] = valResult.value;
+      i = valResult.endIndex;
+      while (i < s.length && WHITESPACE_REGEX2.test(s[i])) {
+        i++;
+      }
+      if (s[i] === ",") {
+        i++;
+      }
+    }
+    return { value: obj, endIndex: i + 1 };
+  }
+};
+_SafeExecutor.DANGEROUS_METHODS = /* @__PURE__ */ new Set([
+  "kill",
+  "exit",
+  "quit",
+  "system",
+  "exec",
+  "eval",
+  "import"
+]);
+_SafeExecutor.METHOD_PARAM_ORDER = {
+  cd: ["folder"],
+  mkdir: ["dir_name"],
+  touch: ["file_name"],
+  echo: ["content", "file_name"],
+  cat: ["file_name"],
+  grep: ["file_name", "pattern"],
+  sort: ["file_name"],
+  tail: ["file_name", "lines"],
+  diff: ["file_name1", "file_name2"],
+  mv: ["source", "destination"],
+  cp: ["source", "destination"],
+  rm: ["file_name"],
+  rmdir: ["dir_name"],
+  find: ["path", "name"],
+  ls: ["a"],
+  pwd: [],
+  wc: ["file_name", "mode"],
+  du: ["human_readable"],
+  // TwitterAPI (PostingAPI)
+  authenticate_twitter: ["username", "password"],
+  posting_get_login_status: [],
+  post_tweet: ["content", "tags", "mentions"],
+  retweet: ["tweet_id"],
+  comment: ["tweet_id", "comment_content"],
+  mention: ["tweet_id", "mentioned_usernames"],
+  follow_user: ["username_to_follow"],
+  list_all_following: [],
+  unfollow_user: ["username_to_unfollow"],
+  get_tweet: ["tweet_id"],
+  get_user_tweets: ["username"],
+  search_tweets: ["keyword"],
+  get_tweet_comments: ["tweet_id"],
+  get_user_stats: ["username"],
+  // TicketAPI
+  create_ticket: ["title", "description", "priority"],
+  get_ticket: ["ticket_id"],
+  close_ticket: ["ticket_id"],
+  resolve_ticket: ["ticket_id", "resolution"],
+  edit_ticket: ["ticket_id", "updates"],
+  ticket_login: ["username", "password"],
+  ticket_get_login_status: [],
+  logout: [],
+  get_user_tickets: ["status"],
+  // MathAPI
+  mean: ["numbers"],
+  std: ["numbers"],
+  add: ["a", "b"],
+  subtract: ["a", "b"],
+  multiply: ["a", "b"],
+  divide: ["a", "b"],
+  absolute: ["number"],
+  absolute_value: ["number"],
+  power: ["base", "exponent"],
+  logarithm: ["value", "base", "precision"],
+  log: ["value", "base"],
+  max_value: ["numbers"],
+  min_value: ["numbers"],
+  percentage: ["part", "whole"],
+  round_number: ["number", "decimal_places"],
+  square_root: ["number", "precision"],
+  standard_deviation: ["numbers"],
+  sum_values: ["numbers"],
+  imperial_si_conversion: ["value", "unit_in", "unit_out"],
+  si_unit_conversion: ["value", "unit_in", "unit_out"],
+  // MessageAPI
+  send_message: ["receiver_id", "message"],
+  view_messages_received: [],
+  view_messages_sent: [],
+  add_contact: ["user_name", "user_id"],
+  delete_contact: ["user_id"],
+  delete_message: ["receiver_id"],
+  search_messages: ["keyword"],
+  get_message_stats: [],
+  get_user_id: ["user"],
+  message_login: ["user_id"],
+  message_get_login_status: [],
+  list_users: [],
+  // TradingBot
+  add_to_watchlist: ["stock"],
+  cancel_order: ["order_id"],
+  filter_stocks_by_price: ["stocks", "min_price", "max_price"],
+  fund_account: ["amount"],
+  get_account_info: [],
+  get_available_stocks: ["sector"],
+  get_current_time: [],
+  get_order_details: ["order_id"],
+  get_order_history: [],
+  get_stock_info: ["symbol"],
+  get_symbol_by_name: ["name"],
+  get_transaction_history: ["start_date", "end_date"],
+  get_watchlist: [],
+  notify_price_change: ["stocks", "threshold"],
+  place_order: ["order_type", "symbol", "price", "amount"],
+  remove_stock_from_watchlist: ["symbol"],
+  trading_get_login_status: [],
+  trading_login: ["username", "password"],
+  trading_logout: [],
+  withdraw_funds: ["amount"],
+  // TravelAPI
+  authenticate_travel: [
+    "client_id",
+    "client_secret",
+    "refresh_token",
+    "grant_type",
+    "user_first_name",
+    "user_last_name"
+  ],
+  book_flight: [
+    "access_token",
+    "card_id",
+    "travel_date",
+    "travel_from",
+    "travel_to",
+    "travel_class"
+  ],
+  cancel_booking: ["access_token", "booking_id"],
+  compute_exchange_rate: ["base_currency", "target_currency", "value"],
+  contact_customer_support: ["booking_id", "message"],
+  get_all_credit_cards: [],
+  get_booking_history: ["access_token"],
+  get_budget_fiscal_year: ["lastModifiedAfter", "includeRemoved"],
+  get_credit_card_balance: ["access_token", "card_id"],
+  get_flight_cost: [
+    "travel_from",
+    "travel_to",
+    "travel_date",
+    "travel_class"
+  ],
+  get_nearest_airport_by_city: ["location"],
+  list_all_airports: [],
+  purchase_insurance: [
+    "access_token",
+    "insurance_type",
+    "insurance_cost",
+    "booking_id",
+    "card_id"
+  ],
+  register_credit_card: [
+    "access_token",
+    "card_number",
+    "expiration_date",
+    "cardholder_name",
+    "card_verification_number"
+  ],
+  retrieve_invoice: ["access_token", "booking_id", "insurance_id"],
+  set_budget_limit: ["access_token", "budget_limit"],
+  travel_get_login_status: [],
+  verify_traveler_information: [
+    "first_name",
+    "last_name",
+    "date_of_birth",
+    "passport_number"
+  ],
+  // VehicleControlAPI
+  activateParkingBrake: ["mode"],
+  adjustClimateControl: ["temperature", "unit", "fanSpeed", "mode"],
+  check_tire_pressure: [],
+  displayCarStatus: ["option"],
+  display_log: ["messages"],
+  estimate_distance: ["cityA", "cityB"],
+  estimate_drive_feasibility_by_mileage: ["distance"],
+  fillFuelTank: ["fuelAmount"],
+  find_nearest_tire_shop: [],
+  gallon_to_liter: ["gallon"],
+  get_current_speed: [],
+  get_outside_temperature_from_google: [],
+  get_outside_temperature_from_weather_com: [],
+  get_zipcode_based_on_city: ["city"],
+  liter_to_gallon: ["liter"],
+  lockDoors: ["unlock", "door"],
+  pressBrakePedal: ["pedalPosition"],
+  releaseBrakePedal: [],
+  setCruiseControl: ["speed", "activate", "distanceToNextVehicle"],
+  setHeadlights: ["mode"],
+  set_navigation: ["destination"],
+  startEngine: ["ignitionMode"]
+};
+var SafeExecutor = _SafeExecutor;
+
+// src/multi-turn/execution-engine.ts
+async function executeMultiTurnFuncCall(toolCalls, initialConfig, involvedClasses, modelName, testEntryId, longContext = false, isEvalRun = false) {
+  const configCopy = JSON.parse(JSON.stringify(initialConfig));
+  const involvedInstances = {};
+  for (const className of involvedClasses) {
+    involvedInstances[className] = globalMethodRegistry.getOrCreateInstance(
+      className,
+      testEntryId,
+      modelName,
+      configCopy[className] || {},
+      longContext,
+      isEvalRun
+    );
+  }
+  const results = await SafeExecutor.executeMany(toolCalls, involvedInstances);
+  const executionResults = results.map(
+    (r) => r.success ? SafeExecutor.serializeResult(r.result) : `Error during execution: ${r.error}`
+  );
+  return { executionResults, involvedInstances };
+}
+function resetInstancesForTest(testEntryId, modelName) {
+  globalMethodRegistry.clearInstancesForTest(testEntryId, modelName);
+}
+function isEmptyExecuteResponse(responseList) {
+  return responseList.every(
+    (response) => response === "" || response === "None" || response === "{}" || response === "[]" || response.includes("Error during execution")
+  );
+}
+
+// src/multi-turn/response-checker.ts
+function responseChecker(modelResponseList, groundTruthResponseList, _turnIndex) {
+  const isSubsequenceResult = isSubsequenceUnordered(
+    groundTruthResponseList,
+    modelResponseList
+  );
+  if (!isSubsequenceResult.isSubsequence) {
+    return {
+      valid: false,
+      error_type: "multi_turn:execution_response_mismatch",
+      details: {
+        missing_items: isSubsequenceResult.missingItems,
+        model_response: modelResponseList,
+        ground_truth_response: groundTruthResponseList
+      }
+    };
+  }
+  return { valid: true };
+}
+function isSubsequenceUnordered(groundTruthList, modelList) {
+  if (groundTruthList.length === 0) {
+    return { isSubsequence: true, missingItems: [] };
+  }
+  if (modelList.length === 0) {
+    return { isSubsequence: false, missingItems: [...groundTruthList] };
+  }
+  const remainingModel = [...modelList];
+  const missingItems = [];
+  for (const groundTruthItem of groundTruthList) {
+    let found = false;
+    for (let i = 0; i < remainingModel.length; i++) {
+      if (itemsEqual(groundTruthItem, remainingModel[i])) {
+        remainingModel.splice(i, 1);
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      missingItems.push(groundTruthItem);
+    }
+  }
+  return {
+    isSubsequence: missingItems.length === 0,
+    missingItems
+  };
+}
+function itemsEqual(a, b) {
+  if (a == null && b == null) {
+    return true;
+  }
+  if (a == null || b == null) {
+    return false;
+  }
+  if (typeof a === "string" && typeof b === "string") {
+    return normalizeResponse(a) === normalizeResponse(b);
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    try {
+      return JSON.stringify(normalizeObject2(a)) === JSON.stringify(normalizeObject2(b));
+    } catch (e) {
+      return String(a) === String(b);
+    }
+  }
+  return a === b;
+}
+function normalizeResponse(response) {
+  return response.trim().replace(/\s+/g, " ");
+}
+function normalizeObject2(obj) {
+  if (obj == null) {
+    return obj;
+  }
+  if (typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => normalizeObject2(item));
+  }
+  const normalized = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) {
+      normalized[key] = normalizeObject2(value);
+    }
+  }
+  const sorted = {};
+  for (const key of Object.keys(normalized).sort()) {
+    sorted[key] = normalized[key];
+  }
+  return sorted;
+}
+
+// src/multi-turn/state-checker.ts
+function stateChecker(modelInstances, groundTruthInstances) {
+  for (const [className, groundTruthInstance] of Object.entries(
+    groundTruthInstances
+  )) {
+    const modelInstance = modelInstances[className];
+    if (!modelInstance) {
+      return {
+        valid: false,
+        error_type: "multi_turn:instance_state_mismatch",
+        details: {
+          differences: { [className]: "Instance not found in model instances" }
+        }
+      };
+    }
+    const comparisonResult = compareInstances(
+      modelInstance,
+      groundTruthInstance
+    );
+    if (!comparisonResult.valid) {
+      console.log("[DEBUG] State mismatch detected!");
+      console.log(
+        "[DEBUG] Differences:",
+        JSON.stringify(comparisonResult.differences, null, 2)
+      );
+      console.log(
+        "[DEBUG] Model instance state:",
+        JSON.stringify(serializeInstanceState(modelInstance), null, 2)
+      );
+      console.log(
+        "[DEBUG] Ground truth instance state:",
+        JSON.stringify(serializeInstanceState(groundTruthInstance), null, 2)
+      );
+      return {
+        valid: false,
+        error_type: "multi_turn:instance_state_mismatch",
+        details: {
+          differences: comparisonResult.differences,
+          model_instance_state: serializeInstanceState(modelInstance),
+          ground_truth_instance_state: serializeInstanceState(groundTruthInstance)
+        }
+      };
+    }
+  }
+  return { valid: true };
+}
+function compareInstances(modelObject, groundTruthObject) {
+  const differences = {};
+  const SKIP_ATTRS = /* @__PURE__ */ new Set(["parent", "_parent"]);
+  for (const attrName of Object.keys(groundTruthObject)) {
+    if (attrName.startsWith("_") || SKIP_ATTRS.has(attrName)) {
+      continue;
+    }
+    const modelAttr = modelObject[attrName];
+    const groundTruthAttr = groundTruthObject[attrName];
+    if (!deepEqual(modelAttr, groundTruthAttr)) {
+      differences[attrName] = {
+        model: modelAttr,
+        ground_truth: groundTruthAttr
+      };
+    }
+  }
+  return {
+    valid: Object.keys(differences).length === 0,
+    differences
+  };
+}
+var SKIP_KEYS = /* @__PURE__ */ new Set(["parent", "_parent"]);
+function shouldSkipKey(key) {
+  return key.startsWith("_") || SKIP_KEYS.has(key);
+}
+function getFilteredKeys(obj) {
+  return Object.keys(obj).filter((k) => !shouldSkipKey(k));
+}
+function deepEqualArrays(a, b, seen) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (!deepEqual(a[i], b[i], seen)) {
+      return false;
+    }
+  }
+  return true;
+}
+function deepEqualObjects(a, b, seen) {
+  const keysA = getFilteredKeys(a);
+  const keysB = getFilteredKeys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  for (const key of keysA) {
+    if (!keysB.includes(key)) {
+      return false;
+    }
+    if (!deepEqual(a[key], b[key], seen)) {
+      return false;
+    }
+  }
+  return true;
+}
+function deepEqual(a, b, seen = /* @__PURE__ */ new WeakSet()) {
+  if (a === b) {
+    return true;
+  }
+  if (a == null || b == null) {
+    return a === b;
+  }
+  if (typeof a !== typeof b) {
+    return false;
+  }
+  if (typeof a !== "object") {
+    return a === b;
+  }
+  if (seen.has(a) || seen.has(b)) {
+    return true;
+  }
+  seen.add(a);
+  if (typeof b === "object") {
+    seen.add(b);
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return deepEqualArrays(a, b, seen);
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) {
+    return false;
+  }
+  return deepEqualObjects(a, b, seen);
+}
+function serializeInstanceState(instance) {
+  const state = {};
+  for (const [key, value] of Object.entries(instance)) {
+    if (!key.startsWith("_")) {
+      try {
+        if (key === "root" && typeof value === "object") {
+          state[key] = serializeDirectory(value);
+        } else {
+          state[key] = typeof value === "object" ? JSON.parse(JSON.stringify(value)) : value;
+        }
+      } catch (e) {
+        state[key] = String(value);
+      }
+    }
+  }
+  return state;
+}
+function serializeDirectory(dir, depth = 0) {
+  if (depth > 5) {
+    return { value: "[Max depth reached]" };
+  }
+  const result = {
+    name: dir.name,
+    contents: {}
+  };
+  const contents = result.contents;
+  for (const [name, item] of Object.entries(dir.contents || {})) {
+    if (item instanceof File) {
+      contents[name] = { type: "file", content: item.content };
+    } else if (item instanceof Directory) {
+      contents[name] = serializeDirectory(item, depth + 1);
+    }
+  }
+  return result;
+}
+
+// src/multi-turn/checker.ts
+function parseGroundTruth(pythonCalls) {
+  return pythonCalls.map((call) => SafeExecutor.parsePythonCall(call));
+}
+async function multiTurnChecker(modelToolCalls, groundTruthPythonCalls, testEntry, testCategory, modelName) {
+  const initialConfig = testEntry.initial_config || {};
+  const involvedClasses = testEntry.involved_classes || [];
+  resetInstancesForTest(testEntry.id, modelName);
+  resetInstancesForTest(testEntry.id, `${modelName}_ground_truth`);
+  const initResult = await executeMultiTurnFuncCall(
+    [],
+    initialConfig,
+    involvedClasses,
+    modelName,
+    testEntry.id,
+    testCategory.includes("long_context"),
+    true
+  );
+  const initGtResult = await executeMultiTurnFuncCall(
+    [],
+    initialConfig,
+    involvedClasses,
+    `${modelName}_ground_truth`,
+    testEntry.id,
+    testCategory.includes("long_context"),
+    true
+  );
+  const allTurnModelExecutionResults = [];
+  let finalModelInstances = initResult.involvedInstances;
+  let finalGroundTruthInstances = initGtResult.involvedInstances;
+  for (let turnIndex = 0; turnIndex < groundTruthPythonCalls.length; turnIndex++) {
+    const groundTruthCalls = parseGroundTruth(
+      groundTruthPythonCalls[turnIndex]
+    );
+    const modelSteps = modelToolCalls[turnIndex] || [];
+    const singleTurnModelExecutionResults = [];
+    for (const stepToolCalls of modelSteps) {
+      const stepResult = await executeMultiTurnFuncCall(
+        stepToolCalls,
+        initialConfig,
+        involvedClasses,
+        modelName,
+        testEntry.id,
+        testCategory.includes("long_context"),
+        true
+      );
+      singleTurnModelExecutionResults.push(...stepResult.executionResults);
+      finalModelInstances = stepResult.involvedInstances;
+    }
+    const groundTruthResult = await executeMultiTurnFuncCall(
+      groundTruthCalls,
+      initialConfig,
+      involvedClasses,
+      `${modelName}_ground_truth`,
+      testEntry.id,
+      testCategory.includes("long_context"),
+      true
+    );
+    allTurnModelExecutionResults.push(...singleTurnModelExecutionResults);
+    finalGroundTruthInstances = groundTruthResult.involvedInstances;
+    if (groundTruthCalls.length === 0) {
+      continue;
+    }
+    const stateCheckResult = stateChecker(
+      finalModelInstances,
+      finalGroundTruthInstances
+    );
+    if (!stateCheckResult.valid) {
+      return {
+        valid: false,
+        error_type: stateCheckResult.error_type,
+        details: stateCheckResult.details
+      };
+    }
+    const responseCheckResult = responseChecker(
+      allTurnModelExecutionResults,
+      groundTruthResult.executionResults,
+      turnIndex
+    );
+    if (!responseCheckResult.valid) {
+      return {
+        valid: false,
+        error_type: responseCheckResult.error_type,
+        details: responseCheckResult.details
+      };
+    }
+  }
+  return { valid: true };
+}
+function multiTurnIrrelevanceChecker(modelToolCalls, groundTruthPythonCalls) {
+  for (let turnIndex = 0; turnIndex < groundTruthPythonCalls.length; turnIndex++) {
+    const groundTruthCalls = groundTruthPythonCalls[turnIndex];
+    const modelSteps = modelToolCalls[turnIndex] || [];
+    const flatModelCalls = modelSteps.flat();
+    const modelCallStrings = flatModelCalls.map(
+      (tc) => tc.args ? JSON.stringify(tc) : "None"
+    );
+    if (groundTruthCalls.length === 0 && !isEmptyExecuteResponse(modelCallStrings)) {
+      return {
+        valid: false,
+        error_type: "multi_turn:irrelevance_error:decoder_success",
+        details: { model_response_decoded: modelSteps }
+      };
+    }
+  }
+  return { valid: true };
+}
+function resetTestInstances(testEntryId, modelName) {
+  resetInstancesForTest(testEntryId, modelName);
+  resetInstancesForTest(testEntryId, `${modelName}_ground_truth`);
+}
+
+// src/benchmarks/bfcl-multi-turn.ts
+var LINE_SPLIT_REGEX2 = /\r?\n/;
+var NUMERIC_STRING_REGEX2 = /^\d+$/;
+var MAXIMUM_STEP_LIMIT = 20;
+var DEFAULT_USER_PROMPT_FOR_ADDITIONAL_FUNCTION_FC = "I have updated some more functions you can choose from. What about now?";
+var MULTI_TURN_SYSTEM_PROMPT = `You are an expert in composing functions. You are given a question and a set of possible functions. Based on the question, you will need to make one or more function/tool calls to achieve the purpose. If none of the functions can be used, point it out. If the given question lacks the parameters required by the function, also point it out.
+
+At each turn, you should try your best to complete the tasks requested by the user within the current turn. Continue to output functions to call until you have fulfilled the user's request to the best of your ability. Once you have no more functions to call, the system will consider the current turn complete and proceed to the next turn or task.`;
+var RETRY_MAX_ATTEMPTS = 5;
+var RETRY_INITIAL_DELAY_MS = 1e3;
+var RETRY_MAX_DELAY_MS = 6e4;
+var RETRY_BACKOFF_MULTIPLIER = 2;
+var MULTI_TURN_DATASETS = [
+  {
+    name: "bfcl-multi-turn-base",
+    description: "BFCL v4 Multi-Turn Base Function Calling",
+    testFile: "BFCL_v4_multi_turn_base.jsonl",
+    answerFile: "possible_answer/BFCL_v4_multi_turn_base.jsonl"
+  },
+  {
+    name: "bfcl-multi-turn-long-context",
+    description: "BFCL v4 Multi-Turn Long-Context Function Calling",
+    testFile: "BFCL_v4_multi_turn_long_context.jsonl",
+    answerFile: "possible_answer/BFCL_v4_multi_turn_long_context.jsonl"
+  },
+  {
+    name: "bfcl-multi-turn-miss-func",
+    description: "BFCL v4 Multi-Turn Missing Function Calling",
+    testFile: "BFCL_v4_multi_turn_miss_func.jsonl",
+    answerFile: "possible_answer/BFCL_v4_multi_turn_miss_func.jsonl"
+  },
+  {
+    name: "bfcl-multi-turn-miss-param",
+    description: "BFCL v4 Multi-Turn Missing Parameter Function Calling",
+    testFile: "BFCL_v4_multi_turn_miss_param.jsonl",
+    answerFile: "possible_answer/BFCL_v4_multi_turn_miss_param.jsonl"
+  }
+];
+var MULTI_TURN_DOCS = {
+  GorillaFileSystem: "multi_turn_func_doc/gorilla_file_system.jsonl",
+  MathAPI: "multi_turn_func_doc/math_api.jsonl",
+  MessageAPI: "multi_turn_func_doc/message_api.jsonl",
+  TwitterAPI: "multi_turn_func_doc/posting_api.jsonl",
+  TicketAPI: "multi_turn_func_doc/ticket_api.jsonl",
+  TradingBot: "multi_turn_func_doc/trading_bot.jsonl",
+  TravelAPI: "multi_turn_func_doc/travel_booking.jsonl",
+  VehicleControlAPI: "multi_turn_func_doc/vehicle_control.jsonl"
+};
+var toolDocCache = /* @__PURE__ */ new Map();
+var normalizeTurns = (question) => {
+  if (Array.isArray(question) && question.some((m) => Array.isArray(m))) {
+    return question;
+  }
+  return [question];
+};
+var fixSchema = (schema) => {
+  if (!schema || typeof schema !== "object") {
+    return { type: "object", properties: {} };
+  }
+  const copy = Array.isArray(schema) ? schema.map((v) => fixSchema(v)) : { ...schema };
+  if (Array.isArray(copy)) {
+    return copy;
+  }
+  if (!copy.type) {
+    copy.type = "object";
+  }
+  if (copy.type === "dict") {
+    copy.type = "object";
+  }
+  if (copy.type === "tuple") {
+    copy.type = "array";
+  }
+  if (copy.type === "integer" || copy.type === "float") {
+    copy.type = "number";
+  }
+  if (copy.properties && typeof copy.properties === "object") {
+    for (const k of Object.keys(copy.properties)) {
+      copy.properties[k] = fixSchema(
+        copy.properties[k]
+      );
+    }
+  }
+  if (copy.items) {
+    copy.items = fixSchema(copy.items);
+  }
+  return copy;
+};
+var sanitizeName = (toolName) => {
+  const s = toolName.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+  return s.length > 0 ? s : "tool";
+};
+var buildTransformedTools = (tools) => {
+  const nameMap = /* @__PURE__ */ new Map();
+  const transformedTools = tools.map((t) => {
+    const fixed = fixSchema(t.parameters);
+    const isObjectSchema = fixed && typeof fixed === "object" && fixed.type === "object";
+    const inputSchema = isObjectSchema ? fixed : { type: "object", properties: {} };
+    const sanitized = sanitizeName(t.name);
+    nameMap.set(sanitized, t.name);
+    return {
+      type: "function",
+      name: sanitized,
+      description: t.description,
+      inputSchema
+    };
+  });
+  return { transformedTools, nameMap };
+};
+var buildToolsMap = (transformedTools) => Object.fromEntries(
+  transformedTools.map((t) => [
+    t.name,
+    (0, import_ai2.tool)({
+      description: typeof t.description === "string" ? t.description : void 0,
+      inputSchema: (0, import_ai2.jsonSchema)(t.inputSchema)
+    })
+  ])
+);
+var parseToolArgs = (extractedArgs) => {
+  if (typeof extractedArgs !== "string") {
+    return extractedArgs;
+  }
+  try {
+    return JSON.parse(extractedArgs);
+  } catch (e) {
+    try {
+      const escaped = extractedArgs.replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+      return JSON.parse(escaped);
+    } catch (e2) {
+      return extractedArgs;
+    }
+  }
+};
+var getSanitizedName = (rawName, transformedTools) => {
+  var _a, _b;
+  if (typeof rawName === "string" && NUMERIC_STRING_REGEX2.test(rawName)) {
+    return (_b = (_a = transformedTools[Number(rawName)]) == null ? void 0 : _a.name) != null ? _b : rawName;
+  }
+  return rawName;
+};
+var restoreToolCalls = (toolCalls, nameMap, transformedTools) => (toolCalls || []).map((c) => {
+  var _a, _b, _c, _d, _e, _f;
+  const call = c;
+  const rawName = (_a = call.toolName) != null ? _a : call.name;
+  const sanitizedFromIndex = getSanitizedName(rawName, transformedTools);
+  const originalName = (_b = nameMap.get(sanitizedFromIndex)) != null ? _b : sanitizedFromIndex;
+  const extractedArgs = (_f = (_e = (_d = (_c = call.args) != null ? _c : call.arguments) != null ? _d : call.input) != null ? _e : call.params) != null ? _f : call.parameters;
+  const parsedArgs = parseToolArgs(extractedArgs);
+  return {
+    toolCallId: typeof call.toolCallId === "string" ? call.toolCallId : void 0,
+    toolName: String(originalName),
+    args: parsedArgs != null ? parsedArgs : {}
+  };
+});
+var loadToolsForClass = async (className, dataDir) => {
+  const forceRefresh = process.env.BFCL_FORCE_CACHE_REFRESH === "true";
+  if (!forceRefresh) {
+    const cached = toolDocCache.get(className);
+    if (cached) {
+      return cached;
+    }
+  }
+  const relPath = MULTI_TURN_DOCS[className];
+  if (!relPath) {
+    throw new Error(`Missing tool doc mapping for class: ${className}`);
+  }
+  const raw = await import_node_fs3.promises.readFile(import_node_path3.default.join(dataDir, relPath), "utf-8");
+  const tools = raw.split(LINE_SPLIT_REGEX2).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line)).map((entry) => {
+    var _a;
+    const methodName = typeof entry.name === "string" ? entry.name : "tool";
+    const fullName = `${className}.${methodName}`;
+    return {
+      name: fullName,
+      description: typeof entry.description === "string" ? entry.description : void 0,
+      parameters: (_a = entry.parameters) != null ? _a : {
+        type: "object",
+        properties: {}
+      }
+    };
+  });
+  toolDocCache.set(className, tools);
+  return tools;
+};
+var loadToolsForClasses = async (classes, dataDir) => {
+  const toolsPerClass = await Promise.all(
+    classes.map((cls) => loadToolsForClass(cls, dataDir))
+  );
+  return toolsPerClass.flat();
+};
+var getMethodName = (toolName) => {
+  var _a;
+  return (_a = toolName.split(".").pop()) != null ? _a : toolName;
+};
+var isRateLimitError = (error) => {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message.toLowerCase();
+  if (message.includes("429") || message.includes("rate limit")) {
+    return true;
+  }
+  const anyError = error;
+  if (anyError.status === 429 || anyError.statusCode === 429) {
+    return true;
+  }
+  if (anyError.cause && typeof anyError.cause === "object" && anyError.cause.status === 429) {
+    return true;
+  }
+  return false;
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var withRetry = async (fn, options = {}) => {
+  let lastError;
+  let delay = RETRY_INITIAL_DELAY_MS;
+  for (let attempt = 1; attempt <= RETRY_MAX_ATTEMPTS; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (!isRateLimitError(error)) {
+        throw error;
+      }
+      if (attempt === RETRY_MAX_ATTEMPTS) {
+        throw error;
+      }
+      if (options.debug) {
+        console.log(
+          `[DEBUG] Rate limit hit, retrying in ${delay}ms (attempt ${attempt}/${RETRY_MAX_ATTEMPTS})`
+        );
+      }
+      await sleep(delay);
+      delay = Math.min(delay * RETRY_BACKOFF_MULTIPLIER, RETRY_MAX_DELAY_MS);
+    }
+  }
+  throw lastError;
+};
+var createBfclMultiTurnBenchmark = (name, description, testDataFile, answerDataFile) => ({
+  name,
+  version: "1.0.0",
+  description,
+  async run(model, config) {
+    console.log("Starting BFCL multi-turn benchmark...");
+    toolDocCache.clear();
+    globalMethodRegistry.reset();
+    const logs = [];
+    let correctCount = 0;
+    let testCases = [];
+    const dataPath = resolveDataDir();
+    const configHash = JSON.stringify(config || {});
+    const runId = `bfcl_${Date.now()}_${Math.random().toString(36).slice(2, 8)}_${configHash.slice(0, 10)}`;
+    try {
+      logs.push(`[INFO] Using data dir: ${dataPath}`);
+      const testCasesJson = await import_node_fs3.promises.readFile(
+        import_node_path3.default.join(dataPath, testDataFile),
+        "utf-8"
+      );
+      const possibleAnswersJson = await import_node_fs3.promises.readFile(
+        import_node_path3.default.join(dataPath, answerDataFile),
+        "utf-8"
+      );
+      testCases = testCasesJson.split(LINE_SPLIT_REGEX2).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+      const possibleAnswers = possibleAnswersJson.split(LINE_SPLIT_REGEX2).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+      const possibleAnswersMap = new Map(
+        possibleAnswers.map((ans) => [ans.id, ans])
+      );
+      const limitEnv = process.env.BFCL_LIMIT;
+      const limit = limitEnv ? Number(limitEnv) : void 0;
+      if (limit && Number.isFinite(limit) && limit > 0) {
+        testCases = testCases.slice(0, limit);
+        logs.push(`[INFO] Limiting test cases to ${limit} due to BFCL_LIMIT.`);
+      }
+      const concurrencyEnv = process.env.BFCL_CONCURRENCY;
+      const concurrency = concurrencyEnv && Number.isFinite(Number(concurrencyEnv)) ? Math.max(1, Number(concurrencyEnv)) : 4;
+      logs.push(
+        `[INFO] Running ${testCases.length} test cases with concurrency=${concurrency}`
+      );
+      const temp = config == null ? void 0 : config.temperature;
+      const temperature = typeof temp === "number" ? temp : void 0;
+      const maxTok = config == null ? void 0 : config.maxTokens;
+      const maxTokens = typeof maxTok === "number" ? maxTok : void 0;
+      const debugMode = process.env.BFCL_DEBUG === "true";
+      const executeModelGeneration = async (options) => {
+        var _a, _b, _c;
+        const { messages, toolsMap } = options;
+        const providerOptions = {
+          toolCallMiddleware: {
+            debugSummary: {}
+          }
+        };
+        const { toolCalls, text, finishReason } = await withRetry(
+          () => (0, import_ai2.generateText)({
+            model,
+            system: MULTI_TURN_SYSTEM_PROMPT,
+            messages,
+            tools: toolsMap,
+            toolChoice: "auto",
+            providerOptions,
+            ...temperature !== void 0 ? { temperature } : {},
+            ...maxTokens !== void 0 ? { maxOutputTokens: maxTokens } : {}
+          }),
+          { debug: debugMode }
+        );
+        if (debugMode) {
+          console.log("[DEBUG] generateText response:");
+          console.log("  finishReason:", finishReason);
+          console.log("  text:", (_b = (_a = text == null ? void 0 : text.slice) == null ? void 0 : _a.call(text, 0, 200)) != null ? _b : text);
+          console.log(
+            "  toolCalls:",
+            (_c = JSON.stringify(toolCalls, null, 2)) == null ? void 0 : _c.slice(0, 500)
+          );
+        }
+        return { toolCalls, text, finishReason };
+      };
+      const buildWithholdUntil = (missedFunctionMap) => {
+        const withholdUntil = /* @__PURE__ */ new Map();
+        for (const [turnStr, funcs] of Object.entries(missedFunctionMap)) {
+          const turnIndex = Number(turnStr);
+          if (!Number.isFinite(turnIndex)) {
+            continue;
+          }
+          for (const fn of funcs) {
+            withholdUntil.set(fn, turnIndex);
+          }
+        }
+        return withholdUntil;
+      };
+      const getTurnMessages = (turns, turnIndex, missedFunctionMap) => {
+        var _a, _b;
+        const turnMessages = (_a = turns[turnIndex]) != null ? _a : [];
+        const missedFunctionsForTurn = (_b = missedFunctionMap[String(turnIndex)]) != null ? _b : [];
+        if (turnMessages.length === 0 && missedFunctionsForTurn.length > 0) {
+          return [
+            {
+              role: "user",
+              content: DEFAULT_USER_PROMPT_FOR_ADDITIONAL_FUNCTION_FC
+            }
+          ];
+        }
+        return turnMessages;
+      };
+      const getAvailableTools = (tools, excludedFunctions, withholdUntil, turnIndex) => tools.filter((toolSpec) => {
+        var _a;
+        const methodName = getMethodName(toolSpec.name);
+        if (excludedFunctions.has(methodName) || excludedFunctions.has(toolSpec.name)) {
+          return false;
+        }
+        const availableFrom = (_a = withholdUntil.get(methodName)) != null ? _a : withholdUntil.get(toolSpec.name);
+        if (availableFrom !== void 0 && turnIndex < availableFrom) {
+          return false;
+        }
+        return true;
+      });
+      const runToolStep = async (options) => {
+        const {
+          history,
+          toolsMap,
+          transformedTools,
+          nameMap,
+          turnIndex,
+          stepCount,
+          initialConfig,
+          involvedClasses,
+          isLongContext,
+          testCaseId
+        } = options;
+        const { toolCalls, text, finishReason } = await executeModelGeneration({
+          messages: history,
+          toolsMap
+        });
+        const toolCallsArray = Array.isArray(toolCalls) ? toolCalls : [];
+        console.log(`[DEBUG] TestCase ${testCaseId} Step ${stepCount}:`);
+        console.log(`  History length: ${history.length}`);
+        console.log("  Last message:", history.at(-1));
+        console.log(`  Finish reason: ${finishReason}`);
+        console.log(`  Text response: "${text}"`);
+        console.log(`  Tool calls count: ${toolCallsArray.length}`);
+        if (toolCallsArray.length > 0) {
+          console.log(
+            "  Tool calls:",
+            toolCallsArray.map((tc) => ({
+              name: tc.toolName,
+              args: tc.args
+            }))
+          );
+        }
+        if (toolCallsArray.length === 0) {
+          const textContent = typeof text === "string" ? text : "";
+          const updatedHistory = textContent ? [
+            ...history,
+            {
+              role: "assistant",
+              content: [{ type: "text", text: textContent }]
+            }
+          ] : history;
+          return { done: true, history: updatedHistory, toolCalls: [] };
+        }
+        const isLastStep = finishReason === "stop" || finishReason === "end_turn" || finishReason === "length";
+        const restoredCalls = restoreToolCalls(
+          toolCallsArray,
+          nameMap,
+          transformedTools
+        );
+        const toolCallParts = toolCallsArray.map((call, idx) => {
+          var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+          const record = call;
+          const toolCallId = typeof record.toolCallId === "string" ? record.toolCallId : `toolcall-${turnIndex}-${stepCount}-${idx}`;
+          const rawName = (_a = record.toolName) != null ? _a : record.name;
+          const toolName = typeof rawName === "string" ? rawName : (_c = (_b = transformedTools[idx]) == null ? void 0 : _b.name) != null ? _c : "tool";
+          const extractedArgs = (_g = (_f = (_e = (_d = record.args) != null ? _d : record.arguments) != null ? _e : record.input) != null ? _f : record.params) != null ? _g : record.parameters;
+          const parsedInput = (_h = parseToolArgs(extractedArgs)) != null ? _h : {};
+          if (debugMode) {
+            console.log(`[DEBUG] Tool call ${idx} args processing:`);
+            console.log(`  record.args type: ${typeof record.args}`);
+            console.log(`  record.arguments type: ${typeof record.arguments}`);
+            console.log(
+              `  extractedArgs type: ${typeof extractedArgs}, value: ${(_i = JSON.stringify(extractedArgs)) == null ? void 0 : _i.slice(0, 200)}`
+            );
+            console.log(
+              `  parsedInput type: ${typeof parsedInput}, value: ${(_j = JSON.stringify(parsedInput)) == null ? void 0 : _j.slice(0, 200)}`
+            );
+          }
+          return {
+            type: "tool-call",
+            toolCallId,
+            toolName,
+            input: parsedInput
+          };
+        });
+        const historyWithToolCalls = [
+          ...history,
+          {
+            role: "assistant",
+            content: toolCallParts
+          }
+        ];
+        const toolCallsForExecution = restoredCalls.map((call) => {
+          var _a;
+          return {
+            toolName: call.toolName,
+            args: (_a = call.args) != null ? _a : {}
+          };
+        });
+        const executionResult = await executeMultiTurnFuncCall(
+          toolCallsForExecution,
+          initialConfig,
+          involvedClasses,
+          runId,
+          testCaseId,
+          isLongContext,
+          false
+        );
+        const executionResults = executionResult.executionResults;
+        console.log("[DEBUG] Tool call execution results:", executionResults);
+        console.log("[DEBUG] Tool calls:", toolCallsForExecution);
+        const toolResultParts = executionResults.map((result, idx) => {
+          const toolCallPart = toolCallParts[idx];
+          return {
+            type: "tool-result",
+            toolCallId: toolCallPart.toolCallId,
+            toolName: toolCallPart.toolName,
+            output: {
+              type: "text",
+              value: result
+            }
+          };
+        });
+        const historyWithToolResults = [
+          ...historyWithToolCalls,
+          {
+            role: "tool",
+            content: toolResultParts
+          }
+        ];
+        return {
+          done: isLastStep,
+          history: historyWithToolResults,
+          toolCalls: toolCallsForExecution
+        };
+      };
+      const runTurn = async (options) => {
+        const {
+          testCase,
+          turnIndex,
+          history,
+          tools,
+          excludedFunctions,
+          withholdUntil,
+          initialConfig,
+          involvedClasses,
+          isLongContext
+        } = options;
+        const availableTools = getAvailableTools(
+          tools,
+          excludedFunctions,
+          withholdUntil,
+          turnIndex
+        );
+        const { transformedTools, nameMap } = buildTransformedTools(availableTools);
+        const toolsMap = buildToolsMap(transformedTools);
+        const turnResults = [];
+        let stepCount = 0;
+        let updatedHistory = history;
+        while (stepCount <= MAXIMUM_STEP_LIMIT) {
+          const stepResult = await runToolStep({
+            history: updatedHistory,
+            toolsMap,
+            transformedTools,
+            nameMap,
+            turnIndex,
+            stepCount,
+            initialConfig,
+            involvedClasses,
+            isLongContext,
+            testCaseId: testCase.id
+          });
+          if (stepResult.done) {
+            return {
+              history: stepResult.history,
+              turnResults,
+              forceQuit: false
+            };
+          }
+          turnResults.push(stepResult.toolCalls);
+          updatedHistory = stepResult.history;
+          stepCount += 1;
+        }
+        return { history: updatedHistory, turnResults, forceQuit: true };
+      };
+      const buildCaseContext = async (testCase, possibleAnswer) => {
+        var _a, _b, _c, _d, _e;
+        const turns = normalizeTurns((_a = testCase.question) != null ? _a : []);
+        const expectedGroundTruth = possibleAnswer.ground_truth;
+        const involvedClasses = (_b = testCase.involved_classes) != null ? _b : [];
+        const initialConfig = (_c = testCase.initial_config) != null ? _c : {};
+        const excludedFunctions = new Set((_d = testCase.excluded_function) != null ? _d : []);
+        const missedFunctionMap = (_e = testCase.missed_function) != null ? _e : {};
+        const tools = await loadToolsForClasses(involvedClasses, dataPath);
+        const withholdUntil = buildWithholdUntil(missedFunctionMap);
+        const isLongContext = testCase.id.includes("long_context") || testCase.id.includes("composite");
+        return {
+          turns,
+          expectedGroundTruth,
+          involvedClasses,
+          initialConfig,
+          excludedFunctions,
+          missedFunctionMap,
+          tools,
+          withholdUntil,
+          isLongContext
+        };
+      };
+      const runConversation = async (context) => {
+        const {
+          turns,
+          testCase,
+          tools,
+          excludedFunctions,
+          withholdUntil,
+          initialConfig,
+          involvedClasses,
+          missedFunctionMap,
+          isLongContext
+        } = context;
+        let history = [];
+        const modelResultsByTurn = [];
+        for (let turnIndex = 0; turnIndex < turns.length; turnIndex += 1) {
+          const turnMessages = getTurnMessages(
+            turns,
+            turnIndex,
+            missedFunctionMap
+          );
+          if (turnMessages.length > 0) {
+            history = [
+              ...history,
+              ...turnMessages
+            ];
+          }
+          const turnOutcome = await runTurn({
+            testCase,
+            turnIndex,
+            history,
+            tools,
+            excludedFunctions,
+            withholdUntil,
+            initialConfig,
+            involvedClasses,
+            isLongContext
+          });
+          history = turnOutcome.history;
+          modelResultsByTurn.push(turnOutcome.turnResults);
+          if (turnOutcome.forceQuit) {
+            return { modelResultsByTurn, forceQuit: true };
+          }
+        }
+        return { modelResultsByTurn, forceQuit: false };
+      };
+      const checkCase = async (testCase, modelResultsByTurn, expectedGroundTruth) => {
+        const testCategory = testCase.id.split("_").slice(0, -1).join("_");
+        const checkResult = await multiTurnChecker(
+          modelResultsByTurn,
+          expectedGroundTruth,
+          testCase,
+          testCategory,
+          runId
+        );
+        const irrelevanceResult = multiTurnIrrelevanceChecker(
+          modelResultsByTurn,
+          expectedGroundTruth
+        );
+        return {
+          valid: checkResult.valid && irrelevanceResult.valid,
+          error_type: checkResult.error_type || irrelevanceResult.error_type,
+          details: checkResult.details || irrelevanceResult.details
+        };
+      };
+      const runSingleCase2 = async (testCase) => {
+        var _a;
+        try {
+          const caseLogs = [];
+          const possibleAnswer = possibleAnswersMap.get(testCase.id);
+          if (!possibleAnswer) {
+            caseLogs.push(`[FAIL] ${testCase.id}: missing possible answer`);
+            return { valid: false, logs: caseLogs };
+          }
+          const context = await buildCaseContext(testCase, possibleAnswer);
+          const conversationResult = await runConversation({
+            ...context,
+            testCase
+          });
+          if (conversationResult.forceQuit) {
+            caseLogs.push(
+              `[FAIL] ${testCase.id}: force-terminated after ${MAXIMUM_STEP_LIMIT} steps`
+            );
+            return { valid: false, logs: caseLogs };
+          }
+          const checkerResult = await checkCase(
+            testCase,
+            conversationResult.modelResultsByTurn,
+            context.expectedGroundTruth
+          );
+          console.log(`[DEBUG] Test case: ${testCase.id}`);
+          console.log(
+            `[DEBUG] Model results (${conversationResult.modelResultsByTurn.length} turns):`,
+            conversationResult.modelResultsByTurn
+          );
+          console.log(
+            `[DEBUG] Ground truth (${context.expectedGroundTruth.length} turns):`,
+            context.expectedGroundTruth
+          );
+          for (let turn = 0; turn < Math.max(
+            conversationResult.modelResultsByTurn.length,
+            context.expectedGroundTruth.length
+          ); turn++) {
+            const modelTurn = conversationResult.modelResultsByTurn[turn] || [];
+            const gtTurn = context.expectedGroundTruth[turn] || [];
+            console.log(`[DEBUG] Turn ${turn}:`);
+            console.log(`  Model: ${JSON.stringify(modelTurn)}`);
+            console.log(`  Ground Truth: ${JSON.stringify(gtTurn)}`);
+            console.log(
+              `  Match: ${JSON.stringify(modelTurn) === JSON.stringify(gtTurn)}`
+            );
+          }
+          console.log("[DEBUG] Checker result:", checkerResult);
+          console.log(
+            `[DEBUG] Ground truth (${context.expectedGroundTruth.length} turns):`,
+            context.expectedGroundTruth
+          );
+          console.log("[DEBUG] Checker result:", checkerResult);
+          if (checkerResult.valid === true) {
+            caseLogs.push(`[PASS] ${testCase.id}`);
+            return { valid: true, logs: caseLogs };
+          }
+          caseLogs.push(
+            `[FAIL] ${testCase.id}: ${(_a = checkerResult.error_type) != null ? _a : "unknown error"}`
+          );
+          return { valid: false, logs: caseLogs };
+        } catch (e) {
+          const errorMsg = e instanceof Error ? e.message : "unknown error in runSingleCase";
+          return {
+            valid: false,
+            logs: [`[FAIL] ${testCase.id}: ${errorMsg}`]
+          };
+        }
+      };
+      const runSingleCaseSafe = async (testCase) => {
+        try {
+          return await runSingleCase2(testCase);
+        } catch (e) {
+          const errorMsg = e instanceof Error ? e.message : "unknown error occurred";
+          if (debugMode) {
+            console.error(`[DEBUG] Error in test case ${testCase.id}:`, e);
+          }
+          return {
+            valid: false,
+            logs: [`[FAIL] ${testCase.id}: ${errorMsg}`]
+          };
+        }
+      };
+      const mapWithConcurrency2 = async (items, concurrencyLimit, mapper) => {
+        const results = new Array(items.length);
+        let idx = 0;
+        const workers = new Array(Math.min(concurrencyLimit, items.length)).fill(0).map(async () => {
+          while (true) {
+            const current = idx;
+            idx += 1;
+            if (current >= items.length) {
+              break;
+            }
+            results[current] = await mapper(items[current], current);
+          }
+        });
+        await Promise.all(workers);
+        return results;
+      };
+      const resultsPerCase = await mapWithConcurrency2(
+        testCases,
+        concurrency,
+        async (tc) => runSingleCaseSafe(tc)
+      );
+      correctCount = resultsPerCase.reduce(
+        (acc, r) => acc + (r.valid ? 1 : 0),
+        0
+      );
+      for (const r of resultsPerCase) {
+        logs.push(...r.logs);
+      }
+      if (testCases.length === 0) {
+        return {
+          score: 0,
+          success: false,
+          metrics: {},
+          logs: ["No test cases found."]
+        };
+      }
+      const score = correctCount / testCases.length;
+      const caseResults = resultsPerCase.map((r, i) => ({
+        id: testCases[i].id,
+        valid: r.valid
+      }));
+      return {
+        score,
+        success: score > 0.95,
+        metrics: {
+          correct_count: correctCount,
+          total_cases: testCases.length,
+          accuracy: score,
+          case_results: JSON.stringify(caseResults)
+        },
+        logs
+      };
+    } catch (e) {
+      return {
+        score: 0,
+        success: false,
+        metrics: {},
+        error: e,
+        logs: [
+          `[ERROR] Failed to run BFCL multi-turn benchmark: ${e.message}`
+        ]
+      };
+    } finally {
+      resetTestInstances("", runId);
+    }
+  }
+});
+var bfclMultiTurnBaseBenchmark = createBfclMultiTurnBenchmark(
+  MULTI_TURN_DATASETS[0].name,
+  MULTI_TURN_DATASETS[0].description,
+  MULTI_TURN_DATASETS[0].testFile,
+  MULTI_TURN_DATASETS[0].answerFile
+);
+var bfclMultiTurnLongContextBenchmark = createBfclMultiTurnBenchmark(
+  MULTI_TURN_DATASETS[1].name,
+  MULTI_TURN_DATASETS[1].description,
+  MULTI_TURN_DATASETS[1].testFile,
+  MULTI_TURN_DATASETS[1].answerFile
+);
+var bfclMultiTurnMissFuncBenchmark = createBfclMultiTurnBenchmark(
+  MULTI_TURN_DATASETS[2].name,
+  MULTI_TURN_DATASETS[2].description,
+  MULTI_TURN_DATASETS[2].testFile,
+  MULTI_TURN_DATASETS[2].answerFile
+);
+var bfclMultiTurnMissParamBenchmark = createBfclMultiTurnBenchmark(
+  MULTI_TURN_DATASETS[3].name,
+  MULTI_TURN_DATASETS[3].description,
+  MULTI_TURN_DATASETS[3].testFile,
+  MULTI_TURN_DATASETS[3].answerFile
+);
+
 // src/benchmarks/complex-func-bench.ts
-var import_node_fs3 = require("fs");
-var import_node_path3 = __toESM(require("path"), 1);
-var import_ai2 = require("ai");
-var LINE_SPLIT_REGEX2 = /\r?\n/;
+var import_node_fs4 = require("fs");
+var import_node_path4 = __toESM(require("path"), 1);
+var import_ai3 = require("ai");
+var LINE_SPLIT_REGEX3 = /\r?\n/;
 function standardizeString2(input) {
   if (typeof input !== "string") {
     return input;
@@ -1460,22 +5870,22 @@ var fixSchemaType = (copy) => {
     copy.type = "number";
   }
 };
-var fixSchema = (schema) => {
+var fixSchema2 = (schema) => {
   if (!schema || typeof schema !== "object") {
     return { type: "object", properties: {} };
   }
-  const copy = Array.isArray(schema) ? schema.map((v) => fixSchema(v)) : { ...schema };
+  const copy = Array.isArray(schema) ? schema.map((v) => fixSchema2(v)) : { ...schema };
   if (!Array.isArray(copy)) {
     fixSchemaType(copy);
     if (copy.properties && typeof copy.properties === "object") {
       for (const k of Object.keys(copy.properties)) {
-        copy.properties[k] = fixSchema(
+        copy.properties[k] = fixSchema2(
           copy.properties[k]
         );
       }
     }
     if (copy.items) {
-      copy.items = fixSchema(copy.items);
+      copy.items = fixSchema2(copy.items);
     }
   }
   return copy;
@@ -1483,7 +5893,7 @@ var fixSchema = (schema) => {
 function buildTools(tools) {
   const nameMap = /* @__PURE__ */ new Map();
   const transformedTools = tools.map((t) => {
-    const fixed = fixSchema(t.parameters);
+    const fixed = fixSchema2(t.parameters);
     const inputSchema = fixed && typeof fixed === "object" && fixed.type === "object" ? fixed : { type: "object", properties: {} };
     const sanitized = t.name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64) || "tool";
     nameMap.set(sanitized, t.name);
@@ -1497,9 +5907,9 @@ function buildTools(tools) {
   const toolsMap = Object.fromEntries(
     transformedTools.map((t) => [
       t.name,
-      (0, import_ai2.tool)({
+      (0, import_ai3.tool)({
         description: typeof t.description === "string" ? t.description : void 0,
-        inputSchema: (0, import_ai2.jsonSchema)(t.inputSchema)
+        inputSchema: (0, import_ai3.jsonSchema)(t.inputSchema)
       })
     ])
   );
@@ -1530,7 +5940,7 @@ async function runSingleCase(testCase, model, possibleAnswersMap, temperature, m
     const providerOptions = {
       toolCallMiddleware: { debugSummary: debugSummaryRef }
     };
-    const { toolCalls, finishReason } = await (0, import_ai2.generateText)({
+    const { toolCalls, finishReason } = await (0, import_ai3.generateText)({
       model,
       messages,
       tools: toolsMap,
@@ -1573,18 +5983,18 @@ async function runSingleCase(testCase, model, possibleAnswersMap, temperature, m
   }
 }
 async function loadTestData(dataPath, testDataFile) {
-  const testCasesJson = await import_node_fs3.promises.readFile(
-    import_node_path3.default.join(dataPath, testDataFile),
+  const testCasesJson = await import_node_fs4.promises.readFile(
+    import_node_path4.default.join(dataPath, testDataFile),
     "utf-8"
   );
-  return testCasesJson.split(LINE_SPLIT_REGEX2).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+  return testCasesJson.split(LINE_SPLIT_REGEX3).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
 }
 async function loadAnswerData(dataPath, answerDataFile) {
-  const answersJson = await import_node_fs3.promises.readFile(
-    import_node_path3.default.join(dataPath, answerDataFile),
+  const answersJson = await import_node_fs4.promises.readFile(
+    import_node_path4.default.join(dataPath, answerDataFile),
     "utf-8"
   );
-  const answers = answersJson.split(LINE_SPLIT_REGEX2).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+  const answers = answersJson.split(LINE_SPLIT_REGEX3).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
   return new Map(answers.map((ans) => [ans.id, ans]));
 }
 function getConfigValues(config) {
@@ -1679,14 +6089,14 @@ var complexFuncBenchBenchmark = createComplexFuncBenchBenchmark(
 );
 
 // src/benchmarks/json-generation.ts
-var import_node_fs4 = require("fs");
-var import_node_path4 = __toESM(require("path"), 1);
-var import_ai3 = require("ai");
+var import_node_fs5 = require("fs");
+var import_node_path5 = __toESM(require("path"), 1);
+var import_ai4 = require("ai");
 var import_ajv = __toESM(require("ajv"), 1);
 var JSON_FENCE_REGEX = /```json\s*([\s\S]*?)```/i;
 var CODE_FENCE_REGEX = /```\s*([\s\S]*?)```/i;
 var NEWLINE_REGEX = /\r?\n/;
-var LINE_SPLIT_REGEX3 = /\r?\n/;
+var LINE_SPLIT_REGEX4 = /\r?\n/;
 function tryDirectParse(text) {
   try {
     return JSON.parse(text);
@@ -1775,12 +6185,12 @@ function subsetMatch(expected, actual) {
 async function loadDatasets() {
   try {
     const dataDir = resolveDataDir();
-    const testsJsonl = await import_node_fs4.promises.readFile(
-      import_node_path4.default.join(dataDir, "json_generation_tests.jsonl"),
+    const testsJsonl = await import_node_fs5.promises.readFile(
+      import_node_path5.default.join(dataDir, "json_generation_tests.jsonl"),
       "utf-8"
     );
-    const expectedJsonl = await import_node_fs4.promises.readFile(
-      import_node_path4.default.join(dataDir, "json_generation_expected.jsonl"),
+    const expectedJsonl = await import_node_fs5.promises.readFile(
+      import_node_path5.default.join(dataDir, "json_generation_expected.jsonl"),
       "utf-8"
     );
     const tests = testsJsonl.split(NEWLINE_REGEX).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
@@ -1840,7 +6250,7 @@ async function processTestCase(tc, context) {
   const messages = buildMessages(tc);
   const temp = (_a = context.config) == null ? void 0 : _a.temperature;
   const temperature = typeof temp === "number" ? temp : void 0;
-  const { text } = await (0, import_ai3.generateText)({
+  const { text } = await (0, import_ai4.generateText)({
     model: context.model,
     messages,
     ...temperature !== void 0 ? { temperature } : {}
@@ -1942,11 +6352,11 @@ function buildBenchmarkResult(total, counts, logs) {
 async function loadSchemaOnlyTests() {
   try {
     const dataDir = resolveDataDir();
-    const testsJsonl = await import_node_fs4.promises.readFile(
-      import_node_path4.default.join(dataDir, "json_generation_tests.jsonl"),
+    const testsJsonl = await import_node_fs5.promises.readFile(
+      import_node_path5.default.join(dataDir, "json_generation_tests.jsonl"),
       "utf-8"
     );
-    const tests = testsJsonl.split(LINE_SPLIT_REGEX3).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+    const tests = testsJsonl.split(LINE_SPLIT_REGEX4).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
     return { tests };
   } catch (e) {
     return { tests: [], error: e };
@@ -1957,7 +6367,7 @@ async function processSchemaOnlyTestCase(tc, context) {
   const messages = buildMessages(tc);
   const temp = (_a = context.config) == null ? void 0 : _a.temperature;
   const temperature = typeof temp === "number" ? temp : void 0;
-  const { text } = await (0, import_ai3.generateText)({
+  const { text } = await (0, import_ai4.generateText)({
     model: context.model,
     messages,
     ...temperature !== void 0 ? { temperature } : {}
@@ -2036,7 +6446,7 @@ var jsonGenerationSchemaOnlyBenchmark = {
 
 // src/evaluate.ts
 var import_middleware = require("@ai-sdk-tool/middleware");
-var import_ai4 = require("ai");
+var import_ai5 = require("ai");
 
 // src/reporters/console.ts
 var colors = {
@@ -2051,6 +6461,8 @@ var colors = {
   white: "\x1B[37m"
 };
 var DEBUG_FAIL_REGEX = /^\[DEBUG-FAIL\] /;
+var PASS_REGEX = /^\[PASS\] (.+)$/;
+var FAIL_REGEX = /^\[FAIL\] ([^:]+)(?:: (.+))?$/;
 function formatDiff(diff) {
   if (!diff || diff.length === 0) {
     return "";
@@ -2142,6 +6554,42 @@ function printFailureSummary(failures) {
     );
   }
 }
+function parseTestResults(logs) {
+  const results = [];
+  for (const log of logs) {
+    const passMatch = log.match(PASS_REGEX);
+    if (passMatch) {
+      results.push({ id: passMatch[1], passed: true });
+      continue;
+    }
+    const failMatch = log.match(FAIL_REGEX);
+    if (failMatch) {
+      results.push({
+        id: failMatch[1],
+        passed: false,
+        reason: failMatch[2]
+      });
+    }
+  }
+  return results;
+}
+function printTestResults(testResults) {
+  const passed = testResults.filter((r) => r.passed);
+  const failed = testResults.filter((r) => !r.passed);
+  if (passed.length > 0) {
+    const passedIds = passed.map((r) => r.id).join(", ");
+    console.log(
+      `    ${colors.green}\u2714 Passed (${passed.length}):${colors.reset} ${passedIds}`
+    );
+  }
+  if (failed.length > 0) {
+    console.log(`    ${colors.red}\u2716 Failed (${failed.length}):${colors.reset}`);
+    for (const f of failed) {
+      const reason = f.reason ? `: ${colors.gray}${f.reason}${colors.reset}` : "";
+      console.log(`      ${colors.red}${f.id}${colors.reset}${reason}`);
+    }
+  }
+}
 function printResult(result) {
   const { model, modelKey, benchmark, result: benchmarkResult } = result;
   const passed = benchmarkResult.metrics.correct_count;
@@ -2161,15 +6609,14 @@ function printResult(result) {
       `    ${colors.red}Error: ${benchmarkResult.error.message}${colors.reset}`
     );
   }
-  if (!benchmarkResult.success && benchmarkResult.logs) {
-    const failures = parseFailures(benchmarkResult.logs);
-    if (failures.length > 0) {
-      printFailureSummary(failures);
-    } else if (benchmarkResult.logs.length > 0) {
-      console.log(`    ${colors.gray}Raw Logs (Sample):${colors.reset}`);
-      for (const l of benchmarkResult.logs.slice(0, 5)) {
-        console.log(`      ${l}`);
-      }
+  if (benchmarkResult.logs && benchmarkResult.logs.length > 0) {
+    const structuredFailures = parseFailures(benchmarkResult.logs);
+    const testResults = parseTestResults(benchmarkResult.logs);
+    if (testResults.length > 0) {
+      printTestResults(testResults);
+    }
+    if (structuredFailures.length > 0) {
+      printFailureSummary(structuredFailures);
     }
   }
 }
@@ -2960,7 +7407,7 @@ function buildEffectiveModel(baseModel, userMiddleware, cacheOptions) {
   if (middlewares.length === 0) {
     return baseModel;
   }
-  return (0, import_ai4.wrapLanguageModel)({
+  return (0, import_ai5.wrapLanguageModel)({
     // biome-ignore lint/suspicious/noExplicitAny: AI SDK v5/v6 type mismatch
     model: baseModel,
     middleware: middlewares.length === 1 ? middlewares[0] : middlewares
@@ -2970,11 +7417,19 @@ async function runSingleBenchmark(model, benchmark, modelKey, config) {
   const modelId = typeof model === "object" && model !== null && "modelId" in model && typeof model.modelId === "string" ? model.modelId : "unknown-model";
   const prefix = `[${modelId}]${modelKey ? ` (${modelKey})` : ""} ${benchmark.name}`;
   try {
-    process.stdout.write(`${prefix}: ...`);
+    if (process.stdout.isTTY) {
+      process.stdout.write(`${prefix}: ...`);
+    } else {
+      console.log(`${prefix}: ...`);
+    }
     const result = await benchmark.run(model, config);
     const scoreDisplay = result.score.toFixed(2);
-    process.stdout.write(`\r${prefix}: .... Score: ${scoreDisplay}
+    if (process.stdout.isTTY) {
+      process.stdout.write(`\r${prefix}: .... Score: ${scoreDisplay}
 `);
+    } else {
+      console.log(`${prefix}: .... Score: ${scoreDisplay}`);
+    }
     return {
       model: modelId,
       modelKey,
@@ -2982,8 +7437,12 @@ async function runSingleBenchmark(model, benchmark, modelKey, config) {
       result
     };
   } catch (error) {
-    process.stdout.write(`\r${prefix}: .... Score: ERROR
+    if (process.stdout.isTTY) {
+      process.stdout.write(`\r${prefix}: .... Score: ERROR
 `);
+    } else {
+      console.log(`${prefix}: .... Score: ERROR`);
+    }
     console.error(error);
     return {
       model: modelId,
@@ -3031,12 +7490,17 @@ async function evaluate(options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  bfclMultiTurnBaseBenchmark,
+  bfclMultiTurnLongContextBenchmark,
+  bfclMultiTurnMissFuncBenchmark,
+  bfclMultiTurnMissParamBenchmark,
   bfclMultipleBenchmark,
   bfclParallelBenchmark,
   bfclParallelMultipleBenchmark,
   bfclSimpleBenchmark,
   complexFuncBenchBenchmark,
   evaluate,
+  executeMultiTurnFuncCall,
   jsonGenerationBenchmark,
   jsonGenerationSchemaOnlyBenchmark
 });